YOLOv5 con Comet#

Questa guida spiega come usare YOLOv5 con Comet, un potente strumento per monitorare, confrontare e ottimizzare gli esperimenti di machine learning.

Informazioni su Comet#

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

Monitora e visualizza in tempo reale le metriche del modello, salva gli iperparametri, i dataset e i checkpoint del modello e visualizza le previsioni del modello con i pannelli personalizzati di Comet! Comet ti aiuta a tenere 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'

In alternativa, crea un file .comet.config nella directory di lavoro e inserisci 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

Ecco fatto! 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!#

Dai un'occhiata a un esempio di esecuzione completata.

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

Registrazione automatica#

Per impostazione predefinita, Comet registra i seguenti elementi:

Metriche#

• Perdita del riquadro, perdita di rilevamento degli oggetti e perdita di classificazione per i dati di addestramento e di convalida
• Metriche mAP_0.5 e mAP_0.5:0.95 per i dati di convalida
• Precisione e richiamo 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 previsioni 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#

Puoi configurare Comet per registrare altri dati 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_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

Registrazione dei checkpoint con Comet#

La registrazione dei modelli su Comet è disabilitata per impostazione predefinita. Per abilitarla, passa l'argomento save-period allo script di addestramento. I checkpoint registrati verranno salvati su Comet secondo l'intervallo specificato da save-period:

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

Registrazione delle previsioni del modello#

Per impostazione predefinita, le previsioni del modello (immagini, etichette di riferimento e riquadri di delimitazione) vengono registrate su Comet.

Puoi controllare la frequenza di registrazione delle previsioni e delle immagini associate passando l'argomento della riga di comando bbox_interval. Puoi visualizzare le previsioni nel pannello personalizzato Rilevamento di oggetti di Comet. Questa frequenza corrisponde a ogni N-esimo batch di dati per epoca. Nell'esempio seguente registriamo un batch di dati ogni 2 per ciascuna epoca.

Nota: il dataloader di convalida di YOLOv5 usa un batch size doppio rispetto a quello di addestramento (32 per --batch 16), quindi dovrai impostare di conseguenza la frequenza di registrazione.

Ecco un progetto di esempio che usa il pannello

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

Controllare il numero di immagini delle previsioni registrate su Comet#

Quando registri le previsioni di YOLOv5, Comet registra le immagini associate a ciascun insieme di previsioni. Per impostazione predefinita, vengono registrate al massimo 100 immagini di convalida. Puoi aumentare o diminuire questo numero usando 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

Registrazione delle metriche per classe#

Usa la variabile d'ambiente COMET_LOG_PER_CLASS_METRICS per registrare mAP, precisione, richiamo 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

Caricare un dataset negli artifact di Comet#

Se vuoi archiviare i tuoi dati usando gli artifact di Comet, puoi farlo con il flag upload_dataset.

Il dataset deve essere organizzato come descritto nella documentazione di YOLOv5. Il file di configurazione del dataset yaml deve rispettare 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 Artifacts del tuo spazio di lavoro Comet:

Puoi visualizzare in anteprima i dati direttamente nell'interfaccia di Comet:

Gli artifact sono versionati e consentono anche di aggiungere metadati sul dataset. Comet registra automaticamente i metadati dal file del dataset yaml:

Usare un artifact salvato#

Se vuoi usare un dataset dagli artifact di Comet, imposta la variabile path nel file del dataset yaml in modo che punti al seguente URL della risorsa Artifact:

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

Poi 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 consentono anche di monitorare la provenienza dei dati mentre attraversano il flusso di lavoro di sperimentazione. Qui puoi vedere un grafico con tutti gli esperimenti che hanno usato il dataset caricato:

Riprendere un'esecuzione di addestramento#

Se l'esecuzione di addestramento viene interrotta per qualsiasi motivo, ad esempio a causa di una connessione Internet instabile, puoi riprenderla usando il flag resume e il percorso dell'esecuzione di Comet.

Il percorso dell'esecuzione ha il seguente formato: comet://WORKSPACE_NAME/PROJECT_NAME/EXPERIMENT_ID.

In questo modo l'esecuzione tornerà allo stato precedente all'interruzione. Verranno ripristinati il modello da un checkpoint, tutti gli iperparametri e gli argomenti di addestramento, e gli artifact del dataset di Comet, se usati nell'esecuzione originale. L'esecuzione ripresa continuerà a registrare i dati nell'esperimento esistente nell'interfaccia utente di Comet:

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

Ricerca degli iperparametri con Comet Optimizer#

YOLOv5 è integrato anche con Comet's Optimizer, così puoi visualizzare facilmente le sweep degli iperparametri nell'interfaccia utente di Comet.

Configurare una sweep dell'ottimizzatore#

Per configurare Comet Optimizer, devi creare un file JSON con le informazioni sulla sweep. È disponibile un file di esempio 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 vuoi passare altri argomenti alla sweep, 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

Visualizzare i risultati#

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

Domande frequenti#