การติดตามโมเดลภาษาขนาดใหญ่ (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

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

import mlflow
import openai

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()

with mlflow.start_run():
    prompt = "Explain the concept of machine learning in simple terms."
    
    # Log parameters
    mlflow.log_param("model", "text-davinci-002")
    mlflow.log_param("max_tokens", 100)
    
    # Query the LLM and log the result
    result = query_llm(prompt)
    mlflow.log_metric("response_length", len(result))
    
    # Log the prompt and response
    mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})
    
    print(f"Response: {result}")

import mlflow
from mlflow.deployments import get_deploy_client

# Initialize the deployment client
client = get_deploy_client("databricks")

# Define the endpoint configuration
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",
            },
        },
    }],
}

# Create the endpoint
client.create_endpoint(name=endpoint_name, config=endpoint_config)

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

response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Explain the concept of neural networks briefly.","max_tokens": 100,},)

print(response)

สิ่งนี้จะส่งข้อความพร้อมท์ไปยังโมเดลที่ปรับใช้ของเราและส่งคืนการตอบกลับที่สร้างขึ้น

การประเมิน LLM ด้วย MLflow

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

เตรียม LLM ของคุณสำหรับการประเมินผล

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

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

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

import mlflow
import openai

with mlflow.start_run():
    system_prompt = "Answer the following question concisely."
    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}"},
        ],
    )

# Prepare evaluation data
eval_data = pd.DataFrame({
    "question": ["What is machine learning?", "Explain neural networks."],
    "ground_truth": [
        "Machine learning is a subset of AI that enables systems to learn and improve from experience without explicit programming.",
        "Neural networks are computing systems inspired by biological neural networks, consisting of interconnected nodes that process and transmit information."
    ]
})

# Evaluate the model
results = mlflow.evaluate(
    logged_model_info.model_uri,
    eval_data,
    targets="ground_truth",
    model_type="question-answering",
)

print(f"Evaluation metrics: {results.metrics}")

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

ตัวชี้วัดการประเมินผลที่กำหนดเอง

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

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

professionalism = make_genai_metric(
    name="professionalism",
    definition="Measure of formal and appropriate communication style.",
    grading_prompt=(
        "Score the professionalism of the answer on a scale of 0-4:\n"
        "0: Extremely casual or inappropriate\n"
        "1: Casual but respectful\n"
        "2: Moderately formal\n"
        "3: Professional and appropriate\n"
        "4: Highly formal and expertly crafted"
    ),
    examples=[
        EvaluationExample(
            input="What is MLflow?",
            output="MLflow is like your friendly neighborhood toolkit for managing ML projects. It's super cool!",
            score=1,
            justification="The response is casual and uses informal language."
        ),
        EvaluationExample(
            input="What is MLflow?",
            output="MLflow is an open-source platform for the machine learning lifecycle, including experimentation, reproducibility, and deployment.",
            score=4,
            justification="The response is formal, concise, and professionally worded."
        )
    ],
    model="openai:/gpt-3.5-turbo-16k",
    parameters={"temperature": 0.0},
    aggregations=["mean", "variance"],
    greater_is_better=True,
)

# Use the custom metric in evaluation
results = mlflow.evaluate(
    logged_model_info.model_uri,
    eval_data,
    targets="ground_truth",
    model_type="question-answering",
    extra_metrics=[professionalism]
)

print(f"Professionalism score: {results.metrics['professionalism_mean']}")

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

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

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

การประเมินการสร้างแบบดึงข้อมูล-เสริม (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

# Load and preprocess documents
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)

# Create vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# Create 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
)

# Evaluation function
def evaluate_rag(question):
    result = qa_chain({"query": question})
    return result["result"], [doc.page_content for doc in result["source_documents"]]

# Prepare evaluation data
eval_questions = [
    "What is MLflow?",
    "How does MLflow handle experiment tracking?",
    "What are the main components of MLflow?"
]

# Evaluate using MLflow
with mlflow.start_run():
    for question in eval_questions:
        answer, sources = evaluate_rag(question)
        
        mlflow.log_param(f"question", question)
        mlflow.log_metric("num_sources", len(sources))
        mlflow.log_text(answer, f"answer_{question}.txt")
        
        for i, source in enumerate(sources):
            mlflow.log_text(source, f"source_{question}_{i}.txt")

    # Log custom metrics
    mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))