Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter
Ni kommer att instrumentera ett träningsskript med mlflow.log_param och mlflow.log_metric, starta MLflow-gränssnittet och jämföra körningar med olika hyperparameterinställningar.
Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Varför experimentspårning är viktigt
När ni tränar flera modeller med olika hyperparametrar är det lätt att tappa bort vilken körning som gav bäst resultat. Experimentspårning registrerar automatiskt parametrarna, mätvärdena och kodversionen för varje träningskörning i en sökbar databas. Utan detta tvingas team ofta använda röriga kalkylblad eller glömmer helt enkelt vad som fungerade. MLflow är branschens standardverktyg med öppen källkod för att spåra ML-experiment och hantera modellens livscykel.
Installera och starta MLflow
MLflow är ett rent Python-paket som inte kräver någon extern databas för att komma igång – körningar lagras lokalt i en katalog med namnet mlruns/. Installera paketet med pip och starta sedan spårningsgränssnittet för att visualisera körningar i en webbläsare. Gränssnittet visar alla experiment, parametrarna och mätvärdena för varje körning och låter er jämföra körningar sida vid sida med interaktiva diagram.
# 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())Skapa experiment
MLflow organiserar körningar i experiment – logiska grupperingar av relaterade körningar. Skapa ett namngivet experiment med mlflow.set_experiment. Alla efterföljande körningar hör till detta experiment. Använd beskrivande namn som identifierar projektet och datumet, till exempel 'random_forest_imdb_2024'. Varje körning i ett experiment får ett unikt ID, ett namn som människor kan läsa och ett eget lager för parametrar, mätvärden och artefakter.
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)Logga parametrar med mlflow.log_param
Parametrar är de konfigurationsval som görs innan träningen börjar: hyperparametrar som inlärningshastighet, antal estimatorer och regulariseringsstyrka. Logga dem med mlflow.log_param(key, value) i en aktiv körningskontext. Parametrar är oföränderliga när de väl har loggats – de definierar experimentets konfiguration och hjälper er att filtrera körningar för att hitta den konfiguration som fungerade bäst.
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.')Logga mätvärden med mlflow.log_metric
Mätvärden är de kvantitativa resultat som produceras under och efter träningen: träffsäkerhet, F1 och förlustvärden. Logga dem med mlflow.log_metric(key, value) eller mlflow.log_metric(key, value, step=i) för att följa utvecklingen över epokerna. Genom att logga mätvärden vid varje epok kan MLflow rita inlärningskurvor i gränssnittet, vilket gör det enkelt att jämföra konvergenshastigheten mellan körningar.
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}')Logga artefakter
Artefakter är filer som hör till en körning: tränade modellvikter, diagram, förväxlingsmatriser eller diagram över egenskapernas betydelse. Logga dem med mlflow.log_artifact(local_path). MLflow lagrar filen i körningens artefaktkatalog och gör den nedladdningsbar från användargränssnittet. Genom att logga bilden av förväxlingsmatrisen tillsammans med mätvärdena får granskare en fullständig bild utan att behöva gå igenom koden.
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.')Automatisk loggning med mlflow.sklearn.autolog
För scikit-learn tillhandahåller MLflow automatisk loggning som automatiskt fångar alla parametrar, mätvärden och den tränade modellen utan manuella loggningsanrop. Anropa helt enkelt mlflow.sklearn.autolog() innan träningen startas. Automatisk loggning stöder XGBoost, LightGBM, PyTorch, TensorFlow med flera, med liknande aktivering på en rad. Det är det snabbaste sättet att börja spåra körningar utan att ändra befintlig träningskod.
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.')Jämföra körningar i MLflows användargränssnitt
Efter flera körningar med olika hyperparametrar öppnar du MLflows användargränssnitt på http://localhost:5000. Markera flera körningar med kryssrutorna och klicka på Compare för att visa dem sida vid sida. På jämförelsesidan visas ett diagram med parallella koordinater där varje axel motsvarar en parameter eller ett mätvärde. Det gör det enkelt att se vilken kombination av parametrar som gav högst träffsäkerhet. Du kan också sortera körningstabellen efter valfri kolumn med mätvärden.
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'])Logga modeller med mlflow.sklearn.log_model
Utöver att logga modellfiler som generiska artefakter använder du mlflow.sklearn.log_model för att logga modellen i MLflows standardiserade format. Formatet innehåller modellobjektet, metadata för dess variant och en automatiskt genererad konfigurationsfil med namnet MLmodel. Det standardiserade formatet möjliggör distribution med ett klick till lokala REST-servrar (mlflow models serve) och molnplattformar som Azure ML och 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.')Tagga körningar för organisation
MLflow-körningar kan ha taggar: metadata i nyckel-värde-format som går utöver strukturerade parametrar och mätvärden. Använd taggar för att lagra datauppsättningens version, hashvärdet för kodincheckningen, experimenterarens namn eller anteckningar om vad som ändrades. Taggar kan sökas efter och filtreras i användargränssnittet. En bra taggningskonvention — till exempel att alltid logga dataset_version och git_sha — säkerställer att varje körning går att återskapa och granska även flera månader senare.
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.')Konfigurera en fjärrbaserad spårningsserver
För samarbete i team konfigurerar du MLflow att använda en fjärrbaserad spårningsserver i stället för den lokala mappen mlruns/. Ange spårnings-URI:n till serverns URL innan du gör några MLflow-anrop. Alla teammedlemmar loggar till samma server, kan se varandras körningar och får åtkomst till delade artefakter. Serverns backend kan använda en PostgreSQL-databas för metadata och S3/GCS för artefaktlagring, vilket ger hållbarhet och åtkomstkontroll på företagsnivå.
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.')Snabbtest
Testa dina kunskaper om begreppen inom Machine Learning med Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har du lärt dig att: MLflow spårar parametrar, mätvärden och artefakter för varje träningskörning i en sökbar databas, mlflow.sklearn.autolog() fångar allt automatiskt utan manuella loggningsanrop och loggade modeller i sklearn-varianten kan tillhandahållas som REST-API:er eller befordras genom Model Registry. Nästa steg är att bygga återskapningsbara Docker-containrar för ML-träning för att eliminera miljöskillnader mellan datorer.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter” gratis?
Ja – hela texten till ”Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter”?
Ni kommer att instrumentera ett träningsskript med mlflow.log_param och mlflow.log_metric, starta MLflow-gränssnittet och jämföra körningar med olika hyperparameterinställningar. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Experimentuppföljning med MLflow: Logga parametrar, mått och artefakter
- Reproducerbara miljöer med Docker för maskininlärning
- Modellregister: Staging, produktion och arkivering
- Automatiserade omträningspipelines med GitHub Actions