Addestra YOLOv5 su 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 computer vision ad applicazioni reali specifiche che vanno oltre il generico object detection.

Prima di iniziare#

Innanzitutto, assicurati di aver configurato l'ambiente necessario. Clona il repository di YOLOv5 e installa le dipendenze richieste da requirements.txt. Un ambiente Python>=3.8.0 con PyTorch>=1.8 è essenziale. Modelli e dataset vengono scaricati automaticamente dall'ultimo 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

Addestra su dati personalizzati#

Lo sviluppo di un modello di object detection personalizzato è un processo iterativo:

1. Raccogli e organizza le immagini: Raccogli immagini pertinenti alla tua attività specifica. Dati diversificati e di alta qualità sono fondamentali. Consulta la nostra guida sulla Raccolta e annotazione dei dati.
2. Etichetta gli oggetti: Annotare accuratamente gli oggetti di interesse all'interno delle tue immagini.
3. Addestra un modello: Usa i dati etichettati per addestrare il tuo modello YOLOv5. Sfrutta il transfer learning iniziando con pesi pre-addestrati.
4. Distribuisci ed esegui predizioni: Utilizza il modello addestrato per l'inference su dati nuovi e non visti.
5. Raccogli casi limite: Identifica gli scenari in cui il modello offre scarse prestazioni (edge cases) 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 machine learning operations (MLOps), inclusa la gestione del dataset, l'addestramento del modello e la distribuzione.

Prima di avviare l'addestramento, la preparazione del dataset è essenziale.

Crea un dataset#

I modelli YOLOv5 richiedono dati etichettati per apprendere le caratteristiche visive delle classi di oggetti. Organizzare correttamente il tuo 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 alle directory delle immagini. COCO128 funge da piccolo dataset di esempio, comprendendo le prime 128 immagini dall'esteso 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 che elencano i percorsi delle immagini per i set di addestramento, validazione e test.
• names: Un dizionario che mappa gli indici delle classi (a partire da 0) ai relativi nomi di classe corrispondenti.

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 radice del repository di YOLOv5.

Di seguito è riportata la struttura per 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 comune, ma richiede tempo. I modelli di base possono automatizzare o semi-automatizzare l'annotazione e velocizzare la creazione del dataset. Esempi di modelli che possono aiutare a generare etichette:

• Google Gemini: I grandi modelli multimodali come Gemini possiedono potenti capacità di comprensione delle immagini. Possono ricevere prompt per identificare e localizzare oggetti all'interno delle immagini, generando bounding box o descrizioni che possono essere convertite in etichette in formato YOLO. Esplora le sue potenzialità nel notebook tutorial fornito.
• SAM2 (Segment Anything Model 2): I modelli di base incentrati sulla segmentazione, come SAM2, possono identificare e delineare oggetti con elevata precisione. Sebbene siano principalmente destinati alla segmentazione, le maschere risultanti possono spesso essere convertite in annotazioni di bounding box adatte per attività di object detection.
• YOLOWorld: Questo modello offre funzionalità di rilevamento a vocabolario aperto. Puoi fornire descrizioni testuali degli oggetti a cui sei interessato e YOLOWorld può individuarli nelle immagini senza un addestramento precedente su quelle classi specifiche. Questo può essere usato come punto di partenza per generare etichette iniziali, che possono poi essere perfezionate.

L'uso di questi modelli può fornire una fase di "pre-etichettatura", riducendo lo sforzo manuale richiesto. Tuttavia, è fondamentale rivedere e perfezionare le etichette generate automaticamente per garantirne precisione e coerenza, poiché la qualità influisce direttamente sulle prestazioni del tuo modello YOLOv5 addestrato. Dopo aver generato (e potenzialmente perfezionato) le tue 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 con indice zero). Se un'immagine non contiene oggetti di interesse, non è necessario alcun file *.txt corrispondente.

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

• Una riga per ogni bounding box dell'oggetto.
• Ogni riga deve contenere: class_index x_center y_center width height.
• Le coordinate devono essere normalizzate a un intervallo compreso tra 0 e 1. Per fare ciò, 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), si presenterà così:

1.3 Organizza le directory#

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

YOLOv5 individua automaticamente le etichette per ciascuna immagine sostituendo l'ultima istanza di /images/ nel percorso dell'immagine con /labels/. Per 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 raccomandata è:

/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)
            └── ...

Seleziona un modello#

Scegli un modello pre-addestrato per avviare il processo di addestramento. Iniziare con pesi pre-addestrati accelera significativamente l'apprendimento e migliora le prestazioni rispetto all'addestramento da zero. YOLOv5 offre varie dimensioni di modello, ciascuna delle quali bilancia velocità e precisione in modo diverso. Ad esempio, YOLOv5s è il secondo modello più piccolo e veloce, adatto ad ambienti con risorse limitate. Consulta la tabella nel README per un confronto dettagliato di tutti i modelli disponibili.

Addestra#

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

• --img: Definisce la dimensione dell'immagine di input (ad es. --img 640). Dimensioni maggiori generalmente producono una precisione migliore ma richiedono più memoria della GPU.
• --batch: Determina la dimensione del batch (ad es. --batch 16). Scegli la dimensione più grande che la tua GPU può gestire.
• --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 al tuo file dataset.yaml (ad es. --data coco128.yaml).
• --weights: Percorso al file dei pesi iniziali. L'uso di pesi pre-addestrati (ad es. --weights yolov5s.pt) è altamente raccomandato per una convergenza più rapida e risultati superiori. Per addestrare da zero (sconsigliato a meno che tu non abbia un dataset molto grande e specifiche esigenze), usa --weights '' --cfg yolov5s.yaml.

I pesi pre-addestrati vengono scaricati automaticamente dal più recente 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 agiunta di 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, ecc.). Per un'esperienza interattiva e pratica, esplora la sezione di addestramento nei nostri notebook tutorial ufficiali:

Visualizza#

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

Registrazione e visualizzazione con Comet#

Comet è completamente integrato per il tracciamento completo degli esperimenti. Visualizza le metriche in tempo reale, salva gli iperparametri, gestisci dataset e checkpoint di modello e analizza le predizioni del modello utilizzando gli interattivi Comet Custom Panels.

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 dalla loro documentazione ufficiale. Prova il Notebook Colab di Comet per una demo dal vivo:

Registrazione e automazione con ClearML#

L'integrazione con ClearML consente il tracciamento 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 (auto-ospitato o nel livello gratuito).

ClearML cattura automaticamente i dettagli degli esperimenti, i caricamenti dei modelli, i confronti, le modifiche al codice non ancora inserite nel commit e i pacchetti installati, garantendo la completa riproducibilità. Puoi facilmente pianificare attività di addestramento su agenti remoti e gestire le versioni dei dataset usando ClearML Data. Esplora la Guida all'integrazione di ClearML per dettagli completi.

Registrazione locale#

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

• Perdita e metriche di prestazione di addestramento e validazione.
• Immagini campione che mostrano le aumentazioni applicate (come i mosaici).
• Etichette di verità di base insieme alle previsioni del modello per l'ispezione visiva.
• Metriche di valutazione chiave come le curve di Precision-Recall (PR).
• Confusion matrices per un'analisi dettagliata delle prestazioni per classe.

Il file results.csv viene aggiornato dopo ogni epoca e viene tracciato come results.png una volta completato l'addestramento. Puoi anche tracciare qualsiasi file results.csv manualmente 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

Passaggi successivi#

Al completamento con successo 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 potenziali passaggi successivi includono:

• Esegui l'inference su nuove immagini o video utilizzando il modello addestrato tramite la CLI o Python.
• Esegui la validazione per valutare l'accuracy e le capacità di generalizzazione del modello su diversi split di dati (ad es. un set di test tenuto da parte).
• Esporta il modello in vari formati di distribuzione come ONNX, TensorFlow SavedModel o TensorRT per un'inference ottimizzata su diverse piattaforme.
• Impiega tecniche di hyperparameter tuning per estrarre potenzialmente ulteriori guadagni di prestazioni.
• Continua a migliorare il tuo modello seguendo i nostri Consigli per i migliori risultati di addestramento e aggiungendo iterativamente dati più diversificati e complessi in base all'analisi delle prestazioni.

Ambienti supportati#

Ultralytics fornisce ambienti pronti all'uso dotati di dipendenze essenziali come CUDA, cuDNN, Python e PyTorch, facilitando un avvio senza intoppi.

• 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 di Continuous Integration (CI) di GitHub Actions per YOLOv5 vengono superati con successo. Questi rigorosi test di CI coprono le funzionalità principali, tra cui training, validation, inference, export e benchmarks, 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#