Context Compaction：上下文压缩

可视化演示

动态演示Context Compac的核心机制，通过概览/流程/对比/趋势四种模式展示关键概念与交互流程。

压缩基本概念

小美站在行李秤前，看着 20 寸登机箱发愁：七天行程，五套衣服、一双备用鞋、洗漱包、充电器，全挤在一起。箱子就是这么大，航空公司不会为她的纠结多给一寸空间。她第一次意识到：问题不在箱子太小，而在怎么装。当她终于学会把厚衣服抽成真空、把零碎件塞进缝隙，同样的箱子仿佛变大了一倍。

大语言模型的“登机箱”叫上下文窗口（Context Window），它决定模型一次能“看见”多少 token。一次长对话动辄数千 token，一份技术文档更是轻松上万。当内容超出窗口上限，系统必须做决定：截断最早的对话、丢弃次要段落，或者——把已有内容压缩。Context Compaction 就是第三种选择：把零散、冗余的上下文，整理成一份信息密集的浓缩版。

具体来说，Context Compaction 会分析当前上下文，保留对后续任务最重要的内容，把次要内容合并、概括、重写，最终用更少的 token 表达同样的信息。衡量效果的标准是压缩率（compaction ratio）：

$$\displaystyle R_{\mathrm{compact}} = 1 - \frac{T_{\mathrm{compressed}}}{T_{\mathrm{original}}}$$

R 越接近 1，说明省下的 token 越多。例如原始 1000 token 压缩到 200 token，压缩率就是 0.8，窗口立刻腾出八成空间。

1. R_compact（压缩率）：表示压缩前后上下文体量的节省比例，取值越接近 1，说明被省掉的 token 越多。

$$\displaystyle R_{\mathrm{compact}}$$

2. T_compressed（压缩后 token 数）：完成压缩后上下文实际占用的 token 数量，是压缩结果的核心指标。

$$\displaystyle T_{\mathrm{compressed}}$$

3. T_original（原始 token 数）：压缩前上下文的原始 token 数量，代表“没收拾前的行李量”。

$$\displaystyle T_{\mathrm{original}}$$

4. 1 减去剩余占比（补集）：用整体 1 扣除剩余比例，得到被省掉的部分；剩余占比越小，压缩率越高。

$$\displaystyle 1 - \frac{T_{\mathrm{compressed}}}{T_{\mathrm{original}}}$$

小美恍然大悟：压缩的意义从来不是把箱子撑大，而是把花在“纠结带什么”上的心思，换成“如何装得更聪明”。上下文压缩同理，窗口边界是固定的，但工程师的收纳智慧是无限的。

信息密度优化

小美开始翻检行李，发现箱子里塞着三条只在步行街上才会戴的花哨围巾，还有一本三百页的旅行攻略书——实际上她每天只翻两页。它们占据大半空间，却几乎不产生价值。她给这类物品下了定义：低密度行李。于是她果断把围巾留在家，攻略书换成手机里的两页笔记。

上下文里也有大量“低密度区域”：客套寒暄（“你好呀，在吗？”）、重复表述、离题闲聊。它们占用 token，却对当前任务毫无帮助。信息密度优化的目标，就是让上下文里每一个 token 都“物尽其用”。

工程上，信息密度（information density）定义为：

$$\displaystyle \rho = \frac{K}{T}$$

其中 K 是关键信息单元数（用户诉求、实体、指令、决策），T 是本段上下文的总 token 数。优化手段包括：删除重复表述、移除无意义填充词、合并相似句子、把冗长短语换成精确名词。实践中可以先统计高频词与停用词，当“字面冗余率”超过阈值时，优先把该片段送进压缩队列。

1. ρ（信息密度）：衡量每个 token 平均携带多少关键信息的指标，密度越高，上下文越“扎实”。

$$\displaystyle \rho$$

2. K（关键信息单元数）：可以被后续任务直接使用的信息单元数量，例如用户意图、订单号、决策结论等。

$$\displaystyle K$$

3. T（总 token 数）：上下文占用的 token 总量，作为密度的分母。

$$\displaystyle T$$

4. 除法（平均密度）：用关键信息总量除以 token 总量，得到单位 token 的信息贡献。

$$\displaystyle \frac{K}{T}$$

小美把围巾留在家里，攻略书换成两页笔记，箱子立刻空出三成位置。高密度的行李，每一克都有用途；高密度的上下文，每一个 token 都为答案服务。这就是信息密度优化给压缩带来的第一重收益。

摘要式压缩

即便完成了“断舍离”，小美发现厚外套还是太占地方。朋友给她支招：别带衣服，带“穿搭清单”——每天穿什么、搭什么配件、什么场合用哪套，一页纸写清楚。行李瞬间从 15 公斤降到 8 公斤，旅行体验却一点没缩水。

摘要式压缩（Summarization-based Compaction）就是这条“清单思维”在上下文领域的落地：不保留原文，而是调用模型的摘要能力，把一整段对话或文档浓缩成几个要点。原文可能一千 token，摘要只需一百 token，信息被“重写”成高浓度的短语。

当上下文特别长时，单次摘要可能仍超出预算，这时可以采用迭代式压缩：

$$\displaystyle S_t = \mathrm{Summarize}(S_{t-1}), \quad |S_t| < |S_{t-1}|$$

每一轮把上一轮的摘要继续压缩，直到满足长度要求。需要警惕的是，每压缩一轮都会损失部分细节，因此要在摘要长度与信息保全之间取平衡；实践上通常限制迭代轮数，并对关键事实做一致性抽查（例如用户的订单号是否还在摘要里）。

1. S_t（本轮摘要）：第 t 轮压缩后生成的摘要文本，是“清单”的当前版本。

$$\displaystyle S_t$$

2. Summarize（摘要函数）：把一段较长内容浓缩为要点列表的映射操作，通常由大模型完成。

$$\displaystyle \mathrm{Summarize}$$

3. S_{t-1}（上一轮摘要）：作为输入的上一轮摘要，构成“摘要的摘要”。

$$\displaystyle S_{t-1}$$

4. 长度递减条件 |S_t| < |S_{t-1}|（每轮变短）：每一轮产物都必须比输入更短，否则压缩就失去了意义。

$$\displaystyle |S_t| < |S_{t-1}|$$

小美把穿搭清单贴在行李箱盖内侧，旅途中每次需要都知道去哪查。摘要式压缩也一样：用一个精心维护的“上下文清单”替代原始对话，模型随时能找到它需要的那一行。

关键信息保留

清单写好了，但小美在行李里反复确认三样东西：护照、常用药、行程单。“别的都可以省，这三样丢了，旅行直接报废。”她给所有物品画了一张优先级表：红区必带、黄区视情况、绿区可舍弃。每次打包前，她先照表把红区物品清点完毕，才敢碰其他东西。

上下文压缩最危险的行为，就是把“护照级信息”顺手丢掉——用户的明确指令、财务数字、权限约束、否定措辞。关键信息保留策略（Key Information Retention）专门解决这个问题：压缩前先识别出必保留项，确保它们在压缩后依然存在。

常用做法分三层。第一层，信息优先级排序：按任务相关度和时间近因给信息打标签。第二层，语义重要性判断：用向量相似度或规则识别“实体、数字、否定词”等高价值片段。第三层，记忆锚点设计：把关键实体与结论固定在摘要的固定位置（如开头），形成稳定的记忆锚。评估保留效果使用覆盖率：

$$\displaystyle \mathrm{Coverage} = \frac{|P_{\mathrm{kept}} \cap P_{\mathrm{key}}|}{|P_{\mathrm{key}}|}$$

1. P_key（关键信息集合）：压缩前标记出的必须保留项，例如订单号、退款原因、截止日期。

$$\displaystyle P_{\mathrm{key}}$$

2. P_kept（保留信息集合）：压缩后仍然出现在上下文中的信息项，是“压缩后清单”的实际内容。

$$\displaystyle P_{\mathrm{kept}}$$

3. 交集（保住的重叠部分）：同时属于“关键”与“已保留”的信息，即被幸运保住的护照级内容。

$$\displaystyle P_{\mathrm{kept}} \cap P_{\mathrm{key}}$$

4. 基数与除法（覆盖率）：用保住的关键项数量除以全部关键项数量，得到 0 到 1 之间的覆盖率；1 表示一个关键信息都没丢。

$$\displaystyle \frac{|P_{\mathrm{kept}} \cap P_{\mathrm{key}}|}{|P_{\mathrm{key}}|}$$

小美把优先级表贴进手机壳，每次打包都照表核对一遍。覆盖率就是压缩流程里的“手机壳清单”——它不能保证旅行完美，但能保证最珍贵的物品永远在场。

长上下文模型对比

朋友劝小美：“别这么费劲，换个 32 寸的大箱子托运不就行了？”小美算了笔账：大箱子贵两百元托运费，值机排队三十分钟，落地等行李二十分钟，还随时可能被塞进“超规行李”通道。省下的收纳功夫，全在别处还回去了。

大模型界的“32 寸箱子”就是长上下文模型（Long-context Model），把窗口从几千 token 扩到几十万甚至百万。看起来一劳永逸，但代价藏在三个地方：成本、延迟、注意力质量。

Transformer 的自注意力机制中，每个 token 都要与其余所有 token 计算相关性，计算成本随序列长度 N 呈平方增长：

$$\displaystyle C = O(N^{2}) \quad \text{vs} \quad C' = O(N \cdot k)$$

窗口翻倍，计算量翻四倍；而 Context Compaction 先把长序列压成摘要（长度 k，且 k 远小于 N），后续注意力只与摘要交互，成本近似线性。此外，研究还发现长上下文存在“迷失在中间”效应：模型对窗口中部信息的回忆能力明显弱于两端。盲目堆窗口，未必堆得出好效果。

1. N（序列长度）：上下文总 token 数，是注意力计算的规模基准。

$$\displaystyle N$$

2. C = O(N²)（平方复杂度）：全量注意力需要计算 N × N 对关系，N 增长时开销急剧膨胀。

$$\displaystyle O(N^{2})$$

3. k（压缩后长度）：Context Compaction 把长上下文压成的摘要长度，远小于 N。

$$\displaystyle k$$

4. C' = O(N·k)（准线性开销）：压缩后模型主要与摘要交互，成本从平方级降到准线性级。

$$\displaystyle O(N \cdot k)$$

小美最终没有换箱子。她算清楚一个道理：大箱子解决的是“装得下”，压缩解决的是“装得好”。真正的旅行高手，既不背奢侈品托运，也不裸装出门，而是用登机箱装出全世界的从容。

工程实践指南

经过几次旅行，小美把自己的收纳经验提炼成一套“三步法”：出发前分类、打包时压缩、过检前核对。方法写下来，朋友照着做，人人行李箱都轻了三公斤——经验变成了流程。她也因此明白，光靠“这次多塞几件”的灵光一现，永远无法应对下一次满仓。

工程上，Context Compaction 同样需要流程化，否则“偶尔压缩一下”很容易变成“出 bug 靠玄学”。一套成熟的压缩流水线包括三个环节：何时触发、如何压缩、如何验证。

触发时机常看三个信号：token 使用率超过阈值（如 80%）、检测到上下文冗余率上升、任务发生切换（新问题的答案不再依赖旧对话的全部细节）。触发时，用打分函数做最终决策：

$$\displaystyle \mathrm{Score}(x) = \alpha \cdot U(x) - \beta \cdot L(x)$$

压缩执行时，按“评估 → 摘要/抽取 → 校验 → 替换”四步走。质量监控也不能少：定期回测关键信息覆盖率、对比压缩前后下游任务准确率、人工抽样给摘要质量打分。覆盖率和任务指标双下滑时，回滚到压缩前版本并放宽触发阈值。

1. Score(x)（触发分数）：用于判断“当前上下文该不该压缩”的综合评分，分数超阈值才执行。

$$\displaystyle \mathrm{Score}(x)$$

2. U(x)（信息效用）：当前内容对后续任务的价值，效用越高越倾向于保留原样。

$$\displaystyle U(x)$$

3. L(x)（丢失风险）：压缩可能造成的损失度量，风险越高越要谨慎。

$$\displaystyle L(x)$$

4. α 与 β（权衡权重）：两个系数控制“追求价值”与“规避损失”的相对权重，β 调大则策略变保守。

$$\displaystyle \alpha \cdot U(x) - \beta \cdot L(x)$$

小美的三步法后来被写进公司的旅行手册，她自己也从“会收纳的人”变成了“有制度的人”。Context Compaction 也一样：从灵光一现到稳定流水线，靠的不是更聪明的模型，而是更可靠的工程纪律。

AI 应用场景

Python 演示

import refrom collections import Counter  class ContextCompactor:    """提取式上下文压缩器: 模拟 Context Compaction 的最小实现"""     def __init__(self, keep_ratio=0.3):        self.keep_ratio = keep_ratio          # 保留句子的比例        self.compacted_text = ""              # 压缩后的文本        self.tokens_before = 0                # 压缩前的 token 数        self.tokens_after = 0                 # 压缩后的 token 数     def _tokenize(self, text):        # 简单中英文分词: 提取英文数字词与汉字串        return re.findall(r"[a-zA-Z0-9]+|[\u4e00-\u9fff]+", text)     def _sentence_score(self, sentence, freq, pos_ratio):        words = self._tokenize(sentence)        if not words:            return 0.0        # 词频分: 关键词越多的句子越重要        freq_score = sum(freq.get(w, 1) for w in words) / len(words)        # 位置分: 靠前的句子通常包含更多核心信息        return freq_score * 1.5 + (1.0 - pos_ratio) * 10.0     def compact(self, text):        sentences = [s.strip() for s in re.split(r"[。！？!?；;]", text) if s.strip()]        if not sentences:            return ""        freq = Counter(self._tokenize(text))        scored = [            (self._sentence_score(s, freq, i / len(sentences)), s)            for i, s in enumerate(sentences)        ]        keep_n = max(1, int(len(scored) * self.keep_ratio))        top = sorted(scored, key=lambda x: x[0], reverse=True)[:keep_n]        self.compacted_text = "。".join(s for _, s in top)        self.tokens_before = len(self._tokenize(text))        self.tokens_after = len(self._tokenize(self.compacted_text))        return self.compacted_text     def compression_ratio(self):        if self.tokens_before <= 0:            return 0.0        return 1.0 - self.tokens_after / self.tokens_before  if __name__ == "__main__":    doc = (        "小美要为演讲准备素材, 原始资料有三千字。"        "她先通读全文, 圈出三个核心观点。"        "她删掉重复案例, 只保留最有说服力的一组。"        "她把每段结论提炼成一句话, 写进提词卡。"        "演讲当天, 她靠提词卡完成三十分钟分享。"        "听众反馈重点清晰, 几乎没有冗余信息。"    )    cc = ContextCompactor(keep_ratio=0.4)    result = cc.compact(doc)    print("压缩后文本:", result)    print("token 数:", cc.tokens_before, "->", cc.tokens_after)    print("压缩率:", round(cc.compression_ratio(), 3))

1. class ContextCompactor:定义压缩器类，内部封装分词、打分、压缩与统计逻辑。
2. self.keep_ratio = keep_ratio控制保留句子的比例，对应摘要式压缩的“长度取舍”。
3. return re.findall(r"[a-zA-Z0-9]+|[\u4e00-\u9fff]+", text)把中英文切成词元，粗略模拟 tokenizer。
4. freq_score = sum(freq.get(w, 1) for w in words) / len(words)平均词频越高，句子越重要。
5. return freq_score * 1.5 + (1.0 - pos_ratio) * 10.0位置靠前加分，体现“开头更关键”的直觉。
6. top = sorted(scored, key=lambda x: x[0], reverse=True)[:keep_n]按分数取前 N 句，类似压缩时优先保留高价值内容。
7. self.tokens_before = len(self._tokenize(text))记录压缩前 token 数，用于计算压缩率。
8. return 1.0 - self.tokens_after / self.tokens_before压缩率公式实现：R = 1 − 压缩后 / 原始。
9. print("压缩率:", round(cc.compression_ratio(), 3))输出结果，直观看到上下文瘦身了多少。

常见误区

面试题