Commencer

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.



À regarder : Comment utiliser Comet pour suivre les journaux et les métriques d’entraînement des modèles Ultralytics YOLO 🚀

Ultralytics YOLO26 s’intègre à Comet (anciennement Comet ML) pour enregistrer le processus d’entraînement de tes modèles de détection d’objets YOLO26. Ce guide couvre l’installation, la configuration de Comet, les informations en temps réel, la journalisation personnalisée et l’utilisation hors ligne, afin que tes entraînements YOLO26 soient documentés et reproductibles.

Comet#

Comet ML experiment tracking dashboard

Comet est une plateforme de suivi, de comparaison, d’explication et d’optimisation des modèles et des expériences de machine learning. Elle te permet de journaliser des métriques, des paramètres, des médias et bien plus pendant l’entraînement de tes modèles, ainsi que de suivre tes expériences via une interface Web. 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 destinés à la production.

Tirer parti de YOLO26 et de Comet#

L’association d’Ultralytics YOLO26 et de Comet offre plusieurs avantages, notamment un suivi des expériences simplifié, 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 t’aide à prendre des décisions fondées sur les données et à analyser les métriques de performance.

Installation#

Pour installer les paquets requis, exécute :

Installation
# 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.

Configurer Comet
# 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.

Initialiser le 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#

Utilisation
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.

Une fois Comet installé et configuré, son callback est activé par défaut et journalise des métriques comme mAP et la perte, les hyperparamètres, les points de contrôle du modèle et une matrice de confusion interactive. Les prédictions des boîtes englobantes des images du jeu de validation sont journalisées pour l’entraînement en détection et en segmentation avec save_json=True. Exécute yolo settings comet=False pour désactiver l’intégration.

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

Dès que l’entraînement de ton modèle YOLO26 commence, le tableau de bord Comet affiche les informations journalisées automatiquement sous forme de graphiques et de statistiques :

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.

Comet experiment panels comparing YOLO26 training runs and metrics

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.

Comet metrics pane listing YOLO26 training metrics in a table

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.

Comet interactive confusion matrix for YOLO26 validation results

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.

Comet system metrics showing GPU and CPU utilization during training

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) :

Variable d’environnementValeur par défautDescription
COMET_START_ONLINE1Exécuter l’expérience en mode en ligne (1) ou hors ligne (0).
COMET_PROJECT_NAMEargs.projectProjet de l’espace de travail Comet. Utilise l’argument d’entraînement YOLO project si cette variable n’est pas définie.
COMET_MODEL_NAMEUltralyticsNom enregistré pour l’artefact de modèle journalisé.
COMET_MAX_IMAGE_PREDICTIONS100Nombre total de prédictions d’images de validation à journaliser par exécution.
COMET_EVAL_BATCH_LOGGING_INTERVAL1Journaliser les prédictions d’images toutes les N itérations de lot de validation.
COMET_EVAL_LOG_IMAGE_PREDICTIONStrueActiver (true) ou désactiver (false) la journalisation des prédictions d’images.
COMET_EVAL_LOG_CONFUSION_MATRIXfalseEnregistre une matrice de confusion à chaque point de contrôle save_period. Une matrice finale est toujours enregistrée après l'entraînement.
COMET_MAX_CONFIDENCE_SCORE100.0Multiplicateur appliqué aux scores de confiance de détection avant leur journalisation (l’interface Comet attend une échelle en pourcentage).
COMET_MODE (obsolète)onlineAlias historique de COMET_START_ONLINE ("online" ↔ 1, "offline" ↔ 0). Un avertissement de dépréciation est émis.

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 consigne pendant tes expériences. Avec save_json=True, Comet consigne jusqu’à 100 prédictions d’images provenant de l’ensemble de validation. Tu peux toutefois modifier ce nombre selon tes besoins. Par exemple, pour consigner 200 prédictions d’images, utilise le code suivant :

import os

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

Pour désactiver la consignation des prédictions d’images annotées (par exemple, afin de réduire le volume de téléversement sur les connexions lentes), définis COMET_EVAL_LOG_IMAGE_PREDICTIONS sur "false" :

import os

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

Les images des graphiques train_batch*.jpg et val_batch*.jpg sont tout de même consignées à la fin de l’entraînement.

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"

Enregistrement de la matrice de confusion à chaque époque#

Par défaut, la matrice de confusion de ton jeu de validation est enregistrée une seule fois, à la fin de l'entraînement. Pour l'enregistrer aussi à chaque point de contrôle sauvegardé par save_period (save_period=1 enregistre à chaque époque), définis la variable d'environnement COMET_EVAL_LOG_CONFUSION_MATRIX sur « true ».

import os

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

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
`COMET_MODE` est obsolète

Les versions précédentes utilisaient COMET_MODE="offline" à cette fin. Cette variable reste prise en charge pour assurer la rétrocompatibilité, mais un avertissement de dépréciation est émis. Utilise désormais COMET_START_ONLINE.

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 expliqué comment intégrer Comet à Ultralytics YOLO26. 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.

FAQ#

  • Pour intégrer Comet à Ultralytics YOLO26, suis ces étapes :

    1. Installe les packages nécessaires :

      pip install ultralytics comet_ml
    2. Configure ta clé API Comet :

      export COMET_API_KEY=YOUR_API_KEY
    3. Authentifie-toi auprès de Comet dans ton code Python :

      import comet_ml
      
      comet_ml.login()
    4. Entraîne ton modèle YOLO26 et journalise les métriques :

      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      results = model.train(
          data="coco8.yaml",
          project="comet-example-yolo26-coco128",
          batch=32,
          save_period=1,
          save_json=True,
          epochs=3,
      )

    Pour obtenir des instructions plus détaillées, consulte la section sur la configuration de Comet.

  • En intégrant Ultralytics YOLO26 à Comet, tu peux :

    • Suivre les informations en temps réel : Obtiens un retour immédiat sur les résultats de ton entraînement afin de pouvoir effectuer rapidement des ajustements.
    • Consigner de nombreuses métriques : Capture automatiquement les métriques essentielles, telles que mAP, la fonction de perte, les hyperparamètres et les points de contrôle du modèle.
    • Suivre les expériences hors ligne : Consigne localement tes exécutions d’entraînement lorsque tu n’as pas accès à Internet.
    • Comparer différentes exécutions d’entraînement : Utilise le tableau de bord interactif de Comet pour analyser et comparer plusieurs expériences.

    Grâce à ces fonctionnalités, tu peux optimiser tes workflows de machine learning pour améliorer les performances et la reproductibilité.

  • Comet permet de personnaliser largement son comportement de journalisation à l’aide de variables d’environnement :

    • Modifier le nombre de prédictions d’images consignées :

      import os
      
      os.environ["COMET_MAX_IMAGE_PREDICTIONS"] = "200"
    • Régler l’intervalle de journalisation des lots :

      import os
      
      os.environ["COMET_EVAL_BATCH_LOGGING_INTERVAL"] = "4"
    • Enregistre la matrice de confusion à chaque point de contrôle save_period :

      import os
      
      os.environ["COMET_EVAL_LOG_CONFUSION_MATRIX"] = "true"
    • Définir le nom du projet Comet :

      import os
      
      os.environ["COMET_PROJECT_NAME"] = "my-yolo26-experiments"
    • Définir le nom de l’artefact du modèle consigné :

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

    Consulte la section Personnaliser la journalisation de Comet pour obtenir la liste complète, notamment les options d’activation des prédictions d’images, la mise à l’échelle des scores de confiance et le mode en ligne/hors ligne.

  • Dès que l’entraînement de ton modèle YOLO26 commence, tu peux accéder à de nombreuses métriques et visualisations dans le tableau de bord de Comet. Voici les principales fonctionnalités :

    • Panneaux des expériences : Consulte les différentes exécutions et leurs métriques, notamment la perte des masques de segmentation, la perte de classification et la précision moyenne.
    • Métriques : Examine les métriques sous forme de tableau pour les analyser en détail.
    • Matrice de confusion interactive : Évalue la précision de la classification à l’aide d’une matrice de confusion interactive.
    • Métriques système : Surveille l’utilisation du GPU et du CPU, l’utilisation de la mémoire et d’autres métriques système.

    Pour obtenir un aperçu détaillé de ces fonctionnalités, consulte la section Comprendre les performances de ton modèle avec les visualisations Comet.

  • Oui. Définis COMET_START_ONLINE=0 avant le début de l’entraînement pour consigner les données localement :

    import os
    
    os.environ["COMET_START_ONLINE"] = "0"

    Les données de l’expérience sont enregistrées sur le disque et peuvent être téléversées ultérieurement vers Comet à l’aide de la CLI comet upload lorsque la connexion est disponible. La variable COMET_MODE="offline" précédente fonctionne toujours, mais émet un avertissement de dépréciation. Pour en savoir plus, consulte la section Mode en ligne et hors ligne.

Commentaires5

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. lauravchrobakGitHub

    I am getting this warning when using the above workflow, 'comet_ml.init() is deprecated and will be removed soon. Please use comet_ml.login()' perhaps the above should be updated to use comet_ml.login() instead?

    1. Paula DerrengerUltralytics

      @lauravchrobak thank you for pointing that out. The warning indicates that comet_ml.init() is deprecated and should be replaced with comet_ml.login(). We will update the documentation accordingly. For now, please use comet_ml.login() to avoid the deprecation warning. If you encounter any further issues, ensure you are using the latest versions of the packages. For more details, you can visit the Comet ML integration guide.

      1
    2. Glenn JocherUltralytics

      Thank you for your feedback! We've updated our documentation to use comet_ml.login() instead of the deprecated comet_ml.init(). This should resolve the warning you're encountering. If you have any other questions or need further assistance, feel free to ask. For more details, you can visit the Comet ML integration guide.