Verfolgung von Large Language Models (LLMs) mit MLflow: Ein umfassender Leitfaden

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 = "Erklären Sie das Konzept des maschinellen Lernens in einfachen Worten."</p>

<p># Protokollieren von Parametern
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p># Abfrage des LLM und Protokollierung des Ergebnisses
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))</p>

<p># Protokollieren des Prompts und der Antwort
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>

<p>print(f"Antwort: {result}")

import mlflow
from mlflow.deployments import get_deploy_client

<p># Initialisieren des Bereitstellungs-Clients
client = get_deploy_client("databricks")</p>

<p># Definieren der Endpunkt-Konfiguration
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># Erstellen des Endpunkts
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": "Erklären Sie das Konzept der neuronalen Netze kurz.", "max_tokens": 100,},)</p>

print(response)

Dies sendet eine Abfrage an unser bereitgestelltes Modell und gibt die generierte Antwort zurück.

Bewertung von LLMs mit MLflow

Die Bewertung ist entscheidend für das Verständnis der Leistung und des Verhaltens Ihrer LLMs. MLflow bietet umfassende Tools für die Bewertung von LLMs, einschließlich integrierter und benutzerdefinierter Metriken.

Vorbereitung Ihres LLMs für die Bewertung

Um Ihr LLM mit mlflow.evaluate() zu bewerten, muss Ihr Modell in einer der folgenden Formen vorliegen:

1. Ein mlflow.pyfunc.PyFuncModel-Instanz oder ein URI, der auf ein protokolliertes MLflow-Modell verweist.
2. Eine Python-Funktion, die String-Eingaben annimmt und eine einzelne String-Ausgabe zurückgibt.
3. Ein MLflow-Bereitstellungs-Endpunkt-URI.
4. Setzen Sie model=None und schließen Sie Modellausgaben in die Bewertungsdaten ein.

Lassen Sie uns ein Beispiel mit einem protokollierten MLflow-Modell betrachten:

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "Beantworten Sie die folgende Frage knapp."
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># Vorbereiten der Bewertungsdaten
eval_data = pd.DataFrame({
"question": ["Was ist maschinelles Lernen?", "Erklären Sie neuronale Netze."],
"ground_truth": [
"Maschinelles Lernen ist ein Teilbereich der künstlichen Intelligenz, der es Systemen ermöglicht, aus Erfahrungen zu lernen und sich zu verbessern, ohne explizite Programmierung.",
"Neuronale Netze sind Rechenmodelle, die von biologischen neuronalen Netzen inspiriert sind und aus miteinander verbundenen Knoten bestehen, die Informationen verarbeiten und übertragen.",
]
})</p>

<p># Bewerten des Modells
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>

<p>print(f"Bewertungsmetriken: {results.metrics}")

Dieses Beispiel protokolliert ein OpenAI-Modell, bereitet Bewertungsdaten vor und bewertet das Modell dann mit den integrierten Metriken von MLflow für Frage-Antwort-Aufgaben.

Benutzerdefinierte Bewertungsmetriken

MLflow ermöglicht es Ihnen, benutzerdefinierte Metriken für die Bewertung von LLMs zu definieren. Hier ist ein Beispiel für die Erstellung einer benutzerdefinierten Metrik zur Bewertung der Professionalität von Antworten:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="Maß für formellen und angemessenen Kommunikationsstil.",
grading_prompt=(
"Bewerten Sie die Professionalität der Antwort auf einer Skala von 0-4:\n"
"0: Extrem locker oder unangemessen\n"
"1: Locker, aber respektvoll\n"
"2: Mittelmäßig formal\n"
"3: Professionell und angemessen\n"
"4: Hoch formal und expertenmäßig gestaltet"
),
examples=[
EvaluationExample(
input="Was ist MLflow?",
output="MLflow ist wie Ihr freundlicher Nachbarschaftstoolkit für die Verwaltung von ML-Projekten. Es ist super cool!",
score=1,
justification="Die Antwort ist locker und verwendet informelle Sprache.",
),
EvaluationExample(
input="Was ist MLflow?",
output="MLflow ist eine Open-Source-Plattform für den maschinellen Lernzyklus, einschließlich Experimentierung, Reproduzierbarkeit und Bereitstellung.",
score=4,
justification="Die Antwort ist formal, präzise und professionell formuliert.",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p># Verwenden der benutzerdefinierten Metrik in der Bewertung
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>

<p>print(f"Professionalitäts-Score: {results.metrics['professionalism_mean']}")

Diese benutzerdefinierte Metrik verwendet GPT-3.5-Turbo, um die Professionalität von Antworten zu bewerten, und zeigt, wie Sie LLMs selbst für die Bewertung nutzen können.

Fortgeschrittene LLM-Bewertungstechniken

Da LLMs immer komplexer werden, werden auch die Techniken für ihre Bewertung komplexer. Lassen Sie uns einige fortgeschrittene Bewertungsmethoden mit MLflow erkunden.

Retrieval-Augmented-Generation-(RAG)-Bewertung

RAG-Systeme kombinieren die Kraft von Retrieval-basierten und generativen Modellen. Die Bewertung von RAG-Systemen erfordert die Bewertung sowohl der Retrieval- als auch der Generierungskomponenten. Hier ist, wie Sie ein RAG-System einrichten und mit MLflow bewerten können:

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># Laden und Vorverarbeiten von Dokumenten
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># Erstellen eines Vektor-Speichers
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>

<p># Erstellen eines 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># Bewertungsfunktion
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p># Vorbereiten der Bewertungsdaten
eval_questions = [
"Was ist MLflow?",
"Wie handhabt MLflow die Experiment-Verfolgung?",
"Was sind die Hauptkomponenten von MLflow?",
]</p>

<p># Bewerten mit 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># Protokollieren von benutzerdefinierten Metriken
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))