解决claudecode使用glm-5模型时上下文超限问题：自动压缩技术实战

1次阅读

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

最近在使用 claudecode 调用 glm- 5 模型时，很多开发者都遇到了一个头疼的问题：模型经常提示上下文超出限制。glm- 5 模型的最大上下文长度通常在 2048 个 token 左右，当输入内容超过这个限制时，模型就会直接报错，而不会自动进行任何压缩处理。这对于处理长文档或多轮对话场景来说，简直是噩梦。

简单截断法
直接截取前 2048 个 token
优点：实现简单
缺点：丢失大量关键信息
摘要提取法
先用摘要模型生成内容摘要
优点：保留核心内容
缺点：摘要质量不可控，处理速度慢
分段处理法
将长文本分成多个段落分别处理
优点：可以处理任意长度文本
缺点：上下文连贯性差

我们的解决方案包含三个核心模块：

语义重要性评估
关键信息保留
动态调整压缩比

from sentence_transformers import SentenceTransformer
import numpy as np

# 初始化模型
model = SentenceTransformer('paraphrase-MiniLM-L6-v2')

def calculate_sentence_scores(text):
    sentences = text.split('.')
    embeddings = model.encode(sentences)

    # 计算每个句子的重要性分数
    doc_embedding = np.mean(embeddings, axis=0)
    scores = []
    for emb in embeddings:
        score = np.dot(emb, doc_embedding)
        scores.append(score)

    return sentences, scores

def compress_text(text, target_length=2000):
    sentences, scores = calculate_sentence_scores(text)

    # 按分数排序
    sorted_sentences = [sent for _, sent in sorted(zip(scores, sentences), reverse=True)]

    compressed_text = ''
    current_length = 0

    for sent in sorted_sentences:
        sent_length = len(sent.split())
        if current_length + sent_length <= target_length:
            compressed_text += sent + '.'
            current_length += sent_length
        else:
            break

    return compressed_text

def dynamic_compress(text, model_max_length=2048):
    original_length = len(text.split())

    if original_length <= model_max_length:
        return text

    # 初始压缩比
    compression_ratio = model_max_length / original_length

    # 逐步调整压缩比
    for _ in range(3):  # 最多尝试 3 次
        compressed = compress_text(text, int(original_length * compression_ratio))
        if len(compressed.split()) <= model_max_length:
            return compressed
        compression_ratio *= 0.9  # 每次降低 10%

    return compress_text(text, model_max_length)  # 最后强制压缩到最大长度

import re
from typing import List, Tuple

class GLM5ContextCompressor:
    def __init__(self):
        self.sbert_model = SentenceTransformer('paraphrase-MiniLM-L6-v2')

    def preprocess_text(self, text: str) -> str:
        # 处理特殊符号和代码块
        text = re.sub(r'\s+', ' ', text)  # 合并多余空格
        return text

    def split_sentences(self, text: str) -> List[str]:
        # 更健壮的句子分割
        sentences = re.split(r'(?<=[.!?])\s+', text)
        return [s for s in sentences if s.strip()]

    def calculate_importance(self, sentences: List[str]) -> Tuple[List[str], List[float]]:
        if not sentences:
            return [], []

        embeddings = self.sbert_model.encode(sentences)
        doc_embedding = np.mean(embeddings, axis=0)

        scores = []
        for emb in embeddings:
            score = np.dot(emb, doc_embedding) / (np.linalg.norm(emb) * np.linalg.norm(doc_embedding))
            scores.append(score)

        return sentences, scores

    def compress(self, text: str, max_length: int = 2048) -> str:
        text = self.preprocess_text(text)
        sentences, scores = self.calculate_importance(self.split_sentences(text))

        if not sentences:
            return ''

        # 按重要性排序
        sorted_items = sorted(zip(sentences, scores), key=lambda x: x[1], reverse=True)

        result = []
        current_length = 0

        for sent, _ in sorted_items:
            sent_length = len(sent.split())
            if current_length + sent_length <= max_length:
                result.append(sent)
                current_length += sent_length
            else:
                break

        return ' '.join(result)

    def smart_compress(self, text: str, max_length: int = 2048, max_iter: int = 3) -> str:
        original_length = len(text.split())

        if original_length <= max_length:
            return text

        # 尝试动态调整压缩比
        best_result = ''
        best_score = 0

        for ratio in [0.9, 0.8, 0.7]:
            target_length = min(max_length, int(original_length * ratio))
            compressed = self.compress(text, target_length)

            # 评估压缩质量
            compressed_emb = self.sbert_model.encode(compressed)
            original_emb = self.sbert_model.encode(text)
            similarity = np.dot(compressed_emb, original_emb) / (np.linalg.norm(compressed_emb) * np.linalg.norm(original_emb))

            if similarity > best_score:
                best_score = similarity
                best_result = compressed

        return best_result if best_result else self.compress(text, max_length)

我们使用 CNN/Daily Mail 数据集进行了测试，结果如下：