YOLOv5 avec Comet#

Ce guide explique comment utiliser YOLOv5 avec Comet, un outil puissant pour suivre, comparer et optimiser les expériences d’apprentissage automatique.

À propos de Comet#

Comet crée des outils qui aident les spécialistes des données, les ingénieurs et les responsables d’équipe à accélérer et à optimiser les modèles d’apprentissage automatique et d’apprentissage profond.

Suis et visualise les métriques de ton modèle en temps réel, enregistre tes hyperparamètres, tes jeux de données et tes points de contrôle de modèle, et visualise les prédictions de ton modèle avec les panneaux personnalisés de Comet ! Comet veille à ce que tu ne perdes jamais le fil de ton travail et facilite le partage des résultats et la collaboration entre équipes de toutes tailles !

Premiers pas#

Installer Comet#

pip install comet_ml

Configurer les identifiants Comet#

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

Tu peux définir tes identifiants à l’aide de 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'

Tu peux aussi 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'

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

Et voilà ! Comet enregistrera automatiquement tes hyperparamètres, les arguments de la 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 Comet.

Essaie un exemple !#

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

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

Enregistrement automatique#

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

Métriques#

• Pertes de boîte, de détection d’objet et de classification pour les données de validation
• Métriques mAP_0.5 et mAP_0.5:0.95 pour les données de validation
• Précision et rappel pour les données de validation

Paramètres#

• Hyperparamètres du modèle
• Tous les paramètres transmis via les options de la 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 enregistrer des données supplémentaires, soit au moyen d’options de ligne de commande transmises au script d’entraînement, soit au moyen de 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_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

Enregistrer les 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. Les points de contrôle 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

Enregistrer les prédictions du modèle#

Par défaut, les prédictions du modèle (images, étiquettes de vérité terrain et boîtes englobantes) sont enregistrées dans Comet.

Tu peux contrôler la fréquence d’enregistrement des prédictions et des images associées en transmettant l’argument de ligne de commande bbox_interval. Les prédictions peuvent être visualisées avec le panneau personnalisé Détection d’objets de Comet. Cette fréquence correspond à chaque Nième lot de données par époque. Dans l’exemple ci-dessous, nous enregistrons un lot de données sur deux pour chaque époque.

Remarque : le chargeur de données de validation de YOLOv5 utilise une taille de lot deux fois supérieure à celle de l’entraînement (32 pour --batch 16), tu devras donc régler 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

Contrôler le nombre d’images de prédiction enregistrées dans Comet#

Lorsque tu enregistres les prédictions de YOLOv5, Comet enregistre les images associées à chaque ensemble de prédictions. Par défaut, un maximum de 100 images de validation est enregistré. 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

Enregistrer les métriques par classe#

Utilise la variable d’environnement COMET_LOG_PER_CLASS_METRICS pour enregistrer la mAP, la précision, le rappel et le score F1 de chaque classe :

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

Téléverser un jeu de données dans les artefacts Comet#

Si tu souhaites stocker tes données dans les artefacts Comet, tu peux le faire à l’aide de l’option upload_dataset.

Le jeu de données doit être organisé comme indiqué dans la documentation de YOLOv5. Le fichier de configuration du jeu de données yaml 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 téléversé 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 enregistre automatiquement les métadonnées à partir du fichier de jeu de données yaml :

Utiliser un artefact enregistré#

Si tu souhaites utiliser un jeu de données provenant des artefacts Comet, définis la variable path dans le fichier de jeu de données yaml afin qu’elle pointe vers l’URL de ressource de l’artefact 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 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 des données au fil de ton processus d’expérimentation. Tu peux voir ici un graphe qui présente toutes les expériences ayant utilisé le jeu de données que tu as téléversé :

Reprendre un entraînement#

Si ton entraînement est interrompu pour une raison quelconque, par exemple à cause d'une connexion Internet instable, tu peux le reprendre à l'aide de l'option resume et du chemin d'exécution Comet.

Le chemin d'exécution a le format suivant : comet://WORKSPACE_NAME/PROJECT_NAME/EXPERIMENT_ID.

Cette opération rétablit l'état de l'exécution avant l'interruption. Elle restaure notamment le modèle à partir d'un point de contrôle, tous les hyperparamètres et arguments d'entraînement, et télécharge les artefacts de jeu de données Comet s'ils ont été utilisés lors de l'exécution initiale. L'exécution reprise continue à consigner les données dans l'expérience existante de l'interface Comet :

python train.py \
  --resume "comet://YOUR_RUN_PATH"

Recherche d'hyperparamètres avec l'optimiseur Comet#

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

Configurer un balayage de l'optimiseur#

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

Visualiser les résultats#

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

FAQ#