YOLOv5 con Comet#

Questa guida illustra come utilizzare YOLOv5 con Comet, uno strumento potente per monitorare, confrontare e ottimizzare gli esperimenti di machine learning.

Informazioni su Comet#

Comet sviluppa strumenti che aiutano data scientist, ingegneri e responsabili dei team ad accelerare e ottimizzare i modelli di machine learning e deep learning.

Monitora e visualizza le metriche del modello in tempo reale, salva gli iperparametri, i dataset e i checkpoint del modello e visualizza le predizioni del modello con i Comet Custom Panels! Comet ti assicura di non perdere mai traccia del tuo lavoro e semplifica la condivisione dei risultati e la collaborazione tra team di qualsiasi dimensione!

Per iniziare#

Installa Comet#

pip install comet_ml

Configura le credenziali di Comet#

Esistono due modi per configurare Comet con YOLOv5.

Puoi impostare le credenziali tramite variabili d'ambiente:

Variabili d'ambiente

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

Oppure crea un file .comet.config nella directory di lavoro e imposta lì le credenziali:

File di configurazione di Comet

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

Esegui lo script di addestramento#

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

Tutto qui! Comet registrerà automaticamente gli iperparametri, gli argomenti della riga di comando e le metriche di addestramento e convalida. Puoi visualizzare e analizzare le tue esecuzioni nell'interfaccia di Comet.

Prova un esempio!#

Guarda un esempio di esecuzione completata qui.

O, ancora meglio, provalo tu stesso in questo notebook Colab:

Registra automaticamente#

Per impostazione predefinita, Comet registrerà i seguenti elementi:

Metriche#

• Perdita delle box, perdita degli oggetti e perdita di classificazione per i dati di convalida
• Metriche mAP_0.5 e mAP_0.5:0.95 per i dati di convalida
• Precision e Recall per i dati di convalida

Parametri#

• Iperparametri del modello
• Tutti i parametri passati tramite le opzioni della riga di comando

Visualizzazioni#

• Matrice di confusione delle predizioni del modello sui dati di convalida
• Grafici delle curve PR e F1 per tutte le classi
• Correlogramma delle etichette delle classi

Configura la registrazione di Comet#

Comet può essere configurato per registrare dati aggiuntivi tramite flag della riga di comando passati allo script di addestramento oppure tramite variabili d'ambiente:

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

Registra i checkpoint con Comet#

La registrazione dei modelli in Comet è disabilitata per impostazione predefinita. Per abilitarla, passa l'argomento save-period allo script di addestramento. In questo modo i checkpoint registrati verranno salvati in Comet in base al valore dell'intervallo fornito da save-period:

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

Registra le predizioni del modello#

Per impostazione predefinita, le predizioni del modello (immagini, etichette della verità a terra e riquadri di delimitazione) verranno registrate in Comet.

Puoi controllare la frequenza delle predizioni registrate e delle immagini associate passando l'argomento della riga di comando bbox_interval. Le predizioni possono essere visualizzate utilizzando il Custom Panel Object Detection di Comet. Questa frequenza corrisponde a ogni N-esimo batch di dati per epoca. Nell'esempio seguente, registriamo ogni 2° batch di dati per ciascuna epoca.

Nota: il dataloader di convalida di YOLOv5 utilizza per impostazione predefinita una dimensione del batch pari a 32, quindi dovrai impostare di conseguenza la frequenza di registrazione.

Ecco un progetto di esempio che utilizza il Panel

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

Controlla il numero di immagini delle predizioni registrate in Comet#

Quando registra le predizioni da YOLOv5, Comet registrerà le immagini associate a ogni set di predizioni. Per impostazione predefinita, vengono registrate al massimo 100 immagini di convalida. Puoi aumentare o diminuire questo numero utilizzando la variabile d'ambiente 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

Registra le metriche a livello di classe#

Utilizza la variabile d'ambiente COMET_LOG_PER_CLASS_METRICS per registrare mAP, precision, recall e f1 per ogni classe:

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

Carica un dataset negli Artifact di Comet#

Se desideri archiviare i tuoi dati utilizzando gli Artifact di Comet, puoi farlo usando il flag upload_dataset.

Il dataset deve essere organizzato come descritto nella documentazione di YOLOv5. Il file di configurazione del dataset yaml deve avere lo stesso formato del file coco128.yaml.

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

Puoi trovare il dataset caricato nella scheda Artifact del tuo Workspace di Comet:

Puoi visualizzare un'anteprima dei dati direttamente nell'interfaccia di Comet:

Gli Artifact sono sottoposti a versionamento e supportano anche l'aggiunta di metadati sul dataset. Comet registrerà automaticamente i metadati dal file yaml del tuo dataset:

Utilizza un Artifact salvato#

Se desideri utilizzare un dataset dagli Artifact di Comet, imposta la variabile path nel file yaml del dataset affinché punti al seguente URL della risorsa Artifact:

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

Quindi passa questo file allo script di addestramento nel modo seguente:

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

Gli Artifact ti consentono anche di monitorare la derivazione dei dati mentre attraversano il tuo workflow di sperimentazione. Qui puoi vedere un grafico che mostra tutti gli esperimenti che hanno utilizzato il dataset caricato:

Riprendi un'esecuzione di addestramento#

Se la tua esecuzione di addestramento viene interrotta per qualsiasi motivo, ad esempio a causa di una connessione Internet instabile, puoi riprenderla utilizzando il flag resume e il Run Path di Comet.

Il Run Path ha il seguente formato: comet://WORKSPACE_NAME/PROJECT_NAME/EXPERIMENT_ID.

In questo modo l'esecuzione verrà ripristinata allo stato precedente all'interruzione, incluso il ripristino del modello da un checkpoint, di tutti gli iperparametri e degli argomenti di addestramento e il download degli Artifact del dataset di Comet, se utilizzati nell'esecuzione originale. L'esecuzione ripresa continuerà a registrare dati nell'Experiment esistente nell'interfaccia di Comet:

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

Ricerca degli iperparametri con Comet Optimizer#

YOLOv5 è inoltre integrato con Comet Optimizer, semplificando la visualizzazione delle scansioni degli iperparametri nell'interfaccia di Comet.

Configura una scansione dell'Optimizer#

Per configurare Comet Optimizer, dovrai creare un file JSON con le informazioni sulla scansione. Un file di esempio è disponibile in utils/loggers/comet/optimizer_config.json:

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

Lo script hpo.py accetta gli stessi argomenti di train.py. Se desideri passare argomenti aggiuntivi alla scansione, aggiungili semplicemente dopo lo script:

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

Visualizza i risultati#

Comet offre diversi modi per visualizzare i risultati della scansione. Dai un'occhiata a un progetto con una scansione completata qui.