手写 AI 上下文压缩系统：从零实现 Prompt 压缩与选择性上下文管理

I(x) = -log P(x)

import math
import re
from typing import List, Tuple, Optional
from dataclasses import dataclass, field

@dataclass
class TokenInfo:
    """Token 信息"""
    token_id: int
    text: str
    log_prob: float
    self_information: float

@dataclass
class CompressionResult:
    """压缩结果"""
    original_tokens: List[TokenInfo]
    compressed_text: str
    compression_ratio: float
    kept_tokens: List[TokenInfo]
    removed_tokens: List[TokenInfo]
    token_mask: List[bool]  # True=保留, False=丢弃

from transformers import AutoModelForMaskedLM, AutoTokenizer
import torch

class BertProbabilityEstimator:
    """基于 BERT 的 Token 概率估计器"""

    def __init__(self, model_name: str = "bert-base-uncased"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForMaskedLM.from_pretrained(model_name)
        self.model.eval()

    def estimate_token_probabilities(self, text: str) -> List[Tuple[str, float]]:
        """
        估计文本中每个 Token 的出现概率
        返回: [(token_text, probability), ...]
        """
        # 对文本进行编码
        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
        input_ids = inputs["input_ids"]

        with torch.no_grad():
            outputs = self.model(**inputs)
            logits = outputs.logits[0]  # [seq_len, vocab_size]

        # 使用 softmax 将 logits 转为概率
        probs = torch.softmax(logits, dim=-1)

        # 获取每个位置上实际 Token 的概率
        token_probs = []
        for i, token_id in enumerate(input_ids[0]):
            prob = probs[i, token_id].item()
            token_text = self.tokenizer.decode([token_id])
            token_probs.append((token_text, prob))

        return token_probs

class TokenLevelCompressor:
    """Token 级上下文压缩器"""

    def __init__(self, estimator: BertProbabilityEstimator):
        self.estimator = estimator

    def compute_self_information(self, prob: float) -> float:
        """计算自信息: I(x) = -log P(x)"""
        if prob <= 0:
            return float('inf')
        return -math.log2(prob)

    def compress(
        self,
        text: str,
        compression_ratio: float = 0.5,  # 压缩到原长度的比例
        min_token_length: int = 2,       # 最少保留的 Token 长度
        preserve_special: bool = True,   # 是否保留特殊标记
        window_size: int = 3             # 滑动窗口平滑大小
    ) -> CompressionResult:
        """
        对文本进行 Token 级压缩

        Args:
            text: 输入文本
            compression_ratio: 目标压缩比例 (0~1)，0.5 表示压缩到 50%
            min_token_length: 最少保留的 Token 长度（低于此长度直接保留）
            preserve_special: 是否保留标点、数字等特殊 Token
            window_size: 滑动窗口大小，用于平滑自信息分数
        """
        # 步骤 1：获取 Token 概率
        token_probs = self.estimator.estimate_token_probabilities(text)

        # 步骤 2：构建 TokenInfo 列表
        tokens = []
        for i, (token_text, prob) in enumerate(token_probs):
            si = self.compute_self_information(prob)
            # 包含 [CLS]、[SEP] 等特殊 Token
            tokens.append(TokenInfo(
                token_id=i,
                text=token_text,
                log_prob=math.log(prob) if prob > 0 else float('-inf'),
                self_information=si
            ))

        # 步骤 3：滑动窗口平滑
        smoothed_scores = self._smooth_scores(
            [t.self_information for t in tokens],
            window_size
        )

        # 步骤 4：确定保留和丢弃的 Token
        keep_mask = self._determine_keep_mask(
            tokens, smoothed_scores,
            compression_ratio,
            min_token_length,
            preserve_special
        )

        # 步骤 5：构建压缩结果
        kept_tokens = [t for t, m in zip(tokens, keep_mask) if m]
        removed_tokens = [t for t, m in zip(tokens, keep_mask) if not m]

        # 重新组装文本（需要处理 tokenizer 合并问题）
        compressed_text = self._reconstruct_text(tokens, keep_mask)

        original_len = len(tokens)
        compressed_len = len(kept_tokens)

        return CompressionResult(
            original_tokens=tokens,
            compressed_text=compressed_text,
            compression_ratio=compressed_len / original_len if original_len > 0 else 0,
            kept_tokens=kept_tokens,
            removed_tokens=removed_tokens,
            token_mask=keep_mask
        )

    def _smooth_scores(
        self,
        scores: List[float],
        window_size: int
    ) -> List[float]:
        """滑动窗口平均平滑"""
        if window_size <= 1:
            return scores

        smoothed = []
        for i in range(len(scores)):
            left = max(0, i - window_size // 2)
            right = min(len(scores), i + window_size // 2 + 1)
            avg = sum(scores[left:right]) / (right - left)
            smoothed.append(avg)
        return smoothed

    def _determine_keep_mask(
        self,
        tokens: List[TokenInfo],
        smoothed_scores: List[float],
        compression_ratio: float,
        min_token_length: int,
        preserve_special: bool
    ) -> List[bool]:
        """确定哪些 Token 应该保留"""
        n = len(tokens)
        keep_count = max(1, int(n * compression_ratio))

        # 为每个 Token 计算最终分数
        scores_with_bonus = list(smoothed_scores)

        for i, token in enumerate(tokens):
            # 短 Token（如标点）增加保留权重
            if preserve_special and len(token.text.strip()) <= min_token_length:
                scores_with_bonus[i] += 5.0  # 给予加分

            # 数字通常很重要
            if re.search(r'\d', token.text):
                scores_with_bonus[i] += 3.0

        # 按分数从高到低排序，取前 keep_count 个
        indices_sorted = sorted(
            range(n),
            key=lambda i: scores_with_bonus[i],
            reverse=True
        )

        keep_indices = set(indices_sorted[:keep_count])

        return [i in keep_indices for i in range(n)]

    def _reconstruct_text(
        self,
        tokens: List[TokenInfo],
        keep_mask: List[bool]
    ) -> str:
        """从保留的 Token 重建文本"""
        kept_texts = []
        for token, keep in zip(tokens, keep_mask):
            if keep:
                text = token.text
                # 处理部分 tokenizer 的分词问题
                if text.startswith('##'):
                    kept_texts.append(text[2:])
                else:
                    kept_texts.append(text)

        # 合并并清理多余空格
        text = ''.join(kept_texts)
        text = re.sub(r'\s+', ' ', text).strip()
        return text

# 初始化压缩器
estimator = BertProbabilityEstimator("bert-base-uncased")
compressor = TokenLevelCompressor(estimator)

# 待压缩文本
text = """
The Transformer architecture revolutionized natural language processing 
by introducing the self-attention mechanism, which allows the model to 
weigh the importance of different words in a sequence regardless of 
their positional distance. This breakthrough enabled parallel computation 
and captured long-range dependencies far more effectively than recurrent 
neural networks. However, the quadratic complexity of self-attention 
remains a significant bottleneck when processing long documents.
"""

# 压缩到 50%
result = compressor.compress(text, compression_ratio=0.5)

print(f"原始长度: {len(result.original_tokens)} tokens")
print(f"压缩后长度: {len(result.kept_tokens)} tokens")
print(f"压缩率: {result.compression_ratio:.2%}")
print(f"\n原始文本:\n{text}")
print(f"\n压缩后文本:\n{result.compressed_text}")

from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

class SentenceLevelCompressor:
    """句子级上下文压缩器"""

    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
        self.encoder = SentenceTransformer(model_name)

    def split_sentences(self, text: str) -> List[str]:
        """将文本分割为句子列表"""
        # 简单的正则分割
        sentences = re.split(r'(?<=[.!?])\s+', text)
        return [s.strip() for s in sentences if s.strip()]

    def compress(
        self,
        text: str,
        query: Optional[str] = None,
        compression_ratio: float = 0.5,
        method: str = "relevance"  # "relevance" | "diversity" | "hybrid"
    ) -> Tuple[str, List[int]]:
        """
        句子级压缩

        Args:
            text: 输入文本
            query: 任务查询（可选），用于相关性评分
            compression_ratio: 目标压缩比例
            method: 压缩策略
        """
        sentences = self.split_sentences(text)
        n = len(sentences)
        keep_count = max(1, int(n * compression_ratio))

        if method == "relevance":
            return self._compress_by_relevance(sentences, query, keep_count)
        elif method == "diversity":
            return self._compress_by_diversity(sentences, keep_count)
        else:  # hybrid
            return self._compress_hybrid(sentences, query, keep_count)

    def _compress_by_relevance(
        self,
        sentences: List[str],
        query: Optional[str],
        keep_count: int
    ) -> Tuple[str, List[int]]:
        """基于相关性的压缩"""
        if query is None:
            # 无查询时使用句子位置加权（认为靠前的句子更重要）
            scores = np.array([1.0 / (i + 1) for i in range(len(sentences))])
        else:
            # 计算每个句子与查询的相似度
            sent_emb = self.encoder.encode(sentences)
            query_emb = self.encoder.encode([query])
            scores = cosine_similarity(query_emb, sent_emb)[0]

        # 选择 top-k
        top_indices = np.argsort(scores)[::-1][:keep_count]
        top_indices = sorted(top_indices)  # 保持原始顺序

        compressed = [sentences[i] for i in top_indices]
        return ' '.join(compressed), top_indices.tolist()

    def _compress_by_diversity(
        self,
        sentences: List[str],
        keep_count: int
    ) -> Tuple[str, List[int]]:
        """基于多样性的压缩——最大化覆盖不同主题"""
        if len(sentences) <= keep_count:
            return ' '.join(sentences), list(range(len(sentences)))

        # 编码所有句子
        sent_emb = self.encoder.encode(sentences)

        # 贪心算法：每次选择与已选集合最不相似（最独特）的句子
        selected = [0]  # 总是选择第一个句子
        remaining = list(range(1, len(sentences)))

        while len(selected) < keep_count and remaining:
            # 计算每个剩余句子与已选句子的最大相似度
            max_sim = []
            for r in remaining:
                sims = cosine_similarity(
                    sent_emb[r:r+1],
                    sent_emb[selected]
                )[0]
                max_sim.append(np.max(sims))

            # 选择与已选集最不相似的句子
            best_idx = remaining[np.argmin(max_sim)]
            selected.append(best_idx)
            remaining.remove(best_idx)

        selected.sort()
        compressed = [sentences[i] for i in selected]
        return ' '.join(compressed), selected

    def _compress_hybrid(
        self,
        sentences: List[str],
        query: Optional[str],
        keep_count: int
    ) -> Tuple[str, List[int]]:
        """混合压缩：兼顾相关性和多样性"""
        if len(sentences) <= keep_count:
            return ' '.join(sentences), list(range(len(sentences)))

        sent_emb = self.encoder.encode(sentences)

        if query:
            query_emb = self.encoder.encode([query])
            relevance = cosine_similarity(query_emb, sent_emb)[0]
        else:
            # 无查询时使用位置加权
            relevance = np.array([1.0 / (i + 1) for i in range(len(sentences))])

        # 贪心选择，考虑相关性和多样性
        selected = [int(np.argmax(relevance))]
        remaining = [i for i in range(len(sentences)) if i != selected[0]]

        while len(selected) < keep_count and remaining:
            scores = []
            for r in remaining:
                # 相关性分数
                rel_score = relevance[r]
                # 与已选集的多样性惩罚
                sims = cosine_similarity(
                    sent_emb[r:r+1],
                    sent_emb[selected]
                )[0]
                div_penalty = np.max(sims)
                # 综合分数：相关性 - 多样性惩罚系数
                combined = rel_score - 0.5 * div_penalty
                scores.append((r, combined))

            best_idx = max(scores, key=lambda x: x[1])[0]
            selected.append(best_idx)
            remaining.remove(best_idx)

        selected.sort()
        compressed = [sentences[i] for i in selected]
        return ' '.join(compressed), selected

compressor = SentenceLevelCompressor()

# 示例：压缩 RAG 检索结果文本
document = """
Retrieval-Augmented Generation (RAG) is a technique that enhances 
language models by retrieving relevant information from external 
knowledge sources. The RAG architecture consists of two main components: 
a retriever and a generator. The retriever searches a knowledge base 
for documents relevant to the user's query. These retrieved documents 
are then concatenated with the original query to form an augmented 
prompt. The generator, typically a large language model, produces a 
response based on this augmented context. RAG has been shown to improve 
factual accuracy and reduce hallucinations. It also enables knowledge 
updates without model retraining. However, RAG introduces additional 
latency due to the retrieval step. The quality of RAG outputs heavily 
depends on the retriever's performance. Evaluating RAG systems requires 
measuring both retrieval quality and generation quality.
"""

query = "What are the components and benefits of RAG?"

compressed, indices = compressor.compress(
    document, 
    query=query,
    compression_ratio=0.5,
    method="hybrid"
)

print(f"原始句子数: {len(compressor.split_sentences(document))}")
print(f"压缩后句子数: {len(indices)}")
print(f"保留的句子索引: {indices}")
print(f"\n压缩结果:\n{compressed}")

import json

class LLMBasedCompressor:
    """基于 LLM 的语义级压缩"""

    def __init__(self, api_base: str = "https://api.openai.com/v1"):
        self.api_base = api_base

    def compress_with_llm(
        self,
        text: str,
        query: Optional[str] = None,
        compression_ratio: float = 0.3,
        model: str = "gpt-4o-mini",  # 使用小模型降低压缩成本
        max_tokens_per_chunk: int = 2000
    ) -> str:
        """
        用 LLM 对上下文进行语义压缩

        支持两种模式：
        1. 压缩：保留核心信息，丢弃冗余
        2. 摘要：针对特定查询提炼关键信息
        """
        chunks = self._chunk_text(text, max_tokens_per_chunk)
        compressed_chunks = []

        for chunk in chunks:
            prompt = self._build_compression_prompt(
                chunk, query, compression_ratio
            )
            compressed = self._call_llm(prompt, model)
            compressed_chunks.append(compressed)

        return '\n'.join(compressed_chunks)

    def _chunk_text(self, text: str, max_length: int) -> List[str]:
        """将文本切分为可处理的块"""
        # 简化的分块：按段落切分后合并
        paragraphs = text.split('\n\n')
        chunks = []
        current = []
        current_len = 0

        for para in paragraphs:
            para_len = len(para.split())
            if current_len + para_len > max_length and current:
                chunks.append('\n\n'.join(current))
                current = [para]
                current_len = para_len
            else:
                current.append(para)
                current_len += para_len

        if current:
            chunks.append('\n\n'.join(current))

        return chunks if chunks else [text]

    def _build_compression_prompt(
        self,
        text: str,
        query: Optional[str],
        ratio: float
    ) -> str:
        """构建压缩 prompt"""
        if query:
            return f"""你是一个上下文压缩专家。请根据以下查询，对提供的文本进行极致压缩。
压缩目标：保留与查询最相关的信息，将文本压缩到约 {ratio*100:.0f}%。
输出格式：直接输出压缩后的文本，不要添加任何说明。

查询：{query}

待压缩文本：
{text}

压缩后文本："""
        else:
            return f"""你是一个上下文压缩专家。请对以下文本进行压缩。
压缩目标：只保留最关键的技术要点和事实，将冗余描述、修饰词和示例删除。
压缩比例：约 {ratio*100:.0f}%。
输出格式：直接输出压缩后的文本。

待压缩文本：
{text}

压缩后文本："""

    def _call_llm(self, prompt: str, model: str) -> str:
        """调用 LLM API"""
        import requests

        payload = {
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.3,  # 低温度确保确定性
            "max_tokens": 2048
        }

        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }

        response = requests.post(
            f"{self.api_base}/chat/completions",
            json=payload,
            headers=headers
        )

        return response.json()["choices"][0]["message"]["content"]

class CompressedWithVerification:
    """带验证的压缩器"""

    def compress_with_verification(
        self,
        text: str,
        query: Optional[str] = None,
        model: str = "gpt-4o-mini"
    ) -> Tuple[str, dict]:
        """
        压缩并验证信息的忠实度
        返回: (压缩文本, 验证结果)
        """
        compressor = LLMBasedCompressor()
        compressed = compressor.compress_with_llm(text, query)

        # 验证：检查压缩结果是否引入了新信息
        verification = self._verify_faithfulness(text, compressed, query, model)

        return compressed, verification

    def _verify_faithfulness(
        self,
        original: str,
        compressed: str,
        query: Optional[str],
        model: str
    ) -> dict:
        """验证压缩结果的忠实度"""
        # 计算语义相似度
        encoder = SentenceTransformer("all-MiniLM-L6-v2")
        orig_emb = encoder.encode([original])
        comp_emb = encoder.encode([compressed])
        sim = cosine_similarity(orig_emb, comp_emb)[0][0]

        return {
            "semantic_similarity": float(sim),
            "length_ratio": len(compressed) / max(len(original), 1),
            "verified": sim > 0.7  # 语义相似度 > 0.7 视为可信
        }

from enum import Enum
from typing import Any, Dict

class CompressionLevel(Enum):
    """压缩等级"""
    LIGHT = "light"        # Token 级，保留 70-80%
    MEDIUM = "medium"      # 句子级，保留 40-60%
    AGGRESSIVE = "aggressive"  # 混合压缩，保留 20-30%
    EXTREME = "extreme"    # LLM 摘要，保留 5-15%

class ContextCompressionPipeline:
    """完整的上下文压缩管线"""

    def __init__(self, config: Optional[Dict[str, Any]] = None):
        # 初始化各组件
        self.token_compressor = TokenLevelCompressor(
            BertProbabilityEstimator()
        )
        self.sentence_compressor = SentenceLevelCompressor()
        self.llm_compressor = LLMBasedCompressor()

        # 默认配置
        self.config = config or {
            CompressionLevel.LIGHT: {
                "method": "token",
                "ratio": 0.75,
                "min_token_length": 3
            },
            CompressionLevel.MEDIUM: {
                "method": "sentence",
                "ratio": 0.5,
                "sentence_method": "hybrid"
            },
            CompressionLevel.AGGRESSIVE: {
                "method": "sentence",
                "ratio": 0.25,
                "sentence_method": "relevance"
            },
            CompressionLevel.EXTREME: {
                "method": "llm",
                "ratio": 0.1,
                "model": "gpt-4o-mini"
            }
        }

    def compress(
        self,
        text: str,
        level: CompressionLevel = CompressionLevel.MEDIUM,
        query: Optional[str] = None,
        **kwargs
    ) -> CompressionResult:
        """
        统一的压缩入口

        Args:
            text: 输入文本
            level: 压缩等级
            query: 任务查询（用于 RAG 场景）
        """
        cfg = self.config[level]

        if cfg["method"] == "token":
            return self.token_compressor.compress(
                text,
                compression_ratio=cfg.get("ratio", 0.5)
            )
        elif cfg["method"] == "sentence":
            compressed_text, indices = self.sentence_compressor.compress(
                text,
                query=query,
                compression_ratio=cfg.get("ratio", 0.5),
                method=cfg.get("sentence_method", "hybrid")
            )
            # 包装为 CompressionResult
            sentences = self.sentence_compressor.split_sentences(text)
            total_sentences = len(sentences)
            return CompressionResult(
                original_tokens=[],
                compressed_text=compressed_text,
                compression_ratio=len(indices) / max(total_sentences, 1),
                kept_tokens=[],
                removed_tokens=[],
                token_mask=[]
            )
        elif cfg["method"] == "llm":
            compressed = self.llm_compressor.compress_with_llm(
                text,
                query=query,
                compression_ratio=cfg.get("ratio", 0.1),
                model=cfg.get("model", "gpt-4o-mini")
            )
            return CompressionResult(
                original_tokens=[],
                compressed_text=compressed,
                compression_ratio=len(compressed) / max(len(text), 1),
                kept_tokens=[],
                removed_tokens=[],
                token_mask=[]
            )

class AdaptiveCompressor:
    """自适应压缩器——根据上下文自动选择压缩级别"""

    def __init__(self, pipeline: ContextCompressionPipeline):
        self.pipeline = pipeline

    def estimate_tokens(self, text: str) -> int:
        """粗略估算 Token 数量"""
        return len(text.split()) * 1.3  # 英文约为单词数×1.3

    def select_compression_level(
        self,
        text: str,
        task_type: str = "general",  # general / rag / agent
        max_budget_tokens: int = 4096
    ) -> CompressionLevel:
        """根据上下文长度和任务类型选择压缩级别"""
        estimated_tokens = self.estimate_tokens(text)

        # 如果本来就很少，不压缩
        if estimated_tokens <= max_budget_tokens * 0.8:
            return CompressionLevel.LIGHT

        # 计算需要压缩到的比例
        required_ratio = max_budget_tokens / estimated_tokens

        if required_ratio >= 0.75:
            return CompressionLevel.LIGHT
        elif required_ratio >= 0.4:
            return CompressionLevel.MEDIUM
        elif required_ratio >= 0.2:
            return CompressionLevel.AGGRESSIVE
        else:
            return CompressionLevel.EXTREME

    def compress_adaptive(
        self,
        text: str,
        task_type: str = "general",
        max_budget_tokens: int = 4096,
        query: Optional[str] = None
    ) -> CompressionResult:
        """自适应压缩"""
        level = self.select_compression_level(text, task_type, max_budget_tokens)

        # RAG 任务默认传 query 做相关性压缩
        if task_type == "rag" and query is None:
            raise ValueError("RAG 任务需要提供 query")

        return self.pipeline.compress(text, level, query=query)

import hashlib
from functools import lru_cache

class CachedProbabilityEstimator:
    """带缓存概率估计器"""

    def __init__(self, base_estimator, max_cache_size: int = 1000):
        self.estimator = base_estimator
        self.cache = {}
        self.max_cache_size = max_cache_size

    def estimate_token_probabilities(self, text: str):
        # 用文本哈希作为缓存键
        text_hash = hashlib.md5(text.encode()).hexdigest()

        if text_hash in self.cache:
            return self.cache[text_hash]

        result = self.estimator.estimate_token_probabilities(text)

        if len(self.cache) < self.max_cache_size:
            self.cache[text_hash] = result

        return result

class BatchCompressor:
    """批量压缩多个文本"""

    def __init__(self, compressor: ContextCompressionPipeline):
        self.compressor = compressor

    def compress_batch(
        self,
        documents: List[str],
        level: CompressionLevel = CompressionLevel.MEDIUM,
        queries: Optional[List[str]] = None
    ) -> List[CompressionResult]:
        """批量压缩多个文档"""
        results = []
        for i, doc in enumerate(documents):
            query = queries[i] if queries else None
            result = self.compressor.compress(doc, level, query=query)
            results.append(result)
        return results

class RAGCompressionIntegration:
    """将上下文压缩集成到 RAG 管线中"""

    def __init__(
        self,
        compressor: ContextCompressionPipeline,
        retriever: Any,  # 你的检索器
        llm: Any         # 你的生成模型
    ):
        self.compressor = compressor
        self.retriever = retriever
        self.llm = llm

    def query_with_compression(
        self,
        query: str,
        top_k: int = 5,
        compression_level: CompressionLevel = CompressionLevel.MEDIUM
    ) -> str:
        """带上下文压缩的 RAG 查询"""
        # 1. 检索相关文档
        retrieved_docs = self.retriever.retrieve(query, top_k=top_k * 2)

        # 2. 压缩每个检索到的文档
        compressed_docs = []
        for doc in retrieved_docs:
            result = self.compressor.compress(
                doc, 
                compression_level,
                query=query
            )
            compressed_docs.append(result.compressed_text)

        # 3. 构建压缩后的上下文
        context = '\n\n'.join(compressed_docs)

        # 4. 生成回复
        prompt = f"""基于以下上下文回答问题。

上下文：
{context}

问题：{query}

回答："""

        return self.llm.generate(prompt)

def evaluate_compression():
    """评估不同压缩策略的效果"""

    test_docs = [
        "The Transformer architecture revolutionized...",  # 长文本
        "Python is a high-level programming language...",
        "Machine learning algorithms can be categorized..."
    ]

    queries = [
        "How does self-attention work?",
        "What are Python's key features?",
        "Types of ML algorithms"
    ]

    pipe = ContextCompressionPipeline()
    results = {}

    for level in CompressionLevel:
        scores = []
        for doc, query in zip(test_docs, queries):
            result = pipe.compress(doc, level, query=query)
            scores.append(result.compression_ratio)

        results[level.value] = {
            "avg_compression_ratio": np.mean(scores),
            "min_ratio": min(scores),
            "max_ratio": max(scores)
        }

    return results

class SafeCompressor:
    """带 Fallback 的安全压缩器"""

    def compress_safe(self, text: str, **kwargs):
        """安全的压缩：异常时返回原始文本"""
        try:
            result = self.compressor.compress(text, **kwargs)
            # 验证结果质量
            if len(result.compressed_text) < len(text) * 0.05:
                # 压缩过度，退还原文
                return text
            return result.compressed_text
        except Exception as e:
            print(f"压缩异常: {e}，使用原文")
            return text