Addestra YOLOv5 su dati personalizzati#

📚 Questa guida spiega come addestrare il tuo dataset personalizzato utilizzando il modello YOLOv5 🚀. L'addestramento di modelli personalizzati è un passaggio fondamentale per adattare le soluzioni di visione artificiale ad applicazioni specifiche del mondo reale, oltre la generica rilevazione degli oggetti.

Prima di iniziare#

Per prima cosa, assicurati di aver configurato l'ambiente necessario. Clona il repository YOLOv5 e installa le dipendenze richieste da requirements.txt. È essenziale un ambiente Python>=3.8.0 con PyTorch>=1.8. I modelli e i dataset vengono scaricati automaticamente dall'ultima release di YOLOv5 se non vengono trovati localmente.

git clone https://github.com/ultralytics/yolov5 # Clone the repository
cd yolov5
pip install -r requirements.txt # Install dependencies

Addestramento su dati personalizzati#

Lo sviluppo di un modello personalizzato di rilevazione degli oggetti è un processo iterativo:

1. Raccogli e organizza le immagini: raccogli immagini pertinenti alla tua attività specifica. Dati di alta qualità e diversificati sono fondamentali. Consulta la nostra guida su Raccolta e annotazione dei dati.
2. Etichetta gli oggetti: annota con precisione gli oggetti di interesse nelle tue immagini.
3. Addestra un modello: usa i dati etichettati per addestrare il tuo modello YOLOv5. Sfrutta il transfer learning iniziando da pesi preaddestrati.
4. Distribuisci e fai previsioni: utilizza il modello addestrato per l'inferenza su dati nuovi e mai analizzati.
5. Raccogli i casi limite: individua gli scenari in cui il modello ha prestazioni scarse (casi limite) e aggiungi dati simili al tuo dataset per migliorarne la robustezza. Ripeti il ciclo.

Ultralytics Platform offre una soluzione semplificata e senza codice per l'intero ciclo di operazioni di machine learning (MLOps), inclusi la gestione dei dataset, l'addestramento dei modelli e la distribuzione.

Prima di avviare l'addestramento, è essenziale preparare il dataset.

1. Crea un dataset#

I modelli YOLOv5 richiedono dati etichettati per apprendere le caratteristiche visive delle classi di oggetti. Organizzare correttamente il dataset è fondamentale.

1.1 Crea dataset.yaml#

Il file di configurazione del dataset (ad esempio, coco128.yaml) descrive la struttura del dataset, i nomi delle classi e i percorsi delle directory delle immagini. COCO128 è un piccolo dataset di esempio composto dalle prime 128 immagini dell'ampio dataset COCO. È utile per testare rapidamente la pipeline di addestramento e diagnosticare potenziali problemi come l'overfitting.

La struttura del file dataset.yaml include:

• path: la directory radice che contiene il dataset.
• train, val, test: percorsi relativi da path alle directory contenenti immagini o file di testo che elencano i percorsi delle immagini per i set di addestramento, validazione e test.
• names: un dizionario che associa gli indici delle classi (a partire da 0) ai rispettivi nomi.

Puoi impostare path su una directory assoluta (ad esempio, /home/user/datasets/coco128) oppure su un percorso relativo come ../datasets/coco128 quando avvii l'addestramento dalla radice del repository YOLOv5.

Di seguito è riportata la struttura di coco128.yaml (visualizza su GitHub):

# Dataset root directory relative to the yolov5 directory
path: coco128

# Train/val/test sets: specify directories, *.txt files, or lists
train: images/train2017 # 128 images for training
val: images/train2017 # 128 images for validation
test: # Optional path to test images

# Classes (example using 80 COCO classes)
names:
    0: person
    1: bicycle
    2: car
    # ... (remaining COCO classes)
    77: teddy bear
    78: hair drier
    79: toothbrush

1.2 Sfrutta i modelli per l'etichettatura automatizzata#

L'etichettatura manuale è l'approccio più comune, ma richiede molto tempo. I foundation model possono automatizzare o semiautomatizzare l'annotazione e accelerare la creazione dei dataset. Ecco alcuni modelli che possono aiutare a generare le etichette:

• Google Gemini: i modelli multimodali di grandi dimensioni come Gemini offrono potenti funzionalità di comprensione delle immagini. Puoi fornire loro istruzioni per identificare e localizzare gli oggetti nelle immagini, generando bounding box o descrizioni che possono essere convertite in etichette nel formato YOLO. Esplora il loro potenziale nel notebook tutorial fornito.
• SAM2 (Segment Anything Model 2): i foundation model incentrati sulla segmentazione, come SAM2, possono identificare e delimitare gli oggetti con grande precisione. Sebbene siano destinati principalmente alla segmentazione, le maschere risultanti possono spesso essere convertite in annotazioni con bounding box adatte alle attività di rilevazione degli oggetti.
• YOLOWorld: questo modello offre funzionalità di rilevazione a vocabolario aperto. Puoi fornire descrizioni testuali degli oggetti di tuo interesse e YOLOWorld può localizzarli nelle immagini senza essere stato precedentemente addestrato su quelle classi specifiche. Può essere usato come punto di partenza per generare etichette iniziali, che possono poi essere perfezionate.

L'uso di questi modelli può fornire un passaggio di «pre-etichettatura», riducendo il lavoro manuale necessario. Tuttavia, è fondamentale esaminare e perfezionare le etichette generate automaticamente per garantirne accuratezza e coerenza, poiché la qualità influisce direttamente sulle prestazioni del modello YOLOv5 addestrato. Dopo aver generato e, se necessario, perfezionato le etichette, assicurati che rispettino il formato YOLO: un file *.txt per immagine, con ogni riga che rappresenta un oggetto come class_index x_center y_center width height (coordinate normalizzate, classe indicizzata a partire da zero). Se un'immagine non contiene oggetti di interesse, non è necessario alcun file *.txt corrispondente.

Le specifiche del file *.txt nel formato YOLO sono precise:

• Una riga per ogni bounding box.
• Ogni riga deve contenere: class_index x_center y_center width height.
• Le coordinate devono essere normalizzate in un intervallo compreso tra 0 e 1. Per farlo, dividi i valori dei pixel di x_center e width per la larghezza totale dell'immagine, quindi dividi y_center e height per l'altezza totale dell'immagine.
• Gli indici delle classi partono da zero (ovvero, la prima classe è rappresentata da 0, la seconda da 1 e così via).

Il file delle etichette corrispondente all'immagine sopra, contenente due oggetti «person» (indice di classe 0) e un oggetto «tie» (indice di classe 27), sarebbe simile al seguente:

1.3 Organizza le directory#

Struttura la directory dei tuoi dataset come illustrato di seguito. Per impostazione predefinita, YOLOv5 prevede che la directory del dataset (ad esempio, /coco128) si trovi all'interno di una cartella /datasets collocata accanto alla directory del repository /yolov5.

YOLOv5 individua automaticamente le etichette di ogni immagine sostituendo l'ultima occorrenza di /images/ nel percorso dell'immagine con /labels/. Ad esempio:

../datasets/coco128/images/im0.jpg # Path to the image file
../datasets/coco128/labels/im0.txt # Path to the corresponding label file

La struttura di directory consigliata è:

/datasets/
└── coco128/  # Dataset root
    ├── images/
    │   ├── train2017/  # Training images
    │   │   ├── 000000000009.jpg
    │   │   └── ...
    │   └── val2017/    # Validation images (optional if using same set for train/val)
    │       └── ...
    └── labels/
        ├── train2017/  # Training labels
        │   ├── 000000000009.txt
        │   └── ...
        └── val2017/    # Validation labels (optional if using same set for train/val)
            └── ...

2. Seleziona un modello#

Scegli un modello preaddestrato per avviare il processo di addestramento. Iniziare con pesi preaddestrati accelera notevolmente l'apprendimento e migliora le prestazioni rispetto all'addestramento da zero. YOLOv5 offre modelli di diverse dimensioni, ciascuno con un diverso compromesso tra velocità e accuratezza. Ad esempio, YOLOv5s è il secondo modello più piccolo e il più veloce, adatto agli ambienti con risorse limitate. Consulta la tabella del README per un confronto dettagliato di tutti i modelli disponibili.

3. Addestra#

Avvia l'addestramento del modello utilizzando lo script train.py. Gli argomenti essenziali includono:

• --img: definisce la dimensione dell'immagine di input (ad esempio, --img 640). Dimensioni maggiori generalmente producono una migliore accuratezza, ma richiedono più memoria GPU.
• --batch: determina la dimensione del batch (ad esempio, --batch 16). Scegli la dimensione più grande che la tua GPU è in grado di gestire.
• --epochs: specifica il numero totale di epoche di addestramento (ad esempio, --epochs 100). Un'epoca rappresenta un passaggio completo sull'intero dataset di addestramento.
• --data: percorso del file dataset.yaml (ad esempio, --data coco128.yaml).
• --weights: percorso del file dei pesi iniziali. L'uso di pesi preaddestrati (ad esempio, --weights yolov5s.pt) è altamente consigliato per una convergenza più rapida e risultati migliori. Per addestrare da zero (scelta sconsigliata a meno che tu non disponga di un dataset molto grande e di esigenze specifiche), usa --weights '' --cfg yolov5s.yaml.

I pesi preaddestrati vengono scaricati automaticamente dall'ultima release di YOLOv5 se non vengono trovati localmente.

# Example: Train YOLOv5s on the COCO128 dataset for 3 epochs
python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt

Tutti gli output dell'addestramento, inclusi i pesi e i log, vengono salvati nella directory runs/train/. Ogni sessione di addestramento crea una nuova sottodirectory (ad esempio, runs/train/exp, runs/train/exp2, ecc.). Per un'esperienza interattiva e pratica, esplora la sezione sull'addestramento nei nostri notebook ufficiali del tutorial:

4. Visualizza#

YOLOv5 si integra perfettamente con diversi strumenti per visualizzare l'avanzamento dell'addestramento, valutare i risultati e monitorare le prestazioni in tempo reale.

Logging e visualizzazione con Comet#

Comet è completamente integrato per un monitoraggio completo degli esperimenti. Visualizza le metriche in tempo reale, salva gli iperparametri, gestisci i dataset e i checkpoint dei modelli e analizza le previsioni del modello utilizzando i Comet Custom Panels interattivi.

Iniziare è semplice:

pip install comet_ml                                                          # 1. Install Comet library
export COMET_API_KEY=YOUR_API_KEY_HERE                                        # 2. Set your Comet API key (create a free account at Comet.ml)
python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. Train your model - Comet automatically logs everything!

Approfondisci le funzionalità supportate nella nostra Guida all'integrazione di Comet. Scopri di più sulle capacità di Comet nella loro documentazione ufficiale. Prova il notebook Colab di Comet per una demo dal vivo:

Logging e automazione con ClearML#

L'integrazione con ClearML consente un monitoraggio dettagliato degli esperimenti, la gestione delle versioni dei dataset e persino l'esecuzione remota delle sessioni di addestramento. Attiva ClearML con questi semplici passaggi:

• Installa il pacchetto: pip install clearml
• Inizializza ClearML: esegui una volta clearml-init per connetterti al tuo server ClearML (self-hosted o al livello gratuito).

ClearML acquisisce automaticamente i dettagli degli esperimenti, i caricamenti dei modelli, i confronti, le modifiche al codice non sottoposte a commit e i pacchetti installati, garantendo la completa riproducibilità. Puoi programmare facilmente le attività di addestramento su agenti remoti e gestire le versioni dei dataset utilizzando ClearML Data. Consulta la Guida all'integrazione di ClearML per tutti i dettagli.

Logging locale#

I risultati dell'addestramento vengono registrati automaticamente utilizzando TensorBoard e salvati come file CSV all'interno della directory dell'esperimento specifico (ad esempio, runs/train/exp). I dati registrati includono:

• Perdita e metriche delle prestazioni dell'addestramento e della validazione.
• Immagini di esempio che mostrano le augmentazioni applicate (come i mosaici).
• Etichette ground truth insieme alle previsioni del modello per l'ispezione visiva.
• Metriche di valutazione chiave come le curve Precision-Recall (PR).
• Matrici di confusione per un'analisi dettagliata delle prestazioni per classe.

Il file results.csv viene aggiornato dopo ogni epoca e viene rappresentato graficamente come results.png al termine dell'addestramento. Puoi anche rappresentare manualmente qualsiasi file results.csv utilizzando la funzione di utilità fornita:

from utils.plots import plot_results

# Plot results from a specific training run directory
plot_results("runs/train/exp/results.csv")  # This will generate 'results.png' in the same directory

5. Passaggi successivi#

Al completamento dell'addestramento, il checkpoint del modello con le migliori prestazioni (best.pt) viene salvato ed è pronto per la distribuzione o per un ulteriore perfezionamento. I possibili passaggi successivi includono:

• Esegui l'inferenza su nuove immagini o video utilizzando il modello addestrato tramite la CLI o Python.
• Esegui la validazione per valutare l'accuratezza e le capacità di generalizzazione del modello su diverse suddivisioni dei dati (ad esempio, un set di test separato).
• Esporta il modello in diversi formati di distribuzione, come ONNX, TensorFlow SavedModel o TensorRT, per un'inferenza ottimizzata su diverse piattaforme.
• Applica tecniche di ottimizzazione degli iperparametri per ottenere potenzialmente ulteriori miglioramenti delle prestazioni.
• Continua a migliorare il tuo modello seguendo i nostri Suggerimenti per ottenere i migliori risultati di addestramento e aggiungendo iterativamente dati più diversificati e impegnativi sulla base dell'analisi delle prestazioni.

Ambienti supportati#

Ultralytics offre ambienti pronti all'uso dotati di dipendenze essenziali come CUDA, cuDNN, Python e PyTorch, per consentirti di iniziare senza difficoltà.

• Notebook GPU gratuiti:
  • 
  • 
  • 
• Piattaforme cloud:
  • Google Cloud: Guida rapida a GCP
  • Amazon AWS: Guida introduttiva ad AWS
  • Microsoft Azure: Guida introduttiva ad AzureML
• Configurazione locale:
  • Docker: Guida rapida a Docker

Stato del progetto#

Questo badge indica che tutti i test di Continuous Integration (CI) delle GitHub Actions di YOLOv5 vengono superati correttamente. Questi rigorosi test CI coprono le funzionalità principali, tra cui addestramento, validazione, inferenza, esportazione e benchmark, sui sistemi operativi macOS, Windows e Ubuntu. I test vengono eseguiti automaticamente ogni 24 ore e a ogni commit del codice, garantendo stabilità costante e prestazioni ottimali.

FAQ#