揭示LLaMA 3對話能力的奧秘
過去的一年中，大模型技術得到了廣泛認可，全行業對大模型的投入也在不斷增加。開源社區涌現了許多優秀的模型和框架，推動了大模型技術的普及和應用。在這一年的時間里，LLaMA 系列模型也經歷了快速的發展，從 LLaMA 2 到 LLaMA 3，我們看到了性能和應用上的顯著提升。
基本操作：生成內容
首先，讓我們來了解一下 LLaMA 3 的核心能力。LLaMA 3 主要依賴于 Next Token Prediction（下一個詞預測）機制，通過預測下一個詞來生成連貫的對話。這種機制基于海量文本數據的訓練，使模型能夠捕捉語言的模式和規律，生成符合上下文邏輯的文本內容。
Next Token Prediction
Next Token Prediction 是大語言模型生成文本的基礎。模型處理輸入文本的步驟如下：
標記化：首先，大模型將輸入文本分解成一系列的 token（詞或子詞）。例如，句子“請解釋一下黑洞的形成”可能被分解為以下 token：
["請", "解釋", "一", "下", "黑", "洞", "的", "形", "成"]文字表征：接下來，將這些 token 轉換為模型能夠理解的數值形式（通常是嵌入向量）。
概率預測：大模型會根據當前的輸入序列計算下一個詞的概率分布。這些概率分布表示下一個詞的可能性，例如：
{"黑洞": 0.1, "形成": 0.05, "是": 0.2, "由于": 0.15, ...}生成文本：根據概率分布選擇具體的一個詞作為下一個詞。選擇方式可以是貪婪搜索（選擇概率最大的詞）、隨機采樣（根據概率分布隨機選擇）或其他搜索策略（比如 Beam Search）。例如，使并將其用貪婪搜索選擇概率最大的詞“是”，添加到已生成的文本序列中，重復上述步驟。
[“請”, “解釋”, “一”, “下”, “黑”, “洞”, “的”, “形”, “成”, “是”]。因此，LLaMA 3 模型的推理過程是一個循環：通過預測下一個詞，將其加入到序列中，再預測下一個詞來生成連貫的文本。這種循環造成了大量的模型推理算力開銷，這也是為什么 OpenAI 等公司在 API 使用中根據 Token 計費。
接下來，我們通過一個具體的代碼示例來演示 LLaMA 3 的文本生成過程。假設我們有一個文章開頭：
在一個陽光明媚的早晨，Alice 決定去森林里探險。她走著走著，突然發現了一條小路。我們使用 LLaMA 3 來續寫這段話：
import torch
from modelscope import snapshot_download
from transformers import AutoModelForCausalLM, AutoTokenizer
# 下載模型
cache_dir = './llama_cache'
model_id = snapshot_download("LLM-Research/Meta-Llama-3-8B", cache_dir=cache_dir)import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
# 加載分詞器和模型
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None
)
# 編碼輸入并將其移至模型設備
input_text = "在一個陽光明媚的早晨，Alice決定去森林里探險。她走著走著，突然發現了一條小路。"
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
# 生成并解碼文本
with torch.no_grad():
outputs = model.generate(**inputs)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)輸出結果：
這條小路被兩旁茂密的樹木掩映著，似乎通向森林深處。Alice 決定沿著小路前進，想看看盡頭有什么驚喜等著她。在這個例子中，LLaMA 3 成功地續寫了文章內容，我們可以看到 LLaMA 3 流暢地生成了具有創意性的內容，這個生成的過程就是剛剛提到的 Next Token Prediction 循環所形成的。
停止條件
你可能會問，Next Token Prediction 的方式豈不是會一直輸出內容不停止？很好的問題！現在我們來聊聊 LLaMA 3 停止輸出的條件，LLaMA 3 的輸出由以下幾個因素控制：
最大長度（max_length）：這是最常用的控制方式之一。在初始化模型時，你可以指定一個最大長度值。當模型生成的文本長度達到該值時，它就會停止輸出。
例如，如果將最大長度設置為 100，那么模型生成的文本最長不會超過 100 個詞。
from transformers import AutoTokenizer, AutoModelForCausalLM
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None
)
max_length = 50
input_text = "寫一首關于愛情的詩"
encoded_input = tokenizer(input_text, return_tensors="pt")
output = model.generate(encoded_input.input_ids, max_length=max_length)
print(tokenizer.decode(output[0], skip_special_tokens=True))其他停止條件：一些模型還支持其他停止條件。例如檢測到重復的文本、低質量的文本等。
LLaMA 3 可以檢測到重復的文本并將其跳過。
from transformers import AutoTokenizer, AutoModelForCausalLM
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None
)
repetition_penalty = 1.2
input_text = "寫一首關于愛情的詩："
encoded_input = tokenizer(input_text, return_tensors="pt")
output = model.generate(encoded_input.input_ids, repetition_penalty=repetition_penalty)
print(tokenizer.decode(output[0], skip_special_tokens=True))其他停止條件：一些模型還支持其他停止條件。例如檢測到重復的文本、低質量的文本等。
LLaMA 3 可以檢測到重復的文本并將其跳過。
from transformers import AutoTokenizer, AutoModelForCausalLM
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None
)
repetition_penalty = 1.2
input_text = "寫一首關于愛情的詩："
encoded_input = tokenizer(input_text, return_tensors="pt")
output = model.generate(encoded_input.input_ids, repetition_penalty=repetition_penalty)
print(tokenizer.decode(output[0], skip_special_tokens=True))這些停止條件確保模型生成的文本不會無限延長，可以通過設置不同的參數來控制生成過程。
無狀態到有狀態：對話能力
對話生成不僅需要理解上下文，還得保持連貫性。因此，我們首先要解決的問題，就是大模型服務“無狀態”的問題。為了讓“無狀態”的 LLaMA 3 模型具備對話能力，我們可以將先前的“歷史會話”作為當前輸入的一部分。這樣可以保持上下文的連貫性，使模型成為一個“有狀態”的服務，從而準確地生成響應。
以下是實現這一功能的代碼示例：
import torch
from modelscope import snapshot_download
from transformers import AutoModelForCausalLM, AutoTokenizer
# 下載模型
cache_dir = './llama_cache'
model_id = snapshot_download("LLM-Research/Meta-Llama-3-8B-Instruct", cache_dir=cache_dir)from transformers import AutoTokenizer, AutoModelForCausalLM
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None
)
# 初始化對話歷史
dialogue_history = [
"Customer: Hi, I have an issue with my order.",
"Support: Sure, could you please provide your order number?",
"Customer: Sure, it's #12345.",
"Support: Thank you. Let me check the status for you.",
]
# 合并對話歷史為一個字符串
dialogue_history_text = "\n".join(dialogue_history)
# 添加用戶輸入，模擬當前對話
user_input = "Customer: Can you please expedite the delivery?"
input_text = dialogue_history_text + "\n" + user_input
# 生成文本
input_ids = tokenizer.encode(input_text, return_tensors="pt")
outputs = model.generate(input_ids, max_length=100)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Generated Response:", generated_text)這段代碼演示了如何使用 LLaMA 3 模型生成對話響應。
首先，我們定義了模型和 tokenizer，并初始化了一個簡單的對話歷史列表。然后，將對話歷史轉換為單個字符串，并添加用戶的當前輸入。接下來，我們使用 tokenizer 對輸入進行編碼，然后通過模型生成響應文本。最后，解碼生成的文本并打印出來。
這里為你帶來這節課的第一個重點，你可能會發現，上面的示例使用了基礎版模型，而下面的示例使用了 Instruct 版本的模型。這是為什么呢？這是因為這兩個模型的目標不一樣，為了服務不同的角色，每個版本 LLaMA 3 模型在訓練數據和訓練方法上有所不同，針對特定對象進行了微調，比如：
人類用戶：通過指令微調，使模型更好地理解和響應人類指令。這種微調使模型能夠處理更自然的語言輸入，提供更準確和相關的回答。
檢索系統：結合檢索系統的微調方法，提升模型在特定領域的信息檢索能力。通過實時檢索最新的外部數據，模型可以提供更加準確和時效性強的回答。
智能體（多步推理）：模型之間的協作與交互，通過互相微調提升整體智能水平。不同模型可以相互補充，共同完成復雜的任務，從而提高整體性能。
此外，選擇不同版本的 LLaMA 3 模型還需要考慮多個維度。
場景數據：根據不同應用場景選擇合適的指令微調數據，如語言、行業、文化等。不同領域的數據特點和需求不同，需要針對性地進行模型微調。
輸入長度：不同版本的模型在輸入長度上有所差異，我們需要根據具體應用需求選擇適合的模型版本。一些應用場景可能需要處理較長的輸入文本，因此選擇支持較長輸入的模型版本是必要的。
參數效率：通過微調降低模型的參數要求，例如使用更小的模型架構或優化算法。在資源有限的環境中，可以優化模型性能以滿足需求。通過合理的參數配置，可以在性能和資源消耗之間找到平衡點。
量化程度：不同量化程度帶來不同的性能提升和效果下降，需要在性能和效果之間找到平衡點。量化可以減少模型的計算和存儲需求，但也可能影響生成效果，因此需要根據具體應用情況進行權衡。
這些考慮因素在選擇和使用 LLaMA 3 模型時至關重要。隨著后面課程的深入，我們將在示例中不斷展開這些內容。
在解決了大模型的“無狀態“問題之后，我們再來看另一個大模型的局限性，那就是訓練數據時效性的問題。
封閉到開放：檢索增強
在某些情況下，我們需要 LLaMA 3 訓練后產生的最新事實。為了解決這個問題，我們可以結合檢索系統，在生成過程中獲取最新或特定領域的事實信息。
為了解決 LLaMA 3 無法提供最新的事實信息的問題，我們需要用到檢索增強生成（RAG）方法。簡單來說，RAG 就是結合外部知識庫或 API 進行實時檢索，并將檢索到的內容通過提示語補充到模型的輸入中。
這種方法可以顯著提高生成內容的準確性和時效性。例如，在對話過程中調用外部知識庫，增強回答的準確性。以下是一個常見的示例實現步驟：
定義檢索機制：首先，我們需要選擇一個適當的外部知識庫或 API，用于實時檢索最新的事實信息。常見的選擇包括搜索引擎 API、新聞 API、專門的行業知識庫等。
集成檢索系統：將外部檢索系統集成到 LLaMA 3 的生成流程中。當模型生成初步響應后，調用檢索系統獲取最新的相關信息，并將檢索到的信息整合到最終的響應中。
更新生成內容：利用檢索到的最新信息，更新和完善模型的初步生成內容，確保回答的準確性和時效性。
相應的，以下是一個簡單的代碼示例，演示如何在生成過程中集成外部知識庫進行實時檢索和信息更新。
定義檢索機制：在 retrieve_information 函數中，我們使用搜索引擎 API 根據給定的查詢關鍵詞檢索最新的信息。
集成檢索系統：在 generate_response 函數中，首先使用 LLaMA 3 生成初步響應，然后提取生成文本中的關鍵詞，通過 retrieve_information 函數獲取相關的最新信息。
更新生成內容：將檢索到的信息整合到最終的響應中，生成更為準確和時效性的回答。
import requests
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
from googleapiclient.discovery import build
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None
)
# Google Custom Search API配置
API_KEY = 'YOUR_GOOGLE_API_KEY'
SEARCH_ENGINE_ID = 'YOUR_SEARCH_ENGINE_ID'
# 檢索相關文檔的函數
def retrieve_documents(query):
try:
service = build("customsearch", "v1", developerKey=API_KEY)
res = service.cse().list(q=query, cx=SEARCH_ENGINE_ID).execute()
results = res.get('items', [])
documents = [item["snippet"] for item in results]
return documents
except Exception as e:
print(f"Error retrieving documents: {e}")
return []
# 生成答案的函數
def generate_answer(query, documents):
# 限制檢索到的文檔數量
documents = documents[:3]
context = "\n\n".join(documents) + "\n\nQuestion: " + query + "\nAnswer:"
# 編碼輸入
inputs = tokenizer(context, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
# 生成答案
outputs = model.generate(**inputs, max_length=512)
# 解碼答案
answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
return answer
# 主函數
def main():
query = "What is the capital of France?"
documents = retrieve_documents(query)
if documents:
answer = generate_answer(query, documents)
print("Question:", query)
print("Answer:", answer)
else:
print("No documents retrieved.")
if __name__ == "__main__":
main()Question: What is the capital of France?Answer: The capital of France is Paris. It is known for its art, fashion, and culture, and is home to famous landmarks such as the Eiffel Tower and the Louvre Museum.通過結合外部知識庫或 API 進行實時檢索和信息更新，我們可以有效解決 LLaMA 3 在生成過程中無法獲取最新事實的問題。這種方法不僅提高了回答的準確性，還確保了內容的時效性。在后續課程中，我們將進一步探討如何使用向量數據和混合檢索及重排技術，來構建一個定制化的 RAG 引擎。
單體服務到微服務：多智能體
在單步推理方面，LLaMA 3 存在一定的局限性，例如長對話和職責混亂可能會影響模型的推理性能。針對這些問題，多智能體架構提供了一些優化策略。多智能體系統（MAS）通過將多個智能體組織起來協同工作，實現復雜任務的解決。
每個智能體都有特定的角色和功能，通過相互之間的通信和協作來達成共同目標。在 LLaMA 3 的應用中，我們可以利用多智能體系統的以下優點：
拆分對話：將單一對話拆分成多個獨立的對話段，以減少對話長度對模型推理性能的影響。例如，在處理一個長篇對話時，可以將對話分成若干段，每段集中討論一個具體問題。
明確職責：當單個模型需要處理過多問題時，可以通過拆分角色來明確每個模型的職責。例如，在一個復雜的對話系統中，可以設置不同的子模型分別處理用戶意圖識別、對話管理和應答生成等任務。
角色拆分：通過角色拆分，確保每個模型處理的內容單一而連貫，從而提升整體對話系統的性能和準確性。例如，可以設置一個專門處理技術問題的模型和一個專門處理日常對話的模型，分別負責不同類型的對話。
為了模擬一個計算機科學家（Agent A）和一個法律專家（Agent B）協作解決人工智能合規標準制定的問題，我們設計了如下復雜的任務和分工：
gent A（計算機科學家）：負責提出技術實施的建議和技術難題的解決，熟悉人工智能技術和數據隱私。
# agent_a.py
from common import create_app
app = create_app("system: 你是一個熟悉人工智能技術的計算機科學家。")
if __name__ == '__main__':
app.run(port=5000)Agent B（法律專家）：負責評估合規性、提出法律建議和法規框架，精通法律法規和數據隱私保護。
# agent_b.py
from common import create_app
app = create_app("system: 你是一個熟悉法律法規的法律專家。")
if __name__ == '__main__':
app.run(port=5001)Agent C（標準化專家）：負責協調和整合建議，生成完整的技術合規方案。確保最終的合規方案完整和可實施。
# agent_c.py
from flask import Flask, request, jsonify
from transformers import pipeline
from transformers import AutoTokenizer, AutoModelForCausalLM
from langchain.agents import initialize_agent, Tool, AgentType
from langchain.llms import HuggingFacePipeline
import requests
import torch
app = Flask(__name__)
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None,
pad_token_id=tokenizer.eos_token_id
)
def call_expert(url, task_requirement):
response = requests.post(url, json={"intent": task_requirement}, timeout=5)
response.raise_for_status()
return response.json().get("response", "Error: No response from expert")
ai_expert = lambda task: call_expert("http://localhost:5000/chat", task)
law_expert = lambda task: call_expert("http://localhost:5001/chat", task)
ai = Tool.from_function(func=ai_expert, name="ai_expert", description="當你需要人工智能專家知識時使用這個工具，輸入為具體問題，返回為問題答案")
law = Tool.from_function(func=law_expert, name="law_expert", description="當你需要法律合規專家知識時使用這個工具，輸入為具體問題，返回為問題答案")
tools = [ai, law]
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512)
llm = HuggingFacePipeline(pipeline=pipe)
agent = initialize_agent(tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
max_iterations = 5,
handle_parsing_errors = True)
@app.route('/integrate', methods=['POST'])
def integrate():
data = request.get_json()
task = data.get('task', '')
res = agent.run(task)
return jsonify({'response': res})
if __name__ == '__main__':
app.run(port=5002)可以看出，在多智能體合作的時候，各個智能體在彼此的眼中都是工具。下面，通過 curl 命令向 http://localhost:5002/integrate 發送 POST 請求，任務描述為制定人工智能合規標準，避免人工智能傷害人類。
返回結果為標準化專家（Agent C）通過協調計算機科學家（Agent A）和法律專家（Agent B）的響應生成的綜合答案。
$ curl -X POST http://localhost:5002/integrate \
-H "Content-Type: application/json" \
-d '{"task": "制定人工智能合規標準，避免人工智能傷害人類"}'在這個設計示例中，計算機科學家和法律專家在制定人工智能合規標準時進行了分工和協作。Agent A 提出技術實施的建議和解決技術難題，而 Agent B 負責評估合規性、提出法律建議和法規框架。這種分工模式能有效結合技術實施和法律法規，以確保人工智能技術的合法合規性。
最后，我們展開介紹 common.py，這個函數接收模型目錄和種子記憶（seed memory）作為參數，創建并返回一個 python 服務應用。
這里有一個重點，那就是我們要給每個 Agent 一個種子記憶，也就是它的全局人設，這是智能體應用中最重要的部分，因為如果沒有一個堅固的人設，智能體在長期工作過程中一定會出現偏離，在后面課程中我將進一步解釋這句話的含義。
# common.py
from flask import Flask, request, jsonify
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
def create_app(seed_memory):
app = Flask(__name__)
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
device_map="auto" if torch.cuda.is_available() else None,
pad_token_id=tokenizer.eos_token_id
)
# 定義聊天接口
@app.route('/chat', methods=['POST'])
def chat():
data = request.get_json()
intent = data.get('intent', '')
# 構造提示詞
prompt = f"{seed_memory}\n請回答以下問題:{intent}"
input_ids = tokenizer.encode(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(input_ids, max_length=150)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
return jsonify({'response': response})
return app當然本節課的例子都是為了讓你可以快速產生感性認識，這種實現方式適用于簡單的示例和小規模的應用，但在生產環境中則需要進一步地學習更復雜的方案。
