Addestra YOLOv5 su Dati Personalizzati

📚 Questa guida spiega come addestrare il tuo dataset personalizzato utilizzando il modello YOLOv5 🚀. L'addestramento di modelli personalizzati è un passo fondamentale per adattare le soluzioni di computer vision ad applicazioni specifiche del mondo reale, al di là del generico object detection.

Prima di iniziare

Innanzitutto, assicurati di avere l'ambiente necessario configurato. Clona il repository YOLOv5 e installa le dipendenze richieste da requirements.txt. Un Python>=3.8.0 ambiente con PyTorch>=1.8 è essenziale. Modelli e set di dati vengono scaricati automaticamente dall'ultima versione di YOLOv5 release 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 object detection è un processo iterativo:

1. Raccogli e Organizza le Immagini: Raccogli immagini rilevanti per il tuo compito specifico. Dati diversificati e di alta qualità sono fondamentali. Consulta la nostra guida sulla Raccolta e Annotazione dei Dati.
2. Etichetta oggetti: Annota accuratamente gli oggetti di interesse all'interno delle tue immagini.
3. Addestra un modello: Utilizza i dati etichettati per addestrare il tuo modello YOLOv5. Sfrutta il transfer learning iniziando con pesi pre-addestrati.
4. Deploy & Predict: Utilizza il modello addestrato per l'inferenza su dati nuovi e non visti.
5. Raccogli i Casi Limite: Identifica gli scenari in cui il modello ha prestazioni insufficienti (casi limite) e aggiungi dati simili al tuo set di dati per migliorare la robustezza. Ripeti il ciclo.

Ultralytics HUB offre una soluzione semplificata e senza codice per l'intero ciclo di Machine Learning Operations (MLOps), inclusa la gestione dei dataset, l'addestramento dei modelli e la distribuzione.

Prima di iniziare l'addestramento, è essenziale preparare il set di dati.

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 alle directory delle immagini. COCO128 funge da piccolo dataset di esempio, comprendente le prime 128 immagini dell'esteso COCO dataset. È utile per testare rapidamente la pipeline di addestramento e diagnosticare potenziali problemi come overfitting.

Il dataset.yaml La struttura del file include:

• path: La directory principale 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 training, convalida e test.
• names: Un dizionario che mappa gli indici di classe (a partire da 0) ai loro nomi di classe corrispondenti.

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 Automatica

Sebbene l'etichettatura manuale tramite strumenti sia un approccio comune, il processo può richiedere molto tempo. I recenti progressi nei modelli di base offrono possibilità di automatizzare o semi-automatizzare il processo di annotazione, accelerando potenzialmente in modo significativo la creazione del dataset. Ecco alcuni esempi di modelli che possono aiutare a generare etichette:

• Google Gemini: I modelli multimodali di grandi dimensioni come Gemini possiedono potenti capacità di comprensione delle immagini. Possono essere sollecitati a identificare e localizzare oggetti all'interno delle immagini, generando bounding box o descrizioni che possono essere convertite in etichette in formato YOLO. Esplora il suo potenziale nel notebook tutorial fornito.
• SAM2 (Segment Anything Model 2): I modelli di base focalizzati sulla segmentazione, come SAM2, possono identificare e delineare oggetti con elevata precisione. Sebbene principalmente per la segmentazione, le maschere risultanti possono spesso essere convertite in annotazioni di bounding box adatte per attività di rilevamento di oggetti.
• YOLOWorld: Questo modello offre funzionalità di rilevamento a vocabolario aperto. Puoi fornire descrizioni testuali degli oggetti che ti interessano e YOLOWorld è in grado di localizzarli nelle immagini senza un addestramento preliminare su quelle specifiche classi. Questo può essere utilizzato come punto di partenza per generare etichette iniziali, che possono poi essere perfezionate.

L'utilizzo 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 garantire accuratezza e coerenza, poiché la qualità influisce direttamente sulle prestazioni del modello YOLOv5 addestrato. Dopo aver generato (e potenzialmente perfezionato) le etichette, assicurati che aderiscano a formato YOLO: uno *.txt file per immagine, con ogni riga che rappresenta un oggetto come class_index x_center y_center width height (coordinate normalizzate, classe a indice zero). Se un'immagine non ha oggetti di interesse, nessun corrispondente *.txt file è necessario.

Il formato YOLO *.txt Le specifiche del file 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 normalizzato a un intervallo compreso tra 0 e 1. Per ottenere questo risultato, dividi i valori dei 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 sono indicizzati a zero (ovvero, la prima classe è rappresentata da 0, il secondo da 1, e così via).

Il file di etichette corrispondente all'immagine sopra, contenente due oggetti 'persona' (indice di classe 0) e un oggetto 'tie' (indice di classe 27), sarebbe simile a questo:

1.3 Organizza le Directory

Struttura il tuo datasets directory come illustrato di seguito. Per impostazione predefinita, YOLOv5 prevede la directory del dataset (ad esempio, /coco128) da risiedere all'interno di un /datasets cartella situata adiacente a il /yolov5 directory del repository.

YOLOv5 individua 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 avviare il processo di training. Iniziare con pesi pre-addestrati accelera significativamente l'apprendimento e migliora le prestazioni rispetto al training da zero. YOLOv5 offre varie dimensioni di modello, ognuna delle quali bilancia velocità e accuratezza in modo diverso. Ad esempio, YOLOv5s è il secondo modello più piccolo e veloce, adatto per ambienti con risorse limitate. Consulta la tabella del file README per un confronto dettagliato di tutti i modelli disponibili.

3. Addestramento

Inizia il addestramento del modello utilizzando il train.py script. Gli argomenti essenziali includono:

• --img: Definisce l'input dimensione dell'immagine (ad esempio, --img 640). Dimensioni maggiori generalmente producono una migliore accuratezza, ma richiedono più memoria GPU.
• --batch: Determina il dimensione del batch (ad esempio, --batch 16). Scegli la dimensione più grande che la tua GPU può gestire.
• --epochs: Specifica il numero totale di training epoche (ad esempio, --epochs 100). Un'epoca rappresenta un passaggio completo sull'intero set di dati di addestramento.
• --data: Percorso del tuo dataset.yaml file (ad esempio, --data coco128.yaml).
• --weights: Percorso del file dei pesi iniziali. Utilizzo di pesi pre-addestrati (ad esempio, --weights yolov5s.pt) è altamente raccomandato per una convergenza più rapida e risultati superiori. Per eseguire il training da zero (sconsigliato a meno che tu non abbia un dataset molto grande 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 training, inclusi pesi e log, vengono salvati in runs/train/ directory. Ogni sessione di training crea una nuova sottodirectory (ad esempio, runs/train/exp, runs/train/exp2, ecc.). Per un'esperienza interattiva e pratica, esplora la sezione di training nei nostri notebook tutorial ufficiali:

4. Visualizza

YOLOv5 si integra perfettamente con vari strumenti per visualizzare l'avanzamento del training, valutare i risultati e monitorare le prestazioni in tempo reale.

Logging e visualizzazione con Comet 🌟 NUOVO

Comet è completamente integrato per un tracciamento completo degli esperimenti. Visualizza le metriche in diretta, salva gli iperparametri, gestisci i dataset e i checkpoint del modello e analizza le previsioni 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 funzionalità di Comet dal loro sito ufficiale documentazione. Prova il Notebook Comet Colab per una demo dal vivo:

Logging e automazione con ClearML 🌟 NUOVO

L'integrazione con ClearML consente il tracciamento dettagliato degli esperimenti, la gestione delle versioni dei dataset e persino l'esecuzione remota delle esecuzioni di training. 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 auto-ospitato che il livello gratuito).

ClearML acquisisce automaticamente i dettagli degli esperimenti, i caricamenti dei modelli, i confronti, le modifiche del codice non sottoposte a commit e i pacchetti installati, garantendo la completa riproducibilità. Puoi facilmente pianificare attività di training su agent remoti e gestire le versioni dei dataset utilizzando ClearML Data. Esplora la Guida all'integrazione di ClearML per dettagli completi.

Logging locale

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

• Perdita di addestramento e validazione e metriche di performance.
• Immagini di esempio che mostrano gli aumenti applicati (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 results.csv file viene aggiornato dopo ogni epoca e viene tracciato come results.png una volta che l'addestramento è concluso. Puoi anche tracciare qualsiasi results.csv file 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

5. Prossimi Passi

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 ottimizzazione. I potenziali 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 del modello e le capacità di generalizzazione su diverse suddivisioni dei dati (ad esempio, un set di test riservato).
• Esporta il modello in vari formati di distribuzione come ONNX, TensorFlow SavedModel, o TensorRT per un'inferenza ottimizzata su diverse piattaforme.
• Utilizza tecniche di ottimizzazione degli iperparametri per ottenere potenzialmente ulteriori guadagni in termini di 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 stimolanti 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 GCP
  • Amazon AWS: Guida rapida AWS
  • Microsoft Azure: Guida rapida di AzureML
• Configurazione locale:
  • Docker: Guida rapida a Docker

Stato del progetto

Questo badge indica che tutti i test di GitHub Actions di Integrazione Continua (CI) di YOLOv5 vengono superati con successo. Questi rigorosi test CI coprono le funzionalità principali, tra cui training, validation, inference, export e benchmark, su sistemi operativi macOS, Windows e Ubuntu. I test vengono eseguiti automaticamente ogni 24 ore e ad ogni commit di codice, garantendo stabilità costante e prestazioni ottimali.

FAQ

Domande frequenti

Come posso addestrare YOLOv5 sul mio dataset personalizzato?

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

1. Prepara il tuo set di dati: Raccogli le immagini e annotale. Assicurati che le annotazioni siano nel formato richiesto formato YOLO. Organizza immagini ed etichette in train/ e val/ (e opzionalmente test/) delle directory. Si consiglia di utilizzare modelli come Google Gemini, SAM2, oppure 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 dataset.yaml file.
4. Avvia l'addestramento: Esegui il train.py script, fornendo i percorsi ai tuoi dataset.yaml, pesi pre-addestrati desiderati (ad esempio, yolov5s.pt), dimensioni dell'immagine, dimensione del batch e 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 HUB per addestrare i miei modelli YOLO?

Ultralytics HUB è una piattaforma completa progettata per ottimizzare l'intero ciclo di vita dello sviluppo del modello YOLO, spesso senza la necessità di scrivere codice. I vantaggi principali includono:

• Training semplificato: Addestra facilmente i modelli utilizzando ambienti preconfigurati e un'interfaccia utente intuitiva.
• Gestione integrata dei dati: Carica, controlla le versioni e gestisci i tuoi set di dati in modo efficiente all'interno della piattaforma.
• Monitoraggio in tempo reale: Tieni traccia dei progressi dell'addestramento e visualizza le metriche di performance utilizzando strumenti integrati come Comet o TensorBoard.
• Funzionalità di Collaborazione: Facilita il lavoro di squadra attraverso risorse condivise, strumenti di gestione dei progetti e facile condivisione dei modelli.
• Distribuzione senza codice: Distribuisci i modelli addestrati direttamente su vari target.

Per una dimostrazione pratica, consulta il nostro articolo del blog: Come addestrare i tuoi modelli personalizzati con Ultralytics HUB.

Come posso convertire i miei dati annotati nel formato YOLOv5?

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

• Creane uno .txt file per ogni immagine. Il nome del file deve corrispondere al nome del file immagine (ad esempio, image1.jpg corrisponde a image1.txt). Posiziona questi file in un labels/ directory parallela alla tua images/ directory (ad esempio, ../datasets/mydataset/labels/train/).
• Ogni riga all'interno di un .txt file rappresenta un'annotazione di un oggetto e segue il formato: class_index center_x center_y width height.
• Coordinate (center_x, center_y, width, height) deve essere normalizzato (valori tra 0.0 e 1.0) relativi alle dimensioni dell'immagine.
• Gli indici di classe sono a base zero (la prima classe è 0, il secondo è 1, ecc.).

Molti strumenti di annotazione manuale offrono l'esportazione diretta nel formato YOLO. Se si utilizzano modelli automatizzati, saranno necessari script o processi per convertire il loro output (ad esempio, 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 maggiori dettagli, consulta la nostra Guida alla raccolta e all'annotazione dei dati.

Quali sono le opzioni di licenza per l'utilizzo di YOLOv5 in applicazioni commerciali?

Ultralytics offre 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 con licenza AGPL-3.0. Consultare 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 di AGPL-3.0, consentendo la distribuzione closed source. Visita la nostra pagina delle licenze per ulteriori dettagli o per richiedere una Licenza Enterprise.

Seleziona la licenza che meglio si adatta ai requisiti del tuo progetto e al modello di distribuzione.

📅 Creato 1 anno fa ✏️ Aggiornato 2 mesi fa

Commenti