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

news2024/11/23 4:04:25

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

在这里插入图片描述

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

目录

  • 1 Multi-Query
    • 1.1 基本思想
    • 1.2 代码演示
  • 2 RAG-Fusion
    • 2.1 基本思想
    • 2.2 代码
  • 3 HyDE
    • 3.1 基本思想
    • 3.2 代码演示
  • 4 Decomposition
    • 4.1 基本思想
    • 4.2 代码演示
  • 5 Step-back prompting
    • 5.1 基本思想
    • 5.2 代码演示
  • 6 总结

说明：以下所有方法实现的前置条件：

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

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="ec5c5980165386142d4d401976234a0a.xGWn3QfonQqfbJPg",
    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="ec5c5980165386142d4d401976234a0a.xGWn3QfonQqfbJPg",
    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="ec5c5980165386142d4d401976234a0a.xGWn3QfonQqfbJPg",
    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方式，让大模型基于原始问题提出更为抽象问题针对复杂问题

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

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

相关文章

职场必备：三大神器助你完美驾驭工作与生活；从 GTD 到SMART再到OKR：提升效率的终极指南；告别拖延，高效工作的秘密武器！

职场必备：三大神器助你完美驾驭工作与生活；从 GTD 到SMART再到OKR：提升效率的终极指南；告别拖延，高效工作的秘密武器！

在现代职场和个人生活中，有效的时间管理和目标设定是成功的关键。我们每天都面临着无数的任务和目标。如何在纷繁复杂的日常中保持专注，高效地完成工作？ GTD（Getting Things Done） GTD（Getting Things Don…
阅读更多...
容器技术-docker4

容器技术-docker4

一、docker资源限制 在使用 docker 运行容器时，一台主机上可能会运行几百个容器，这些容器虽然互相隔离，但是底层却使用着相同的 CPU、内存和磁盘资源。如果不对容器使用的资源进行限制，那么容器之间会互相影响，小的来说…
阅读更多...
Qt：5.QWidget属性介绍(isEnabled和geometry)

Qt：5.QWidget属性介绍(isEnabled和geometry)

目录 一、 QWidget属性的介绍： 二、Enabled属性： 2.1Enabled属性的介绍： 2.2获取控件当前可用状态的api——isEnabled()： 2.3设置控件当前的可用状态的api—— setEnabled() ： 2.4 实例：通过一个按钮&…
阅读更多...
Gin框架基础

Gin框架基础

1、一个简单的Gin示例 下载并安装Gin: go get -u github.com/gin-gonic/gin1.1 一个简单的例子 package mainimport ("net/http""github.com/gin-gonic/gin" )func main() {// 创建一个默认的路由引擎r : gin.Default()// 当客户端以GET方式访问 /hello…
阅读更多...
企业化运维(6)_redis数据库

企业化运维(6)_redis数据库

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 redis是一个key-value存储系统。和Memcached类似&#xff0…
阅读更多...
优化模型验证30：多车场车辆路径问题模型及Gurobipy验证

优化模型验证30：多车场车辆路径问题模型及Gurobipy验证

目录 1 数学模型 1.1 用到的符号集合 1.2 模型公式 2 模型验证代码 2.1 Gurobipy代码 2.2 结果可视化 多车场车辆路径问题的定义：大型的物流公司拥有多个车场,而每个车场都有若干车辆用于配送，决策者需要根据客户的所在位置，将客户分配到合适的车场和车辆中。 1 数学模…
阅读更多...
深度学习基准模型Transformer

深度学习基准模型Transformer

深度学习基准模型Transformer 深度学习基准模型Transformer，最初由Vaswani等人在2017年的论文《Attention is All You Need》中提出，是自然语言处理（NLP）领域的一个里程碑式模型。它在许多序列到序列（seq2seq&#xf…
阅读更多...
matlab仿真 通信信号和系统分析（上）

matlab仿真 通信信号和系统分析（上）

（内容源自详解MATLAB／SIMULINK 通信系统建模与仿真 刘学勇编著第三章内容，有兴趣的读者请阅读原书） 一、求离散信号卷积和 主要还是使用卷积函数conv，值得注意的是，得到的卷积和长度结果为81&#xff0…
阅读更多...
lumbda常用操作

lumbda常用操作

文章目录 lumbda的常用操作将List<String>转List<Integer>filter 过滤max 和min将List<Object>转为Map将List<Object>转为Map&#xff08;重复key&#xff09;将List<Object>转为Map&#xff08;指定Map类型&#xff09;过滤List重复 lumbda的常…
阅读更多...
【强化学习的数学原理】课程笔记--2（贝尔曼最优公式，值迭代与策略迭代）

【强化学习的数学原理】课程笔记--2（贝尔曼最优公式，值迭代与策略迭代）

目录 贝尔曼最优公式最优 Policy求解贝尔曼最优公式求解最大 State Value v ∗ v^* v∗根据 v ∗ v^* v∗ 求解贪婪形式的最佳 Policy π ∗ \pi^* π∗一些证明过程 一些影响 π ∗ \pi^* π∗ 的因素如何让 π ∗ \pi^* π∗ 不 “绕弯路” γ \gamma γ 的影响reward 的…
阅读更多...
15- 22题聚合函数 - 高频 SQL 50 题基础版

15- 22题聚合函数 - 高频 SQL 50 题基础版

目录 1. 相关知识点2. 例子2.15 - 有趣的电影2.16 - 平均售价2.17 - 项目员工 I2.18 - 各赛事的用户注册率2.19 - 查询结果的质量和占比2.20 - 每月交易 I2.21 - 即时食物配送 II2.22 - 游戏玩法分析 IV 1. 相关知识点 函数 函数含义order by排序group by分组between 小值 an…
阅读更多...
基于web的产品管理系统

基于web的产品管理系统

文章目录 项目介绍主要功能截图：部分代码展示设计总结项目获取方式🍅 作者主页：超级无敌暴龙战士塔塔开 🍅 简介：Java领域优质创作者🏆、 简历模板、学习资料、面试题库【关注我，都给你】 🍅文末获取源码联系🍅 项目介绍 基于web的产品管理系统,java项目。 ecli…
阅读更多...
2024最新boss直聘岗位数据爬虫，并进行可视化分析

2024最新boss直聘岗位数据爬虫，并进行可视化分析

前言 近年来，随着互联网的发展和就业市场的变化，数据科学与爬虫技术在招聘信息分析中的应用变得越来越重要。通过对招聘信息的爬取和可视化分析，我们可以更好地了解当前的就业市场动态、职位需求和薪资水平，从而为求职者和招聘企业提供有价值的数据支持。本文将介绍如何使…
阅读更多...
Chrome浏览器web调试（js调试、css调试、篡改前置）

Chrome浏览器web调试（js调试、css调试、篡改前置）

目录 1. 打开开发者工具（Dev Tool） 2. 打开命令菜单 截图 3. 面板介绍 4. CSS调试 右键检查快速到达元素处 查找DOM数 利用面板Console查找DOM节点 内置函数查找上一个选择点击的元素 5. 调试JS代码（Javascript调试） 日志调试 选择查看日志等级 眼睛观测变量 …
阅读更多...
关于Unity运行时动态修改材质的小秘密

关于Unity运行时动态修改材质的小秘密

一、问题背景 在以往的Unity项目中涉及到修改材质的需求时&#xff0c;也只是改改材质贴图&#xff0c;材质颜色等&#xff0c;也没遇到那么多动态修改材质的坑。最近在做Unity App Demo时也遇到了要修改材质的小需求&#xff0c;本以为几分钟就能完成了&#xff0c;却花费了我…
阅读更多...
【FPGA项目】System Generator算法板级验证-快速搭建外围测试电路

【FPGA项目】System Generator算法板级验证-快速搭建外围测试电路

&#x1f389;欢迎来到FPGA专栏~System Generator算法板级验证-快速搭建外围测试电路 ☆* o(≧▽≦)o *☆嗨~我是小夏与酒&#x1f379; ✨博客主页&#xff1a;小夏与酒的博客 &#x1f388;该系列文章专栏&#xff1a;FPGA学习之旅 文章作者技术和水平有限&#xff0c;如果文…
阅读更多...
深入解析MySQL语句的执行步骤

深入解析MySQL语句的执行步骤

目录 MySQL架构概述语句执行步骤总览连接管理与线程处理语法解析查询缓存语义解析与预处理查询优化执行计划生成存储引擎层执行结果集返回优化查询性能的技巧结论 MySQL架构概述 在深入探讨MySQL语句执行的具体步骤之前&#xff0c;我们先来了解MySQL的整体架构。MySQL架构主…
阅读更多...
简单多状态DP问题

简单多状态DP问题

这里写目录标题 什么是多状态DP解决多状态DP问题应该怎么做&#xff1f;关于多状态DP问题的几道题1.按摩师2.打家劫舍Ⅱ3.删除并获得点数4.粉刷房子5.买卖股票的最佳时期含手冷冻期 总结 什么是多状态DP 多状态动态规划&#xff08;Multi-State Dynamic Programming, Multi-St…
阅读更多...
Chapter8 透明效果——Shader入门精要学习笔记

Chapter8 透明效果——Shader入门精要学习笔记

一、基本概念 在Unity中通常使用两种方法来实现透明效果 透明度测试&#xff08;无法达到真正的半透明效果&#xff09;透明度混合&#xff08;关闭了深度写入&#xff09; 透明度测试 基本原理&#xff1a;设置一个阈值&#xff0c;只要片元的透明度小于阈值&#xff0c;就…
阅读更多...
pandas数据分析（2）

pandas数据分析（2）

列 执行df.columns获取DataFrame列信息&#xff1a; 如果在构造DataFrame时没有提供列名&#xff0c;那么pandas会用 从0开始的数字为列编号。我们也可以为列命名&#xff0c;和为索引命名类似&#xff1a; 同样也可以重命名列名&#xff1a; 使用df.drop删除列&#xff1a; 删…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023