Addestramento nel cloud#
L'Ultralytics Platform Cloud Training offre l'addestramento con un solo clic sulle 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 dell'addestramento#
Avvia l'addestramento dall'interfaccia della piattaforma facendo clic su New Model in qualsiasi pagina di progetto o dataset. La finestra di dialogo dell'addestramento ha due schede: Cloud Training e Local Training. Quando il dataset selezionato risiede su un host On Premise, la prima scheda diventa On Premise e la scheda Local Training viene nascosta: il dataset può essere addestrato solo sul proprio host, il che richiede un piano Enterprise e un worker connesso e online.

La finestra di dialogo ricorda il modello di base e gli eventuali parametri non predefiniti presenti alla sua chiusura, per ciascuna attività di set di dati e area di lavoro nel browser corrente, e li ripristina la volta successiva che la apri per quell'attività. La selezione della GPU non viene ricordata e il pulsante Retry (Riprova) su un'esecuzione non riuscita ripristina gli argomenti specifici di quell'esecuzione.
Passaggio 1: seleziona il modello di base#
Scegli un modello Ultralytics ufficiale o uno dei tuoi modelli completati:
| Scheda | Descrizione |
|---|---|
| Ufficiali | Modelli di progetto YOLO26 (consigliato), YOLO11, YOLOv8 e YOLOv5 |
| I miei modelli | I tuoi modelli completati o caricati, raggruppati per progetto, per il fine-tuning |
All'interno di ogni scheda, i modelli sono raggruppati per attività in ordine canonico e ordinati per dimensione. Il selettore filtra i modelli ufficiali in base alle attività compatibili con il dataset selezionato. YOLO26 include varianti Detect, Segment, Semantic, Depth, Classify, Pose e OBB, con dimensioni da nano a xlarge.
I dataset di profondità possono essere caricati con target NPY float in metri o target PNG uint16 usando il depth_scale del dataset. Consulta il formato dei dataset di profondità.
Passaggio 2: seleziona il dataset#
Scegli un dataset su cui eseguire l'addestramento (consulta Datasets):
| Opzione | Descrizione |
|---|---|
| Ufficiali | Dataset curati da Ultralytics |
| I tuoi dataset | Dataset che hai caricato |
I dataset devono avere lo stato ready, almeno 1 immagine nel set di addestramento, 1 immagine nel set di validazione o test, almeno 1 immagine annotata e almeno un nome di classe. I dataset di classificazione richiedono inoltre che l'immagine del set di addestramento sia annotata, mentre i dataset di posa devono definire una forma dei 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à dell'attività quando il modello selezionato non può 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; per le altre attività del dataset è necessario il modello con l'attività corrispondente. Consulta le guide sulle attività.
Passaggio 3: configura i parametri#
Imposta i parametri principali dell'addestramento:
| Parametro | Descrizione | Predefinito |
|---|---|---|
| Epoche | Numero di iterazioni di addestramento (1-10000) | 100 |
| Dimensione del batch | Campioni per iterazione (-1 adatta automaticamente il valore alla VRAM disponibile, oppure 1-512) | -1 (automatico) |
| Dimensione immagine | Slider della risoluzione di input, 32-1280 con incrementi di 32 | 640 |
| Nome | Nome facoltativo per l'esecuzione dell'addestramento | automatico |
I valori inseriti al di fuori dell'intervallo di un parametro vengono limitati quando il campo perde lo stato attivo.
Lo slider si ferma a 1280, ma l'editor YAML accetta dimensioni fino a 4096. Sopra 1280 viene visualizzato un avviso perché le risoluzioni maggiori aumentano notevolmente l'utilizzo della memoria GPU, il tempo di addestramento e i costi.
Passaggio 4: impostazioni avanzate (facoltativo)#
Espandi Advanced Settings per accedere all'editor completo dei parametri basato su YAML, con oltre 50 parametri di addestramento organizzati per gruppo (consulta il riferimento della configurazione):
| 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 della loss | box, cls, dfl, pose, kobj, label_smoothing |
| Augmentation del colore | hsv_h, hsv_s, hsv_v |
| Augmentation geometrica | degrees, translate, scale, shear, perspective |
| Augmentation di flip e mix | 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 |
| Dispositivo e inferenza | device, cache, workers, dropout, iou, max_det |
I parametri tengono conto dell'attività (ad esempio, copy_paste viene mostrato solo per le attività di segmentazione, pose/kobj solo per le attività di posa e dropout solo per la classificazione). Un badge Modified viene visualizzato quando i valori differiscono da quelli predefiniti e puoi ripristinare tutti i valori predefiniti con il pulsante di ripristino. Al job di addestramento vengono inviati solo i valori avanzati non predefiniti (i parametri di base relativi a epoche, batch e dimensione delle immagini sono sempre inclusi), così il comando risultante rimane leggibile.
Esempio: ottimizzazione dell'augmentation per dataset piccoli
Per i dataset piccoli (<1000 immagini), aumenta l'augmentation 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 la versione del dataset (facoltativo)#
Abilita Save Dataset Version per collegare il modello a una versione immutabile di un dataset ospitato sulla Platform. La Platform verifica se i contenuti del dataset sono cambiati, riutilizza una versione corrispondente quando non sono cambiati e crea una nuova versione numerata solo quando necessario. L'addestramento utilizza quindi quell'esatto snapshot NDJSON e registra sul modello il numero di versione e l'hash dei contenuti.
In questo modo vengono preservati 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 lo storage cloud connesso e per i dataset On Premise. Puoi anche creare snapshot manualmente dalla scheda Versions.
Passaggio 5: seleziona la 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 piccoli e medi |
| 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 | Ottimizzata per l'inferenza |
| A40 | Ampere | 48 GB | $0.44 | Dimensioni del batch maggiori |
| RTX 3090 | Ampere | 24 GB | $0.46 | Addestramento generico |
| RTX A6000 | Ampere | 48 GB | $0.49 | Modelli di grandi dimensioni |
| RTX PRO 4000 | Blackwell | 24 GB | $0.57 | Blackwell economica |
| RTX PRO 4500 | Blackwell | 32 GB | $0.64 | Ottimo rapporto qualità/prezzo |
| RTX 4090 | Ada | 24 GB | $0.69 | Miglior rapporto qualità/prezzo |
| RTX 6000 Ada | Ada | 48 GB | $0.77 | Addestramento con batch di grandi dimensioni |
| L40S | Ada | 48 GB | $0.86 | Addestramento con batch di grandi dimensioni |
| RTX PRO 5000 | Blackwell | 48 GB | $0.96 | Addestramento con batch di grandi dimensioni |
| RTX 5090 | Blackwell | 32 GB | $0.99 | Ultima generazione consumer |
| L40 | Ada | 48 GB | $0.99 | Modelli di grandi dimensioni |
| A100 PCIe | Ampere | 80 GB | $1.39 | Addestramento in produzione |
| A100 SXM | Ampere | 80 GB | $1.49 | Addestramento in produzione |
| RTX PRO 6000 | Blackwell | 96 GB | $2.09 | Impostazione predefinita consigliata |
| H100 PCIe | Hopper | 80 GB | $2.89 | Addestramento ad alte prestazioni |
| H100 NVL | Hopper | 94 GB | $3.19 | Prestazioni massime |
| 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 | Prestazioni massime |
| B200 | Blackwell | 180 GB | $5.89 | Modelli di grandi dimensioni (Pro+) |
| B300 | Blackwell | 288 GB | $7.39 | Modelli di dimensioni massime (Pro+) |
- RTX PRO 6000: 96 GB Blackwell, impostazione predefinita consigliata per la maggior parte dei job
- A100 SXM: 80 GB HBM2e — una scelta efficace per batch di grandi dimensioni o modelli più grandi
- H100 PCIe / H100 SXM / H100 NVL: 80–94 GB Hopper per l'addestramento con tempi critici (disponibile in tutti i piani)
- H200 NVL / H200 SXM: 141–143 GB Hopper per carichi di lavoro ad alto utilizzo di 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 saldo attuale e un pulsante Top Up. La scheda dei costi stima la durata e il prezzo totali della tua configurazione (dimensione del modello, immagini del dataset, epoche, dimensione delle immagini, dimensione del batch, ottimizzatore e velocità della GPU) e indica anche i secondi stimati per epoca e il numero di immagini del dataset.
Il selettore della GPU riflette la disponibilità corrente nel cloud, quindi le opzioni senza capacità disponibile vengono contrassegnate. Se un job non può ancora essere avviato sulla GPU scelta, la Platform segnala la carenza e passa la selezione alla GPU disponibile più vicina — prima in base alla VRAM, poi alla velocità e infine al prezzo — indicando la nuova VRAM e la tariffa oraria, così puoi avviare subito il job o scegliere diversamente.
Selezionando una GPU più economica della RTX PRO 6000, il tuo job diventa idoneo per l'infrastruttura gestita da Ultralytics. Quando tale capacità è disponibile, l'esecuzione avviene su una RTX PRO 6000, ma viene comunque fatturata alla tariffa della GPU selezionata; in questo modo un'esecuzione può terminare più rapidamente e costare meno rispetto all'utilizzo della GPU selezionata — l'upgrade non rende mai un'esecuzione più lenta o più costosa.
Passaggio 6: avvia l'addestramento#
Fai clic su Start Training per avviare il job. La Platform:
- Risoluzione della versione immutabile del dataset quando Save Dataset Version è abilitato
- Provisioning di un'istanza GPU
- Download del dataset
- Avvio dell'addestramento
- Streaming delle metriche in tempo reale
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 una volta creato il nuovo job. Un'esecuzione che non va a buon fine prima del provisioning delle risorse di calcolo lascia invariati i risultati precedenti.
Ciclo di vita del job di addestramento#
I job di addestramento avanzano attraverso i seguenti stati:
| Stato | Descrizione |
|---|---|
| In sospeso | Job inviato, in attesa dell'allocazione della GPU |
| Avvio | GPU predisposta, download del dataset e del modello in corso |
| In esecuzione | Addestramento in corso, streaming delle metriche in tempo reale |
| Completato | Addestramento completato correttamente |
| Non riuscito | Addestramento non riuscito (consulta i log della console per maggiori dettagli) |
| Annullato | L'addestramento è stato annullato dall'utente |
Un errore fatale di Python nel flusso della console — un traceback, un errore di memoria CUDA esaurita o un'inizializzazione CUDA non riuscita — termina immediatamente l'esecuzione invece di 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 non riuscite e le relative risorse di calcolo vengono rilasciate.
Per ricevere i risultati completati e non riusciti senza tenere aperta questa pagina, collega gli avvisi Slack.
I nuovi account ricevono crediti di iscrizione: 5 $ per le email personali e 25 $ per le email aziendali. Controlla il tuo saldo in Settings > Billing.

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 segnala l'esecuzione:
| Gruppo | Sommario |
|---|---|
| Metriche | Metriche dell'attività — mAP50, mAP50-95, precisione e recall per il rilevamento; consulta Modelli per le altre attività |
| Perdita | Un grafico per ogni componente della loss, con la serie di addestramento continua e quella di validazione tratteggiata |
| Tasso di apprendimento | lr/pg0, lr/pg1, lr/pg2 |
Ogni gruppo può essere compresso, i singoli grafici possono essere nascosti o visualizzati 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 dei colori ANSI, barre di avanzamento e rilevamento degli errori fatali. Vengono conservate le ultime 2000 righe, i timestamp possono essere attivati e l'intero log può essere copiato come testo normale.
Sottoscheda Sistema#
Una scheda dell'host in tempo reale (nome host, CPU, GPU, RAM e capacità totali del disco), oltre a grafici per epoca dell'utilizzo di CPU e RAM, dell'utilizzo e della memoria della GPU, della temperatura della GPU, dell'I/O di rete e dell'I/O del disco.
Checkpoint#
Il checkpoint migliore (best.pt) viene caricato periodicamente sulla Platform durante l'addestramento e nuovamente al termine dell'esecuzione, così download, esportazione e deployment utilizzano sempre la migliore epoca prodotta fino a quel momento. Se l'esecuzione viene annullata, viene conservato il checkpoint caricato prima dell'annullamento.
Annulla addestramento#
Fai clic su Cancel nella scheda Run Information della pagina del modello e conferma l'azione. Per l'addestramento sul cloud, la Platform arresta il job, rilascia le risorse di calcolo e addebita il tempo GPU trascorso utilizzato prima dell'annullamento. Per l'addestramento locale, il segnale di annullamento comunica al processo di arrestarsi al confine dell'epoca successiva e conserva i risultati parziali: l'esecuzione carica ciò che ha prodotto 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:#fffEsegui l'addestramento sul tuo hardware trasmettendo le metriche alla platform.
L'integrazione con la piattaforma richiede Python>=3.11 e ultralytics>=8.4.120. Le versioni inferiori non funzioneranno con la piattaforma.
pip install -U ultralyticsConfigura la chiave API#
- Vai a
Settings > API Keys - Crea una nuova chiave (oppure la platform ne crea automaticamente una quando apri la scheda Local Training)
- Imposta la variabile d'ambiente:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"Addestra con lo streaming#
Usa i parametri project e name per trasmettere 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.
Utilizzo dei dataset della Platform#
Addestra con i dataset archiviati sulla platform usando 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 platform (consulta Utilizzo dei dataset della Platform).
Fatturazione#
I costi dell'addestramento si basano sull'utilizzo della GPU:
Stima dei costi#
Prima dell'inizio dell'addestramento, la platform stima la durata e il costo totali in base alle dimensioni del dataset e del modello, alla dimensione delle immagini, alla dimensione del batch, al numero di epoche e alla GPU selezionata. Le stime sono approssimative; l'utilizzo effettivo è ciò che viene addebitato.
Fattori che influenzano il costo:
| Fattore | Impatto |
|---|---|
| Dimensioni del dataset | Più immagini = tempi di addestramento più lunghi (il calcolo aumenta all'incirca linearmente con le dimensioni del dataset) |
| Dimensioni del modello | I modelli più grandi (m, l, x) vengono addestrati più lentamente rispetto a (n, s) |
| Numero di epoche | Moltiplicatore diretto del tempo di addestramento |
| Dimensione immagine | Un imgsz maggiore aumenta sostanzialmente il calcolo: 1280px costa diverse volte più di 640px |
| Dimensione del batch | I batch più grandi vengono addestrati in modo più efficiente rispetto a quelli piccoli |
| Velocità della GPU | Le GPU più veloci riducono il tempo di addestramento, compensando parzialmente la loro tariffa oraria più elevata |
| Ottimizzatore | MuSGD richiede all'incirca il doppio del tempo rispetto agli altri ottimizzatori |
| Overhead di avvio | Fino a 5 minuti per l'inizializzazione dell'istanza, il download dei dati e il warmup (aumenta in base alle dimensioni del dataset) |
Le stime si basano su esecuzioni reali di addestramento sul cloud e utilizzano sempre la GPU selezionata: pertanto, un job instradato verso un'infrastruttura Ultralytics più veloce termina prima della stima.
Esempi di costi#
Le stime dei costi sono approssimative e dipendono da molti fattori. La finestra di dialogo dell'addestramento mostra una stima in tempo reale prima dell'inizio dell'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 |
Processo 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:#fffProcesso di fatturazione dell'addestramento sul cloud:
- Stima: costo calcolato prima dell'inizio dell'addestramento
- Controllo del saldo: i crediti disponibili vengono verificati prima dell'avvio
- Addestramento e misurazione: il job viene eseguito sulle risorse di calcolo selezionate e il tempo GPU accumulato viene addebitato dal tuo saldo a intervalli durante l'esecuzione
- Saldo finale: nello stato terminale viene addebitato il tempo residuo e viene registrata un'unica transazione di Training per l'intera esecuzione
La fatturazione tiene traccia del tempo GPU effettivo, comprese le esecuzioni parziali che vengono annullate o non riescono dopo l'avvio di una GPU cloud.
Fatturazione in base allo stato del job#
| Stato | Addebitato? |
|---|---|
| Completato | Sì — tempo GPU effettivamente utilizzato |
| Annullato | Sì — tempo GPU dall'avvio all'annullamento |
| Non riuscito | Sì, quando è iniziato il calcolo sul cloud — tempo GPU trascorso utilizzato |
| Bloccato | Sì — tempo GPU trascorso fino alla terminazione automatica |
Un'esecuzione che smette di segnalare attività per diverse ore viene automaticamente contrassegnata come non riuscita; l'istanza viene terminata e il tempo GPU trascorso viene saldato. Le esecuzioni remote sul tuo hardware vengono semplicemente contrassegnate come non riuscite, senza alcun addebito.
Un errore di convalida o di avvio prima che venga avviata una GPU cloud non comporta alcun utilizzo di risorse di calcolo da addebitare. Una volta in esecuzione una GPU, i job completati, annullati, non riusciti e terminati automaticamente vengono saldati in base al tempo GPU trascorso sull'orologio.
Metodi di pagamento#
L'addestramento sul cloud viene pagato utilizzando il saldo dei crediti della tua Platform.
Per avviare l'addestramento è necessario un saldo disponibile positivo e crediti sufficienti a coprire il costo stimato del job, poiché ogni stima riserva almeno 15 minuti di tempo GPU. Con più esecuzioni attive contemporaneamente, il controllo tiene conto anche della parte non fatturata di tali esecuzioni.
Visualizza i costi dell'addestramento#
Prima di avviare un job sul cloud, la finestra di dialogo dell'addestramento mostra il saldo attuale dei tuoi crediti e stima la durata e il costo del job in base al modello, al dataset, al numero di epoche, alla dimensione delle immagini e alla GPU selezionati. La stima è informativa; l'utilizzo effettivo viene addebitato in base al tempo GPU consumato. In seguito, controlla la transazione risultante relativa ai crediti in Settings > Billing.

Suggerimenti per l'addestramento#
Scegli la dimensione del modello giusta#
| Modello | Parametri | Ideale per |
|---|---|---|
| YOLO26n | 2.4M | Tempo reale, dispositivi edge |
| YOLO26s | 9.5M | Velocità/accuratezza bilanciate |
| YOLO26m | 20.4M | Maggiore accuratezza |
| YOLO26l | 24.8M | Accuratezza per la produzione |
| YOLO26x | 55.7M | Accuratezza massima |
Ottimizza il tempo di addestramento#
- Inizia in piccolo: esegui un test con 10-20 epoche su una GPU economica per verificare che il dataset e la configurazione funzionino
- Usa una GPU adeguata: RTX PRO 6000 gestisce bene la maggior parte dei carichi di lavoro
- Convalida il dataset: correggi i problemi di etichettatura prima di investire nell'addestramento
- Monitora fin dall'inizio: annulla l'addestramento se la loss si stabilizza: paghi solo il tempo di calcolo utilizzato
Risoluzione dei problemi#
| Problema | Soluzione |
|---|---|
| Addestramento bloccato allo 0% | Controlla il formato del dataset e riprova |
| Memoria insufficiente | Riduci la dimensione del batch o usa una GPU più grande |
| Accuratezza insufficiente | Aumenta il numero di epoche e controlla la qualità dei dati |
| Addestramento lento | Valuta una GPU più veloce |
| Errore di incompatibilità delle attività | Assicurati che le attività del modello e del dataset corrispondano |
Riferimento dei parametri di addestramento#
| Parametro | Tipo | Predefinito | Intervallo | Descrizione |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Numero di epoche di addestramento |
batch | int | -1 (automatico) | Da -1 a 512 | Dimensione del batch (-1 = adattamento automatico alla VRAM disponibile) |
imgsz | int | 640 | 32-4096 | Dimensione dell'immagine di input |
pretrained | bool | True | - | Inizia dai pesi preaddestrati invece che da un'inizializzazione casuale |
patience | int | 100 | 1-1000 | Pazienza per l'arresto anticipato |
time | float | null | 0.1-720 | Limite dell'addestramento in ore di tempo reale, sovrascrive il numero di 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 dell'addestramento |
compile | bool | False | - | Compila con torch.compile (prima epoca più lenta) |
close_mosaic | int | 10 | 0-50 | Disabilita il mosaic nelle ultime N epoche |
save_period | int | -1 | -1-100 | Salva un checkpoint ogni N epoche |
device | select | automatico | auto/0/cpu/mps | Dispositivo di addestramento |
workers | int | 8 | 0-64 | Worker del dataloader |
cache | select | false | ram/disk/false | Memorizza nella cache le immagini |
dropout | float | 0.0 | 0.0-1.0 | Dropout della testa di classificazione (solo classify) |
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 ad attività specifiche:
- Tutte le attività tranne classify e depth (detect, segment, semantic, pose, obb):
box,dfl,mosaic,mixup,close_mosaic,iou,max_det - Tutte le attività tranne depth (le attività con classi):
cls,label_smoothing,single_cls - Tutte le attività tranne classify (detect, segment, semantic, depth, pose, obb):
degrees,translate,shear,perspective - Solo segment:
copy_paste - Solo pose:
pose(peso della loss),kobj(objectness dei keypoint) - Solo classify:
dropout
FAQ#
La durata dell'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 aumento e alla dimensione del batch. Usa la stima dei costi della finestra di dialogo dell'addestramento per previsioni più accurate.
Sì. L'addestramento può essere eseguito senza supervisione finché il saldo è sufficiente, e la Piattaforma registra un evento di completamento o di errore. Se la contabilizzazione porta il saldo sotto zero, le esecuzioni cloud a pagamento attive vengono interrotte e viene addebitato il tempo GPU già utilizzato.
L'utilizzo del cloud viene conteggiato man mano che l'addestramento procede. Se un addebito porta il tuo saldo sotto zero, le esecuzioni attive di addestramento cloud a pagamento vengono interrotte e viene effettuato il conguaglio per il tempo GPU già utilizzato. Aggiungi crediti o abilita la ricarica automatica per mantenere finanziati i job di lunga durata.
Saldo negativoUn saldo pari a zero o negativo impedisce l'avvio di nuovi processi di addestramento cloud a pagamento. Un saldo negativo risultante dalla contabilizzazione attiva inoltre l'arresto delle esecuzioni di addestramento cloud a pagamento attive.
Le stime dei costi sono approssimative: il tempo effettivo di addestramento può variare a causa di fattori come la velocità di caricamento dei dati, il riscaldamento della GPU e il comportamento della convergenza del modello. Se l'utilizzo effettivo esaurisce il saldo disponibile, la Piattaforma interrompe le esecuzioni cloud a pagamento attive dopo che il saldo è diventato 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 Impostazioni avanzate nella finestra di dialogo dell'addestramento per accedere a un editor YAML con oltre 50 parametri configurabili. I valori non predefiniti vengono inclusi sia nei comandi di addestramento cloud sia in quelli locali.
L'editor YAML supporta anche l'importazione di configurazioni da precedenti esecuzioni di addestramento:
- Copia dal modello esistente: nella pagina di qualsiasi modello completato, la scheda Configurazione dell'addestramento contiene un menu Esporta dati con l'opzione Copia JSON. Incolla il JSON direttamente nell'editor YAML: il formato JSON viene rilevato automaticamente e tutti i parametri vengono importati. Lo stesso menu consente di scaricare la configurazione in formato CSV o JSON.
- Incolla YAML o JSON: incolla nell'editor una configurazione di addestramento YAML o JSON valida. I parametri vengono convalidati automaticamente; i valori fuori intervallo vengono limitati e vengono visualizzati degli avvisi.
- Trascina e rilascia i file: trascina un file
.yamlo.jsondirettamente nell'editor per importarne i parametri.

Questo rende semplice riprodurre o iterare sulle configurazioni di addestramento precedenti senza dover reinserire manualmente ogni parametro.
Sì. Un modello con errore mostra un banner di errore con un'azione Riprova che riapre la finestra di dialogo dell'addestramento con lo stesso modello di base, dataset e parametri, così puoi modificare un valore e avviare nuovamente l'addestramento. Il nuovo tentativo riutilizza la stessa pagina del modello: i grafici, l'output della console, le metriche di sistema e l'errore dell'esecuzione precedente vengono cancellati quando viene creato il nuovo processo, mentre i relativi pesi vengono sostituiti quando la nuova esecuzione produce un checkpoint migliore.
Sì, il pulsante Nuovo modello nelle pagine dei dataset apre la finestra di dialogo dell'addestramento con il dataset preselezionato e bloccato. Seleziona quindi un progetto e un modello per iniziare l'addestramento.