什么是 ‘Hypothetical Document Embeddings (HyDE)’ 的迭代版：在循环图中生成多个虚假文档以逼近真实召回

各位同仁，欢迎来到今天的讲座。我们今天将深入探讨信息检索领域的一个前沿话题：Hypothetical Document Embeddings (HyDE) 的迭代版本。具体来说，我们将聚焦于如何在循环中生成多个虚假（或称假设）文档，以期更精准地逼近真实的召回率。

在当今数据爆炸的时代，高效、准确地从海量信息中检索出用户所需的内容，是摆在我们面前的核心挑战之一。传统的关键词匹配、词袋模型（BoW）以及TF-IDF等方法，在处理语义鸿沟（semantic gap）时往往力不从心。用户输入的查询通常简洁而意图丰富，而文档则可能冗长且包含大量上下文信息。如何在两者之间建立起一座稳固的桥梁，是现代信息检索，尤其是密集检索（Dense Retrieval）所致力解决的问题。

HyDE，即“假设文档嵌入”，正是为解决这一问题而生的一种创新方法。它巧妙地利用大型语言模型（LLM）的生成能力，将简短的用户查询扩展为一个语义丰富、与真实文档结构相似的“假设文档”。这个假设文档随后被嵌入到一个向量空间中，并用于与真实文档的嵌入进行相似性搜索。然而，原始的HyDE方法，尽管效果显著，却也存在一个固有的局限性：它通常只生成一个假设文档。一个假设文档，即使生成质量再高，也可能无法完全捕获复杂查询的所有细微之处或多种可能的解释。

因此，我们今天的讨论将围绕一个更进一步的迭代策略展开：如何通过在循环中生成并利用多个假设文档，来更全面、更鲁棒地提升检索的召回能力。这不仅仅是简单地重复HyDE过程，更涉及策略性的生成、反馈与聚合机制，旨在从不同角度逼近用户查询的真实意图，从而在向量空间中覆盖更广的相关文档区域。

理解 HyDE 的基石：假设文档嵌入

在深入迭代版本之前，我们首先需要快速回顾一下HyDE的核心思想和工作原理。这为我们后续理解迭代的必要性和机制打下基础。

HyDE 的核心理念

HyHyDE的核心理念是：将用户查询（query）转换为一个“假设文档”（hypothetical document），这个假设文档在语义上与查询意图高度相关，但在结构和内容上更接近于实际的文档。然后，我们对这个假设文档进行向量嵌入，并用其在文档嵌入空间中进行相似性搜索。

为什么是假设文档？

1. 语义鸿沟弥合： 查询通常很短，缺乏上下文，而文档很长且信息丰富。直接将短查询嵌入到与长文档相同的向量空间中，往往会导致查询嵌入与文档嵌入在语义距离上存在偏差。假设文档通过模拟真实文档的结构和信息密度，有效地弥合了这一鸿沟。
2. 嵌入空间特性： 许多预训练的密集检索模型（如Contriever, DPR等）在文档层面的嵌入效果往往优于查询层面的嵌入。这是因为文档提供了更丰富的上下文信息，使得模型能够生成更稳定、更具区分度的表示。通过将查询转化为文档，我们能够利用这种优势。
3. 零样本能力： HyDE的强大之处在于，它使得一个预训练好的密集检索器（无需在查询-文档对上进行微调）能够有效地执行检索任务。LLM负责将查询转化为“理想”的文档形式，而检索器则负责找到与该“理想”文档最相似的真实文档。

HyDE 的工作流程

一个典型的HyDE流程包含以下几个关键步骤：

1. 用户查询输入： 用户提交一个自然语言查询，例如 "机器学习中的注意力机制是如何工作的？"
2. LLM 生成假设文档： 将用户查询作为提示（prompt）输入给一个大型语言模型（LLM）。LLM根据查询的意图，生成一个详细的、语义相关的、结构上类似于真实文档的文本。这个文本就是“假设文档”。
   • 示例假设文档： "这篇文档将详细解释机器学习领域中注意力机制的原理、发展历程及其在深度学习模型中的应用。它会涵盖注意力机制如何解决长序列依赖问题、其在Transformer架构中的核心作用，以及不同类型的注意力，如自注意力、多头注意力等。此外，还将探讨其计算复杂度、优缺点以及未来发展方向，并可能提及一些关键论文和实际案例。"
3. 假设文档嵌入： 使用一个预训练的文档嵌入模型（如BERT、RoBERTa、Contriever等）将生成的假设文档转换为一个高维向量。
4. 向量相似性搜索： 在预先嵌入并存储在向量数据库中的所有真实文档的向量空间中，使用假设文档的向量进行相似性搜索（例如，使用余弦相似度或内积）。
5. 返回检索结果： 根据相似度排名，返回最相关的真实文档给用户。

原始 HyDE 的局限性

尽管HyDE带来了显著的性能提升，但其原始形式也存在一些固有的局限性，这些局限性正是我们引入迭代策略的根本原因：

1. 单点覆盖问题： 一个复杂的查询可能包含多个子意图或存在多种合理解释。单个假设文档只能代表其中一种或有限的几种解释。这就像在一个广阔的湖泊中只用一根鱼竿垂钓，可能会错过大量潜在的鱼群。
   • 例如，查询 "AI 在医疗健康领域的应用和伦理问题" 既涉及技术应用，也涉及伦理考量。一个假设文档可能偏重技术，而忽略伦理。
2. LLM 幻觉风险： LLM在生成文本时有产生“幻觉”的风险，即生成与事实不符或不准确的信息。如果假设文档包含幻觉，那么基于它的检索结果也可能偏离目标。
3. 对提示的敏感性： 假设文档的质量高度依赖于LLM的提示工程。一个不佳的提示可能导致生成一个泛泛而谈或不够聚焦的假设文档。
4. 无法充分探索语义空间： 即使LLM生成了一个高质量的假设文档，它也仅仅是文档嵌入空间中的一个点。用户真正感兴趣的文档可能分布在一个更广阔的区域，或者由多个语义集群构成。

为了克服这些局限，提高检索的鲁棒性和召回率，我们迫切需要一种机制，能够从多个角度、以更全面的方式探索查询的语义空间。这正是“迭代版HyDE”所要解决的核心问题。

迭代 HyDE：超越单点覆盖

迭代HyDE的核心思想是：不满足于仅仅生成一个假设文档，而是通过一个循环过程，生成并利用多个假设文档来更全面地捕获查询的意图。这些文档可以并行生成，也可以通过反馈机制逐步精炼，其目的都是为了在向量空间中“撒下更大的网”，从而逼近更真实的召回率。

想象一下，你不是用一个固定位置的探照灯去寻找目标，而是使用多个探照灯从不同角度同时照射，或者根据第一次照射的结果调整探照灯的方向。

迭代的动机：为什么需要多份假设文档？

1. 多维度捕获： 复杂查询通常是多方面的。例如，“量子计算的硬件实现挑战与潜在应用”包含“硬件挑战”和“潜在应用”两个主要方面。单个假设文档很难同时深入这两个方面。生成多个假设文档，可以分别侧重于不同的方面。
2. 鲁棒性增强： 减少对单一LLM生成结果的依赖。如果某个假设文档存在偏差或幻觉，其他假设文档的正确性可以弥补，从而提高整体检索的鲁棒性。
3. 探索语义多样性： 即使是相同的查询，也可能存在多种合法的解释或不同的关键词组合方式。生成多个假设文档有助于探索这些语义变体，覆盖更广泛的相关文档。
4. 逼近真实召回： 真实世界中与查询相关的文档可能分布在向量空间中的多个语义集群中。单个假设文档的嵌入可能只会指向其中一个集群。多个假设文档的嵌入则有潜力同时指向多个相关集群，从而显著提高召回率。
5. 应对模糊查询： 对于开放性或模糊的查询，生成多个不同解释的假设文档有助于用户发现意想不到但有价值的信息。

迭代 HyDE 的通用架构

无论采用何种具体的迭代策略，迭代HyDE的通用架构都包含以下核心组件：

• 用户查询 (Q): 原始的用户输入。
• 大型语言模型 (LLM): 用于生成假设文档或重写查询。
• 文档嵌入器 (E_doc): 将文本（假设文档或真实文档）转换为向量。
• 向量数据库 (V_db): 存储所有真实文档的嵌入，并支持高效的相似性搜索。
• 迭代控制器/聚合器: 管理生成循环，并负责合并来自不同假设文档的检索结果。

下面，我们将探讨几种主要的迭代策略，并提供相应的代码示例。

迭代策略一：并行生成与结果聚合

这是最直接、最容易实现的迭代策略。其核心思想是：从原始查询出发，并行地生成多个独立的假设文档，对每个假设文档执行检索，然后将所有检索结果进行聚合。

机制描述

1. 多重假设文档生成： 使用原始查询作为提示，多次调用LLM（或通过一次调用请求LLM生成多个变体）来生成 N 个不同的假设文档 (H_1, H_2, ..., H_N)。为了鼓励多样性，可以在LLM调用时调整采样参数（如 temperature, top_k, top_p）或在提示中明确要求多样性。
2. 独立嵌入与检索： 对每个生成的假设文档 H_i，使用文档嵌入器 E_doc 生成其嵌入向量 v_i。然后，使用每个 v_i 在向量数据库 V_db 中独立执行相似性搜索，得到一个排名靠前的文档列表 D_i。
3. 结果聚合： 将所有 N 个检索结果列表 (D_1, D_2, ..., D_N) 进行合并和重新排名，以生成最终的单个排名列表。

结果聚合方法

结果聚合是此策略的关键环节。常见的聚合方法包括：

• 简单并集去重与按得分排序： 将所有 D_i 中的文档ID去重后合并，并根据其在各自列表中的最高相似度得分进行重新排序。这种方法可能对来自不同假设文档的得分进行不公平的比较。
• 倒数排名融合 (Reciprocal Rank Fusion – RRF)： 这是一种更鲁棒的融合方法，它不依赖于原始相似度得分，而是根据文档在各个列表中的排名来计算一个融合得分。RRF的计算公式为：
  $$
  Score{RRF}(d) = sum{i=1}^{N} frac{1}{k + rank_i(d)}
  $$
  其中，$rank_i(d)$ 是文档 $d$ 在第 $i$ 个检索列表中的排名（如果不在该列表中，则视为无穷大），$k$ 是一个平滑常数（通常取60）。RRF对排名前列的文档给予更高的权重，且对排名靠后的文档的精确得分不敏感，非常适合处理来自异构源或不同检索器的结果。
• Borda Count： 另一种基于排名的融合方法，对每个文档在每个列表中的排名进行评分，然后求和。

代码示例 (Python)

我们将使用 transformers 库来模拟LLM和嵌入模型，以及 faiss 作为向量数据库。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel
from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
from typing import List, Dict, Tuple

# --- 1. 初始化模型和数据库 ---

# LLM for hypothetical document generation
# For demonstration, we'll use a smaller model. In practice, use GPT-3.5/4 or a powerful local LLM.
llm_tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
llm_model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2", trust_remote_code=True)
llm_model.eval() # Set to evaluation mode

# Document Embedder
# Using a SentenceTransformer for document embeddings, which is efficient and produces good quality embeddings.
embedder = SentenceTransformer('all-MiniLM-L6-v2')

# Sample Document Corpus (for demonstration)
documents = [
    "人工智能在医疗诊断中的应用，包括图像识别和疾病预测。",
    "量子计算的原理、发展历程以及其在密码学和材料科学中的潜在应用。",
    "深度学习模型中的注意力机制如何提升序列任务性能，如自然语言处理。",
    "气候变化对全球经济和生态系统的长期影响。",
    "区块链技术在金融服务和供应链管理中的去中心化应用。",
    "探讨AI伦理，包括偏见、隐私和责任问题，特别是在医疗AI中的体现。",
    "机器学习算法，如支持向量机和决策树，在数据分类中的作用。",
    "大型语言模型的训练方法、架构（如Transformer）和未来挑战。",
    "可再生能源技术，如太阳能和风能，在全球能源转型中的地位。",
    "基因编辑技术CRISPR-Cas9的生物学机制和医学应用潜力。"
]

# Pre-embed documents and build FAISS index
document_embeddings = embedder.encode(documents, convert_to_tensor=True)
dimension = document_embeddings.shape[1]
faiss_index = faiss.IndexFlatIP(dimension) # Inner Product for similarity
faiss_index.add(document_embeddings.cpu().numpy()) # Add embeddings to index

print(f"Loaded {len(documents)} documents into FAISS index.")

# --- 2. 核心迭代函数 ---

def generate_hypothetical_document(query: str, llm_tokenizer, llm_model, prompt_variant: str = "") -> str:
    """
    Generates a hypothetical document using the LLM.
    `prompt_variant` allows injecting different instructions for diversity.
    """
    base_prompt = f"请为以下查询生成一个详细的、类似文档的描述，以便更好地检索相关信息：n查询：{query}n"
    if prompt_variant:
        base_prompt += f"请特别关注：{prompt_variant}n"
    base_prompt += "假设文档："

    inputs = llm_tokenizer(base_prompt, return_tensors="pt", max_length=512, truncation=True)

    # Generate with some diversity (e.g., higher temperature)
    outputs = llm_model.generate(
        **inputs,
        max_new_tokens=256,
        num_return_sequences=1,
        temperature=0.7, # Higher temperature for more creative/diverse output
        top_k=50,
        top_p=0.95,
        do_sample=True,
        pad_token_id=llm_tokenizer.eos_token_id
    )
    generated_text = llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
    # Extract only the generated document part, removing the prompt itself
    generated_doc = generated_text[len(base_prompt):].strip()
    return generated_doc

def reciprocal_rank_fusion(ranked_lists: List[List[Tuple[int, float]]], k: int = 60) -> List[Tuple[int, float]]:
    """
    Performs Reciprocal Rank Fusion (RRF) on multiple ranked lists.
    Each item in ranked_lists is a list of (doc_id, score) tuples.
    Returns a list of (doc_id, rrf_score) tuples, sorted by rrf_score.
    """
    fused_scores = {}
    for r_list in ranked_lists:
        for rank, (doc_id, _) in enumerate(r_list):
            if doc_id not in fused_scores:
                fused_scores[doc_id] = 0.0
            fused_scores[doc_id] += 1.0 / (k + rank + 1) # +1 because rank is 0-indexed

    # Sort by fused score in descending order
    sorted_fused_scores = sorted(fused_scores.items(), key=lambda item: item[1], reverse=True)
    return sorted_fused_scores

def parallel_iterative_hyde(query: str, num_hypo_docs: int = 3) -> List[Tuple[int, float]]:
    """
    Executes parallel iterative HyDE.
    Generates multiple hypothetical documents, performs retrieval for each, and fuses results.
    """
    all_ranked_lists = []
    prompt_variants = [
        "侧重于其技术实现和工作原理。",
        "侧重于其应用场景和实际影响。",
        "从更广阔的视角来描述。",
        "强调其挑战和未来发展。",
        "从历史发展角度。",
        "强调其社会和伦理影响。"
    ]

    print(f"n--- Processing query: '{query}' with {num_hypo_docs} hypothetical documents ---")

    for i in range(num_hypo_docs):
        # Use different prompt variants to encourage diversity, cycling through them
        variant = prompt_variants[i % len(prompt_variants)] if num_hypo_docs > 1 else ""

        print(f"nGenerating hypothetical document {i+1}/{num_hypo_docs} (variant: {variant})...")
        hypo_doc = generate_hypothetical_document(query, llm_tokenizer, llm_model, variant)
        print(f"Hypothetical Document {i+1}:n{hypo_doc[:200]}...") # Print first 200 chars

        # Embed the hypothetical document
        hypo_doc_embedding = embedder.encode([hypo_doc], convert_to_tensor=True)

        # Perform similarity search
        D, I = faiss_index.search(hypo_doc_embedding.cpu().numpy(), k=5) # k=5 top results per search

        current_ranked_list = []
        for rank, (doc_id, score) in enumerate(zip(I[0], D[0])):
            current_ranked_list.append((doc_id, score))
        all_ranked_lists.append(current_ranked_list)
        print(f"Retrieved {len(current_ranked_list)} documents for H_{i+1}.")

    # Fuse the results using RRF
    final_ranked_results = reciprocal_rank_fusion(all_ranked_lists)

    print("n--- Final Fused Results (Top 5) ---")
    for rank, (doc_id, rrf_score) in enumerate(final_ranked_results[:5]):
        print(f"Rank {rank+1} (RRF Score: {rrf_score:.4f}): Doc ID {doc_id} - '{documents[doc_id][:100]}...'")

    return final_ranked_results

# --- 3. 运行示例 ---
query_example = "AI在医疗领域的应用和伦理挑战"
parallel_iterative_hyde(query_example, num_hypo_docs=3)

query_example_2 = "深度学习中的注意力机制"
parallel_iterative_hyde(query_example_2, num_hypo_docs=2)

代码说明：

• generate_hypothetical_document: 封装了LLM生成逻辑，允许通过 prompt_variant 引入多样性。
• reciprocal_rank_fusion: 实现了RRF算法，用于合并来自不同检索列表的结果。
• parallel_iterative_hyde: 协调整个并行迭代过程，包括生成、嵌入、检索和融合。
• 我们使用一个小型LLM (microsoft/phi-2) 和 SentenceTransformer 进行演示。在实际应用中，您会使用更强大的LLM（如GPT系列、Llama系列）和针对密集检索优化的嵌入模型。
• faiss.IndexFlatIP 用于内积相似度搜索，因为我们假设嵌入模型产生的是适用于内积的向量。

优点与缺点

优点：

• 实现简单： 逻辑直接，易于部署。
• 并行性： 各个假设文档的生成和检索过程可以完全并行，提高效率。
• 多样性捕获： 通过调整LLM采样参数或使用不同的提示变体，可以有效生成涵盖查询不同侧面的假设文档。
• 鲁棒性： 减少对单个LLM输出的依赖，有助于缓解幻觉带来的负面影响。

缺点：

• LLM调用成本： 生成多个假设文档意味着多次LLM调用，如果使用付费API，成本会线性增加。
• 缺乏反馈： 这种方法没有一个显式的反馈循环。生成的假设文档之间是独立的，不会根据之前的检索结果进行调整。
• 潜在重复： 如果LLM生成的多份假设文档过于相似，那么迭代带来的增益可能不明显。

迭代策略二：基于反馈的迭代精炼（Query Rewriting/Contextualization）

与并行生成不同，基于反馈的迭代精炼引入了序列化的思维链。它利用前一轮的检索结果来指导下一轮的假设文档生成，从而逐步聚焦或扩展搜索范围。

机制描述

1. 初始假设文档生成与检索： 首先，像原始HyDE一样，从用户查询 Q 生成第一个假设文档 H_1，并进行检索得到初始结果 D_1（例如，Top-K文档）。
2. 反馈与上下文提取： 从 D_1 中提取关键信息作为反馈。这可以包括：
   • 关键词提取： 从前K个文档中提取高频或重要的关键词。
   • 摘要： 让LLM对前K个文档进行摘要，作为新的上下文。
   • 共同主题识别： 识别这些文档的共同主题或视角。
   • 相关段落抽取： 抽取最相关的一些段落。
3. 查询重写/新假设文档生成： 将原始查询 Q 和提取的反馈信息作为新的提示输入给LLM。LLM根据这些信息，生成一个更精炼、更聚焦或从不同角度出发的新查询 Q'，或者直接生成新的假设文档 H_2。
   • 如果生成 Q'，则 Q' 再用于生成 H_2。
4. 循环迭代： 重复步骤2和3，进行 K 次迭代。每次迭代都利用前一轮的检索结果来指导下一轮的生成。
5. 结果聚合： 将所有迭代获得的检索结果 (D_1, D_2, ..., D_K) 进行聚合。

两种主要的反馈方式

• 伪相关反馈 (Pseudo-Relevance Feedback – PRF) 启发： 类似于传统IR中的PRF，假设前K个检索结果是相关的，并用它们来扩充或重写原始查询。
• LLM驱动的上下文重写： 直接让LLM根据检索到的文档，思考并生成一个“更好的”查询或假设文档。

代码示例 (Python)

我们将演示一个基于LLM驱动的上下文重写和假设文档生成的迭代过程。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel
from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
from typing import List, Dict, Tuple

# Assume llm_tokenizer, llm_model, embedder, documents, faiss_index are already initialized
# from the previous example.

def generate_hypothetical_document_with_context(query: str, context: str, llm_tokenizer, llm_model) -> str:
    """
    Generates a hypothetical document, potentially using retrieved context.
    """
    if context:
        base_prompt = (
            f"原始查询：{query}n"
            f"我们已经检索到一些相关文档。这些文档的摘要或关键信息如下：n{context}n"
            "请根据原始查询和这些上下文信息，生成一个更详细、更聚焦的假设文档，以帮助我们找到更多相关文档。n"
            "假设文档："
        )
    else:
        base_prompt = f"请为以下查询生成一个详细的、类似文档的描述：n查询：{query}n假设文档："

    inputs = llm_tokenizer(base_prompt, return_tensors="pt", max_length=1024, truncation=True)
    outputs = llm_model.generate(
        **inputs,
        max_new_tokens=300,
        num_return_sequences=1,
        temperature=0.7,
        top_k=50,
        top_p=0.95,
        do_sample=True,
        pad_token_id=llm_tokenizer.eos_token_id
    )
    generated_text = llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
    generated_doc = generated_text[len(base_prompt):].strip()
    return generated_doc

def summarize_documents(doc_texts: List[str], llm_tokenizer, llm_model) -> str:
    """
    Uses LLM to summarize a list of documents into a concise context string.
    """
    if not doc_texts:
        return ""

    combined_text = "n---n".join(doc_texts[:3]) # Summarize top 3 documents
    prompt = f"请总结以下文档的关键信息，以作为后续查询的上下文：n{combined_text}n总结："

    inputs = llm_tokenizer(prompt, return_tensors="pt", max_length=1500, truncation=True)
    outputs = llm_model.generate(
        **inputs,
        max_new_tokens=150,
        num_return_sequences=1,
        temperature=0.7,
        do_sample=True,
        pad_token_id=llm_tokenizer.eos_token_id
    )
    generated_text = llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
    summary = generated_text[len(prompt):].strip()
    return summary

def iterative_refined_hyde(query: str, num_iterations: int = 2, k_retrieved_per_step: int = 3) -> List[Tuple[int, float]]:
    """
    Executes iterative HyDE with feedback-based refinement.
    """
    current_context = ""
    all_ranked_lists = []

    print(f"n--- Processing query: '{query}' with {num_iterations} refinement iterations ---")

    for i in range(num_iterations):
        print(f"n--- Iteration {i+1}/{num_iterations} ---")

        # 1. Generate hypothetical document (with context if available)
        hypo_doc = generate_hypothetical_document_with_context(query, current_context, llm_tokenizer, llm_model)
        print(f"Generated Hypothetical Document (Iteration {i+1}):n{hypo_doc[:200]}...")

        # 2. Embed and retrieve
        hypo_doc_embedding = embedder.encode([hypo_doc], convert_to_tensor=True)
        D, I = faiss_index.search(hypo_doc_embedding.cpu().numpy(), k=k_retrieved_per_step)

        current_ranked_list = []
        retrieved_doc_texts = []
        for rank, (doc_id, score) in enumerate(zip(I[0], D[0])):
            current_ranked_list.append((doc_id, score))
            retrieved_doc_texts.append(documents[doc_id])
        all_ranked_lists.append(current_ranked_list)
        print(f"Retrieved {len(current_ranked_list)} documents for Iteration {i+1}.")

        # 3. Update context for next iteration (if not the last iteration)
        if i < num_iterations - 1:
            current_context = summarize_documents(retrieved_doc_texts, llm_tokenizer, llm_model)
            print(f"Context for next iteration:n{current_context[:150]}...")

    # Fuse the results using RRF
    final_ranked_results = reciprocal_rank_fusion(all_ranked_lists)

    print("n--- Final Fused Results (Top 5) ---")
    for rank, (doc_id, rrf_score) in enumerate(final_ranked_results[:5]):
        print(f"Rank {rank+1} (RRF Score: {rrf_score:.4f}): Doc ID {doc_id} - '{documents[doc_id][:100]}...'")

    return final_ranked_results

# --- 运行示例 ---
query_example = "量子计算的挑战和未来"
iterative_refined_hyde(query_example, num_iterations=2, k_retrieved_per_step=3)

query_example_2 = "区块链技术在金融领域的应用"
iterative_refined_hyde(query_example_2, num_iterations=3, k_retrieved_per_step=2)

代码说明：

• generate_hypothetical_document_with_context: 这是一个通用生成函数，可以接收 context 参数。
• summarize_documents: 模拟了从检索到的文档中提取关键信息作为反馈的过程。这里简单地使用LLM对前几个文档进行摘要。
• iterative_refined_hyde: 实现了迭代循环。在每次循环中，它生成一个假设文档，进行检索，然后根据检索到的文档生成新的 current_context，用于指导下一次迭代的假设文档生成。
• 同样，reciprocal_rank_fusion 用于最终的结果聚合。

优点与缺点

优点：

• 聚焦与精炼： 通过反馈机制，迭代过程可以逐步聚焦到查询更深层次的意图，或探索不同的相关子主题。
• 处理复杂查询： 对于多意图或模糊查询，可以先宽泛检索，再根据结果逐步细化。
• 避免重复： 通过上下文引导，LLM更有可能生成与之前不同的、更具信息增量的假设文档。
• 更高召回潜力： 逐步探索语义空间，有望发现更多相关但可能被初始查询遗漏的文档。

缺点：

• 实现复杂性： 需要更精细的逻辑来管理迭代状态和反馈机制。
• 顺序依赖性： 每次迭代依赖于前一次的结果，无法并行，这会增加总响应时间。
• 错误累积： 如果某一步的LLM生成或检索结果出现较大偏差，可能会导致后续迭代的“漂移”，远离真实意图。
• LLM调用成本： 仍然是多次LLM调用，但由于是顺序的，可能总次数相对少于并行生成大量文档的情况。

迭代策略三：混合嵌入与一次性检索

这种策略不侧重于生成多个独立的检索结果列表，而是尝试将多个假设文档的语义信息融合到一个单一的查询嵌入中，然后用这个融合后的嵌入进行一次性检索。

机制描述

1. 生成多个假设文档： 与并行生成策略类似，从原始查询 Q 生成 N 个不同的假设文档 (H_1, H_2, ..., H_N)。多样性同样是关键。
2. 独立嵌入： 对每个假设文档 H_i，使用文档嵌入器 E_doc 生成其嵌入向量 v_i。
3. 嵌入聚合： 将这 N 个嵌入向量 v_1, v_2, ..., v_N 聚合为一个单一的融合嵌入向量 v_fused。常见的聚合方法包括：
   • 平均池化 (Mean Pooling)： 简单地计算所有 v_i 的平均值。这假设所有假设文档同等重要，且它们的语义是互补的。
   • 加权平均： 如果能为每个假设文档分配权重（例如，根据其与原始查询的相似度），则可以进行加权平均。
   • 最大池化 (Max Pooling)： 取每个维度上的最大值。
   • 串联后线性投影： 将所有嵌入向量串联起来，然后通过一个小的神经网络层投影回原始维度。
4. 一次性相似性搜索： 使用融合后的嵌入向量 v_fused 在向量数据库 V_db 中执行一次相似性搜索，得到最终的排名列表。

代码示例 (Python)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel
from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
from typing import List, Dict, Tuple

# Assume llm_tokenizer, llm_model, embedder, documents, faiss_index are already initialized.

def generate_diverse_hypothetical_documents(query: str, llm_tokenizer, llm_model, num_docs: int = 3) -> List[str]:
    """
    Generates multiple diverse hypothetical documents for embedding aggregation.
    """
    hypo_docs = []
    prompt_variants = [
        "从技术角度详细阐述。",
        "侧重于其应用和实际影响。",
        "提供一个广泛的概述。",
        "强调其发展历史和未来趋势。",
        "探讨其面临的挑战和潜在解决方案。"
    ]

    for i in range(num_docs):
        variant = prompt_variants[i % len(prompt_variants)] if num_docs > 1 else ""
        prompt = f"请为以下查询生成一个详细的、类似文档的描述。n查询：{query}n{variant}n假设文档："

        inputs = llm_tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
        outputs = lllm_model.generate(
            **inputs,
            max_new_tokens=256,
            num_return_sequences=1,
            temperature=0.8, # Higher temperature for more diversity
            top_k=50,
            top_p=0.95,
            do_sample=True,
            pad_token_id=llm_tokenizer.eos_token_id
        )
        generated_text = llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
        hypo_doc = generated_text[len(prompt):].strip()
        hypo_docs.append(hypo_doc)
        print(f"Generated Hypothetical Document {i+1}:n{hypo_doc[:150]}...")
    return hypo_docs

def ensemble_embedding_hyde(query: str, num_hypo_docs: int = 3) -> List[Tuple[int, float]]:
    """
    Executes HyDE with ensemble embedding.
    Generates multiple hypothetical documents, aggregates their embeddings, and performs a single search.
    """
    print(f"n--- Processing query: '{query}' with {num_hypo_docs} hypothetical documents for ensemble embedding ---")

    # 1. Generate multiple hypothetical documents
    hypo_docs = generate_diverse_hypothetical_documents(query, llm_tokenizer, llm_model, num_hypo_docs)

    # 2. Embed each hypothetical document
    hypo_doc_embeddings = embedder.encode(hypo_docs, convert_to_tensor=True)

    # 3. Aggregate embeddings (Mean Pooling)
    fused_embedding = torch.mean(hypo_doc_embeddings, dim=0, keepdim=True) # Resulting shape (1, dimension)

    # 4. Perform a single similarity search
    D, I = faiss_index.search(fused_embedding.cpu().numpy(), k=5) # k=5 top results

    final_ranked_results = []
    for rank, (doc_id, score) in enumerate(zip(I[0], D[0])):
        final_ranked_results.append((doc_id, score))

    print("n--- Final Results (Top 5) from Ensemble Embedding ---")
    for rank, (doc_id, score) in enumerate(final_ranked_results[:5]):
        print(f"Rank {rank+1} (Score: {score:.4f}): Doc ID {doc_id} - '{documents[doc_id][:100]}...'")

    return final_ranked_results

# --- 运行示例 ---
query_example = "机器学习模型在工业界的部署挑战"
ensemble_embedding_hyde(query_example, num_hypo_docs=4)

query_example_2 = "AI在艺术创作中的角色"
ensemble_embedding_hyde(query_example_2, num_hypo_docs=2)

代码说明：

• generate_diverse_hypothetical_documents: 旨在生成多样化的假设文档，为嵌入聚合提供更丰富的语义信息。
• ensemble_embedding_hyde: 核心逻辑在于 torch.mean(hypo_doc_embeddings, dim=0)，它将所有假设文档的嵌入向量在维度0（文档数量）上进行平均，得到一个代表这些文档平均语义的单一向量。
• 然后，这个融合后的向量用于一次性检索。

优点与缺点

优点：

• 检索效率高： 只执行一次相似性搜索，计算成本远低于并行生成后聚合结果的策略。
• 平滑噪声： 多个假设文档的平均嵌入可以平滑单个假设文档可能存在的噪声或幻觉，提供更鲁棒的查询表示。
• 捕捉主要趋势： 平均嵌入倾向于代表所有假设文档的共同语义中心，有助于捕捉查询的核心意图。

缺点：

• 可能丢失细节： 如果查询的多个方面彼此差异较大，简单平均可能会稀释或模糊掉每个特定方面的独特信息，导致检索精度下降。例如，一个关于“苹果公司财务表现和iPhone设计理念”的查询，平均嵌入可能会导致检索结果既不偏重财务也不偏重设计。
• 假设： 隐含地假设所有假设文档的语义空间是线性可加的，并且平均操作是语义上有意义的。
• 多样性挑战： 仍然需要LLM生成足够多样化的假设文档，否则平均效果不佳。

综合比较与实践建议

下表总结了我们讨论的三种迭代策略及其特点：

特征/策略	并行生成与聚合	基于反馈的迭代精炼	混合嵌入与一次性检索
核心思想	多角度并行探索，结果融合	逐步精炼查询/假设文档，聚焦或扩展搜索	融合多份假设文档语义，一次性检索
LLM 调用模式	多次并行调用，或一次性生成多个	多次顺序调用，每次基于前一步结果	多次并行调用，或一次性生成多个
检索模式	多次独立检索	多次独立检索	一次性检索
结果聚合方式	RRF、Borda Count、去重排序等	RRF、Borda Count 等（融合所有迭代结果）	无（检索结果直接来自融合嵌入）
复杂查询处理	适用于多意图查询，覆盖面广	适用于复杂、模糊查询，可逐步深入	适用于有明确中心意图但需多角度描述的查询
实现难度	较低	中等	较低
计算/成本	高（多LLM调用，多检索）	中高（多LLM调用，多检索，但顺序执行）	中等（多LLM调用，一次检索）
鲁棒性	较好（平均化LLM幻觉）	较好（通过精炼避免漂移，但也可能累积错误）	较好（平滑噪声）
召回潜力	高	高（潜在最高，如果反馈循环有效）	中高
主要缺点	成本高，无反馈	响应时间长，错误累积风险，实现复杂	可能丢失细节，要求嵌入空间线性可加

实践中的考虑

1. LLM选择与成本： 迭代HyDE会显著增加LLM的调用次数。对于生产环境，需要权衡LLM的性能和API成本。可以考虑使用更高效的API（如GPT-3.5-turbo）或部署成本效益更高的本地LLM（如Llama-2, Mixtral）。
2. 提示工程： 无论是哪种策略，高质量的提示工程都是生成优秀假设文档的关键。
   • 明确指示LLM生成“类似文档”的文本。
   • 在并行生成时，通过提示明确要求多样性（例如，“从经济、技术、社会三个角度生成假设文档”）。
   • 在反馈迭代时，清晰地指示LLM如何利用上下文来精炼查询或生成新的假设文档。
3. 多样性控制： LLM的 temperature、top_k、top_p 等采样参数对于控制生成文档的多样性至关重要。适当调整这些参数可以鼓励LLM生成更多元的假设。
4. 结果聚合的艺术： RRF是目前广泛认可且效果良好的结果融合方法。它对不同检索器的得分尺度不敏感，仅依赖于排名，非常适合HyDE这种可能产生不同相似度得分的场景。
5. 召回与精度的权衡： 迭代HyDE旨在提高召回率。但在某些场景下，过高的召回可能会引入更多不那么相关的文档，从而降低前K位的精度。可以考虑在迭代HyDE之后，再使用一个交叉编码器（Cross-Encoder）进行二次重排序，以提升最终结果的精度。
6. 缓存机制： 对于重复的查询或子查询，可以考虑引入缓存机制，以减少LLM的重复调用和检索时间。

挑战与展望

迭代版HyDE作为一种强大的密集检索增强技术，仍面临一些挑战：

1. 复杂性与可解释性： 迭代过程增加了系统的复杂性，也使得整个检索过程的黑箱程度更高，难以解释特定结果是如何被召回的。
2. 参数调优： 迭代次数、生成的假设文档数量、反馈机制的细节、聚合方法的选择等，都需要针对特定数据集和应用场景进行细致的调优。
3. 实时性要求： 多个LLM调用和检索可能导致较高的延迟，对于实时性要求高的应用需要仔细优化。
4. 动态适应： 未来研究可以探索如何让系统动态地决定迭代的停止条件，例如，当检索结果的多样性不再显著增加时停止迭代。
5. 多模态扩展： 将HyDE的概念扩展到多模态检索，例如，通过LLM生成假设的图片描述或视频脚本，然后进行多模态嵌入和检索。

结语

迭代版假设文档嵌入（Iterative HyDE）代表了密集检索领域的一个重要进步。通过在循环中生成并利用多个假设文档，我们能够更全面、更鲁棒地捕捉用户查询的复杂语义，从而显著提升信息召回的能力。无论是通过并行生成与结果聚合、基于反馈的迭代精炼，还是混合嵌入与一次性检索，这些策略都为我们提供了强大的工具，以应对现代信息检索所面临的挑战。随着大型语言模型能力的不断增强和优化，迭代HyDE及其变种无疑将在未来的智能信息系统中扮演越来越重要的角色。