Améliore l'entraînement de YOLO26 : simplifie ton processus de 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 du modèle, est essentielle en apprentissage automatique : elle garantit la transparence de ton projet, permet de mesurer tes progrès et rend tes résultats reproductibles.

Ultralytics YOLO26 s'intègre parfaitement à Comet (anciennement Comet ML) et capture et optimise efficacement chaque aspect du processus d'entraînement de ton modèle YOLO26 de détection d'objets. Dans ce guide, tu découvriras le processus d'installation, la configuration de Comet, les informations en temps réel, la journalisation personnalisée et l'utilisation hors ligne, afin de documenter précisément ton entraînement YOLO26 et de l'optimiser 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 d'apprentissage automatique. 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, et de surveiller tes expériences via une interface web esthétique. Comet aide les data scientists à itérer plus rapidement, améliore la transparence et la reproductibilité, et contribue au développement de modèles prêts pour la production.

Exploiter la puissance 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 tes 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 des résultats exceptionnels.

Installation#

Pour installer les packages requis, exécute :

# Install YOLO26 and Comet
pip install ultralytics comet_ml

Configurer Comet#

Après avoir installé les packages requis, tu devras créer un compte, obtenir une clé API Comet et 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 lors de l'initialisation.

Utilisation#

Avant de passer aux instructions d'utilisation, consulte 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

# Load a model
model = YOLO("yolo26n.pt")

# Train the model
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 automatiquement une expérience dans ton espace de travail Comet pour suivre l'exécution. Un lien te sera ensuite fourni pour 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 telles que mAP et la perte, les hyperparamètres, les points de contrôle du modèle, la matrice de confusion interactive et les prédictions d'encadrements dans les images.

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

Examinons ce que tu verras sur le tableau de bord Comet une fois que ton modèle YOLO26 aura commencé son entraînement. Le tableau de bord est le centre de toutes les activités : il présente un éventail d'informations journalisées automatiquement sous forme de visualisations 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 classe, 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 volet dédié comme illustré ici.

Matrice de confusion interactive

La matrice de confusion, disponible dans l'onglet Confusion Matrix, fournit un moyen interactif d'évaluer l'exactitude de la classification du modèle. Elle détaille les prédictions correctes et incorrectes, ce qui te permet de comprendre les points forts et les faiblesses du modèle.

Métriques système

Comet journalise les métriques système pour aider à identifier les éventuels goulots d'étranglement dans le processus d'entraînement. Cela comprend des métriques telles que l'utilisation du GPU, l'utilisation de la mémoire GPU, l'utilisation du CPU et l'utilisation 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 de Comet#

Comet offre la possibilité 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 spécifiques. 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 analysées comme True (sans distinction de casse). Toute autre valeur est interprétée comme False.

Journaliser les 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 provenant de l'ensemble de validation. Tu peux toutefois modifier ce nombre pour mieux répondre à 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 téléversements sur les connexions lentes), 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 ajuster cette valeur pour journaliser les prédictions selon un intervalle différent. Par exemple, en la définissant sur 4, les prédictions seront journalisées tous les quatre lots.

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 ensemble 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 seule fois, une fois l'entraînement terminé.

import os

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

Mode en ligne et hors ligne#

Par défaut, Comet s'exécute en mode en ligne et diffuse les données de l'expérience vers les serveurs Comet. Si tu dois entraîner un modèle sans accès à Internet, définis COMET_START_ONLINE=0 avant le début de l'entraînement. Les données de l'expérience sont enregistrées localement et peuvent être téléversées ultérieurement avec le CLI comet upload.

import os

os.environ["COMET_START_ONLINE"] = "0"  # 1 (default) = online, 0 = offline

Nom du projet#

Par défaut, le callback Comet transmet à Comet l'argument d'entraînement YOLO project (ou None lorsque 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 spécifique de ton espace de travail Comet, 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 du modèle journalisé (par défaut, Ultralytics). Utilise-le pour différencier les variantes de modèle 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 des détections sont générés dans la plage [0, 1], mais l'interface utilisateur de Comet les affiche par défaut sur une échelle en pourcentage. Le callback multiplie chaque score par COMET_MAX_CONFIDENCE_SCORE (par défaut, 100.0) avant la journalisation. Ajuste cette valeur si tu préfères utiliser les probabilités brutes ou une autre échelle :

import os

os.environ["COMET_MAX_CONFIDENCE_SCORE"] = "1.0"  # log raw [0, 1] scores

Résumé#

Ce guide t'a accompagné dans l'intégration de 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 de l'intégration de YOLOv8 avec 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 fournit des informations utiles et des instructions étape par étape pour améliorer les performances de ton modèle.

Par ailleurs, pour découvrir d'autres intégrations intéressantes avec Ultralytics, consulte la page du guide des intégrations, qui propose de nombreuses ressources et informations.

FAQ#