微调模型成本太高，用RAG技术，低成本实现AI升级

文章目录

• 大模型 RAG 技术深度解析：从入门到进阶
• • 一、大语言模型（LLM）的三大痛点
  • • 1.1 幻觉问题：一本正经地胡说八道
    • 1.2 时效性问题：知识更新不及时
    • 1.3 数据安全问题：敏感信息泄露风险
  • 二、RAG 技术：检索增强生成
  • • 2.1 RAG 的定义
    • 2.2 RAG 的架构
    • • 2.2.1 检索器模块
      • 2.2.2 生成器模块
  • 三、使用 RAG 的八大优势
  • • 3.1 可扩展性：减少模型大小和训练成本
    • 3.2 准确性：通过引用信息来源增强信任
    • 3.3 可控性：允许更新或定制知识
    • 3.4 可解释性：检索到的项目作为模型预测中来源的参考
    • 3.5 多功能性：适用于多种任务
    • 3.6 及时性：识别最新的信息
    • 3.7 定制性：为不同领域提供专业的知识支持
    • 3.8 安全性：更好地控制数据使用
  • 四、RAG 与 SFT 的对比
  • • 4.1 数据处理方式
  • 五、RAG 的典型实现方法
  • • 5.1 数据索引
    • 5.2 数据检索
    • 5.3 文本生成
  • 六、RAG 的典型案例
  • • 6.1 ChatPDF 及其复刻版
    • 6.2 Baichuan
    • 6.3 Multi-modal retrieval-based LMs
  • 七、RAG 存在的问题
  • • 7.1 检索效果依赖 embedding 和检索算法
    • 7.2 大模型如何利用检索到的信息仍是黑盒
    • 7.3 效率问题：无差别检索所有任务
    • 7.4 无法精准查证事实
  • 八、RAG 的拓展方案
  • • 8.1 多模态 RAG
    • 8.2 实时 RAG
    • 8.3 个性化 RAG
  • 九、互动与交流
  • • 9.1 评论区互动
    • 9.2 转载声明

大模型 RAG 技术深度解析：从入门到进阶

一、大语言模型（LLM）的三大痛点

1.1 幻觉问题：一本正经地胡说八道

专业解释：LLM 的文本生成是基于概率的 token by token 形式，它会根据训练数据中的模式生成最可能的下一个 token，但并不理解语义的正确性。

大白话解读：就像一个学生考试时遇到不会的题目，凭借记忆中的片段瞎蒙答案，虽然看起来像模像样，但实际上可能完全错误。

生活案例：当你问 AI：“太阳为什么从西边升起？”，它可能会一本正经地解释:“因为地球自转方向发生了改变”，而实际上太阳根本不会从西边升起。

示例 Python 代码：

from transformers import pipeline
​
generator = pipeline('text-generation', model='gpt2')
result = generator("太阳为什么从西边升起？", max_length=100, num_return_sequences=1)
print(result[0]['generated_text'])

1.2 时效性问题：知识更新不及时

专业解释：大型语言模型的训练成本极高，周期长，导致实时性强的数据无法及时参与训练，模型无法回答时效性相关的问题。

大白话解读：就像一个只会背诵五年前课本知识的学生，无法回答最新的科技进展或热点事件。

生活案例：当你在 2026 年问 AI：“2026 年的春节是哪一天？”，如果 AI 的训练数据截止到 2023 年，它可能无法给出正确答案。

示例 Python 代码：

from datetime import datetime
import requests
​
def get_current_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
​
def get_latest_news():
response = requests.get("https://newsapi.org/v2/top-headlines?country=cn&apiKey=YOUR_API_KEY")
return response.json()
​
print(f"当前时间: {get_current_time()}")
print(f"最新新闻: {get_latest_news()}")

1.3 数据安全问题：敏感信息泄露风险

专业解释：通用 LLM 没有企业内部数据和用户数据，企业想要在保证安全的前提下使用 LLM，最好的方式是将数据放在本地，仅让在线大模型完成归纳功能。

大白话解读：就像你不会把公司的机密文件交给一个陌生人保管，而是自己妥善保存，只在需要的时候让他人帮忙整理。

生活案例：银行不会将用户的账户信息直接输入到公共 LLM 中进行处理，而是先在本地处理敏感信息，再将处理后的结果发送给 LLM 进行分析。

示例 Python 代码：

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
​
# 本地处理敏感数据
def process_sensitive_data(data):
# 脱敏处理
return data.replace("敏感信息", "***")
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 创建Prompt模板
prompt = PromptTemplate(
input_variables=["data"],
template="分析以下数据：{data}"
)
​
# 创建LLM Chain
chain = LLMChain(llm=llm, prompt=prompt)
​
# 处理敏感数据
sensitive_data = "用户的敏感信息：1234567890"
processed_data = process_sensitive_data(sensitive_data)
​
# 调用LLM进行分析
result = chain.run(processed_data)
print(result)

二、RAG 技术：检索增强生成

2.1 RAG 的定义

专业解释：RAG（Retrieval-Augmented Generation，检索增强生成）是指 LLM 在回答问题或生成文本时，先从大量文档中检索出相关的信息，然后基于这些信息生成回答或文本，从而提高预测质量。

大白话解读：就像学生考试时，可以查阅课本资料，然后基于资料回答问题，而不是仅凭记忆瞎蒙。

生活案例：当你问 AI：“如何做红烧肉？”，RAG 技术会先检索相关的菜谱文档，然后基于这些文档生成详细的红烧肉做法。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
​
# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["红烧肉的做法：1. 准备食材…"], embeddings)
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)
​
# 提问
result = qa_chain.run("如何做红烧肉？")
print(result)

2.2 RAG 的架构

RAG 技术主要包含两个核心模块：检索器（R）和生成器（G）。

2.2.1 检索器模块

专业解释：检索器的作用是从大量知识库中检索出最相关的前 k 个文档。构建高质量的检索器需要解决三个关键问题：如何获得准确的语义表示？如何协调查询和文档的语义空间？如何对齐检索模型的输出和大语言模型的偏好？

大白话解读：就像图书馆的图书管理员，能够根据读者的需求快速找到最相关的书籍。

生活案例：当你在搜索引擎中输入"如何学习 Python"，搜索引擎会根据你的检索词，从海量网页中找到最相关的学习资源。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
​
# 初始化嵌入模型
embeddings = OpenAIEmbeddings()
​
# 创建向量数据库
documents = ["Python学习资源1…", "Python学习资源2…", "Python学习资源3…"]
db = FAISS.from_texts(documents, embeddings)
​
# 检索相关文档
query = "如何学习Python"
docs = db.similarity_search(query, k=2)
for doc in docs:
print(doc.page_content)

2.2.2 生成器模块

专业解释：生成器的作用是将检索到的信息转化为自然流畅的文本。生成器的输入不仅包括传统的上下文信息，还有通过检索器得到的相关文本片段，这使得生成的回答更加信息丰富、准确。

大白话解读：就像作家在写文章时，会参考相关的资料，然后基于这些资料创作出一篇完整的文章。

生活案例：当你在写论文时，会先查阅相关的文献资料，然后基于这些资料写出论文的内容。

示例 Python 代码：

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 创建Prompt模板
prompt = PromptTemplate(
input_variables=["context", "question"],
template="基于以下上下文回答问题：\\n{context}\\n\\n问题：{question}"
)
​
# 检索到的上下文
context = "Python是一种高级编程语言，易于学习和使用。"
​
# 提问
question = "Python是什么？"
​
# 生成回答
result = llm(prompt.format(context=context, question=question))
print(result)

三、使用 RAG 的八大优势

3.1 可扩展性：减少模型大小和训练成本

专业解释：RAG 方法使得开发者不必为每一个特定的任务重新训练整个大模型，只需要外挂上知识库，即可为模型提供额外的信息输入，提高其回答的准确性。

大白话解读：就像给一台普通的电脑外接一个移动硬盘，增加了存储容量，而不需要更换整个电脑。

生活案例：企业可以使用 RAG 技术，将内部知识库与通用 LLM 相结合，而不需要重新训练一个专有的大模型。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
​
# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
# 加载企业内部知识库
db = FAISS.load_local("enterprise_knowledge_base", embeddings)
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)
​
# 提问
result = qa_chain.run("公司的请假政策是什么？")
print(result)

3.2 准确性：通过引用信息来源增强信任

专业解释：通过引用信息来源，用户可以核实答案的准确性，这增强了人们对模型输出结果的信任。

大白话解读：就像老师在批改作业时，如果学生引用了课本上的内容，老师会更加相信答案的正确性。

生活案例：当你在网上看到一篇文章，如果作者引用了权威的研究报告，你会更加相信文章内容的真实性。

示例 Python 代码：

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 创建Prompt模板
prompt = PromptTemplate(
input_variables=["context", "question"],
template="基于以下上下文回答问题，并引用信息来源：\\n{context}\\n\\n问题：{question}"
)
​
# 检索到的上下文
context = "根据《Python编程从入门到精通》一书，Python是一种高级编程语言，易于学习和使用。"
​
# 提问
question = "Python是什么？"
​
# 生成回答
result = llm(prompt.format(context=context, question=question))
print(result)

3.3 可控性：允许更新或定制知识

专业解释：RAG 技术允许开发者轻松更新或定制知识库，而不需要重新训练大模型。

大白话解读：就像你可以随时更新手机上的 APP，而不需要更换整个手机。

生活案例：企业可以定期更新内部知识库，使得 LLM 能够回答最新的政策和业务问题。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 创建向量数据库
documents = ["公司的请假政策是：病假需要提供医院证明…"]
db = FAISS.from_texts(documents, embeddings)

# 更新知识库
new_document = "公司的请假政策已更新：病假需要提供三甲医院证明…"
db.add_texts([new_document])

# 检索相关文档
query = "公司的请假政策是什么？"
docs = db.similarity_search(query, k=1)
print(docs[0].page_content)

3.4 可解释性：检索到的项目作为模型预测中来源的参考

专业解释：RAG 系统通过将响应生成分解为不同的阶段来提供透明度，提供对数据检索的匹配度以提高对输出的信任。

大白话解读：就像法官在判决案件时，会引用相关的法律条文作为判决的依据。

生活案例：当你在搜索引擎中搜索结果时，搜索引擎会显示每个结果的来源链接，你可以点击链接查看原始文档。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQAWithSourcesChain
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts([
{"content": "Python是一种高级编程语言，易于学习和使用。", "metadata": {"source": "《Python编程从入门到精通》"}}
], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQAWithSourcesChain.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain({"question": "Python是什么？"})
print(f"回答：{result['answer']}")
print(f"来源：{result['sources']}")

3.5 多功能性：适用于多种任务

专业解释：RAG 可以针对多种任务进行微调和定制，包括 QA、文本摘要、对话系统等。

大白话解读：就像一把多功能的瑞士军刀，可以用来切割、开瓶、拧螺丝等。

生活案例：RAG 技术可以应用于智能客服、文档问答、知识图谱等多个领域。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains.summarize import load_summarize_chain
from langchain.llms import OpenAI
from langchain.text_splitter import CharacterTextSplitter

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载文档
with open("example.txt", "r", encoding="utf-8") as f:
text = f.read()

# 分割文本
text_splitter = CharacterTextSplitter()
texts = text_splitter.split_text(text)

# 创建向量数据库
db = FAISS.from_texts(texts, embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建摘要链
chain = load_summarize_chain(llm, chain_type="map_reduce")

# 检索相关文档
query = "本文的主要内容是什么？"
docs = db.similarity_search(query, k=5)

# 生成摘要
result = chain.run(documents=docs)
print(result)

3.6 及时性：识别最新的信息

专业解释：使用检索技术能识别到最新的信息，这使 RAG 在保持回答的及时性和准确性方面，相较于只依赖训练数据的传统语言模型有明显优势。

大白话解读：就像你可以随时通过手机获取最新的新闻资讯。

生活案例：当你问 AI：“2026 年的春节是哪一天？”，RAG 技术可以检索最新的日历数据，给出正确的答案。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
import requests

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载最新的日历数据
response = requests.get("https://api.example.com/calendar/2026")
calendar_data = response.json()

# 创建向量数据库
db = FAISS.from_texts([str(calendar_data)], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("2026年的春节是哪一天？")
print(result)

3.7 定制性：为不同领域提供专业的知识支持

专业解释：通过索引与特定领域相关的文本语料库，RAG 能够为不同领域提供专业的知识支持。

大白话解读：就像一个专业的医生，能够针对不同的疾病提供专业的治疗方案。

生活案例：RAG 技术可以应用于医疗、法律、金融等多个专业领域，为用户提供专业的知识支持。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载医疗知识库
with open("medical_knowledge_base.txt", "r", encoding="utf-8") as f:
medical_data = f.read()

# 创建向量数据库
db = FAISS.from_texts([medical_data], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何治疗感冒？")
print(result)

3.8 安全性：更好地控制数据使用

专业解释：RAG 通过数据库中设置的角色和安全控制，实现了对数据使用的更好控制。相比之下，经过微调的模型在管理数据访问权限方面可能不够明确。

大白话解读：就像一个保险箱，只有拥有钥匙的人才能打开并查看里面的内容。

生活案例：企业可以使用 RAG 技术，将敏感数据存储在本地数据库中，通过角色和权限控制来限制对数据的访问。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载敏感数据
with open("sensitive_data.txt", "r", encoding="utf-8") as f:
sensitive_data = f.read()

# 创建向量数据库
db = FAISS.from_texts([sensitive_data], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 设置访问权限
access_control = {
"admin": True,
"user": False
}

# 检查访问权限
user_role = "admin"
if access_control[user_role]:
# 提问
result = qa_chain.run("敏感数据是什么？")
print(result)
else:
print("您没有访问权限。")

四、RAG 与 SFT 的对比

4.1 数据处理方式

专业解释：RAG 和 SFT 是两种不同的大模型增强技术，它们在数据处理方式、外部知识利用、模型定制等方面存在明显的差异。

大白话解读：RAG 就像一个会查资料的助手，能够根据问题快速找到相关的信息并给出准确的回答；而 SFT 就像一个经过特殊训练的专家，能够根据特定的领域知识提供专业的回答。

生活案例：当你需要回答一个关于最新科技进展的问题时，RAG 技术会检索最新的科技新闻和研究报告，给出准确的回答；而 SFT 技术可能无法及时更新知识，给出的回答可能已经过时。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from transformers import pipeline

# RAG示例
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["最新科技进展：GPT-5发布…"], embeddings)
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)
rag_result = qa_chain.run("最新的科技进展是什么？")
print(f"RAG回答：{rag_result}")

# SFT示例
sft_model = pipeline('text-generation', model='fine_tuned_model')
sft_result = sft_model("最新的科技进展是什么？", max_length=100, num_return_sequences=1)
print(f"SFT回答：{sft_result[0]['generated_text']}")

五、RAG 的典型实现方法

5.1 数据索引

专业解释：数据索引是一个离线的过程，主要是将私域数据向量化后构建索引并存入数据库的过程。主要包括：数据提取、文本分割、向量化（embedding）及创建索引等环节。

大白话解读：就像图书馆的图书管理员，会将图书分类并建立索引，以便读者能够快速找到需要的图书。

生活案例：当你在图书馆借书时，管理员会根据书名、作者等信息，从索引中找到对应的图书。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
import PyPDF2

# 提取PDF文本
def extract_text_from_pdf(pdf_path):
text = ""
with open(pdf_path, "rb") as f:
reader = PyPDF2.PdfReader(f)
for page in reader.pages:
text += page.extract_text()
return text

# 分割文本
text_splitter = CharacterTextSplitter()

# 向量化
embeddings = OpenAIEmbeddings()

# 创建索引
def create_index(pdf_path):
text = extract_text_from_pdf(pdf_path)
texts = text_splitter.split_text(text)
db = FAISS.from_texts(texts, embeddings)
db.save_local("pdf_index")

# 创建PDF索引
create_index("example.pdf")

5.2 数据检索

专业解释：数据检索是获取有效信息的关键环节，主要包括元数据过滤、图关系检索、向量化相似度检索、关键词检索、全文检索、SQL 检索等方式。

大白话解读：就像你在搜索引擎中输入关键词，搜索引擎会从海量网页中找到最相关的结果。

生活案例：当你在百度搜索中输入"Python 学习教程"，百度会根据你的搜索词，从海量网页中找到最相关的 Python 学习教程。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 加载索引
embeddings = OpenAIEmbeddings()
db = FAISS.load_local("pdf_index", embeddings)

# 检索
query = "Python学习教程"
docs = db.similarity_search(query, k=3)
for doc in docs:
print(doc.page_content)

5.3 文本生成

专业解释：文本生成就是将原始 query 和检索得到的文本组合起来输入模型得到结果的过程，本质上就是个 prompt engineering 过程。

大白话解读：就像你在写作文时，会先收集相关的资料，然后基于这些资料写出一篇完整的作文。

生活案例：当你在写毕业论文时，会先查阅相关的文献资料，然后基于这些资料写出论文的内容。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 加载索引
embeddings = OpenAIEmbeddings()
db = FAISS.load_local("pdf_index", embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何学习Python？")
print(result)

六、RAG 的典型案例

6.1 ChatPDF 及其复刻版

专业解释：ChatPDF 是一个基于 RAG 技术的在线工具，它允许用户上传 PDF 文件并通过聊天界面提问。ChatPDF 会先将 PDF 文件转换为可处理的文本格式，然后使用 OpenAI 的 Embeddings API 将每个分段转换为向量，最后基于这些向量回答用户的问题。

大白话解读：就像你可以和一本 PDF 文件进行聊天，询问它里面的内容，而不需要手动翻阅。

生活案例：当你有一本厚厚的技术文档，你可以使用 ChatPDF 上传该文档，然后通过聊天界面询问文档中的内容，而不需要手动翻阅。

示例 Python 代码：

import requests
import PyPDF2
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 提取PDF文本
def extract_text_from_pdf(pdf_path):
text = ""
with open(pdf_path, "rb") as f:
reader = PyPDF2.PdfReader(f)
for page in reader.pages:
text += page.extract_text()
return text

# 创建索引
def create_chat_pdf(pdf_path):
text = extract_text_from_pdf(pdf_path)
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts([text], embeddings)
db.save_local("chat_pdf_index")

# 提问
def chat_with_pdf(question):
embeddings = OpenAIEmbeddings()
db = FAISS.load_local("chat_pdf_index", embeddings)
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)
result = qa_chain.run(question)
return result

# 创建ChatPDF索引
create_chat_pdf("example.pdf")

# 提问
answer = chat_with_pdf("本文的主要内容是什么？")
print(answer)

6.2 Baichuan

专业解释：Baichuan 是一个基于 RAG 技术的大模型搜索增强系统，它融合了指令意图理解、智能搜索和结果增强等多个模块，通过这些模块的协同作用，实现了更精确、智能的模型结果回答，减少了模型的幻觉。

大白话解读：就像一个智能搜索引擎，能够理解你的搜索意图，并提供更准确的搜索结果。

生活案例：当你在 Baichuan 中搜索"如何做红烧肉"，Baichuan 会先理解你的搜索意图，然后进行智能搜索，最后结合大模型技术优化搜索结果，提供更准确的红烧肉做法。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["红烧肉的做法：1. 准备食材…"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建Prompt模板
prompt = PromptTemplate(
input_variables=["context", "question"],
template="理解用户意图：{question}\\n基于以下上下文回答问题：{context}\\n\\n问题：{question}"
)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever(),
chain_type_kwargs={"prompt": prompt}
)

# 提问
result = qa_chain.run("如何做红烧肉？")
print(result)

6.3 Multi-modal retrieval-based LMs

专业解释：RA-CM3 是一个检索增强的多模态模型，它包含了一个信息检索框架来从外部存储库中获取知识。作者首先使用预训练的 CLIP 模型来实现一个检索器，然后使用 CM3 Transformer 架构来构成一个生成器，其中检索器用来辅助模型从外部存储库中搜索有关于当前提示文本中的精确信息，然后将该信息连同文本送入到生成器中进行图像合成。

大白话解读：就像一个能够同时处理文本和图像的智能助手，它可以根据你的文本提示，从图像库中找到相关的图像，并生成新的图像。

生活案例：当你告诉 RA-CM3"生成一只猫在草地上玩耍的图片"，它会先从图像库中找到相关的猫和草地的图片，然后生成一张新的猫在草地上玩耍的图片。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from PIL import Image
import requests
from io import BytesIO

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫在草地上玩耍的图片：https://example.com/cat.jpg"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("生成一只猫在草地上玩耍的图片")
print(result)

# 显示图片
image_url = result.split("：")[–1].strip()
response = requests.get(image_url)
image = Image.open(BytesIO(response.content))
image.show()

七、RAG 存在的问题

7.1 检索效果依赖 embedding 和检索算法

专业解释：RAG 的检索效果依赖于 embedding 模型和检索算法的质量，如果 embedding 模型无法准确表示文本的语义，或者检索算法无法找到最相关的文档，会导致检索到无关信息，反而对输出有负面影响。

大白话解读：就像如果图书馆的图书分类和索引做得不好，读者可能无法找到需要的图书。

生活案例：如果搜索引擎的检索算法不够准确，你可能会搜索到与你想要的内容无关的结果。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物…", "狗是一种哺乳动物…"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何训练一只狗？")
print(result)

7.2 大模型如何利用检索到的信息仍是黑盒

专业解释：虽然 RAG 技术能够检索到相关的信息，但大模型如何利用这些信息生成回答仍然是一个黑盒，可能仍存在不准确（甚至生成的文本与检索信息相冲突）的情况。

大白话解读：就像你给学生提供了相关的参考资料，但你不知道学生是如何使用这些资料来回答问题的。

生活案例：即使 AI 检索到了相关的信息，它仍然可能生成与这些信息相冲突的回答。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物…", "狗是一种哺乳动物…"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("猫是一种什么动物？")
print(result)

7.3 效率问题：无差别检索所有任务

专业解释：RAG 对所有任务都无差别检索 k 个文本片段，效率不高，同时会大大增加模型输入的长度，导致生成速度变慢。

大白话解读：就像你无论遇到什么问题，都要去图书馆查阅所有相关的书籍，这会浪费大量的时间和精力。

生活案例：如果 AI 对每个问题都检索大量的文档，会导致回答速度变慢，影响用户体验。

示例 Python 代码：

import time
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物…", "狗是一种哺乳动物…", "鸟是一种脊椎动物…", "鱼是一种脊椎动物…"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链（检索2个文档）
qa_chain_2 = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever(search_kwargs={"k": 2})
)

# 创建检索QA链（检索4个文档）
qa_chain_4 = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever(search_kwargs={"k": 4})
)

# 提问并计时
start_time = time.time()
result_2 = qa_chain_2.run("猫是一种什么动物？")
end_time = time.time()
print(f"检索2个文档耗时：{end_time – start_time}秒")

start_time = time.time()
result_4 = qa_chain_4.run("猫是一种什么动物？")
end_time = time.time()
print(f"检索4个文档耗时：{end_time – start_time}秒")

7.4 无法精准查证事实

专业解释：RAG 无法引用来源，也因此无法精准地查证事实，检索的真实性取决于数据源及检索算法。

大白话解读：就像你听到一个消息，但不知道它的来源，无法判断它的真实性。

生活案例：如果 AI 检索到的信息来自不可靠的数据源，它生成的回答可能是不准确的。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种爬行动物…（来源：不可靠网站）"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("猫是一种什么动物？")
print(result)

八、RAG 的拓展方案

8.1 多模态 RAG

专业解释：多模态 RAG 不仅可以处理文本数据，还可以处理图像、音频、视频等多种模态的数据。它可以将不同模态的数据转化为向量，然后进行检索和生成。

大白话解读：就像一个能够同时处理文字、图片、声音和视频的智能助手，它可以根据你的需求，从不同模态的数据中找到相关的信息，并生成相应的回答。

生活案例：当你问 AI"这张图片中的动物是什么？"，多模态 RAG 会先分析图片中的动物，然后从知识库中找到相关的信息，给出准确的回答。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from PIL import Image
import pytesseract

# 提取图片文本
def extract_text_from_image(image_path):
image = Image.open(image_path)
text = pytesseract.image_to_string(image)
return text

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物…"], embeddings)

# 初始化LLM
llm = OpenAI(temperature=0)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)

# 提取图片文本
image_text = extract_text_from_image("cat.jpg")

# 提问
result = qa_chain.run(f"这张图片中的动物是什么？图片文本：{image_text}")
print(result)

8.2 实时 RAG

专业解释：实时 RAG 能够实时检索最新的数据，并基于这些数据生成回答。它可以与实时数据源（如新闻 API、社交媒体 API 等）集成，确保回答的及时性和准确性。

大白话解读：就像一个实时更新的新闻播报员，能够随时获取最新的新闻信息，并及时播报给观众。

生活案例：当你问 AI"最新的科技新闻是什么？"，实时 RAG 会实时检索最新的科技新闻，并给出准确的回答。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
import requests
​
# 实时获取科技新闻
def get_latest_tech_news():
response = requests.get("https://newsapi.org/v2/top-headlines?country=us&category=technology&apiKey=YOUR_API_KEY")
news = response.json()
return news['articles'][0]['content']
​
# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts([get_latest_tech_news()], embeddings)
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever()
)
​
# 提问
result = qa_chain.run("最新的科技新闻是什么？")
print(result)

8.3 个性化 RAG

专业解释：个性化 RAG 能够根据用户的个性化需求和偏好，提供个性化的回答。它可以通过分析用户的历史记录、兴趣爱好等信息，调整检索策略和生成方式，以满足用户的个性化需求。

大白话解读：就像一个贴心的私人秘书，能够根据你的兴趣爱好，为你提供个性化的服务。

生活案例：当你问 AI"推荐一些适合我的电影"，个性化 RAG 会分析你的电影喜好，为你推荐符合你口味的电影。

示例 Python 代码：

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
​
# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["《肖申克的救赎》是一部经典的剧情片…", "《阿甘正传》是一部励志的剧情片…", "《星际穿越》是一部科幻片…"], embeddings)
​
# 初始化LLM
llm = OpenAI(temperature=0)
​
# 获取用户偏好
user_preference = "剧情片"
​
# 创建Prompt模板
prompt = PromptTemplate(
input_variables=["context", "question", "user_preference"],
template="用户偏好：{user_preference}\\n基于以下上下文回答问题：{context}\\n\\n问题：{question}"
)
​
# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=db.as_retriever(),
chain_type_kwargs={"prompt": prompt}
)
​
# 提问
result = qa_chain.run({"question": "推荐一些适合我的电影", "user_preference": user_preference})
print(result)

九、互动与交流

9.1 评论区互动

欢迎在评论区留言，分享你对 RAG 技术的看法和经验。如果你有任何问题或建议，也可以在评论区提出，我会尽力为你解答。

9.2 转载声明

本文系 Java后端的Ai之路 原创，如需转载，请注明出处和作者。未经授权，禁止商用。