下一个项目的前13个高级抹布技术

AI可以大规模产生真正相关的答案吗？我们如何确保它了解复杂的多转交谈？我们如何避免自信地吐出不正确的事实？这些是现代AI系统所面临的挑战，尤其是使用抹布建造的挑战。 RAG将文件检索的力量与语言产生的流利性结合在一起，从而使系统可以通过上下文感知的，扎根的回答回答问题。尽管基本的抹布系统可以很好地完成直接的任务，但它们通常会偶然发现复杂的查询，幻觉和跨较长互动的上下文保留。那就是高级抹布技术的来源。

在此博客中，我们将探讨如何升级您的抹布管道，增强堆栈的每个阶段：索引，检索和一代。我们将浏览强大的方法（具有动手代码），这些方法可以帮助提高相关性，降低噪音并扩展系统的性能 - 无论您是建立医疗保健助理，教育导师还是企业知识机器人。

目录

• 基本抹布在哪里不足？
• 索引和分块：建立强大的基础
  • HNSW：分层通航的小世界
  • 语义块
  • 基于语言模型的块
  • 利用元数据：添加上下文
  • 使用Gliner产生元数据
• 检索：找到正确的信息
  • 混合搜索
  • 查询重写
  • LLM及时基于上下文压缩检索
  • 微调嵌入模型
• 一代：制定高质量的回应
  • 自动注射以删除无关的信息
  • 重新脉络检索的对象
  • 微调LLM
  • 使用筏：适应语言模型到特定领域的抹布
• 结论

基本抹布在哪里不足？

让我们看一下基本的抹布框架：

此抹布系统体系结构显示了矢量存储中块嵌入的基本存储。第一步是加载文档，然后使用各种块技术将其拆分或切碎，然后使用嵌入模型嵌入它，以便LLM可以轻松理解它。

该图像描述了抹布的检索和生成步骤；用户问一个问题，然后我们的系统通过搜索矢量存储来根据问题提取结果。然后，检索到的内容与问题一起传递给LLM，LLM提供了结构化的输出。

基本的破布系统有明显的局限性，尤其是在苛刻的情况下。

• 幻觉：一个主要问题是幻觉。该模型创建的内容实际上是错误的或源文档不支持的内容。这损害了可靠性，尤其是在精度至关重要的医学或法律等领域。
• 缺乏域特异性：标准抹布模型与专门主题斗争。在不适应域的特定细节的情况下，该系统可能会发现无关紧要或不准确的信息。
• 复杂的对话：基本的抹布系统在复杂的查询或多转交谈时遇到麻烦。他们经常在互动中失去背景。这会导致断开或不完整的答案。抹布系统必须处理增加的查询复杂性。

因此，我们将通过抹布堆栈的每个部分进行高级抹布技术，即索引，检索和发电。我们将使用开源库和资源讨论改进。无论您是建立医疗保健聊天机器人，教育机器人还是其他应用程序，这些先进的破布技术通常都适用。他们将改善大多数抹布系统。

让我们从高级的抹布技术开始！

索引和分块：建立强大的基础

良好的索引对于任何抹布系统都是必不可少的。第一步涉及我们如何实现，分解和存储数据。让我们探索索引数据的方法，专注于索引和块文本以及使用元数据。

1。HNSW：层次通航的小世界

层次可导航的小世界（HNSW）是在大型数据集中查找类似项目的有效算法。它有助于使用基于图形的结构化方法快速定位近似最近的邻居（ANN）。

• 接近图：HNSW构建一个图形，每个点连接到附近的点。这种结构允许有效搜索。
• 层次结构：该算法将指点组织成多层。顶层连接遥远的点，而下层连接更紧密的点。此设置加快了搜索过程。
• 贪婪的路由：HNSW使用一种贪婪的方法来寻找邻居。它从高级点开始，然后移至最近的邻居，直到达到局部最低限度为止。此方法减少了查找类似项目所需的时间。

HNSW如何工作？

HNSW的工作包括几个关键组成部分：

1. 输入层：每个数据点在高维空间中表示为向量。
2. 图形结构：
   • 节点一次添加到图。
   • 每个节点都根据概率函数分配给图层。该函数决定将节点放入更高层的可能性。
   • 该算法平衡了连接数量和搜索速度。
3. 搜索过程：
   • 搜索从顶层的特定入口点开始。
   • 该算法在每个步骤中移至最近的邻居。
   • 一旦达到局部最小值，它就会转移到下一个下层并继续搜索，直到找到底层的最接近点为止。
4. 参数：
   • M ：连接到每个节点的邻居数。
   • efconstruction ：此参数会影响算法构建图时考虑的算法数量。
   • EFSearch ：此参数会影响搜索过程，确定要评估多少邻居。

HNSW的设计使其可以快速准确地找到类似的项目。这使其成为需要在大型数据集中进行有效搜索的任务的强大选择。

该图像描述了简化的HNSW搜索：从“入口点”（蓝色）开始，该算法将图导向“查询向量”（Yellow）。 “最近的邻居”（条纹）是通过基于接近度遍历边缘的。这说明了导航图的核心概念，以进行有效的近似近似邻居搜索。

手上的HNSW

按照以下步骤使用Faiss实施层次可导航的小世界（HNSW）算法。本指南包括示例输出以说明过程。

步骤1：设置HNSW参数

首先，定义HNSW索引的参数。您需要指定向量的大小和每个节点的邻居数。

进口faiss
导入numpy作为NP
＃设置HNSW参数
d = 128＃向量的大小
M = 32＃每个节点的邻居数

步骤2：初始化HNSW索引

使用上面定义的参数创建HNSW索引。

 ＃初始化HNSW索引
index = faiss.indexhnswflat（d，m）

步骤3：设置EFConstruction

在将数据添加到索引之前，请设置“ fconstruction”参数。该参数控制构建索引时考虑的算法有多少邻居。

 efconstruction = 200＃efconstruction的示例值
index.hnsw.efconstruction = efconstruction

步骤4：生成样本数据

对于此示例，生成随机数据以索引。在这里，`xb`表示要索引的数据集。

 ＃生成向量的随机数据集
n = 10000＃索引的向量数
xb = np.random.random（（（n，d））。astype（'float32'）
＃将数据添加到索引
index.add（xb）＃构建索引

步骤5：设置EFSearch

构建索引后，设置“ fsearch”参数。此参数会影响搜索过程。

 efsearch = 100＃efsearch的示例值
index.hnsw.efsearch = efsearch

步骤6：执行搜索

现在，您可以搜索查询向量的最近的邻居。在这里，`xq`代表查询向量。

 ＃生成随机查询向量
NQ = 5＃查询向量的数量
xq = np.random.random（（（nq，d））。astype（'float32'）
＃执行搜索顶部K最近的邻居
k = 5＃最近的邻居数量
距离，索引= index.search（xq，k）
＃输出结果
打印（“查询向量：\ n”，xq）
打印（“ \ nnearest邻居索引：\ n”，索引）
print（“ \ nnearest最邻居距离：\ n”，距离）

输出

查询向量：<br><br> [[0.12345678 0.23456789 ... 0.98765432]<br><br> [0.23456789 0.34567890 ... 0.87654321]<br><br> [0.34567890 0.45678901 ... 0.76543210]<br><br> [0.45678901 0.56789012 ... 0.65432109]<br><br> [0.56789012 0.67890123 ... 0.54321098]]<br><br>最近的邻居指数：<br><br> [[123 456 789 101 112]<br><br> [234 567 890 123 134]<br><br> [345 678 901 234 245]<br><br> [456 789 012 345 356]<br><br> [567 890 123 456 467]]<br><br>最近的邻居距离：<br><br> [[0.123 0.234 0.345 0.456 0.567]<br><br> [0.234 0.345 0.456 0.567 0.678]<br><br> [0.345 0.456 0.567 0.678 0.789]<br><br> [0.456 0.567 0.678 0.789 0.890]<br><br> [0.567 0.678 0.789 0.890 0.901]]

2。语义块

这种方法基于含义，而不仅仅是固定尺寸。每个块代表一个连贯的信息。我们计算句子嵌入之间的余弦距离。如果两个句子在语义上相似（低于阈值），则它们位于相同的部分。这基于内容的含义创建了不同长度的块。

• 优点：创造更连贯和有意义的块，改善检索。
• 缺点：需要更多的计算（使用基于BERT的编码器）。

动手语义块

来自langchain_experiment.text_splitter导入semanticchunker
来自langchain_openai.embeddings进口openaiembeddings
text_splitter = semanticchunker（openaiembeddings（））
docs = text_splitter.create_documents（[[document]）
打印（文档[0] .page_content）

该代码利用了Langchain的Semanticchunker，该语法将文档分为使用OpenAI嵌入的语义相关块。它创建了文档块，每个块旨在捕获连贯的语义单元，而不是任意文本段。这

3。基于语言模型的块

此高级方法使用语言模型从文本中创建完整的语句。每个块在语义上都是完整的。语言模型（例如，一个70亿个参数模型）处理文本。它将其分解为单独有意义的陈述。然后，该模型将它们结合到块中，平衡完整性和环境。该方法在计算上很重，但具有很高的精度。

• 优点：适应文本的细微差别并创造高质量的块。
• 缺点：计算昂贵；可能需要微调特定用途。

基于语言模型的动手大块

异步def generate_contexts（文档，块）：
异步def Process_chunk（块）：
响应=等待client.chat.completions.create（
型号=“ gpt-4o”，
消息= [
{“角色”：“系统”，“ content”：“生成一个简短的上下文，解释了此块与完整文档的关系。
{"role": "user", "content": f"<document> \n{document} \n</document> \nHere is the chunk we want to situate within the whole document \n<chunk> \n{chunk} \n</chunk> \nPlease give a short succinct context to situate this chunk within the overall document for the purposes of improving search retrieval of the chunk. Answer only with the succinct上下文，别无其他。”}
]，，
温度= 0.3，
max_tokens = 100
）
context =响应。选择[0] .message.content
返回f“ {context} {块}”
＃同时处理所有块
contextual_chunks =等待asyncio.gather（
*[Process_chunk（块）用于块中的块]
）
返回contextual_chunks

此代码段使用LLM（可能通过client.chat.completions.create Call的OpenAI的GPT-4O）来为文档的每个块生成上下文信息。它异步处理每个块，促使LLM解释块与完整文档的关系。最后，它返回以其生成的上下文准备的原始块的列表，有效地丰富了它们以改进搜索检索。

4。利用元数据：添加上下文

用元数据添加和过滤

元数据提供了额外的背景。这提高了检索准确性。通过包括元数据，例如日期，患者年龄和预先存在的条件，您可以在搜索过程中滤除无关的信息。过滤缩小搜索，从而使检索更加高效和相关。索引时，将元数据存储在文本旁边。

例如，医疗保健数据包括年龄，访问日期和患者记录中的特定状况。使用此元数据过滤搜索结果。这样可以确保系统仅检索相关信息。例如，如果查询与儿童有关，请筛选出18岁以上患者的记录。这会降低噪音并提高相关性。

例子

块＃1

来源元数据：{'id'：'doc：1c6f3e3f7ee14027BC856822871572DC：26E9AAC7D5494208A56FF0C6CBBBFDA20'

源文本：

 2.2.1第一个不完整定理<br><br>在他的逻辑之旅中（Wang 1996）Hao Wang出版了<br><br>材料的全文Gödel已写（应王的要求）<br><br>关于他发现不完整定理。这材料有<br><br>构成了王的“关于库尔特的一些事实<br><br>哥德尔，并被戈德尔（Gödel）阅读和批准：

块＃2

来源元数据：{'id'：'doc：1c6f3e3f7EE14027BC856822871572DC：D15F62C453C64072B768E13608E136080CB5BA

源文本：

第一个不完整定理提供了一个反例<br><br>通过展示算术陈述，这都不是<br><br>在Peano算术中可证明也可以反驳，尽管在<br><br>标准型号。第二个不完整定理表明<br><br>算术的一致性无法在算术本身中证明。因此<br><br>戈德尔的定理证明了<br><br>希尔伯特计划，如果要以那些特定的特征为特征<br><br>Desiderata，一致性和完整性。

在这里，我们可以看到元数据包含块的独特ID和来源，这些ID和源提供了更多的上下文，并有助于轻松检索。

5。使用Gliner产生元数据

您不会总是有很多元数据，但是使用像Gliner这样的模型可以随时生成元数据！ Gliner在摄入过程中标记并标记块以创建元数据。

执行

给每个块的Gliner带有标签以识别。如果找到标签，它将标记它们。如果没有匹配的信心，则不会产生标签。
一般运行良好，但可能需要对利基数据集进行微调。提高检索准确性，但增加了处理步骤。
Gliner可以解析传入的查询并将其与用于过滤的元数据标签相匹配。

Gliner：使用双向变压器演示的命名实体识别的通才模型：单击此处

这些技术建立了强大的抹布系统。它们可以从大型数据集中有效检索。块和元数据使用的选择取决于您数据集的特定需求和功能。

检索：找到正确的信息

现在，让我们专注于抹布中的“ R”。我们如何改善矢量数据库的检索？这是关于检索与查询有关的所有文档。这大大增加了LLM可以产生高质量结果的机会。这是几种技术：

6。混合搜索

结合矢量搜索（查找语义含义）和关键字搜索（查找确切的匹配）。混合搜索使用两者的优势。在AI中，许多术语是特定的关键字：算法名称，技术术语，LLMS。仅矢量搜索可能会错过这些。关键字搜索确保考虑这些重要术语。结合两种方法都会创建一个更完整的检索过程。这些搜索同时进行。

使用加权系统合并并排名结果。例如，使用编织，您可以调整alpha参数以平衡向量和关键字结果。这创建了一个组合的排名列表。

• 优点：平衡精度和回忆，提高检索质量。
• 缺点：需要仔细调整重量。

动手混合搜索

来自langchain_community.trievers导入WeaviateHybridSearchRiever
来自langchain_core.documents导入文档
retriever = WeaviateHybridSearchRiever（
客户端=客户端，
index_name =“ langchain”，
text_key =“ text”，
属性= []，
create_schema_if_missing = true，
）
retriever.invoke（“ AI的道德含义”）

该代码初始化了一个从编织矢量数据库检索文档的编织杂交搜索搜索器。它将矢量搜索和关键字搜索结合在编织的混合检索功能中。最后，它执行了使用这种混合方法检索相关文档的查询“ AI的道德含义”。

7。查询重写

认识到人类查询可能不是数据库或语言模型的最佳选择。使用语言模型重写查询可显着改善检索。

1. 重写矢量数据库：这将用户的初始查询转换为对数据库友好的格式。例如，“什么是AI代理以及为什么它们是2025年的下一件大事”可能会变成“ 2025年AI代理商的大事”。我们可以使用任何LLM重写查询，以捕获查询的重要方面。
2. 提示语言模型的提示：这涉及自动创建提示以优化与语言模型的交互。这提高了结果的质量和准确性。我们可以使用诸如DSPY之类的框架来帮助此或任何LLM来重写查询。这些重写的查询和提示可确保搜索过程检索相关文档，并有效提出语言模型。

多查询检索

检索可以根据查询措辞的细微变化而产生不同的结果。如果嵌入无法准确反映数据的含义，则此问题可能会变得更加明显。为了应对这些挑战，经常使用及时的工程或调整，但是此过程可能很耗时。

多QueryReTriever简化了此任务。它使用大型语言模型（LLM）根据单个用户输入从不同角度创建多个查询。对于每个生成的查询，它都会检索一组相关文档。通过结合所有查询的独特结果，多QueryReTriever提供了更广泛的潜在相关文档。这种方法增加了寻找有用信息的机会，而无需进行大量的手动调整。

来自langchain_openai进口chatopenai
chatgpt = chathopenai（model_name =“ gpt-4o”，温度= 0）
来自langchain.retrievers.multi_query import MultiqueryReTriever
＃设置查询的记录
导入记录
samelity_retriever3 = chroma_db3.as_retriever（search_type =“相似性”，
search_kwargs = {“ k”：2}）
mq_retriever = multiqueryRiever.from_llm（
retiever = samelity_retriever3，llm = chatgpt，
include_original = true
）
logging.basicconfig（）
＃我们可以看到LLM生成了哪些查询
logging.getLogger（“ langchain.retrievers.multi_query”）。setlevel（logging.info）
查询=“印度的首都是什么？”
docs = mq_retriever.invoke（查询）
文档

此代码使用Langchain设置了多电量检索系统。它产生了输入查询的多种变化（“印度的首都是什么？”）。然后，这些变化用于通过相似性检索器查询Chroma Vector数据库（Chroma_DB3），旨在扩大搜索并捕获多样化的相关文档。多QueryReTriever最终汇总并返回检索到的文档。

输出

[document（metadata = {'aptict_id'：'5117'，'title'：'new delhi'}，<br> page_content ='new delhi（）是印度的首都，也是工会领土<br> 德里的大城。它有一个很古老的历史，有几个<br> 城市居住昂贵的纪念碑。在传统的印度人中<br> 地理位置属于北印度地区。该市有一个区域<br> 约42.7 \ xa0km。新德里的人口约为940万人。”），<br><br> document（metadata = {'aptrict_id'：'4062'，'title'：'kolkata'}，<br> page_content =“ kolkata（2001年1月1日之前拼写加尔各答）是<br> 印度西孟加拉邦的首都。这是第二大<br> 孟买之后的印度城市。它在胡格利河的东岸。<br> 当称为加尔各答时，它包括郊区。这使它成为第三<br> 印度最大的城市。这也使它成为世界第八大<br> 联合国定义的大都市地区。加尔各答作为<br> 英国拉吉期间印度的首都直到1911年。加尔各答曾经是<br> 工业和教育中心。但是，它目睹了政治<br> 自1954年以来的暴力和经济问题。自2000年以来，加尔各答已发生<br> 经济增长。像印度的其他大都市一样，加尔各答<br> 在贫困，污染和交通拥堵方面挣扎。”），<br><br>文档（metadata = {'aptrict_id'：'22215'，'title'：'状态和联合<br> 印度领土'}，page_content ='印度共和国分为<br> 28个州和八个联盟领土在内<br> 资本领域。”）]

8。基于LLM提示的上下文压缩检索

上下文压缩有助于提高检索文档的相关性。这可以通过两种主要方式发生：

1. 提取相关内容：删除与查询无关的已检索文档的部分。这意味着只保留回答问题的部分。
2. 过滤无关的文档：不包括与查询无关的文档，而无需更改文档本身的内容。
   

为了实现这一目标，我们可以使用llmchainextractor，该llmchainextractor审查了最初返回的文档并仅提取查询的相关内容。它也可能删除完全无关的文件。

这是使用Langchain实施此方法的方法：

从langchain.retrievers导入contextualCompressionReTriever
来自langchain.retrievers.document_compressor
来自langchain_openai进口chatopenai
＃初始化语言模型
chatgpt = chathopenai（model_name =“ gpt-4o”，温度= 0）

＃设置一个相似之处

samelity_retriever = chroma_db3.as_retriever（search_type =“相似性”，search_kwargs = {“ k”：3}）

＃创建提取器以获取相关内容

compressor = llmchainextractor.from_llm（llm = chatgpt）

＃结合猎犬和提取器

compression_retriever = contextualCompressionRiever（base_compressor = compressor，base_retriever = samelity_retriever）

＃示例查询

查询=“印度的首都是什么？”
docs = compression_retriever.invoke（查询）
打印（文档）

输出：

 [document（metadata = {'aptict_id'：'5117'，'title'：'new delhi'}，<br> page_content ='新德里是印度的首都，也是联合领土<br>德里的大型。'）]

对于其他查询：

查询=“印度的旧首都是什么？”
docs = compression_retriever.invoke（查询）
打印（文档）

输出

[document（metadata = {'aptict_id'：'4062'，'title'：'kolkata'}，<br> page_content ='加尔各答在英国拉吉期间担任印度首都<br> 直到1911年。'）]

“ llmchainfilter”提供了一种更简单但有效的过滤文档的方法。它使用LLM链来决定要保留哪些文档以及在不更改文档内容的情况下丢弃哪些文档。

这是实现过滤器的方法：

来自langchain.retrievers.document_compressor
＃设置过滤器
_filter = llmchainfilter.from_llm（llm = chatgpt）
＃结合猎犬和过滤器
compression_retriever = contextualcompressionretriever（base_compressor = _filter，base_retriever = samelity_retriever）

＃示例查询
查询=“印度的首都是什么？”
docs = compression_retriever.invoke（查询）
打印（文档）

输出

[document（metadata = {'aptict_id'：'5117'，'title'：'new delhi'}，<br> page_content ='新德里是印度的首都，也是联合领土<br> 德里的大型。'）]

对于另一个查询：

查询=“印度的旧首都是什么？”
docs = compression_retriever.invoke（查询）
打印（文档）

输出：

 [document（metadata = {'aptict_id'：'4062'，'title'：'kolkata'}，<br> page_content ='加尔各答在英国拉吉期间担任印度首都<br> 直到1911年。'）]

这些策略通过关注相关内容来帮助完善检索过程。 “ llmchainextractor”仅提取文档的必要部分，而“ llmchainfilter”决定要保留哪些文档。两种方法都提高了检索到的信息的质量，使其与用户的查询更加相关。

9。微调嵌入模型

预训练的嵌入模型是一个良好的开始。在数据上进行微调这些模型可大大改善检索。

选择合适的模型：对于医学等专业领域，选择对相关数据进行预训练的模型。例如，您可以使用PubMed搜索日志中的25500万查询库对进行大规模训练的查询和文档编码器。

用正面和负面对进行微调：收集您自己的数据，并创建一对相似（正）和不同（负）示例。微调模型以了解这些差异。这有助于模型学习特定领域的关系，改善检索。

• 优点：提高检索性能。
• 缺点：需要精心创建的培训数据。

这些组合的技术创造了强大的检索系统。这提高了对LLM的对象的相关性，从而提高了生成质量。

另请阅读以下内容：训练和填充嵌入模型，句子变形金刚V3

一代：制定高质量的回应

最后，让我们讨论提高语言模型（LLM）的发电质量。目的是提供与提示尽可能相关的LLM上下文。无关的数据可以触发幻觉。以下是更好一代的提示：

10。自动删除无关信息的信息

自动输入过滤从数据库中检索到的无关信息。这样可以防止LLM被误导。

• 检索和分数相似性：进行查询时，以相似性得分检索了多个对象。
• 识别和切断：使用相似性分数找到一个分数显着下降的截止点。将对象排除在此点之外。这样可以确保仅将最相关的信息提供给LLM。例如，如果您检索六个对象，那么第四个对象可能会急剧下降。通过查看变更速率，您可以确定要排除哪些对象。

动手

来自langchain_openai进口openaiembeddings
来自langchain_pinecone导入pineconevectorstore
从输入导入列表
来自langchain_core.documents导入文档
来自langchain_core.runnables进口链
vectorstore = pineconevectorstore.from_documents（
文档，index_name =“ sample”，embedding = openaiembeddings（）
）
@链
Def Retriever（查询：STR）：
docs，分数= zip（*vectorstore.simurility_search_with_score（query））
对于DOC，在ZIP中得分（DOC，分数）：
doc.metadata [“得分”] =得分
返回文档
结果= retriever.invoke（“恐龙”）
结果

此代码段使用Langchain和Pinecone进行相似性搜索。它使用OpenAI嵌入嵌入文档，将其存储在Pinecone矢量存储中，并定义回收函数。猎犬搜索类似于给定查询（“恐龙”）的文档，计算相似性分数，并在返回结果之前将这些分数添加到文档元数据中。

输出

[文档（page_content ='在她的第二本书中，西蒙斯博士深入研究<br> 围绕AI发展和部署的道德考虑。这是<br> 开发人员面临的困境的大开眼室检查，<br> 政策制定者和整个社会。'，元数据= {}），<br><br>文档（page_content ='综合分析<br> 人工智能，从成立到未来的前景。博士<br> 西蒙斯涵盖了道德考虑，潜力和威胁<br> ai。'，元数据= {}），<br><br>文档（page_content =“在他对'共生'的后续行动中，斯特林教授<br> 看看AI在我们日常的微妙，未知的存在和影响<br> 生命。它揭示了AI如何编织到我们的日常工作中，通常没有<br> 我们的明确实现。”，元数据= {}），<br><br>文档（page_content ='斯特林教授探索和谐的潜力<br>人与人工智能之间的共存。这本书讨论了<br> 如何将AI纳入社会中<br>方式。'，元数据= {}）]

我们可以看到，它还给出了与之相似的分数，我们可以根据阈值值切断。

11。重读检索的对象

Reranking使用更高级的模型重新评估和重新排序最初检索的对象。这提高了最终检索集的质量。

• 过度取回：最初检索比所需的更多对象。
• 应用排名模型：使用高延迟模型（通常是交叉编码器）重新评估相关性。该模型将查询和每个对象成对以重新评估相似性。
• 重新排序结果：基于新评估，重新排序对象。将最相关的结果放在顶部。这样可以确保将最相关的文档优先考虑，从而改善了给出的LLM数据。

动手重读检索的对象

从langchain.retrievers导入contextualCompressionReTriever
来自langchain.retrievers.document_compressor
来自langchain_openai进口chatopenai

llm = chatopenai（温度= 0）

compressor = flashrankrerank（）
compression_retriever = contextualCompressionRiever（
base_compressor = Compressor，base_retriever = retriever
）
compressed_docs = compression_retriever.invoke（
“总统对Ketanji Jackson Brown有何评论”
）
打印（compressed_docs中的DOC [DOC.METADATA [“ ID”））
pretty_print_docs（compressed_docs）

该代码段使用在ContextualCompressionReTriever中利用FlashRankrerank来提高检索到的文档的相关性。它特别是由基本猎犬（由猎犬代表）获得的重读文件，其与查询的相关性“总统对Ketanji Jackson Brown有何评论”。最后，它打印文档ID和压缩的，重新的文档。

输出

[0，5，3]<br><br>文件1：<br><br>总统承担的最严重的宪法责任之一是提名某人在美国最高法院任职。<br><br>我在4天前做到了这一点，当时我提名了上诉法院法官Ketanji Brown Jackson。我们国家的顶级法律思想之一，他将继续布雷耶大法官的卓越遗产。<br><br> --------------------------------------------------------------------------------------------------------------------------------------------------------<br><br>文件2：<br><br>他遇到了乌克兰人民。<br><br>从总统Zelenskyy到每个乌克兰人，他们的无所畏惧，勇气，决心都激发了世界。<br><br>一群公民用自己的尸体阻挡坦克。从学生到退休人员的每个人都变成了捍卫自己家园的士兵。<br><br> Zelenskyy在对欧洲议会的讲话中说，在这场斗争中，“光将击败黑暗。”乌克兰驻美国大使在今晚在这里。<br><br> --------------------------------------------------------------------------------------------------------------------------------------------------------<br><br>文件3：<br><br>今晚，我宣布司法部将命名大流行欺诈的首席检察官。<br><br>到今年年底，赤字将不到我上任前的一半。<br><br>一年中唯一将赤字减少超过一万亿美元的总统。<br><br>降低成本也意味着要求更多的竞争。<br><br>我是资本主义，但没有竞争的资本主义不是资本主义。<br><br>它是剥削的，并提高了价格。

它的输出鞋根据相关性重新恢复了块。

12。微调LLM

对特定于域数据的LLM进行微调大大提高了其性能。例如，使用Meditron 70B之类的模型。这是Llama 2 70B的微调版本，用于医疗数据，使用两者：

无监督的微调：继续对大量域特异性文本（例如PubMed文献）进行预训练。

监督微调：进一步使用针对特定领域任务的监督学习（例如医疗多项选择问题）进一步完善模型。这种专门的培训有助于模型在目标域中表现良好。它的表现优于其基本模型和更大的专业模型，例如GPT-3.5在特定任务上。

This image denotes the process of fine-tuning in task-specific examples. This approach allows developers to specify desired outputs, encourage certain behaviors, or achieve better control over the model's responses.

13. Using RAFT: Adapting Language Model to Domain-Specific RAG

RAFT, or Retrieval-Augmented fine-tuning, is a method that improves how large language models (LLMs) work in specific fields. It helps these models use relevant information from documents to answer questions more accurately.

• Retrieval-Augmented Fine Tuning : RAFT combines fine-tuning with retrieval methods. This allows the model to learn from both useful and less useful documents during training.
  
• Chain-of-Thought Reasoning : The model generates answers that show its reasoning process. This helps it provide clear and accurate responses based on the documents it retrieves.
• Dynamic Document Handling : RAFT trains the model to find and use the most relevant documents while ignoring those that do not help answer the question.

Architecture of RAFT

The RAFT architecture includes several key components:

1. Input Layer : The model takes in a question (Q) and a set of retrieved documents (D), which include both relevant and irrelevant documents.
2. Processing Layer :
   • The model analyzes the input to find important information in the documents.
   • It creates an answer (A*) that refers to the relevant documents.
3. Output Layer : The model produces the final answer based on the relevant documents while disregarding the irrelevant ones.
4. Training Mechanism : During training, some data includes both relevant and irrelevant documents, while other data includes only irrelevant ones. This setup encourages the model to focus on context rather than memorization.
5. Evaluation : The model's performance is assessed based on its ability to answer questions accurately using the retrieved documents.

By using this architecture, RAFT enhances the model's ability to work in specific domains. It provides a reliable way to generate accurate and relevant responses.

The top-left figure depicts the approach of adapting LLMs to reading solutions from a set of positive and distractor documents in contrast to the standard RAG setup, where models are trained based on the retriever outputs, which is a mixture of both memorization and reading. At test time, all methods follow the standard RAG setting, provided with top-k retrieved documents in the context.

结论

Improving retrieval and generation in RAG systems is essential for better AI applications. The techniques discussed range from low-effort, high-impact methods (query rewriting, reranking) to more intensive processes (embedding and LLM fine-tuning). The best technique depends on your application's specific needs and limits. Advanced RAG techniques, when applied thoughtfully, allow developers to build more accurate, reliable, and context-aware AI systems capable of handling complex information needs.

以上是下一个项目的前13个高级抹布技术的详细内容。更多信息请关注PHP中文网其他相关文章！