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 specifiche del mondo reale, oltre il semplice rilevamento oggetti.

Prima di iniziare

Per prima cosa, assicurati di avere l'ambiente necessario configurato. Clona il repository di YOLOv5 e installa le dipendenze richieste dal file requirements.txt. Un ambiente Python>=3.8.0 con PyTorch>=1.8 è essenziale. Modelli e 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

Addestra su dati personalizzati

Lo sviluppo di un modello personalizzato di rilevamento oggetti è un processo iterativo:

1. Raccogli e organizza le immagini: Raduna le immagini rilevanti per il tuo compito specifico. Dati di alta qualità e diversificati sono cruciali. Consulta la nostra guida su 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 partendo da pesi pre-addestrati.
4. Distribuisci e prevedi: Utilizza il modello addestrato per l'inferenza su dati nuovi e mai visti prima.
5. Raccogli i casi limite: Identifica gli scenari in cui il modello ha scarse prestazioni (casi limite) e aggiungi dati simili al tuo dataset per migliorare la robustezza. Ripeti il ciclo.

La piattaforma Ultralytics offre una soluzione semplificata e senza codice per l'intero ciclo di operazioni di machine learning (MLOps), inclusa la gestione dei dataset, l'addestramento del modello e la distribuzione.

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

1. 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 esempio, coco128.yaml) delinea la struttura del dataset, i nomi delle classi e i percorsi delle directory delle immagini. COCO128 funge da piccolo dataset di esempio, comprendente le 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 contenente il dataset.
• train, val, test: Percorsi relativi da path a 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 di classe (a partire da 0) ai relativi nomi di classe.

Puoi impostare path su una directory assoluta (ad esempio, /home/user/datasets/coco128) o su un percorso relativo come ../datasets/coco128 quando avvii l'addestramento dalla radice del repository 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: Grandi modelli multimodali come Gemini possiedono potenti capacità di comprensione delle immagini. Possono essere istruiti a identificare e localizzare oggetti all'interno delle immagini, generando riquadri di delimitazione o descrizioni che possono essere convertite in etichette in formato YOLO. Esplora il suo potenziale nel notebook del tutorial fornito.
• SAM2 (Segment Anything Model 2): I modelli di base focalizzati sulla segmentazione, come SAM2, possono identificare e delineare oggetti con alta precisione. Sebbene siano principalmente per la segmentazione, le maschere risultanti possono spesso essere convertite in annotazioni di riquadri di delimitazione adatte per compiti di rilevamento oggetti.
• YOLOWorld: Questo modello offre capacità di rilevamento a vocabolario aperto. Puoi fornire descrizioni testuali degli oggetti a cui sei interessato e YOLOWorld può localizzarli 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'utilizzo di questi modelli può fornire un passaggio di "pre-etichettatura", riducendo lo sforzo manuale richiesto. Tuttavia, è fondamentale rivedere e perfezionare le etichette generate automaticamente per garantire accuratezza 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 aderiscano al formato YOLO: un file *.txt per ogni 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 ha oggetti di interesse, non è necessario alcun file *.txt corrispondente.

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

• Una riga per ogni riquadro di delimitazione di oggetto.
• Ogni riga deve contenere: class_index x_center y_center width height.
• Le coordinate devono essere normalizzate su un intervallo compreso tra 0 e 1. Per ottenere 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 di classe iniziano 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 'persona' (indice di classe 0) e un oggetto 'cravatta' (indice di classe 27), apparirebbe così:

1.3 Organizza le directory

Struttura la tua directory dei dataset come illustrato di seguito. Per impostazione predefinita, YOLOv5 prevede che la directory del dataset (ad esempio, /coco128) risieda all'interno di una cartella /datasets situata adiacente alla directory del repository /yolov5.

YOLOv5 localizza automaticamente le etichette per ogni immagine sostituendo l'ultima istanza 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 pre-addestrato per iniziare 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, ognuna delle quali bilancia velocità e precisione in modo diverso. Ad esempio, YOLOv5s è il secondo modello più piccolo e veloce, adatto per ambienti con risorse limitate. Consulta la tabella README per un confronto dettagliato di tutti i modelli disponibili.

3. Addestra

Inizia 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 precisione migliore ma richiedono più memoria GPU.
• --batch: Determina la dimensione del batch (ad esempio, --batch 16). Scegli la dimensione più grande che la tua GPU può 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 tuo file dataset.yaml (ad esempio, --data coco128.yaml).
• --weights: Percorso del file dei pesi iniziale. L'uso di pesi pre-addestrati (ad esempio, --weights yolov5s.pt) è caldamente consigliato per una convergenza più rapida e risultati superiori. Per addestrare da zero (non consigliato a meno che tu non abbia un dataset molto ampio ed esigenze specifiche), usa --weights '' --cfg yolov5s.yaml.

I pesi pre-addestrati 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 di addestramento, inclusi pesi e log, vengono salvati nella directory runs/train/. Ogni sessione di addestramento crea una nuova sottodirectory (ad esempio, runs/train/exp, runs/train/exp-2, ecc.). Per un'esperienza interattiva e pratica, esplora la sezione di addestramento nei nostri notebook tutorial ufficiali:

4. Visualizza

YOLOv5 si integra perfettamente con vari strumenti per visualizzare l'avanzamento 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 del modello e analizza le predizioni del modello utilizzando 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!

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 live:

Registrazione e automazione con ClearML

L'integrazione di 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 (sia esso ospitato autonomamente o tramite il piano gratuito).

ClearML acquisisce automaticamente i dettagli dell'esperimento, i caricamenti dei modelli, i confronti, le modifiche al codice non ancora eseguite e i pacchetti installati, garantendo una riproducibilità totale. Puoi pianificare facilmente compiti 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 utilizzando TensorBoard e salvati come file CSV all'interno della directory specifica dell'esperimento (ad esempio, runs/train/exp). I dati registrati includono:

• Metriche di perdita e prestazioni di addestramento e validazione.
• Immagini campione che mostrano le aumentazioni applicate (come i mosaici).
• Etichette di verità (ground truth) insieme alle predizioni del modello per un'ispezione visiva.
• Metriche di valutazione chiave come le curve Precisione-Richiamo (PR).
• Matrici di confusione per un'analisi dettagliata delle prestazioni per singola classe.

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

• Eseguire l'inferenza su nuove immagini o video utilizzando il modello addestrato tramite la CLI o Python.
• Eseguire la validazione per valutare l'accuratezza del modello e le capacità di generalizzazione su diversi split di dati (ad esempio, un set di test tenuto da parte).
• Esportare il modello in vari formati di distribuzione come ONNX, TensorFlow SavedModel o TensorRT per un'inferenza ottimizzata su diverse piattaforme.
• Impiegare tecniche di ottimizzazione degli iperparametri per potenzialmente ottenere ulteriori miglioramenti nelle prestazioni.
• Continuare a migliorare il tuo modello seguendo i nostri Suggerimenti per i migliori risultati di addestramento e aggiungendo iterativamente dati più diversificati e impegnativi basati sull'analisi delle prestazioni.

Ambienti supportati

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

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

Stato del progetto

This badge indicates that all YOLOv5 GitHub Actions Continuous Integration (CI) tests are passing successfully. These rigorous CI tests cover the core functionalities, including training, validation, inference, export, and benchmarks, across macOS, Windows, and Ubuntu operating systems. Tests are executed automatically every 24 hours and upon each code commit, ensuring consistent stability and optimal performance.

FAQ

Come addestro YOLOv5 sul mio dataset personalizzato?

L'addestramento di YOLOv5 su un dataset personalizzato comporta diversi passaggi chiave:

1. Prepara il tuo dataset: Raccogli le immagini e annotale. Assicurati che le annotazioni siano nel formato YOLO richiesto. Organizza le immagini e le etichette nelle directory train/ e val/ (e opzionalmente test/). Prendi in considerazione l'utilizzo di modelli come Google Gemini, SAM2 o YOLOWorld per assistere o automatizzare il processo di etichettatura (vedi Sezione 1.2).
2. Configura il tuo ambiente: Clona il repository YOLOv5 e installa le dipendenze usando pip install -r requirements.txt.

   git clone https://github.com/ultralytics/yolov5
   cd yolov5
   pip install -r requirements.txt

3. Crea la configurazione del dataset: Definisci i percorsi del dataset, il numero di classi e i nomi delle classi in un file dataset.yaml.
4. Avvia l'addestramento: Esegui lo script train.py, fornendo i percorsi per il tuo dataset.yaml, i pesi pre-addestrati desiderati (es. yolov5s.pt), la dimensione dell'immagine, la dimensione del batch e il numero di epoche.

   python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt

Perché dovrei usare Ultralytics Platform per addestrare i miei modelli YOLO?

Ultralytics Platform è una piattaforma completa progettata per semplificare l'intero ciclo di vita dello sviluppo dei modelli YOLO, spesso senza dover scrivere alcun codice. I vantaggi principali includono:

• Addestramento semplificato: Addestra facilmente i modelli utilizzando ambienti preconfigurati e un'interfaccia utente intuitiva.
• Gestione dati integrata: Carica, controlla la versione e gestisci i tuoi dataset in modo efficiente all'interno della piattaforma.
• Monitoraggio in tempo reale: Traccia l'avanzamento dell'addestramento e visualizza le metriche delle prestazioni utilizzando strumenti integrati come Comet o TensorBoard.
• Funzionalità di collaborazione: Facilita il lavoro di squadra attraverso risorse condivise, strumenti di gestione dei progetti e una facile condivisione dei modelli.
• Distribuzione senza codice: Distribuisci i modelli addestrati direttamente verso vari target.

Per una guida pratica, dai un'occhiata al nostro post sul blog: Come addestrare i tuoi modelli personalizzati con Ultralytics Platform.

Come posso convertire i miei dati annotati nel formato YOLOv5?

Che tu annoti manualmente o utilizzi strumenti automatizzati (come quelli menzionati nella Sezione 1.2), le etichette finali devono essere nel formato YOLO specifico richiesto da YOLOv5:

• Crea un file .txt per ogni immagine. Il nome del file deve corrispondere al nome del file immagine (es. image1.jpg corrisponde a image1.txt). Posiziona questi file in una directory labels/ parallela alla tua directory images/ (es. ../datasets/mydataset/labels/train/).
• Ogni riga all'interno di un file .txt rappresenta un'annotazione di oggetto e segue il formato: class_index center_x center_y width height.
• Le coordinate (center_x, center_y, width, height) devono essere normalizzate (valori tra 0.0 e 1.0) rispetto alle dimensioni dell'immagine.
• Gli indici di classe sono basati su zero (la prima classe è 0, la seconda è 1, ecc.).

Molti strumenti di annotazione manuale offrono l'esportazione diretta nel formato YOLO. Se utilizzi modelli automatizzati, avrai bisogno di script o processi per convertire il loro output (es. coordinate del riquadro di delimitazione, maschere di segmentazione) in questo specifico formato di testo normalizzato. Assicurati che la struttura finale del tuo dataset aderisca all'esempio fornito nella guida. Per ulteriori dettagli, consulta la nostra Guida alla raccolta e annotazione dei dati.

Quali sono le opzioni di licenza per utilizzare YOLOv5 in applicazioni commerciali?

Ultralytics fornisce licenze flessibili su misura per diverse esigenze:

• Licenza AGPL-3.0: Questa licenza open-source è adatta per la ricerca accademica, i progetti personali e le situazioni in cui la conformità open-source è accettabile. Richiede che le modifiche e le opere derivate siano anch'esse open-source sotto AGPL-3.0. Esamina i dettagli della Licenza AGPL-3.0.
• Licenza Enterprise: Una licenza commerciale progettata per le aziende che integrano YOLOv5 in prodotti o servizi proprietari. Questa licenza rimuove gli obblighi open-source della AGPL-3.0, consentendo la distribuzione a codice chiuso. Visita la nostra pagina delle Licenze per ulteriori dettagli o per richiedere una Licenza Enterprise.

Seleziona la licenza che meglio si allinea con i requisiti e il modello di distribuzione del tuo progetto.