Addestramento dei modelli con Ultralytics YOLO#

Introduzione#

L'addestramento di un modello di deep learning consiste nel fornirgli dati e modificarne i parametri affinché possa effettuare predizioni accurate. La modalità train di Ultralytics YOLO26 è progettata per addestrare modelli di rilevamento degli oggetti in modo efficace ed efficiente, sfruttando appieno le capacità dell'hardware moderno. Questa guida illustra tutti i dettagli necessari per iniziare ad addestrare i tuoi modelli con il robusto insieme di funzionalità di YOLO26. Se non hai ancora installato Ultralytics, inizia con la guida introduttiva.

Consulta l'anteprima non ancora rilasciata di YOLO27 per gli esempi di addestramento previsti.

Perché scegliere Ultralytics YOLO per l'addestramento?#

Ecco alcuni validi motivi per scegliere la modalità Train di YOLO26:

• Efficienza: sfrutta al massimo il tuo hardware, che tu utilizzi una singola GPU o distribuisca il carico su più GPU.
• Versatilità: addestra i modelli su dataset personalizzati, oltre che su quelli facilmente disponibili come COCO, VOC e ImageNet.
• Facilità d'uso: interfacce CLI e Python semplici ma potenti, per un'esperienza di addestramento immediata.
• Flessibilità degli iperparametri: un'ampia gamma di iperparametri personalizzabili per ottimizzare le prestazioni del modello. Per un controllo più approfondito, puoi personalizzare il trainer.
• Addestramento nel cloud: addestra i modelli su GPU cloud tramite la piattaforma Ultralytics, con metriche in tempo reale e salvataggio automatico dei checkpoint.

Funzionalità principali della modalità Train#

Ecco alcune funzionalità degne di nota della modalità Train di YOLO26:

• Download automatico dei dataset: le configurazioni dei dataset con una fonte di download vengono scaricate automaticamente al primo utilizzo, ad esempio yolo train data=coco8.yaml. Consulta la panoramica dei dataset per conoscere i formati e i dataset supportati.
• Supporto multi-GPU: distribuisci senza problemi l'addestramento su più GPU per accelerare il processo.
• Configurazione degli iperparametri: puoi modificare gli iperparametri tramite file di configurazione YAML o argomenti CLI.
• Visualizzazione e monitoraggio: monitoraggio in tempo reale delle metriche di addestramento e visualizzazione del processo di apprendimento per ottenere informazioni più utili.

Esempi d'uso#

Addestra YOLO26n sul dataset COCO8 per 100 epoche con dimensione dell'immagine pari a 640. Puoi specificare il dispositivo di addestramento usando l'argomento device. Se non passi alcun argomento, verrà usata la GPU device=0 se disponibile; altrimenti verrà usata device='cpu'. Consulta la sezione Argomenti qui sotto per l'elenco completo degli argomenti di addestramento.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.yaml")  # crea un nuovo modello dal file YAML
model = YOLO("yolo26n.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # crea dal file YAML e trasferisci i pesi

# Addestra il modello
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Addestramento multi-GPU#

L'addestramento multi-GPU consente di utilizzare in modo più efficiente le risorse hardware disponibili, distribuendo il carico di addestramento su più GPU. Questa funzionalità è disponibile sia tramite l'API Python sia tramite l'interfaccia a riga di comando. Per attivare l'addestramento multi-GPU, specifica gli ID dei dispositivi GPU che vuoi usare.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)

# Addestra il modello con 2 GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Addestra il modello con le due GPU meno occupate
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

python -m torch.distributed.run --nproc_per_node 2 your_training_script.py

L'addestramento su GPU AMD usa una build di PyTorch con ROCm, con la sintassi standard device=0 o device=cuda:0. Consulta la guida all'integrazione AMD per informazioni sull'installazione di ROCm, l'addestramento multi-GPU e le note su AMP, oltre che sull'inferenza MIGraphX dei modelli esportati.

L'addestramento su GPU Intel usa device=xpu:0 oppure più ID XPU con una build di PyTorch che supporti XCCL.

Addestramento su NPU Huawei Ascend#

Ultralytics supporta l'addestramento e la convalida su NPU Huawei Ascend tramite torch_npu. Installa versioni compatibili tra loro di CANN, PyTorch e torch_npu seguendo la guida all'installazione di Ascend Extension for PyTorch, quindi carica l'ambiente CANN prima di avviare Ultralytics:

source /usr/local/Ascend/ascend-toolkit/set_env.sh

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Addestra su una NPU Ascend
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Addestra su due NPU Ascend con HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Le funzionalità standard di addestramento, tra cui AMP, convalida, salvataggio dei checkpoint e ripresa, usano la NPU attiva. AutoBatch è disponibile per l'addestramento su una singola NPU, mentre più ID NPU avviano l'addestramento distribuito tramite HCCL. Consulta la guida all'integrazione di Huawei Ascend per informazioni sull'esportazione e il deployment del modello dopo l'addestramento.

Addestramento su GPU inattive#

L'addestramento su GPU inattive seleziona automaticamente le GPU meno utilizzate nei sistemi multi-GPU, ottimizzando l'uso delle risorse senza dover scegliere manualmente le GPU. Questa funzionalità individua le GPU disponibili in base alle metriche di utilizzo e alla disponibilità di VRAM.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)

# Addestra usando la GPU meno occupata
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Addestra usando le due GPU meno occupate
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

L'algoritmo di selezione automatica dà priorità alle GPU con:

1. Percentuali di utilizzo attuale inferiori
2. Maggiore memoria disponibile (VRAM libera)

Questa funzionalità è particolarmente utile negli ambienti di calcolo condivisi o quando si eseguono più processi di addestramento su modelli diversi. Si adatta automaticamente alle condizioni mutevoli del sistema, garantendo un'allocazione ottimale delle risorse senza interventi manuali.

Addestramento MPS su Apple Silicon#

Grazie al supporto integrato per i chip Apple Silicon nei modelli Ultralytics YOLO, ora puoi addestrare i tuoi modelli su dispositivi che usano il potente framework Metal Performance Shaders (MPS). MPS offre un metodo ad alte prestazioni per eseguire calcoli e attività di elaborazione delle immagini sui chip proprietari di Apple.

Per attivare l'addestramento sui chip Apple Silicon, specifica 'mps' come dispositivo quando avvii il processo di addestramento. Ecco un esempio di come farlo in Python e tramite la riga di comando:

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)

# Addestra il modello con MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Sfruttando la potenza di calcolo dei chip Apple Silicon, puoi elaborare le attività di addestramento in modo più efficiente. Per indicazioni più dettagliate e opzioni di configurazione avanzate, consulta la documentazione di PyTorch MPS.

Ripresa degli addestramenti interrotti#

Riprendere l'addestramento da uno stato salvato in precedenza è una funzionalità fondamentale quando si lavora con modelli di deep learning. Può tornare utile in vari scenari, ad esempio quando il processo di addestramento viene interrotto inaspettatamente o quando vuoi continuare ad addestrare un modello con nuovi dati o per più epoche.

Quando l'addestramento viene ripreso, Ultralytics YOLO carica i pesi dell'ultimo modello salvato e ripristina anche lo stato dell'ottimizzatore, lo scheduler del tasso di apprendimento, il numero di epoche e il dataset. In questo modo puoi continuare il processo di addestramento senza interruzioni dal punto in cui era stato interrotto. Passa un data= esplicito insieme a resume per continuare con un dataset diverso da quello del checkpoint.

Puoi riprendere facilmente l'addestramento in Ultralytics YOLO impostando l'argomento resume su True quando chiami il metodo train e specificando il percorso del file .pt contenente i pesi del modello parzialmente addestrato.

Di seguito è riportato un esempio di come riprendere un addestramento interrotto usando Python e la riga di comando:

from ultralytics import YOLO

# Carica un modello
model = YOLO("path/to/last.pt")  # carica un modello parzialmente addestrato

# Riprendi l'addestramento
results = model.train(resume=True)

Impostando resume=True, la funzione train continuerà l'addestramento dal punto in cui era stato interrotto, usando lo stato memorizzato nel file 'path/to/last.pt'. Se l'argomento resume viene omesso o impostato su False, la funzione train avvierà una nuova sessione di addestramento.

Ricorda che, per impostazione predefinita, i checkpoint vengono salvati alla fine di ogni epoca o a intervalli fissi usando l'argomento save_period, quindi devi completare almeno 1 epoca per riprendere un'esecuzione di addestramento.

Impostazioni di Train#

Le impostazioni di addestramento dei modelli YOLO comprendono vari iperparametri e configurazioni usati durante il processo di addestramento. Queste impostazioni influenzano le prestazioni, la velocità e la precisione del modello. Tra le impostazioni di addestramento principali figurano la dimensione del batch, il tasso di apprendimento, il momentum e il weight decay. Anche la scelta dell'ottimizzatore, della funzione di perdita e della composizione del dataset di addestramento può influire sul processo. Una regolazione accurata e la sperimentazione con queste impostazioni sono fondamentali per ottimizzare le prestazioni.

Ottimizzatore MuSGD#

In YOLO26, MuSGD è un ottimizzatore ibrido che combina gli aggiornamenti standard di SGD con gli aggiornamenti ortogonalizzati in stile Muon.

È consigliato per le sessioni di addestramento di YOLO26 più lunghe e per i dataset più grandi, in cui gli aggiornamenti ortogonalizzati di Muon possono contribuire a stabilizzare l'ottimizzazione.

Solo i pesi lineari 2D e i filtri convoluzionali 4D (rimodellati in 2D) ricevono l'aggiornamento in stile Muon insieme a SGD, mentre tutti gli altri parametri, come i pesi della normalizzazione del batch e i termini di bias, continuano a usare SGD standard.

Quando si usa optimizer=auto, Ultralytics seleziona automaticamente MuSGD per le sessioni di addestramento più lunghe (in genere quando le iterazioni > 10000). Per le sessioni più brevi, il trainer passa a AdamW. In modalità auto, il trainer seleziona anche il tasso di apprendimento, quindi un valore lr0 fornito dall'utente viene ignorato. Per controllare manualmente queste impostazioni, seleziona esplicitamente un ottimizzatore, ad esempio optimizer=AdamW lr0=0.001.

Esempio d'uso:

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

Consulta l'implementazione in ultralytics/optim/muon.py e la logica di selezione automatica dell'ottimizzatore in BaseTrainer.build_optimizer.

Impostazioni e iperparametri di data augmentation#

Le tecniche di data augmentation sono essenziali per migliorare la robustezza e le prestazioni dei modelli YOLO, introducendo variabilità nei dati di addestramento e aiutando il modello a generalizzare meglio sui dati mai visti. La tabella seguente illustra lo scopo e l'effetto di ciascun argomento di augmentation:

Puoi modificare queste impostazioni in base ai requisiti specifici del dataset e dell'attività. Sperimentare con valori diversi può aiutarti a trovare la strategia di augmentation ottimale per ottenere le migliori prestazioni del modello.

Registrazione#

Le metriche di addestramento, i grafici e i checkpoint vengono sempre scritti nella directory dell'esecuzione; Ultralytics li trasmette anche a qualsiasi sistema di tracciamento degli esperimenti installato e abilitato: Comet, ClearML, TensorBoard, MLflow, Weights & Biases e DVCLive. Puoi attivare o disattivare ciascun logger tramite le impostazioni di Ultralytics, ad esempio yolo settings tensorboard=True. Di seguito sono illustrate le tre configurazioni più comuni.

Comet#

Comet è una piattaforma che permette a data scientist e sviluppatori di monitorare, confrontare, spiegare e ottimizzare esperimenti e modelli. Offre funzionalità come metriche in tempo reale, differenze nel codice e tracciamento degli iperparametri.

Per usare Comet:

# pip install comet_ml
import comet_ml

comet_ml.login()

Ricordati di accedere al tuo account Comet sul sito web e di ottenere la chiave API. Dovrai aggiungerla alle variabili d'ambiente o al tuo script per registrare gli esperimenti.

ClearML#

ClearML è una piattaforma open source che automatizza il tracciamento degli esperimenti e facilita la condivisione efficiente delle risorse. È progettata per aiutare i team a gestire, eseguire e riprodurre il proprio lavoro di ML in modo più efficiente.

Per usare ClearML:

# pip install clearml
import clearml

clearml.browser_login()

Dopo aver eseguito questo script, dovrai accedere al tuo account ClearML tramite il browser e autenticare la sessione.

TensorBoard#

TensorBoard è un toolkit di visualizzazione per TensorFlow. Ti permette di visualizzare il grafo TensorFlow, tracciare metriche quantitative sull'esecuzione del grafo e mostrare dati aggiuntivi, come le immagini che lo attraversano.

Per usare TensorBoard in Google Colab:

%load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Per usare TensorBoard in locale, esegui il comando seguente e visualizza i risultati in localhost:6006.

tensorboard --logdir ultralytics/runs # replace with 'runs' directory

In questo modo TensorBoard verrà caricato e indirizzato alla directory in cui sono salvati i log di addestramento.

Dopo aver configurato il logger, puoi procedere con l'addestramento del modello. Tutte le metriche di addestramento verranno registrate automaticamente sulla piattaforma scelta e potrai consultare questi log per monitorare nel tempo le prestazioni del modello, confrontare modelli diversi e individuare aree da migliorare.

E adesso?#

Convalida il modello addestrato su dati di test esclusi dall'addestramento per verificarne la precisione nel mondo reale, quindi esportalo in ONNX, TensorRT o in un altro formato di distribuzione. Addestri il modello sui tuoi dati invece che su COCO8? Formattali prima seguendo la guida ai dataset.

Domande frequenti#