RAG系统的四层天梯：大模型RAG系统的成长之路 精华

from haystack import Pipeline
from haystack.nodes import BM25Retriever, FARMReader

retriever = BM25Retriever(document_store)
reader = FARMReader("deepset/roberta-base-squad2")

pipe = Pipeline()
pipe.add_node(compnotallow=retriever, name="Retriever", inputs=["Query"])
pipe.add_node(compnotallow=reader, name="Reader", inputs=["Retriever"])

result = pipe.run(query="谁发明了电话？")
print(result['answers'][0].answer)

from haystack import Pipeline
from haystack.nodes import BM25Retriever, FARMReader, JoinDocuments

retriever = BM25Retriever(document_store)
reader = FARMReader("deepset/roberta-base-squad2")
joiner = JoinDocuments(join_mode="concatenate")

pipe = Pipeline()
pipe.add_node(compnotallow=retriever, name="Retriever", inputs=["Query"])
pipe.add_node(compnotallow=joiner, name="Joiner", inputs=["Retriever"])
pipe.add_node(compnotallow=reader, name="Reader", inputs=["Joiner"])

result = pipe.run(query="哪个国家在2020年奥运会上获得的金牌最多？")
print(result['answers'][0].answer)

import openai

openai.api_key = "your-api-key"

prompt = """
Query: 根据现行法律，一个年收入5万美元的单身人士在加利福尼亚州需要缴纳多少所得税？

Let's approach this step-by-step:

1) First, we need to know the California state income tax brackets for single filers.
2) Then, we'll calculate the tax for each bracket up to $50,000.
3) Finally, we'll sum up the tax amounts.

Step 1: California tax brackets for single filers (2021):
- 1% on the first $8,932 of taxable income
- 2% on taxable income between $8,933 and $21,175
- 4% on taxable income between $21,176 and $33,421
- 6% on taxable income between $33,422 and $46,394
- 8% on taxable income between $46,395 and $50,000

Step 2: Calculate tax for each bracket:
- 1% of $8,932 = $89.32
- 2% of ($21,175 - $8,933) = $244.84
- 4% of ($33,421 - $21,176) = $489.80
- 6% of ($46,394 - $33,422) = $778.32
- 8% of ($50,000 - $46,395) = $288.40

Step 3: Sum up the tax amounts:
$89.32 + $244.84 + $489.80 + $778.32 + $288.40 = $1,890.68

Therefore, a single person with an annual income of $50,000 in California would owe approximately $1,890.68 in state income tax.

Note: This is a simplified calculation and doesn't account for deductions, credits, or other factors that might affect the actual tax liability.
"""

response = openai.Completion.create(
  engine="gpt4",
  prompt=prompt,
  max_tokens=500
)

print(response.choices[0].text.strip())

from transformers import pipeline
import openai

# 使用BART进行初步总结
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")

# 假设我们有多个相关文档
documents = [
    "气候变化正在加速亚马逊雨林的退化...",
    "人类活动，如砍伐和农业扩张，正在威胁亚马逊雨林...",
    "一些研究表明，亚马逊雨林可能会在未来几十年内达到临界点..."
]

# 总结每个文档
summaries = [summarizer(doc, max_length=50, min_length=10, do_sample=False)[0]['summary_text'] for doc in documents]

# 使用GPT-3进行最终的综合分析
openai.api_key = "your-api-key"

prompt = f"""
Based on the following summaries about the Amazon rainforest:

{' '.join(summaries)}

Predict the changes in the Amazon rainforest over the next 50 years, considering global climate change and human activities. Provide a detailed analysis.
"""

response = openai.Completion.create(
  engine="gpt4",
  prompt=prompt,
  max_tokens=500
)

print(response.choices[0].text.strip())

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-72B-Instruct")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-72B-Instruct")

def get_context(query):
    # 这里应该是你的检索逻辑
    return "相关上下文信息..."

query = "什么是量子计算？"
context = get_context(query)

input_text = f"上下文：{context}\n问题：{query}\n回答："
input_ids = tokenizer.encode(input_text, return_tensors="pt")

output = model.generate(input_ids, max_length=200, num_return_sequences=1, no_repeat_ngram_size=2)
response = tokenizer.decode(output[0], skip_special_tokens=True)

print(response)

from transformers import AutoTokenizer, AutoModel, AutoModelForCausalLM
import torch

# 假设这是我们的小模型，用于生成查询的向量表示
retriever_tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
retriever_model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")

# 主要的LLM
lm_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-72B-Instruct")
lm_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-72B-Instruct")

def get_query_embedding(query):
    inputs = retriever_tokenizer(query, return_tensors="pt", padding=True, truncatinotallow=True)
    with torch.no_grad():
        outputs = retriever_model(**inputs)
    return outputs.last_hidden_state.mean(dim=1)

query = "什么是量子计算？"
query_embedding = get_query_embedding(query)

# 在实际应用中，我们会用这个嵌入来检索相关文档
# 这里我们简单地假设我们得到了一些相关信息
retrieved_info = "量子计算是利用量子力学现象进行计算的技术..."

input_text = f"基于以下信息：{retrieved_info}\n回答问题：{query}"
input_ids = lm_tokenizer.encode(input_text, return_tensors="pt")

output = lm_model.generate(input_ids, max_length=200, num_return_sequences=1, no_repeat_ngram_size=2)
response = lm_tokenizer.decode(output[0], skip_special_tokens=True)

print(response)

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
import torch
from datasets import load_dataset

# 加载预训练模型
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 准备数据集（这里使用虚构的数据集名称）
dataset = load_dataset("quantum_physics_dataset")

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncatinotallow=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

# 设置训练参数
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
)

# 创建Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
)

# 开始微调
trainer.train()

# 使用微调后的模型
query = "什么是量子纠缠？"
input_ids = tokenizer.encode(query, return_tensors="pt")
output = model.generate(input_ids, max_length=200, num_return_sequences=1, no_repeat_ngram_size=2)
response = tokenizer.decode(output[0], skip_special_tokens=True)

print(response)

- 灵活性拉满：想换数据就换，LLM完全不用动
- 透明度高：我们清楚地知道模型用了哪些额外信息

- 上下文长度有限：就像塞鸭子，塞太多LLM也消化不了
- 检索质量决定生死：垃圾进垃圾出，检索不好全盘皆输

- 需要频繁更新知识库的应用
- 对结果可解释性要求高的场景

- 专业性强：可以为特定任务定制"小助手"
- 模块化设计：想换就换，主LLM不受影响

- 训练成本高：又要准备数据又要训练，累死个人
- 集成难度大：让"小助手"和LLM无缝配合不是易事

- 有特定复杂任务需要处理的应用
- 计算资源有限，无法频繁调用大型LLM的情况

- 性能王者：在特定领域可以达到最佳表现
- 推理效率高：不需要额外的检索步骤

- 计算成本高：微调大模型，没个几千块GPU别想了
- 灵活性降低：一旦微调，可能会影响其他领域的表现

- 特定领域的专业应用
- 有大量高质量领域数据可用的情况

from haystack import Pipeline
from haystack.nodes import BM25Retriever, FARMReader

retriever = BM25Retriever(document_store)
reader = FARMReader("deepset/roberta-base-squad2")

pipe = Pipeline()
pipe.add_node(compnotallow=retriever, name="Retriever", inputs=["Query"])
pipe.add_node(compnotallow=reader, name="Reader", inputs=["Retriever"])

result = pipe.run(query="谁发明了电话？")
print(result['answers'][0].answer)

def iterative_rag(query, max_iteratinotallow=3):
    context = ""
    for i in range(max_iterations):
        result = pipe.run(query=query + " " + context)
        new_info = result['answers'][0].answer
        context += new_info
        if "完整回答" in new_info:
            break
    return context

final_answer = iterative_rag("比较太阳系中最大和最小的行星")
print(final_answer)

- 迭代RAG：多轮检索，每轮基于之前的结果继续深入
- 图/树RAG：构建知识图谱，进行多跳推理
- RAG+SQL：结合结构化数据查询，处理复杂的数值计算

prompt = """
问题：一个水箱可以在6小时内装满水。现在已经装了2小时，还剩下3/4没装满。请问这个水箱实际上需要多长时间才能装满？

让我们一步步思考：
1) 首先，我们知道正常情况下，水箱需要6小时装满。
2) 现在已经装了2小时，还剩3/4没装满。
3) 这意味着2小时内只装满了1/4的水箱。
4) 如果2小时装满1/4，那么装满整个水箱需要的时间是：
   2小时 * 4 = 8小时

因此，这个水箱实际上需要8小时才能装满。

是否需要我进一步解释这个推理过程？
"""

response = openai.Completion.create(engine="gpt4", prompt=prompt, max_tokens=150)
print(response.choices[0].text.strip())

- 提示调优：设计特定的提示模板，引导LLM进行推理
- 思维链提示：让LLM像人类一样，一步步写出推理过程

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer

model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 准备特定领域的数据集
train_dataset = ...  # 你的训练数据
eval_dataset = ...   # 你的评估数据

training_args = TrainingArguments(output_dir="./results", num_train_epochs=3, per_device_train_batch_size=8)

trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset)
trainer.train()

# 使用微调后的模型
query = "预测未来5年的全球经济趋势"
input_ids = tokenizer.encode(query, return_tensors="pt")
output = model.generate(input_ids, max_length=200)
print(tokenizer.decode(output[0], skip_special_tokens=True))

- 离线学习：预先学习领域知识，构建专门的知识库
- 上下文学习：动态选择最相关的上下文进行学习
- 微调：在特定领域数据上微调LLM

def query_router(query):
    if is_simple_fact_query(query):
        return basic_rag(query)
    elif is_implicit_fact_query(query):
        return iterative_rag(query)
    elif is_interpretable_reasoning_query(query):
        return chain_of_thought_prompting(query)
    elif is_hidden_reasoning_query(query):
        return fine_tuned_model(query)
    else:
        return fallback_method(query)

def process_query(query):
    response = query_router(query)
    return post_process(response)

# 使用示例
user_query = "请解释量子纠缠的原理及其在量子计算中的应用"
answer = process_query(user_query)
print(answer)