Link to this sectionModelli#
Ultralytics Platform fornisce una gestione completa dei modelli per l'addestramento, l'analisi e il deployment dei modelli YOLO. Carica modelli pre-addestrati o addestrarne di nuovi direttamente sulla piattaforma.

Link to this sectionCarica modello#
Carica i pesi di un modello esistente sulla piattaforma:
- Vai al tuo progetto
- Trascina i file
.ptsulla pagina del progetto o nella barra laterale dei 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 task (detect, segment, semantic, pose, OBB, classify)
- Architettura (YOLO26n, YOLO26s, ecc.)
- Nomi e conteggio delle classi
- Dimensione dell'input e parametri
- Risultati e metriche di addestramento (se presenti nel checkpoint)
Link to this sectionAddestra 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
Consulta Cloud Training per istruzioni dettagliate.
Link to this sectionCiclo 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[19+ Formats]:::out
F --> H[Endpoint]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffLink to this sectionSchede 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 |
Link to this sectionScheda 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

Link to this sectionScheda Addestra#
La scheda Addestra ha tre sottoschede:
Link to this sectionSottoscheda 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 |

Link to this sectionSottoscheda 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

Link to this sectionSottoscheda 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 |

Link to this sectionScheda 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 task (detect, segment, semantic, pose, OBB, classify)
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.
Link to this sectionScheda Esporta#
Esporta il tuo modello in oltre 19 formati di deployment. Consulta Esporta Modello di seguito e la guida alla modalità Esporta principale per tutti i dettagli.
Link to this sectionScheda Deploy#
Crea e gestisci endpoint di inferenza dedicati. Vedi Deployments per i dettagli.
Link to this sectionGrafici di Validazione#
Una volta terminato l'addestramento, visualizza l'analisi dettagliata della validazione:
Link to this sectionMatrice di Confusione#
Heatmap interattiva che mostra l'accuratezza della predizione per classe:

Link to this sectionCurve PR/F1#
Curve di performance a diverse soglie di confidenza:

| 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 |
Link to this sectionEsporta 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 oltre 19 formati di deployment:
- 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
- Clicca su Export
- Scarica al termine

Link to this sectionFormati supportati#
La piattaforma supporta l'esportazione verso 19+ formati di distribuzione: ONNX, TorchScript, OpenVINO, TensorRT, CoreML, TF SavedModel, TF GraphDef, LiteRT, TF Edge TPU, PaddlePaddle, NCNN, MNN, RKNN, Qualcomm (QNN), IMX500, Axelera, ExecuTorch e DeepX.
Link to this sectionGuida 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 |

Link to this sectionObiettivi NVIDIA Jetson TensorRT#
Ultralytics Platform offre le seguenti selezioni di obiettivi Jetson per esportazioni TensorRT .engine. A 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.
I motori scaricati sono vincolati alla loro piattaforma di build, famiglia GPU, versione di TensorRT e a un runtime CUDA compatibile. Per i target Jetson, le versioni software sono mostrate nella tabella precedente. Valida ogni motore e il suo ingombro in memoria sul dispositivo di distribuzione, ed esegui la calibrazione INT8 in quella sede per ottenere i migliori risultati. Se gli ambienti non corrispondono, esporta il motore localmente. Consulta la guida NVIDIA Jetson e la guida all'integrazione TensorRT per i dettagli sulla distribuzione locale.
Link to this sectionSupporto 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 |
Link to this sectionCiclo 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 possono richiedere diversi minuti perché TensorRT profila e ottimizza il motore sulla GPU fisica mostrata nella tabella di validazione Jetson o sulla GPU cloud selezionata.
Link to this sectionAzioni di esportazione in blocco#
- Esporta tutto: Clicca su
Export Allper avviare i processi di esportazione per tutti i formati basati su CPU con le impostazioni predefinite. - Elimina tutte le esportazioni: Clicca su
Delete Allper rimuovere tutte le esportazioni per il modello.
Link to this sectionRestrizioni sui formati#
Alcuni formati di esportazione hanno restrizioni di architettura o di attività:
| Formato | Restrizione |
|---|---|
| IMX500 | Disponibile solo per YOLOv8n e YOLO11n |
| Axelera | Solo modelli di rilevamento (detect) |
- Le esportazioni di classificazione non includono NMS.
- Le esportazioni CoreML con dimensioni del batch superiori a
1utilizzanodynamic=true. - Le combinazioni non supportate di formato/modello sono disabilitate nella finestra di dialogo di esportazione prima dell'avvio.
Link to this sectionClona modello#
Clona un modello in un progetto diverso:
- Apri la pagina del modello
- Clicca sul pulsante Clone
- Seleziona il progetto di destinazione
- Clicca su Clone
Il modello e i suoi pesi vengono copiati nel progetto di destinazione.
Link to this sectionScarica modello#
Scarica i pesi del tuo modello:
- Vai alla scheda Overview del modello
- Clicca sul pulsante Download
- Il file
.ptoriginale si scaricherà automaticamente
I formati esportati possono essere scaricati dalla scheda Export una volta completata l'esportazione.
Link to this sectionCollegamento 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 effettui il training con i dataset della Platform utilizzando il formato URI ul://, il collegamento avviene automaticamente.
# Train with a Platform dataset — linking is automatic
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100Lo schema ul:// rimanda al tuo dataset sulla Platform. La scheda Panoramica del modello addestrato mostrerà un collegamento a questo dataset (vedi Utilizzo dei Dataset della Platform).
Link to this sectionImpostazioni di visibilità#
Controlla chi può vedere il tuo modello:
| Impostazione | Descrizione |
|---|---|
| Privato | Puoi accedere solo tu |
| Pubblico | Chiunque può visualizzare sulla pagina Esplora |
Per modificare la visibilità, clicca 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.
Link to this sectionElimina Modello#
Rimuovi un modello che non ti serve più:
- Apri il menu delle azioni del modello
- Clicca Elimina
- Conferma l'eliminazione
I modelli eliminati finiscono nel Cestino per 30 giorni. Ripristinali da Impostazioni > Cestino.
Link to this sectionVedi anche#
- Inferenza: Testa i modelli nel browser con la scheda Predict
- Endpoint: Distribuisci i modelli in produzione con endpoint dedicati
- Cloud Training: Configura ed esegui job di training su GPU cloud
- Formati di Esportazione: Guida completa a tutti i 19+ formati di esportazione
Link to this sectionFAQ#
Link to this sectionQuali architetture di modello sono supportate?#
La Ultralytics Platform supporta pienamente tutte le architetture YOLO con progetti dedicati:
- YOLO26: varianti n, s, m, l, x (più recente, consigliata) — 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 6 tipi di attività: detect, segment, semantic, pose, OBB e classify. YOLO11 e YOLOv8 supportano lo stesso set tranne la segmentazione semantica, mentre YOLOv5 supporta detect, segment e classify.
Link to this sectionPosso 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 file
.ptoriginale si scaricherà automaticamente - I formati esportati possono essere scaricati dalla scheda Esporta
Link to this sectionCome 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
Link to this sectionQual è la dimensione massima del modello?#
I file del modello .pt caricati sono limitati a 1 GB e i modelli vicini a quel limite potrebbero richiedere più tempo per il caricamento e l'elaborazione.
Link to this sectionPosso fare il fine-tuning di modelli pre-addestrati?#
Sì! Puoi usare uno qualsiasi dei modelli ufficiali YOLO26 come base, oppure selezionare uno dei tuoi modelli completati dal selettore di modelli nella finestra di dialogo di training. La Platform supporta il fine-tuning da qualsiasi checkpoint caricato.