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)