Spåra Stora Språkmodeller med MLflow: En Komplett 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 = "Förklara konceptet maskinlärning på ett enkelt sätt."</p>

<p> # Logga parametrar
mlflow.log_param("modell", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p> # Fråga LLM och logga resultat
result = query_llm(prompt)
mlflow.log_metric("svars_längd", len(result))</p>

<p> # Logga prompt och svar
mlflow.log_table("prompt_svar", {"prompt": [prompt], "svar": [result]})</p>

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

import mlflow
from mlflow.deployments import get_deploy_client

<p># Initiera distributionsklienten
client = get_deploy_client("databricks")</p>

<p># Definiera slutpunktskonfigurationen
slutpunktsnamn = "llm-slutpunkt"
slutpunktskonfig = {
"served_entities": [{
"name": "gpt-modell",
"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># Skapa slutpunkten
client.create_endpoint(name=slutpunktsnamn, config=slutpunktskonfig)

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

<p>response = client.predict(
endpoint=slutpunktsnamn,
inputs={"prompt": "Förklara konceptet neuronnät på ett kort sätt.", "max_tokens": 100,},
)</p>

print(response)

Detta kommer att skicka en prompt till vår distribuerade modell och returnera den genererade responsen.

Utvärdera LLM med MLflow

Utvärdering är avgörande för att förstå prestanda och beteende hos dina LLM. MLflow erbjuder omfattande verktyg för att utvärdera LLM, inklusive både inbyggda och anpassade mätvärden.

Förbereda Din LLM för Utvärdering

För att utvärdera din LLM med mlflow.evaluate() måste din modell vara i en av följande former:

1. En mlflow.pyfunc.PyFuncModel-instans eller en URI som pekar på en loggad MLflow-modell.
2. En Python-funktion som tar stränginmatningar och returnerar en enda sträng.
3. En MLflow-distributions-slutpunkts-URI.
4. Ange modell=None och inkludera modellutdata i utvärderingsdata.

Låt oss titta på ett exempel som använder en loggad MLflow-modell:

import mlflow
import openai

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

<p> system_prompt = "Svara på följande fråga kortfattat."
logged_model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.chat.completions,
artifact_path="modell",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": "{fråga}"},
],
)</p>

<p> # Förbered utvärderingsdata
utvärderingsdata = pd.DataFrame({
"fråga": ["Vad är maskinlärning?", "Förklara neuronnät."],
"grund_sanning": [
"Maskinlärning är en undergrupp till AI som möjliggör system att lära och förbättra från erfarenhet utan explicit programmering.",
"Neuronnät är beräkningsystem inspirerade av biologiska neuronnät, bestående av sammanlänkade noder som bearbetar och överför information.",
]
})</p>

<p> # Utvärdera modellen
result = mlflow.evaluate(
logged_model_info.model_uri,
utvärderingsdata,
targets="grund_sanning",
model_type="frågesvar",
)</p>

<p>print(f"Utvärderingsmätvärden: {result.metrics}")

Detta exempel loggar en OpenAI-modell, förbereder utvärderingsdata och utvärderar sedan modellen med MLflows inbyggda mätvärden för frågesvarsuppgifter.

Anpassade Utvärderingsmätvärden

MLflow tillåter dig att definiera anpassade mätvärden för LLM-utvärdering. Här är ett exempel på att skapa ett anpassat mätvärde för att utvärdera professionalismen i svaren:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="Mått på formell och lämplig kommunikationsstil.",
grading_prompt=(
"Ge ett betyg på professionalismen i svaret på en skala från 0-4:\n"
"0: Extremt informell eller olämplig\n"
"1: Informell men respektfull\n"
"2: Måttligt formell\n"
"3: Professionell och lämplig\n"
"4: Mycket formell och expertutformad"
),
examples=[
EvaluationExample(
input="Vad är MLflow?",
output="MLflow är som ditt vänliga grannverktyg för att hantera ML-projekt. Det är supercoolt!",
score=1,
justification="Svaret är informellt och använder informell språk.",
),
EvaluationExample(
input="Vad är MLflow?",
output="MLflow är en öppen källkodsplattform för maskinlärningslivscykeln, inklusive experiment, reproducerbarhet och distribution.",
score=4,
justification="Svaret är formellt, koncist och professionellt utformat.",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p> # Använd det anpassade mätvärdet i utvärdering
result = mlflow.evaluate(
logged_model_info.model_uri,
utvärderingsdata,
targets="grund_sanning",
model_type="frågesvar",
extra_metrics=[professionalism]
)</p>

<p>print(f"Professionalismsscore: {result.metrics['professionalism_mean']}")

Detta anpassade mätvärde använder GPT-3.5-turbo för att bedöma professionalismen i svaren, vilket visar hur du kan utnyttja LLM själva för utvärdering.

Avancerade LLM-utvärderingstekniker

När LLM blir mer avancerade, blir också utvärderingsteknikerna mer avancerade. Låt oss utforska några avancerade utvärderingsmetoder med MLflow.

Retrieval-Augmented Generation (RAG) Utvärdering

RAG-system kombinerar kraften i retrieval-baserade och generativa modeller. Utvärdering av RAG-system kräver bedömning av både retrieval- och genereringskomponenterna. Här är hur du kan konfigurera ett RAG-system och utvärdera det med 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> # Ladda och förbered dokument
loader = WebBaseLoader(["https://mlflow.org/docs/latest/index.html"])
dokument = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texter = text_splitter.split_documents(dokument)</p>

<p> # Skapa vektorlagring
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texter, embeddings)</p>

<p> # Skapa RAG-kedja
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> # Utvärderingsfunktion
def evaluate_rag(fråga):
result = qa_chain({"query": fråga})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p> # Förbered utvärderingsdata
utvärderingsfrågor = [
"Vad är MLflow?",
"Hur hanterar MLflow experimentsspårning?",
"Vilka är de viktigaste komponenterna i MLflow?",
]</p>

<p> # Utvärdera med MLflow
with mlflow.start_run():
for fråga in utvärderingsfrågor:
svar, källor = evaluate_rag(fråga)</p>

<p> mlflow.log_param(f"fråga", fråga)
mlflow.log_metric("antal_källor", len(källor))
mlflow.log_text(svar, f"svar_{fråga}.txt")</p>

<p> for i, källa in enumerate(källor):
mlflow.log_text(källa, f"källa_{fråga}_{i}.txt")</p>

<p> # Logga anpassade mätvärden
mlflow.log_metric("genomsnittligt_antal_källor_per_fråga", sum(len(evaluate_rag(q)[1]) for q in utvärderingsfrågor) / len(utvärderingsfrågor))