Link to this sectionAméliore ton entraînement 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 machine learning — cela rend ton projet transparent, tes progrès mesurables et tes résultats reproductibles.

Ultralytics YOLO26 s'intègre parfaitement avec Comet (anciennement Comet ML), capturant et optimisant efficacement chaque aspect du processus d'entraînement de ton modèle de détection d'objets YOLO26. Dans ce guide, nous couvrirons le processus d'installation, la configuration de Comet, les analyses en temps réel, la journalisation personnalisée et l'utilisation hors ligne, en t'assurant que ton entraînement YOLO26 est minutieusement documenté et optimisé pour des résultats exceptionnels.

Link to this sectionComet#

Comet est une plateforme pour suivre, comparer, expliquer et optimiser les modèles et les 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 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 facilite le développement de modèles de production.

Link to this sectionExploite la puissance de YOLO26 et de Comet#

En combinant Ultralytics YOLO26 avec Comet, tu débloques une gamme d'avantages. Ceux-ci incluent une gestion simplifiée des expériences, des analyses en temps réel pour des ajustements rapides, 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 basées sur les données, d'analyser les métriques de performance et d'obtenir des résultats exceptionnels.

Link to this sectionInstallation#

Pour installer les paquets requis, exécute :

# Install the required packages for YOLO26 and Comet
pip install ultralytics comet_ml torch torchvision

Link to this sectionConfiguration de Comet#

Après avoir installé les paquets requis, tu devras t'inscrire, obtenir une clé API Comet et la configurer.

# Set your Comet API Key
export COMET_API_KEY=YOUR_API_KEY

Ensuite, tu pourras initialiser ton projet Comet. Comet détectera automatiquement la clé API et poursuivra la configuration.

import comet_ml

comet_ml.login(project_name="comet-example-yolo26-coco128")

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

Link to this sectionUtilisation#

Avant de te plonger dans les instructions d'utilisation, assure-toi de consulter la gamme de modèles YOLO26 proposés par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié pour les 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 avoir exécuté le code d'entraînement, Comet créera une expérience dans ton espace de travail Comet pour suivre l'exécution automatiquement. Tu recevras ensuite un lien 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 : métriques telles que mAP et perte, hyperparamètres, points de contrôle du modèle, matrice de confusion interactive et prédictions de boîtes englobantes d'images.

Link to this sectionComprendre les performances de ton modèle avec les visualisations Comet#

Plongeons dans ce que tu verras sur le tableau de bord Comet une fois que ton modèle YOLO26 commencera l'entraînement. Le tableau de bord est le centre de l'action, présentant une gamme d'informations journalisées automatiquement via des visuels et des statistiques. Voici une visite rapide :

Panneaux d'expérience

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

Metrics

Dans la section des métriques, tu as également la possibilité d'examiner les métriques sous un format tabulaire, qui est affiché dans un volet dédié comme illustré ici.

Matrice de confusion interactive

La matrice de confusion, située dans l'onglet Confusion Matrix, offre un moyen interactif d'évaluer la précision de classification du modèle. Elle détaille les prédictions correctes et incorrectes, te permettant de comprendre les forces et les faiblesses du modèle.

Métriques système

Comet journalise les métriques système pour aider à identifier les goulots d'étranglement dans le processus d'entraînement. Cela inclut 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. Celles-ci sont essentielles pour surveiller l'efficacité de l'utilisation des ressources pendant l'entraînement du modèle.

Link to this sectionPersonnalisation de la journalisation Comet#

Comet offre la flexibilité 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 rappel Ultralytics lit les variables d'environnement suivantes (définis-les avant le début de l'entraînement) :

Link to this sectionJournalisation 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 de l'ensemble de validation. Cependant, tu peux changer 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, pour réduire le volume de téléchargement sur des connexions lentes), règle COMET_EVAL_LOG_IMAGE_PREDICTIONS sur "false" :

import os

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

Link to this sectionIntervalle de journalisation par lot#

Comet te permet de spécifier la fréquence à laquelle les lots de prédictions d'images sont journalisés. La variable d'environnement COMET_EVAL_BATCH_LOGGING_INTERVAL contrôle cette fréquence. Le réglage 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 à un intervalle différent. Par exemple, le régler sur 4 journalisera les prédictions de chaque quatrième lot.

import os

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

Link to this sectionDésactivation de la journalisation de la matrice de confusion#

Dans certains cas, tu pourrais ne pas vouloir journaliser la matrice de confusion de ton ensemble de validation après chaque époque. Tu peux désactiver cette fonctionnalité en réglant 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"

Link to this sectionMode en ligne et hors ligne#

Par défaut, Comet fonctionne en mode en ligne et diffuse les données de l'expérience vers les serveurs Comet. Si tu dois t'entraîner sans accès à Internet, règle 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échargées ultérieurement avec l'interface CLI comet upload.

import os

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

Link to this sectionNom du projet#

Par défaut, le rappel Comet transmet l'argument d'entraînement project de YOLO à Comet (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 cela par COMET_PROJECT_NAME pour envoyer toutes les expériences vers un projet d'espace de travail Comet spécifique, indépendamment de l'argument d'entraînement YOLO :

import os

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

Link to this sectionNom de l'artefact de modèle#

COMET_MODEL_NAME définit le nom que Comet enregistre pour l'artefact de modèle journalisé (par défaut Ultralytics). Utilise-le pour différencier les variantes de modèles dans un espace de travail partagé :

import os

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

Link to this sectionMise à l'échelle du score de confiance#

Les scores de confiance de détection sont émis dans la plage [0, 1], mais l'interface utilisateur de Comet les affiche par défaut sur une échelle de pourcentage. Le rappel multiplie chaque score par COMET_MAX_CONFIDENCE_SCORE (par défaut 100.0) avant la journalisation. Ajuste cela si tu préfères les probabilités brutes ou une échelle différente :

import os

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

Link to this sectionRésumé#

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

Explore la documentation officielle d'intégration de YOLOv8 avec Comet, qui s'applique également aux projets YOLO26.

De plus, si tu cherches à approfondir les applications pratiques de YOLO26, spécifiquement pour les tâches de segmentation d'image, ce guide détaillé sur le réglage fin de YOLO26 avec Comet offre des informations précieuses et des instructions étape par étape pour améliorer les performances de ton modèle.

Par ailleurs, pour explorer d'autres intégrations passionnantes avec Ultralytics, consulte la page du guide d'intégration, qui propose une mine de ressources et d'informations.

Link to this sectionFAQ#

Link to this sectionComment intégrer Comet avec Ultralytics YOLO26 pour l'entraînement ?#

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

1. Installe les paquets requis :

   pip install ultralytics comet_ml torch torchvision

2. Configure ta clé API Comet :

   export COMET_API_KEY=YOUR_API_KEY

3. Initialise ton projet Comet dans ton code Python :

   import comet_ml
   
   comet_ml.login(project_name="comet-example-yolo26-coco128")

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 des instructions plus détaillées, reporte-toi à la section de configuration de Comet.

Link to this sectionQuels sont les avantages d'utiliser Comet avec YOLO26 ?#

En intégrant Ultralytics YOLO26 avec Comet, tu peux :

• Surveiller des informations en temps réel : Obtiens un retour instantané sur tes résultats d'entraînement, permettant des ajustements rapides.
• Journaliser des métriques étendues : Capture automatiquement les métriques essentielles telles que le mAP, la perte, les hyperparamètres et les points de contrôle du modèle.
• Suivre les expériences hors ligne : Journalise tes exécutions d'entraînement localement lorsqu'un accès à Internet est indisponible.
• Comparer différentes exécutions d'entraînement : Utilise le tableau de bord interactif de Comet pour analyser et comparer plusieurs expériences.

En tirant parti de ces fonctionnalités, tu peux optimiser tes flux de travail de machine learning pour une meilleure performance et reproductibilité. Pour plus d'informations, visite le guide d'intégration de Comet.

Link to this sectionComment personnaliser le comportement de journalisation de Comet pendant l'entraînement YOLO26 ?#

Comet permet une personnalisation étendue de son comportement de journalisation à l'aide de variables d'environnement :

• Change le nombre de prédictions d'images journalisées :

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

• Ajuste l'intervalle de journalisation par lot :

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

• Désactive la journalisation de la matrice de confusion :

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

• Définis le nom du projet Comet :

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

• Définis le nom de l'artefact de modèle journalisé :

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

Consulte la section Personnalisation de la journalisation Comet pour la liste complète, y compris les bascules de prédiction d'images, la mise à l'échelle du score de confiance et le mode en ligne/hors ligne.

Link to this sectionComment visualiser des métriques détaillées et des visualisations de mon entraînement YOLO26 sur Comet ?#

Une fois que ton modèle YOLO26 commence l'entraînement, tu peux accéder à un large éventail de métriques et de visualisations sur le tableau de bord Comet. Les fonctionnalités clés incluent :

• Panneaux d'expérience : Visualise différentes exécutions et leurs métriques, y compris la perte de masque de segmentation, la perte de classe et la précision moyenne.
• Métriques : Examine les métriques dans un format tabulaire pour une analyse détaillée.
• Matrice de confusion interactive : Évalue la précision de classification avec 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 un aperçu détaillé de ces fonctionnalités, visite la section Comprendre les performances de ton modèle avec les visualisations Comet.

Link to this sectionPuis-je utiliser Comet pour la journalisation hors ligne lors de l'entraînement de modèles YOLO26 ?#

Oui. Règle COMET_START_ONLINE=0 avant le début de l'entraînement pour journaliser 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échargées vers Comet ultérieurement avec l'interface CLI comet upload lorsque la connectivité est disponible. L'ancienne variable COMET_MODE="offline" fonctionne toujours mais émet un avertissement d'obsolescence. Pour plus de détails, consulte la section Mode en ligne et hors ligne.