Améliore ton entraînement YOLO26 : Simplifie ton processus de journalisation avec Comet#

L'enregistrement 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 essentiel en machine learning : cela garantit la transparence de ton projet, la mesure de tes progrès et la reproductibilité de tes résultats.

Ultralytics YOLO26 s'intègre de manière transparente 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 aborderons le processus d'installation, la configuration de Comet, les analyses en temps réel, l'enregistrement personnalisé et l'utilisation hors ligne, afin de garantir que ton entraînement YOLO26 soit minutieusement documenté et optimisé pour des résultats exceptionnels.

Comet#

Comet est une plateforme permettant de suivre, comparer, expliquer et optimiser des modèles et des expériences de machine learning. Elle te permet d'enregistrer des métriques, des paramètres, des médias et bien plus encore lors de 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 de production.

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

Installation#

Pour installer les paquets requis, exécute :

# Install YOLO26 and Comet
pip install ultralytics comet_ml

Configuration 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, authentifie-toi 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 te lancer dans les instructions d'utilisation, assure-toi de découvrir la gamme de YOLO26 models offered by Ultralytics. Cela t'aidera à choisir le modèle le plus 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 avoir exécuté le code d'entraînement, Comet créera automatiquement une expérience dans ton espace de travail Comet pour suivre l'exécution. Tu recevras ensuite un lien pour consulter l'historique détaillé du processus d'entraînement de ton modèle YOLO26.

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

Comprendre 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 ainsi que leurs métriques, telles que la perte du 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 Matrice de confusion, 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 points forts 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.

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

Pour les commutateurs booléens (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 (insensible à la casse). Toute autre valeur est 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 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 l'enregistrement des prédictions d'images (par exemple, pour réduire le volume de téléchargement sur des connexions lentes), définis COMET_EVAL_LOG_IMAGE_PREDICTIONS sur "false" :

import os

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

Intervalle de journalisation par lot#

Comet te permet de spécifier la fréquence d'enregistrement des lots de prédictions d'images. La variable d'environnement COMET_EVAL_BATCH_LOGGING_INTERVAL contrôle cette fréquence. Le paramètre par défaut est 1, ce qui enregistre les prédictions de chaque lot de validation. Tu peux ajuster cette valeur pour enregistrer les prédictions à un intervalle différent. Par exemple, la définir sur 4 enregistrera les prédictions de chaque quatrième lot.

import os

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

Désactivation de la journalisation de la matrice de confusion#

Dans certains cas, tu ne souhaites peut-être pas enregistrer 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 alors enregistré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 d'expérience vers les serveurs Comet. Si tu dois t'entraîner sans accès Internet, définis COMET_START_ONLINE=0 avant le début de l'entraînement. Les données d'expérience sont enregistrées localement et peuvent être téléchargées ultérieurement à l'aide de la CLI comet upload.

import os

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

Nom du projet#

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

Mise à 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 par défaut sur une échelle en pourcentage. Le rappel multiplie chaque score par COMET_MAX_CONFIDENCE_SCORE (par défaut 100.0) avant l'enregistrement. Ajuste ce paramètre si tu préfères des probabilités brutes ou une échelle différente :

import os

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

Ré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.

Consulte 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, en particulier pour les tâches de segmentation d'images, ce guide détaillé sur l'affinage de YOLO26 avec Comet offre des informations précieuses et des instructions étape par étape pour améliorer les performances de ton modèle.

En outre, pour explorer d'autres intégrations passionnantes avec Ultralytics, consulte la page du guide d'intégration, qui offre une multitude de ressources et d'informations.

FAQ#