Image adapted from Seven Failure Points When Engineering a Retrieval Augmented Generation System

· 痛点1：内容缺失

· 痛点2：错过了排名靠前的文件

· 痛点3：不在上下文中 — 合并策略的局限性

· 痛点4：未提取

· 痛点 5: Wrong Format

· 痛点6: 不正确的特异性

· 痛点7：不完整

· 痛点8：数据摄入可扩展性

· 痛点9: 结构化数据质量保证

· 痛点10：从复杂的PDF中提取数据

· 痛点11：备用模型（或模型）

· 痛点12: LLM 安全

受Barnett等人的论文《工程检索增强生成系统的七个失败点》的启发，让我们在本文中探讨论文中提到的七个失败点以及开发RAG管道中的五个常见痛点。

更重要的是，我们将深入探讨这些RAG痛点的解决方案，这样我们就能更好地应对我们日常RAG开发中的这些痛点。

我使用“痛点”而不是“失败点”，主要是因为这些点都有相应的解决方案。在我们的RAG管道中，让我们试着修复它们，避免它们变成失败。

请问这段文字是要翻译成哪种语言呢？

图像来源：工程检索增强生成系统时的七个失败点

痛点1：缺少内容

RAG系统在知识库中没有实际答案时会提供一个似是而非的答案，而不是声明它不知道。用户会收到误导性信息，导致沮丧。

我们有两个提议的解决方案：

 清理你的数据

垃圾进，垃圾出。如果您的源数据质量很差，比如包含矛盾信息，无论您如何构建RAG管道，它也无法将您输入的垃圾变成金子。
 

本文提出的解决方案不仅可以解决这一痛点，还可以解决本文列出的所有痛点。干净的数据是任何运行良好的 RAG 管道的先决条件。

Better prompting

更好的提示可以在系统可能因知识库中信息不足而提供一个似是而非的答案的情况下，显著地帮助。

通过这样的提示来指导系统，比如“告诉我你不知道，如果你对答案不确定”，你鼓励模型承认自己的局限性，并更透明地表达不确定性。
虽然不能保证 100% 的准确性，但制作提示语是您在清理数据后所能做的最佳努力之一。

痛点2：错过了排名靠前的文件

重要文件可能不会出现在系统检索组件返回的顶部结果中。正确答案被忽略，导致系统无法提供准确的回复。
这篇论文暗示：“问题的答案在文件中，但排名不够高，无法返回给用户”。

两个提议的解决方案浮现在我脑海中：

超参数调整用于chunk_size和 similarity_top_k

chunk_size and similarity_top_k 都是用于管理RAG模型中数据检索过程的效率和有效性的参数。调整这些参数可能会影响计算效率和检索信息质量之间的权衡。

我们在之前的文章中探讨了LlamaIndex的超参数调整的细节，包括 chunk_size 和 similarity_top_k 。请参阅下面的示例代码片段。

param_tuner = ParamTuner(
    param_fn=objective_function_semantic_similarity,
    param_dict=param_dict,
    fixed_param_dict=fixed_param_dict,
    show_progress=True,
)

results = param_tuner.tune()

该函数 objective_function_semantic_similarity 的定义如下，其中 param_dict 包含参数， chunk_size 和 top_k 及其对应的建议值：

# contains the parameters that need to be tuned
param_dict = {"chunk_size": [256, 512, 1024], "top_k": [1, 2, 5]}

# contains parameters remaining fixed across all runs of the tuning process
fixed_param_dict = {
    "docs": documents,
    "eval_qs": eval_qs,
    "ref_response_strs": ref_response_strs,
}

def objective_function_semantic_similarity(params_dict):
    chunk_size = params_dict["chunk_size"]
    docs = params_dict["docs"]
    top_k = params_dict["top_k"]
    eval_qs = params_dict["eval_qs"]
    ref_response_strs = params_dict["ref_response_strs"]

    # build index
    index = _build_index(chunk_size, docs)

    # query engine
    query_engine = index.as_query_engine(similarity_top_k=top_k)

    # get predicted responses
    pred_response_objs = get_responses(
        eval_qs, query_engine, show_progress=True
    )

    # run evaluator
    eval_batch_runner = _get_eval_batch_runner_semantic_similarity()
    eval_results = eval_batch_runner.evaluate_responses(
        eval_qs, responses=pred_response_objs, reference=ref_response_strs
    )

    # get semantic similarity metric
    mean_score = np.array(
        [r.score for r in eval_results["semantic_similarity"]]
    ).mean()

    return RunResult(score=mean_score, params=params_dict)

请参考LlamaIndex关于RAG超参数优化的完整笔记本获取更多详细信息。

Reranking

在将检索结果发送给 LLM 之前对其进行Reranking大大提高了 RAG 的性能。这本 LlamaIndex   notebook 展示了这两者之间的区别：

• 直接检索前 2 个节点而不使用重新搜索器，检索不准确。
• 请问这是科技文件吗？

import os
from llama_index.postprocessor.cohere_rerank import CohereRerank

api_key = os.environ["COHERE_API_KEY"]
cohere_rerank = CohereRerank(api_key=api_key, top_n=2) # return top 2 nodes from reranker

query_engine = index.as_query_engine(
    similarity_top_k=10, # we can set a high top_k here to ensure maximum relevant retrieval
    node_postprocessors=[cohere_rerank], # pass the reranker to node_postprocessors
)

response = query_engine.query(
    "What did Sam Altman do in this essay?",
)

 

此外，您可以微调自定义的重新排序器，以获得更好的检索性能，详细的实现已在《通过与LlamaIndex微调Cohere Reranker来改善检索性能》中记录

 

痛点3：不在上下文中 —— 合并策略的局限性

这篇论文定义了这一点：“从数据库中检索到了带有答案的文档，但并未用于生成答案的上下文中。

这种情况发生在从数据库返回许多文档时，然后进行合并处理以获取答案。

除了按照上述部分所述添加重新排序器并对重新排序器进行微调之外，我们还可以探索以下提出的解决方案：

Tweak retrieval strategies

LlamaIndex提供一系列的检索策略，从基础到高级，以帮助我们在RAG管道中实现准确的检索。查看检索模块指南，了解所有检索策略的全面列表，分为不同的类别。

• Basic retrieval from each index
• Advanced retrieval and search
• Auto-Retrieval
• Knowledge Graph Retrievers
• Composed/Hierarchical Retrievers
• and more!

Finetune embeddings

如果您使用开源嵌入模型，微调您的嵌入模型是实现更准确检索的好方法。LlamaIndex有一份逐步指南，介绍如何微调开源嵌入模型，证明微调嵌入模型可以在一系列评估指标中持续改善指标。

请参阅以下有关创建微调引擎、运行微调和获取微调模型的示例代码片段：

finetune_engine = SentenceTransformersFinetuneEngine(
    train_dataset,
    model_id="BAAI/bge-small-en",
    model_output_path="test_model",
    val_dataset=val_dataset,
)

finetune_engine.finetune()

embed_model = finetune_engine.get_finetuned_model()

痛点4：未提取

系统在处理提供的上下文时很难提取出正确的答案，特别是在信息过载的情况下。关键细节被忽略，影响了回答的质量。

这篇论文暗示：“当环境中存在太多噪音或矛盾信息时，就会发生这种情况”。

让我们探讨三种提议的解决方案：

 清理你的数据

这一痛点是又一个典型的受到糟糕数据影响的受害者。我们无法再次强调数据清洁的重要性！在责怪你的RAG管道之前，请花时间清理你的数据。

Prompt Compression

LongLLMLingua 研究项目/论文引入了长语境设置中的提示压缩。通过将其集成到 LlamaIndex 中，我们现在可以将 LongLLMLingua 作为节点后处理器来实现，它将在检索步骤后压缩上下文，然后再将其输入 LLM。
 

请参见下面的示例代码片段，其中我们设置了 LongLLMLinguaPostprocessor ，它使用 longllmlingua 包来运行提示压缩。

请查看LongLLMLingua上的完整笔记本获取更多详情。

from llama_index.query_engine import RetrieverQueryEngine
from llama_index.response_synthesizers import CompactAndRefine
from llama_index.postprocessor import LongLLMLinguaPostprocessor
from llama_index.schema import QueryBundle

node_postprocessor = LongLLMLinguaPostprocessor(
    instruction_str="Given the context, please answer the final question",
    target_token=300,
    rank_method="longllmlingua",
    additional_compress_kwargs={
        "condition_compare": True,
        "condition_in_question": "after",
        "context_budget": "+100",
        "reorder_context": "sort",  # enable document reorder
    },
)

retrieved_nodes = retriever.retrieve(query_str)
synthesizer = CompactAndRefine()

# outline steps in RetrieverQueryEngine for clarity:
# postprocess (compress), synthesize
new_retrieved_nodes = node_postprocessor.postprocess_nodes(
    retrieved_nodes, query_bundle=QueryBundle(query_str=query_str)
)

print("\n\n".join([n.get_content() for n in new_retrieved_nodes]))

response = synthesizer.synthesize(query_str, new_retrieved_nodes)

LongContextReorder

这项研究观察到，当关键数据位于输入上下文的开头或结尾时，通常会出现最佳性能。 LongContextReorder 旨在通过重新排序检索到的节点来解决这个“中间丢失”的问题，在需要大量 top-k 的情况下可能会有所帮助。

请参见以下示例代码片段，了解在查询引擎构建过程中如何将 LongContextReorder 定义为您的 node_postprocessor 。有关更多详细信息，请参阅LlamaIndex的完整笔记本 LongContextReorder 。

from llama_index.postprocessor import LongContextReorder

reorder = LongContextReorder()

reorder_engine = index.as_query_engine(
    node_postprocessors=[reorder], similarity_top_k=5
)

reorder_response = reorder_engine.query("Did the author meet Sam Altman?")

痛点5：错误的格式

当LLM忽略提取特定格式（如表格或列表）信息的指令时，我们有四个建议的解决方案可供探讨：

Better prompting

有几种策略可以采用来改善您的提示并纠正这个问题：

• 澄清说明。
• 简化请求并使用关键词。
•  给出例子。
• 迭代提示和提出后续问题。

Output parsing

Output parsing可以通过以下方式来帮助确保所需的输出:

• 提供任何提示/查询的格式说明
• 提供对LLM输出的“解析”

LlamaIndex支持与其他框架提供的输出解析模块集成，例如Guardrails和LangChain。

请参阅LangChain输出解析模块的示例代码片段，您可以在LlamaIndex中使用。有关更多详细信息，请查看LlamaIndex关于输出解析模块的文档。

from llama_index import VectorStoreIndex, SimpleDirectoryReader
from llama_index.output_parsers import LangchainOutputParser
from llama_index.llms import OpenAI
from langchain.output_parsers import StructuredOutputParser, ResponseSchema

# load documents, build index
documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()
index = VectorStoreIndex.from_documents(documents)

# define output schema
response_schemas = [
    ResponseSchema(
        name="Education",
        description="Describes the author's educational experience/background.",
    ),
    ResponseSchema(
        name="Work",
        description="Describes the author's work experience/background.",
    ),
]

# define output parser
lc_output_parser = StructuredOutputParser.from_response_schemas(
    response_schemas
)
output_parser = LangchainOutputParser(lc_output_parser)

# Attach output parser to LLM
llm = OpenAI(output_parser=output_parser)

# obtain a structured response
from llama_index import ServiceContext

ctx = ServiceContext.from_defaults(llm=llm)

query_engine = index.as_query_engine(service_context=ctx)
response = query_engine.query(
    "What are a few things the author did growing up?",
)
print(str(response))

 Pydantic程序

Pydantic 程序是一个多功能框架，可将输入字符串转换为结构化的 Pydantic 对象。LlamaIndex 提供几类 Pydantic 程序：

• Text Completion Pydantic Programs: 这些程序处理输入文本，并将其转换为用户定义的结构化对象，利用文本完成 API 结合输出解析。
• Function Calling Pydantic Programs: 这些程序接受输入文本，并通过利用LLM函数调用API，将其转换为用户指定的结构化对象。
• Prepackaged Pydantic Programs: 这些程序旨在将输入文本转换为预定义的结构化对象。

请参见OpenAI pydantic程序中的示例代码片段。有关更多详细信息，请查看LlamaIndex关于pydantic程序的文档，以获取不同pydantic程序的笔记本/指南链接。

from pydantic import BaseModel
from typing import List

from llama_index.program import OpenAIPydanticProgram

# Define output schema (without docstring)
class Song(BaseModel):
    title: str
    length_seconds: int


class Album(BaseModel):
    name: str
    artist: str
    songs: List[Song]

# Define openai pydantic program
prompt_template_str = """\
Generate an example album, with an artist and a list of songs. \
Using the movie {movie_name} as inspiration.\
"""
program = OpenAIPydanticProgram.from_defaults(
    output_cls=Album, prompt_template_str=prompt_template_str, verbose=True
)

# Run program to get structured output
output = program(
    movie_name="The Shining", description="Data model for an album."
)

 OpenAI JSON 模式

OpenAI JSON模式使我们能够设置 response_format 为 { "type": "json_object" } ，以启用响应的JSON模式。启用JSON模式时，模型受限于仅生成解析为有效JSON对象的字符串。虽然JSON模式强制输出的格式，但它并不帮助验证指定的模式。

请查看LlamaIndex关于OpenAI JSON模式与函数调用进行数据提取的文档，以获取更多详细信息。

痛点 6: 不正确的具体性

这些回答可能缺乏必要的细节或具体性，通常需要后续的查询来进行澄清。答案可能过于模糊或泛泛，未能有效满足用户的需求。

我们转向高级检索策略寻求解决方案。

高级检索策略

当答案的粒度不符合您的期望时，您可以改进检索策略。一些可能有助于解决这一痛点的主要高级检索策略包括：

•  小到大检索
• sentence window retrieval
• recursive retrieval

请查看我的最新文章《使用高级检索LlamaPacks来启动您的RAG管道，并使用Lighthouz AI进行基准测试》，了解更多关于七种高级检索LlamaPacks的详细信息。

 痛点7：不完整

部分回答并不是错误；然而，尽管信息已经存在并且在上下文中可以获取，但它们并没有提供所有的细节。

例如，如果有人问：“文件A、B和C中讨论的主要方面是什么？”单独询问每个文件可能更有效，以确保得到全面的答案。

Query transformations

比较问题在最原始的 RAG 方法中表现尤为糟糕。提高 RAG 推理能力的一个好方法是添加查询理解层--在实际查询向量存储之前添加查询转换。以下是四种不同的查询转换:

• Routing: 在确定相关工具的适当子集时保留初始查询。然后，将这些工具指定为合适的选项。
• Query-Rewriting: 在保留所选工具的同时，以多种方式重新构造查询，以在相同的一组工具中应用它。
• Sub-Questions: 将查询分解为几个较小的问题，每个问题针对不同的工具，根据它们的元数据确定。
• ReAct Agent Tool Selection: 根据原始查询，确定使用哪种工具，并制定在该工具上运行的具体查询。

请参见以下示例代码片段，演示如何使用HyDE（假设性文档嵌入），一种查询重写技术。给定自然语言查询，首先生成一个假设性文档/答案。

这个假设性文件随后用于嵌入查找，而不是原始查询。

# load documents, build index
documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()
index = VectorStoreIndex(documents)

# run query with HyDE query transform
query_str = "what did paul graham do after going to RISD"
hyde = HyDEQueryTransform(include_original=True)
query_engine = index.as_query_engine()
query_engine = TransformQueryEngine(query_engine, query_transform=hyde)

response = query_engine.query(query_str)
print(response)

请查看LlamaIndex的查询转换手册，了解所有细节。

此外，请查看这篇很棒的文章  Advanced Query Transformations to Improve RAG ，作者是 

Iulia Brezeanu