MLflow : suivi d'expériences et gestion de modèles ML

MLflow est une plateforme open source qui gère le cycle de vie du machine learning : tracer les expériences (paramètres, métriques), packager les modèles, les versionner dans un registre et les déployer. Il répond à une question récurrente : quel code, quelles données et quels paramètres ont produit quel modèle ?

Ce guide définit MLflow, présente ses composants, montre comment tracer une première expérience avec du code testé, ouvrir l'interface, et utiliser le Model Registry. Il s'inscrit dans une démarche MLOps. Public : intermédiaire, à l'aise avec Python et scikit-learn.

Ce que vous allez apprendre

Définir MLflow et le problème de traçabilité qu'il résout.
Distinguer ses quatre composants.
Tracer une expérience (paramètres, métriques, modèle).
Ouvrir l'interface MLflow.
Versionner un modèle avec le Model Registry.

Qu'est-ce que MLflow ?

MLflow standardise la façon dont on suit et partage les travaux de machine learning. Sans lui, les résultats d'expériences finissent dispersés dans des carnets, des noms de fichiers et des tableurs : impossible de reproduire un bon modèle des semaines plus tard. MLflow enregistre automatiquement le contexte de chaque exécution.

Développé à l'origine par Databricks, il est open source, léger et modulaire : on adopte seulement les composants utiles, sans se lier à une plateforme propriétaire. Il s'intègre nativement avec scikit-learn, PyTorch, TensorFlow et d'autres.

Les composants de MLflow

MLflow s'organise autour de quatre briques indépendantes :

Composant	Rôle
Tracking	Enregistrer paramètres, métriques et artefacts de chaque exécution
Models	Empaqueter un modèle dans un format portable, quel que soit le framework
Model Registry	Versionner les modèles et gérer leur passage en production
Projects	Décrire un projet reproductible (dépendances, points d'entrée)

Le Tracking est le point d'entrée le plus courant : c'est par lui qu'on commence.

Tracer une première expérience

Installez MLflow dans un environnement Conda isolé :

conda create -n mlops python=3.12 -y
conda activate mlops
pip install mlflow scikit-learn

Le code ci-dessous entraîne un modèle et enregistre ses paramètres, sa métrique et le modèle lui-même dans MLflow :

import mlflow, mlflow.sklearn
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X, y = make_classification(n_samples=500, random_state=42)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=42)

mlflow.set_experiment("demo")
with mlflow.start_run() as run:
    C = 1.0
    model = LogisticRegression(C=C, max_iter=200).fit(Xtr, ytr)
    acc = accuracy_score(yte, model.predict(Xte))

    mlflow.log_param("C", C)                       # un paramètre
    mlflow.log_metric("accuracy", acc)             # une métrique
    mlflow.sklearn.log_model(model, name="model")  # le modèle

    print("run_id:", run.info.run_id)
    print("accuracy:", round(acc, 3))

La sortie confirme l'enregistrement, et un dossier mlruns/ apparaît :

run_id: 32683d41642c4af0a7f55cb6e250fb77
accuracy: 0.9

Chaque appel à start_run crée une run rattachée à une expérience. En relançant le script avec un autre C, vous accumulez des runs comparables.

Ouvrir l'interface MLflow

MLflow fournit une interface web pour explorer et comparer les runs. Depuis le dossier contenant mlruns/ :

mlflow ui

L'interface s'ouvre sur http://localhost:5000. Vous y visualisez les expériences, triez les runs par métrique et comparez les paramètres côte à côte.

Versionner un modèle avec le Model Registry

Une fois une run satisfaisante, on enregistre son modèle dans le Model Registry, qui gère les versions :

model_uri = f"runs:/{run.info.run_id}/model"
mlflow.register_model(model_uri=model_uri, name="churn-classifier")

Chaque enregistrement crée une nouvelle version du modèle. Le registre sert ensuite à suivre quelle version est candidate, validée ou en production, et à la charger par son nom plutôt que par un chemin de fichier. C'est ce qui rend le passage en production traçable et réversible.

MLflow ou Kubeflow ?

Les deux servent le MLOps mais à des échelles différentes. MLflow se concentre sur le suivi des expériences et la gestion des modèles, s'installe en une commande et convient à un usage individuel comme à une équipe. Kubeflow orchestre des pipelines ML complets sur Kubernetes : plus puissant, mais bien plus lourd à opérer. On les combine parfois, MLflow pour le tracking à l'intérieur de pipelines Kubeflow.

Questions fréquentes

MLflow, c'est quoi ?

MLflow est une plateforme open source de MLOps qui trace les expériences (paramètres, métriques), package les modèles et les versionne, pour rendre le machine learning reproductible et traçable.

Comment fonctionne le tracking MLflow ?

On encadre l'entraînement par mlflow.start_run(), puis on enregistre les paramètres (log_param), les métriques (log_metric) et le modèle (log_model). MLflow stocke le tout dans le dossier mlruns/ ou sur un serveur.

Qu'est-ce que le Model Registry ?

Un registre central des modèles : il gère les versions, suit celle qui est en production et permet de charger un modèle par son nom. Il rend les déploiements gouvernés et réversibles.

MLflow est-il gratuit ?

Oui, MLflow est open source et gratuit. Des versions managées existent (Databricks, cloud), mais le coeur du projet s'installe librement avec pip.

À retenir

MLflow rend le machine learning reproductible : il enregistre le contexte de chaque exécution.
Quatre composants : Tracking, Models, Model Registry, Projects.
Le tracking enregistre paramètres, métriques et modèle en quelques appels.
L'interface (mlflow ui) compare les runs visuellement.
Le Model Registry versionne les modèles et gouverne leur mise en production.

Prochaines étapes

Introduction au MLOps Le cadre global du cycle de vie des modèles.

Monitoring ML Surveiller un modèle en production et détecter le drift.

Kubeflow Orchestrer des pipelines ML sur Kubernetes.

Machine Learning : les bases Le socle avant d'industrialiser.