AI技能如何处理超过上下文窗口的任务：分块处理与记忆机制实战指南

1次阅读

没有评论

共计 1838 个字符，预计需要花费 5 分钟才能阅读完成。

大型语言模型（LLM）如 GPT 系列通过固定长度的上下文窗口（context window）处理输入，典型值为 2048 或 4096 个 token。当输入超过这个限制时，模型会丢弃超出部分的信息，导致以下问题：

信息丢失 ：关键上下文被截断
连贯性下降 ：长距离依赖关系断裂
性能波动 ：输出质量随截断位置变化

原理：将长文本分段摘要，再对摘要结果进行二次处理
优点：大幅压缩信息量
缺点：累计误差明显，适合事实性内容

原理：保持固定窗口大小逐步移动处理
优点：保留局部上下文完整性
缺点：高频重复处理边界内容

原理：建立多级表示，顶层保留全局信息
优点：兼顾粗细粒度
缺点：实现复杂度高

flowchart TD
    A[原始文本] --> B{长度检查}
    B -->| 超过 | C[选择处理策略]
    C --> D[递归摘要]
    C --> E[滑动窗口]
    C --> F[分层压缩]
    B -->| 未超过 | G[直接处理]

from typing import List
import re

def semantic_chunking(text: str, max_size: int = 1000) -> List[str]:
    """
    基于语义边界的文本分块
    :param text: 输入文本
    :param max_size: 单块最大字符数
    :return: 分块结果列表
    """
    # 优先按段落分割
    chunks = re.split(r'\n\s*\n', text)

    # 合并过小分块
    merged = []
    buffer = ""
    for chunk in chunks:
        if len(buffer) + len(chunk) <= max_size:
            buffer += "\n\n" + chunk if buffer else chunk
        else:
            if buffer:
                merged.append(buffer)
            buffer = chunk
    if buffer:
        merged.append(buffer)
    return merged

from collections import OrderedDict

class ContextCache:
    """LRU 策略的上下文缓存"""
    def __init__(self, capacity: int = 5):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key: str) -> str:
        if key not in self.cache:
            return ""
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key: str, value: str) -> None:
        self.cache[key] = value
        self.cache.move_to_end(key)
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

def weighted_aggregate(results: List[dict]) -> str:
    """
    带置信度加权的结果聚合
    :param results: 包含 confidence 字段的结果字典列表
    :return: 聚合后的文本
    """sorted_results = sorted(results, key=lambda x: x['confidence'], reverse=True)
    return "".join([res['text'] for res in sorted_results])