Modelli#
Ultralytics Platform offre una gestione completa dei modelli per l'addestramento, l'analisi e il deployment dei modelli YOLO. Carica modelli pre-addestrati o addine di nuovi direttamente sulla piattaforma.

Carica modello#
Carica i pesi di un modello esistente sulla piattaforma:
- Vai al tuo progetto
- Trascina e rilascia i file
.ptsulla pagina del progetto o nella barra laterale dei modelli, oppure fai clic sull'icona Carica modelli - I metadati del modello vengono analizzati automaticamente dal file
È possibile caricare più file contemporaneamente (fino a 3 in parallelo).
Formati di modello supportati:
| Formato | Estensione | Descrizione |
|---|---|---|
| PyTorch | .pt | Formato nativo Ultralytics |
Dopo il caricamento, la piattaforma analizza i metadati del modello:
- Tipo di attività (detect, segment, semantic, depth, classify, pose, OBB)
- Architettura (YOLO26n, YOLO26s, ecc.)
- Nomi e conteggio delle classi
- Dimensione dell'input e parametri
- Risultati e metriche di addestramento (se presenti nel checkpoint)
Addestra modello#
Addestra un nuovo modello direttamente sulla piattaforma:
- Vai al tuo progetto
- Fai clic su Nuovo Modello
- Seleziona il modello base e il dataset
- Configura i parametri di addestramento
- Scegli l'addestramento su cloud o locale
- Avvia l'addestramento
Vedi Addestramento nel cloud per istruzioni dettagliate.
Ciclo di vita del modello#
graph LR
A[Upload .pt]:::start --> B[Overview]:::proc
C[Train]:::start --> B
B --> D[Predict]:::proc
B --> E[Export]:::proc
B --> F[Deploy]:::proc
E --> G[20 Formats]:::out
F --> H[Endpoint]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffSchede della pagina modello#
Ogni pagina modello presenta le seguenti schede:
| Scheda | Contenuto |
|---|---|
| Panoramica | Metadati del modello, metriche chiave, link al dataset |
| Addestra | Grafici di addestramento, output della console, statistiche di sistema |
| Predizione | Inferenza interattiva nel browser |
| Esporta | Conversione di formato con selezione della GPU |
| Deploy | Creazione e gestione degli endpoint |
Scheda Panoramica#
Mostra i metadati e le metriche chiave del modello:
- Nome modello (modificabile), badge di stato, tipo di task
- Metriche finali (mAP50, mAP50-95, precision, recall)
- Grafici sparkline delle metriche che mostrano l'avanzamento dell'addestramento
- Argomenti di addestramento (epoche, dimensione batch, dimensione immagine, ecc.)
- Link al dataset (quando addestrato con un dataset della Piattaforma)
- Pulsante di download per i pesi del modello

Scheda Addestra#
La scheda Addestra ha tre sottoschede:
Sottoscheda Grafici#
Grafici interattivi delle metriche di addestramento che mostrano le curve di loss e le metriche di performance nel corso delle epoche:
| Gruppo Grafici | Metriche |
|---|---|
| Metriche | mAP50, mAP50-95, precisione, recall |
| Loss di Addestramento | train/box_loss, train/cls_loss, train/dfl_loss |
| Loss di Validazione | val/box_loss, val/cls_loss, val/dfl_loss |
| Tasso di apprendimento | lr/pg0, lr/pg1, lr/pg2 |

Sottoscheda Console#
Output live della console dal processo di addestramento:
- Streaming dei log in tempo reale durante l'addestramento
- Barre di avanzamento delle epoche e risultati di validazione
- Rilevamento degli errori con banner evidenziati
- Supporto colori ANSI per l'output formattato

Sottoscheda Sistema#
Metriche GPU e di sistema durante l'addestramento:
| Metrica | Descrizione |
|---|---|
| Utilizzo GPU | Percentuale di utilizzo della GPU |
| Memoria GPU | Utilizzo della memoria GPU |
| Temp GPU | Temperatura della GPU |
| Uso CPU | Utilizzo della CPU |
| RAM | Utilizzo della memoria di sistema |
| Disco | Utilizzo del disco |

Scheda Predici#
Esegui inferenza interattiva direttamente nel browser:
- Carica un'immagine, usa immagini di esempio o usa la webcam
- Visualizzazione dei risultati con bounding box, maschere, mappe delle classi semantiche o keypoint
- Auto-inferenza quando viene fornita un'immagine
- Supporta tutti i tipi di attività (detect, segment, semantic, depth, classify, pose, OBB)
La scheda Predici esegue l'inferenza su Ultralytics Cloud, quindi non hai bisogno di una GPU locale. I risultati vengono visualizzati con overlay interattivi che corrispondono al tipo di task del modello.
Scheda Esporta#
Esporta il tuo modello in 20 formati di deployment. Vedi Esportazione del modello qui sotto e la Guida alla modalità di esportazione principale per tutti i dettagli.
Scheda Deploy#
Crea e gestisci endpoint di inferenza dedicati. Vedi Deployments per i dettagli.
Grafici di Validazione#
Una volta terminato l'addestramento, visualizza l'analisi dettagliata della validazione:
Matrice di Confusione#
Heatmap interattiva che mostra l'accuratezza della predizione per classe:

Curve PR/F1#
Quando l'esecuzione dell'addestramento li fornisce, la scheda secondaria Validazione mostra anche le curve delle prestazioni a diverse soglie di confidenza. I grafici di validazione disponibili dipendono dagli artefatti prodotti dall'esecuzione.

| Curva | Descrizione |
|---|---|
| Precisione-Richiamo | Compromesso tra precisione e richiamo |
| F1-Confidenza | Punteggio F1 a diversi livelli di confidenza |
| Precisione-Confidenza | Precisione a diversi livelli di confidenza |
| Richiamo-Confidenza | Richiamo a diversi livelli di confidenza |
Esporta modello#
graph LR
A[Select Format]:::start --> B[Configure Args]:::proc
B --> C[Export]:::proc
C --> D{GPU Required?}:::decide
D -->|Yes| E[Cloud GPU Export]:::proc
D -->|No| F[CPU Export]:::proc
E --> G[Download]:::out
F --> G
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef decide fill:#FF9800,color:#fff
classDef out fill:#9C27B0,color:#fffEsporta il tuo modello in 20 formati di distribuzione:
- Vai alla scheda Export
- Seleziona il formato di destinazione
- Configura gli argomenti di esportazione (dimensione immagine, mezza precisione, dinamico, ecc.)
- Per i formati che richiedono la GPU (TensorRT), seleziona un tipo di GPU
- Fai clic su Avvia esportazione
- Scarica al termine
Collega gli avvisi Slack per ricevere un messaggio quando un'esportazione è pronta o fallisce.

Formati supportati#
La Platform supporta l'esportazione verso 20 formati di deployment: ONNX, TorchScript, OpenVINO, TensorRT, CoreML, TF SavedModel, TF GraphDef, LiteRT, TF Edge TPU, PaddlePaddle, NCNN, MNN, RKNN, Qualcomm (QNN), IMX500, Axelera, ExecuTorch, DeepX, Hailo e Huawei Ascend.
Guida alla selezione del formato#
| Destinazione | Formato consigliato | Note |
|---|---|---|
| GPU NVIDIA | TensorRT | Seleziona la stessa famiglia di GPU del dispositivo di distribuzione |
| NVIDIA Jetson | TensorRT | Seleziona l'obiettivo previsto e controlla il suo stato di validazione |
| Hardware Intel | OpenVINO | CPU, GPU e VPU |
| Dispositivi Apple | CoreML o LiteRT | iOS, macOS, Apple Silicon |
| Android | LiteRT o NCNN | LiteRT (runtime on-device di Google) o NCNN per ARM |
| Browser Web | LiteRT.js o ONNX | LiteRT.js o ONNX tramite ONNX Runtime Web |
| Dispositivi Edge | TF Edge TPU o RKNN | Coral e Rockchip (vedi chip supportati) |
| Generale | ONNX | Funziona con la maggior parte dei runtime |

Obiettivi NVIDIA Jetson TensorRT#
Ultralytics Platform offre le seguenti selezioni di target Jetson per le esportazioni TensorRT di .engine. A partire da luglio 2026, i worker di esportazione Jetson utilizzano JetPack 7.2 / L4T r39.2, Python 3.12.3, NVIDIA PyTorch 2.12.0a0 (build 26.04), CUDA 13.2 e TensorRT 10.16.1.11 all'interno del container di esportazione.
| Selezione dell'obiettivo | API gpuType | Memoria | Architettura GPU | Python | CUDA | TensorRT | Esportazione YOLO26n FP16 misurata | Validazione build/caricamento fisico |
|---|---|---|---|---|---|---|---|---|
| Jetson Thor T5000 | jetson-thor-t5000 | 128 GB | Blackwell, CC 11.0 | 3.12.3 | 13.2 | 10.16.1.11 | ~1m 46s | Thor nel profilo NVIDIA T4000; candidato T5000 |
| Jetson Thor T4000 | jetson-thor-t4000 | 64 GB | Blackwell, CC 11.0 | 3.12.3 | 13.2 | 10.16.1.11 | ~1m 46s | Thor nel profilo NVIDIA T4000 |
| Jetson AGX Orin 64GB | jetson-agx-orin-64gb | 64 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 7m 15s | Costruito, caricato e inferito su AGX Orin 64GB |
| Jetson AGX Orin 32GB | jetson-agx-orin-32gb | 32 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 34s | Build/caricamento su AGX Orin 64GB; SKU 32GB in attesa |
| Jetson Orin NX 16GB | jetson-orin-nx-16gb | 16 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 09s | Build/caricamento su AGX Orin 64GB; SKU NX in attesa |
| Jetson Orin NX 8GB | jetson-orin-nx-8gb | 8 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 01s | Build/caricamento su AGX Orin 64GB; SKU NX in attesa |
| Jetson Orin Nano 8GB Super | jetson-orin-nano-8gb | 8 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 4m 59s | Build/caricamento su AGX Orin 64GB; SKU Nano in attesa |
| Jetson Orin Nano 4GB | jetson-orin-nano-4gb | 4 GB | Ampere, CC 8.7 | 3.12.3 | 13.2 | 10.16.1.11 | 5m 01s | Build/caricamento su AGX Orin 64GB; SKU Nano in attesa |
Le tempistiche si riferiscono a singoli test di routing di produzione end-to-end osservati a luglio 2026, arrotondati al secondo più vicino; si tratta di misurazioni di riferimento, non di un SLA o di un benchmark delle prestazioni per SKU. Entrambe le selezioni Thor sono basate su un T5000 Developer Kit nel profilo di compatibilità T4000 di NVIDIA. I sei percorsi Orin sono basati su un AGX Orin 64GB, dove ogni motore risultante è stato caricato ed eseguito.
Gli engine scaricati sono legati alla loro piattaforma di build, alla famiglia di GPU, alla versione di TensorRT e a un runtime CUDA compatibile. Per i target Jetson, le versioni del software sono mostrate nella tabella sopra. Valida ciascun engine e la sua conformità di memoria sul dispositivo di deployment ed esegui lì la calibrazione INT8 per ottenere i risultati migliori. Se gli ambienti non corrispondono, esporta invece l'engine localmente. Vedi la Guida a NVIDIA Jetson e la Guida all'integrazione di TensorRT per i dettagli sul deployment locale.
Supporto chip RKNN#
Quando esporti nel formato RKNN, seleziona il tuo dispositivo Rockchip di destinazione:
| Chip | Descrizione |
|---|---|
| RK3588 | SoC edge di fascia alta |
| RK3576 | SoC edge di fascia media |
| RK3568 | SoC edge di fascia media |
| RK3566 | SoC edge di fascia media |
| RK3562 | SoC edge entry-level |
| RV1103 | Processore di visione |
| RV1106 | Processore di visione |
| RV1103B | Processore di visione |
| RV1106B | Processore di visione |
| RK2118 | Processore AI |
| RV1126B | Processore di visione |
Ciclo di vita del processo di esportazione#
I processi di esportazione avanzano attraverso i seguenti stati:
| Stato | Descrizione |
|---|---|
| In coda | Il processo di esportazione è in attesa di avvio |
| Starting | Il processo di esportazione si sta inizializzando |
| Running | L'esportazione è in corso |
| Completed | Esportazione terminata: download disponibile |
| Failed | Esportazione fallita (vedi messaggio di errore) |
| Cancelled | L'esportazione è stata annullata dall'utente |
Il tempo di esportazione varia in base al formato e all'host di build. Le esportazioni TensorRT potrebbero richiedere diversi minuti poiché TensorRT profila e ottimizza l'engine sulla GPU fisica mostrata nella Tabella di validazione Jetson o sulla GPU cloud selezionata.
Azioni di esportazione in blocco#
- Esporta tutto: fai clic su
Export Allper avviare i job di esportazione per tutti i formati basati su CPU con le impostazioni predefinite. - Elimina tutte le esportazioni: fai clic su
Delete Allper rimuovere tutte le esportazioni per il modello.
Restrizioni sui formati#
Alcuni formati di esportazione hanno restrizioni di architettura o di attività:
| Formato | Restrizione |
|---|---|
| IMX500 | Disponibile solo per YOLOv8n e YOLO11n; solo INT8 |
| Axelera | Solo modelli di rilevamento; solo INT8 |
| DeepX | Solo INT8 |
| Hailo | Output HEF INT8; seleziona l'architettura Hailo di destinazione |
| Huawei | Output FP16 .om; target Ascend310P1, Ascend310P3, Ascend310B1 e Ascend310B4 |
| Qualcomm | Quantizzazione W8A16 fissa; seleziona un target HTP supportato. Dragonwing IQ-8275 è supportato con name=iq-8275; IQ-615 non è supportato |
- Le esportazioni di classificazione non includono NMS.
- Le esportazioni CoreML con batch size superiori a
1utilizzanodynamic=true. - Le combinazioni non supportate di formato/modello sono disabilitate nella finestra di dialogo di esportazione prima dell'avvio.
Clona modello#
Clona un modello in un progetto diverso:
- Apri la pagina del modello
- Fai clic su Clona modello
- Seleziona il progetto di destinazione
- Fai clic su Clona modello
Il modello e i suoi pesi vengono copiati nel progetto di destinazione.
Scarica modello#
Scarica i pesi del tuo modello:
- Vai alla scheda Overview del modello
- Clicca sul pulsante Download
- Il checkpoint principale
.ptdel modello viene scaricato automaticamente
I formati esportati possono essere scaricati dalla scheda Export una volta completata l'esportazione.
Collegamento del dataset#
I modelli possono essere collegati al loro dataset di origine:
- Visualizza quale dataset è stato utilizzato per l'addestramento
- Clicca sulla scheda del dataset nella pagina Overview per andarci
- Traccia la provenienza dei dati
Quando esegui l'addestramento con i dataset di Platform utilizzando il ul:// formato URI, il collegamento è automatico.
# Train with a Platform dataset — linking is automatic
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100Lo schema ul:// si risolve nel tuo dataset Platform. La scheda Overview del modello addestrato mostrerà un link di ritorno a questo dataset (vedi Utilizzo dei dataset Platform).
Metadati personalizzati#
Apri Altre azioni e seleziona Informazioni per esaminare due sezioni:
- Metadati Ultralytics: dettagli Platform di sola lettura come ID del modello, progetto, dataset di origine, attività, stato e timestamp
- Metadati personalizzati: il tuo oggetto JSON per contesto di valutazione, tracciamento delle release, governance o altri dati specifici del modello
I metadati personalizzati sono separati dalle informazioni del modello di proprietà dell'addestramento, dai dettagli dell'ambiente e dagli argomenti di addestramento. Gli osservatori dello spazio di lavoro possono ispezionarli, mentre i membri con accesso di modifica possono sostituire l'oggetto. L'oggetto di metadati serializzato è limitato a 500.000 caratteri e ciascuna chiave di primo livello è limitata a 128 caratteri. Salva un oggetto vuoto ({}) per cancellare i metadati personalizzati.
Impostazioni di visibilità#
Controlla chi può vedere il tuo modello:
| Impostazione | Descrizione |
|---|---|
| Privato | Accessibile solo da te e dai membri dello spazio di lavoro |
| Pubblico | Chiunque può visualizzare sulla pagina Esplora |
Per modificare la visibilità, fai clic sul badge di visibilità (ad es. private o public) nell'intestazione della pagina. La visibilità è impostata a livello di progetto, quindi questo controlla tutti i modelli nel progetto. Il passaggio a privato ha effetto immediato. Il passaggio a pubblico mostra una finestra di dialogo di conferma prima dell'applicazione.
Elimina Modello#
Rimuovi un modello che non ti serve più:
- Fai clic sull'icona del cestino Elimina modello nell'intestazione del modello
- Conferma l'eliminazione
I modelli eliminati vanno nel Cestino per 30 giorni. Ripristina da Impostazioni > Cestino.
Vedi anche#
- Inferenza: testa i modelli nel browser con la scheda Predict
- Endpoint: effettua il deploy dei modelli in produzione con endpoint dedicati
- Addestramento nel cloud: configura ed esegui i job di addestramento su GPU cloud
- Formati di esportazione: guida completa a tutti i 20 formati di esportazione
FAQ#
Quali architetture di modello sono supportate?#
La Ultralytics Platform supporta pienamente tutte le architetture YOLO con progetti dedicati:
- YOLO26: varianti n, s, m, l, x (ultime, consigliate) — platform.ultralytics.com/ultralytics/yolo26
- YOLO11: varianti n, s, m, l, x — platform.ultralytics.com/ultralytics/yolo11
- YOLOv8: varianti n, s, m, l, x — platform.ultralytics.com/ultralytics/yolov8
- YOLOv5: varianti n, s, m, l, x — platform.ultralytics.com/ultralytics/yolov5
YOLO26 supporta 7 tipi di attività: detect, segment, semantic, depth, classify, pose e OBB. YOLO11 e YOLOv8 supportano lo stesso insieme tranne la segmentazione semantica e la profondità, mentre YOLOv5 supporta detect, segment e classify.
Posso scaricare il mio modello addestrato?#
Sì, scarica i pesi del tuo modello dalla pagina del modello:
- Clicca sull'icona di download nella scheda Panoramica
- Il checkpoint principale
.ptdel modello viene scaricato automaticamente - I formati esportati possono essere scaricati dalla scheda Esporta
Come confronto i modelli tra diversi progetti?#
Attualmente, il confronto dei modelli avviene all'interno dei progetti. Per confrontare tra diversi progetti:
- Clona i modelli in un unico progetto, oppure
- Esporta le metriche e confronta esternamente
Qual è la dimensione massima del modello?#
I file di modello .pt caricati sono limitati a 1 GB e i modelli vicini a tale limite potrebbero richiedere più tempo per il caricamento e l'elaborazione.
Posso fare il fine-tuning di modelli pre-addestrati?#
Sì. Scegli un modello compatibile dai progetti ufficiali YOLO26, YOLO11, YOLOv8 o YOLOv5, oppure seleziona uno dei tuoi checkpoint completati o caricati da I miei modelli nella finestra di dialogo dell'addestramento.