การติดตามโมเดลภาษาขนาดใหญ่ (LLM) โดยใช้ MLflow: คู่มือที่สมบูรณ์

pip install mlflow>=2.8.1
pip install openai
pip install chromadb==0.4.15
pip install langchain==0.0.348
pip install tiktoken
pip install 'mlflow[genai]'
pip install databricks-sdk --upgrade

import mlflow
import chromadb

<p>print(f"MLflow version: {mlflow.__version__}")
print(f"ChromaDB version: {chromadb.__version__}")

import mlflow
import openai

<p>def query_llm(prompt, max_tokens=100):
response = openai.Completion.create(
engine="text-davinci-002",
prompt=prompt,
max_tokens=max_tokens
)
return response.choices[0].text.strip()</p>

<p>with mlflow.start_run():
prompt = "อธิบายแนวคิดของการเรียนรู้ของเครื่องในคำพูดที่ง่าย"</p>

<p># บันทึกพารามิเตอร์
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p># ค้นหา LLM และบันทึกผลลัพธ์
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))</p>

<p># บันทึกคำถามและคำตอบ
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>

<p>print(f"คำตอบ: {result}")

import mlflow
from mlflow.deployments import get_deploy_client

<p># เริ่มต้นไคลเอ็นต์การนำไปใช้
client = get_deploy_client("databricks")</p>

<p># กำหนดค่าจุดสิ้นสุด
endpoint_name = "llm-endpoint"
endpoint_config = {
"served_entities": [{
"name": "gpt-model",
"external_model": {
"name": "gpt-3.5-turbo",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_type": "azure",
"openai_api_key": "{{secrets/scope/openai_api_key}}",
"openai_api_base": "{{secrets/scope/openai_api_base}}",
"openai_deployment_name": "gpt-35-turbo",
"openai_api_version": "2023-05-15",
},
},
}],
}</p>

<p># สร้างจุดสิ้นสุด
client.create_endpoint(name=endpoint_name, config=endpoint_config)

<div class="relative flex flex-col rounded-lg">

<p>response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "อธิบายแนวคิดของเครือข่ายประสาทเทียมอย่างง่าย", "max_tokens": 100,},)</p>

print(response)

สิ่งนี้จะส่งคำถามไปยังโมเดลที่เราเสิร์ฟและคืนคำตอบที่สร้างขึ้น

การประเมิน LLM โดยใช้ MLflow

การประเมินเป็นสิ่งสำคัญสำหรับการทำความเข้าใจประสิทธิภาพและพฤติกรรมของ LLM ของคุณ MLflow มีเครื่องมือที่ครอบคลุมสำหรับการประเมิน LLM รวมถึงเมตริกที่มีอยู่และแบบกำหนดเอง

การเตรียม LLM สำหรับการประเมิน

เพื่อประเมิน LLM ของคุณโดยใช้ mlflow.evaluate() โมเดลของคุณต้องอยู่ในรูปแบบต่อไปนี้:

1. อินสแตนซ์ mlflow.pyfunc.PyFuncModel หรือ URI ที่ชี้ไปยังโมเดล MLflow ที่บันทึกไว้
2. ฟังก์ชัน Python ที่รับข้อมูลเข้าเป็นข้อความและคืนค่าข้อความเดียว
3. URI ของจุดสิ้นสุด MLflow Deployments
4. ตั้งค่า model=None และรวมเอาต์พุตของโมเดลไว้ในข้อมูลการประเมิน

มาทำตัวอย่างโดยใช้โมเดล MLflow ที่บันทึกไว้:

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "ตอบคำถามต่อไปนี้อย่างสั้น"
logged_model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.chat.completions,
artifact_path="model",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": "{question}"},
],
)</p>

<p># เตรียมข้อมูลการประเมิน
eval_data = pd.DataFrame({
"question": ["อะไรคือการเรียนรู้ของเครื่อง?", "อธิบายเครือข่ายประสาทเทียม"],
"ground_truth": [
"การเรียนรู้ของเครื่องเป็นส่วนหนึ่งของ AI ที่ช่วยให้ระบบสามารถเรียนรู้และปรับปรุงจากประสบการณ์โดยไม่ต้องเขียนโปรแกรมอย่างชัดเจน",
"เครือข่ายประสาทเทียมเป็นระบบการประมวลผลที่ได้รับแรงบันดาลใจจากเครือข่ายประสาททางชีววิทยา ประกอบด้วยโหนดที่เชื่อมต่อกันซึ่งประมวลผลและถ่ายทอดข้อมูล",
]
})</p>

<p># ประเมินโมเดล
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>

<p>print(f"เมตริกการประเมิน: {results.metrics}")

ตัวอย่างนี้บันทึกโมเดล OpenAI เตรียมข้อมูลการประเมิน จากนั้นประเมินโมเดลโดยใช้เมตริกที่มีอยู่ของ MLflow สำหรับการตอบคำถาม

การสร้างเมตริกแบบกำหนดเอง

MLflow ช่วยให้คุณสามารถกำหนดเมตริกแบบกำหนดเองสำหรับการประเมิน LLM ได้ มาทำตัวอย่างการสร้างเมตริกแบบกำหนดเองสำหรับการประเมินความเป็นมืออาชีพของคำตอบ:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="การวัดระดับของการสื่อสารที่เป็นทางการและเหมาะสม",
grading_prompt=(
"ให้คะแนนความเป็นมืออาชีพของคำตอบตามมาตราส่วน 0-4:\n"
"0: มากเกินไปหรือไม่เหมาะสม\n"
"1: ไม่ทางการแต่ให้ความเคารพ\n"
"2: มoderately เป็นทางการ\n"
"3: มืออาชีพและเหมาะสม\n"
"4: มืออาชีพและสร้างสรรค์"
),
examples=[
EvaluationExample(
input="อะไรคือการเรียนรู้ของเครื่อง?",
output="การเรียนรู้ของเครื่องเป็นเครื่องมือที่ยอดเยี่ยมสำหรับโครงการ ML",
score=1,
justification="คำตอบไม่ทางการและใช้ภาษาไม่เหมาะสม",
),
EvaluationExample(
input="อะไรคือการเรียนรู้ของเครื่อง?",
output="การเรียนรู้ของเครื่องเป็นส่วนหนึ่งของ AI ที่ช่วยให้ระบบสามารถเรียนรู้และปรับปรุงจากประสบการณ์โดยไม่ต้องเขียนโปรแกรมอย่างชัดเจน",
score=4,
justification="คำตอบเป็นทางการ สั้นและเขียนด้วยภาษาที่มืออาชีพ",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p># ใช้เมตริกแบบกำหนดเองในการประเมิน
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>

<p>print(f"คะแนนความเป็นมืออาชีพ: {results.metrics['professionalism_mean']}")

เมตริกแบบกำหนดเองนี้ใช้ GPT-3.5-turbo เพื่อประเมินความเป็นมืออาชีพของคำตอบ โดยแสดงให้เห็นว่าคุณสามารถใช้ LLM เองในการประเมินได้อย่างไร

เทคนิคการประเมิน LLM ขั้นสูง

เมื่อ LLM มีความซับซ้อนมากขึ้น เทคนิคการประเมินก็เช่นกัน มาทำความเข้าใจเทคนิคการประเมินที่ขั้นสูงโดยใช้ MLflow

การประเมิน Retrieval-Augmented Generation (RAG)

ระบบ RAG รวมพลังของโมเดลการค้นหาและการสร้างข้อความ การประเมินระบบ RAG ต้องประเมินส่วนการค้นหาและการสร้างข้อความทั้งสองส่วน มาทำความเข้าใจวิธีการตั้งค่าระบบ RAG และประเมินโดยใช้ MLflow:

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

<p># โหลดและประมวลผลเอกสาร
loader = WebBaseLoader(["https://mlflow.org/docs/latest/index.html"])
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)</p>

<p># สร้าง vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>

<p># สร้าง RAG chain
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)</p>

<p># ฟังก์ชันการประเมิน
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p># เตรียมข้อมูลการประเมิน
eval_questions = [
"อะไรคือการเรียนรู้ของเครื่อง?",
"การเรียนรู้ของเครื่องช่วยให้ทำอะไรได้บ้าง?",
"ส่วนประกอบหลักของการเรียนรู้ของเครื่องคืออะไร?",
]</p>

<p># ประเมินโดยใช้ MLflow
with mlflow.start_run():
for question in eval_questions:
answer, sources = evaluate_rag(question)</p>

<p>mlflow.log_param(f"question", question)
mlflow.log_metric("num_sources", len(sources))
mlflow.log_text(answer, f"answer_{question}.txt")</p>

<p>for i, source in enumerate(sources):
mlflow.log_text(source, f"source_{question}_{i}.txt")</p>

<p># บันทึกเมตริกแบบกำหนดเอง
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))