Link to this sectionAméliorer l'entraînement avec 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 insights en temps réel, la journalisation personnalisée et l'utilisation hors ligne, en veillant à ce que ton entraînement YOLO26 soit minutieusement documenté et optimisé pour des résultats exceptionnels.

Link to this sectionComet#

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 des métriques, des paramètres, des 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 facilite le développement de modèles de production.

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

En combinant Ultralytics YOLO26 avec Comet, tu débloques une série d'avantages. Ceux-ci incluent une gestion simplifiée des expériences, des insights en temps réel pour des ajustements rapides, des options de journalisation flexibles et personnalisées, ainsi que la capacité de journaliser des 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'atteindre des résultats exceptionnels.

Link to this sectionInstallation#

Pour installer les packages 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 packages 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 peux 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 d'entrer ta clé API pour l'initialisation.

Link to this sectionUtilisation#

Avant de 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 besoins 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 automatiquement l'exécution. Tu recevras ensuite un lien pour voir 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 de 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 l'endroit où toute l'action se déroule, 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.

Métriques

Dans la section des métriques, tu as également l'option 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, fournit 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 tout goulot 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 que l'entraînement ne commence) :

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 modifier ce nombre pour mieux répondre à tes exigences. 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 lots#

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 s'exécute en mode en ligne et diffuse les données d'expérience vers les serveurs Comet. Si tu as besoin de t'entraîner sans accès à Internet, règle COMET_START_ONLINE=0 avant que l'entraînement ne commence. Les données d'expérience sont enregistrées localement et peuvent être téléchargées ultérieurement avec le 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 ton espace de travail par défaut). Remplace cela avec 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 Comet les affiche sur une échelle de pourcentage par défaut. 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é à travers l'intégration de Comet avec le YOLO26 d'Ultralytics. De l'installation à la personnalisation, tu as appris à rationaliser la gestion des expériences, à obtenir des insights en temps réel et à adapter la journalisation aux besoins de ton projet.

Explore la documentation officielle de l'intégration YOLOv8 de 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 fine-tuning de YOLO26 avec Comet offre des insights précieux et des instructions étape par étape pour améliorer les performances de ton modèle.

De plus, pour explorer d'autres intégrations passionnantes avec Ultralytics, consulte la page du guide d'intégration, qui offre 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 packages 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, réfère-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 insights 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 lorsque l'accès à Internet n'est pas disponible.
• 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 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 en utilisant des variables d'environnement :

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

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

• Ajuste l'intervalle de journalisation des lots :

  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 enregistré :

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

Consulte la section Personnalisation de la journalisation Comet pour obtenir la liste complète, y compris les options d'activation des prédictions d'image, la mise à l'échelle des scores de confiance et le mode en ligne/hors ligne.

Link to this sectionComment puis-je visualiser les métriques détaillées et les 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, notamment la perte de masque de segmentation, la perte de classe et la précision moyenne.
• Métriques : Examine les métriques sous forme de tableau pour une analyse détaillée.
• Matrice de confusion interactive : Évalue la précision de la 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 des modèles YOLO26 ?#

Oui. Définis COMET_START_ONLINE=0 avant le début de l'entraînement pour enregistrer localement :

import os

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

Les données d'expérience sont enregistrées sur le disque et peuvent être téléchargées sur Comet plus tard avec l'interface CLI comet upload lorsque la connectivité est disponible. L'ancienne variable COMET_MODE="offline" fonctionne toujours mais émet un avertissement de dépréciation. Pour plus de détails, consulte la section Mode en ligne et hors ligne.