AI-modellen en platforms
Het volgen van Large Language Models (LLM) met MLflow: Een complete gids
Voeg Unite.AI toe aan je voorkeursbronnen op Google
Naarmate Large Language Models (LLM’s) in complexiteit en omvang toenemen, wordt het volgen van hun prestaties, experimenten en implementaties steeds uitdagender. Hier komt MLflow om de hoek kijken – een uitgebreid platform voor het beheren van de hele levenscyclus van machine learning-modellen, inclusief LLM’s.
In deze diepgaande gids zullen we onderzoeken hoe we MLflow kunnen gebruiken voor het volgen, evalueren en implementeren van LLM’s. We zullen alles behandelen, van het instellen van uw omgeving tot geavanceerde evaluatietechnieken, met veel codevoorbeelden en best practices onderweg.
Functionaliteit van MLflow in Large Language Models (LLM’s)
MLflow is een cruciaal hulpmiddel geworden in de machine learning- en data science-gemeenschap, vooral voor het beheren van de levenscyclus van machine learning-modellen. Wanneer het gaat om Large Language Models (LLM’s), biedt MLflow een robuuste set tools die het proces van ontwikkelen, volgen, evalueren en implementeren van deze modellen aanzienlijk vereenvoudigen. Hieronder volgt een overzicht van hoe MLflow functioneert binnen de LLM-ruimte en de voordelen die het biedt aan engineers en data scientists.
Volgen en beheren van LLM-interacties
MLflow’s LLM-volgsysteem is een verbetering van zijn bestaande volgcapaciteiten, aangepast aan de unieke behoeften van LLM’s. Het biedt een uitgebreide volging van modelinteracties, inclusief de volgende belangrijke aspecten:
- Parameters: Logging van key-value-paren die de invoerparameters voor de LLM specificeren, zoals model-specifieke parameters zoals
top_kentemperature. Dit biedt context en configuratie voor elke run, waardoor alle aspecten van de modelconfiguratie worden vastgelegd. - Metrieken: Kwantitatieve maatstaven die inzicht bieden in de prestaties en nauwkeurigheid van de LLM. Deze kunnen dynamisch worden bijgewerkt terwijl de run vordert, waardoor real-time of post-proces inzichten worden geboden.
- Voorspellingen: Vastleggen van de invoer die naar de LLM wordt gestuurd en de corresponderende uitvoer, die als artefacten in een gestructureerd formaat worden opgeslagen voor eenvoudige ophaling en analyse.
- Artefacten: Bovenop voorspellingen kan MLflow verschillende uitvoerbestanden opslaan, zoals visualisaties, geserialiseerde modellen en gestructureerde gegevensbestanden, waardoor een gedetailleerde documentatie en analyse van de modelprestaties mogelijk wordt.
Deze gestructureerde aanpak zorgt ervoor dat alle interacties met de LLM zorgvuldig worden geregistreerd, waardoor een uitgebreide afstamming en kwaliteitsvolging voor tekstgenererende modellen wordt geboden.
Evaluatie van LLM’s
Het evalueren van LLM’s stelt unieke uitdagingen door hun generatieve aard en het ontbreken van een enkele grondwaarheid. MLflow vereenvoudigt dit met gespecialiseerde evaluatietools die speciaal voor LLM’s zijn ontworpen. Belangrijke functies zijn:
- Veelzijdige model-evaluatie: Ondersteunt het evalueren van verschillende soorten LLM’s, of het nu een MLflow pyfunc-model, een URI die naar een geregistreerd MLflow-model wijst, of een Python-functie die uw model vertegenwoordigt.
- Uitgebreide metrieken: Biedt een reeks metrieken die speciaal voor LLM-evaluatie zijn ontworpen, inclusief zowel SaaS-model-afhankelijke metrieken (bijv. antwoordrelevantie) als functie-gebaseerde metrieken (bijv. ROUGE, Flesch Kincaid).
- Voorgeprogrammeerde metriekcollecties: Afhankelijk van het gebruik, zoals vraagbeantwoording of tekstsamenvatting, biedt MLflow voorgeprogrammeerde metrieken om het evaluatieproces te vereenvoudigen.
- Aangepaste metriekcreatie: Staat gebruikers toe om aangepaste metrieken te definiëren en te implementeren om specifieke evaluatiebehoeften te vervullen, waardoor de flexibiliteit en diepgang van model-evaluatie worden verbeterd.
- Evaluatie met statische datasets: Maakt het mogelijk om statische datasets te evalueren zonder een model te specificeren, wat nuttig is voor snelle beoordelingen zonder modelinferentie opnieuw uit te voeren.
Implementatie en integratie
MLflow ondersteunt ook naadloze implementatie en integratie van LLM’s:
- MLflow-implementatieserver: Fungeert als een uniforme interface voor interactie met meerdere LLM-aanbieders. Het vereenvoudigt integraties, beheert referenties op een veilige manier en biedt een consistente API-ervaring. Deze server ondersteunt een reeks basismodellen van populaire SaaS-leveranciers, evenals zelfgehoste modellen.
- Uniforme endpoint: Maakt het gemakkelijk om tussen aanbieders te schakelen zonder codeaanpassingen, waardoor downtime wordt geminimaliseerd en flexibiliteit wordt verbeterd.
- Geïntegreerde resultatenweergave: Biedt uitgebreide evaluatieresultaten, die rechtstreeks in de code of via de MLflow-UI kunnen worden benaderd voor gedetailleerde analyse.
MLflow is een uitgebreide set tools en integraties, waardoor het een onmisbaar actief wordt voor engineers en data scientists die werken met geavanceerde NLP-modellen.
Uw omgeving instellen
Voordat we ons in het volgen van LLM’s met MLflow verdiepen, laten we onze ontwikkelomgeving instellen. We moeten MLflow en enkele andere belangrijke bibliotheken installeren:
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
Na de installatie is het een goed idee om uw Python-omgeving opnieuw te starten om ervoor te zorgen dat alle bibliotheken correct zijn geladen. In een Jupyter-notebook kunt u:
import mlflow
import chromadb
<p>print(f"MLflow-versie: {mlflow.__version__}")
print(f"ChromaDB-versie: {chromadb.__version__}")
Dit bevestigt de versies van de belangrijkste bibliotheken die we zullen gebruiken.
MLflow’s LLM-volgcapaciteiten begrijpen
MLflow’s LLM-volgsysteem bouwt voort op zijn bestaande volgcapaciteiten, met functies die speciaal voor de unieke aspecten van LLM’s zijn ontworpen. Laten we de belangrijkste componenten onderzoeken:
Runs en experimenten
In MLflow vertegenwoordigt een “run” een enkele uitvoering van uw modelcode, terwijl een “experiment” een verzameling van gerelateerde runs is. Voor LLM’s kan een run een enkele query of een batch prompts vertegenwoordigen die door het model worden verwerkt.
Belangrijke volgcomponenten
- Parameters: Deze zijn invoerconfiguraties voor uw LLM, zoals temperatuur, top_k of max_tokens. U kunt deze loggen met
mlflow.log_param()ofmlflow.log_params(). - Metrieken: Kwantitatieve maatstaven van uw LLM’s prestaties, zoals nauwkeurigheid, latentie of aangepaste scores. Gebruik
mlflow.log_metric()ofmlflow.log_metrics()om deze te volgen. - Voorspellingen: Voor LLM’s is het cruciaal om zowel de invoerprompts als de modeluitvoer te loggen. MLflow slaat deze op als artefacten in CSV-formaat met
mlflow.log_table(). - Artefacten: Alle aanvullende bestanden of gegevens die verband houden met uw LLM-run, zoals modelcontrolepunten, visualisaties of datasetsamples. Gebruik
mlflow.log_artifact()om deze op te slaan.
Laten we een basisvoorbeeld bekijken van het loggen van een LLM-run:
Dit voorbeeld demonstreert het loggen van parameters, metrieken en de invoer/uitvoer als een tabelartefact.
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 = "Leg het concept van machine learning eenvoudig uit."</p>
<p># Log parameters
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>
<p># Query de LLM en log het resultaat
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))</p>
<p># Log de prompt en respons
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>
<p>print(f"Respons: {result}")
LLM’s implementeren met MLflow
MLflow biedt krachtige mogelijkheden voor het implementeren van LLM’s, waardoor het gemakkelijker wordt om uw modellen in productieomgevingen te gebruiken. Laten we onderzoeken hoe u een LLM kunt implementeren met MLflow’s implementatiefuncties.
Een endpoint maken
Eerst zullen we een endpoint voor onze LLM maken met MLflow’s implementatieclient:
import mlflow
from mlflow.deployments import get_deploy_client
<p># Initialiseer de implementatieclient
client = get_deploy_client("databricks")</p>
<p># Definieer de endpointconfiguratie
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># Maak het endpoint
client.create_endpoint(name=endpoint_name, config=endpoint_config)
Deze code stelt een endpoint in voor een GPT-3.5-turbo-model met Azure OpenAI. Let op het gebruik van Databricks-geheimen voor veilig API-sleutelbeheer.
Het endpoint testen
Zodra het endpoint is gemaakt, kunnen we het testen:
<div class="relative flex flex-col rounded-lg">
<p>response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Leg het concept van neurale netwerken kort uit.", "max_tokens": 100,},)</p>
print(response)
Dit zal een prompt naar ons geïmplementeerde model sturen en de gegenereerde respons teruggeven.
LLM’s evalueren met MLflow
Evaluatie is cruciaal voor het begrijpen van de prestaties en het gedrag van uw LLM’s. MLflow biedt uitgebreide tools voor het evalueren van LLM’s, inclusief zowel ingebouwde als aangepaste metrieken.
Uw LLM voorbereiden voor evaluatie
Om uw LLM te evalueren met mlflow.evaluate(), moet uw model in een van de volgende vormen zijn:
- Een
mlflow.pyfunc.PyFuncModel-instantie of een URI die naar een geregistreerd MLflow-model wijst. - Een Python-functie die stringinvoer accepteert en een enkele stringuitvoer produceert.
- Een MLflow-implementatieendpoint-URI.
- Stel
model=Nonein en neem modeluitvoer op in de evaluatiegegevens.
Laten we een voorbeeld bekijken met een geregistreerd MLflow-model:
import mlflow
import openai
<p>with mlflow.start_run():
system_prompt = "Beantwoord de volgende vraag bondig."
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># Bereid evaluatiegegevens voor
eval_data = pd.DataFrame({
"question": ["Wat is machine learning?", "Leg neurale netwerken uit."],
"ground_truth": [
"Machine learning is een subset van AI die systemen in staat stelt om te leren en te verbeteren van ervaring zonder expliciete programmering.",
"Neurale netwerken zijn computingsystemen geïnspireerd door biologische neurale netwerken, bestaande uit verbonden knooppunten die informatie verwerken en doorgeven."
]
})</p>
<p># Evalueer het model
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>
<p>print(f"Evaluatiemetrieken: {results.metrics}")
Dit voorbeeld logt een OpenAI-model, bereidt evaluatiegegevens voor en evalueert vervolgens het model met MLflow’s ingebouwde metrieken voor vraagbeantwoordingstaken.
Aangepaste evaluatiemetrieken
MLflow staat u toe om aangepaste metrieken te definiëren voor LLM-evaluatie. Hieronder volgt een voorbeeld van het maken van een aangepaste metriek voor het evalueren van de professionaliteit van antwoorden:
from mlflow.metrics.genai import EvaluationExample, make_genai_metric
<p>professionaliteit = make_genai_metric(
name="professionaliteit",
definition="Maat van formeel en passend communicatiegedrag.",
grading_prompt=(
"Score de professionaliteit van het antwoord op een schaal van 0-4:\n"
"0: Extreem informeel of ongepast\n"
"1: Informeel maar respectvol\n"
"2: Matig formeel\n"
"3: Professioneel en passend\n"
"4: Hoog formeel en deskundig geformuleerd"
),
examples=[
EvaluationExample(
input="Wat is MLflow?",
output="MLflow is een open-sourceplatform voor de machine learning-levenscyclus, inclusief experimenten, reproduceerbaarheid en implementatie.",
score=4,
justification="Het antwoord is formeel, bondig en professioneel geformuleerd."
),
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>
<p># Gebruik de aangepaste metriek in evaluatie
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionaliteit]
)</p>
<p>print(f"Professionaliteitsscore: {results.metrics['professionaliteit_mean']}")
Deze aangepaste metriek gebruikt GPT-3.5-turbo om de professionaliteit van antwoorden te scoren, waarmee wordt gedemonstreerd hoe u LLM’s zelf kunt gebruiken voor evaluatie.
Geavanceerde LLM-evaluatietechnieken
Naarmate LLM’s geavanceerder worden, worden de technieken voor hun evaluatie ook geavanceerder. Laten we enkele geavanceerde evaluatiemethoden met MLflow onderzoeken.
Retrieval-Augmented Generation (RAG)-evaluatie
RAG-systemen combineren de kracht van retrieval-gebaseerde en generatieve modellen. Het evalueren van RAG-systemen vereist het evalueren van zowel de retrieval- als de generatiecomponent. Hieronder volgt een voorbeeld van het instellen van een RAG-systeem en het evalueren ervan met 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># Laad en verwerk documenten
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># Maak een vectorstore
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>
<p># Maak een RAG-keten
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># Evaluatiefunctie
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>
<p># Bereid evaluatiegegevens voor
eval_questions = [
"Wat is MLflow?",
"Hoe behandelt MLflow experimentvolging?",
"Wat zijn de belangrijkste componenten van MLflow?",
]</p>
<p># Evalueer met 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 aangepaste metrieken
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))
Dit voorbeeld stelt een RAG-systeem in met LangChain en Chroma, en evalueert het vervolgens door prompts, antwoorden, opgehaalde bronnen en aangepaste metrieken naar MLflow te loggen.
Chunking-strategie-evaluatie
De manier waarop u uw documenten chunkt, kan de prestaties van RAG aanzienlijk beïnvloeden. MLflow kan helpen bij het evalueren van verschillende chunking-strategieën:
import mlflow
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter
<p>def evaluate_chunking_strategy(documents, chunk_size, chunk_overlap, splitter_class):
splitter = splitter_class(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
chunks = splitter.split_documents(documents)</p>
<p>with mlflow.start_run():
mlflow.log_param("chunk_size", chunk_size)
mlflow.log_param("chunk_overlap", chunk_overlap)
mlflow.log_param("splitter_class", splitter_class.__name__)</p>
<p>mlflow.log_metric("num_chunks", len(chunks))
mlflow.log_metric("avg_chunk_length", sum(len(chunk.page_content) for chunk in chunks) / len(chunks))</p>
<p># Evalueer opnameprestaties (vereenvoudigd)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)</p>
<p># Evalueer verschillende strategieën
for chunk_size in [500, 1000, 1500]:
for chunk_overlap in [0, 50, 100]:
for splitter_class in [CharacterTextSplitter, TokenTextSplitter]:
evaluate_chunking_strategy(documents, chunk_size, chunk_overlap, splitter_class)</p>
<p># Vergelijk resultaten
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"Beste chunking-strategie: {best_run['params.splitter_class']} met grootte {best_run['params.chunk_size']} en overlap {best_run['params.chunk_overlap']}")
Dit script evalueert verschillende combinaties van chunkgroottes, overlaps en splitsingsmethoden, en logt de resultaten naar MLflow voor eenvoudige vergelijking.
LLM-evaluatieresultaten visualiseren
MLflow biedt verschillende manieren om uw LLM-evaluatieresultaten te visualiseren. Hieronder volgen enkele technieken:
Gebruik van de MLflow-UI
Nadat u uw evaluaties heeft uitgevoerd, kunt u de MLflow-UI gebruiken om resultaten te visualiseren:
- Start de MLflow-UI:
mlflow ui - Open een webbrowser en navigeer naar
http://localhost:5000 - Selecteer uw experiment en runs om metrieken, parameters en artefacten te bekijken
Aangepaste visualisaties
U kunt aangepaste visualisaties van uw evaluatieresultaten maken met bibliotheken zoals Matplotlib of Plotly, en deze vervolgens als artefacten loggen:
import matplotlib.pyplot as plt
import mlflow
<p>def plot_metric_comparison(metric_name, run_ids):
plt.figure(figsize=(10, 6))
for run_id in run_ids:
run = mlflow.get_run(run_id)
metric_values = mlflow.get_metric_history(run_id, metric_name)
plt.plot([m.step for m in metric_values], [m.value for m in metric_values], label=run.data.tags.get("mlflow.runName", run_id))</p>
<p>plt.title(f"Vergelijking van {metric_name}")
plt.xlabel("Stap")
plt.ylabel(metric_name)
plt.legend()</p>
<p># Sla de plot op en log deze
plt.savefig(f"{metric_name}_comparison.png")
mlflow.log_artifact(f"{metric_name}_comparison.png")</p>
<p># Gebruik
with mlflow.start_run():
plot_metric_comparison("answer_relevance", ["run_id_1", "run_id_2", "run_id_3"])
Deze functie maakt een lijnplot die een specifieke metriek over meerdere runs vergelijkt en logt deze als een artefact.
Alternatieven voor Open Source MLflow
Er zijn verschillende alternatieven voor open source MLflow voor het beheren van machine learning-workflows, elk met unieke functies en integraties.
Beheerd MLflow door Databricks
Beheerd MLflow, gehost door Databricks, biedt de core-functionaliteiten van open source MLflow, maar met extra voordelen zoals naadloze integratie met Databricks’ ecosysteem, geavanceerde beveiligingsfuncties en beheerde infrastructuur. Dit maakt het een uitstekende keuze voor organisaties die robuuste beveiliging en schaalbaarheid nodig hebben.
Azure Machine Learning
Azure Machine Learning biedt een end-to-end machine learning-oplossing op Microsoft’s Azure-cloudplatform. Het biedt compatibiliteit met MLflow-componenten zoals de modelregistry en experimentvolger, hoewel het niet op MLflow is gebaseerd.
Gedicateerde ML-platforms
Verschillende bedrijven bieden beheerde ML-producten met diverse functies:
- neptune.ai: Richt zich op experimentvolging en modelbeheer.
- Weights & Biases: Biedt uitgebreide experimentvolging, datasetversiebeheer en collaboratietools.
- Comet ML: Biedt experimentvolging, modelproductiebewaking en datalogging.
- Valohai: Specialiseert zich in machine learning-pijplijnen en -orchestratie.
Metaflow
Metaflow, ontwikkeld door Netflix (NFLX ), is een open source-framework ontworpen om data-workflows en ML-pijplijnen te orkestreren. Hoewel het uitblinkt in het beheren van grote implementaties, ontbreekt het aan uitgebreide experimentvolgings- en modelbeheerfuncties in vergelijking met MLflow.
Amazon SageMaker en Google’s Vertex AI
Zowel Amazon SageMaker (AMZN ) als Google’s Vertex AI bieden end-to-end MLOps-oplossingen geïntegreerd in hun respectievelijke cloudplatforms. Deze diensten bieden robuuste tools voor het bouwen, trainen en implementeren van machine learning-modellen op grote schaal.
Gedetailleerde vergelijking
Beheerd MLflow vs. Open Source MLflow
Beheerd MLflow door Databricks biedt verschillende voordelen ten opzichte van de open source-versie, waaronder:
- Instellen en implementeren: Naadloze integratie met Databricks vermindert de insteltijd en -inspanning.
- Schaalbaarheid: In staat om grote machine learning-werklasten gemakkelijk te verwerken.
- Beveiliging en beheer: Out-of-the-box beveiligingsfuncties zoals rolgebaseerd toegangsbeheer (RBAC) en gegevensversleuteling.
- Integratie: Diepe integratie met Databricks’ diensten, waardoor interoperabiliteit en functionaliteit worden verbeterd.
- Gegevensopslag en back-up: Geautomatiseerde back-upstrategieën waarborgen gegevensveiligheid en -betrouwbaarheid.
- Kosten: Gebruikers betalen voor het platform, opslag en rekenbronnen.
- Ondersteuning en onderhoud: Toegewijd ondersteuning en onderhoud door Databricks.
Conclusie
Het volgen van Large Language Models met MLflow biedt een robuust kader voor het beheren van de complexiteit van LLM-ontwikkeling, -evaluatie en -implementatie. Door de beste praktijken en geavanceerde functies te volgen die in deze gids worden beschreven, kunt u meer georganiseerde, reproduceerbare en inzichtelijke LLM-experimenten creëren.
Onthoud dat het veld van LLM’s snel evolueert en dat nieuwe technieken voor evaluatie en volging constant worden ontwikkeld. Blijf op de hoogte van de laatste MLflow-releases en LLM-onderzoek om uw volg- en evaluatieprocessen voortdurend te verfijnen.
Naarmate u deze technieken in uw projecten toepast, zult u een dieper inzicht krijgen in het gedrag en de prestaties van uw LLM’s, waardoor u effectievere en betrouwbaardere taalmodellen kunt ontwikkelen.
