Experiment Tracking

Le suivi des expériences consiste à enregistrer dans un référentiel consultable tout ce qui concerne chaque exécution d’entraînement en apprentissage automatique : version du code, version des données, paramètres, environnement, métriques au fil du temps et fichiers de sortie comme les poids et les graphiques. Un projet qui teste des dizaines de taux d’apprentissage, de paramètres d’augmentation et de tailles de modèle produit des exécutions qui se ressemblent sur le disque. Le suivi conserve la configuration associée à chaque résultat, afin de comparer et de reproduire la meilleure exécution, et d’en retracer l’origine des mois plus tard. TensorBoard, publié avec TensorFlow en 2015, a généralisé les courbes d’entraînement en direct ; en 2018, Databricks a publié MLflow en open source, dont le suivi était l’un des trois composants d’origine. Weights & Biases, Comet, ClearML et DVC sont d’autres outils de suivi largement utilisés.

Données enregistrées par un outil de suivi#

Chaque exécution reçoit un identifiant unique et appartient à une expérience, un groupe nommé d’exécutions apparentées. Un enregistrement type contient :

• Hyperparamètres : Taux d’apprentissage, taille des lots, optimiseur, architecture du modèle, graine aléatoire et tous les autres paramètres qui influencent l’entraînement.
• Métriques : Pertes et scores d’entraînement et de validation enregistrés à chaque étape ou époque, ainsi que des métriques système comme l’utilisation et la mémoire du GPU.
• Artefacts : Points de contrôle, matrices de confusion, prédictions d’exemples et fichiers de configuration.
• Traçabilité : Commit Git, version du jeu de données, versions des paquets, matériel et auteur associés à l’exécution.

L’enregistrement s’effectue avec un appel client pour chaque valeur, ou automatiquement grâce à des intégrations d’enregistrement automatique qui capturent les paramètres et les métriques d’un framework sans code supplémentaire. Un serveur de suivi partagé collecte les exécutions de tous les ordinateurs portables, machines cloud et tâches CI de l’équipe. Son tableau de bord superpose les courbes de perte des exécutions sélectionnées et permet de les filtrer selon n’importe quel paramètre ou métrique, ce qui rend immédiatement visibles des problèmes comme le surapprentissage.

L’entraînement Ultralytics YOLO enregistre les arguments de chaque exécution dans args.yaml, ainsi que les pertes et métriques par époque dans results.csv. Les intégrations intégrées envoient les mêmes valeurs à MLflow, Comet, ClearML ou DVC dès que leur paquet est installé. TensorBoard et Weights & Biases s’activent avec yolo settings. Les arguments d’entraînement project et name deviennent les noms de l’expérience et de l’exécution dans MLflow, de sorte qu’une campagne d’essais YOLO26 arrive déjà organisée dans l’outil de suivi.

Comparer et reproduire des exécutions#

Les tableaux de bord tracent une métrique en fonction d’un paramètre sur plusieurs exécutions, ou affichent des graphiques à coordonnées parallèles reliant les paramètres de chaque exécution à son score, ce qui montre quels paramètres comptent lors d’un balayage. Dans Ultralytics Platform, un projet compare ses modèles à l’aide de courbes de métriques et de pertes superposées et d’un tableau côte à côte, et la leçon Comparer des exécutions et choisir la meilleure transforme cette comparaison en une étape de validation automatisée du déploiement. Reproduire une exécution demande plus que ses hyperparamètres : l’enregistrement doit aussi contenir le commit de code, l’instantané exact des données, les versions des packages et la graine aléatoire, car les noyaux GPU et l’ordre de chargement des données peuvent légèrement modifier les résultats, même entre des exécutions autrement identiques.

Ce script MLflow entraîne un arbre de décision avec quatre profondeurs sur les chiffres manuscrits de scikit-learn. Il enregistre chaque profondeur comme paramètre et la précision de validation comme métrique, puis interroge l’expérience sous forme de tableau :

import mlflow
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# Store runs in a local SQLite file and group them under one experiment
mlflow.set_tracking_uri("sqlite:///mlflow.db")
mlflow.set_experiment("digits-tree-depth")
X_train, X_val, y_train, y_val = train_test_split(*load_digits(return_X_y=True), random_state=0)

# One tracked run per setting: the parameter goes in, the metric comes out
for depth in [2, 4, 8, 16]:
    with mlflow.start_run(run_name=f"depth-{depth}"):
        model = DecisionTreeClassifier(max_depth=depth, random_state=0).fit(X_train, y_train)
        mlflow.log_param("max_depth", depth)
        mlflow.log_metric("val_accuracy", model.score(X_val, y_val))

# Query the experiment like a table, best run first
runs = mlflow.search_runs(order_by=["metrics.val_accuracy DESC"])
print(runs[["params.max_depth", "metrics.val_accuracy"]])

Sur une nouvelle base de données, le tableau affiche d’abord la profondeur 16, avec une précision de validation de 0,838, puis la profondeur 8 à 0,818, la profondeur 4 à 0,533 et la profondeur 2 à 0,318. Exécuter mlflow ui dans le même dossier avec --backend-store-uri sqlite:///mlflow.db ouvre les mêmes exécutions dans le navigateur.

Suivi des expériences et pratiques connexes#

Le suivi des expériences est une étape des opérations d’apprentissage automatique (MLOps), au même titre que trois pratiques souvent confondues avec lui :

• Registre de modèles : Conserve les quelques modèles entraînés qui méritent d’être déployés, chaque version étant reliée à l’exécution suivie qui l’a produite.
• Surveillance des modèles : Surveille les entrées, les sorties et la précision d’un modèle déployé en production, après le suivi effectué pendant le développement.
• Optimisation des hyperparamètres : Des outils de recherche comme Optuna et Ray Tune lancent automatiquement de nombreuses exécutions ; l’outil de suivi les enregistre et les classe toutes.