Améliorer l’entraînement de YOLO26 : simplifie la journalisation avec Comet#

La journalisation des détails clés de l’entraînement, tels que les paramètres, les métriques, les prédictions d’images et les points de contrôle des modèles, est essentielle en machine learning : elle assure la transparence de ton projet, te permet de mesurer tes progrès et de reproduire tes résultats.

Ultralytics YOLO26 s’intègre parfaitement à Comet (anciennement Comet ML), qui capture et optimise efficacement chaque aspect du processus d’entraînement de ton modèle YOLO26 de détection d’objets. Dans ce guide, nous abordons l’installation, la configuration de Comet, les informations en temps réel, la journalisation personnalisée et l’utilisation hors ligne afin que l’entraînement de YOLO26 soit entièrement documenté et optimisé pour obtenir d’excellents résultats.

Comet#

Comet est une plateforme permettant de suivre, comparer, expliquer et optimiser les modèles et les expériences de machine learning. Elle te permet de journaliser les métriques, les paramètres, les médias et bien plus encore pendant l’entraînement de ton modèle, ainsi que de surveiller tes expériences depuis une interface Web esthétique. Comet aide les spécialistes des données à itérer plus rapidement, améliore la transparence et la reproductibilité, et contribue au développement de modèles prêts pour la production.

Tirer parti de YOLO26 et de Comet#

En associant Ultralytics YOLO26 à Comet, tu bénéficies de nombreux avantages : une gestion simplifiée des expériences, des informations en temps réel pour effectuer rapidement des ajustements, des options de journalisation flexibles et personnalisées, ainsi que la possibilité de journaliser les expériences hors ligne lorsque l’accès à Internet est limité. Cette intégration te permet de prendre des décisions fondées sur les données, d’analyser les métriques de performance et d’obtenir d’excellents résultats.

Installation#

Pour installer les paquets requis, exécute :

# Install YOLO26 and Comet
pip install ultralytics comet_ml

Configurer Comet#

Après avoir installé les packages nécessaires, tu dois créer un compte, obtenir une clé API Comet, puis la configurer.

# Set your Comet API Key
export COMET_API_KEY=YOUR_API_KEY

Authentifie-toi ensuite auprès de Comet. Le callback Ultralytics crée l’expérience et utilise l’argument d’entraînement YOLO project comme nom de projet Comet.

import comet_ml

comet_ml.login()

Si tu utilises un notebook Google Colab, le code ci-dessus te demandera de saisir ta clé API pour l’initialisation.

Utilisation#

Avant de passer aux instructions d’utilisation, pense à découvrir la gamme de modèles YOLO26 proposés par Ultralytics. Cela t’aidera à choisir le modèle le mieux adapté aux exigences de ton projet.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")

# Entraîner le modèle
results = model.train(
    data="coco8.yaml",
    project="comet-example-yolo26-coco128",
    batch=32,
    save_period=1,
    save_json=True,
    epochs=3,
)

Après l’exécution du code d’entraînement, Comet créera une expérience dans ton espace de travail Comet pour suivre automatiquement l’exécution. Tu recevras ensuite un lien permettant de consulter la journalisation détaillée du processus d’entraînement de ton modèle YOLO26.

Comet journalise automatiquement les données suivantes sans configuration supplémentaire : les métriques comme mAP et la perte, les hyperparamètres, les points de contrôle des modèles, la matrice de confusion interactive et les prédictions de boîtes englobantes des images.

Comprendre les performances de ton modèle grâce aux visualisations Comet#

Voyons ce qui s’affiche dans le tableau de bord Comet lorsque ton modèle YOLO26 commence son entraînement. C’est là que tout se passe : le tableau de bord présente de nombreuses informations journalisées automatiquement sous forme de graphiques et de statistiques. Voici un aperçu rapide :

Panneaux des expériences

La section des panneaux d’expériences du tableau de bord Comet organise et présente les différentes exécutions et leurs métriques, telles que la perte des masques de segmentation, la perte de classification, la précision et la précision moyenne.

Métriques

Dans la section des métriques, tu peux également les examiner sous forme de tableau, affiché dans un panneau dédié comme illustré ici.

Matrice de confusion interactive

La matrice de confusion, accessible dans l’onglet Matrice de confusion, permet d’évaluer interactivement l’exactitude de la classification du modèle. Elle détaille les prédictions correctes et incorrectes, ce qui te permet de comprendre les forces et les faiblesses du modèle.

Métriques système

Comet journalise les métriques système pour t’aider à repérer les éventuels goulots d’étranglement dans le processus d’entraînement. Il s’agit notamment de l’utilisation du GPU, de la mémoire GPU, du CPU et de la RAM. Ces métriques sont essentielles pour surveiller l’efficacité de l’utilisation des ressources pendant l’entraînement du modèle.

Personnaliser la journalisation Comet#

Comet te permet de personnaliser son comportement de journalisation en définissant des variables d’environnement. Ces configurations te permettent d’adapter Comet à tes besoins et préférences. Le callback Ultralytics lit les variables d’environnement suivantes (définis-les avant le début de l’entraînement) :

Pour les bascules booléennes (COMET_EVAL_LOG_IMAGE_PREDICTIONS et COMET_EVAL_LOG_CONFUSION_MATRIX), les valeurs 1, true, yes, on, y et t sont interprétées comme True (sans distinction entre majuscules et minuscules). Toute autre valeur est interprétée comme False.

Journalisation des prédictions d’images#

Tu peux contrôler le nombre de prédictions d’images que Comet journalise pendant tes expériences. Par défaut, Comet journalise 100 prédictions d’images issues du jeu de validation. Tu peux toutefois modifier ce nombre selon tes besoins. Par exemple, pour journaliser 200 prédictions d’images, utilise le code suivant :

import os

os.environ["COMET_MAX_IMAGE_PREDICTIONS"] = "200"

Pour désactiver complètement la journalisation des prédictions d’images (par exemple, afin de réduire le volume des chargements sur une connexion lente), définis COMET_EVAL_LOG_IMAGE_PREDICTIONS sur "false" :

import os

os.environ["COMET_EVAL_LOG_IMAGE_PREDICTIONS"] = "false"

Intervalle de journalisation des lots#

Comet te permet de définir la fréquence de journalisation des lots de prédictions d’images. La variable d’environnement COMET_EVAL_BATCH_LOGGING_INTERVAL contrôle cette fréquence. La valeur par défaut est 1, ce qui journalise les prédictions de chaque lot de validation. Tu peux modifier cette valeur pour journaliser les prédictions à un autre intervalle. Par exemple, en la définissant sur 4, les prédictions de chaque quatrième lot seront journalisées.

import os

os.environ["COMET_EVAL_BATCH_LOGGING_INTERVAL"] = "4"

Désactiver la journalisation de la matrice de confusion#

Dans certains cas, tu peux ne pas vouloir journaliser la matrice de confusion de ton jeu de validation après chaque époque. Tu peux désactiver cette fonctionnalité en définissant la variable d’environnement COMET_EVAL_LOG_CONFUSION_MATRIX sur "false". La matrice de confusion ne sera journalisée qu’une fois, à la fin de l’entraînement.

import os

os.environ["COMET_EVAL_LOG_CONFUSION_MATRIX"] = "false"

Mode en ligne et hors ligne#

Par défaut, Comet fonctionne en mode en ligne et transmet les données des expériences aux serveurs Comet. Si tu dois entraîner ton modèle sans accès à Internet, définis COMET_START_ONLINE=0 avant le début de l’entraînement. Les données des expériences sont enregistrées localement et peuvent être chargées ultérieurement à l’aide de la CLI comet upload.

import os

os.environ["COMET_START_ONLINE"] = "0"  # 1 (par défaut) = en ligne, 0 = hors ligne

Nom du projet#

Par défaut, le callback Comet transmet à Comet l’argument d’entraînement YOLO project (ou None si l’argument n’est pas défini, auquel cas Comet utilise la valeur par défaut de ton espace de travail). Remplace ce comportement par COMET_PROJECT_NAME pour envoyer toutes les expériences vers un projet Comet spécifique, quel que soit l’argument d’entraînement YOLO :

import os

os.environ["COMET_PROJECT_NAME"] = "my-yolo26-experiments"

Nom de l’artefact du modèle#

COMET_MODEL_NAME définit le nom que Comet enregistre pour l’artefact de modèle journalisé (la valeur par défaut est Ultralytics). Utilise cette variable pour distinguer les variantes de modèles dans un espace de travail partagé :

import os

os.environ["COMET_MODEL_NAME"] = "yolo26n-coco128"

Mise à l’échelle du score de confiance#

Les scores de confiance de détection sont émis dans la plage [0, 1], mais l’interface Comet les affiche par défaut sur une échelle en pourcentage. Avant de les journaliser, le callback multiplie chaque score par COMET_MAX_CONFIDENCE_SCORE (valeur par défaut : 100.0). Ajuste ce paramètre si tu préfères des probabilités brutes ou une autre échelle :

import os

os.environ["COMET_MAX_CONFIDENCE_SCORE"] = "1.0"  # journaliser les scores bruts [0, 1]

Résumé#

Ce guide t’a accompagné dans l’intégration de Comet avec YOLO26 d’Ultralytics. De l’installation à la personnalisation, tu as appris à simplifier la gestion des expériences, à obtenir des informations en temps réel et à adapter la journalisation aux besoins de ton projet.

Consulte la documentation officielle d’intégration de YOLOv8 de Comet, qui s’applique également aux projets YOLO26.

De plus, si tu souhaites approfondir les applications pratiques de YOLO26, notamment pour les tâches de segmentation d’images, ce guide détaillé sur l’ajustement fin de YOLO26 avec Comet propose des informations précieuses et des instructions étape par étape pour améliorer les performances de ton modèle.

Pour découvrir d’autres intégrations intéressantes avec Ultralytics, consulte également la page du guide d’intégration, qui propose de nombreuses ressources et informations.

FAQ#