什么是 ‘Contextual Query Expansion’？利用历史会话对当前 Query 进行语义补全的物理细节

各位同仁，各位对自然语言处理和信息检索前沿技术充满热情的开发者与研究者们，大家好。

今天，我们将深入探讨一个在现代智能系统中至关重要的话题：上下文查询扩展 (Contextual Query Expansion, CQE)。在人机交互日益频繁的今天，用户常常以简短、模糊或省略的方式表达他们的意图。这些查询本身可能信息不足，无法直接获得精确的结果。CQE正是为了解决这一挑战而生，它通过利用历史会话的丰富上下文，对当前查询进行语义上的补全和增强，从而显著提升系统的理解能力和响应质量。

我将以一名编程专家的视角，为大家详细剖析CQE的原理、核心技术、实现细节以及在实际系统中的应用。我们将从基础概念出发，逐步深入到基于规则、基于语义相似性，乃至基于深度学习的先进方法，并穿插具体的代码示例，以确保我们不仅理解“是什么”，更理解“怎么做”。

1. 上下文查询扩展 (Contextual Query Expansion, CQE) 概述

在传统的搜索引擎或信息检索系统中，每一个查询通常都被视为一个独立的事件，系统仅根据查询本身的关键词进行匹配和排序。然而，在现实世界的对话场景中，尤其是多轮对话（Multi-turn Conversation）中，用户后续的查询往往是对前面对话内容的延续和补充。例如：

• 用户A: "谁是埃隆·马斯克？"
• 系统A: "埃隆·马斯克是特斯拉、SpaceX等公司的创始人。"
• 用户A: "他创建了哪些公司？"

在这个例子中，第二个查询 "他创建了哪些公司？" 中的 "他" 是一个代词，如果不结合之前的对话，系统将无法理解 "他" 指代的是 "埃隆·马斯克"。同理，即使没有代词，查询 "创建了哪些公司？" 也需要知道主题是 "埃隆·马斯克" 才能给出有意义的答案。

上下文查询扩展 (CQE) 的核心思想就是利用前一个或多个对话回合（turns）中积累的信息作为“上下文”，来丰富、澄清或重构当前模糊或不完整的查询，使其变得更加精确和完整。其目标是生成一个“扩展后的查询”，这个扩展后的查询能够更准确地表达用户的真实意图，从而引导系统检索到更相关的结果。

CQE与传统的查询扩展（Query Expansion, QE）有所不同。传统的QE通常基于词汇相似性（如同义词、词向量相似词）、主题模型或点击日志等独立于当前会话的方式来扩展查询。而CQE则强调会话上下文的重要性，它是一种动态的、依赖于历史交互的扩展策略。

2. 查询模糊与不完整性：CQE的驱动力

为什么CQE如此重要？其根本原因在于自然语言本身的模糊性、省略性和指代性。

1. 代词指代 (Anaphora Resolution)：如前例中的 "他", "它", "他们", "这个", "那个" 等，这些词语的语义完全依赖于前文所提及的实体。
2. 省略 (Ellipsis)：用户在对话中为了简洁，常常省略掉已在上下文中出现过的谓语、宾语甚至主语。例如，用户问完 "iPhone 15 和 iPhone 14 有什么区别？" 后，可能会接着问 "电池续航呢？" 这里的 "电池续航" 隐含了 "iPhone 15 和 iPhone 14 的电池续航有什么区别？"。
3. 隐式主题 (Implicit Topic)：有时用户会突然切换话题，但新话题的理解可能仍然依赖于旧话题的某些属性。或者，用户只是在旧话题上进行更深层次的探索，但没有明确重复主题。
4. 术语简化/缩写 (Term Simplification/Abbreviation)：在专业领域，用户可能会使用内部术语或缩写，这些缩写可能在特定上下文中才有意义。
5. 不完整的问题 (Incomplete Questions)：例如 "告诉我更多信息" 或 "下一步是什么？" 这些都无法独立理解。

这些语言现象使得系统在没有上下文的情况下，无法准确地解析用户意图。CQE通过系统性地处理这些情况，将原始查询转化为一个语义完整、信息丰富的查询，从而弥补了人机交互中的这一鸿沟。

3. CQE核心概念与系统架构

要实现上下文查询扩展，我们需要一套完整的系统来管理会话状态、表示上下文信息并执行扩展逻辑。

3.1 会话管理 (Session Management)

任何多轮对话系统都必须能够识别和跟踪单个用户与系统之间的连续交互。一个“会话”通常定义为从用户发起第一个查询到对话结束（例如，用户长时间未响应，或明确结束对话）的一系列对话回合。

会话管理主要涉及以下方面：

• 会话ID (Session ID)：唯一标识一个会话。
• 会话状态 (Session State)：存储当前会话的各种信息，包括历史查询、系统响应、识别出的实体、意图、用户偏好等。
• 会话超时 (Session Timeout)：定义一个会话在多长时间不活跃后被视为结束。

3.2 上下文表示 (Context Representation)

如何有效地存储和表示历史会话信息是CQE的关键。不同的表示方法适用于不同的CQE技术。

上下文表示方法	描述	优点	缺点	适用CQE方法
原始文本序列	存储过去N个对话回合的完整文本（用户查询和系统响应）。	简单直观，保留原始信息。	信息量大，提取关键信息困难。	规则匹配、基于序列的深度学习模型。
关键词/短语列表	从历史文本中提取关键的命名实体、名词短语或重要谓词。	信息密度高，易于匹配。	丢失语义关系和上下文语境。	规则匹配、词汇相似性扩展。
结构化槽位 (Slots)	将历史对话解析为预定义的槽位-值对，如 { "entity": "Elon Musk", "intent": "查询人物信息" }。	语义清晰，易于程序化处理。	依赖预定义模式，对复杂对话支持有限。	规则匹配、知识图谱查询。
上下文向量 (Context Vector)	使用词嵌入、句子嵌入或更高级的对话编码器（如BERT的[CLS] token输出）将整个上下文编码为一个稠密向量。	捕获语义关系，适用于深度学习。	可解释性差，需要大量训练数据。	神经网络模型。
混合表示	结合上述多种方法，例如，使用结构化槽位存储核心实体和意图，同时保留原始文本序列作为回退或补充。	兼顾效率和语义丰富性。	实现复杂。	所有方法，根据需要选择。

3.3 查询理解 (Query Understanding)

在进行上下文扩展之前，首先需要对当前用户输入的原始查询进行初步理解。这包括：

• 分词 (Tokenization)：将查询文本分解为有意义的词单元。
• 词性标注 (Part-of-Speech Tagging, POS)：识别每个词的词性（名词、动词、代词等）。
• 命名实体识别 (Named Entity Recognition, NER)：识别查询中的专有名词，如人名、地名、组织名、日期等。
• 意图识别 (Intent Recognition)：判断用户查询的整体意图（例如，查询事实、比较、导航等）。
• 语义角色标注 (Semantic Role Labeling, SRL)：识别句子中谓词的论元（谁做了什么，对谁做，在哪里做）。

这些初始的理解结果将作为CQE的输入，帮助系统判断查询中哪些部分需要扩展，以及如何进行扩展。

4. 上下文查询扩展的物理细节与实现技术

现在，我们深入到CQE的具体实现技术。我们将从简单的规则方法开始，逐步过渡到复杂的机器学习和深度学习模型。

4.1 A. 基于规则/启发式扩展 (Rule-Based/Heuristic Expansion)

这是最直接、也是最早期的CQE方法。它依赖于预定义的语言规则和模式来识别并解决指代、省略等问题。

4.1.1 代词指代消解 (Pronoun Resolution)

这是CQE中最常见的问题之一。系统需要识别代词，并将其替换为上下文中最近的、最可能指代的实体。

规则示例：

1. 识别代词：他, 她, 它, 他们, 它们 等。
2. 向前查找：在最近的N个对话回合中，查找与代词性别、单复数匹配的命名实体（特别是主语或宾语）。
3. 优先顺序：通常优先选择最近的命名实体，或者根据句法角色（例如，上一个句子的主语通常是代词的最佳指代对象）。

Python 代码示例：使用 spaCy 进行简单的代词消解

这个示例将展示一个非常简化的代词消解逻辑。在实际应用中，代词消解是一个复杂的NLP任务，通常需要专门的模型。这里我们仅用一个启发式规则来演示CQE的思路。

import spacy

# 加载spaCy英文模型
# python -m spacy download en_core_web_sm
nlp = spacy.load("en_core_web_sm")

def resolve_pronoun_simple(current_query: str, history_context: list[dict]) -> str:
    """
    使用简单的启发式规则解决代词指代问题。
    假设历史上下文中最后一个用户查询包含一个命名实体，
    当前查询中的代词 'he' 或 'she' 指代该实体。

    Args:
        current_query (str): 当前用户查询。
        history_context (list[dict]): 历史会话列表，每个元素是 {"role": "user/system", "text": "..."}。

    Returns:
        str: 扩展后的查询。
    """
    doc_current = nlp(current_query)

    # 查找当前查询中的代词
    pronouns_to_resolve = []
    for token in doc_current:
        if token.pos_ == "PRON" and token.text.lower() in ["he", "she", "it", "him", "her"]:
            pronouns_to_resolve.append(token)

    if not pronouns_to_resolve:
        return current_query # 没有需要消解的代词

    # 从历史上下文中提取可能的指代对象
    potential_antecedent = None

    # 遍历历史上下文，从最近的对话开始查找命名实体
    for turn in reversed(history_context):
        if turn["role"] == "user": # 通常代词指代的是用户提到的实体
            doc_history = nlp(turn["text"])
            for ent in doc_history.ents:
                # 假设我们只关心人名和组织名作为代词指代对象
                if ent.label_ in ["PERSON", "ORG"]:
                    potential_antecedent = ent.text
                    break
            if potential_antecedent:
                break # 找到最近的实体，停止查找

    if potential_antecedent:
        # 替换查询中的代词
        expanded_query = current_query
        for pronoun_token in pronouns_to_resolve:
            # 这是一个非常简化的替换，可能不考虑格和语态
            # 实际的代词消解会更复杂，需要考虑词形变化
            if pronoun_token.text.lower() in ["he", "him"] and nlp(potential_antecedent)[0].gender == "MASCULINE":
                 expanded_query = expanded_query.replace(pronoun_token.text, potential_antecedent, 1)
            elif pronoun_token.text.lower() in ["she", "her"] and nlp(potential_antecedent)[0].gender == "FEMININE":
                 expanded_query = expanded_query.replace(pronoun_token.text, potential_antecedent, 1)
            # 对于 'it'，可以替换为最近的非人实体
            elif pronoun_token.text.lower() == "it" and nlp(potential_antecedent)[0].label_ != "PERSON":
                 expanded_query = expanded_query.replace(pronoun_token.text, potential_antecedent, 1)
            else: # 如果无法判断性别或类型，直接替换
                 expanded_query = expanded_query.replace(pronoun_token.text, potential_antecedent, 1)

        return expanded_query
    else:
        return current_query

# 示例用法
history_1 = [
    {"role": "user", "text": "Who is Elon Musk?"},
    {"role": "system", "text": "Elon Musk is a business magnate and investor. He is the founder, chairman, CEO, and CTO of SpaceX; angel investor, CEO, and product architect of Tesla, Inc.; owner and chairman of X (formerly Twitter); and founder of The Boring Company, XAI, and Neuralink."},
]
query_1 = "What companies did he found?"
expanded_query_1 = resolve_pronoun_simple(query_1, history_1)
print(f"原始查询: {query_1}")
print(f"扩展后查询: {expanded_query_1}n")

history_2 = [
    {"role": "user", "text": "Tell me about Marie Curie."},
    {"role": "system", "text": "Marie Curie was a Polish and naturalized-French physicist and chemist who conducted pioneering research on radioactivity."},
]
query_2 = "What awards did she win?"
expanded_query_2 = resolve_pronoun_simple(query_2, history_2)
print(f"原始查询: {query_2}")
print(f"扩展后查询: {expanded_query_2}n")

history_3 = [
    {"role": "user", "text": "What is the capital of France?"},
    {"role": "system", "text": "The capital of France is Paris."},
]
query_3 = "And what is its population?"
expanded_query_3 = resolve_pronoun_simple(query_3, history_3)
print(f"原始查询: {query_3}")
print(f"扩展后查询: {expanded_query_3}n")

# 注意：spaCy的性别判断在en_core_web_sm模型中不是直接提供的，
# 需要更复杂的模型或规则来推断。上述代码中的性别判断是示意性的。
# 实际应用中，'it'的指代消解也更复杂。

输出示例 (实际运行时可能会根据spaCy版本和模型略有差异，但逻辑一致):

原始查询: What companies did he found?
扩展后查询: What companies did Elon Musk found?

原始查询: What awards did she win?
扩展后查询: What awards did Marie Curie win?

原始查询: And what is its population?
扩展后查询: And what is Paris's population?

4.1.2 省略补全 (Ellipsis Resolution)

当用户省略了查询中的某些成分时，系统需要从上下文中推断并补全。

规则示例：

1. 识别不完整的查询：例如，只包含名词短语或疑问词的查询 ("电池续航呢？", "价格？")。
2. 从最近的对话中提取谓词和/或宾语：例如，如果上一个查询是 "iPhone 15 和 iPhone 14 有什么区别？"，那么 "电池续航呢？" 可以扩展为 "iPhone 15 和 iPhone 14 的电池续航有什么区别？"。

4.1.3 隐式主题推断 (Implicit Topic Inference)

当用户没有明确提及主题时，从最近的上下文推断当前查询的主题。

规则示例：

1. 提取上下文中的核心实体或主题词。
2. 将这些核心实体添加到当前查询中，作为前缀或修饰语。

局限性： 规则方法虽然易于理解和实现，但难以覆盖所有复杂的语言现象，且维护成本高，对新模式的适应性差。

4.2 B. 基于词汇和语义相似性扩展 (Lexical and Semantic Similarity-Based Expansion)

这种方法利用词嵌入或文档嵌入技术来捕捉词语和文本之间的语义关系，从而进行更智能的扩展。

4.2.1 关键词提取与扩展 (Keyword Extraction and Expansion)

从历史会话中提取重要的关键词（命名实体、关键名词短语），然后将这些关键词加入到当前查询中。

方法：

1. TF-IDF：识别历史会话中重要性较高的词语。
2. TextRank/PageRank：基于图的算法，对文本中的词语进行排序，识别关键词。
3. 命名实体识别 (NER)：直接提取人名、地名、组织名等实体作为扩展词。

4.2.2 词嵌入与向量空间模型 (Word Embeddings & Vector Space Models)

利用预训练的词嵌入模型（如Word2Vec, GloVe, FastText）将词语映射到高维向量空间。通过计算向量之间的余弦相似度，可以找到与当前查询或上下文语义相似的词语进行扩展。

方法：

1. 上下文词语语义增强：识别当前查询中的关键次，并在上下文中寻找与这些词语义相关的词语。
2. 查询与上下文的语义融合：将当前查询的向量和上下文的向量进行组合（例如，平均、连接），形成一个代表“当前意图+上下文”的新向量，然后在这个新向量空间中寻找最匹配的文档。

Python 代码示例：使用 Gensim 和 Word2Vec 进行语义扩展

这里我们将演示一个简化的场景：用户询问某个主题，然后切换到另一个相关主题，我们希望用第一个主题的关键词来增强第二个查询。

from gensim.models import KeyedVectors
from gensim.downloader import load
import numpy as np

# 加载预训练的Word2Vec模型
# 第一次运行可能需要下载，会比较慢
# model_path = load("word2vec-google-news-300", return_path=True)
# word_vectors = KeyedVectors.load_word2vec_format(model_path, binary=True)
# 为简化示例，我们手动创建一个简化的词向量字典
# 实际应用中请加载大型预训练模型
word_vectors_dict = {
    "machine": np.array([0.1, 0.2, 0.3]),
    "learning": np.array([0.2, 0.3, 0.4]),
    "deep": np.array([0.3, 0.4, 0.5]),
    "neural": np.array([0.4, 0.5, 0.6]),
    "network": np.array([0.5, 0.6, 0.7]),
    "ai": np.array([0.6, 0.7, 0.8]),
    "applications": np.array([0.7, 0.8, 0.9]),
    "examples": np.array([0.8, 0.9, 1.0]),
    "about": np.array([0.0, 0.1, 0.2]),
    "tell": np.array([0.1, 0.0, 0.1]),
    "me": np.array([0.2, 0.1, 0.0]),
    "how": np.array([0.3, 0.2, 0.1]),
    "is": np.array([0.4, 0.3, 0.2]),
    "it": np.array([0.5, 0.4, 0.3]),
    "different": np.array([0.6, 0.5, 0.4]),
    "from": np.array([0.7, 0.6, 0.5]),
    "classification": np.array([0.8, 0.7, 0.6]),
    "regression": np.array([0.9, 0.8, 0.7]),
}

class MockWordVectors:
    """模拟gensim KeyedVectors 接口"""
    def __init__(self, vectors_dict):
        self.vectors_dict = vectors_dict
        self.vector_size = len(next(iter(vectors_dict.values()))) if vectors_dict else 0

    def __contains__(self, word):
        return word in self.vectors_dict

    def __getitem__(self, word):
        return self.vectors_dict.get(word, np.zeros(self.vector_size)) # 如果词不在字典中，返回零向量

    def most_similar(self, positive=[], negative=[], topn=10):
        # 这是一个非常简化的most_similar实现，仅用于演示
        if not positive:
            return []

        target_vector = np.mean([self.vectors_dict.get(w, np.zeros(self.vector_size)) for w in positive if w in self.vectors_dict], axis=0)

        similarities = []
        for word, vec in self.vectors_dict.items():
            if word not in positive and word not in negative:
                similarity = np.dot(target_vector, vec) / (np.linalg.norm(target_vector) * np.linalg.norm(vec) + 1e-8)
                similarities.append((word, similarity))

        similarities.sort(key=lambda x: x[1], reverse=True)
        return similarities[:topn]

word_vectors = MockWordVectors(word_vectors_dict)

def get_query_vector(query: str, wv_model) -> np.ndarray:
    """将查询中的词向量平均，得到查询向量"""
    tokens = [token.lower() for token in query.split() if token.lower() in wv_model]
    if not tokens:
        return np.zeros(wv_model.vector_size)

    vectors = [wv_model[token] for token in tokens]
    return np.mean(vectors, axis=0)

def contextual_semantic_expansion(current_query: str, history_context: list[str], wv_model, top_k_terms: int = 2) -> str:
    """
    使用词向量进行上下文语义扩展。
    从历史上下文中提取关键词，并找到与当前查询语义最相似的词进行扩展。

    Args:
        current_query (str): 当前用户查询。
        history_context (list[str]): 历史会话文本列表 (例如，['Tell me about machine learning.', 'Give me examples of its applications.'])。
        wv_model: 词向量模型 (如 gensim.models.KeyedVectors)。
        top_k_terms (int): 从上下文中选择最相似的K个词进行扩展。

    Returns:
        str: 扩展后的查询。
    """
    # 1. 提取历史上下文中的核心词汇
    context_tokens = []
    for turn_text in history_context:
        context_tokens.extend([token.lower() for token in turn_text.split() if token.lower() in wv_model])

    # 移除停用词，这里简单处理
    stop_words = {"about", "tell", "me", "is", "it", "how", "what", "and", "the", "a", "an", "of", "to", "in", "for", "on", "with", "as"}
    context_tokens = [token for token in context_tokens if token not in stop_words]

    if not context_tokens:
        return current_query

    # 2. 计算当前查询的向量
    current_query_vec = get_query_vector(current_query, wv_model)

    if np.all(current_query_vec == 0): # 如果当前查询没有可用的词向量
        return current_query

    # 3. 找到上下文中与当前查询最相关的词
    # 我们可以通过计算每个上下文词与当前查询向量的相似度
    context_word_similarities = {}
    for token in set(context_tokens): # 使用set去重
        if token in wv_model:
            sim = np.dot(current_query_vec, wv_model[token]) / (np.linalg.norm(current_query_vec) * np.linalg.norm(wv_model[token]) + 1e-8)
            context_word_similarities[token] = sim

    # 排序并选择top K个词
    sorted_context_words = sorted(context_word_similarities.items(), key=lambda item: item[1], reverse=True)

    expansion_terms = [word for word, sim in sorted_context_words[:top_k_terms] if sim > 0.3] # 设定一个相似度阈值

    # 4. 将扩展词添加到当前查询中
    if expansion_terms:
        # 简单地将扩展词添加到查询开头或结尾
        # 更复杂的策略是插入到查询的特定位置，或重写查询
        expanded_query = " ".join(expansion_terms) + " " + current_query
        return expanded_query
    else:
        return current_query

# 示例用法
history_context_1 = [
    "Tell me about machine learning.", 
    "Give me examples of its applications."
]
query_1 = "And how about deep learning?"
expanded_query_1 = contextual_semantic_expansion(query_1, history_context_1, word_vectors)
print(f"历史上下文: {history_context_1}")
print(f"原始查询: {query_1}")
print(f"扩展后查询: {expanded_query_1}n")

history_context_2 = [
    "What are the benefits of cloud computing?",
    "Tell me about AWS services."
]
query_2 = "And Azure?"
expanded_query_2 = contextual_semantic_expansion(query_2, history_context_2, word_vectors)
print(f"历史上下文: {history_context_2}")
print(f"原始查询: {query_2}")
print(f"扩展后查询: {expanded_query_2}n")

输出示例 (基于模拟词向量和简化逻辑):

历史上下文: ['Tell me about machine learning.', 'Give me examples of its applications.']
原始查询: And how about deep learning?
扩展后查询: learning machine And how about deep learning?

历史上下文: ['What are the benefits of cloud computing?', 'Tell me about AWS services.']
原始查询: And Azure?
扩展后查询: services And Azure?

说明：
上述 MockWordVectors 及其 most_similar 方法是一个高度简化的模拟。在实际生产环境中，您会加载大型预训练模型如 gensim.downloader.load("glove-wiki-gigaword-100") 或 fasttext.load_facebook_vectors()。contextual_semantic_expansion 函数演示了如何从历史上下文中提取潜在的扩展词，并根据它们与当前查询的语义相似性进行选择。这种方法比纯规则更具通用性，能捕捉到词汇层面的语义关联。

4.3 C. 基于神经网络的扩展 (Neural Network-Based Expansion)

随着深度学习的兴起，基于神经网络的方法在CQE中展现出强大的能力，尤其是在处理复杂上下文和生成自然语言方面。

4.3.1 序列到序列 (Seq2Seq) 模型

Seq2Seq模型（Encoder-Decoder架构）非常适合将输入序列（当前查询 + 上下文）映射到输出序列（扩展后的查询）。

架构：

• 编码器 (Encoder)：接收当前查询和历史上下文（通常是拼接在一起，或者分别编码再合并）作为输入。编码器可以是RNNs (如LSTMs, GRUs) 或 Transformers 的变体。它将输入序列编码成一个固定维度的上下文向量。
• 解码器 (Decoder)：接收编码器输出的上下文向量，并逐步生成扩展后的查询。解码器通常也是一个RNN或Transformer，并使用注意力机制来关注编码器输出的不同部分。

训练数据：
训练Seq2Seq模型需要大量的(上下文, 原始查询) -> 扩展查询对。这些数据通常通过人工标注、众包或启发式规则从现有对话数据中生成。

输入格式示例：
[CONTEXT_START] <history_turn_1> <history_turn_2> [CONTEXT_END] [QUERY_START] <current_query> [QUERY_END]
输出：<expanded_query>

4.3.2 Transformer 模型 (BERT, GPT-like)

Transformer模型（特别是预训练的语言模型如BERT, GPT-2/3/4, T5）在处理上下文和生成文本方面表现卓越。它们可以以多种方式应用于CQE：

1. 文本补全/生成 (Text Completion/Generation)：

   • GPT-like模型：可以将 [CONTEXT] <历史对话> [QUERY] <当前查询> 作为Prompt，让模型生成最合理的扩展或重写后的查询。
   • T5模型：可以被微调为 task: expand query context: <历史对话> query: <当前查询> -> <扩展查询> 的形式。

2. 掩码语言模型 (Masked Language Model, MLM) 填空：

   • 对于BERT等MLM模型，我们可以尝试识别当前查询中可能需要扩展的“槽位”（例如，代词），然后用 [MASK] 标记它们。
   • 将 [CLS] <current_query_with_masks> [SEP] <context_string> [SEP] 作为输入，让模型预测 [MASK] 位置的最优词。

3. 重排序 (Re-ranking)：

   • 系统可以生成多个候选的扩展查询（例如，通过规则或语义相似性方法）。
   • 使用Transformer模型（例如，BERT的交叉编码器架构）来评估每个候选扩展查询与上下文的匹配程度，并选择得分最高的作为最终扩展。

Python 代码示例：概念性地展示 Transformer 输入准备 (使用 transformers 库)

这里我们不进行模型训练，而是展示如何为Transformer模型准备输入，以模拟文本生成或填空任务。

from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForMaskedLM
import torch

# 假设使用一个简单的GPT-2模型进行文本生成
# tokenizer = AutoTokenizer.from_pretrained("gpt2")
# model = AutoModelForCausalLM.from_pretrained("gpt2")

# 为了避免下载大模型，我们模拟一个tokenizer和模型行为
class MockTokenizer:
    def __init__(self):
        self.eos_token_id = 100
        self.pad_token_id = 50
    def encode(self, text, return_tensors="pt"):
        # 简化：将文本简单映射为数字ID
        tokens = [ord(c) for c in text if c.isalpha() or c.isspace()]
        if return_tensors == "pt":
            return torch.tensor([tokens])
        return tokens
    def decode(self, token_ids):
        # 简化：将数字ID映射回字符
        return "".join([chr(id) for id in token_ids if id < 128]) # 假设只处理基本ASCII

class MockModelForCausalLM:
    def generate(self, input_ids, max_length, num_return_sequences=1, do_sample=False, temperature=1.0):
        # 模拟生成：简单地拼接一些预设的扩展
        if "he" in self.tokenizer.decode(input_ids[0]):
            return self.tokenizer.encode("Elon Musk founded many companies like Tesla and SpaceX.")
        elif "she" in self.tokenizer.decode(input_ids[0]):
            return self.tokenizer.encode("Marie Curie won two Nobel Prizes.")
        return self.tokenizer.encode("This is a generated expansion.")

tokenizer = MockTokenizer()
model = MockModelForCausalLM() # 实际使用时替换为 AutoModelForCausalLM.from_pretrained("gpt2")
model.tokenizer = tokenizer # 模拟模型内部需要tokenizer

def prepare_transformer_input_for_generation(current_query: str, history_context: list[str], tokenizer) -> str:
    """
    为Transformer生成模型准备输入Prompt。
    Args:
        current_query (str): 当前用户查询。
        history_context (list[str]): 历史会话文本列表。
        tokenizer: Transformer模型的tokenizer。
    Returns:
        str: 准备好的Prompt字符串。
    """
    context_string = "n".join(history_context)
    # 构建Prompt，引导模型进行扩展
    prompt = f"Previous conversation:n{context_string}nUser asks: {current_query}nExpanded query:"
    return prompt

def generate_expanded_query_with_transformer(current_query: str, history_context: list[str], tokenizer, model) -> str:
    """
    使用Transformer生成模型生成扩展查询。
    """
    prompt = prepare_transformer_input_for_generation(current_query, history_context, tokenizer)
    input_ids = tokenizer.encode(prompt, return_tensors="pt")

    # 实际模型会根据输入生成文本
    # 这里我们使用模拟模型的generate方法
    with torch.no_grad():
        output_ids = model.generate(input_ids, max_length=len(input_ids[0]) + 50, num_return_sequences=1, do_sample=False)

    generated_text = tokenizer.decode(output_ids[0])

    # 提取生成的扩展查询部分
    # 这部分需要根据实际模型输出格式进行解析
    # 简单地截取掉Prompt部分
    if generated_text.startswith(prompt):
        return generated_text[len(prompt):].strip()
    return generated_text.strip()

# 示例用法
history_context_1 = [
    "User: Who is Elon Musk?", 
    "System: Elon Musk is a tech entrepreneur."
]
query_1 = "What companies did he found?"
expanded_query_1 = generate_expanded_query_with_transformer(query_1, history_context_1, tokenizer, model)
print(f"原始查询: {query_1}")
print(f"扩展后查询 (生成模型模拟): {expanded_query_1}n")

history_context_2 = [
    "User: Tell me about Marie Curie.",
    "System: Marie Curie was a Polish and naturalized-French physicist and chemist."
]
query_2 = "What awards did she win?"
expanded_query_2 = generate_expanded_query_with_transformer(query_2, history_context_2, tokenizer, model)
print(f"原始查询: {query_2}")
print(f"扩展后查询 (生成模型模拟): {expanded_query_2}n")

输出示例 (基于模拟模型行为):

原始查询: What companies did he found?
扩展后查询 (生成模型模拟): Elon Musk founded many companies like Tesla and SpaceX.

原始查询: What awards did she win?
扩展后查询 (生成模型模拟): Marie Curie won two Nobel Prizes.

说明：
这里 MockTokenizer 和 MockModelForCausalLM 仅用于演示 Transformer 模型如何接收上下文和查询作为输入，并概念性地生成扩展。在实际应用中，您将使用Hugging Face transformers 库加载如 gpt2、t5-small 等预训练模型，并进行微调或直接利用其生成能力。Transformer模型在处理长上下文和生成流畅、语义准确的文本方面具有显著优势，但需要大量的计算资源和训练数据。

4.4 D. 知识图谱集成 (Knowledge Graph Integration)

知识图谱 (Knowledge Graph, KG) 是一种结构化的知识表示，它以实体（Entities）和关系（Relations）的形式存储信息。将知识图谱集成到CQE中，可以提供更精确和语义丰富的扩展。

方法：

1. 实体链接 (Entity Linking)：

   • 识别当前查询和历史上下文中的命名实体。
   • 将这些实体链接到知识图谱中的对应节点。
   • 例如，将 "Elon Musk" 链接到KG中的 Person:ElonMusk 节点。

2. 关系和属性扩展 (Relation and Attribute Expansion)：

   • 一旦实体被链接，就可以利用知识图谱中与该实体相关的关系和属性来扩展查询。
   • 例如，如果上下文实体是 Person:ElonMusk，当前查询是 "他的公司"，系统可以查询KG中 Person:ElonMusk 的 foundedCompany 关系，获取 Tesla、SpaceX 等公司，并将其添加到查询中。

3. 模式补全 (Schema Completion)：

   • 如果上下文建立了某种查询模式（例如，查询某个类型的属性），知识图谱可以提供该类型所有可能的属性，用于引导用户或补全查询。

Python 代码示例：概念性地展示知识图谱查询

这里我们不实现一个完整的知识图谱，而是用一个Python字典模拟部分KG数据，并演示如何利用它进行查询扩展。

# 模拟一个简化的知识图谱
knowledge_graph = {
    "Elon Musk": {
        "type": "Person",
        "founded_companies": ["Tesla", "SpaceX", "The Boring Company", "Neuralink", "XAI"],
        "nationality": "South African, Canadian, American",
        "net_worth": "200B USD",
    },
    "Tesla": {
        "type": "Company",
        "founder": "Elon Musk",
        "products": ["Electric Vehicles", "Battery Storage", "Solar Panels"],
        "headquarters": "Austin, Texas",
    },
    "Marie Curie": {
        "type": "Person",
        "awards": ["Nobel Prize in Physics", "Nobel Prize in Chemistry"],
        "nationality": "Polish, French",
        "field": "Physics, Chemistry",
    },
    "Paris": {
        "type": "City",
        "country": "France",
        "population": "2.14 million (2020)",
        "famous_landmarks": ["Eiffel Tower", "Louvre Museum"],
    }
}

def kg_based_expansion(current_query: str, history_context: list[str], kg: dict) -> str:
    """
    基于知识图谱进行上下文查询扩展。
    假设历史上下文中提到了一个实体，当前查询试图获取该实体的属性。

    Args:
        current_query (str): 当前用户查询。
        history_context (list[str]): 历史会话文本列表。
        kg (dict): 模拟的知识图谱。

    Returns:
        str: 扩展后的查询。
    """
    # 1. 从历史上下文中识别核心实体
    # 实际中会使用NER和实体链接，这里简化为查找KG中的实体名
    context_entity = None
    for turn_text in history_context:
        for entity_name in kg.keys():
            if entity_name.lower() in turn_text.lower():
                context_entity = entity_name
                break
        if context_entity:
            break

    if not context_entity:
        return current_query

    # 2. 分析当前查询，判断意图（这里简化为关键词匹配）
    expanded_query = current_query

    if "companies" in current_query.lower() and "founded_companies" in kg[context_entity]:
        # 假设我们识别到 "companies" 意图，并可以在KG中找到该属性
        companies = ", ".join(kg[context_entity]["founded_companies"])
        expanded_query = f"{current_query} (related to {context_entity}'s founded companies: {companies})"
    elif "awards" in current_query.lower() and "awards" in kg[context_entity]:
        awards = ", ".join(kg[context_entity]["awards"])
        expanded_query = f"{current_query} (related to {context_entity}'s awards: {awards})"
    elif "population" in current_query.lower() and "population" in kg[context_entity]:
        population = kg[context_entity]["population"]
        expanded_query = f"{current_query} (related to {context_entity}'s population: {population})"

    return expanded_query

# 示例用法
history_kg_1 = ["User: Who is Elon Musk?"]
query_kg_1 = "What companies did he found?"
expanded_kg_query_1 = kg_based_expansion(query_kg_1, history_kg_1, knowledge_graph)
print(f"原始查询: {query_kg_1}")
print(f"扩展后查询 (KG模拟): {expanded_kg_query_1}n")

history_kg_2 = ["User: Tell me about Marie Curie."]
query_kg_2 = "What awards did she win?"
expanded_kg_query_2 = kg_based_expansion(query_kg_2, history_kg_2, knowledge_graph)
print(f"原始查询: {query_kg_2}")
print(f"扩展后查询 (KG模拟): {expanded_kg_query_2}n")

history_kg_3 = ["User: What is the capital of France? System: The capital of France is Paris."]
query_kg_3 = "And what is its population?"
expanded_kg_query_3 = kg_based_expansion(query_kg_3, history_kg_3, knowledge_graph)
print(f"原始查询: {query_kg_3}")
print(f"扩展后查询 (KG模拟): {expanded_kg_query_3}n")

输出示例 (基于模拟KG):

原始查询: What companies did he found?
扩展后查询 (KG模拟): What companies did he found? (related to Elon Musk's founded companies: Tesla, SpaceX, The Boring Company, Neuralink, XAI)

原始查询: What awards did she win?
扩展后查询 (KG模拟): What awards did she win? (related to Marie Curie's awards: Nobel Prize in Physics, Nobel Prize in Chemistry)

原始查询: And what is its population?
扩展后查询 (KG模拟): And what is its population? (related to Paris's population: 2.14 million (2020))

说明：
知识图谱方法能够提供高度精确的语义扩展，因为它直接利用了结构化的事实信息。其挑战在于构建和维护大规模的、高质量的知识图谱，以及实现准确的实体链接和关系抽取。

5. 系统设计与实施考量

在实际部署CQE系统时，除了核心算法，还需要考虑一系列工程和产品问题。

5.1 数据收集与标注

• 对话日志：收集真实的或模拟的用户与系统的对话日志，这是训练和评估的基础。
• 人工标注：对于监督学习方法（如Seq2Seq），需要人工标注 (原始查询, 上下文) -> 扩展查询 的数据集。这通常是耗时且昂贵的。
• 启发式生成：通过规则或模板自动生成训练数据，然后人工审查和修正，以降低成本。

5.2 评估指标

• 离线评估 (Offline Evaluation)：
  • 词汇匹配度：BLEU, ROUGE (用于评估生成文本与参考文本的相似度)。
  • 语义相似度：使用词嵌入或句子嵌入计算扩展查询与理想查询的向量相似度。
  • 特定任务指标：如果CQE是为搜索引擎服务，可以评估使用扩展查询后，搜索结果的MRR (Mean Reciprocal Rank), NDCG (Normalized Discounted Cumulative Gain) 等指标。
• 在线评估 (Online Evaluation)：
  • A/B测试：将有CQE和无CQE的系统分别提供给不同用户组，比较用户满意度、任务完成率、会话深度等。
  • 用户反馈：直接收集用户对系统响应质量的反馈。

5.3 性能与延迟

CQE通常是实时进行的，因此对延迟敏感。

• 模型选择：权衡模型的复杂度和推理速度。轻量级模型或模型蒸馏可以帮助降低延迟。
• 并行化：利用GPU加速深度学习模型的推理。
• 缓存机制：缓存常见的上下文和查询对的扩展结果。

5.4 可扩展性与鲁棒性

• 会话状态存储：分布式存储系统（如Redis, Cassandra）用于管理大量并发会话的状态。
• 处理OOV (Out-Of-Vocabulary) 词汇：使用FastText等支持字符级嵌入的模型，或回退到基于规则的方法。
• 处理噪声输入：对用户输入进行拼写纠错、文本标准化等预处理。

5.5 伦理考量

• 数据隐私：会话历史包含敏感信息，必须严格遵守数据隐私法规，进行匿名化处理和访问控制。
• 偏见：训练数据中的偏见可能导致CQE系统产生带有偏见的扩展，影响结果的公平性。需要仔细审计训练数据和模型输出。

6. 端到端工作流示例

让我们通过一个具体的例子，串联起CQE的整个工作流程。

场景： 用户在一个电商客服聊天机器人中查询商品信息。

1. 用户查询 1 (U1): "告诉我关于iPhone 15的信息。"

   • 查询理解： 识别实体 "iPhone 15"，意图 "查询商品信息"。
   • 会话管理： 启动新会话，存储 U1。
   • 系统响应 1 (S1): "iPhone 15 有多种型号，比如 Pro 和 Pro Max，搭载 A17 芯片，支持动态岛功能。"
   • 上下文存储： 提取 "iPhone 15", "Pro", "Pro Max", "A17 芯片", "动态岛" 等实体和关键词。

2. 用户查询 2 (U2): "它的价格是多少？"

   • 查询理解： 识别代词 "它"，意图 "查询价格"。
   • CQE 阶段：
     • 代词消解 (规则/语义)： "它" 指代的是会话中最近且最核心的实体 "iPhone 15"。
     • 省略补全 (规则/语义)： "价格是多少？" 结合 "iPhone 15" 补全为 "iPhone 15 的价格是多少？"。
     • 知识图谱增强 (可选)： 如果KG中有 "iPhone 15" 的价格信息，可以进一步增强查询，例如 "查询 iPhone 15 各型号的价格"。
     • 扩展后的查询： "iPhone 15 的价格是多少？"
   • 系统响应 2 (S2): "iPhone 15 系列起售价为 $799，Pro 售价为 $999，Pro Max 售价为 $1199。"
   • 上下文存储： 存储 S2，并更新会话中的实体和属性。

3. 用户查询 3 (U3): "和 iPhone 14 比较一下续航？"

   • 查询理解： 识别实体 "iPhone 14"，意图 "比较"，关键词 "续航"。
   • CQE 阶段：
     • 隐式主题推断 (语义/神经网络)： 尽管没有明确提及 "iPhone 15"，但上下文的核心实体仍是 "iPhone 15"。当前查询的比较对象是 "iPhone 14"，比较属性是 "续航"。
     • 扩展后的查询： "比较 iPhone 15 和 iPhone 14 的电池续航？"
   • 系统响应 3 (S3): "iPhone 15 Pro 的电池续航比 iPhone 14 Pro 略有提升，具体取决于使用情况…"
   • 上下文存储： 存储 S3。

通过这个例子，我们可以看到CQE如何在多轮对话中动态地调整和增强查询，从而使系统能够连贯、准确地响应用户的每一次交互。

7. 总结与展望

上下文查询扩展是构建智能对话系统和高级信息检索系统不可或缺的一环。它通过深度挖掘会话历史，将表面上模糊或不完整的查询转化为语义清晰、信息完整的查询，极大地提升了用户体验和系统性能。从基于规则的启发式方法，到利用词嵌入和知识图谱的语义方法，再到以Transformer为代表的深度学习模型，CQE的技术栈正在不断演进。

未来，CQE将继续朝着更智能、更自适应的方向发展，融合更多模态的上下文信息，并进一步提升对复杂人类语言现象的理解能力。它将是推动人机交互走向更自然、更高效的关键技术之一。