Link to this sectionYOLOv5 avec Comet#

Ce guide couvre la manière d'utiliser YOLOv5 avec Comet, un outil puissant pour suivre, comparer et optimiser tes expériences de machine learning.

Link to this sectionÀ propos de Comet#

Comet crée des outils qui aident les data scientists, les ingénieurs et les chefs d'équipe à accélérer et optimiser les modèles de machine learning et de deep learning.

Suis et visualise les métriques de tes modèles en temps réel, enregistre tes hyperparamètres, tes datasets et tes points de contrôle (checkpoints) de modèles, et visualise les prédictions de ton modèle avec les Comet Custom Panels ! Comet garantit que tu ne perdras jamais la trace de ton travail et facilite le partage des résultats ainsi que la collaboration au sein d'équipes de toutes tailles !

Link to this sectionDémarrage rapide#

Link to this sectionInstaller Comet#

pip install comet_ml

Link to this sectionConfigurer 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 :

Variables d'environnement

export COMET_API_KEY=YOUR_API_KEY
export COMET_PROJECT_NAME=YOUR_COMET_PROJECT_NAME # This will default to 'yolov5'

Soit créer un fichier .comet.config dans ton répertoire de travail et y définir tes identifiants :

Fichier de configuration Comet

[comet]
api_key=YOUR_API_KEY
project_name=YOUR_COMET_PROJECT_NAME # This will default to 'yolov5'

Link to this sectionExé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 enregistrera automatiquement tes hyperparamètres, tes arguments en 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 utilisateur de Comet.

Link to this sectionEssaie un exemple !#

Jette un œil à un exemple d'exécution terminée ici.

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

Link to this sectionEnregistrement automatique#

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

Link to this sectionMétriques#

• Perte de boîte (Box Loss), perte d'objet (Object Loss), perte de classification pour les données d'entraînement et les données 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 passés 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 sur 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, soit par des indicateurs de ligne de commande passés au script d'entraînement, soit par 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="yolov5"                   # 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=30                  # 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="last.pt" # 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

Link 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, passe l'argument save-period au script d'entraînement. Cela enregistrera les points de contrôle journalisés dans Comet selon l'intervalle fourni par save-period :

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

Link 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 les images associées en passant l'argument de ligne de commande bbox_interval. Les prédictions peuvent être visualisées en utilisant le panneau personnalisé Object Detection de Comet. Cette fréquence correspond à chaque Niè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 (dataloader) de validation de 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 2

Link to this sectionContrôler le nombre d'images de prédiction enregistrées dans Comet#

Lors de l'enregistrement des prédictions depuis 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 1

Link to this sectionEnregistrement des métriques par classe#

Utilise la variable d'environnement COMET_LOG_PER_CLASS_METRICS pour enregistrer le 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

Link to this sectionChargement d'un dataset vers Comet Artifacts#

Si tu souhaites stocker tes données en utilisant Comet Artifacts, tu peux le faire en utilisant l'indicateur upload_dataset.

Le dataset doit être organisé comme décrit dans la documentation YOLOv5. Le fichier de configuration yaml du dataset doit suivre le même format que celui du fichier coco128.yaml.

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

Tu peux trouver le dataset chargé 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 prennent également en charge l'ajout de métadonnées concernant le dataset. Comet enregistrera automatiquement les métadonnées de ton fichier yaml de dataset :

Link to this sectionUtiliser un artefact enregistré#

Si tu souhaites utiliser un dataset provenant de Comet Artifacts, définis la variable path dans ton fichier yaml de dataset pour qu'elle pointe vers l'URL de ressource d'artefact suivante :

# Contents of artifact.yaml file
path: "comet://WORKSPACE_NAME/ARTIFACT_NAME:ARTIFACT_VERSION_OR_ALIAS"

Ensuite, passe 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.pt

Les artefacts te permettent également de suivre la lignée (lineage) des données à 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 dataset 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 interrompue, tu peux reprendre l'exécution en utilisant l'indicateur resume et le chemin d'exécution Comet (Run Path).

The Run Path has the following format comet://WORKSPACE_NAME/PROJECT_NAME/EXPERIMENT_ID.

Cela restaurera l'exécution à 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 dataset Comet s'ils ont été utilisés lors de l'exécution d'origine. L'exécution reprise continuera à se journaliser dans l'expérience existante de l'interface 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 permet de visualiser simplement les balayages d'hyperparamètres dans l'interface Comet.

Link to this sectionConfigurer un balayage de l'optimiseur#

Pour configurer l'optimiseur Comet, tu devras créer un fichier JSON contenant les informations sur le balayage. Un exemple de fichier 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 passer 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

Link to this sectionVisualiser les résultats#

Comet offre plusieurs façons de visualiser les résultats de ton balayage. Jette un œil à un projet avec un balayage terminé ici.