Comment utiliser Ultralytics YOLOv5 avec Comet

Chez Ultralytics, nous collaborons commercialement avec d'autres startups pour nous aider à financer la recherche et le développement de nos excellents outils open source, comme YOLOv5, afin de les maintenir gratuits pour tout le monde. Cet article peut contenir des liens affiliés vers ces partenaires.

Notre nouveau partenaire, Comet, développe des outils qui aident les data scientists, les ingénieurs et les responsables d’équipe à accélérer et à optimiser les modèles de machine learning et de deep learning.

Comet est un outil puissant pour suivre tes modèles, tes jeux de données et tes métriques. Il journalise également les variables système et d’environnement afin de garantir la reproductibilité et de faciliter le débogage de chaque exécution. C’est comme avoir un assistant virtuel qui sait comme par magie quelles notes conserver. Suis et visualise les métriques de tes modèles en temps réel, enregistre tes hyperparamètres, tes jeux de données et tes checkpoints de modèles, puis visualise les prédictions de tes modèles avec les panneaux personnalisés de Comet !

De plus, Comet veille à ce que tu ne perdes jamais le fil de ton travail et facilite le partage des résultats ainsi que la collaboration entre des équipes de toutes tailles !

YOLOv5 est un excellent point de départ pour te lancer dans la vision par ordinateur. Pour améliorer les performances de ton modèle et le préparer à la mise en production, tu devras journaliser les résultats dans un outil de suivi des expériences comme Comet.

L’intégration de Comet et YOLOv5 offre 3 fonctionnalités principales :

• Fonctionnalités de journalisation automatique et personnalisée
• Enregistrement des jeux de données et des modèles en tant qu’artefacts pour le débogage et la reproductibilité
• Organisation de ta vue avec les panneaux personnalisés de Comet

Ce guide explique comment utiliser YOLOv5 avec Comet.

Alors, prêt à suivre tes expériences en temps réel ? Commençons !

Premiers pas#

1. Installer Comet#

pip install comet_ml

2. Configurer les identifiants Comet#

Il existe deux façons de configurer Comet avec YOLOv5.

Tu peux définir tes identifiants via des variables d’environnement ou créer un fichier .comet.config dans ton répertoire de travail et y définir tes identifiants.

Variables d’environnement#

export COMET_API_KEY=<Your API Key>
export COMET_PROJECT_NAME=<Your Comet Project Name> # This will default to 'yolov5'

Fichier de configuration Comet#

[comet]
api_key=<Your API Key>
project_name=<Your Comet Project Name> # This will default to 'yolov5'

3. Exécuter le script d’entraînement#

# Train YOLOv5s on COCO128 for 5 epochs
python train.py --img 640 --batch 16 --epochs 5 --data coco128.yaml --weights yolov5s.pt

C’est tout !

Comet journalisera automatiquement tes hyperparamètres, tes arguments de ligne de commande, ainsi que tes métriques d’entraînement et de validation. Tu peux visualiser et analyser tes exécutions dans l’interface Comet.

Essaie par toi-même !#

Consulte un exemple d’exécution terminée ici.

Ou mieux encore, essaie par toi-même dans ce notebook Colab.

Journalisation automatique#

Par défaut, Comet journalise les éléments suivants :

Métriques#

• Les pertes de boîtes, d’objets et de classification pour les données d’entraînement et de validation
• Les métriques mAP_0.5 et mAP_0.5:0.95 pour les données de validation
• La précision et le rappel pour les données de validation

Paramètres#

• Hyperparamètres du modèle
• Tous les paramètres transmis via les options de ligne de commande

Visualisations#

• Matrice de confusion des prédictions du modèle sur les données de validation
• Graphiques des courbes PR et F1 pour toutes les classes
• Corrélogramme des étiquettes de classe

Configurer la journalisation Comet#

Comet peut être configuré pour journaliser des données supplémentaires via des indicateurs de ligne de commande transmis au script d’entraînement ou via des variables d’environnement.

export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
export COMET_MODEL_NAME=<your model name> # Set the name for the saved model. Defaults to yolov5
export COMET_LOG_CONFUSION_MATRIX=false # Set to disable logging a Comet Confusion Matrix. Defaults to true
export COMET_MAX_IMAGE_UPLOADS=<number of allowed images to upload to Comet> # Controls how many total image predictions to log to Comet. Defaults to 100.
export COMET_LOG_PER_CLASS_METRICS=true # Set to log evaluation metrics for each detected class at the end of training. Defaults to false
export COMET_DEFAULT_CHECKPOINT_FILENAME=<your checkpoint filename> # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
export COMET_LOG_BATCH_LEVEL_METRICS=true # Set this if you would like to log training metrics at the batch level. Defaults to false.
export COMET_LOG_PREDICTIONS=true # Set this to false to disable logging model predictions

Journaliser les checkpoints avec Comet#

La journalisation des modèles dans Comet est désactivée par défaut. Pour l’activer, transmets l’argument save-period au script d’entraînement. Les checkpoints journalisés seront alors enregistrés dans Comet selon l’intervalle indiqué par save-period.

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --save-period 1

Journaliser les prédictions du modèle#

Par défaut, les prédictions du modèle (images, étiquettes de vérité terrain et BBox) sont journalisées dans Comet. Tu peux contrôler la fréquence des prédictions journalisées et des images associées en transmettant l’argument de ligne de commande bbox_interval. Les prédictions peuvent être visualisées à l’aide du panneau personnalisé de détection d’objets de Comet. Cette fréquence correspond à chaque Nᵉ lot de données par époque. Dans l’exemple ci-dessous, nous journalisons un lot de données sur deux pour chaque époque.

Remarque : le chargeur de données de validation YOLOv5 utilise par défaut une taille de lot de 32 ; tu devras donc définir la fréquence de journalisation en conséquence.

Voici un exemple de projet utilisant le panneau.

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --bbox_interval 2

Contrôler le nombre d’images de prédictions journalisées dans Comet#

Lors de la journalisation des prédictions de YOLOv5, Comet journalise les images associées à chaque ensemble de prédictions. Par défaut, 100 images de validation au maximum sont journalisées. Tu peux augmenter ou réduire ce nombre à l’aide de la variable d’environnement COMET_MAX_IMAGE_UPLOADS.

env COMET_MAX_IMAGE_UPLOADS=200 python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --bbox_interval 1

Journaliser les métriques par classe#

Utilise la variable d’environnement COMET_LOG_PER_CLASS_METRICS pour journaliser la mAP, la précision, le rappel et le f1 pour chaque classe.

env COMET_LOG_PER_CLASS_METRICS=true python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt

Importer un jeu de données dans les artefacts Comet#

Si tu souhaites stocker tes données à l’aide des artefacts Comet, tu peux le faire avec l’indicateur upload_dataset.

Le jeu de données est organisé comme décrit dans la documentation YOLOv5. Le fichier yaml de configuration du jeu de données doit respecter le même format que le fichier coco128.yaml.

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --upload_dataset

Tu trouveras le jeu de données importé dans l’onglet Artifacts de ton espace de travail Comet.

Tu peux prévisualiser les données directement dans l’interface Comet.

Les artefacts sont versionnés et permettent également d’ajouter des métadonnées sur le jeu de données. Comet journalisera automatiquement les métadonnées de ton fichier yaml de jeu de données.

Utiliser un artefact enregistré#

Si tu veux utiliser un jeu de données provenant des artefacts Comet, définis la variable path de ton fichier yaml de jeu de données pour qu’elle pointe vers l’URL de ressource Artifact suivante.

# contents of artifact.yaml file
path: "comet://<workspace name>/<artifact name>:<artifact version or alias>"

Transmets ensuite ce fichier à ton script d’entraînement comme suit :

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data artifact.yaml \
  --weights yolov5s.pt

Les artefacts te permettent également de suivre la lignée des données à mesure qu’elles évoluent dans ton workflow d’expérimentation. Tu peux voir ici un graphique qui présente toutes les expériences ayant utilisé ton jeu de données importé.

Reprendre une exécution d’entraînement#

Si ton exécution d’entraînement est interrompue pour quelque raison que ce soit, par exemple à cause d’une connexion Internet instable, tu peux la reprendre à l’aide de l’indicateur resume et du chemin d’exécution Comet.

Le chemin d’exécution suit le format suivant : comet://<your workspace name>/<your project name>/<experiment id>.

Cela restaurera l’exécution dans l’état où elle se trouvait avant l’interruption, notamment en restaurant le modèle depuis un checkpoint, tous les hyperparamètres et arguments d’entraînement, et en téléchargeant les artefacts de jeu de données Comet s’ils ont été utilisés lors de l’exécution initiale. L’exécution reprise continuera à être journalisée dans l’expérience existante de l’interface Comet.

python train.py \
  --resume "comet://<your run path>"

Recherche d’hyperparamètres avec l’Optimizer de Comet#

YOLOv5 est également intégré à l’Optimizer de Comet, ce qui simplifie la visualisation des balayages d’hyperparamètres dans l’interface Comet.

Configurer un balayage de l’Optimizer#

Pour configurer l’Optimizer de Comet, tu dois créer un fichier JSON contenant les informations relatives au balayage.

Un fichier d’exemple est fourni dans utils/loggers/comet/optimizer_config.json.

python utils/loggers/comet/hpo.py \
  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json"

Le script hpo.py accepte les mêmes arguments que train.py. Si tu souhaites transmettre des arguments supplémentaires à ton balayage, ajoute-les simplement après le script.

python utils/loggers/comet/hpo.py \
  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json" \
  --save-period 1 \
  --bbox_interval 1

Exécuter un balayage en parallèle#

comet optimizer -j <num_workers> utils/loggers/comet/hpo.py \
  utils/loggers/comet/optimizer_config.json

Comet offre de nombreuses façons de visualiser les résultats de ton balayage. Consulte un projet avec un balayage terminé ici :

Restons en contact#

Commence à utiliser notre intégration avec Comet pour gérer, visualiser et optimiser tes modèles YOLOv5, des exécutions d’entraînement au suivi en production.

Et bien sûr, rejoins la communauté Ultralytics, un espace où tu peux poser des questions et partager des conseils sur l’entraînement, la validation et le déploiement de YOLOv5.