Comment utiliser Ultralytics YOLOv5 avec Comet
Découvre comment Ultralytics s'associe à Comet pour l'optimisation des modèles Ultralytics YOLOv5 : suivi en temps réel, collaboration simplifiée et reproductibilité améliorée.
Chez Ultralytics, nous collaborons commercialement avec d'autres startups pour nous aider à financer la recherche et le développement de nos incroyables outils open-source, comme YOLOv5, afin de les garder gratuits pour tout le monde. Cet article peut contenir des liens d'affiliation vers ces partenaires.
Notre tout nouveau partenaire, Comet, conçoit des outils qui aident les data scientists, les ingénieurs et les chefs d'équipe à accélérer et optimiser leurs 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 enregistre même tes variables système et d'environnement pour garantir la reproductibilité et faciliter le débogage de chaque exécution. C'est comme avoir un assistant virtuel qui sait magiquement quelles notes conserver. Suis et visualise les métriques de tes modèles en temps réel, sauvegarde tes hyperparamètres, jeux de données et points de contrôle de modèle, et visualise les prédictions de ton modèle avec les Comet Custom Panels !
De plus, Comet te permet de ne jamais perdre le fil de ton travail et facilite le partage des résultats ainsi que la collaboration au sein d'équipes de toutes tailles !
YOLOv5 est un excellent point de départ pour ton parcours en vision par ordinateur. Pour améliorer les performances de ton modèle et le rendre prêt pour la production, tu devras consigner les résultats dans un outil de suivi d'expériences comme Comet.
L'intégration entre Comet et YOLOv5 offre 3 fonctionnalités principales :
- Fonctionnalités de journalisation automatique et personnalisée
- Sauvegarde de jeux de données et de 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 couvrira la manière d'utiliser YOLOv5 avec Comet.
Alors, prêt à suivre tes expériences en temps réel ? Commençons !
Link to this sectionDémarrage#
Link to this sectionInstalle Comet#
pip install comet_mlLink to this sectionConfigure les identifiants Comet#
Il existe deux manières de configurer Comet avec YOLOv5.
Tu peux soit définir tes identifiants via des variables d'environnement, soit créer un fichier .comet.config dans ton répertoire de travail et y définir tes identifiants.
Link to this sectionVariables d'environnement#
export COMET_API_KEY=<Your API Key>
export COMET_PROJECT_NAME=<Your Comet Project Name> # This will default to 'yolov5'Link to this sectionFichier de configuration Comet#
[comet]
api_key=<Your API Key>
project_name=<Your Comet Project Name> # This will default to 'yolov5'Link to this sectionExécute 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.ptC'est tout !
Comet enregistrera automatiquement tes hyperparamètres, les arguments de ligne de commande ainsi que les métriques d'entraînement et de validation. Tu peux visualiser et analyser tes exécutions dans l'interface utilisateur de Comet.
Link to this sectionEssaie par toi-même !#
Découvre un exemple d'une exécution terminée ici.
Ou mieux encore, essaie par toi-même dans ce Notebook Colab.
Link to this sectionJournalisation automatique#
Par défaut, Comet enregistrera les éléments suivants :
Link to this sectionMétriques#
- Box Loss, Object Loss et Classification Loss pour les données d'entraînement et de validation
- Métriques mAP_0.5, mAP_0.5:0.95 pour les données de validation
- Précision et Rappel pour les données de validation
Link to this sectionParamètres#
- Hyperparamètres du modèle
- Tous les paramètres transmis via les options de ligne de commande
Link to this sectionVisualisations#
- Matrice de confusion des prédictions du modèle sur les données de validation
- Graphiques pour les courbes PR et F1 à travers toutes les classes
- Corrélogramme des étiquettes de classe
Link to this sectionConfigurer la journalisation Comet#
Comet peut être configuré pour enregistrer des données supplémentaires via des indicateurs de ligne de commande transmis au script d'entraînement ou 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 predictionsLink to this sectionEnregistrement des points de contrôle avec Comet#
L'enregistrement des modèles dans Comet est désactivé par défaut. Pour l'activer, transmets l'argument save-period au script d'entraînement. Cela enregistrera les points de contrôle consignés dans Comet en fonction de la valeur d'intervalle fournie par save-period.
python train.py \
--img 640 \
--batch 16 \
--epochs 5 \
--data coco128.yaml \
--weights yolov5s.pt \
--save-period 1Link to this sectionEnregistrement des prédictions du modèle#
Par défaut, les prédictions du modèle (images, étiquettes de vérité terrain et boîtes englobantes) seront enregistrées dans Comet. Tu peux contrôler la fréquence des prédictions enregistrées et des images associées en transmettant l'argument de ligne de commande bbox_interval. Les prédictions peuvent être visualisées en utilisant le panneau personnalisé de détection d'objets de Comet. Cette fréquence correspond à chaque N-ième lot de données par époque. Dans l'exemple ci-dessous, nous enregistrons chaque 2ème lot de données pour chaque époque.
Remarque : Le chargeur de données de validation YOLOv5 utilisera par défaut une taille de lot de 32, tu devras donc définir la fréquence d'enregistrement 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 2Link to this sectionContrôler le nombre d'images de prédiction enregistrées dans Comet#
Lors de l'enregistrement des prédictions à partir de YOLOv5, Comet enregistrera les images associées à chaque ensemble de prédictions. Par défaut, un maximum de 100 images de validation sont enregistrées. Tu peux augmenter ou diminuer ce nombre en utilisant 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 1Link to this sectionEnregistrement des métriques au niveau de la classe#
Utilise la variable d'environnement COMET_LOG_PER_CLASS_METRICS pour enregistrer 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.ptLink to this sectionCharger un jeu de données vers les Artefacts Comet#
Si tu souhaites stocker tes données en utilisant les Artefacts Comet, tu peux le faire en utilisant l'indicateur upload_dataset.
Le jeu de données est organisé de la manière décrite dans la documentation YOLOv5. Le fichier yaml de configuration du jeu de données doit suivre 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_datasetTu peux trouver le jeu de données téléchargé dans l'onglet Artefacts de ton Espace de travail Comet
Tu peux prévisualiser les données directement dans l'interface utilisateur de Comet.
Les artefacts sont versionnés et prennent également en charge l'ajout de métadonnées sur le jeu de données. Comet enregistrera automatiquement les métadonnées de ton fichier yaml de jeu de données.
Link to this sectionUtiliser un artefact sauvegardé#
Si tu veux utiliser un jeu de données provenant des Artefacts Comet, définis la variable path dans ton fichier yaml de jeu de données pour pointer vers l'URL de ressource Artefact suivante.
# contents of artifact.yaml file
path: "comet://<workspace name>/<artifact name>:<artifact version or alias>"Ensuite, transmets ce fichier à ton script d'entraînement de la manière suivante :
python train.py \
--img 640 \
--batch 16 \
--epochs 5 \
--data artifact.yaml \
--weights yolov5s.ptLes artefacts te permettent également de suivre la lignée des données au fur et à mesure qu'elles circulent dans ton flux de travail d'expérimentation. Ici, tu peux voir un graphique qui te montre toutes les expériences ayant utilisé ton jeu de données téléchargé.
Link to this sectionReprendre une exécution d'entraînement#
Si ton exécution d'entraînement est interrompue pour une raison quelconque, par exemple une connexion internet perturbée, tu peux reprendre l'exécution en utilisant l'indicateur resume et le chemin d'exécution Comet (Run Path).
Le chemin d'exécution (Run Path) suit le format suivant comet://<your workspace name>/<your project name>/<experiment id>.
Cela restaurera l'exécution dans son état avant l'interruption, ce qui inclut la restauration du modèle à partir d'un point de contrôle, la restauration de tous les hyperparamètres et arguments d'entraînement, et le téléchargement des artefacts de jeu de données Comet s'ils étaient utilisés dans l'exécution originale. L'exécution reprise continuera à se journaliser dans l'expérience existante dans l'interface utilisateur de Comet.
python train.py \
--resume "comet://<your run path>"Link to this sectionRecherche d'hyperparamètres avec l'optimiseur Comet#
YOLOv5 est également intégré à l'optimiseur de Comet, ce qui facilite la visualisation des balayages (sweeps) d'hyperparamètres dans l'interface utilisateur de Comet.
Link to this sectionConfigurer un balayage d'optimiseur#
Pour configurer l'optimiseur Comet, tu devras créer un fichier JSON avec les informations sur le balayage.
Un fichier d'exemple a été 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 1Link to this sectionExécuter un balayage en parallèle#
comet optimizer -j <num_workers> utils/loggers/comet/hpo.py \
utils/loggers/comet/optimizer_config.jsonComet propose de nombreuses façons de visualiser les résultats de ton balayage. Jette un œil à un projet avec un balayage terminé ici :
Link to this sectionReste en contact#
Commence à utiliser notre intégration avec Comet pour gérer, visualiser et optimiser tes modèles YOLOv5, depuis les exécutions d'entraînement jusqu'à la surveillance en production.
Et, bien sûr, rejoins la Communauté Ultralytics – un endroit pour poser des questions et partager des astuces sur l'entraînement, la validation et le déploiement avec YOLOv5.
