LLM’s evalueren met MLflow: een praktische gids voor beginners

MLflow instellen voor LLM-evaluatie

Voordat we LLM’s met MLflow evalueren, moeten we het platform goed instellen. Dit houdt onder meer in: MLflow installeren, optioneel een trackingserver configureren voor remote logging, en zorgen dat onze omgeving klaar is voor het beheren van experimenten en het volgen van resultaten. 

Laten we zien hoe je dat doet.

MLflow installeren

1. Zorg dat Python is geïnstalleerd:

We moeten eerst controleren of Python op onze machine staat. MLflow is compatibel met Python 3.6 en hoger (let op: Python 3.8 is nu verouderd, dus Python >= 3.9 wordt aanbevolen). We kunnen onze Python-versie checken met:

python --version

2. Maak een virtuele omgeving (optioneel maar aanbevolen):

Het is een goede gewoonte om een virtuele omgeving te gebruiken bij het tracken van experimenten met MLflow, zeker op macOS. We kunnen er een maken met venv of virtualenv.  

python -m venv mlflow-env

We activeren de virtuele omgeving:

Op Windows:

mlflow-env\Scripts\activate

Op Mac/Linux:

source mlflow-env/bin/activate

3. Installeer MLflow met pip:

Met de virtuele omgeving geactiveerd (indien gebruikt) kunnen we MLflow installeren via pip:

pip install mlflow

4. Installeer aanvullende dependencies:

MLflow heeft enkele optionele dependencies voor extra functionaliteit. Als we specifieke features nodig hebben, zoals de serveermogelijkheden van MLflow-modellen, moeten we gunicorn installeren. 

pip install gunicorn

Als we bibliotheken zoals TensorFlow of PyTorch gebruiken, moeten we mogelijk hun respectieve MLflow-integraties installeren:

pip install mlflow[extras]

4. Verifieer de installatie:

Controleer vervolgens of MLflow correct is geïnstalleerd door de versie op te vragen:

mlflow --version

Een MLflow-trackingserver opzetten (optioneel)

Als we in een samenwerking werken of remote logging nodig hebben, moeten we een MLflow-trackingserver opzetten. Deze feature stelt ons in staat om het tracken en beheren van experimenten te centraliseren.

1. Start de trackingserver:

We kunnen de MLflow-server starten door de backend store en de artifactlocatie te specificeren. 

mlflow server --backend-store-uri sqlite:///mlruns.db --default-artifact-root ./mlruns

•  --backend-store-uri specificeert waar de experimentdata wordt opgeslagen. We kunnen elk databasesysteem gebruiken (PostgreSQL, MySQL, enz.).
•  --default-artifact-root geeft de map aan waar artifacts, bijv. modelfiles, worden opgeslagen.

2. Configureer de trackingserver:

We moeten zorgen dat onze MLflow-clients zijn geconfigureerd om naar de trackingserver te loggen. We kunnen de omgevingsvariabele MLFLOW_TRACKING_URI instellen om naar onze server te verwijzen.

export MLFLOW_TRACKING_URI=http://localhost:5000

3. Open de tracking-UI:

Nu kunnen we een webbrowser openen en navigeren naar http://localhost:5000 om de MLflow-UI te bereiken. In deze interface kunnen we experimenten bekijken, resultaten vergelijken en je MLflow-projecten beheren, zoals we later zullen zien.

LLM’s laden en evalueren

Met MLflow ingesteld is het tijd voor de kerntaken: LLM’s laden en evalueren. Laten we bekijken hoe we een vooraf getrainde LLM kiezen, laden met verschillende bibliotheken en een evaluatiedataset voorbereiden om de prestaties van het model te meten.

Een vooraf getrainde LLM kiezen

Bij het selecteren van een vooraf getrainde LLM bieden bibliotheken zoals Hugging Face Transformers veel opties. Zo kunnen we een vooraf getraind model laden, zoals GPT (voor tekstgeneratie) of BERT (voor tekstclassificatie en andere taken).

1. Hugging Face Transformers installeren

We zorgen eerst dat de Hugging Face Transformers-bibliotheek is geïnstalleerd. Dat doen we met pip.

pip install transformers

2. Een vooraf getraind model en tokenizer laden

Nu laden we het BERT-model met de transformers-bibliotheek, inclusief zowel het model als de tokenizer, die nodig zijn om tekst te verwerken en voorspellingen te genereren.

from transformers import (
BertForSequenceClassification, 
BertTokenizer
)
# Load pre-trained model and tokenizer
model_name = "textattack/bert-base-uncased-yelp-polarity"
tokenizer = BertTokenizer.from_pretrained(model_name)      
model = BertForSequenceClassification.from_pretrained(model_name)

Het model bert-base-uncased gebruik je wanneer de tekstdata hoofdzakelijk uit kleine en hoofdletters bestaat, maar je niet wilt dat het model onderscheid maakt tussen hoofd- en kleine letters.

De evaluatiedataset voorbereiden

Om een LLM te evalueren, hebben we een geschikte dataset nodig die past bij de taak die we beoordelen. Laten we zien hoe we een tekstreeks evaluatiedataset voor sentimentanalyse voorbereiden:

1. De dataset laden of maken en preprocessen

Onze data kan op meerdere plekken staan: op de lokale schijf, in een GitHub-repository of op de Hugging Face Hub, een uitgebreide verzameling community-gecurateerde en populaire onderzoeksdatasets.

Voor deze tutorial gebruiken we een grote dataset met filmrecensies voor sentimentanalyse: IMDB. We gebruiken de datasets-bibliotheek om de kant-en-klare dataset te laden:

De datasetsbibliotheek installeren:

pip install datasets

Een dataset laden:

from datasets import load_dataset
# Load the dataset IMDb for sentiment analysis
dataset = load_dataset("imdb")

2. Preprocessing voor sentimentanalyse

We gebruiken de eerder geladen BERT-tokenizer om de dataset voor sentimentanalyse te preprocessen.

def preprocess_function(examples):
    return tokenizer(examples['text'], padding="max_length", truncation=True)
tokenized_datasets = dataset.map(preprocess_function, batched=True)

LLM-evaluaties uitvoeren en metrics loggen met MLflow

Nu onze LLM’s zijn geladen en de evaluatiedataset is voorbereid, is het tijd om evaluaties uit te voeren en metrics te loggen. 

Experimentmetadata bijhouden

1. MLflow importeren en een nieuw experiment starten

Om experimenten met MLflow te tracken, moeten we eerst een nieuw experiment starten en relevante metadata loggen, zoals modelnaam, versie en evaluatieparameters.

import mlflow
import mlflow.pytorch
# Start a new experiment
mlflow.set_experiment("LLM_Evaluation")
with mlflow.start_run() as run:
    # Log experiment metadata
    mlflow.log_param("model_name", "bert")
    mlflow.log_param("model_version", "v1.0")
    mlflow.log_param("evaluation_task", "sentiment_analysis")

2. Evaluatieparameters loggen

We kunnen nu parameters loggen die betrekking hebben op het evaluatieproces, zoals de grootte van de evaluatiedataset of specifieke configuraties die tijdens de evaluatie zijn gebruikt.

with mlflow.start_run() as run:
	  mlflow.log_param("dataset_size",  len(dataset['test']))

Evaluatiemetrics loggen

Zodra we het model hebben getraind en de bijbehorende voorspellingen hebben gemaakt, kunnen we de LLM evalueren en diverse metrics loggen die de prestaties weerspiegelen. 

Sentimentanalyse is een classificatieprobleem, dus we kunnen ons model evalueren met metrics zoals accuracy en F1-score. Voor tekstgeneratie worden vaak metrics zoals BLEU-score of perplexity gebruikt. 

from sklearn.metrics import accuracy_score, f1_score
# Assuming y_true and y_pred are true labels and model predictions
accuracy = accuracy_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred, average='weighted')
with mlflow.start_run() as run:
    mlflow.log_metric("accuracy", accuracy)
    mlflow.log_metric("f1_score", f1)

LLM-prestaties vergelijken met MLflow

Als meerdere evaluatieruns met MLflow zijn getrackt, is het vergelijken van hun prestaties essentieel om de best presterende modellen en configuraties te bepalen. 

Laten we bekijken hoe we meerdere runs tracken en de MLflow-UI gebruiken om resultaten effectief te visualiseren en te vergelijken.

Meerdere runs tracken

We moeten eerst meerdere runs binnen hetzelfde experiment of over verschillende experimenten tracken om de prestaties van verschillende LLM-versies te vergelijken. 

1. Meerdere runs loggen

We kunnen meerdere runs onder één experiment loggen door voor elk model of elke configuratie die we willen evalueren een nieuwe run te starten. 

models = [("bert-base-cased", "v1.0"), ("bert-base-uncased", "v1.0")]
y_pred_dict = {
       "bert-base-cased": y_pred_case,
       "bert-base-uncased": y_pred_uncase
}
for model_name, model_version in models:
    with mlflow.start_run() as run:
        # Log model and version
        mlflow.log_param("model_name", model_name)
        mlflow.log_param("model_version", model_version)
           
        # Perform evaluation and log metrics
	   y_pred = y_pred_dict[model_name]
        accuracy = accuracy_score(y_true, y_pred)
        f1 = f1_score(y_true, y_pred, average='weighted')
           
        mlflow.log_metric("accuracy", accuracy)
        mlflow.log_metric("f1_score", f1)

2. Experimenten met verschillende modellen tracken

Stel dat we verschillende typen modellen willen evalueren. Dan kunnen we MLflow gebruiken om een experiment te maken en de modellen samen te loggen. 

Modellogging in MLflow uitvoeren is vergelijkbaar met versiebeheer voor machinelearningmodellen. Het vastleggen van model- en omgevingsdetails garandeert reproduceerbaarheid.

Eerst zetten we een experiment op. Vervolgens loggen we elk model in een aparte MLflow-run, inclusief de run-ID’s en artifactpaden.

 # Create an experiments for the different models
mlflow.set_experiment("sentiment_analysis_comparison")
model_names = ["bert-base-cased", "bert-base-uncased"]
run_ids = []
artifact_paths = []
for model, name in zip([betcased, bertuncased], model_names):
    with mlflow.start_run(run_name=f"log_model_{name}"):
        artifact_path = f"models/{name}"
        mlflow.pyfunc.log_model(
            artifact_path=artifact_path,
            python_model=model,
        )
        run_ids.append(mlflow.active_run().info.run_id)
        artifact_paths.append(artifact_path)

Nu kunnen we de modellen evalueren en de resultaten loggen. MLflow biedt een API, mlflow.evaluate(), om onze LLM’s te helpen evalueren. 

for i in len(model_names):
    with mlflow.start_run(run_id=run_ids[i]):  
        # reopen the run with the stored run ID
        evaluation_results = mlflow.evaluate(
            model=f"runs:/{run_ids[i]}/{artifact_paths[i]}",
            model_type="text",
            data=dataset['test'],
        )

Resultaten visualiseren en vergelijken

Nadat we de verschillende metrics en modellen in MLflow hebben gelogd, kunnen we een vergelijking maken.  We kunnen de gebruiksvriendelijke interface van MLflow gebruiken om evaluatiemetrics van verschillende runs te visualiseren en te vergelijken.  Om dat te doen, moeten we de MLflow-server starten als die nog niet draait

mlflow server --backend-store-uri sqlite:///mlruns.db --default-artifact-root ./mlruns

We openen vervolgens een webbrowser en navigeren naar http://localhost:5000 om de MLflow-UI te bereiken. In de MLflow-UI gaan we naar de pagina "Experiments" om al onze experimenten te bekijken. Klik op de naam van het experiment om de lijst met bijbehorende runs te zien.

De MLflow-interface toont het tabblad Experiments, waar de verschillende runs en logevents te zien zijn—afbeelding door de auteur.

Binnen een experiment kunnen we verschillende runs vergelijken door meerdere runs te selecteren en hun metrics naast elkaar te bekijken. 

De UI biedt een visuele weergave van metrics zoals accuracy, F1-score en andere evaluatiemetrics. We kunnen ook de ingebouwde visualisaties van MLflow gebruiken om grafieken te genereren voor meer gedetailleerde vergelijkingen.

MLflow-visualisaties kunnen laten zien wanneer verschillende runs zijn gelogd, zodat we metrics kunnen vergelijken—afbeelding door de auteur.

De MLflow-UI biedt gedetailleerde grafieken en logs voor elke run. We kunnen deze logs en visualisaties raadplegen om te begrijpen welk model of welke configuratie het beste presteert op basis van de gelogde metrics.

Geavanceerde technieken voor LLM-evaluatie met MLflow

Voor een diepere en meer uitgebreide evaluatie van LLM’s biedt MLflow geavanceerde technieken die tracking en analyse verbeteren. We bekijken hoe je modelartefacten logt voor grondige tracking en MLflow inzet voor hyperparameter-tuning om de LLM-prestaties te optimaliseren. 

Modelartefacten loggen

Modelartefacten loggen is erg belangrijk om de details van onze experimenten te bewaren en te analyseren. Artefacten geven een compleet beeld van de modelprestaties en helpen resultaten te reproduceren.

Onder de artefacten die we kunnen loggen, vallen onder meer:

• Modelgewichten: We kunnen modelgewichten opslaan en loggen in formaten die bij ons framework passen (bijv. joblib voor scikit-learn of TensorFlow’s SavedModel-formaat).
• Evaluatieresultaten: We kunnen metrics loggen, zoals accuracy, precision, recall, F1-score en confusion matrices, en ze opslaan als CSV of JSON voor eenvoudige toegang.
• Gegenereerde outputs: Als ons model outputs produceert (zoals voorspellingen of gegenereerde afbeeldingen), kunnen we deze ook als artefacten loggen. Denk aan bestanden, plots of visualisaties die helpen de prestaties te begrijpen.

Hier is een voorbeeld:

import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay
with mlflow.start_run() as run:
    # Log the model
    mlflow.pytorch.save_model(model, "model")
    
    # Log the model weights
    joblib.dump(model, "model_weights.pkl") 
    mlflow.log_artifact("model", artifact_path="model")
    
    # Log the confusion matrix as image
    confusion_matrix = pd.DataFrame(confusion_matrix(y_test,    predictions))
    cm = ConfusionMatrixDisplay(confusion_matrix=cm)
    plt.savefig("confusion_matrix.png") 
    mlflow.log_artifact("confusion_matrix.png")
  
    # Generate predictions
    outputs = dataset['test']
    outputs['prediction'] = model.predict(dataset['test'])
    with open("generated_outputs.txt", "w") as f:
           for output in outputs:
               f.write(output + "\n")
       # Log the file
       mlflow.log_artifact("generated_outputs.txt")

Hyperparameter-tuning met MLflow

Hyperparameter-tuning is cruciaal om LLM-prestaties te optimaliseren. In onze experimenten kunnen we met MLflow verschillende hyperparameterconfiguraties loggen. Zo kunnen we de effecten van diverse instellingen vergelijken en de optimale configuratie vinden.

from transformers import Trainer, TrainingArguments
def train_and_log_model(model, lr, bs): 
training_args = TrainingArguments(
                     output_dir='./results',   
                     num_train_epochs=3, 
                     per_device_train_batch_size=batch_size, 
                     per_device_eval_batch_size=batch_size,
                     learning_rate=learning_rate, 
                     evaluation_strategy="epoch") 
trainer = Trainer(model=model, 
                  args=training_args,
                  train_dataset=(X_train, y_train)
                  eval_dataset=(X_test, y_test))
with mlflow.start_run() as run:
# Log hyperparameters
           mlflow.log_param("learning_rate", lr)
           mlflow.log_param("batch_size", bs)  
            trainer.train()
            eval_result = trainer.evaluate()      
            mlflow.log_metric("eval_accuracy",
                               eval_result['eval_accuracy'])
hyperparameter_grid = [{"learning_rate": 5e-5, "batch_size": 8}, 
                       {"learning_rate": 3e-5, "batch_size": 16}] 
for params in hyperparameter_grid:
train_and_log_model(params["learning_rate"],
                    params["batch_size"])

Een ander voordeel van MLflow is dat het kan worden gebruikt met hyperparameter-optimalisatiebibliotheken zoals Optuna of Ray Tune om het tuningproces te automatiseren.

Best practices voor LLM-evaluatie met MLflow

Een nauwkeurige evaluatie van LLM’s is meer dan tests draaien en metrics loggen. Het vereist een strategische aanpak om consistentie, nauwkeurigheid en efficiëntie te waarborgen. Door best practices te hanteren, verhoog je de betrouwbaarheid en effectiviteit van het evaluatieproces. 

Stabiele en representatieve datasets gebruiken is een van de eerste dingen die bijdragen aan een effectieve evaluatie. Door te zorgen dat onze evaluatiedatasets stabiel en representatief zijn voor de taken waarvoor onze LLM is ontworpen, krijgen we betekenisvolle vergelijkingen in de tijd en tussen verschillende modellen of versies. Als de dataset verandert, is het lastig om prestatieveranderingen toe te schrijven aan het model in plaats van aan de dataset zelf.

Niet alleen de dataset, maar ook hoe we preprocessen is belangrijk. We moeten dezelfde preprocessingstappen op alle evaluatiedatasets toepassen om vergelijkbare resultaten te garanderen. Dit omvat tokenization, normalization en het afhandelen van speciale gevallen. Consistente preprocessing zorgt ervoor dat variaties in prestaties niet voortkomen uit verschillen in gegevensverwerking.

Zoals hierboven gezien helpt het gebruik van de model registry van MLflow voor versiebeheer ons om verschillende versies van onze LLM’s te tracken. Dit maakt het eenvoudiger om prestaties te vergelijken en zo nodig terug te schakelen naar eerdere versies. We moeten alle details loggen en veranderingen aan de modellen bijhouden, inclusief aanpassingen aan architectuur, hyperparameters of trainingsdata. 

Tot slot helpt het om de evaluatie te automatiseren door deze te integreren in CI/CD-pipelines (continuous integration/continuous deployment), zodat modellen consistent en tijdig worden geëvalueerd wanneer er updates zijn. Stel geplande evaluaties in om periodiek de prestaties te beoordelen. Zo monitoren we modeldrift en zorgen we dat modellen aan de prestatienormen blijven voldoen.

Conclusie

LLM’s effectief evalueren vereist een gestructureerde en systematische aanpak, en MLflow biedt een framework om dit proces te ondersteunen.

In deze tutorial hebben we MLflow geïnstalleerd en een trackingserver ingesteld. Vervolgens hebben we onze LLM geëvalueerd door belangrijke metrics te loggen, meerdere runs getrackt om ze te vergelijken en de UI van MLflow gebruikt om deze vergelijkingen effectief te visualiseren en analyseren.

Wil je je MLflow-kennis naar een hoger niveau tillen? Bekijk dan onze cursus Introduction to MLflow!