Sporing af Large Language Models (LLM) med MLflow: En Komplet Guide

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):</p>

<p> 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():</p>

<p> prompt = "Forklar begrebet maskinlæring på en simpel måde."</p>

<p> # Log parametre
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p> # Spørg LLM og log resultater
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))</p>

<p> # Log prompt og svar
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>

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

import mlflow
from mlflow.deployments import get_deploy_client

<p># Initialiser installationsklienten
client = get_deploy_client("databricks")</p>

<p># Definer slutpunktets konfiguration
endpoint_name = "llm-slutpunkt"
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># Opret slutpunktet
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": "Forklar begrebet neurale netværk kort.", "max_tokens": 100,},)</p>

print(response)

Dette sender en prompt til vores installeret model og returnerer den genererede respons.

Evaluering af LLM med MLflow

Evaluering er afgørende for at forstå ydeevnen og adfærden af dine LLM. MLflow giver omfattende værktøjer til evaluering af LLM, herunder både indbyggede og brugerdefinerede mål.

Forberedelse af din LLM til evaluering

For at evaluere din LLM med mlflow.evaluate(), skal din model være i en af disse former:

1. En mlflow.pyfunc.PyFuncModel-instance eller en URI, der peger på en loggeret MLflow-model.
2. En Python-funktion, der tager streng-input og returnerer en enkelt streng.
3. En MLflow-installationsslutpunkt-URI.
4. Sæt model=None og inkluder modeloutput i evalueringens data.

Lad os se på et eksempel, der bruger en loggeret MLflow-model:

import mlflow
import openai

<p>with mlflow.start_run():</p>

<p> system_prompt = "Besvar følgende spørgsmål kortfattet."
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> # Forbered evalueringdata
eval_data = pd.DataFrame({
"question": ["Hvad er maskinlæring?", "Forklar neurale netværk."],
"ground_truth": [
"Maskinlæring er en underkategori af AI, der giver systemer mulighed for at lære og forbedre sig fra erfaring uden eksplicit programmering.",
"Neurale netværk er beregningsystemer inspireret af biologiske neurale netværk, bestående af sammenkoblede noder, der behandler og transmitterer information.",
]
})</p>

<p> # Evaluér modellen
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>

<p>print(f"Evalueringmål: {results.metrics}")

Dette eksempel logger en OpenAI-model, forbereder evalueringdata og evaluerer derefter modellen ved hjælp af MLflows indbyggede mål til spørgsmål-svar-opgaver.

Brugerdefinerede evalueringmål

MLflow giver mulighed for at definere brugerdefinerede mål til LLM-evaluering. Her er et eksempel på, hvordan man kan oprette et brugerdefineret mål til at evaluere professionelhed i svarene:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="Mål for formel og passende kommunikationsstil.",
grading_prompt=(
"Vurder professionelhed i svaret på en skala fra 0-4:\n"
"0: Ekstremt uformel eller upassende\n"
"1: Uformel, men respektfuld\n"
"2: Moderat formel\n"
"3: Professionel og passende\n"
"4: Meget formel og ekspertudført"
),
examples=[
EvaluationExample(
input="Hvad er MLflow?",
output="MLflow er som dit venlige nabolagsværktøj til at styre ML-projekter. Det er super fedt!",
score=1,
justification="Svaret er uformelt og bruger uformel sprog.",
),
EvaluationExample(
input="Hvad er MLflow?",
output="MLflow er en åben platform for maskinlæringslivscyklussen, herunder eksperimentering, reproducerbarhed og installation.",
score=4,
justification="Svaret er formelt, kortfattet og professionelt formuleret.",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p> # Brug det brugerdefinerede mål i evaluering
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>

<p>print(f"Professionalitets-score: {results.metrics['professionalism_mean']}")

Dette brugerdefinerede mål bruger GPT-3.5-turbo til at score professionelhed i svarene, og demonstrerer, hvordan man kan udnytte LLM selv til evaluering.

Avancerede LLM-evalueringsteknikker

Da LLM bliver mere avanceret, bliver også evalueringsteknikkerne mere avancerede. Lad os udforske nogle avancerede evalueringsteknikker med MLflow.

Retrieval-Augmented Generation (RAG)-evaluering

RAG-systemer kombinerer kraften fra retrieval-baserede og generative modeller. Evaluering af RAG-systemer kræver vurdering af både retrieval- og genereringskomponenterne. Her er, hvordan du kan opsætte et RAG-system og evaluere det ved hjælp af 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> # Indlæs og forbered dokumenter
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> # Opret vektorlager
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>

<p> # Opret RAG-kæde
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> # Evaluéringsfunktion
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p> # Forbered evalueringdata
eval_questions = [
"Hvad er MLflow?",
"Hvordan håndterer MLflow eksperimentssporing?",
"Hvad er de vigtigste komponenter i MLflow?",
]</p>

<p> # Evaluér ved hjælp af 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> # Log brugerdefinerede mål
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))