Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen
Cursisten instrumenteren een trainingsscript met mlflow.log_param en mlflow.log_metric, starten de MLflow-gebruikersinterface en vergelijken runs met verschillende hyperparameterinstellingen.
Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Waarom het bijhouden van experimenten belangrijk is
Wanneer je meerdere modellen met verschillende hyperparameters traint, raak je gemakkelijk kwijt welke run het beste resultaat opleverde. Het bijhouden van experimenten registreert automatisch de parameters, metrieken en codeversie van elke trainingsrun in een doorzoekbare database. Zonder deze registratie zijn teams aangewezen op rommelige spreadsheets of vergeten ze simpelweg wat werkte. MLflow is de industriestandaard open-sourcetool voor het bijhouden van ML-experimenten en het beheren van de levenscyclus van modellen.
MLflow installeren en starten
MLflow is een puur Python-pakket waarvoor je om te beginnen geen externe database nodig hebt — runs worden lokaal opgeslagen in een map mlruns/. Installeer het met pip en start vervolgens de trackinginterface om runs in een browser te visualiseren. De interface toont alle experimenten, de parameters en metrieken van elke run en laat je runs naast elkaar vergelijken met interactieve grafieken.
# Install MLflow
# pip install mlflow scikit-learn
import mlflow
import mlflow.sklearn
# Start the tracking UI (run this in a terminal):
# mlflow ui --host 0.0.0.0 --port 5000
# Then open http://localhost:5000
# Check MLflow version
print('MLflow version:', mlflow.__version__)
# Default tracking URI stores to ./mlruns
print('Tracking URI:', mlflow.get_tracking_uri())Experimenten maken
MLflow ordent runs in experimenten — logische groepen van gerelateerde runs. Maak een experiment met een naam aan met mlflow.set_experiment. Alle volgende runs horen bij dit experiment. Gebruik beschrijvende namen die het project en de datum aangeven, bijvoorbeeld 'random_forest_imdb_2024'. Elke run binnen een experiment krijgt een unieke ID, een voor mensen leesbare naam en een eigen opslag voor parameters, metrieken en artefacten.
import mlflow
# Create or switch to an experiment
experiment_name = 'sentiment_classification'
mlflow.set_experiment(experiment_name)
# List all experiments
for exp in mlflow.search_experiments():
print(f'ID: {exp.experiment_id} Name: {exp.name}')
# Get current experiment info
experiment = mlflow.get_experiment_by_name(experiment_name)
print('Artifact location:', experiment.artifact_location)Parameters loggen met mlflow.log_param
Parameters zijn de configuratiekeuzes die je maakt voordat de training begint: hyperparameters zoals learning rate, het aantal estimators en de sterkte van de regularisatie. Log ze met mlflow.log_param(key, value) binnen de context van een actieve run. Parameters kunnen na het loggen niet meer worden gewijzigd — ze definiëren de experimentele opzet en helpen je runs te filteren om de configuratie te vinden die het beste werkte.
import mlflow
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
with mlflow.start_run(run_name='rf_baseline'):
n_estimators = 100
max_depth = 5
mlflow.log_param('n_estimators', n_estimators)
mlflow.log_param('max_depth', max_depth)
mlflow.log_param('random_state', 42)
clf = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=42)
clf.fit(X_train, y_train)
print('Params logged.')Metrieken loggen met mlflow.log_metric
Metrieken zijn de kwantitatieve resultaten die tijdens en na de training worden geproduceerd: nauwkeurigheid, F1 en losswaarden. Log ze met mlflow.log_metric(key, value) of mlflow.log_metric(key, value, step=i) om de voortgang per epoch bij te houden. Door metrieken bij elke epoch te loggen, kan MLflow leercurves in de interface weergeven, waardoor je de convergentiesnelheid van runs eenvoudig kunt vergelijken.
import mlflow
from sklearn.metrics import accuracy_score, f1_score
with mlflow.start_run(run_name='rf_run_1'):
mlflow.log_param('n_estimators', 100)
mlflow.log_param('max_depth', 5)
# Train model (abbreviated)
clf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
clf.fit(X_train, y_train)
preds = clf.predict(X_test)
acc = accuracy_score(y_test, preds)
f1 = f1_score(y_test, preds)
mlflow.log_metric('test_accuracy', acc)
mlflow.log_metric('test_f1', f1)
print(f'Logged accuracy={acc:.4f}, f1={f1:.4f}')Artefacten loggen
Artefacten zijn bestanden die bij een run horen: gewichten van getrainde modellen, grafieken, verwarringsmatrices of grafieken met kenmerkbelang. Registreer ze met mlflow.log_artifact(local_path). MLflow slaat het bestand op in de artefactmap van de run en maakt het vanuit de gebruikersinterface downloadbaar. Door de afbeelding van de verwarringsmatrix samen met de metrieken te registreren, krijgen beoordelaars een volledig beeld zonder in de code te hoeven duiken.
import mlflow
import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay
import numpy as np
with mlflow.start_run():
clf.fit(X_train, y_train)
preds = clf.predict(X_test)
# Save confusion matrix as an artifact
fig, ax = plt.subplots(figsize=(5, 4))
ConfusionMatrixDisplay.from_predictions(y_test, preds, ax=ax)
plt.tight_layout()
plt.savefig('/tmp/confusion_matrix.png')
plt.close()
mlflow.log_artifact('/tmp/confusion_matrix.png')
print('Artifact logged.')Automatisch loggen met mlflow.sklearn.autolog
Voor scikit-learn biedt MLflow automatisch loggen, waarbij alle parameters, metrieken en het getrainde model automatisch worden vastgelegd zonder handmatige aanroepen om gegevens te registreren. Roep eenvoudig mlflow.sklearn.autolog() aan voordat je het model fit. Automatisch loggen ondersteunt ook XGBoost, LightGBM, PyTorch, TensorFlow en meer, met een vergelijkbare activering van één regel. Dit is de snelste manier om te beginnen met bijhouden zonder bestaande trainingscode aan te passen.
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
# Enable auto-logging -- no manual log calls needed
mlflow.sklearn.autolog()
with mlflow.start_run(run_name='gb_autolog'):
clf = GradientBoostingClassifier(n_estimators=200, max_depth=3, learning_rate=0.05)
clf.fit(X_train, y_train)
# MLflow automatically logs:
# - All constructor params
# - Training accuracy
# - Model artifact
print('Auto-logged run complete.')Runs vergelijken in de MLflow-gebruikersinterface
Open na meerdere runs met verschillende hyperparameters de MLflow-gebruikersinterface op http://localhost:5000. Selecteer meerdere runs met selectievakjes en klik op Vergelijken om ze naast elkaar te bekijken. De vergelijkingspagina toont een grafiek met parallelle coördinaten, waarin elke as een parameter of metriek vertegenwoordigt. Zo zie je eenvoudig welke parametercombinatie tot de hoogste nauwkeurigheid leidde. Je kunt de runtabel ook sorteren op elke metriekkolom.
import mlflow
# Search runs programmatically (useful in CI/CD pipelines)
runs = mlflow.search_runs(
experiment_names=['sentiment_classification'],
order_by=['metrics.test_accuracy DESC']
)
if not runs.empty:
best_run = runs.iloc[0]
print('Best run ID:', best_run['run_id'])
print('Best accuracy:', best_run['metrics.test_accuracy'])
print('n_estimators:', best_run['params.n_estimators'])
print('max_depth:', best_run['params.max_depth'])Modellen registreren met mlflow.sklearn.log_model
Gebruik naast het registreren van modelbestanden als algemene artefacten mlflow.sklearn.log_model om het model te registreren in de gestandaardiseerde indeling van MLflow. Deze indeling bevat het modelobject, de metadata van de modelvariant en een automatisch gegenereerd MLmodel-configuratiebestand. Dankzij deze gestandaardiseerde indeling kun je modellen met één klik implementeren op lokale REST-servers (mlflow models serve) en cloudplatforms zoals Azure ML en AWS SageMaker.
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
with mlflow.start_run(run_name='rf_logged_model'):
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
mlflow.log_metric('accuracy', accuracy_score(y_test, clf.predict(X_test)))
# Log in sklearn flavour -- enables mlflow models serve
mlflow.sklearn.log_model(
sk_model=clf,
artifact_path='random_forest',
registered_model_name='SentimentRF'
)
print('Model registered in Model Registry.')Runs labelen voor ordening
MLflow-runs kunnen labels hebben: metadata in de vorm van sleutel-waardeparen die verder gaat dan gestructureerde parameters en metrieken. Gebruik labels om de versie van de gegevensset, de hash van de codecommit, de naam van de onderzoeker of notities over wijzigingen op te slaan. Labels kunnen in de gebruikersinterface worden doorzocht en gefilterd. Een goede labelconventie — bijvoorbeeld altijd dataset_version en git_sha registreren — zorgt ervoor dat elke run maanden later reproduceerbaar en controleerbaar is.
import mlflow
import subprocess
def get_git_sha():
try:
return subprocess.check_output(
['git', 'rev-parse', 'HEAD'], text=True
).strip()
except Exception:
return 'unknown'
with mlflow.start_run():
mlflow.set_tag('dataset_version', 'imdb_v2')
mlflow.set_tag('git_sha', get_git_sha())
mlflow.set_tag('author', 'mehmet.canker')
mlflow.set_tag('notes', 'Testing higher max_depth after previous plateau')
mlflow.log_param('max_depth', 8)
print('Run tagged.')Een externe trackingserver instellen
Richt MLflow voor samenwerking binnen een team op een externe trackingserver in plaats van op de lokale map mlruns/. Stel de tracking-URI in op de URL van je server voordat je MLflow aanroept. Alle teamleden registreren gegevens op dezelfde server, zien elkaars runs en hebben toegang tot gedeelde artefacten. De backend van de server kan een PostgreSQL-database gebruiken voor metadata en S3/GCS voor artefactopslag. Zo krijg je duurzaamheid en toegangsbeheer op ondernemingsniveau.
import mlflow
import os
# Point to a remote MLflow tracking server
os.environ['MLFLOW_TRACKING_URI'] = 'http://mlflow.yourcompany.com:5000'
os.environ['MLFLOW_TRACKING_USERNAME'] = 'data_team'
os.environ['MLFLOW_TRACKING_PASSWORD'] = 'secret'
mlflow.set_tracking_uri(os.environ['MLFLOW_TRACKING_URI'])
# All subsequent mlflow calls go to the remote server
mlflow.set_experiment('shared_team_experiment')
with mlflow.start_run():
mlflow.log_param('model_type', 'xgboost')
mlflow.log_metric('auc', 0.94)
print('Logged to remote server.')Korte controle
Test je begrip van de concepten uit deze les over Machine Learning met Python.
Samenvatting van de les
In deze les heb je geleerd dat MLflow parameters, metrieken en artefacten voor elke trainingsrun bijhoudt in een doorzoekbare database, dat mlflow.sklearn.autolog() alles automatisch vastlegt zonder handmatige aanroepen om gegevens te registreren en dat geregistreerde modellen in de sklearn-modelvariant als REST-API's kunnen worden aangeboden of via het Model Registry kunnen worden gepromoveerd. Hierna bouwen we reproduceerbare Docker-containers voor ML-training om omgevingsverschillen tussen machines te elimineren.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen” gratis?
Ja — de volledige tekst van “Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen”?
Cursisten instrumenteren een trainingsscript met mlflow.log_param en mlflow.log_metric, starten de MLflow-gebruikersinterface en vergelijken runs met verschillende hyperparameterinstellingen. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Experimenten bijhouden met MLflow: parameters, metrieken en artefacts loggen
- Reproduceerbare omgevingen met Docker voor ML
- Modelregister: staging, productie en archivering
- Geautomatiseerde retrainingpipelines met GitHub Actions