大模型高质量rag构建:A Cheat Sheet and Some Recipes For Building Advanced RAG

news2025/4/2 21:39:06

原文:A Cheat Sheet and Some Recipes For Building Advanced RAG — LlamaIndex - Build Knowledge Assistants over your Enterprise DataLlamaIndex is a simple, flexible framework for building knowledge assistants using LLMs connected to your enterprise data.https://www.llamaindex.ai/blog/a-cheat-sheet-and-some-recipes-for-building-advanced-rag-803a9d94c41b

一、TL;DR

  1. 给出了典型的基础rag并定义了2条rag是成功的要求
  2. 基于2条rag的成功要求给出了构建高级rag的相关技术,包括块大小优化、结构化外部知识、信息压缩、结果重排等
  3. 对上述所有的方法,给出了LlamaIndexdemo代码和相关的其他参考链接

二、基础RAG

如今所定义的主流RAG(检索增强型生成)涉及从外部知识数据库中检索文档,并将这些文档连同用户的查询一起传递给大型语言模型(LLM),以生成回答。换句话说,RAG包含检索组件、外部知识数据库和生成组件。

LlamaIndex基础RAG配方:

from llama_index import SimpleDirectoryReader, VectorStoreIndex

# load data
documents = SimpleDirectoryReader(input_dir="...").load_data()

# build VectorStoreIndex that takes care of chunking documents
# and encoding chunks to embeddings for future retrieval
index = VectorStoreIndex.from_documents(documents=documents)

# The QueryEngine class is equipped with the generator
# and facilitates the retrieval and generation steps
query_engine = index.as_query_engine()

# Use your Default RAG
response = query_engine.query("A user's query")

三、RAG的成功要求

为了使一个RAG系统被认为是成功的(即能够为用户提供有用且相关的答案),实际上只有两个高级要求:

  1. 检索必须能够找到与用户查询最相关的文档(能够找到)。
  2. 生成必须能够充分利用检索到的文档来充分回答用户查询(充分找到)。

四、高级RAG

构建高级RAG实际上就是应用更复杂的技术和策略(针对检索或生成组件),以确保这些要求最终得以满足。此外,我们可以将一种复杂的技术归类为:要么是独立(或多或少)于另一个要求来解决这两个高级成功要求中的一个,要么是同时解决这两个要求。

4.1 检索的高级技术必须能够找到与用户查询最相关的文档

下面,我们简要描述一些更复杂的技术,以帮助实现第一个成功要求。

4.1.1 块大小优化

由于LLM(大型语言模型)受到上下文长度的限制,在构建外部知识库时,有必要将文档分割成块。块过大或过小都会给生成组件带来问题,导致回答不准确

LlamaIndex Chunk Size Optimization Recipe:

from llama_index import ServiceContext
from llama_index.param_tuner.base import ParamTuner, RunResult
from llama_index.evaluation import SemanticSimilarityEvaluator, BatchEvalRunner

### Recipe
### Perform hyperparameter tuning as in traditional ML via grid-search
### 1. Define an objective function that ranks different parameter combos
### 2. Build ParamTuner object
### 3. Execute hyperparameter tuning with ParamTuner.tune()

# 1. Define objective function
def objective_function(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 RAG pipeline
    index = _build_index(chunk_size, docs)  # helper function not shown here
    query_engine = index.as_query_engine(similarity_top_k=top_k)
  
    # perform inference with RAG pipeline on a provided questions `eval_qs`
    pred_response_objs = get_responses(
        eval_qs, query_engine, show_progress=True
    )

    # perform evaluations of predictions by comparing them to reference
    # responses `ref_response_strs`
    evaluator = SemanticSimilarityEvaluator(...)
    eval_batch_runner = BatchEvalRunner(
        {"semantic_similarity": evaluator}, workers=2, show_progress=True
    )
    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)

# 2. Build ParamTuner object
param_dict = {"chunk_size": [256, 512, 1024]} # params/values to search over
fixed_param_dict = { # fixed hyperparams
  "top_k": 2,
    "docs": docs,
    "eval_qs": eval_qs[:10],
    "ref_response_strs": ref_response_strs[:10],
}
param_tuner = ParamTuner(
    param_fn=objective_function,
    param_dict=param_dict,
    fixed_param_dict=fixed_param_dict,
    show_progress=True,
)

# 3. Execute hyperparameter search
results = param_tuner.tune()
best_result = results.best_run_result
best_chunk_size = results.best_run_result.params["chunk_size"]

4.1.2 结构化外部知识

在复杂场景中,可能需要构建比基础向量索引更具结构化的外部知识,以便在处理合理分离的外部知识源时,允许进行递归检索或路由检索:

LlamaIndex Recursive Retrieval Recipe:

from llama_index import SimpleDirectoryReader, VectorStoreIndex
from llama_index.node_parser import SentenceSplitter
from llama_index.schema import IndexNode

### Recipe
### Build a recursive retriever that retrieves using small chunks
### but passes associated larger chunks to the generation stage

# load data
documents = SimpleDirectoryReader(
  input_file="some_data_path/llama2.pdf"
).load_data()

# build parent chunks via NodeParser
node_parser = SentenceSplitter(chunk_size=1024)
base_nodes = node_parser.get_nodes_from_documents(documents)

# define smaller child chunks
sub_chunk_sizes = [256, 512]
sub_node_parsers = [
    SentenceSplitter(chunk_size=c, chunk_overlap=20) for c in sub_chunk_sizes
]
all_nodes = []
for base_node in base_nodes:
    for n in sub_node_parsers:
        sub_nodes = n.get_nodes_from_documents([base_node])
        sub_inodes = [
            IndexNode.from_text_node(sn, base_node.node_id) for sn in sub_nodes
        ]
        all_nodes.extend(sub_inodes)
    # also add original node to node
    original_node = IndexNode.from_text_node(base_node, base_node.node_id)
    all_nodes.append(original_node)

# define a VectorStoreIndex with all of the nodes
vector_index_chunk = VectorStoreIndex(
    all_nodes, service_context=service_context
)
vector_retriever_chunk = vector_index_chunk.as_retriever(similarity_top_k=2)

# build RecursiveRetriever
all_nodes_dict = {n.node_id: n for n in all_nodes}
retriever_chunk = RecursiveRetriever(
    "vector",
    retriever_dict={"vector": vector_retriever_chunk},
    node_dict=all_nodes_dict,
    verbose=True,
)

# build RetrieverQueryEngine using recursive_retriever
query_engine_chunk = RetrieverQueryEngine.from_args(
    retriever_chunk, service_context=service_context
)

# perform inference with advanced RAG (i.e. query engine)
response = query_engine_chunk.query(
    "Can you tell me about the key concepts for safety finetuning"
)

4.1.3 其他有用的链接

我们有一些指南展示了在复杂情况下确保准确检索的其他高级技术的应用。以下是一些精选链接:

  1. Building External Knowledge using Knowledge Graphs
  2. Performing Mixed Retrieval with Auto Retrievers
  3. Building Fusion Retrievers
  4. Fine-tuning Embedding Models used in Retrieval
  5. Transforming Query Embeddings (HyDE)

4.2 生成的高级技术必须能够充分利用检索到的文档

与前一节类似,我们提供了一些此类复杂技术的例子,这些技术可以被描述为确保检索到的文档与生成器的大型语言模型(LLM)很好地对齐。

4.2.1 信息压缩:

大型语言模型(LLM)不仅受到上下文长度的限制,而且如果检索到的文档携带过多的噪声(即无关信息),还可能导致回答质量下降。

LlamaIndex:

from llama_index import SimpleDirectoryReader, VectorStoreIndex
from llama_index.query_engine import RetrieverQueryEngine
from llama_index.postprocessor import LongLLMLinguaPostprocessor

### Recipe
### Define a Postprocessor object, here LongLLMLinguaPostprocessor
### Build QueryEngine that uses this Postprocessor on retrieved docs

# Define Postprocessor
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
    },
)

# Define VectorStoreIndex
documents = SimpleDirectoryReader(input_dir="...").load_data()
index = VectorStoreIndex.from_documents(documents)

# Define QueryEngine
retriever = index.as_retriever(similarity_top_k=2)
retriever_query_engine = RetrieverQueryEngine.from_args(
    retriever, node_postprocessors=[node_postprocessor]
)

# Used your advanced RAG
response = retriever_query_engine.query("A user query")

4.2.2 结果重排:

LLM(大型语言模型)存在所谓的“迷失在中间”现象,即LLM会重点关注提示的两端。鉴于此,在将检索到的文档传递给生成组件之前,重新对它们进行排序是有益的。

LlamaIndex结果重排以提升生成效果的方法:

import os
from llama_index import SimpleDirectoryReader, VectorStoreIndex
from llama_index.postprocessor.cohere_rerank import CohereRerank
from llama_index.postprocessor import LongLLMLinguaPostprocessor

### Recipe
### Define a Postprocessor object, here CohereRerank
### Build QueryEngine that uses this Postprocessor on retrieved docs

# Build CohereRerank post retrieval processor
api_key = os.environ["COHERE_API_KEY"]
cohere_rerank = CohereRerank(api_key=api_key, top_n=2)

# Build QueryEngine (RAG) using the post processor
documents = SimpleDirectoryReader("./data/paul_graham/").load_data()
index = VectorStoreIndex.from_documents(documents=documents)
query_engine = index.as_query_engine(
    similarity_top_k=10,
    node_postprocessors=[cohere_rerank],
)

# Use your advanced RAG
response = query_engine.query(
    "What did Sam Altman do in this essay?"
)

4.3 同时满足检索和生成成功要求的高级技术

在本小节中,我们考虑一些复杂的办法,这些办法利用检索和生成的协同作用,以实现更好的检索效果以及更准确地回答用户查询的生成结果。

4.3.1 生成器增强型检索:

这些技术利用LLM(大型语言模型)的固有推理能力,在执行检索之前对用户查询进行优化,以便更准确地表明需要什么内容才能提供有用的回答。

LlamaIndex生成器增强型检索:

from llama_index.llms import OpenAI
from llama_index.query_engine import FLAREInstructQueryEngine
from llama_index import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    ServiceContext,
)
### Recipe
### Build a FLAREInstructQueryEngine which has the generator LLM play
### a more active role in retrieval by prompting it to elicit retrieval
### instructions on what it needs to answer the user query.

# Build FLAREInstructQueryEngine
documents = SimpleDirectoryReader("./data/paul_graham").load_data()
index = VectorStoreIndex.from_documents(documents)
index_query_engine = index.as_query_engine(similarity_top_k=2)
service_context = ServiceContext.from_defaults(llm=OpenAI(model="gpt-4"))
flare_query_engine = FLAREInstructQueryEngine(
    query_engine=index_query_engine,
    service_context=service_context,
    max_iterations=7,
    verbose=True,
)

# Use your advanced RAG
response = flare_query_engine.query(
    "Can you tell me about the author's trajectory in the startup world?"
)

4.3.2 迭代式检索-生成型RAG:

  1. 在某些复杂情况下,可能需要多步推理才能为用户查询提供有用且相关的答案。

from llama_index.query_engine import RetryQueryEngine
from llama_index.evaluation import RelevancyEvaluator

### Recipe
### Build a RetryQueryEngine which performs retrieval-generation cycles
### until it either achieves a passing evaluation or a max number of
### cycles has been reached

# Build RetryQueryEngine
documents = SimpleDirectoryReader("./data/paul_graham").load_data()
index = VectorStoreIndex.from_documents(documents)
base_query_engine = index.as_query_engine()
query_response_evaluator = RelevancyEvaluator() # evaluator to critique 
                                                # retrieval-generation cycles
retry_query_engine = RetryQueryEngine(
    base_query_engine, query_response_evaluator
)

# Use your advanced rag
retry_response = retry_query_engine.query("A user query")

五、RAG的评估方面

评估RAG系统当然是至关重要的。在他们的综述论文中,高云帆等人在附带的RAG备忘单的右上角部分指出了7个评估方面。LlamaIndex库包含几个评估抽象以及与RAGAs的集成,以帮助构建者通过这些评估方面的视角,了解他们的RAG系统在多大程度上达到了成功要求。下面,我们列出了一些精选的评估笔记本指南。

  1. Answer Relevancy and Context Relevancy
  2. Faithfulness
  3. Retrieval Evaluation
  4. Batch Evaluations with BatchEvalRunner

你现在能够构建高级RAG了

在阅读了这篇博客文章之后,我们希望你感觉更有能力、更有信心去应用这些复杂的技术来构建高级RAG系统了!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2325979.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

【Qt】游戏场景和图元

一:图元 advance函数: 在 Qt 框架里,QGraphicsItem 是用于在 QGraphicsScene 中绘制图形项的基类。advance(int phase) 是 QGraphicsItem 类的一个虚函数,其主要用途是让图形项在场景的动画或更新过程里完成特定的逻辑操作。 p…

开源的CMS建站系统可以随便用吗?有什么需要注意的?

开源CMS建站系统虽然具有许多优点,但并非完全“随便用”。无论选哪个CMS系统,大家在使用的时候,可以尽可能地多注意以下几点: 1、版权问题 了解开源许可证:不同的开源CMS系统采用不同的开源许可证,如GPL、…

初始ARM

ARM最基础的组成单元。 最小系统:能系统能够正常工作的最少器件构成的系统 。 一、CPU基础定义 1. 核心定位 计算机三大核心部件: CPU(运算与控制)内部存储器(数据存储)输入/输出设备(数据交互…

DataPlatter:利用最少成本数据提升机器人操控的泛化能力

25年3月来自中科院计算所的论文“DataPlatter: Boosting Robotic Manipulation Generalization with Minimal Costly Data”。 视觉-语言-动作 (VLA) 模型在具身人工智能中的应用日益广泛,这加剧对多样化操作演示的需求。然而,数据收集的高成本往往导致…

诠视科技MR眼镜如何安装apk应用

诠视科技MR眼镜如何安装apk应用 1、使用adb工具安装1.1 adb工具下载1.2 解压adb文件1.3 使用adb安装apk1.4 常用adb命令 2、拷贝到文件夹安装 1、使用adb工具安装 1.1 adb工具下载 点击下面的链接开始下载adb工具,下载结束以后解压文件。 下载链接: https://down…

搭建前端环境和后端环境

搭建前端环境 ①、安装vscode,并安装相应的插件工具 ②、安装node.js,可以选择当前版本,或者其他版本 ③、创建工作区 创建一个空文件夹,然后通过vscode工具打开,保存为后缀名为.code-workspace ④、从gitee…

Polhemus FastScan 单摄像头3D激光扫描器

FastSCAN Cobra是Polhemus公司研制的手持激光扫描仪。与以前的产品比较,它节省了30%的费用,体积也减小了一半 ,但仍然保留了所有功能,使用和携带都更加方便。作为超小的手持激光扫描仪,FastSCAN Cobra对扫描三维物体具…

召唤数学精灵

1.召唤数学精灵 - 蓝桥云课 问题描述 数学家们发现了两种用于召唤强大的数学精灵的仪式,这两种仪式分别被称为累加法仪式 A(n) 和累乘法仪式 B(n)。 累加法仪式 A(n) 是将从1到 n 的所有数字进行累加求和,即: A(n)12⋯n 累乘法仪式 B(n) …

2025图像处理和深度学习国际学术会议(IPDL 2025)

重要信息 官网:www.IPDL.xyz 时间:2025年4月11-13日 地点:中国-成都 简介 随着深度学习和图像处理技术的迅速发展,相关技术的应用逐渐渗透到各个行业,如医疗影像分析、自动驾驶、安防监控和智能制造等。这些应用的…

使用uni-app框架 写电商商城前端h5静态网站模板项目-手机端-前端项目练习

以前用vue2 分享过一个电商商城前端静态网站项目-电脑端,需要的小伙伴还是很多的,最近又花了几天更新了一个 手机端的 电商商城h5项目,今天也分享一下实现方案。 对于以前写的 电商商城前端静态网站模板-电脑端,有兴趣的小伙伴 可…

远心镜头原理

文章目录 原理特点分类应用领域 参考:B站优致谱视觉 原理 远心镜头的工作原理基于其特殊的光学设计,旨在解决普通镜头存在的视差问题。它通过将镜头的光轴与成像面垂直,并使主光线平行于光轴,从而确保在一定的物距范围内&#xf…

centos7修复漏洞CVE-2023-38408

漏洞描述: CVE-2023-38408 是 OpenSSH 组件中的一个远程代码执行(RCE)漏洞,影响 OpenSSH 代理(ssh-agent)的安全性。该漏洞被发现于 2023 年 7 月,并被标记为 高危(CVSS 评分 7.3&a…

uniapp微信小程序封装navbar组件

一、 最终效果 二、实现了功能 1、nav左侧返回icon支持自定义点击返回事件(默认返回上一步) 2、nav左侧支持既显示返回又显示返回首页icon 3、nav左侧只显示返回icon 4、nav左侧只显示返回首页icon 5、nav左侧自定义left插槽 6、nav中间支持title命名 7…

系统思考与心智模式

我们的生命为什么越来越长?因为有了疫苗,有了药物。可这些是怎么来的?是因为我们发现了细菌的存在。但在很久以前,医生、助产士甚至都不洗手——不是他们不负责,而是根本不知道“细菌”这回事。那细菌是怎么被发现的&a…

数据库--数据库设计

目录: 1.数据库设计和数据模型 2.概念结构设计:E-R模型 3.逻辑结构设计:从E-R图到关系设计 4.数据库规范化设计理论 5.数据库规范化设计实现 1.数据库设计和数据模型 数据库设计会影响数据库自身和上层应用的性能。 一个好的数据库设计可以提…

[Mac]利用hexo-theme-fluid美化个人博客

接上文,使用Fluid美化个人博客 文章目录 一、安装hexo-theme-fluid安装依赖指定主题创建「关于页」效果展示 二、修改个性化配置1. 修改网站设置2.修改文章路径显示3.体验分类和标签4.左上角博客名称修改5.修改背景图片6.修改关于界面 欢迎大家参观 一、安装hexo-theme-fluid 参…

黑盒测试的场景法(能对项目业务进行设计测试点)

定义: 通过运用场景来对系统的功能点或业务流程的描述,设计用例遍历场景,验证软件系统功能的正确性从而提高测试效果的一种方法。 场景法一般包含基本流和备用流。 基本流:软件功能的正确流程,通常一个业务只存在一个基本流且基本流有一个…

通过Anaconda Prompt激活某个虚拟环境并安装第三方库

打开 Anaconda Prompt 在Windows中,可以通过开始菜单搜索 Anaconda Prompt 来打开。(红色箭头指向的地方。) 激活虚拟环境 输入以下命令来激活您的虚拟环境(假设虚拟环境名称为 myenv): conda activate…

全长约8.3公里!宁波象山港跨海大桥南中塔柱云端合龙

快科技3月31日消息,据报道,由中国交建二航局承建的宁波象山港跨海大桥顺利完成南中塔柱合龙施工,标志着这一重大交通工程取得阶段性突破。 这座连接宁波鄞州区与象山县的跨海通道全长8.3公里,其标志性的南主塔采用创新"钻石…

使用 2 端口探头测量 40 uOhm(2000 安培)PDN 的挑战 – 需要多少 CMRR?

部分 1 / 3 本文是 3 部分系列的第一部分: 第 2 部分 - 测量结果! 第 3 部分 - 使用另一台 VNA 的测量结果 介绍 我们大多数人都知道 2 端口测量中的接地回路。我们大多数人也都知道,我们需要引入接地回路隔离器来纠正错误。如果没有&…