使用 MLflow 跟踪大型语言模型 (LLM)：完整指南

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)

这将向我们部署的模型发送提示并返回生成的响应。

使用 MLflow 评估 LLM

评估对于了解 LLM 的性能和行为至关重要。MLflow 提供了用于评估 LLM 的全面工具，包括内置指标​​和自定义指标。

准备你的法学硕士 (LLM) 评估

评估你的法学硕士 mlflow.evaluate()，你的模型需要采用以下形式之一：

1. An mlflow.pyfunc.PyFuncModel 实例或指向已记录的 MLflow 模型的 URI。
2. 接受字符串输入并输出单个字符串的 Python 函数。
3. MLflow 部署端点 URI。
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 变得越来越复杂，评估它们的技术也日益先进。让我们探索一些使用 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))