MLflow : définition, composants et exemple de tracking

MLflow est né d'un constat partagé par la plupart des équipes data : entraîner un modèle de machine learning est la partie la mieux outillée du travail. Retrouver quels paramètres ont produit le meilleur score trois semaines plus tard, transmettre le modèle à l'équipe qui le déploie ou savoir quelle version tourne en production l'est beaucoup moins. MLflow apporte une réponse standard à ces trois problèmes.

Le projet a été présenté par Databricks en juin 2018, puis confié à la Linux Foundation en 2020. Il est publié sous licence Apache 2.0. Sa force tient à son approche peu intrusive : MLflow ne demande ni de changer de bibliothèque, ni d'adopter une infrastructure particulière. Il s'ajoute à un script ou à un notebook existant, en local comme sur un serveur partagé.

Dans une démarche MLOps, MLflow occupe la couche de gestion du cycle de vie : traçabilité des expériences, format de modèle, registre et déploiement simple. Il ne gère pas l'exécution des traitements sur un cluster, rôle que remplissent des outils comme Kubeflow ou Airflow. Depuis 2025, il couvre aussi le suivi des applications fondées sur des LLM.

À retenir : MLflow répond à la question « d'où vient ce modèle et comment le réutiliser ? ». Il trace, empaquette et versionne, mais n'orchestre pas.

Le script suivant entraîne une forêt aléatoire, enregistre ses paramètres et ses métriques, puis enregistre le modèle dans le Model Registry. Il suppose un serveur de tracking lancé en local avec mlflow server --host 127.0.0.1 --port 5000.

import mlflow
from mlflow import MlflowClient
from mlflow.models import infer_signature
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score
from sklearn.model_selection import train_test_split

mlflow.set_tracking_uri("http://127.0.0.1:5000")
mlflow.set_experiment("detection-tumeurs")

X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
params = {"n_estimators": 200, "max_depth": 6, "random_state": 42}

with mlflow.start_run(run_name="random-forest-v1"):
    model = RandomForestClassifier(**params).fit(X_train, y_train)
    preds = model.predict(X_test)

    mlflow.log_params(params)
    mlflow.log_metrics({
        "accuracy": accuracy_score(y_test, preds),
        "f1": f1_score(y_test, preds),
    })
    model_info = mlflow.sklearn.log_model(
        sk_model=model,
        name="model",
        signature=infer_signature(X_test, preds),
        registered_model_name="detection-tumeurs-rf",
    )

# Désigner cette version comme celle à déployer
client = MlflowClient()
client.set_registered_model_alias(
    "detection-tumeurs-rf", "champion", model_info.registered_model_version
)

Le run apparaît dans l'interface avec ses paramètres, ses deux métriques et le modèle sauvegardé. La signature décrit les colonnes attendues en entrée, ce qui permet de valider les requêtes au moment du serving. L'argument registered_model_name crée une nouvelle version dans le registre, et l'alias champion indique laquelle doit être utilisée. Pour aller plus vite, mlflow.sklearn.autolog() enregistre automatiquement paramètres, métriques et modèle sans appel explicite.

Le modèle est ensuite servi ou empaqueté en ligne de commande, en le désignant par son alias :

export MLFLOW_TRACKING_URI=http://127.0.0.1:5000

# API REST locale sur le port 5001 (endpoint /invocations)
mlflow models serve -m "models:/detection-tumeurs-rf@champion" -p 5001 --env-manager local

# Image Docker prête à déployer
mlflow models build-docker -m "models:/detection-tumeurs-rf@champion" -n detection-tumeurs:1

L'image produite peut être déployée comme n'importe quel conteneur Docker, sur un serveur ou dans un cluster. Notre article MLflow : tout savoir sur l'outil indispensable du MLOps propose une prise en main plus détaillée.

MLflow est organisé en briques indépendantes : on peut n'en utiliser qu'une seule.

• Tracking : l'API et l'interface qui enregistrent les runs. Les métadonnées sont stockées dans une base (fichiers locaux, SQLite, PostgreSQL, MySQL) et les artefacts dans un système de fichiers ou un stockage objet comme S3.
• Models : le format d'empaquetage. Un modèle MLflow est un dossier qui contient les fichiers du modèle, un fichier MLmodel listant ses flavors, sa signature et ses dépendances. La flavor pyfunc offre une interface predict commune à tous les modèles.
• Model Registry : le registre central des modèles. Chaque enregistrement crée une version, à laquelle on associe des alias, des tags et une description. Les alias ont remplacé les anciennes étapes Staging et Production, plus rigides.
• Serving : le déploiement d'un modèle en API REST locale, en image Docker ou vers des plateformes cloud. Le format MLflow est aussi reconnu par des outils de serving tiers comme KServe.
• Projects : un format de description d'un projet (point d'entrée, environnement) pour le rendre réexécutable. Cette brique historique est aujourd'hui moins mise en avant que les autres.

MLflow et l'IA générative

Les versions récentes, à partir de MLflow 3 sorti en 2025, ont ajouté un ensemble de fonctionnalités consacrées aux applications génératives. Le tracing enregistre le détail de chaque requête d'une application LLM : appels au modèle, recherches dans un index, outils invoqués, latence et tokens consommés, avec une instrumentation automatique pour plusieurs fournisseurs et frameworks. L'évaluation mesure la qualité des réponses sur un jeu de questions, notamment à l'aide de LLM juges. Un registre de prompts permet enfin de versionner les prompts comme on versionne les modèles. Ces fonctionnalités rapprochent MLflow des outils de LLMOps ; leur périmètre évolue rapidement d'une version à l'autre.

Les deux outils sont souvent cités ensemble, mais ils ne répondent pas à la même question. MLflow gère la mémoire du projet ; Kubeflow fournit l'usine qui exécute les traitements.

Les deux se combinent naturellement : un pipeline Kubeflow orchestre la préparation des données et l'entraînement, et chaque étape enregistre ses runs et ses modèles dans MLflow. Pour une petite équipe sans cluster, MLflow seul, associé à un ordonnanceur simple, couvre souvent l'essentiel du besoin.