# 克隆仓库
git clone https://github.com/yourusername/queryrewrite.git
cd queryrewrite
# 安装依赖
pip install -e .

pip install queryrewrite

# queryrewrite/llm/openai.py
from langchain_openai import ChatOpenAI
from queryrewrite.llm.base import LLMBase
class OpenAILLM(LLMBase):
    """LLM implementation for OpenAI models."""
    def __init__(self, model: str = "gpt-3.5-turbo", api_key: str = None, temperature: float = 0.7):
        """
        Initializes the OpenAILLM.
        Args:
            model: The name of the OpenAI model to use.
            api_key: Your OpenAI API key.
            temperature: Controls randomness. Higher values make output more random,
                        lower values make it more deterministic.
        """
        self.model = model
        self.api_key = api_key
        self.temperature = temperature
        self.llm = ChatOpenAI(
            model=self.model,
            openai_api_key=self.api_key,
            temperature=self.temperature
        )
    def invoke(self, prompt: str) -> str:
        """Invoke the OpenAI model with a given prompt."""
        response = self.llm.invoke(prompt)
        return response.content

pip install langchain-openai openai

from queryrewrite.llm.openai import OpenAILLM
from queryrewrite.rewriting.base import rewrite, RewriteMethod
from queryrewrite.utils.data_models import Query
# 初始化OpenAI LLM
llm = OpenAILLM(
    model="gpt-3.5-turbo",
    api_key="your-openai-api-key",  # 替换为您的API密钥
    temperature=0.7
)
# 定义查询
query = {"query": "如何测试一个大型语言模型？", "reference": "大型语言模型的测试是一个复杂的过程，涉及多个层面。"}
# 使用OpenAI进行查询重写
rewritten_queries = rewrite(method=RewriteMethod.LLM, query=query, llm=llm)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This demo showcases the usage of the queryrewrite library.
"""
from queryrewrite.llm.ollama import OllamaLLM
from queryrewrite.rewriting.base import rewrite, RewriteMethod
from queryrewrite.validation.base import validate, ValidationMethod
from queryrewrite.utils.data_models import Query, Glossary
def main():
    """Main function to run the demo."""
    # 1. 初始化LLM
    # 这里假设你已经运行了Ollama实例，并加载了qwen3:8b模型
    try:
        llm = OllamaLLM(model="qwen3:8b")
    except Exception as e:
        print(f"Error initializing Ollama LLM: {e}")
        print("Please ensure Ollama is running and the model is available.")
        return
    # 2. 定义输入查询
    query: Query = {"query": "如何测试一个大型语言模型？", "reference": "大型语言模型的测试是一个复杂的过程，涉及多个层面。"}
    # 3. 演示重写方法
    print("--- Demonstrating Rewriting Methods ---")
    # 方法1: LLM重写器
    print("\n--- Method 1: LLM Rewriter ---")
    try:
        llm_rewritten = rewrite(method=RewriteMethod.LLM, query=query, llm=llm,thinking='/no_think')
        print(f"LLM Rewritten Queries: {llm_rewritten}")
    except Exception as e:
        print(f"Error during LLM rewriting: {e}")
    # 方法2: 词汇表重写器
    print("\n--- Method 2: Glossary Rewriter ---")
    glossary: Glossary = [
        ["测试", "评估", "评测"],
        ["大型语言模型", "大模型", "LLM"],
    ]
    glossary_rewritten = rewrite(method=RewriteMethod.GLOSSARY, query=query, glossary=glossary)
    print(f"Glossary Rewritten Queries: {glossary_rewritten}")
    # 方法3: 同义词重写器
    print("\n--- Method 3: Synonym Rewriter ---")
    try:
        synonym_rewritten = rewrite(method=RewriteMethod.SYNONYM, query=query, llm=llm,thinking='/no_think')
        print(f"Synonym Rewritten Queries: {synonym_rewritten}")
    except Exception as e:
        print(f"Error during synonym rewriting: {e}")
    # 4. 演示验证方法
    print("\n--- Demonstrating Validation Methods ---")
    # 我们将使用glossary_rewritten列表进行验证示例
    rewritten_queries = glossary_rewritten
    # 方法1: 无验证
    print("\n--- Validation Method 1: No Validation ---")
    no_validation_result = validate(
        method=ValidationMethod.NONE,
        rewritten_queries=rewritten_queries,
        original_query=query["query"]
    )
    print(f"No Validation Result: {no_validation_result}")
    # 方法2: ROUGE-L + BLEU归一化
    print("\n--- Validation Method 2: ROUGE-L + BLEU Normalized ---")
    rouge_bleu_result = validate(
        method=ValidationMethod.ROUGE_L_BLEU_NORMALIZED,
        rewritten_queries=rewritten_queries,
        original_query=query["query"]
    )
    print(f"ROUGE-L + BLEU Normalized Result: {rouge_bleu_result}")
    # 方法3: 帕累托最优
    print("\n--- Validation Method 3: Pareto Optimal ---")
    pareto_result = validate(
        method=ValidationMethod.PARETO_OPTIMAL,
        rewritten_queries=rewritten_queries,
        original_query=query["query"]
    )
    print(f"Pareto Optimal Result: {pareto_result}")
    # 方法4: 最详细
    print("\n--- Validation Method 4: Most Detailed ---")
    detailed_result = validate(
        method=ValidationMethod.MOST_DETAILED,
        rewritten_queries=rewritten_queries,
        original_query=query["query"]
    )
    print(f"Most Detailed Result: {detailed_result}")
    
    # 方法5: 根据ROUGE-L + BLEU阈值过滤
    print("\n--- Validation Method 5: Filter by ROUGE-L + BLEU Thresholds ---")
    filtered_result = validate(
        method=ValidationMethod.FILTER_BY_ROUGE_L_BLEU_THRESHOLDS,
        rewritten_queries=rewritten_queries,
        original_query=query["query"]
    )
    print(f"Filtered Result: {filtered_result}")
    # 方法6: LLM语义相似度
    print("\n--- Validation Method 6: LLM Semantic Similarity ---")
    try:
        llm_similarity_result = validate(
            method=ValidationMethod.LLM_SEMANTIC_SIMILARITY,
            rewritten_queries=rewritten_queries,
            original_query=query["query"],
            llm=llm,
            thinking='/no_think'
        )
        print(f"LLM Semantic Similarity Result: {llm_similarity_result}")
    except Exception as e:
        print(f"Error during LLM semantic similarity validation: {e}")
if __name__ == "__main__":
    main()

import jieba
def lcs_length(x, y):
    """计算两个序列的最长公共子序列长度"""
    m, n = len(x), len(y)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if x[i-1] == y[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    return dp[m][n]
# 输入文本
reference = "我爱学习自然语言处理"
hypothesis = "我喜欢学习算法和自然语言处理"
# 分词
jieba.add_word("自然语言处理")
ref_tokens = list(jieba.cut(reference, cut_all=False))
hyp_tokens = list(jieba.cut(hypothesis, cut_all=False))
# 调试：打印分词结果
print(f"Reference tokens: {ref_tokens}")
print(f"Hypothesis tokens: {hyp_tokens}")
# 计算 LCS 长度
lcs_len = lcs_length(ref_tokens, hyp_tokens)
# 计算 ROUGE-L
m, n = len(ref_tokens), len(hyp_tokens)
precision = lcs_len / n if n > 0 else 0
recall = lcs_len / m if m > 0 else 0
f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
# 输出结果
print(f"ROUGE-L Precision: {precision:.3f}")
print(f"ROUGE-L Recall: {recall:.3f}")
print(f"ROUGE-L F1: {f1:.3f}")

Reference tokens: ['我', '爱', '学习', '自然语言处理']
Hypothesis tokens: ['我', '喜欢', '学习', '算法', '和', '自然语言处理']
ROUGE-L Precision: 0.500
ROUGE-L Recall: 0.750
ROUGE-L F1: 0.600

from sumeval.metrics.bleu import BLEUCalculator
# 初始化 BLEU 计算器
bleu_calc = BLEUCalculator()
# 英文示例
print("\n=== 英文 BLEU 计算示例 ===")
reference_en = "I love studying natural language processing"
hypothesis_en = "I like studying algorithms and natural language processing"
print(f"Reference: {reference_en}")
print(f"Hypothesis: {hypothesis_en}")
# 计算 BLEU 分数 - 使用列表格式
bleu_score_en = bleu_calc.bleu(summary=[hypothesis_en], references=[[reference_en]])
print(f"BLEU Score: {bleu_score_en:.4f}")
# 多个参考文本的示例
print("\n=== 多参考文本 BLEU 计算示例 ===")
references_multi = [
    "I love studying natural language processing",
    "I enjoy learning natural language processing", 
    "I like to study NLP"
]
hypothesis_multi = "I like studying algorithms and natural language processing"
print(f"References: {references_multi}")
print(f"Hypothesis: {hypothesis_multi}")
# 计算多参考 BLEU 分数 - 使用列表格式
bleu_score_multi = bleu_calc.bleu(summary=[hypothesis_multi], references=[references_multi])
print(f"BLEU Score (multi-ref): {bleu_score_multi:.4f}")

=== 英文 BLEU 计算示例 ===
Reference: I love studying natural language processing
Hypothesis: I like studying algorithms and natural language processing
BLEU Score: 8.7836
=== 多参考文本 BLEU 计算示例 ===
References: ['I love studying natural language processing', 'I enjoy learning natural language processing', 'I like to study NLP']
Hypothesis: I like studying algorithms and natural language processing
BLEU Score (multi-ref): 3.3030