Addestra YOLOv5 con dati personalizzati#

📚 Questa guida spiega come addestrare il tuo dataset personalizzato usando il modello YOLOv5 🚀. L'addestramento di modelli personalizzati è un passaggio fondamentale per adattare le soluzioni di visione artificiale a specifiche applicazioni del mondo reale, al di là del generico rilevamento degli oggetti.

Prima di iniziare#

Per prima cosa, assicurati di aver configurato l'ambiente necessario. Clona il repository di YOLOv5 e installa le dipendenze richieste da requirements.txt. È essenziale disporre di un ambiente Python>=3.8.0 con PyTorch>=1.8. Se non vengono trovati localmente, i modelli e i dataset vengono scaricati automaticamente dalla versione più recente di YOLOv5.

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

Addestra con dati personalizzati#

Lo sviluppo di un modello personalizzato di rilevamento 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 alla raccolta e annotazione dei dati.
2. Etichetta gli oggetti: annota con precisione gli oggetti di interesse nelle 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 predici: usa il modello addestrato per eseguire inferenze su nuovi dati mai visti.
5. Raccogli i casi limite: individua gli scenari in cui il modello ha prestazioni scarse (casi limite) e aggiungi dati simili al dataset per migliorarne la robustezza. Ripeti il ciclo.

Ultralytics Platform offre una soluzione completa e semplificata, 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 es. 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 del vasto 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 principale contenente il dataset.
• train, val, test: percorsi relativi da path alle directory contenenti immagini o file di testo con gli elenchi dei percorsi delle immagini per i set di addestramento, convalida e test.
• names: un dizionario che associa gli indici delle classi (a partire da 0) ai nomi delle rispettive classi.

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

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

# Dataset root directory relative to the yolov5 directory
path: ../datasets/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 modelli di base possono automatizzare o semiautomatizzare le annotazioni e velocizzare la creazione del dataset. Ecco alcuni modelli che possono aiutarti a generare etichette:

• Google Gemini: i modelli multimodali di grandi dimensioni come Gemini hanno potenti capacità di comprensione delle immagini. Puoi chiedere loro di identificare e localizzare gli oggetti nelle immagini, generando riquadri di delimitazione o descrizioni convertibili in etichette nel formato YOLO. Scopri il loro potenziale nel notebook tutorial fornito.
• SAM2 (Modello Segment Anything 2): i modelli di base dedicati alla segmentazione, come SAM2, possono identificare e delineare gli oggetti con grande precisione. Sebbene siano pensati principalmente per la segmentazione, le maschere risultanti possono spesso essere convertite in annotazioni con riquadri di delimitazione adatte alle attività di rilevamento degli oggetti.
• YOLOWorld: questo modello offre funzionalità di rilevamento a vocabolario aperto. Puoi fornire descrizioni testuali degli oggetti che ti interessano e YOLOWorld può individuarli nelle immagini senza essere stato addestrato in precedenza su quelle specifiche classi. Puoi usarlo come punto di partenza per generare etichette iniziali, da perfezionare in seguito.

L'uso di questi modelli può fornire una fase di «pre-etichettatura», riducendo il lavoro manuale necessario. Tuttavia, è fondamentale verificare e perfezionare le etichette generate automaticamente per garantire accuratezza e coerenza, poiché la qualità incide direttamente sulle prestazioni del modello YOLOv5 addestrato. Dopo aver generato (ed eventualmente 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, indice della classe a partire da zero). Se un'immagine non contiene oggetti di interesse, non è necessario alcun file *.txt corrispondente.

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

• Una riga per ogni riquadro di delimitazione.
• 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 in pixel di x_center e width per la larghezza totale dell'immagine e 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 di etichette corrispondente all'immagine sopra, contenente due oggetti «person» (indice di classe 0) e un oggetto «tie» (indice di classe 27), sarebbe così:

1.3 Organizza le directory#

Struttura la directory dei dataset come illustrato di seguito. Per impostazione predefinita, YOLOv5 prevede che la directory del dataset (ad es. /coco128) si trovi in una cartella /datasets 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 varie dimensioni, ciascuno con un diverso equilibrio tra velocità e accuratezza. Ad esempio, YOLOv5s è il secondo modello più piccolo e il secondo 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 usando lo script train.py. Gli argomenti essenziali includono:

• --img: definisce la dimensione dell'immagine di input (ad es. --img 640). In genere, dimensioni maggiori offrono una migliore accuratezza, ma richiedono più memoria GPU.
• --batch: determina la dimensione del batch (ad es. --batch 16). Scegli la dimensione massima gestibile dalla tua GPU.
• --epochs: specifica il numero totale di epoche di addestramento (ad es. --epochs 100). Un'epoca rappresenta un passaggio completo sull'intero dataset di addestramento.
• --data: percorso del tuo file dataset.yaml (ad es. --data coco128.yaml).
• --weights: percorso del file dei pesi iniziali. È vivamente consigliato usare pesi preaddestrati (ad es. --weights yolov5s.pt) per ottenere una convergenza più rapida e risultati migliori. Per addestrare da zero (non consigliato, a meno che tu non abbia un dataset molto grande e necessità specifiche), usa --weights '' --cfg yolov5s.yaml.

Se non sono presenti localmente, i pesi preaddestrati vengono scaricati automaticamente dalla release più recente di YOLOv5.

# 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 pesi e log, vengono salvati nella directory runs/train/. Ogni sessione di addestramento crea una nuova sottodirectory (ad es. runs/train/exp, runs/train/exp2 e così via). Per un'esperienza pratica e interattiva, consulta la sezione sull'addestramento nei notebook tutorial ufficiali:

4. Visualizza#

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

Registrazione 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 usando i pannelli personalizzati Comet 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!

Scopri più a fondo le funzionalità supportate nella nostra guida all'integrazione di Comet. Approfondisci le funzionalità di Comet consultando la documentazione ufficiale. Prova il notebook Comet su Colab per una demo dal vivo:

Registrazione 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 clearml-init una volta per connetterti al tuo server ClearML (ospitato autonomamente o con il piano 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 piena riproducibilità. Puoi pianificare facilmente le attività di addestramento su agenti remoti e gestire le versioni dei dataset con ClearML Data. Consulta la guida all'integrazione di ClearML per informazioni complete.

Registrazione locale#

I risultati dell'addestramento vengono registrati automaticamente con TensorBoard e salvati come file CSV nella directory dell'esperimento specifico (ad es. runs/train/exp). I dati registrati includono:

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

Il file results.csv viene aggiornato dopo ogni epoca e, al termine dell'addestramento, viene generato il grafico results.png. Puoi anche creare manualmente il grafico di qualsiasi file results.csv usando la funzione di utilità fornita:

from utils.plots import plot_results

# Traccia i risultati di una directory di esecuzione di addestramento specifica
plot_results("runs/train/exp/results.csv")  # Verrà generato 'results.png' nella stessa directory

5. Passaggi successivi#

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

• Esegui inferenze su nuove immagini o video con il modello addestrato tramite la CLI o Python.
• Esegui val.py per valutare l'accuratezza del modello e la sua capacità di generalizzazione su diverse suddivisioni dei dati (ad es. un set di test tenuto da parte).
• Esporta il modello in diversi formati di distribuzione, come ONNX, TensorFlow SavedModel o TensorRT, per un'inferenza ottimizzata su piattaforme diverse.
• Usa l'evoluzione degli iperparametri per provare a ottenere ulteriori miglioramenti delle prestazioni.
• Continua a migliorare il tuo modello seguendo i nostri consigli 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 delle 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 rapida ad AWS
  • Microsoft Azure: Guida rapida ad AzureML
• Configurazione locale:
  • Docker: Guida rapida a Docker

Stato del progetto#

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

Domande frequenti#