Addestramento nel Cloud#
Ultralytics Platform Cloud Training offre l'addestramento con un solo clic su GPU cloud, rendendo l'addestramento dei modelli accessibile senza configurazioni complesse. Addestra i modelli YOLO con lo streaming delle metriche in tempo reale e il salvataggio automatico dei checkpoint.
graph LR
A[Configure]:::start --> B[Start Training]:::proc
B --> C[Provision GPU]:::proc
C --> D[Download Dataset]:::proc
D --> E[Train]:::proc
E --> F[Stream Metrics]:::proc
F --> G[Save Checkpoints]:::proc
G --> H[Complete]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffFinestra di dialogo per l'addestramento#
Avvia l'addestramento dall'interfaccia utente della piattaforma cliccando su New Model in qualsiasi pagina di progetto o dataset. La finestra di dialogo per l'addestramento ha due schede: Cloud Training e Local Training. Quando il dataset selezionato si trova su un host On Premise, la prima scheda diventa On Premise e la scheda di addestramento locale viene nascosta; quel dataset può essere addestrato solo sul proprio host, il che richiede un piano Enterprise e un worker connesso e online.

Passaggio 1: Seleziona il modello base#
Scegli un modello Ultralytics ufficiale o uno dei tuoi modelli completati:
| Scheda | Descrizione |
|---|---|
| Ufficiali | Modelli di progetto YOLO26 (consigliato), YOLO11, YOLOv8 e YOLOv5 |
| My Models | I tuoi modelli completati o caricati, raggruppati per progetto, per il fine-tuning |
All'interno di ogni scheda, i modelli sono raggruppati per task in ordine canonico e ordinati per dimensione. Il selettore filtra i modelli ufficiali in base ai task compatibili con il dataset selezionato. YOLO26 include le varianti Detect, Segment, Semantic, Depth, Classify, Pose e OBB in dimensioni che vanno da nano a xlarge.
I dataset di profondità possono essere caricati con target NPY in virgola mobile in metri o target PNG uint16 utilizzando depth_scale del dataset. Consulta il formato del dataset di profondità.
Passaggio 2: Seleziona il dataset#
Scegli un dataset su cui effettuare l'addestramento (vedi Datasets):
| Opzione | Descrizione |
|---|---|
| Ufficiali | Dataset curati da Ultralytics |
| I tuoi dataset | Dataset che hai caricato |
I dataset devono trovarsi nello stato ready con almeno 1 immagine nel set di training, 1 immagine nel set di validazione o di test, almeno 1 immagine etichettata e almeno un nome di classe. I dataset di classificazione richiedono inoltre che l'immagine del set di training sia etichettata e i dataset di posa devono definire una forma di keypoint. I dataset di profondità richiedono invece una mappa associata in train e due in val; le immagini non associate vengono escluse.
Viene visualizzato un avviso di incompatibilità delle attività quando il modello selezionato non è in grado di addestrare l'attività del dataset, e Start Training rimane disabilitato finché non scegli un modello compatibile. Un dataset di segmentazione accetta modelli di segmentazione o semantici; altre attività di dataset richiedono l'attività del modello corrispondente. Consulta le guide alle attività.
Passaggio 3: Configura i parametri#
Imposta i parametri fondamentali dell'addestramento:
| Parametro | Descrizione | Predefinito |
|---|---|---|
| Epoche | Numero di iterazioni di addestramento (1-10000) | 100 |
| Dimensione del batch | Campioni per iterazione (-1 si adatta automaticamente alla VRAM disponibile, oppure 1-512) | -1 (automatico) |
| Dimensione immagine | Cursore per la risoluzione di input, da 32 a 1280 con incrementi di 32 | 640 |
| Nome | Nome facoltativo per l'esecuzione dell'addestramento | automatico |
I valori digitati al di fuori dell'intervallo di un parametro vengono troncati quando il campo perde il focus.
Il cursore si ferma a 1280, ma l'editor YAML accetta dimensioni fino a 4096. Viene visualizzato un avviso sopra i 1280 perché risoluzioni più elevate aumentano notevolmente l'uso della memoria della GPU, il tempo di addestramento e il costo.
Passaggio 4: Impostazioni avanzate (facoltativo)#
Espandi Advanced Settings per accedere all'editor completo basato su YAML con oltre 50 parametri di addestramento organizzati per gruppo (vedi la configuration reference):
| Gruppo | Parametri |
|---|---|
| Tasso di apprendimento | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Ottimizzatore | auto (predefinito), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Pesi di perdita | box, cls, dfl, pose, kobj, label_smoothing |
| Aumentazione colore | hsv_h, hsv_s, hsv_v |
| Geometric Augmentation | degrees, translate, scale, shear, perspective |
| Flip & Mix Augmentation | flipud, fliplr, mosaic, mixup, copy_paste |
| Controllo dell'addestramento | epochs, batch, imgsz, pretrained, patience, time, seed, deterministic, amp, cos_lr, compile, close_mosaic, save_period |
| Dataset | fraction, freeze, single_cls, rect, multi_scale, val, resume |
| Device & Inference | device, cache, workers, dropout, iou, max_det |
I parametri sono consapevoli del task (ad esempio, copy_paste viene mostrato solo per i task di segmentazione, pose/kobj solo per i task di posa, dropout solo per la classificazione). Un badge Modified appare quando i valori differiscono dai valori predefiniti ed è possibile ripristinare tutti i valori predefiniti con il pulsante di ripristino. Solo i valori avanzati non predefiniti vengono inviati al job di addestramento (i parametri di base epochs, batch e dimensione immagine sono sempre inclusi), in modo che il comando risultante rimanga leggibile.
Esempio: Ottimizzazione dell'aumentazione per piccoli dataset
Per piccoli dataset (<1000 immagini), aumenta l'aumentazione per ridurre l'overfitting:
mosaic: 1.0 # Keep mosaic on
mixup: 0.3 # Add mixup blending
copy_paste: 0.3 # Add copy-paste (segment only)
fliplr: 0.5 # Horizontal flip
degrees: 10.0 # Slight rotation
scale: 0.9 # Aggressive scalingSalva versione del dataset (opzionale)#
Abilita Save Dataset Version per collegare il modello a una versione immutabile di un dataset ospitato sulla piattaforma. La piattaforma verifica se il contenuto del dataset è cambiato, riutilizza una versione corrispondente se non lo è, e crea una nuova versione numerata solo quando necessario. L'addestramento utilizza quindi quell'esatto snapshot NDJSON e registra il suo numero di versione e l'hash del contenuto sul modello.
Questo preserva i dati utilizzati per l'esecuzione anche se in seguito aggiungi o rimuovi immagini, modifichi le annotazioni o cambi le suddivisioni del dataset. Puoi trovare la versione collegata nelle schede Models e Versions del dataset.
Save Dataset Version non è disponibile per l'archiviazione cloud connessa e i dataset On Premise. Puoi anche creare istantanee manualmente dalla scheda Versions.
Passaggio 5: Seleziona GPU (scheda Cloud)#
Scegli la tua GPU da Ultralytics Cloud:

| GPU | Generazione | VRAM | Costo/Ora | Ideale per |
|---|---|---|---|---|
| RTX 2000 Ada | Ada | 16 GB | $0.24 | Dataset piccoli, test |
| RTX A4500 | Ampere | 20 GB | $0.25 | Dataset medio-piccoli |
| RTX 4000 Ada | Ada | 20 GB | $0.26 | Dataset medi |
| RTX A5000 | Ampere | 24 GB | $0.27 | Dataset medi |
| L4 | Ada | 24 GB | $0.39 | Ottimizzato per l'inferenza |
| A40 | Ampere | 48 GB | $0.44 | Dimensioni batch più grandi |
| RTX 3090 | Ampere | 24 GB | $0.46 | Addestramento generale |
| RTX A6000 | Ampere | 48 GB | $0.49 | Modelli grandi |
| RTX PRO 4000 | Blackwell | 24 GB | $0.57 | Budget Blackwell |
| RTX PRO 4500 | Blackwell | 32 GB | $0.64 | Ottimo rapporto prezzo/prestazioni |
| RTX 4090 | Ada | 24 GB | $0.69 | Miglior rapporto prezzo/prestazioni |
| RTX 6000 Ada | Ada | 48 GB | $0.77 | Addestramento con batch grandi |
| L40S | Ada | 48 GB | $0.86 | Addestramento con batch grandi |
| RTX PRO 5000 | Blackwell | 48 GB | $0.96 | Addestramento con batch grandi |
| RTX 5090 | Blackwell | 32 GB | $0.99 | Ultima generazione consumer |
| L40 | Ada | 48 GB | $0.99 | Modelli grandi |
| A100 PCIe | Ampere | 80 GB | $1.39 | Addestramento di produzione |
| A100 SXM | Ampere | 80 GB | $1.49 | Addestramento di produzione |
| RTX PRO 6000 | Blackwell | 96 GB | $2.09 | Predefinito consigliato |
| H100 PCIe | Hopper | 80 GB | $2.89 | Addestramento ad alte prestazioni |
| H100 NVL | Hopper | 94 GB | $3.19 | Massime prestazioni |
| H100 SXM | Hopper | 80 GB | $3.29 | Addestramento più veloce |
| H200 NVL | Hopper | 143 GB | $3.39 | Memoria massima |
| H200 SXM | Hopper | 141 GB | $4.39 | Massime prestazioni |
| B200 | Blackwell | 180 GB | $5.89 | Modelli grandi (Pro+) |
| B300 | Blackwell | 288 GB | $7.39 | Modelli più grandi (Pro+) |
- RTX PRO 6000: 96 GB Blackwell, predefinito consigliato per la maggior parte dei lavori
- A100 SXM: 80 GB HBM2e — ottima scelta per dimensioni di batch grandi o modelli più grandi
- H100 PCIe / H100 SXM / H100 NVL: 80–94 GB Hopper per addestramenti sensibili al tempo (disponibile in tutti i piani)
- H200 NVL / H200 SXM: 141–143 GB Hopper per carichi di lavoro ad alta memoria (disponibile in tutti i piani)
- B200 / B300: 180–288 GB NVIDIA Blackwell per carichi di lavoro all'avanguardia — richiede Pro o Enterprise
La finestra di dialogo mostra il tuo balance attuale e un pulsante Top Up. La scheda dei costi stima la durata totale e il prezzo per la tua configurazione (dimensione del modello, immagini del dataset, epoche, dimensione dell'immagine, dimensione del batch, ottimizzatore e velocità della GPU) e riporta anche i secondi stimati per epoca e il conteggio delle immagini del dataset.
Il selettore della GPU riflette la disponibilità cloud in tempo reale, quindi le opzioni esaurite sono contrassegnate. Se un job non può comunque essere allocato sulla GPU scelta, la Platform segnala la carenza e sposta la selezione sulla GPU disponibile più vicina — abbinando prima la VRAM, poi la velocità, poi il prezzo — e ti comunica la nuova VRAM e la tariffa oraria in modo che tu possa iniziare immediatamente o fare una scelta diversa.
La selezione di una GPU più economica della RTX PRO 6000 rende il tuo job idoneo per l'infrastruttura gestita da Ultralytics. Quando tale capacità è libera, l'esecuzione avviene su una RTX PRO 6000 ma viene comunque fatturata alla tariffa della GPU da te selezionata, quindi un'esecuzione può terminare più velocemente e costare meno rispetto a quanto farebbe sulla GPU scelta; l'aggiornamento in sé non rende mai un'esecuzione più lenta o più costosa.
Passaggio 6: Avvia l'addestramento#
Fai clic su Start Training per lanciare il tuo lavoro. La piattaforma:
- Risolve la versione immutabile del dataset quando Save Dataset Version è abilitato
- Fornisce un'istanza GPU
- Scarica il tuo dataset
- Inizia l'addestramento
- Trasmette le metriche in tempo reale
La riprogettazione o il nuovo addestramento di un modello esistente riutilizza la stessa pagina del modello e cancella i grafici, l'output della console, le metriche di sistema e lo stato di errore dell'esecuzione precedente non appena viene creato il nuovo job. Un'esecuzione che fallisce prima che venga allocata la potenza di calcolo lascia inalterati i risultati precedenti.
Ciclo di vita del lavoro di addestramento#
I lavori di addestramento avanzano attraverso i seguenti stati:
| Stato | Descrizione |
|---|---|
| Pending | Lavoro inviato, in attesa dell'allocazione GPU |
| Starting | GPU fornita, download del dataset e del modello in corso |
| Running | Addestramento in corso, metriche trasmesse in tempo reale |
| Completed | Addestramento terminato con successo |
| Failed | Addestramento fallito (vedi i log della console per i dettagli) |
| Cancelled | L'addestramento è stato annullato dall'utente |
Un errore Python fatale nel flusso della console — un traceback, un errore di memoria della GPU (CUDA out-of-memory) o un'inizializzazione CUDA fallita — termina immediatamente l'esecuzione anziché attendere un timeout, e il messaggio estratto appare in un banner di errore nella pagina del modello con le azioni View full console logs e Retry Training. Le esecuzioni che smettono di segnalare attività per diverse ore vengono automaticamente contrassegnate come fallite e la loro potenza di calcolo viene rilasciata.
Per ricevere i risultati di completamento ed errore senza mantenere questa pagina aperta, collega gli avvisi di Slack.
I nuovi account ricevono crediti di iscrizione: $5 per le email personali e $25 per le email aziendali. Controlla il tuo saldo in Impostazioni > Fatturazione.

Monitora l'addestramento#
Visualizza l'avanzamento dell'addestramento in tempo reale nella scheda Train della pagina del modello:
Sottoscheda Grafici#

I grafici sono raggruppati per famiglia di metriche e i gruppi visualizzati dipendono da ciò che l'esecuzione segnala:
| Gruppo | Contenuti |
|---|---|
| Metriche | Metriche del task — mAP50, mAP50-95, precisione e richiamo per il rilevamento; vedi Models per altri task |
| Perdita | Un grafico per ogni componente di perdita, con la serie di addestramento continua e la serie di validazione tratteggiata |
| Tasso di apprendimento | lr/pg0, lr/pg1, lr/pg2 |
Ogni gruppo può essere compresso, i singoli grafici possono essere nascosti o mostrati dal menu del gruppo e i grafici possono essere trascinati e ridimensionati; il layout viene memorizzato per la prossima volta.
Sottoscheda Console#
Output della console in tempo reale con supporto ai colori ANSI, barre di avanzamento e rilevamento degli errori fatali. Le ultime 2000 righe vengono conservate, i timestamp possono essere attivati/disattivati e l'intero log può essere copiato come testo normale.
Sottoscheda Sistema#
Una scheda host in tempo reale (hostname, CPU, GPU, RAM e totali del disco) più grafici per epoca relativi all'utilizzo di CPU e RAM, utilizzo e memoria della GPU, temperatura della GPU, I/O di rete e I/O su disco.
Checkpoint#
Il checkpoint migliore (best.pt) viene caricato sulla Platform periodicamente durante l'addestramento e nuovamente al termine dell'esecuzione, in modo che download, esportazione e distribuzione utilizzino sempre la migliore epoca prodotta finora. Se l'esecuzione viene annullata, viene conservato il checkpoint caricato prima dell'annullamento.
Annulla Addestramento#
Fai clic su Cancel nella scheda Run Information nella pagina del modello e conferma l'azione. Per l'addestramento sul cloud, la Platform interrompe il job, rilascia la potenza di calcolo e addebita il tempo GPU trascorso utilizzato prima dell'annullamento. Per l'addestramento locale, l'annullamento segnala al processo di fermarsi al confine dell'epoca successiva e preserva i risultati parziali: l'esecuzione carica ciò che ha prima di uscire.
Addestramento Remoto#
graph LR
A[Local GPU]:::start --> B[ultralytics Package]:::proc
B --> C[Train]:::proc
C --> D[Stream Metrics]:::proc
D --> E[Platform Dashboard]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffAddestra sul tuo hardware mentre trasmetti le metriche alla piattaforma.
L'integrazione con la Platform richiede ultralytics>=8.4.120. Le versioni inferiori non funzioneranno con la Platform.
pip install -U ultralyticsConfigurazione della Chiave API#
- Vai a
Settings > API Keys - Crea una nuova chiave (o la piattaforma ne crea una automaticamente quando apri la scheda Addestramento Locale)
- Imposta la variabile d'ambiente:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"Addestra con lo Streaming#
Usa i parametri project e name per trasmettere in streaming le metriche:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1La scheda Local Training nella finestra di dialogo dell'addestramento mostra un comando preconfigurato con la tua chiave API, i parametri selezionati e gli argomenti avanzati inclusi.
Uso dei dataset della piattaforma#
Addestra con i dataset memorizzati sulla piattaforma utilizzando il formato URI ul://:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1Il formato URI ul:// scarica e configura automaticamente il tuo dataset. Il modello viene collegato automaticamente al dataset sulla piattaforma (vedi Utilizzo dei dataset della piattaforma).
Fatturazione#
I costi di addestramento si basano sull'utilizzo della GPU:
Stima dei Costi#
Prima dell'inizio dell'addestramento, la piattaforma stima la durata totale e il costo in base alle dimensioni del dataset, del modello, dell'immagine, del batch, alle epoche e alla GPU selezionata. Le stime sono approssimative; l'utilizzo effettivo è ciò che viene fatturato.
Fattori che influenzano il costo:
| Fattore | Impatto |
|---|---|
| Dimensione del Dataset | Più immagini = tempo di addestramento più lungo (il calcolo scala approssimativamente in modo lineare rispetto alla dimensione del dataset) |
| Dimensione del Modello | I modelli più grandi (m, l, x) si addestrano più lentamente rispetto a (n, s) |
| Numero di Epoche | Moltiplicatore diretto sul tempo di addestramento |
| Dimensione immagine | Un valore imgsz maggiore aumenta notevolmente il calcolo: 1280px costa diverse volte di più rispetto a 640px |
| Dimensione del batch | Batch più grandi si addestrano in modo più efficiente rispetto a quelli piccoli |
| Velocità della GPU | GPU più veloci riducono il tempo di addestramento, compensando parzialmente la loro tariffa oraria più elevata |
| Ottimizzatore | MuSGD richiede circa il doppio del tempo rispetto agli altri ottimizzatori |
| Tempo di Avvio | Fino a 5 minuti per l'inizializzazione dell'istanza, il download dei dati e il riscaldamento (scala con la dimensione del dataset) |
Le stime si basano su esecuzioni di addestramento cloud reali e la stima utilizza sempre la GPU da te selezionata, quindi un job instradato verso un'infrastruttura Ultralytics più veloce termina prima della sua stima.
Esempi di Costo#
Le stime dei costi sono approssimative e dipendono da molti fattori. La finestra di dialogo dell'addestramento mostra una stima in tempo reale prima che tu inizi l'addestramento.
| Scenario | GPU | Costo Stimato |
|---|---|---|
| 500 immagini, YOLO26n, 50 epoche | RTX 4090 | ~$0.03 |
| 1000 immagini, YOLO26n, 100 epoche | RTX PRO 6000 | ~$0.23 |
| 5000 immagini, YOLO26s, 100 epoche | H100 SXM | ~$1.56 |
Flusso di Fatturazione#
graph LR
A[Estimate Cost]:::start --> B[Balance Check]:::decide
B --> C[Train and Meter GPU Time]:::proc
C --> D[Settle at Terminal State]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef decide fill:#FF9800,color:#fff
classDef out fill:#9C27B0,color:#fffFlusso di fatturazione dell'addestramento nel cloud:
- Stima: Costo calcolato prima dell'inizio dell'addestramento
- Controllo del Saldo: I crediti disponibili vengono controllati prima dell'avvio
- Train and Meter: Il lavoro viene eseguito sul compute selezionato e il tempo GPU accumulato viene addebitato dal tuo saldo a scatti durante l'esecuzione
- Settle: Allo stato terminale viene addebitata la parte residua finale e viene registrata un'unica transazione Training per l'intera esecuzione
La fatturazione tiene traccia del tempo di GPU effettivo, comprese le esecuzioni parziali che vengono annullate o falliscono dopo l'avvio di una GPU cloud.
Fatturazione per Stato del Job#
| Stato | Addebitato? |
|---|---|
| Completed | Sì — tempo effettivo di GPU utilizzato |
| Cancelled | Sì — tempo di GPU dall'inizio alla cancellazione |
| Failed | Sì, quando il calcolo cloud è iniziato — tempo di GPU utilizzato trascorso |
| Bloccato | Sì — tempo di GPU trascorso fino alla terminazione automatica |
Un'esecuzione che smette di segnalare attività per diverse ore viene automaticamente contrassegnata come fallita; l'istanza viene terminata e il tempo GPU trascorso viene saldato. Le esecuzioni remote sul proprio hardware vengono semplicemente contrassegnate come fallite senza alcun addebito.
Un errore di convalida o di avvio prima che una GPU cloud si avvii non comporta alcun costo di calcolo. Una volta che una GPU è in esecuzione, i processi completati, annullati, falliti e terminati automaticamente vengono saldati in base al tempo di GPU wall-clock trascorso.
Metodi di pagamento#
L'addestramento cloud viene pagato dal saldo di crediti della tua piattaforma.
L'avvio dell'addestramento richiede un saldo disponibile positivo e crediti sufficienti per il costo stimato del job, in cui ogni stima riserva almeno 15 minuti di tempo GPU. Con più esecuzioni attive contemporaneamente, il controllo tiene conto anche del resto non fatturato di tali esecuzioni.
Visualizza i Costi di Addestramento#
Prima di avviare un processo cloud, la finestra di dialogo dell'addestramento mostra il tuo saldo di crediti attuale e stima la durata e il costo del processo in base al modello, al dataset, alle epoche, alla dimensione dell'immagine e alla GPU selezionati. La stima è puramente indicativa; l'utilizzo effettivo viene addebitato per il tempo di GPU consumato. Successivamente, controlla la transazione di credito risultante in Settings > Billing.

Suggerimenti per l'Addestramento#
Scegli la Dimensione Corretta del Modello#
| Modello | Parametri | Ideale per |
|---|---|---|
| YOLO26n | 2.4M | Tempo reale, dispositivi edge |
| YOLO26s | 9.5M | Velocità/precisione bilanciate |
| YOLO26m | 20.4M | Precisione maggiore |
| YOLO26l | 24.8M | Precisione di produzione |
| YOLO26x | 55.7M | Precisione massima |
Ottimizza il Tempo di Addestramento#
- Inizia in piccolo: Testa con 10-20 epoche su una GPU economica per verificare che il tuo dataset e la tua configurazione funzionino
- Usa una GPU appropriata: RTX PRO 6000 gestisce bene la maggior parte dei carichi di lavoro
- Valida il dataset: Risolvi i problemi di etichettatura prima di spendere per l'addestramento
- Monitora presto: Cancella l'addestramento se la perdita si stabilizza — paghi solo per il tempo di calcolo utilizzato
Risoluzione dei problemi#
| Problema | Soluzione |
|---|---|
| Addestramento bloccato allo 0% | Controlla il formato del dataset, riprova |
| Memoria esaurita | Riduci la dimensione del batch o usa una GPU più grande |
| Scarsa precisione | Aumenta le epoche, controlla la qualità dei dati |
| Addestramento lento | Considera una GPU più veloce |
| Errore di mancata corrispondenza del task | Assicurati che i task del modello e del dataset corrispondano |
Riferimento parametri di addestramento#
| Parametro | Tipo | Predefinito | Intervallo | Descrizione |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Numero di epoche di addestramento |
batch | int | -1 (automatico) | -1 a 512 | Dimensione del batch (-1 = adattamento automatico alla VRAM disponibile) |
imgsz | int | 640 | 32-4096 | Dimensione immagine in input |
pretrained | bool | True | - | Inizia da pesi preaddestrati invece di un'inizializzazione casuale |
patience | int | 100 | 1-1000 | Pazienza per arresto anticipato |
time | float | null | 0.1-720 | Limite di tempo di addestramento in ore (wall-clock), sovrascrive le epoche |
seed | int | 0 | 0-2147483647 | Seed casuale per la riproducibilità |
deterministic | bool | True | - | Modalità di addestramento deterministica |
amp | bool/str | True | true/false/fp16/bf16/fp32 | Precisione di training |
compile | bool | False | - | Compila con torch.compile (prima epoca più lenta) |
close_mosaic | int | 10 | 0-50 | Disabilita mosaic nelle ultime N epoche |
save_period | int | -1 | -1-100 | Salva checkpoint ogni N epoche |
device | seleziona | automatico | auto/0/cpu/mps | Dispositivo di addestramento |
workers | int | 8 | 0-64 | Worker del dataloader |
cache | seleziona | false | ram/disk/false | Memorizza immagini in cache |
dropout | float | 0.0 | 0.0-1.0 | Dropout della testa di classificazione (solo per classificazione) |
iou | float | 0.7 | 0.1-0.9 | Soglia IoU per NMS durante la validazione |
max_det | int | 300 | 1-10000 | Numero massimo di rilevamenti per immagine |
Alcuni parametri si applicano solo a specifiche attività:
- Qualsiasi attività tranne classify e depth (detect, segment, semantic, pose, obb):
box,dfl,mosaic,mixup,close_mosaic,iou,max_det - Qualsiasi attività tranne depth (le attività con le classi):
cls,label_smoothing,single_cls - Qualsiasi attività tranne classify (detect, segment, semantic, depth, pose, obb):
degrees,translate,shear,perspective - Solo segmentazione:
copy_paste - Solo posa:
pose(peso della perdita),kobj(oggettualità dei keypoint) - Solo Classify:
dropout
FAQ#
Il tempo di addestramento dipende da:
- Dimensione del dataset
- Dimensione del modello
- Numero di epoche
- GPU selezionata
Tempi tipici (1000 immagini, 100 epoche):
Modello RTX PRO 6000 A100 SXM YOLO26n ~6 min ~5 min YOLO26m ~15 min ~12 min YOLO26x ~30 min ~25 min Tempi approssimativiI tempi di addestramento sono approssimativi e variano in base alla complessità del dataset, alle impostazioni di aumentazione e alla dimensione del batch. Usa la stima dei costi nella finestra di dialogo di addestramento per previsioni più precise.
Sì. L'addestramento può essere eseguito senza supervisione fintanto che è finanziato e la piattaforma registra un evento di completamento o di errore. Se la misurazione fa scendere il saldo al di sotto di zero, le esecuzioni cloud a pagamento attive si fermano e saldano il tempo di GPU già utilizzato.
L'utilizzo del cloud viene misurato man mano che l'addestramento procede. Se un costo fa scendere il tuo saldo al di sotto di zero, le esecuzioni di addestramento cloud a pagamento attive vengono interrotte e saldate per il tempo di GPU già utilizzato. Aggiungi crediti o abilita la ricarica automatica per mantenere finanziati i processi di lunga durata.
Saldo negativoUn saldo pari a zero o negativo impedisce nuovi processi di addestramento cloud a pagamento. Un saldo misurato negativo attiva anche l'arresto delle esecuzioni di addestramento cloud a pagamento attive.
Le stime dei costi sono approssimative: il tempo di addestramento effettivo può variare a causa di fattori quali la velocità di caricamento dei dati, il riscaldamento della GPU e il comportamento di convergenza del modello. Se l'utilizzo effettivo esaurisce il saldo disponibile, la piattaforma interrompe le esecuzioni cloud a pagamento attive dopo che il saldo diventa negativo.
Per gestire i costi:
- Monitora l'avanzamento dell'addestramento in tempo reale e annulla in anticipo se necessario
- Abilita la ricarica automatica per reintegrare automaticamente i crediti
- Inizia con esecuzioni più brevi (meno epoche) per calibrare le aspettative
Sì, espandi la sezione Advanced Settings nella finestra di dialogo di addestramento per accedere a un editor YAML con oltre 50 parametri configurabili. I valori non predefiniti sono inclusi sia nei comandi di addestramento cloud che locale.
L'editor YAML supporta anche l'importazione di configurazioni da precedenti esecuzioni di addestramento:
- Copy from existing model: nella pagina di qualsiasi modello completato, la scheda Training Configuration ha un menu Export data con Copy JSON. Incolla il JSON direttamente nell'editor YAML: rileverà automaticamente il formato JSON e importerà tutti i parametri. Lo stesso menu scarica la configurazione come CSV o JSON.
- Incolla YAML o JSON: Incolla qualsiasi configurazione di addestramento YAML o JSON valida nell'editor. I parametri vengono convalidati automaticamente, con i valori fuori intervallo limitati e avvisi visualizzati.
- Trascina e rilascia i file: trascina un file
.yamlo.jsondirettamente nell'editor per importare i relativi parametri.
Questo semplifica la riproduzione o l'iterazione su configurazioni di addestramento precedenti senza reinserire manualmente ogni parametro.Sì. Un modello fallito mostra un banner di errore con un'azione Retry che riapre la finestra di dialogo di addestramento con lo stesso modello di base, dataset e parametri, in modo da poter regolare un valore e ricominciare. La riprosieuzione riutilizza la stessa pagina del modello: i grafici dell'esecuzione precedente, l'output della console, le metriche di sistema e l'errore vengono cancellati non appena viene creato il nuovo job e i suoi pesi vengono sostituiti quando la nuova esecuzione produce un checkpoint migliore.
Sì, il pulsante New Model nelle pagine dei dataset apre la finestra di dialogo dell'addestramento con il dataset preselezione e bloccato. Selezioni quindi un progetto e un modello per iniziare l'addestramento.