add relative files

test_crossencoder_reranking.py

@@ -1,229 +0,0 @@
-"""
-测试 CrossEncoder 重排功能
-对比 Bi-Encoder vs CrossEncoder 的效果
-"""
-
-from reranker import create_reranker, TFIDFReranker, BM25Reranker, SemanticReranker, CrossEncoderReranker
-
-
-class MockDoc:
-    """模拟文档类"""
-    def __init__(self, content, metadata=None):
-        self.page_content = content
-        self.metadata = metadata or {}
-
-
-class MockEmbeddings:
-    """模拟 Embeddings 类（用于 Semantic Reranker）"""
-    def embed_query(self, text):
-        # 简单的字符级向量化（仅用于测试）
-        return [ord(c) / 100.0 for c in text[:10]]
-    
-    def embed_documents(self, texts):
-        return [self.embed_query(text) for text in texts]
-
-
-def create_test_documents():
-    """创建测试文档集"""
-    return [
-        MockDoc("人工智能是计算机科学的一个分支，致力于创建能够执行通常需要人类智能的任务的系统。"),
-        MockDoc("机器学习是人工智能的子领域，专注于让计算机从数据中学习并改进。"),
-        MockDoc("深度学习使用多层神经网络来处理复杂的数据模式，是机器学习的一种方法。"),
-        MockDoc("自然语言处理（NLP）是人工智能的一个分支，处理计算机与人类语言之间的交互。"),
-        MockDoc("计算机视觉是人工智能的另一个重要领域，使机器能够理解和解释视觉信息。"),
-        MockDoc("今天天气很好，适合出去散步和运动。"),
-        MockDoc("Python 是一种高级编程语言，由 Guido van Rossum 在 1991 年创建。"),
-        MockDoc("RAG（检索增强生成）是一种结合信息检索和文本生成的技术。"),
-    ]
-
-
-def test_tfidf_reranking():
-    """测试 TF-IDF 重排"""
-    print("\n" + "=" * 60)
-    print("📊 测试 TF-IDF 重排")
-    print("=" * 60)
-    
-    query = "什么是人工智能和机器学习？"
-    docs = create_test_documents()
-    
-    reranker = TFIDFReranker()
-    results = reranker.rerank(query, docs, top_k=3)
-    
-    print(f"\n查询: {query}")
-    print("\nTF-IDF 重排结果:")
-    for i, (doc, score) in enumerate(results, 1):
-        print(f"{i}. 分数: {score:.4f} | 内容: {doc.page_content[:50]}...")
-
-
-def test_bm25_reranking():
-    """测试 BM25 重排"""
-    print("\n" + "=" * 60)
-    print("📊 测试 BM25 重排")
-    print("=" * 60)
-    
-    query = "什么是人工智能和机器学习？"
-    docs = create_test_documents()
-    
-    reranker = BM25Reranker()
-    results = reranker.rerank(query, docs, top_k=3)
-    
-    print(f"\n查询: {query}")
-    print("\nBM25 重排结果:")
-    for i, (doc, score) in enumerate(results, 1):
-        print(f"{i}. 分数: {score:.4f} | 内容: {doc.page_content[:50]}...")
-
-
-def test_crossencoder_reranking():
-    """测试 CrossEncoder 重排"""
-    print("\n" + "=" * 60)
-    print("🌟 测试 CrossEncoder 重排（推荐）")
-    print("=" * 60)
-    
-    query = "什么是人工智能和机器学习？"
-    docs = create_test_documents()
-    
-    try:
-        # 使用轻量级模型
-        reranker = CrossEncoderReranker(
-            model_name="cross-encoder/ms-marco-MiniLM-L-6-v2"
-        )
-        results = reranker.rerank(query, docs, top_k=3)
-        
-        print(f"\n查询: {query}")
-        print("\nCrossEncoder 重排结果:")
-        for i, (doc, score) in enumerate(results, 1):
-            print(f"{i}. 分数: {score:.4f} | 内容: {doc.page_content[:50]}...")
-        
-        return True
-        
-    except Exception as e:
-        print(f"\n❌ CrossEncoder 测试失败: {e}")
-        print("💡 提示: 请先安装 sentence-transformers")
-        print("   命令: pip install sentence-transformers")
-        return False
-
-
-def test_factory_function():
-    """测试工厂函数"""
-    print("\n" + "=" * 60)
-    print("🏭 测试重排器工厂函数")
-    print("=" * 60)
-    
-    query = "深度学习和神经网络"
-    docs = create_test_documents()
-    
-    # 测试各种类型
-    reranker_types = ['tfidf', 'bm25']
-    
-    for rtype in reranker_types:
-        try:
-            reranker = create_reranker(rtype)
-            results = reranker.rerank(query, docs, top_k=2)
-            print(f"\n✅ {rtype.upper()} 重排器创建成功")
-            print(f"   Top 1: {results[0][1]:.4f} | {results[0][0].page_content[:40]}...")
-        except Exception as e:
-            print(f"\n❌ {rtype.upper()} 重排器失败: {e}")
-    
-    # 测试 CrossEncoder
-    try:
-        reranker = create_reranker('crossencoder')
-        results = reranker.rerank(query, docs, top_k=2)
-        print(f"\n✅ CROSSENCODER 重排器创建成功")
-        print(f"   Top 1: {results[0][1]:.4f} | {results[0][0].page_content[:40]}...")
-    except Exception as e:
-        print(f"\n❌ CROSSENCODER 重排器失败: {e}")
-
-
-def compare_all_methods():
-    """对比所有重排方法"""
-    print("\n" + "=" * 60)
-    print("⚖️  对比所有重排方法")
-    print("=" * 60)
-    
-    query = "解释一下人工智能、机器学习和深度学习的关系"
-    docs = create_test_documents()
-    
-    methods = {
-        'TF-IDF': TFIDFReranker(),
-        'BM25': BM25Reranker(),
-    }
-    
-    # 尝试添加 CrossEncoder
-    try:
-        methods['CrossEncoder'] = CrossEncoderReranker()
-    except:
-        print("\n⚠️ CrossEncoder 不可用，跳过")
-    
-    print(f"\n查询: {query}\n")
-    
-    for method_name, reranker in methods.items():
-        try:
-            results = reranker.rerank(query, docs, top_k=3)
-            print(f"\n{'=' * 40}")
-            print(f"{method_name} 重排结果:")
-            print('=' * 40)
-            for i, (doc, score) in enumerate(results, 1):
-                print(f"{i}. [{score:.4f}] {doc.page_content[:60]}...")
-        except Exception as e:
-            print(f"\n{method_name} 失败: {e}")
-
-
-def performance_comparison():
-    """性能对比"""
-    print("\n" + "=" * 60)
-    print("⚡ 性能与准确性对比")
-    print("=" * 60)
-    
-    print("""
-    重排方法对比：
-    
-    ┌─────────────────┬──────────┬──────────┬──────────┬────────────┐
-    │ 方法            │ 准确率   │ 速度     │ 成本     │ 适用场景   │
-    ├─────────────────┼──────────┼──────────┼──────────┼────────────┤
-    │ TF-IDF          │ ⭐⭐     │ ⚡⚡⚡   │ 极低     │ 关键词匹配 │
-    │ BM25            │ ⭐⭐⭐   │ ⚡⚡⚡   │ 极低     │ 文本检索   │
-    │ Bi-Encoder      │ ⭐⭐⭐⭐ │ ⚡⚡     │ 低       │ 语义检索   │
-    │ CrossEncoder 🌟 │ ⭐⭐⭐⭐⭐│ ⚡       │ 中       │ 精准重排   │
-    │ Hybrid          │ ⭐⭐⭐⭐ │ ⚡⚡     │ 低       │ 综合场景   │
-    └─────────────────┴──────────┴──────────┴──────────┴────────────┘
-    
-    推荐配置：
-    1️⃣  两阶段检索：Bi-Encoder (快速召回) + CrossEncoder (精准重排)
-    2️⃣  准确率优先：纯 CrossEncoder
-    3️⃣  速度优先：BM25 或 Hybrid
-    
-    当前项目配置：
-    ✅ 已切换到 CrossEncoder 重排
-    📈 准确率预期提升：15-20%
-    ⚡ 速度：单次重排 20-100ms (Top 20 文档)
-    """)
-
-
-if __name__ == "__main__":
-    print("\n🚀 开始测试 CrossEncoder 重排功能...\n")
-    
-    # 1. 测试 TF-IDF
-    test_tfidf_reranking()
-    
-    # 2. 测试 BM25
-    test_bm25_reranking()
-    
-    # 3. 测试 CrossEncoder (重点)
-    crossencoder_available = test_crossencoder_reranking()
-    
-    # 4. 测试工厂函数
-    test_factory_function()
-    
-    # 5. 对比所有方法
-    compare_all_methods()
-    
-    # 6. 性能对比总结
-    performance_comparison()
-    
-    print("\n" + "=" * 60)
-    if crossencoder_available:
-        print("✅ 所有测试完成！CrossEncoder 重排已就绪")
-    else:
-        print("⚠️  测试完成，但 CrossEncoder 不可用")
-        print("   请运行: pip install sentence-transformers")
-    print("=" * 60 + "\n")

test_hallucination_detector.py

@@ -1,173 +0,0 @@
-"""
-测试专业幻觉检测器
-对比 LLM-as-a-Judge vs Vectara/NLI
-"""
-
-from hallucination_detector import (
-    VectaraHallucinationDetector,
-    NLIHallucinationDetector,
-    HybridHallucinationDetector
-)
-
-
-def test_vectara_detector():
-    """测试 Vectara 检测器"""
-    print("=" * 60)
-    print("🧪 测试 Vectara 幻觉检测器")
-    print("=" * 60)
-    
-    detector = VectaraHallucinationDetector()
-    
-    # 测试用例 1: 正常回答（无幻觉）
-    documents = """
-    Python是一种高级编程语言。它由Guido van Rossum在1991年创建。
-    Python强调代码可读性，使用缩进来定义代码块。
-    """
-    generation = "Python是由Guido van Rossum在1991年创建的高级编程语言。"
-    
-    print("\n📝 测试用例 1: 正常回答")
-    print(f"文档: {documents[:100]}...")
-    print(f"生成: {generation}")
-    result = detector.detect(generation, documents)
-    print(f"结果: {result}")
-    
-    # 测试用例 2: 幻觉回答
-    generation_hallucinated = "Python是由Dennis Ritchie在1972年创建的。"
-    
-    print("\n📝 测试用例 2: 幻觉回答")
-    print(f"生成: {generation_hallucinated}")
-    result = detector.detect(generation_hallucinated, documents)
-    print(f"结果: {result}")
-    
-    print("\n" + "=" * 60)
-
-
-def test_nli_detector():
-    """测试 NLI 检测器"""
-    print("\n" + "=" * 60)
-    print("🧪 测试 NLI 幻觉检测器")
-    print("=" * 60)
-    
-    detector = NLIHallucinationDetector()
-    
-    documents = """
-    LangChain是一个用于构建LLM应用的框架。
-    它提供了链式调用、提示模板、内存管理等功能。
-    """
-    
-    # 测试用例 1: 正常回答
-    generation = "LangChain提供了链式调用和提示模板功能。"
-    
-    print("\n📝 测试用例 1: 正常回答")
-    print(f"生成: {generation}")
-    result = detector.detect(generation, documents)
-    print(f"结果: {result}")
-    
-    # 测试用例 2: 幻觉回答
-    generation_hallucinated = "LangChain是由OpenAI开发的数据库系统。它主要用于存储图片。"
-    
-    print("\n📝 测试用例 2: 幻觉回答")
-    print(f"生成: {generation_hallucinated}")
-    result = detector.detect(generation_hallucinated, documents)
-    print(f"结果: {result}")
-    
-    print("\n" + "=" * 60)
-
-
-def test_hybrid_detector():
-    """测试混合检测器"""
-    print("\n" + "=" * 60)
-    print("🧪 测试混合幻觉检测器 (推荐)")
-    print("=" * 60)
-    
-    detector = HybridHallucinationDetector(use_vectara=True, use_nli=True)
-    
-    documents = """
-    GraphRAG是一种结合图结构和RAG的方法。
-    它通过构建知识图谱来增强检索效果。
-    主要步骤包括实体提取、关系识别、社区检测和摘要生成。
-    """
-    
-    # 测试用例 1: 正常回答
-    generation = "GraphRAG通过知识图谱增强检索，包含实体提取和社区检测等步骤。"
-    
-    print("\n📝 测试用例 1: 正常回答")
-    print(f"生成: {generation}")
-    result = detector.detect(generation, documents)
-    print(f"结果: {result}")
-    
-    # 测试用例 2: 幻觉回答
-    generation_hallucinated = "GraphRAG是一个数据库管理系统，主要用于存储用户密码和财务数据。"
-    
-    print("\n📝 测试用例 2: 幻觉回答")
-    print(f"生成: {generation_hallucinated}")
-    result = detector.detect(generation_hallucinated, documents)
-    print(f"结果: {result}")
-    
-    # 测试 grade 方法（兼容接口）
-    print("\n📝 测试 grade 方法（兼容原有接口）")
-    score = detector.grade(generation, documents)
-    print(f"Grade 结果: {score} (yes=无幻觉, no=有幻觉)")
-    
-    print("\n" + "=" * 60)
-
-
-def compare_performance():
-    """对比性能"""
-    print("\n" + "=" * 60)
-    print("📊 性能对比总结")
-    print("=" * 60)
-    
-    print("""
-    方法对比：
-    
-    1️⃣ LLM-as-a-Judge (原方法)
-       准确率: 60-75%
-       速度: 慢 (每次 2-5 秒)
-       成本: 高 (调用 LLM)
-       
-    2️⃣ Vectara 专门检测模型
-       准确率: 90-95%
-       速度: 快 (每次 0.1-0.3 秒)
-       成本: 低 (本地推理)
-       
-    3️⃣ NLI 模型
-       准确率: 85-90%
-       速度: 快 (每次 0.2-0.5 秒)
-       成本: 低 (本地推理)
-       
-    4️⃣ 混合检测器 (推荐) ⭐
-       准确率: 95%+
-       速度: 中等 (每次 0.3-0.8 秒)
-       成本: 低
-       优势: 综合多个模型，准确率最高
-    """)
-    
-    print("=" * 60)
-
-
-if __name__ == "__main__":
-    print("\n🚀 开始测试专业幻觉检测器...\n")
-    
-    try:
-        # 测试 Vectara
-        test_vectara_detector()
-    except Exception as e:
-        print(f"❌ Vectara 测试失败: {e}")
-    
-    try:
-        # 测试 NLI
-        test_nli_detector()
-    except Exception as e:
-        print(f"❌ NLI 测试失败: {e}")
-    
-    try:
-        # ���试混合检测器
-        test_hybrid_detector()
-    except Exception as e:
-        print(f"❌ 混合检测器测试失败: {e}")
-    
-    # 性能对比
-    compare_performance()
-    
-    print("\n✅ 测试完成！")

test_lightweight_detector.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""
-轻量级幻觉检测器测试脚本
-测试效果与性能，替代 Vectara 模型
-"""
-
-import time
-from lightweight_hallucination_detector import LightweightHallucinationDetector
-
-def test_performance():
-    """测试不同模型的性能和效果"""
-    print("="*70)
-    print("🚀 轻量级幻觉检测器性能测试")
-    print("="*70)
-    
-    # 测试不同模型
-    models_to_test = [
-        "cross-encoder/nli-MiniLM2-L6-H768",  # 推荐轻量方案
-        "cross-encoder/nli-deberta-v3-xsmall",  # 超轻量方案
-        "cross-encoder/nli-roberta-base",  # 高准确率方案
-    ]
-    
-    # 测试数据
-    documents = "巴黎是法国的首都，这是一座美丽的城市，拥有许多历史地标和博物馆。"
-    
-    test_cases = [
-        ("完全正确", "巴黎是法国的首都。"),
-        ("事实错误", "柏林是法国的首都。"),
-        ("部分正确", "巴黎是德国的首都，但很美丽。"),
-        ("语义等价", "法国的首都是巴黎。"),
-        ("无关信息", "纽约是美国的一个大城市。"),
-    ]
-    
-    results = []
-    
-    for model_name in models_to_test:
-        print(f"\n📊 测试模型: {model_name}")
-        print("-" * 50)
-        
-        try:
-            detector = LightweightHallucinationDetector(model_name)
-            
-            model_results = {
-                "model": model_name,
-                "tests": []
-            }
-            
-            for test_name, test_case in test_cases:
-                start_time = time.time()
-                result = detector.detect(test_case, documents)
-                end_time = time.time()
-                
-                print(f"  {test_name}:")
-                print(f"    假设: {test_case}")
-                print(f"    是否幻觉: {result['has_hallucination']}")
-                print(f"    幻觉分数: {result['hallucination_score']:.3f}")
-                print(f"    推理时间: {end_time - start_time:.3f}秒")
-                print()
-                
-                model_results["tests"].append({
-                    "name": test_name,
-                    "case": test_case,
-                    "result": result,
-                    "time": end_time - start_time
-                })
-            
-            results.append(model_results)
-            
-        except Exception as e:
-            print(f"  ❌ 模型测试失败: {e}")
-    
-    # 总结
-    print("\n" + "="*70)
-    print("📋 测试总结")
-    print("="*70)
-    
-    for model_result in results:
-        model = model_result["model"]
-        tests = model_result["tests"]
-        
-        avg_time = sum(t["time"] for t in tests) / len(tests)
-        correct_count = 0
-        
-        # 评估准确性
-        expected_results = [False, True, True, False, False]  # 预期结果
-        for i, test in enumerate(tests):
-            if test["result"]["has_hallucination"] == expected_results[i]:
-                correct_count += 1
-        
-        accuracy = correct_count / len(tests) * 100
-        
-        print(f"\n🤖 {model}:")
-        print(f"  ⚡ 平均推理时间: {avg_time:.3f}秒")
-        print(f"  🎯 准确率: {accuracy:.1f}% ({correct_count}/{len(tests)})")
-        print(f"  📊 幻觉检测评分: {sum(t['result']['hallucination_score'] for t in tests):.2f}")
-
-def test_rag_scenarios():
-    """测试RAG场景下的幻觉检测"""
-    print("\n" + "="*70)
-    print("🔍 RAG场景测试")
-    print("="*70)
-    
-    # RAG测试数据
-    rag_documents = """
-    产品信息：iPhone 14 Pro 是苹果公司在2022年9月发布的旗舰智能手机。
-    主要特性：配备6.1英寸Super Retina XDR显示屏，A16仿生芯片，4800万像素主摄像头。
-    电池续航：视频播放最长可达23小时，支持20W有线快充。
-    价格：起售价为799美元。
-    """
-    
-    rag_test_cases = [
-        ("准确信息", "iPhone 14 Pro配备了A16仿生芯片和4800万像素摄像头。"),
-        ("规格错误", "iPhone 14 Pro配备A15仿生芯片和1200万像素摄像头。"),
-        ("价格错误", "iPhone 14 Pro的起售价为999美元。"),
-        ("无关信息", "iPhone 14 Pro支持手写笔输入。"),
-        ("混合信息", "iPhone 14 Pro配备A16芯片，起售价999美元，支持手写笔。"),
-    ]
-    
-    detector = LightweightHallucinationDetector()
-    
-    print("🧪 RAG幻觉检测测试：\n")
-    
-    for test_name, test_case in rag_test_cases:
-        result = detector.detect(test_case, rag_documents, method="sentence_level")
-        
-        print(f"📋 {test_name}:")
-        print(f"   生成内容: {test_case}")
-        print(f"   检测结果: {'🚨 检测到幻觉' if result['has_hallucination'] else '✅ 未检测到幻觉'}")
-        print(f"   幻觉分数: {result['hallucination_score']:.3f}")
-        print(f"   事实性分数: {result['factuality_score']:.3f}")
-        
-        if result['details'].get('problematic_sentences'):
-            print(f"   问题句子数: {len(result['details']['problematic_sentences'])}")
-            for i, prob in enumerate(result['details']['problematic_sentences'], 1):
-                print(f"     {i}. {prob['sentence']} (分数: {prob['score']:.3f})")
-        
-        print()
-
-if __name__ == "__main__":
-    # 1. 性能测试
-    test_performance()
-    
-    # 2. RAG场景测试
-    test_rag_scenarios()
-    
-    print("\n" + "="*70)
-    print("💡 使用建议:")
-    print("1. 生产环境推荐使用 cross-encoder/nli-MiniLM2-L6-H768")
-    print("2. 资源受限环境可使用 cross-encoder/nli-deberta-v3-xsmall")
-    print("3. 高准确率需求可使用 cross-encoder/nli-roberta-base")
-    print("4. 建议设置幻觉分数阈值为 0.6-0.7")
-    print("="*70)

test_reranking.py

@@ -1,224 +0,0 @@
-#!/usr/bin/env python3
-"""
-重排功能测试脚本
-演示不同重排策略的效果
-"""
-
-import sys
-import os
-sys.path.append(os.path.dirname(__file__))
-
-from document_processor import DocumentProcessor
-from reranker import *
-try:
-    from langchain_core.documents import Document
-except ImportError:
-    try:
-        from langchain_core.documents import Document
-    except ImportError:
-        from langchain.schema import Document
-import time
-
-
-def create_test_documents():
-    """创建测试文档"""
-    return [
-        Document(
-            page_content="人工智能（AI）是计算机科学的一个分支，致力于创建能够执行通常需要人类智能的任务的系统。",
-            metadata={"source": "ai_intro.txt", "category": "AI基础"}
-        ),
-        Document(
-            page_content="机器学习是人工智能的一个重要子领域，通过算法让计算机从数据中学习模式和规律。",
-            metadata={"source": "ml_basics.txt", "category": "机器学习"}
-        ),
-        Document(
-            page_content="深度学习是机器学习的一个分支，使用多层神经网络来模拟人脑的学习过程。",
-            metadata={"source": "dl_guide.txt", "category": "深度学习"}
-        ),
-        Document(
-            page_content="自然语言处理（NLP）是人工智能领域的一个重要分支，专注于使计算机理解和处理人类语言。",
-            metadata={"source": "nlp_overview.txt", "category": "自然语言处理"}
-        ),
-        Document(
-            page_content="计算机视觉是人工智能的另一个重要领域，使计算机能够识别和理解图像和视频内容。",
-            metadata={"source": "cv_intro.txt", "category": "计算机视觉"}
-        ),
-        Document(
-            page_content="强化学习是机器学习的一种类型，通过与环境交互来学习最优的行为策略。",
-            metadata={"source": "rl_basics.txt", "category": "强化学习"}
-        ),
-        Document(
-            page_content="今天的天气非常好，阳光明媚，适合外出游玩和运动。",
-            metadata={"source": "weather.txt", "category": "天气"}
-        ),
-        Document(
-            page_content="区块链是一种分布式账本技术，具有去中心化、不可篡改等特点。",
-            metadata={"source": "blockchain.txt", "category": "区块链"}
-        )
-    ]
-
-
-def test_reranker_comparison():
-    """比较不同重排器的效果"""
-    print("🔍 重排器效果比较测试")
-    print("=" * 60)
-    
-    # 创建测试数据
-    query = "什么是人工智能和机器学习？"
-    documents = create_test_documents()
-    
-    # 创建一个简单的嵌入模型（用于测试）
-    try:
-        from langchain_community.embeddings import HuggingFaceEmbeddings
-        embeddings = HuggingFaceEmbeddings(
-            model_name="sentence-transformers/all-MiniLM-L6-v2",
-            model_kwargs={'device': 'cpu'}
-        )
-        print("✅ 成功加载嵌入模型")
-    except Exception as e:
-        print(f"❌ 嵌入模型加载失败: {e}")
-        print("将使用基础重排器进行测试")
-        embeddings = None
-    
-    # 测试不同的重排器
-    rerankers = []
-    
-    # TF-IDF重排器
-    rerankers.append(("TF-IDF", TFIDFReranker()))
-    
-    # BM25重排器
-    rerankers.append(("BM25", BM25Reranker()))
-    
-    if embeddings:
-        # 语义重排器
-        rerankers.append(("语义相似度", SemanticReranker(embeddings)))
-        
-        # 混合重排器
-        rerankers.append(("混合策略", HybridReranker(embeddings)))
-        
-        # 多样性重排器
-        rerankers.append(("多样性优化", DiversityReranker(embeddings)))
-    
-    # 执行测试
-    for name, reranker in rerankers:
-        print(f"\n📊 {name} 重排结果:")
-        print("-" * 40)
-        
-        start_time = time.time()
-        try:
-            results = reranker.rerank(query, documents, top_k=5)
-            end_time = time.time()
-            
-            print(f"⏱️ 处理时间: {(end_time - start_time)*1000:.2f}ms")
-            
-            for i, (doc, score) in enumerate(results, 1):
-                content = doc.page_content[:80] + "..." if len(doc.page_content) > 80 else doc.page_content
-                category = doc.metadata.get('category', '未知')
-                print(f"{i}. [分数: {score:.4f}] [{category}] {content}")
-                
-        except Exception as e:
-            print(f"❌ 重排失败: {e}")
-
-
-def test_reranking_with_embeddings():
-    """测试带嵌入的重排功能"""
-    print("\n\n🧠 嵌入模型重排测试")
-    print("=" * 60)
-    
-    try:
-        # 创建文档处理器
-        processor = DocumentProcessor()
-        
-        # 创建测试文档
-        test_docs = create_test_documents()
-        
-        # 测试查询
-        queries = [
-            "人工智能的定义是什么？",
-            "机器学习和深度学习的区别",
-            "自然语言处理的应用",
-            "今天天气怎么样？"
-        ]
-        
-        for query in queries:
-            print(f"\n🔍 查询: {query}")
-            print("-" * 30)
-            
-            if processor.reranker:
-                # 使用重排功能
-                results = processor.reranker.rerank(query, test_docs, top_k=3)
-                
-                for i, (doc, score) in enumerate(results, 1):
-                    content = doc.page_content[:60] + "..." if len(doc.page_content) > 60 else doc.page_content
-                    category = doc.metadata.get('category', '未知')
-                    print(f"{i}. [分数: {score:.4f}] [{category}] {content}")
-            else:
-                print("❌ 重排器未初始化")
-                
-    except Exception as e:
-        print(f"❌ 测试失败: {e}")
-
-
-def test_performance_comparison():
-    """性能对比测试"""
-    print("\n\n⚡ 性能对比测试")
-    print("=" * 60)
-    
-    documents = create_test_documents() * 10  # 增加文档数量
-    query = "人工智能技术的发展趋势"
-    
-    # 测试不同重排器的性能
-    rerankers_config = [
-        ("无重排", None),
-        ("TF-IDF", TFIDFReranker()),
-        ("BM25", BM25Reranker())
-    ]
-    
-    for name, reranker in rerankers_config:
-        times = []
-        
-        # 多次测试取平均值
-        for _ in range(5):
-            start_time = time.time()
-            
-            if reranker:
-                results = reranker.rerank(query, documents, top_k=5)
-            else:
-                # 模拟无重排的情况
-                results = documents[:5]
-            
-            end_time = time.time()
-            times.append((end_time - start_time) * 1000)
-        
-        avg_time = sum(times) / len(times)
-        print(f"{name}: 平均处理时间 {avg_time:.2f}ms (文档数: {len(documents)})")
-
-
-def main():
-    """主测试函数"""
-    print("🚀 向量重排功能综合测试")
-    print("=" * 80)
-    
-    try:
-        # 基础重排器比较
-        test_reranker_comparison()
-        
-        # 嵌入模型重排测试
-        test_reranking_with_embeddings()
-        
-        # 性能对比测试
-        test_performance_comparison()
-        
-        print("\n\n✅ 所有测试完成!")
-        print("=" * 80)
-        
-    except KeyboardInterrupt:
-        print("\n❌ 测试被用户中断")
-    except Exception as e:
-        print(f"\n❌ 测试过程中发生错误: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-if __name__ == "__main__":
-    main()