Sporing av store språkmodeller (LLM) 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-versjon: {mlflow.__version__}")
print(f"ChromaDB-versjon: {chromadb.__version__}")

import mlflow
import openai

<p>def spør_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 = "Forklar konseptet om maskinlæring på en enkel måte."</p>

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

<p># Spør LLM og logg resultatet
result = spør_llm(prompt)
mlflow.log_metric("svarlengde", len(result))</p>

<p># Logg prompt og 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># Initialiser distribusjonsklienten
client = get_deploy_client("databricks")</p>

<p># Definer sluttpunktkonfigurasjon
sluttpunkt_navn = "llm-sluttpunkt"
sluttpunkt_konfig = {
"served_entities": [{
"navn": "gpt-modell",
"ekstern_modell": {
"navn": "gpt-3.5-turbo",
"tilbyder": "openai",
"oppgave": "llm/v1/completions",
"openai_konfig": {
"openai_api_type": "azure",
"openai_api_nøkkel": "{{secrets/scope/openai_api_nøkkel}}",
"openai_api_base": "{{secrets/scope/openai_api_base}}",
"openai_distribusjonsnavn": "gpt-35-turbo",
"openai_api_versjon": "2023-05-15",
},
},
}],
}</p>

<p># Opprett sluttpunkt
client.create_endpoint(name=sluttpunkt_navn, config=sluttpunkt_konfig)

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

<p>response = client.predict(
endpoint=sluttpunkt_navn,
inputs={"prompt": "Forklar konseptet om neurale nettverk kort.", "max_tokens": 100,},
)</p>

print(response)

Dette vil sende en spørring til vår distribuerte modell og returnere den genererte responsen.

Evaluering av LLM med MLflow

Evaluering er avgjørende for å forstå ytelsen og atferden til dine LLM. MLflow tilbyr omfattende verktøy for å evaluere LLM, inkludert både innebygde og tilpassede målinger.

Forberedelse av LLM for evaluering

For å evaluere din LLM med mlflow.evaluate(), må din modell være i en av følgende former:

1. En mlflow.pyfunc.PyFuncModel-instans eller en URI som peker til en logget MLflow-modell.
2. En Python-funksjon som tar string-input og returnerer en enkelt string.
3. En MLflow-distribusjonssluttpunkt-URI.
4. Sett modell=None og inkluder modell-utdata i evalueringsdataene.

La oss se på et eksempel som bruker en logget MLflow-modell:

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "Svar på følgende spørring kort."
logget_modell_info = mlflow.openai.log_modell(
modell="gpt-3.5-turbo",
oppgave=openai.chat.completions,
artifact_path="modell",
meldinger=[
{"rolle": "system", "innhold": system_prompt},
{"rolle": "bruker", "innhold": "{spørring}"},
],
)</p>

<p># Forbered evalueringdata
eval_data = pd.DataFrame({
"spørring": ["Hva er maskinlæring?", "Forklar neurale nettverk."],
"grunn_sannhet": [
"Maskinlæring er en undergruppe av AI som muliggjør systemer å lære og forbedre seg fra erfaring uten eksplisitt programmering.",
"Neurale nettverk er datamaskin-systemer inspirert av biologiske neurale nettverk, bestående av sammenkoblede noder som prosesserer og overfører informasjon.",
]
})</p>

<p># Evaluering av modell
resultater = mlflow.evaluate(
logget_modell_info.model_uri,
eval_data,
mål="grunn_sannhet",
modell_type="spørring-svar",
)</p>

<p>print(f"Evalueringmålinger: {resultater.målinger}")

Dette eksemplet logger en OpenAI-modell, forbereder evalueringdata og evalueringer så modellen ved hjelp av MLflows innebygde målinger for spørring-svar-oppgaver.

Tilpassede evalueringmålinger

MLflow tillater deg å definere tilpassede målinger for LLM-evaluering. Her er et eksempel på å opprette en tilpasset måling for å evaluere profesjonaliteten til svarene:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>profesjonalitet = make_genai_metric(
navn="profesjonalitet",
definisjon="Mål på formell og passende kommunikasjonsstil.",
grading_prompt=(
"Vurdér profesjonaliteten til svaret på en skala fra 0-4:\n"
"0: Ekstremt uformell eller upassende\n"
"1: Uformell, men respektfull\n"
"2: Moderat formell\n"
"3: Profesjonell og passende\n"
"4: Høy formell og ekspertutformet"
),
eksempler=[
EvaluationExample(
input="Hva er MLflow?",
output="MLflow er en åpen kilde-plattform for maskinlærings-livssyklusen, inkludert eksperimentering, reproduksjon og distribusjon.",
poeng=4,
begrunnelse="Svaret er formelt, konsist og profesjonelt utformet.",
)
],
modell="openai:/gpt-3.5-turbo-16k",
parametere={"temperatur": 0.0},
aggregasjoner=["gjennomsnitt", "varians"],
større_er_bedre=True,
)</p>

<p># Bruk av tilpasset måling i evaluering
resultater = mlflow.evaluate(
logget_modell_info.model_uri,
eval_data,
mål="grunn_sannhet",
modell_type="spørring-svar",
ekstra_målinger=[profesjonalitet]
)</p>

<p>print(f"Profesjonalitetspoeng: {resultater.målinger['profesjonalitet_gjennomsnitt']}")

Denne tilpassede målingen bruker GPT-3.5-turbo til å score profesjonaliteten til svarene, og demonstrerer hvordan du kan utnytte LLM selv for evaluering.

Avanserte LLM-evalueringsteknikker

Ettersom LLM blir mer sofistikerte, blir også teknikkene for å evaluere dem. La oss utforske noen avanserte evalueringsteknikker med MLflow.

Henting-utvidet generering (RAG) evaluering

RAG-systemer kombinerer kraften til henting-baserte og generative modeller. Evaluering av RAG-systemer krever vurdering av både henting- og genereringskomponentene. Her er hvordan du kan opprette et RAG-system og evaluere det ved hjelp av 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># Last og forbered dokumenter
loader = WebBaseLoader(["https://mlflow.org/docs/latest/index.html"])
dokumenter = loader.last()
tekst_splitter = CharacterTextSplitter(chunk_størrelse=1000, chunk_overlap=0)
tekster = tekst_splitter.split_dokumenter(dokumenter)</p>

<p># Opprett vektorlagring
embeddings = OpenAIEmbeddings()
vektorlagring = Chroma.from_dokumenter(tekster, embeddings)</p>

<p># Opprett RAG-kjede
llm = OpenAI(temperatur=0)
qa_kjede = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vektorlagring.as_retriever(),
return_source_dokumenter=True
)</p>

<p># Evalueringfunksjon
def evaluering_rag(spørring):
result = qa_kjede({"spørring": spørring})
return result["result"], [dok.page_content for dok in result["source_dokumenter"]]</p>

<p># Forbered evalueringdata
eval_spøringer = [
"Hva er MLflow?",
"Hvordan håndterer MLflow eksperiment-sporing?",
"Hva er de viktigste komponentene av MLflow?",
]</p>

<p># Evaluering ved hjelp av MLflow
with mlflow.start_run():
for spørring in eval_spøringer:
svar, kilder = evaluering_rag(spørring)</p>

<p>mlflow.log_param(f"spørring", spørring)
mlflow.log_metric("antall_kilder", len(kilder))
mlflow.log_text(svar, f"svar_{spørring}.txt")</p>

<p>for i, kilde in enumerate(kilder):
mlflow.log_text(kilde, f"kilde_{spørring}_{i}.txt")</p>

<p># Logg tilpassede målinger
mlflow.log_metric("gjennomsnitt_kilder_per_spørring", sum(len(evaluering_rag(s)) for s in eval_spøringer) / len(eval_spøringer))