检索增强生成RAG系列4--RAG优化之问题优化

linmoo1986

已于 2024-07-03 11:33:36 修改

阅读量1.1k

点赞数 18

分类专栏： RAG实践文章标签： RAG Multi-Query RAG-Fusion IR-CoT Decomposition Least-to-Most Step-back

于 2024-06-30 18:34:15 首次发布

本文链接：https://blog.csdn.net/linwu_2006_2006/article/details/140061638

版权

RAG实践专栏收录该内容

9 篇文章 3 订阅

订阅专栏

在系列2的章节中罗列了对RAG准确度的几个重要关键点，主要包括2方面，这一章就针对第二个方面，问题优化来做详细的讲解以及其解决方案。

在这里插入图片描述

从系列2中，我们知道初始的问题可能对于查询结果不是很好，可能是因为问题表达模糊、语义与文档不一致等等，因此问题优化就是提高RAG准确率的关键节点，那么下面通过问题优化及结果重排等方法，来提供RAG的准确率（注意：其实方法不止以下几种，这里只是写了一些常见的方法技巧供大家参考）

ChatGLM3 是北京智谱华章科技有限公司和清华大学 KEG 实验室联合发布的对话预训练模型。ChatGLM3-6B 是 ChatGLM3 系列中的开源模型，在保留了前两代模型对话流畅、部署门槛低等众多优秀特性的基础上，ChatGLM3-6B 引入了如下特性：
更强大的基础模型： ChatGLM3-6B 的基础模型 ChatGLM3-6B-Base 采用了更多样的训练数据、更充分的训练步数和更合理的训练策略。在语义、数学、推理、代码、知识等不同角度的数据集上测评显示，* ChatGLM3-6B-Base 具有在 10B 以下的基础模型中最强的性能*。
更完整的功能支持： ChatGLM3-6B 采用了全新设计的 Prompt 格式，除正常的多轮对话外。同时原生支持工具调用（Function Call）、代码执行（Code Interpreter）和 Agent 任务等复杂场景。
更全面的开源序列：除了对话模型 ChatGLM3-6B 外，还开源了基础模型 ChatGLM3-6B-Base 、长文本对话模型 ChatGLM3-6B-32K 和进一步强化了对于长文本理解能力的 ChatGLM3-6B-128K。以上所有权重对学术研究完全开放，在填写问卷进行登记后亦允许免费商业使用。
北京智谱华章科技有限公司是一家来自中国的公司，致力于打造新一代认知智能大模型，专注于做大模型创新。

1 Multi-Query

1.1 基本思想

我们知道，在用户做问题提问的时候，有可能存在提问的问题模糊或者说提问的问题与文档的语义不符合，这时候有一种方法就是使用多个角度提问问题。
Multi Query的基本思想是当用户输入问题时，我们让大模型基于用户的问题再生成多个不同角度句子语句，这些问题句子是从不同的视角来补充用户的问题，然后每条问题都会从向量数据库中检索到一批相关文档，最后所有的相关文档都会扔给大模型，这样大模型就能生成更准确的结果。
在这里插入图片描述

1.2 代码演示

这里使用langchain的MultiQueryRetriever进行多问题检索。

import os
import logging
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.retrievers import MultiQueryRetriever
from langchain_huggingface import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
from langchain_community.document_loaders import DirectoryLoader


# 前置工作1：设置日志，可以让MultiQueryRetriever打印出中间生成的问题
logging.basicConfig()
logging.getLogger("langchain.retrievers.multi_query").setLevel(logging.INFO)

# 前置工作2：文档存储，如果已经存储了文档，则不需要该步骤
encode_kwargs = {"normalize_embeddings": False}
model_kwargs = {"device": "cuda:0"}
embeddings = HuggingFaceEmbeddings(
    model_name='/root/autodl-tmp/model/AI-ModelScope/m3e-base',  # 换成自己的embedding模型路径
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
if os.path.exists('VectorStore'):
    db = Chroma(persist_directory='VectorStore', embedding_function=embeddings)
loader = DirectoryLoader("/root/autodl-tmp/doc")  # 换成自己的文档路径
documents = loader.load()
text_spliter = CharacterTextSplitter(chunk_size=256, chunk_overlap=0)
documents = text_spliter.split_documents(documents)
database = Chroma.from_documents(documents, embeddings, persist_directory="VectorStore")
database.persist()
# 前置工作3：创建llm
llm = ChatOpenAI(
    temperature=0.95,
    model="glm-4",
    openai_api_key="你的API KEY",
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)
# 第一步：优化问题，这里使用langchain的MultiQueryRetriever，已经封装好获取多个问题并查询最终文档结果
question = "ChatGLM是什么?"
question_prompt = PromptTemplate(
    input_variables=["question"],
    template="""你是一个人工智能语言模型助手。你的任务是生成给定用户的3个不同版本从矢量数据库中检索相关文档的问题。
    通过对用户问题产生多种视角，您的目标是帮助用户克服一些限制基于距离的相似度搜索。提供这些选择用换行符分隔的问题。原始问题:{question}""",
)
retriever_from_llm = MultiQueryRetriever.from_llm(
    retriever=database.as_retriever(), prompt=question_prompt, llm=llm, include_original=True
)
unique_docs = retriever_from_llm.invoke(question)
context = ''
for doc in unique_docs:
    context = context+"\n"
    context = context + doc.page_content
# 第二步：获得答案
template = """请根据以下内容回答问题:
{context}
问题: {question}
如果不知道，请回答“不知道”。
"""
prompt = ChatPromptTemplate.from_template(template)
chain = prompt | llm
response = chain.invoke({"question": question, "context": context})
print(response)

2 RAG-Fusion

2.1 基本思想

RAG-Fusion相对于Multi-Query其实就是增加一个RRF（逆向排名融合）技术。也就是同样通过原始问题，让大模型生成更多角度问题，再去查询结果，但是结果通过RRF重排，最终将重排结果给大模型生成答案。
在这里插入图片描述

2.2 代码

前置条件：

这里采用智谱AI的API接口，因此可以先去申请一个API KEY（当然你使用其它模型也可以，目前智谱AI的GLM4送token，就拿它来试验吧）
下载m3e-base的embedding模型
给一个文档目录，里面放一些你需要的文档

import os
from langchain.load import dumps, loads
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain_huggingface import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
from langchain_community.document_loaders import DirectoryLoader


# 定义RRF算法函数，代码来自：https://github.com/langchain-ai/langchain/blob/master/cookbook/rag_fusion.ipynb
def reciprocal_rank_fusion(results: list[list], k=60):
    fused_scores = {}
    for docs in results:
        # Assumes the docs are returned in sorted order of relevance
        for rank, doc in enumerate(docs):
            doc_str = dumps(doc)
            if doc_str not in fused_scores:
                fused_scores[doc_str] = 0
            # previous_score = fused_scores[doc_str]
            fused_scores[doc_str] += 1 / (rank + k)

    reranked_results = [
        (loads(doc), score)
        for doc, score in sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
    ]
    return reranked_results


# 前置工作1：文档存储，如果已经存储了文档，则不需要该步骤
encode_kwargs = {"normalize_embeddings": False}
model_kwargs = {"device": "cuda:0"}
embeddings = HuggingFaceEmbeddings(
    model_name='/root/autodl-tmp/model/AI-ModelScope/m3e-base',  # 换成自己的embedding模型路径
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
if os.path.exists('VectorStore'):
    db = Chroma(persist_directory='VectorStore', embedding_function=embeddings)
loader = DirectoryLoader("/root/autodl-tmp/doc")  # 换成自己的文档路径
documents = loader.load()
text_spliter = CharacterTextSplitter(chunk_size=256, chunk_overlap=0)
documents = text_spliter.split_documents(documents)
database = Chroma.from_documents(documents, embeddings, persist_directory="VectorStore")
database.persist()
# 前置工作2：创建llm
llm = ChatOpenAI(
    temperature=0.95,
    model="glm-4",
    openai_api_key="你的API KEY",
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)
# 第一步：优化问题，这里使用langchain的管道，已经封装好获取多个问题并查询最终文档结果，并通过reciprocal_rank_fusion重排
question_prompt = PromptTemplate(
    input_variables=["question"],
    template="""你是一个人工智能语言模型助手。你的任务是生成给定用户的3个不同版本从矢量数据库中检索相关文档的问题。
    通过对用户问题产生多种视角，您的目标是帮助用户克服一些限制基于距离的相似度搜索。提供这些选择用换行符分隔的问题。原始问题:{question}""",
)
question = "ChatGLM是什么"
generate_queries = (
    question_prompt | llm | StrOutputParser() | (lambda x: x.split("\n"))
)
# 可以打印出生成不同角度的问题
# print(generate_queries.invoke({"question": question}))
chain = generate_queries | database.as_retriever().map() | reciprocal_rank_fusion
docs = chain.invoke({"question": question})
context = ''
for doc in docs:
    context = context+"\n"
    context = context + doc[0].page_content
# 第二步：获得答案
template = """请根据以下内容回答问题:
{context}
问题: {question}
如果不知道，请回答“不知道”。
"""
prompt = ChatPromptTemplate.from_template(template)
chain = prompt | llm
response = chain.invoke({"question": question, "context": context})
print(response)

3 HyDE

3.1 基本思想

我们知道有一类问题是用户的问题与文档的语义不一致，这个不一致会导致检索精度不够，因此可以采用HyDE的方法来解决。
HyDE的全称是hypothetical document embedding，使用大模型假设性回答问题，生成一个答案，再使用答案（注意：这里是使用大模型生成的答案，而非使用原始问题）去向量数据库中搜索相关性内容文档。
在这里插入图片描述

3.2 代码演示

前置条件：

这里采用智谱AI的API接口，因此可以先去申请一个API KEY（当然你使用其它模型也可以，目前智谱AI的GLM4送token，就拿它来试验吧）
下载m3e-base的embedding模型
给一个文档目录，里面放一些你需要的文档

import os
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_core.output_parsers import StrOutputParser
from langchain.text_splitter import CharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
from langchain_community.document_loaders import DirectoryLoader


# 前置工作1：文档存储，如果已经存储了文档，则不需要该步骤
encode_kwargs = {"normalize_embeddings": False}
model_kwargs = {"device": "cuda:0"}
embeddings = HuggingFaceEmbeddings(
    model_name='/root/autodl-tmp/model/AI-ModelScope/m3e-base',  # 换成自己的embedding模型路径
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
if os.path.exists('VectorStore'):
    db = Chroma(persist_directory='VectorStore', embedding_function=embeddings)
loader = DirectoryLoader("/root/autodl-tmp/doc")  # 换成自己的文档路径
documents = loader.load()
text_spliter = CharacterTextSplitter(chunk_size=256, chunk_overlap=0)
documents = text_spliter.split_documents(documents)
database = Chroma.from_documents(documents, embeddings, persist_directory="VectorStore")
database.persist()
# 前置工作2：创建llm
llm = ChatOpenAI(
    temperature=0.95,
    model="glm-4",
    openai_api_key="你的API KEY",
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)
# 第一步：优化问题，这里使用langchain的管道，让大模型生成问题的答案
question_prompt = PromptTemplate(
    input_variables=["question"],
    template="""请根据你已有的知识来回答这个问题，字数不超过100字。
    问题:{question}""",
)
question = "ChatGLM是什么"
hyde_answer = (
    question_prompt | llm | StrOutputParser()
)
answer = hyde_answer.invoke({"question": question})
# 打印一下大模型的回答
# print(answer)
# 第二步：通过大模型生成的答案查询向量数据库
retrieval_chain = hyde_answer | database.as_retriever()
docs = retrieval_chain.invoke({"question":question})
context = ''
for doc in docs:
    context = context+"\n"
    context = context + doc.page_content
# 第三步：获得答案
template = """请根据以下内容回答问题:
{context}
问题: {question}
如果不知道，请回答“不知道”。
"""
prompt = ChatPromptTemplate.from_template(template)
chain = prompt | llm
response = chain.invoke({"question": question, "context": context})
print(response)

4 Decomposition

4.1 基本思想

有时候一个问题较为复杂，按照人类的思维方式，会将其分解为子问题，然后一步步的推理，最终得到结果。这里有2种不同的方式：

第一种方式：

通过大模型将问题分解成多个子问题
将每个子问题分别检索，获得结果，将子问题与其分别对应的结果组成问题对扔给大模型解答
将子问题与得到的解答再组成问题对，连同原始问题一起扔给大模型，得到最终解答

第二种方式：

1）通过大模型将问题分解成多个子问题
2）在将第一个子问题进行检索，获得结果
3）将第一个子问题与其分别对应的结果组成问题对，结果原始问题一起扔给大模型解答
4）重复2）和3）步骤，直到结果出来或者达到最大允许查询次数

在这里插入图片描述

（注：其中第二种方式的思想来自2篇论文分别是IR-CoT和Least-to-Most prompting）

4.2 代码演示

第一种方式代码：

import os

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_huggingface import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain_core.output_parsers import StrOutputParser
from langchain_community.vectorstores.chroma import Chroma
from langchain_community.document_loaders import DirectoryLoader


# 前置工作1：文档存储，如果已经存储了文档，则不需要该步骤
encode_kwargs = {"normalize_embeddings": False}
model_kwargs = {"device": "cuda:0"}
embeddings = HuggingFaceEmbeddings(
    model_name='/root/autodl-tmp/model/AI-ModelScope/m3e-base',  # 换成自己的embedding模型路径
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
if os.path.exists('VectorStore'):
    db = Chroma(persist_directory='VectorStore', embedding_function=embeddings)
loader = DirectoryLoader("/root/autodl-tmp/doc")  # 换成自己的文档路径
documents = loader.load()
text_spliter = CharacterTextSplitter(chunk_size=256, chunk_overlap=0)
documents = text_spliter.split_documents(documents)
database = Chroma.from_documents(documents, embeddings, persist_directory="VectorStore")
database.persist()

# 前置工作2：创建llm
llm = ChatOpenAI(
    temperature=0.01,
    model="glm-4",
    openai_api_key="你的API KEY",
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)

# 第一步：分解问题
template = """您是一个有用的助手，可以生成与输入问题相关的多个子问题。\n
目标是将输入问题分解为一组子问题，这些子问题可以单独得到答案。\n
生成与{question} 相关的多个子问题,输出2个子问题:"""
prompt_decomposition = ChatPromptTemplate.from_template(template)
generate_queries_decomposition = (prompt_decomposition | llm | StrOutputParser() | (lambda x: x.split("\n")))
final_question = "ChatGLM是哪个国家发布的?"
questions = generate_queries_decomposition.invoke({"question": final_question})
print(questions)

# 第二步：循环所有子问题，查询向量数据库获得文档内容，在一起扔给模型回答问题,将子问题和答案存储起来
RAG_prompt = '''你是负责回答问题的助手。使用以下检索到的上下文来回答问题。如果你不知道答案，就说你不知道。最多只用三句话，回答要简明扼要。\n
问题: {question} 
上下文: {context} 
答案：'''
prompt_rag = ChatPromptTemplate.from_template(RAG_prompt)


# 查询向量数据库并扔给大模型函数
def retrieve_and_rag(prompt_tmp):
    # 存储结果
    rag_results = []
    # 循环获取结果
    for sub_question in questions:
        # 查询子问题的文档内容
        retrieved_docs = database.as_retriever().get_relevant_documents(sub_question)
        # 获得答案
        answer = (prompt_tmp | llm | StrOutputParser()).invoke({"context": retrieved_docs, "question": sub_question})
        # 打印子问题和子答案，可以更好看看其获取过程
        # print("子问题: ", sub_question)
        # print(len(retrieved_docs))
        # print("子答案: ", answer)

        rag_results.append(answer)
    return rag_results, questions


answers, questions = retrieve_and_rag(prompt_rag)


# 组成问题对
def format_qa_pairs(sub_questions, sub_answers):
    """Format Q and A pairs"""

    formatted_string = ""
    for i, (question, answer) in enumerate(zip(sub_questions, sub_answers), start=1):
        formatted_string += f"问题 {i}: {question}\n答案 {i}: {answer}\n\n"
    return formatted_string.strip()


context = format_qa_pairs(questions, answers)

# Prompt
template = """下面是一组问题+答案对:

{context}

使用上述问题+答案对来生成问题的答案: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
final_rag_chain = (prompt | llm | StrOutputParser())
response = final_rag_chain.invoke({"context": context, "question": final_question})
print(response)

第二种方式代码：

import os
from operator import itemgetter
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_huggingface import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain_core.output_parsers import StrOutputParser
from langchain_community.vectorstores.chroma import Chroma
from langchain_community.document_loaders import DirectoryLoader


# 前置工作1：文档存储，如果已经存储了文档，则不需要该步骤
encode_kwargs = {"normalize_embeddings": False}
model_kwargs = {"device": "cuda:0"}
embeddings = HuggingFaceEmbeddings(
    model_name='/root/autodl-tmp/model/AI-ModelScope/m3e-base',  # 换成自己的embedding模型路径
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
if os.path.exists('VectorStore'):
    db = Chroma(persist_directory='VectorStore', embedding_function=embeddings)
loader = DirectoryLoader("/root/autodl-tmp/doc")  # 换成自己的文档路径
documents = loader.load()
text_spliter = CharacterTextSplitter(chunk_size=256, chunk_overlap=0)
documents = text_spliter.split_documents(documents)
database = Chroma.from_documents(documents, embeddings, persist_directory="VectorStore")
database.persist()

# 前置工作2：创建llm
llm = ChatOpenAI(
    temperature=0.01,
    model="glm-4",
    openai_api_key="你的API KEY",
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)

# 第一步：分解问题
template = """您是一个有用的助手，可以生成与输入问题相关的多个子问题。\n
目标是将输入问题分解为一组子问题，这些子问题可以单独得到答案。\n
生成与{question} 相关的多个子问题,输出2个子问题:"""
prompt_decomposition = ChatPromptTemplate.from_template(template)
generate_queries_decomposition = ( prompt_decomposition | llm | StrOutputParser() | (lambda x: x.split("\n")))
question = "ChatGLM是哪个国家发布的?"
questions = generate_queries_decomposition.invoke({"question": question})
print(questions)

# 第二步：将前一个子问题及答案组成问题对，再将问题对与当前子问题组成template扔给大模型解答
template = """下面是你需要回答的问题:

\n——\n {question} \n——\n

以下是任何可用的背景问题+答案对:

\n——\n {q_a_pairs} \n——\n

以下是与该问题相关的其他背景:

\n——\n {context} \n——\n

使用上述上下文和任何背景问题+答案对回答问题:\n {question}
"""
decomposition_prompt = ChatPromptTemplate.from_template(template)


# 组装问题对函数
def format_qa_pair(question, answer):
    formatted_string = ""
    formatted_string += f"问题: {question}\n答案: {answer}\n\n"
    return formatted_string.strip()


# 第三步：循环子问题，重复回到子问题
q_a_pairs = ""
answer = ""
for q in questions:
    rag_chain = (
            {"context": itemgetter("question") | database.as_retriever(),
             "question": itemgetter("question"),
             "q_a_pairs": itemgetter("q_a_pairs")}
            | decomposition_prompt
            | llm
            | StrOutputParser())

    answer = rag_chain.invoke({"question": q, "q_a_pairs": q_a_pairs})
    # print("=====", answer) # 此处可以打印出每个子问题的回答，看到完整的推理过程
    q_a_pair = format_qa_pair(q, answer)
    q_a_pairs = q_a_pairs + "\n---\n" + q_a_pair

print(answer)

5 Step-back prompting

5.1 基本思想

在Decomposition中我们知道处理复杂问题需要分步解决，其实还有另外一种方法，就是面对复杂问题时，人们有时会后退一步，抽象到更高层面的概念和原则上指导过程。听起来也挺抽象的，简单来说就是通过原始问题生成更抽象的Step-back问题，检索向量数据库得到的Step-back问题包含了原理和背景信息，基于Step-back问题得到的答案，推理得到了正确答案。步骤如下：

抽象：首先让大模型提出一个更为抽象或者高级的问题（一般给几个few-shot），通过该问题检索向量数据库，得到答案
推理：基于抽象问题和答案，加上原始问题及查询的答案，一起扔给大模型进行回答，得到最终答案

在这里插入图片描述

5.2 代码演示

import os

from langchain_core.runnables import RunnableLambda
from langchain_openai import ChatOpenAI
from langchain_huggingface import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain_core.output_parsers import StrOutputParser
from langchain_community.vectorstores.chroma import Chroma
from langchain_community.document_loaders import DirectoryLoader
from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate

# 前置工作1：文档存储，如果已经存储了文档，则不需要该步骤
encode_kwargs = {"normalize_embeddings": False}
model_kwargs = {"device": "cuda:0"}
embeddings = HuggingFaceEmbeddings(
    model_name='/root/autodl-tmp/model/AI-ModelScope/m3e-base',  # 换成自己的embedding模型路径
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
if os.path.exists('VectorStore'):
    db = Chroma(persist_directory='VectorStore', embedding_function=embeddings)
loader = DirectoryLoader("/root/autodl-tmp/doc")  # 换成自己的文档路径
documents = loader.load()
text_spliter = CharacterTextSplitter(chunk_size=256, chunk_overlap=0)
documents = text_spliter.split_documents(documents)
database = Chroma.from_documents(documents, embeddings, persist_directory="VectorStore")
database.persist()

# 前置工作2：创建llm
llm = ChatOpenAI(
    temperature=0.01,
    model="glm-4",
    openai_api_key="你的API KEY",
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)

# 第一步：设置抽象问题的template和few-shot
examples = [
    {
        "input": "智谱AI是哪个国家?",
        "output": "智谱AI的公司简介是什么?",
    },
    {
        "input": "BYD是哪个国家?",
        "output": "BYD的简介是什么?",
    },
]
example_prompt = ChatPromptTemplate.from_messages(
    [
        ("human", "{input}"),
        ("ai", "{output}"),
    ]
)
few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_prompt=example_prompt,
    examples=examples,
)
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            """你是世界知识方面的专家。你的任务是通过退一步的方式把一个问题改写成一个更一般的问题，这样更容易回答。这里有几个例子:""",
        ),
        few_shot_prompt,
        ("user", "{question}"),
    ]
)
generate_queries_step_back = prompt | llm | StrOutputParser()
question = "ChatGLM是哪个国家发布的?"

# 可以打印一下中间生成的抽象问题
# answer = generate_queries_step_back.invoke({"question": question})
# print(answer)

# 第二步：基于抽象问题和答案，加上原始问题及查询的答案，一起扔给大模型进行回答，得到最终答案
response_prompt_template = """你是世界知识方面的专家。你是世界知识的专家。
我要问你一个问题。你的回答应该是全面的，如果与下面上下文是相关的，则不要与下面上下文相矛盾。
如果与下面上下文是不相关的，就忽略下面上下文。你的任务是通过退一步的方式把一个问题改写成一个更一般的问题，这样更容易回答。这里有几个例子.

# {normal_context}
# {step_back_context}

# 原始问题: {question}
# 答案:"""
response_prompt = ChatPromptTemplate.from_template(response_prompt_template)

chain = (
    {
        "normal_context": RunnableLambda(lambda x: x["question"]) | database.as_retriever(),
        "step_back_context": generate_queries_step_back | database.as_retriever(),
        "question": lambda x: x["question"],
    }
    | response_prompt
    | llm
    | StrOutputParser()
)

response = chain.invoke({"question": question})
print(response)

6 总结

问题优化其实还有很多其它方法，这里先介绍常见的5种，以下表格做一个总结：

方法	描述	场景
Multi-Query	通过生成更多角度的问题	针对问题模糊时
RAG-fusion	在Multi-Query基础上，在检索文档结果后增加RRF重排	针对问题模糊时
HyDE	使用大模型生成假设性答案，再使用答案去查询相似度，而不是原始问题	用户问题和语义不在一个空间
Decomposition	将问题分解为子问题，再通过并行或串行方式获得答案	针对复杂问题或者需要逻辑推理问题
Step-back	使用few-shot方式，让大模型基于原始问题提出更为抽象问题	针对复杂问题

linmoo1986

关注

18
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
检索增强生成RAG系列4--RAG优化之问题优化

方法描述场景通过生成更多角度的问题针对问题模糊时RAG-fusion在Multi-Query基础上，在检索文档结果后增加RRF重排针对问题模糊时HyDE使用大模型生成假设性答案，再使用答案去查询相似度，而不是原始问题用户问题和语义不在一个空间将问题分解为子问题，再通过并行或串行方式获得答案针对复杂问题或者需要逻辑推理问题Step-back使用few-shot方式，让大模型基于原始问题提出更为抽象问题针对复杂问题。
复制链接

扫一扫

专栏目录