Inizia

Addestramento dei modelli con Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Introduzione#

L'addestramento di un modello di deep learning consiste nel fornirgli dati e regolarne i parametri affinché possa generare previsioni accurate. La modalità Train di Ultralytics YOLO26 addestra in modo efficiente modelli di rilevamento degli oggetti e altri modelli per attività di visione su hardware moderno. Questa guida illustra i dettagli necessari per iniziare ad addestrare i tuoi modelli con YOLO26. Se non hai ancora installato Ultralytics, inizia dalla guida introduttiva.

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



Guarda: Come addestrare un modello YOLO sul tuo dataset personalizzato in Google Colab.

Perché scegliere Ultralytics YOLO per l'addestramento?#

Motivi per usare la modalità Train di YOLO26:

  • Efficienza: sfrutta al meglio 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 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: ampia gamma di iperparametri personalizzabili per ottimizzare le prestazioni del modello. Per un controllo più approfondito, puoi anche 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 l'addestramento su più GPU per ridurne la durata.
  • 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 delle immagini pari a 640. Puoi specificare il dispositivo di addestramento usando l'argomento device. Se non specifichi alcun argomento, verrà usata la GPU device=0 se disponibile; altrimenti verrà usata device='cpu'.

Errore di multiprocessing su Windows

Su Windows, quando avvii l'addestramento come script, potresti ricevere un RuntimeError. Per risolvere il problema, aggiungi un blocco if __name__ == "__main__": prima del codice di addestramento.

Esempio di addestramento su singola GPU e CPU

Il dispositivo viene determinato automaticamente. Se è disponibile una GPU, verrà usata (dispositivo CUDA 0 predefinito); altrimenti, l'addestramento verrà avviato sulla CPU.

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 sfrutta meglio l'hardware disponibile distribuendo il carico di addestramento su più GPU. Questa funzionalità è disponibile sia tramite l'API Python che tramite l'interfaccia a riga di comando. Per abilitare l'addestramento multi-GPU, specifica gli ID dei dispositivi GPU che vuoi usare.

Esempio di addestramento multi-GPU

Per addestrare con 2 GPU (dispositivi CUDA 0 e 1), usa i seguenti comandi. Se necessario, estendi l'esempio per includere altre GPU.

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])
Supporto multi-GPU su Windows

L'addestramento multi-GPU non funziona su Windows con le wheel ufficiali di PyTorch per torch>=2.4. Ultralytics avvia DDP tramite torch.distributed.run, il cui passaggio di rendezvous crea un TCPStore che, a partire da PyTorch 2.4, usa per impostazione predefinita il backend libuv; le wheel ufficiali per Windows sono invece compilate senza libuv. L'addestramento termina immediatamente con:

RuntimeError: use_libuv was requested but PyTorch was built without libuv support

Impostare USE_LIBUV=0 non risolve il problema, perché il rendezvous crea direttamente TCPStore e quel percorso del codice non legge mai la variabile. Per usare più GPU, addestra il modello su Linux o WSL2; in alternativa, su Windows, addestralo su una singola GPU con device=0.

Addestramento multi-GPU con codice personalizzato

Quando specifichi più dispositivi (ad esempio, device=[0, 1]), Ultralytics avvia internamente una nuova istanza del trainer ed esegue torch.distributed.run dietro le quinte. Funziona con l'uso standard della CLI e con gli script Python non modificati.

Tuttavia, se lo script contiene componenti personalizzati, come un trainer, un validator, un dataset o una pipeline di augmentation personalizzati, questi oggetti non possono essere serializzati e trasferiti automaticamente ai sottoprocessi DDP. In questo caso, devi avviare direttamente lo script con torch.distributed.run:

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
Esempio di addestramento su NPU Ascend
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, così non devi scegliere i dispositivi manualmente. Ordina le GPU disponibili in base all'utilizzo e alla VRAM libera.

Esempio di addestramento su GPU inattive

Per selezionare e usare automaticamente la GPU o le GPU meno occupate per l'addestramento, usa il parametro device -1. Questa opzione è particolarmente utile negli ambienti di calcolo condivisi o sui server con più utenti.

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)

È particolarmente utile negli ambienti di calcolo condivisi o quando esegui più processi di addestramento contemporaneamente, perché i dispositivi vengono scelti in base alle condizioni correnti ogni volta che inizia un'esecuzione.

Addestramento MPS su Apple Silicon#

I modelli Ultralytics YOLO possono essere addestrati sui chip Apple con architettura silicon tramite il framework Metal Performance Shaders (MPS), che esegue calcoli ed elaborazione delle immagini sulle GPU personalizzate di Apple.

Per addestrare sui chip Apple con architettura silicon, specifica mps come dispositivo all'avvio dell'addestramento, in Python o dalla riga di comando:

Esempio di addestramento MPS
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")

Ripresa degli addestramenti interrotti#

Riprendere l'addestramento da un checkpoint salvato è utile se un'esecuzione è stata interrotta inaspettatamente o se vuoi continuare ad addestrare un modello con nuovi dati o per altre epoche.

Quando l'addestramento riprende, 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. L'addestramento riprende quindi dal punto in cui si era interrotto. Passa un argomento data= esplicito insieme a resume per continuare con un dataset diverso da quello del checkpoint.

Per riprendere l'addestramento in Ultralytics YOLO, imposta l'argomento resume su True quando chiami il metodo train e specifica il percorso del file .pt che contiene i pesi del modello addestrato parzialmente.

Per riprendere un'esecuzione di addestramento interrotta in Python o dalla riga di comando:

Esempio di ripresa dell'addestramento
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 si era interrotto, usando lo stato salvato 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. Se l'esecuzione trasmette i dati a Ultralytics Platform, quando riprende continua a usare lo stesso modello della Platform.

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 influiscono sulle prestazioni, sulla velocità e sull'accuratezza del modello. Le impostazioni principali includono la dimensione del batch, il tasso di apprendimento, il momentum e il decadimento dei pesi. Anche la scelta dell'ottimizzatore, della funzione di perdita e della composizione del dataset di addestramento può influire sul processo. Una regolazione e una sperimentazione attente 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; 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.

ArgomentoTipoPredefinitoDescrizione
modelstrNoneSpecifica il file del modello da usare per l'addestramento. Accetta il percorso di un modello pretrained .pt oppure di un file di configurazione .yaml. È essenziale per definire la struttura del modello o inizializzare i pesi.
datastrNonePercorso del file YAML del dataset (ad es. coco8.yaml), che contiene i percorsi dei dati di addestramento e dei dati di convalida, i nomi delle classi e il numero di classi. Per la classificazione, invece, accetta una directory del dataset o il nome di un dataset integrato (ad es. imagenet10).
epochsint100Numero totale di epoche di addestramento. Ogni epoca corrisponde a un passaggio completo sull'intero dataset. Modificare questo valore può influire sulla durata dell'addestramento e sulle prestazioni del modello.
timefloatNoneDurata massima dell'addestramento in ore. Se impostata, questa opzione sostituisce l'argomento epochs e consente di interrompere automaticamente l'addestramento dopo la durata specificata. Utile per gli scenari di addestramento con limiti di tempo.
patienceint100Numero di epoche da attendere senza miglioramenti nelle metriche di convalida prima di interrompere anticipatamente l'addestramento. Aiuta a prevenire l'overfitting interrompendo l'addestramento quando le prestazioni raggiungono un plateau.
batchint o float16Dimensione del batch, con tre modalità: impostazione come intero (ad es., batch=16), modalità automatica per il 60% della memoria GPU disponibile (batch=-1) oppure modalità automatica con una frazione specificata della memoria GPU disponibile (batch=0.70).
imgszint640Dimensione delle immagini di destinazione per l'addestramento. Le immagini vengono ridimensionate a quadrati con lati pari al valore specificato (se rect=False); i modelli YOLO mantengono le proporzioni, mentre RT-DETR no. Influisce sulla precisione del modello e sulla complessità computazionale.
saveboolTrueConsente di salvare i checkpoint di addestramento e i pesi finali del modello. Utile per riprendere l'addestramento o per la distribuzione del modello.
save_periodint-1Frequenza di salvataggio dei checkpoint del modello, specificata in epoche. Il valore -1 disattiva questa funzione. Utile per salvare modelli intermedi durante sessioni di addestramento prolungate.
cachebool o strFalseConsente di memorizzare nella cache le immagini del dataset in memoria (True/ram), su disco (disk) oppure di disattivare la cache (False). Aumenta la velocità di addestramento riducendo le operazioni di I/O su disco, a fronte di un maggiore utilizzo della memoria.
tilebool o intFalseEspande ogni immagine sorgente in riquadri di addestramento di dimensioni fisse, ritagliando le etichette e mantenendo le finestre negative. True usa imgsz; un intero positivo imposta la dimensione del riquadro. Vedi Suddivisione in riquadri ad alta risoluzione.
deviceint o str o listNoneSpecifica i dispositivi di calcolo per l'addestramento: una singola GPU (device=0), più GPU (device=[0,1]), CPU (device=cpu), MPS per Apple silicon (device=mps), NPU Huawei Ascend (device=npu:0 o device=npu:0,1), Intel XPU (device=xpu:0), oppure la selezione automatica di una GPU inattiva (device=-1) o di più GPU inattive (device=[-1,-1]).
workersint8Numero di thread worker per il caricamento dei dati (per RANK nell'addestramento Multi-GPU). Influisce sulla velocità della preelaborazione dei dati e del loro invio al modello; è particolarmente utile nelle configurazioni multi-GPU.
projectstrNoneNome della directory del progetto in cui vengono salvati gli output dell'addestramento. Un percorso relativo viene inserito in runs_dir/<task>, mentre un percorso assoluto viene utilizzato così com'è.
namestrNoneNome dell'esecuzione di addestramento. Viene usato per creare una sottodirectory nella cartella del progetto, dove vengono archiviati i log e gli output dell'addestramento.
exist_okboolFalseSe è True, consente di sovrascrivere una directory progetto/nome già esistente. Utile per sperimentare in modo iterativo senza dover eliminare manualmente gli output precedenti.
save_dirstrNoneSpecifica la directory esatta in cui salvare gli output dell'esecuzione, sostituendo la combinazione project/name. Il percorso viene usato così com'è, senza incrementi automatici; le esecuzioni consecutive riutilizzano quindi la stessa directory.
pretrainedbool o strTrueDetermina se avviare l'addestramento da pesi pretrained. Può essere un valore booleano o il percorso stringa dei pesi da caricare. pretrained=False avvia l'addestramento con pesi inizializzati casualmente, mantenendo l'architettura del modello.
cls_remapboolTrueQuando esegui il fine-tuning su dataset diversi, copia le righe della testa di classificazione pretrained nel nuovo modello per le classi con lo stesso nome, così le classi corrispondenti mantengono il bias appreso e, se la larghezza della testa non cambia, anche i pesi. Si applica sia quando il numero di classi è diverso, sia quando è uguale ma l'ordine delle classi cambia.
optimizerstr'auto'Scelta dell'ottimizzatore per l'addestramento. Le opzioni includono SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp o auto per scegliere AdamW o MuSGD in base al numero di iterazioni di addestramento. Influisce sulla velocità e sulla stabilità della convergenza.
seedint0Imposta il seed casuale per l'addestramento, garantendo la riproducibilità dei risultati tra esecuzioni con le stesse configurazioni.
deterministicboolTrueForza l'uso di algoritmi deterministici, garantendo la riproducibilità, ma può influire sulle prestazioni e sulla velocità a causa dell'esclusione degli algoritmi non deterministici.
verboseboolTrueAbilita l'output dettagliato durante l'addestramento, mostrando barre di avanzamento, metriche per epoca e informazioni aggiuntive sull'addestramento nella console.
single_clsboolFalseTratta tutte le classi dei dataset multi-classe come un'unica classe durante l'addestramento. Utile per le attività di classificazione binaria o quando interessa rilevare la presenza di oggetti anziché classificarli.
classeslist[int]NoneSpecifica un elenco di ID delle classi su cui addestrare il modello. Utile per filtrare le classi e concentrarsi solo su alcune durante l'addestramento.
rectboolFalseAbilita la strategia di padding minimo: le immagini di un batch vengono sottoposte al padding minimo necessario per raggiungere una dimensione comune, con il lato più lungo pari a imgsz. Può migliorare l'efficienza e la velocità, ma può influire sulla precisione del modello. Il trainer YOLO standard usa rect=True per la validazione di detect, segment, pose e OBB, indipendentemente da questa impostazione.
multi_scalefloat0.0Varia casualmente imgsz a ogni batch di +/- multi_scale (ad es. 0.25 -> 0.75x a 1.25x), arrotondando ai multipli dello stride del modello; 0.0 disattiva l'addestramento multi-scala.
cos_lrboolFalseUsa uno scheduler del tasso di apprendimento cosinusoidale, che regola il tasso di apprendimento seguendo una curva cosinusoidale nel corso delle epoche. Aiuta a gestire il tasso di apprendimento per ottenere una convergenza migliore.
close_mosaicint10Disattiva l'aumento dei dati mosaic nelle ultime N epoche per stabilizzare l'addestramento prima del termine. Imposta a 0 per disattivare questa funzione.
resumeboolFalseRiprende l'addestramento dall'ultimo checkpoint salvato. Carica automaticamente i pesi del modello, lo stato dell'ottimizzatore e il conteggio delle epoche, continuando l'addestramento dal punto in cui si era interrotto.
ampbool o strTrueImposta la precisione di addestramento: True o "fp16" usa FP16, "bf16" usa BF16 sui dispositivi CUDA supportati e False o "fp32" usa FP32.
quantizeint o strNoneImposta 8 (o "int8") per l'addestramento con consapevolezza della quantizzazione INT8 (QAT), che esegue il fine-tuning con la fake quantization nel ciclo, in modo che i pesi tollerino l'esportazione INT8. Consulta Addestramento con consapevolezza della quantizzazione.
fractionfloat, int o list1.0Sottoinsieme del dataset espresso come rapporto/numero o elenco [train, val, test]. 1 indica l'intero split, i numeri interi maggiori di 1 indicano il numero di immagini e solo la voce facoltativa del test accetta 0/0.0 per indicare nessun dato. Gli elenchi di due elementi mantengono completo il test.
profileboolFalseAbilita la profilazione delle velocità ONNX e TensorRT durante l'addestramento, utile per ottimizzare la distribuzione del modello.
freezeint o listNoneBlocca i primi N layer del modello oppure layer specifici in base all'indice o al nome del modulo (23.cv2, senza il prefisso model.), riducendo il numero di parametri addestrabili. Utile per il fine-tuning o l'apprendimento per trasferimento.
lr0float0.01Tasso di apprendimento iniziale (ad es. SGD=1E-2, Adam=1E-3). Ignorato con l'impostazione predefinita optimizer='auto'; specifica esplicitamente un ottimizzatore per usarlo.
lrffloat0.01Tasso di apprendimento finale come frazione del tasso iniziale = (lr0 * lrf), usato insieme agli scheduler per regolare il tasso di apprendimento nel tempo.
momentumfloat0.937Momentum SGD/MuSGD o beta1 per gli ottimizzatori Adam. Con optimizer=auto, AdamW usa 0.9; MuSGD parte da 0.9, quindi il warmup interpola da warmup_momentum a momentum. Senza warmup, MuSGD automatico resta su 0.9.
weight_decayfloat0.0005Termine di regolarizzazione L2, che penalizza i pesi elevati per prevenire l'overfitting.
warmup_epochsfloat3.0Epoche di warmup (sono ammesse frazioni), limitate in modo da lasciare l'ultima epoca senza warmup. Il tasso di apprendimento aumenta linearmente da 0 (bias da warmup_bias_lr) al valore pianificato, il momentum da warmup_momentum a momentum e l'accumulo dei gradienti da 1 batch al valore nominale (vedi nbs); tutti raggiungono i rispettivi valori obiettivo al termine del warmup.
warmup_momentumfloat0.8Momentum iniziale per gli ottimizzatori che includono un termine di momentum (SGD, MuSGD, RMSprop), aumentato linearmente fino a momentum entro la fine del warmup. Il beta1 della famiglia Adam non viene sottoposto a warmup.
warmup_bias_lrfloat0.1Tasso di apprendimento dei parametri di bias durante la fase di warmup, utile per stabilizzare l'addestramento del modello nelle prime epoche. Con il valore predefinito optimizer='auto' viene impostato automaticamente su 0.0; specifica esplicitamente un ottimizzatore per usarlo.
distill_modelstrNonePercorso di un checkpoint del modello teacher (ad es. yolo26x.pt) per la distillazione della conoscenza. Se impostato, il modello student viene addestrato con una loss aggiuntiva di distillazione, guidata dal teacher congelato.
disfloat6.0Peso della loss di distillazione aggiunta alle loss di rilevamento standard. Valori più alti aumentano l'influenza delle indicazioni sulle feature fornite dal teacher.
boxfloat7.5Peso della componente della loss relativa ai riquadri nella funzione di perdita, che determina l'importanza attribuita alla previsione accurata delle coordinate dei riquadri di delimitazione.
clsfloat0.5Peso della loss di classificazione nella funzione di perdita totale, che determina l'importanza della corretta previsione della classe rispetto agli altri componenti.
cls_pwfloat0.0Esponente per la ponderazione delle classi, che gestisce lo sbilanciamento tra classi usando la frequenza inversa delle classi. 0.0 disattiva la ponderazione delle classi, mentre 1.0 applica la ponderazione completa basata sulla frequenza inversa. I valori tra 0 e 1 applicano una ponderazione parziale.
dflfloat1.5Peso del termine di regressione delle distanze dei riquadri: loss focalizzata sulla distribuzione (DFL) quando la testa di rilevamento usa reg_max > 1; loss L1 sulle distanze normalizzate dei riquadri in YOLO26 senza DFL (reg_max: 1).
posefloat12.0Peso della loss della posa nei modelli addestrati per la stima della posa, che determina l'importanza attribuita alla previsione accurata dei keypoint della posa.
kobjfloat1.0Peso della loss di objectness dei keypoint nei modelli di stima della posa, che bilancia la confidenza del rilevamento con la precisione della posa.
rlefloat1.0Peso della loss di stima della log-verosimiglianza residua nei modelli di stima della posa, che influisce sulla precisione della localizzazione dei keypoint.
anglefloat1.0Peso della loss dell'angolo nei modelli OBB, che influisce sulla precisione delle previsioni dell'angolo dei riquadri di delimitazione orientati.
dlogfloat1.0Peso della loss logaritmica invariante rispetto alla scala (SILog) nei modelli di stima della profondità, il termine principale che determina la precisione della profondità.
dgradfloat0.5Peso della loss del gradiente nei modelli di stima della profondità, che penalizza gli errori sui bordi in profondità e favorisce contorni delle superfici più netti.
dlamfloat1.0Fattore di enfasi della varianza della loss SILog nei modelli di stima della profondità. 1.0 rende la loss completamente invariante rispetto alla scala, mentre 0.0 la riduce a una semplice RMSE logaritmica.
nbsint64Dimensione nominale del batch. I gradienti vengono accumulati per round(nbs / batch) batch a ogni passaggio dell'ottimizzatore (almeno 1 e, al di fuori della modalità time, al massimo pari al numero totale di batch dell'esecuzione); weight_decay viene ridimensionato in base a batch * accumulate / nbs per compensare.
overlap_maskboolTrueDetermina se le maschere degli oggetti devono essere unite in un'unica maschera per l'addestramento o mantenute separate per ogni oggetto. In caso di sovrapposizione, durante l'unione la maschera più piccola viene sovrapposta a quella più grande.
mask_ratioint4Rapporto di sottocampionamento delle maschere di segmentazione, che influisce sulla risoluzione delle maschere usate durante l'addestramento. Non modifica la risoluzione delle maschere predette.
dropoutfloat0.0Tasso di dropout per la regolarizzazione nelle attività di classificazione, che previene l'overfitting omettendo casualmente delle unità durante l'addestramento.
valboolTrueAbilita la convalida durante l'addestramento, consentendo la valutazione periodica delle prestazioni del modello su un dataset separato.
splitstr'val'Suddivisione del dataset usata per la validazione durante l'addestramento: val, test o train. Le metriche selezionano best.pt e determinano l'arresto anticipato.
nmsbool, facoltativoNoneSeleziona la testa di inferenza usata per la convalida a ogni epoca, la selezione dei checkpoint e l'arresto anticipato. None o True usa la modalità one-to-many con NMS; False usa la testa senza NMS quando disponibile. Entrambe le teste mantengono le rispettive loss di addestramento.
plotsboolTrueGenera e salva grafici delle metriche di addestramento e convalida, oltre a esempi di predizione, offrendo una rappresentazione visiva delle prestazioni del modello e dei progressi dell'apprendimento.
compilebool o strFalseAbilita la compilazione del grafo torch.compile di PyTorch 2.x con backend='inductor'. Accetta True → "default", False → disattivazione oppure una modalità stringa come "default", "reduce-overhead", "max-autotune-no-cudagraphs". Se non è supportata, ripiega sulla modalità eager con un avviso.
channels_lastboolNoneUsa il formato di memoria channels_last (NHWC) per le convoluzioni durante l'addestramento. None lo abilita automaticamente su CUDA con PyTorch 1.11 o versioni successive, tranne che su Windows e AMD ROCm, dove è risultato più lento. False lo disabilita, mentre True lo richiede esplicitamente. L'addestramento su CPU o MPS usa sempre NCHW (True viene ignorato con un avviso).
max_detint300Numero massimo di rilevamenti per immagine durante la convalida in fase di addestramento. Per detect, segment, pose e OBB, il valore predefinito 300 aumenta fino al numero massimo di oggetti etichettati nei set di addestramento/convalida solo se tale numero supera 300. Gli altri valori rimangono invariati; il superamento del limite genera un avviso.
Nota sulle impostazioni della dimensione del batch

L'argomento batch accetta tre tipi di valori e il trainer aggiunge due misure di sicurezza:

  • Dimensione del batch: Imposta un valore intero (ad es. batch=16), specificando direttamente il numero di immagini per batch. L'addestramento multi-GPU suddivide equamente questo batch globale tra le GPU, quindi deve essere almeno pari al numero di GPU; l'eventuale resto viene scartato (ad es. batch=15 su 2 GPU addestra 7 immagini per GPU).
  • Modalità automatica (60% della memoria GPU): usa batch=-1 per regolare automaticamente la dimensione del batch in modo da utilizzare circa il 60% della memoria CUDA disponibile per l'addestramento.
  • Modalità automatica con frazione di utilizzo: imposta un valore frazionario (ad es., batch=0.70) per regolare la dimensione del batch in base alla frazione specificata della memoria GPU disponibile.
  • Nuovo tentativo automatico in caso di OOM: se durante la prima epoca si verifica un errore CUDA di memoria esaurita, il trainer dimezza automaticamente la dimensione del batch e riprova (fino a 3 volte). Questa opzione si applica solo all'addestramento con una singola GPU; l'addestramento multi-GPU (DDP) genera subito l'errore.
  • Nessuna configurazione valida: se nessuna dimensione del batch candidata produce un profilo utilizzabile, AutoBatch genera un RuntimeError esplicito invece di ripiegare silenziosamente su un valore predefinito non pertinente.

Impostazioni e iperparametri di data augmentation#

Le tecniche di aumento dei dati 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 su dati mai visti. La tabella seguente illustra lo scopo e l'effetto di ogni argomento di aumento dei dati:

ArgomentoTipoPredefinitoAttività supportateIntervalloDescrizione
hsv_hfloat0.015detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Regola la tonalità dell'immagine di una frazione della ruota dei colori, introducendo variabilità cromatica. Aiuta il modello a generalizzare in diverse condizioni di illuminazione. Per classify, si applica solo quando auto_augment=None.
hsv_sfloat0.7detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Modifica la saturazione dell'immagine di una frazione, influendo sull'intensità dei colori. Utile per simulare diverse condizioni ambientali. Per classify, si applica solo quando auto_augment=None.
hsv_vfloat0.4detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Modifica il valore (luminosità) dell'immagine di una frazione, aiutando il modello a funzionare bene in diverse condizioni di illuminazione. Per classify, si applica solo quando auto_augment=None.
degreesfloat0detect, segment, semantic, depth, pose, obb0.0 - 180Ruota casualmente l'immagine entro l'intervallo di gradi specificato, migliorando la capacità del modello di riconoscere gli oggetti con orientamenti diversi.
translatefloat0.1detect, segment, semantic, depth, pose, obb0.0 - 1.0Trasla l'immagine orizzontalmente e verticalmente di una frazione delle sue dimensioni, aiutando il modello a imparare a rilevare oggetti parzialmente visibili.
scalefloat | tuple0.5detect, segment, semantic, depth, classify, pose, obb0 - 1 oppure una tupla (min, max) esplicita (non per classify)Ridimensiona l'immagine con un fattore di scala, simulando oggetti a distanze diverse dalla fotocamera.
shearfloat0detect, segment, semantic, depth, pose, obb-180 - +180Inclina l'immagine di un angolo specificato, imitando l'effetto degli oggetti osservati da angolazioni diverse.
perspectivefloat0detect, segment, semantic, depth, pose, obb0.0 - 0.001Applica all'immagine una trasformazione prospettica casuale, migliorando la capacità del modello di comprendere gli oggetti nello spazio 3D.
flipudfloat0detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Capovolge l'immagine verticalmente con la probabilità specificata, aumentando la variabilità dei dati senza alterare le caratteristiche dell'oggetto.
fliplrfloat0.5detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Capovolge l'immagine da sinistra a destra con la probabilità specificata; è utile per apprendere oggetti simmetrici e aumentare la varietà del dataset.
bgrfloat0detect, segment, semantic, depth, pose, obb0.0 - 1.0Inverte i canali dell'immagine da RGB a BGR con la probabilità specificata; è utile per aumentare la robustezza a un ordinamento errato dei canali.
mosaicfloat1detect, segment, semantic, pose, obb0.0 - 1.0Combina quattro immagini di addestramento in una, simulando diverse composizioni di scene e interazioni tra oggetti. Efficace per comprendere scene complesse.
mixupfloat0detect, segment, semantic, pose, obb0.0 - 1.0Fonde due immagini e le relative etichette, creando un'immagine composita. Migliora la capacità di generalizzazione del modello introducendo rumore nelle etichette e variabilità visiva.
cutmixfloat0detect, segment, semantic, pose, obb0.0 - 1.0Combina porzioni di due immagini, creando una fusione parziale e mantenendo al contempo regioni distinte. Migliora la robustezza del modello creando scenari di occlusione.
copy_pastefloat0segment, semantic, obb0.0 - 1.0Frazione degli oggetti idonei incollati; flip li rispecchia all'interno dell'immagine, mentre mixup usa questo valore anche come probabilità di applicazione tra immagini.
copy_paste_modestrflipsegment, semantic, obb-Specifica la strategia copy-paste da utilizzare. Le opzioni includono 'flip' e 'mixup'.
auto_augmentstrrandaugmentclassify-Applica una policy di augmentation predefinita ('randaugment', 'autoaugment' o 'augmix') per migliorare le prestazioni del modello tramite la varietà visiva.
erasingfloat0.4classify0.0 - 1.0Cancella casualmente alcune regioni dell'immagine durante l'addestramento per incoraggiare il modello a concentrarsi su caratteristiche meno evidenti.
augmentationslistNonedetect, segment, semantic, depth, pose, obb-Trasformazioni Albumentations personalizzate per la data augmentation avanzata (solo API Python). Accetta un elenco di oggetti di trasformazione per esigenze di augmentation specifiche.

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 aumento dei dati migliore.

Informazioni

Per ulteriori informazioni sulle operazioni di data augmentation durante l'addestramento, consulta la sezione di riferimento.

Registrazione#

Le metriche di addestramento, i grafici e i checkpoint vengono sempre scritti nella directory dell'esecuzione; inoltre, Ultralytics li trasmette a qualsiasi tracker 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 mostrate le tre configurazioni più comuni.

Comet#

Comet è una piattaforma che consente a data scientist e sviluppatori di monitorare, confrontare, spiegare e ottimizzare esperimenti e modelli. Fornisce metriche in tempo reale, differenze nel codice e monitoraggio degli iperparametri.

Per usare Comet:

Esempio
# 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:

Esempio
# 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:

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

Per usare TensorBoard in locale, esegui il comando riportato di seguito e visualizza i risultati all'indirizzo localhost:6006.

Esempio
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, avvia l'addestramento come di consueto. Le metriche di addestramento vengono registrate automaticamente sulla piattaforma scelta, dove puoi monitorare le prestazioni nel tempo, confrontare i modelli e individuare le 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#

  • Sì. L'addestramento cloud di Ultralytics Platform include crediti gratuiti per iniziare. Carica il tuo dataset, seleziona un modello e una GPU e avvia l'addestramento direttamente dal browser.

  • Per addestrare un modello di rilevamento di oggetti con Ultralytics YOLO26, puoi usare l'API Python oppure la CLI. Di seguito trovi un esempio per ciascuna modalità:

    Esempio di addestramento su singola GPU e CPU
    from ultralytics import YOLO
    
    # Carica un modello
    model = YOLO("yolo26n.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)
    
    # Addestra il modello
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

    Per ulteriori dettagli, consulta la sezione Impostazioni di addestramento.

  • Le funzionalità principali della modalità Train di Ultralytics YOLO26 includono:

    • Download automatico dei dataset: scarica automaticamente dataset standard come COCO, VOC e ImageNet.
    • Supporto multi-GPU: distribuisci l'addestramento su più GPU per elaborare i dati più rapidamente.
    • Configurazione degli iperparametri: personalizza gli iperparametri tramite file YAML o argomenti CLI.
    • Visualizzazione e monitoraggio: tracciamento in tempo reale delle metriche di addestramento per ottenere informazioni più dettagliate.

    Queste funzionalità rendono l'addestramento efficiente e personalizzabile in base alle tue esigenze. Per ulteriori dettagli, consulta la sezione Funzionalità principali della modalità Train.

  • Per riprendere l'addestramento da una sessione interrotta, imposta l'argomento resume su True e specifica il percorso dell'ultimo checkpoint salvato.

    Esempio di ripresa dell'addestramento
    from ultralytics import YOLO
    
    # Carica il modello parzialmente addestrato
    model = YOLO("path/to/last.pt")
    
    # Riprendi l'addestramento
    results = model.train(resume=True)

    Consulta la sezione Ripresa degli addestramenti interrotti per ulteriori informazioni.

  • Lo sbilanciamento tra classi si verifica quando alcune classi hanno molti meno esempi di altre nei dati di addestramento. Questo può causare prestazioni scarse del modello sulle classi rare. Ultralytics YOLO supporta la ponderazione delle classi tramite l'argomento cls_pw per risolvere questo problema. La ponderazione della loss funziona meglio come ultimo passaggio, dopo aver raccolto e sovracampionato le classi rare, come descritto in Gestire lo sbilanciamento tra classi.

    L'argomento cls_pw controlla il livello di ponderazione delle classi in base alla frequenza inversa delle classi:

    • cls_pw=0.0 (predefinito): disattiva la ponderazione delle classi
    • cls_pw=1.0: applica la ponderazione completa in base alla frequenza inversa
    • Valori compresi tra 0.0 e 1.0: applicano una ponderazione parziale per uno sbilanciamento moderato

    I pesi delle classi vengono calcolati come (1.0 / class_counts) ^ cls_pw e normalizzati in modo che la loro media sia pari a 1.0. class_counts è il numero di oggetti etichettati per classe, oppure il numero di immagini di addestramento per classe nel caso della classificazione; le classi senza etichette di addestramento, come quelle escluse da classes=, ricevono un peso di 1.0. La segmentazione semantica calcola invece i pesi in base alla frequenza dei pixel, come (1.0 / ln(1.02 + p)) ^ cls_pw, dove p è la quota di pixel di addestramento etichettati appartenenti a ciascuna classe; di conseguenza, una classe priva di pixel etichettati riceve il peso più alto.

    Addestramento su un dataset sbilanciato
    from ultralytics import YOLO
    
    # Carica un modello preaddestrato
    model = YOLO("yolo26n.pt")
    
    # Addestra con la ponderazione completa delle classi per dati con forte sbilanciamento
    results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)
    
    # Oppure usa una ponderazione parziale (0.25) per uno sbilanciamento moderato
    results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)
    Suggerimento

    Inizia con cls_pw=0.25 per i dataset moderatamente sbilanciati e aumenta il valore a 1.0 se le prestazioni delle classi rare restano insufficienti. Puoi verificare la distribuzione dei pesi controllando i pesi delle classi calcolati nei log di addestramento.

  • Sì, Ultralytics YOLO26 supporta l'addestramento sui chip Apple con architettura silicon tramite il framework Metal Performance Shaders (MPS). Specifica mps come dispositivo di addestramento.

    Esempio di addestramento MPS
    from ultralytics import YOLO
    
    # Carica un modello preaddestrato
    model = YOLO("yolo26n.pt")
    
    # Addestra il modello su un chip Apple silicon (M1/M2/M3/M4)
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

    Per ulteriori dettagli, consulta la sezione Addestramento con Apple Silicon MPS.

  • Ultralytics YOLO26 ti permette di configurare diverse impostazioni di addestramento tramite argomenti, come la dimensione del batch, il tasso di apprendimento, il numero di epoche e altro. Ecco una breve panoramica:

    ArgomentoPredefinitoDescrizione
    modelNonePercorso del file del modello da usare per l'addestramento.
    dataNonePercorso del file YAML del dataset (ad es. coco8.yaml) oppure directory o nome del dataset (ad es. imagenet10) per la classificazione.
    epochs100Numero totale di epoche di addestramento.
    batch16Dimensione del batch, configurabile come numero intero o in modalità automatica.
    imgsz640Dimensione di destinazione delle immagini per l'addestramento.
    deviceNoneDispositivo o dispositivi di calcolo per l'addestramento, ad esempio cpu, 0, 0,1 o mps.
    saveTrueAbilita il salvataggio dei checkpoint di addestramento e dei pesi finali del modello.

    Per una guida approfondita sulle impostazioni di addestramento, consulta la sezione Impostazioni di addestramento.

Commenti1074

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  1. drcosimoGitHub

    Hi there, I' m new to this field and I'm trying to train a YOLO model for detection and tracking of video streams for security.

    Until now I have managed to create my pipeline for training and I want to understand if it's a correct/possible approach:

    1. Load a pretrained model from yolo

    2. transfer learning with my custom dataset that possibly can focus on just some classes(person,car,truck,bus,bycicle)

    3. Validate model to see how it performs

    4. Operate a tuning with the custom best model and using my custom dataset

    5. Retrain the initial pretrained model with my custom dataset and the best hyperparameters found in the tuning process.

    6. Validate final model

    The questions are several:

    • The above approach is logically correct or it has flaws?
    • Is it correct to narrow the detected classes? Or it isn't crucial to the precision of the model?
    • When tuning(if its a correct approach) should i use my dataset or try the coco dataset to keep generalization?
    • When tuning should i specify the classes to detect?
    • When retraining should I use the first pretrained model or it is better to use my custom trained model?
    • In the final training am I using the correct parameters?

    Here the code of the pipeline:

    from ultralytics import YOLO import yaml

    load pretrained model from coco dataset

    model:YOLO = YOLO('yolov8n.yaml').load('yolov8n.pt')

    train_classes = []

    NOTE if you're using COCO format, the new dataset should also be in COCO format.

    operate transfer learning with my custom dataset, narrowing the classes to the ones I want to detect

    model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,optimizer='AdamW',device=[0,1],augment=True,name='custom_model')

    load custom model

    custom_model = YOLO('path/to/best.pt')

    validate custom model

    custom_model.val()

    try tuning to find the best hyperparameters for my custom model

    custom_model.tune(data='custom_data.yaml', epochs=50, iterations=100,optimizer="AdamW", plots=True,save=True,val=True)

    load best hyperparameters

    cfg = yaml.load(open('path/to/best_hyperparameters.yaml'))

    retrain custom model from pretrained on coco with best hyperparameters

    model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,device=[0,1],name='custom_model',exist_ok=True,optimizer='AdamW',**cfg)

    load and validate

    tuned_custom_model = YOLO('path/to/best.pt')

    tuned_custom_model.val()


    Thank you for your effort and time in this project!

    3
    1. Paula DerrengerUltralytics(modificato)

      Hello,

      Your approach to training a YOLO model for detection and tracking is well-thought-out and mostly aligns with best practices. Here are some insights and answers to your questions:

      1. Approach Validity: Your steps are logically sound. Starting with a pretrained model and applying transfer learning to your specific classes is a recommended strategy. Validating and tuning based on the performance helps refine the model further.

      2. Narrowing Detected Classes: It's perfectly fine to focus on specific classes if those are the only ones relevant to your use case. This can help improve the model's performance by reducing the complexity of the problem it needs to solve.

      3. Dataset for Tuning: Use your custom dataset for tuning. This ensures that the hyperparameters are optimized for the specific characteristics of your data rather than the general characteristics of the COCO dataset.

      4. Specifying Classes During Tuning: When tuning, you should specify the classes if your dataset is a subset of the original classes used in the pretrained model. This helps in focusing the model’s learning and evaluation on relevant classes.

      5. Model for Retraining: Tuning only finds hyperparameters, so the usual practice is to train again from the original pretrained model with the best hyperparameters, as in your step 5. Continuing from the already fine-tuned model is also possible, but then it effectively trains for longer, which makes the result harder to compare with the tuning runs.

      6. Parameters for Final Training: The parameters should be chosen based on the results of your tuning. Ensure that they are the ones that gave the best validation performance during the tuning phase.

      Keep up the great work, and don't hesitate to reach out if you have more questions!

    2. drcosimoGitHub

      Thank you very much for you response. I adjusted my script to follow your insights. I have another question regarding transfer learning. The normal approach in transfer learning is to freeze the first n layers to preserve the more generic feature extraction properties of an already trained model and then it is retrained letting only the remaining layers update. I found the callback function to achieve this. My question is, applying the fine-tuning as specified by ultralytics documentation has the same effect? What I mean is: executing the train method again on a pretrained model changing the dataset causes the underlying library to execute the freeze automatically? If it isn't the case it is not clear to me why the fine-tuning is said to have the same effect as applying transfer learning.

      Another question is: it is useful to take a pretrained model from ultralytics and train it with the coco dataset? Because from what I know the pretrained model is already trained using coco dataset. Doing such a thing following the logic you provide for fine-tuning would be essentially the same as resuming a training / do the same train with more epochs?

      Thank you again for your time.

    3. Paula DerrengerUltralytics

      Hello,

      Thank you for your follow-up questions. Let's address each of them:

      1. Freezing Layers in Transfer Learning: The Ultralytics YOLO framework does not automatically freeze any layers when you initiate training, even if you're using a pretrained model. If you want to freeze the first N layers (common in transfer learning to preserve learned features), you must explicitly specify this in your training script. This is different from some other frameworks that might automate this aspect of transfer learning.

      2. Training on COCO Dataset with a Pretrained Model: If the pretrained model you are using was already trained on the COCO dataset, retraining it on the same dataset without significant changes or additional data might not yield substantial improvements. It could be beneficial for fine-tuning if you've made modifications to the model architecture or if you're using a significantly altered version of the dataset. However, generally, this approach would indeed be akin to simply extending the training duration.

      For fine-tuning and transfer learning, it's crucial to tailor the approach based on what changes you've made to the dataset or model and your specific goals (e.g., improving accuracy, adapting to new classes, etc.).

      I hope this clarifies your queries! If you have more questions or need further assistance, feel free to ask.

    1. Paula DerrengerUltralytics

      哈哈,确实,“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”,指的是在机器学习中对模型进行训练,以提高其准确性和效率。感谢您指出这个问题,我们会尽快修正翻译错误。如果您有任何其他建议或问题,欢迎随时告诉我们!🚀

      2
  2. Syedshajib55GitHub

    Hi, does platform.ultralytics currently support using custom PyTorch modules directly via a YAML configuration without modifying tasks.py or the core source code? We are attempting to train a custom architecture (e.g., YOLO26) and want to know if there is an existing feature for dynamic module registration.

    1
    1. Muh-7GitHub

      Hi, As far as I know, not at the moment. Ultralytics doesn't seem to have a built-in dynamic registration system where you can define a custom PyTorch module outside the repo and then use it directly in the YAML.

      Usually, the custom module still needs to be imported/registered in tasks.py so that parse_model() can resolve it from the YAML.

      It would be really useful if Ultralytics added something like a register_module() API for this, though.

    2. Murat Raimbekov

      @Syedshajib55 @Muh-7 Platform can train any model that the ultralytics Python package can build, including custom architectures from a modified package or fork. The custom code runs on your own hardware; Platform receives real-time metrics, console and system logs, plots, and the final weights.

      There is no dynamic registration API. parse_model() resolves layer names from the ultralytics.nn.tasks namespace, so a name in your YAML must exist there. You don't need to edit tasks.py for that — expose the class from your own package before building the model:

      import ultralytics.nn.tasks as tasks
      from my_custom_package import MyBlock
      
      tasks.MyBlock = MyBlock  # now `[-1, 1, MyBlock, [...]]` resolves in the YAML

      Full local training with metric streaming to Platform:

      pip install "ultralytics>=8.4.120"
      export ULTRALYTICS_API_KEY="YOUR_API_KEY"
      import ultralytics.nn.tasks as tasks
      from my_custom_package import MyBlock
      from ultralytics import YOLO
      
      tasks.MyBlock = MyBlock
      
      model = YOLO("custom-model.yaml")  # YAML referencing MyBlock
      model.train(
          data="ul://username/datasets/my-dataset",
          epochs=100,
          project="username/my-project",
          name="custom-architecture",
      )

      project and name enable the Platform integration automatically; nothing else is required. Verified on 8.4.157 with a custom nn.Module inserted into a YOLO26n YAML: the model builds, trains, and appears on Platform as a completed run with weights and train args.

      One caveat: the saved .pt pickles the class by import path (my_custom_package.MyBlock), so any environment that loads it needs that package importable — otherwise loading fails with ModuleNotFoundError. That includes Platform-side features that load the uploaded weights with the stock package (Predict, Export, Deploy); local training and streaming are unaffected. Setup details: https://docs.ultralytics.com/platform/train/cloud-training/#remote-training

  3. RussellLee12345GitHub

    Hello all,

    I want my training images to rotate 360 degrees randomly. How do I set the hyper-parameter: degrees?

    Thanks a lot.

    1
    1. Glenn JocherUltralytics

      @RussellLee12345 to rotate your training images randomly up to 360 degrees, set the degrees parameter to 180 in your training configuration. This allows for rotations within the range of -180 to +180 degrees. For more details, see the augmentation settings in the Train Settings documentation.

  4. GKYofficeGitHub

    Please tell me how to set imgsz when I use the yolo11 model for training. Can it only be an integer (this means that the final input is a square)? After I modify this parameter, will the input interface of the network change the input of data? There are corresponding transformations, such as imgsz=1280, does it mean that my input data will be resized to 1280*1280 and input into the network for training?

    Thanks!

    1
    1. Glenn JocherUltralytics

      @GKYoffice when using the YOLO11 model, imgsz can be set as an integer, which resizes the input data to a square of that size (e.g., 1280x1280). This parameter adjusts the input dimensions for training. For more details, please visit the training documentation.

  5. IruhDegSetGitHub

    hi, I'm just wondering if yolov8 accepts class weights, in the data.yaml file:

    names: ['class 1', 'class 2', 'class 3']
    classes_weights: [c1_weight, c2_weight, c3_weight]

    if no how to incorpoorate wighted loss in yolov8 THX

    1
    1. Glenn JocherUltralytics

      @IruhDegSet yOLOv8 does not directly support class weights in the data.yaml file. To incorporate weighted loss, you can modify the loss function in the training script to apply different weights to each class. For more details, you might explore custom loss implementations in PyTorch.

    2. Glenn JocherUltralytics(modificato)

      Yes, YOLO11 supports similar features, including training and hyperparameter customization. For specific details on YOLO11, please refer to the documentation or the relevant sections in the repository.

  6. User

    Dear author, how are the weights of these three losses set: box: 7.5, cls: 0.5, dfl: 1.5? Are they adjusted on the COCO validation, manually adjusted, or obtained through hyperparameter search? For the model I trained, the output confidence scores are very low. I directly increased the weight of cls by 10 times, but the effect did not improve. What other methods can I take?

    1
    1. Glenn JocherUltralytics

      @Stephen-Hao the weights for the box, cls, and dfl losses in YOLOv8 are typically set based on empirical results and fine-tuning on standard datasets like COCO. These values are chosen to balance the contributions of each loss component to the overall training process. If increasing the cls weight did not improve your model's performance, consider the following approaches:

      1. Hyperparameter Tuning: Experiment with other hyperparameters such as learning rate, batch size, and augmentation settings.
      2. Data Quality: Ensure your dataset is well-labeled and balanced. Poor quality data can significantly affect model performance.
      3. Training Duration: Increase the number of epochs to allow the model more time to learn.
      4. Validation: Regularly validate your model to monitor overfitting and adjust training strategies accordingly.

      For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.

    2. Glenn JocherUltralytics

      @Stephen-Hao thank you for your question! The weights for box, cls, and dfl losses are typically set based on empirical results and fine-tuning on standard datasets like COCO. If increasing the cls weight didn't improve your model's performance, consider experimenting with other hyperparameters such as learning rate, batch size, and augmentation settings. Additionally, ensure your dataset is well-labeled and balanced. For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.

    1. Glenn JocherUltralytics(modificato)

      Hey there! 🙌 It's awesome that you're looking to further improve your model with new data. To re-train a pre-trained model on a new dataset, you can simply follow these steps:

      1. Make sure your new dataset is prepared in the same YOLO format as your initial training (a dataset YAML plus one .txt label file per image).

      2. Load your pre-trained model using the YOLO loading method, then specify your new dataset in the train method. Here's a quick code snippet for clarity:

        from ultralytics import YOLO
        
        # Load your pre-trained model
        model = YOLO('path/to/your/pretrained/model.pt') 
        
        # Start training on the new dataset
        results = model.train(data='path/to/your/new/dataset.yaml', epochs=50, imgsz=640)

      Just replace 'path/to/your/pretrained/model.pt' and 'path/to/your/new/dataset.yaml' with the actual paths to your model and new dataset config file, respectively. Adjust the epochs and imgsz (image size) to suit your needs. 🛠️

      That's it! Your model will now continue training on the new dataset. If you have any further questions or run into issues, feel free to ask. Happy training! 🚀

  7. songziang182GitHub

    谢谢你们开发了这么完善的 yolov8🙏, 我想问一下,这两种训练方式的区别 model = YOLO('yolov8n.pt') model = YOLO('yolov8n.yaml').load('yolov8n.pt') model.train(.........)

    1
    1. Paula DerrengerUltralytics

      Hello there! 😊

      The main difference between the two training methods you've mentioned:

      1. model = YOLO('yolov8n.pt'): This directly loads a pretrained YOLOv8n model. It's the simplest way to load a model that has already been trained, making it ready for further training, evaluation, or inference right away.

      2. model = YOLO('yolov8n.yaml').load('yolov8n.pt'): This approach builds a new model from the YAML configuration file and then transfers the weights from the pretrained .pt model. It's a two-step process, where the model is first constructed based on the architecture defined in the YAML file, and then the weights from a pretrained model are loaded. This method is useful when you want to customize the model architecture before loading the weights.

      Both methods ultimately get you to a similar starting point for continuing training or making predictions. The choice depends on whether you need to customize the model architecture as defined in the YAML file before applying the pretrained weights.

      Let me know if this helps or if you have more questions!

    2. songziang182GitHub

      Thank you for answering me. I find it very useful. I have another question, which is the configuration file yolov8n.yaml. I didn’t find where it is. Can I adjust the scale of the model, for example, n, s, m, l, etc., is this the case?

    3. Paula DerrengerUltralytics(modificato)

      Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!

      Regarding the yolov8n.yaml configuration file, it defines the architecture for YOLOv8 models. All scales share one model file (yolov8.yaml) that contains a scales section mapping each letter to [depth, width, max_channels]; the letter in the name you load (yolov8n.yaml, yolov8s.yaml, ...) selects the scale:

      scales:
        n: [0.33, 0.25, 1024]
        s: [0.33, 0.50, 1024]

      To create or modify a model, copy the YAML from the Ultralytics GitHub repository, edit the layers or scales, then load it together with the pretrained weights as you mentioned:

      model = YOLO('path/to/custom_yolov8.yaml').load('yolov8n.pt')
      model.train(.........)

      Model changes can require a solid understanding of the network architecture to be effective.

      I hope this clarifies your question! Feel free to reach out if you have further queries or need more examples. 😊

  8. vonzoGitHub

    So, imgsz works different when training than when predicting?

    For train: if it's an int the ratio will be kept and the train function will take care of that (can't be a tuple). For predict: if it's an int the image will be resized as a square of size imgsz x imgsz, if it's a tuple the image will be resized using HxW and the user has to take care of the ratio and stride.

    Is this right? I would add a comment in the doc to avoid confusions

    1
    1. Paula DerrengerUltralytics(modificato)

      You've got it mostly right! 👍 For training (train), imgsz is an int, the aspect ratio is maintained and resizing is handled internally. It can't be a tuple. For prediction (predict), an int imgsz resizes the longest side to imgsz while keeping the aspect ratio, with padding only up to a multiple of the model stride (so the image is not forced into a square), and a [h, w] list sets the size explicitly.

      Great suggestion on the documentation comment – clarity is key! If you have any more questions or need further examples, feel free to ask. 😊