Scegli una destinazione di distribuzione
Individua un runtime e un formato di esportazione a partire dal dispositivo, dal budget di latenza e dalla flotta, quindi verifica la scelta sul dispositivo.

Lo stesso YOLO26n impiega 38.9 ms per immagine su una CPU con ONNX Runtime e 1.7 ms su una GPU T4 con TensorRT nei benchmark di YOLO26. Se scegli il runtime sbagliato, pagherai per hardware molto più potente del necessario oppure distribuirai telecamere che non riescono a stare al passo. In questa lezione trasformerai la scelta in una decisione di dieci minuti, giustificabile con misurazioni eseguite direttamente sul dispositivo.
Pratico
Parti dal dispositivo#
Il runtime dipende da dove viene eseguita l'inferenza, non dalle abitudini. Segui l'albero dall'alto e fermati alla prima corrispondenza:
A ogni runtime corrisponde un valore di format= in Modalità di esportazione:
| Obiettivo | Runtime | format= | Attenzione a |
|---|---|---|---|
| GPU NVIDIA, Jetson | TensorRT | engine | Un engine funziona solo sulla famiglia di GPU e con la versione di TensorRT con cui è stato compilato |
| CPU, iGPU, NPU Intel | OpenVINO | openvino | Ottimizzato per Intel; misurane le prestazioni prima di usarlo altrove |
| Qualsiasi CPU o GPU | ONNX Runtime | onnx | Scegli esplicitamente il provider di esecuzione |
| iPhone, iPad, Mac | CoreML | coreml | L'esportazione viene eseguita su macOS o Linux, non su Windows |
| Android, sistemi embedded | LiteRT | litert | INT8 richiede dati di calibrazione data |
| NPU Snapdragon | Qualcomm QNN | qnn | Solo esportazione quantizzata; passa il target Hexagon come name |
| Raspberry Pi, CPU ARM | NCNN | ncnn | Il formato più veloce nella guida a Raspberry Pi |
| Browser | ONNX Runtime Web | onnx | Attieniti ai modelli n o s |
Sulle piattaforme Apple più recenti puoi anche esportare nel nuovo formato Core AI di Apple (format=coreai, esportato su macOS 26+ con Apple silicon o su Linux x86-64). Non hai mai esportato un modello? La lezione Esportazione per la distribuzione illustra le nozioni di base.
Se preferisci evitare del tutto i server di inferenza, Ultralytics Platform distribuisce un modello come endpoint dedicato in una delle 42 regioni; la scheda Deployments del tuo profilo mostra dove viene eseguito ciascun endpoint:

Questo percorso è descritto in Distribuire e chiamare un endpoint. Il resto del corso è dedicato ai casi in cui esegui il modello autonomamente.
Converti il target FPS in un budget in millisecondi#
«In tempo reale» non è un requisito; lo è un valore numerico. Calcolalo prima di eseguire qualsiasi benchmark:
| Passaggio | Esempio: 20 FPS per telecamera |
|---|---|
| Budget per frame = 1000 ÷ FPS | 50 ms |
| Meno la decodifica (RTSP, 1080p) | circa 10 ms |
| Meno tracking, conteggio e sink | circa 5 ms |
| Meno il 20% di margine per i picchi | 10 ms |
| Disponibile per il modello | circa 25–30 ms |
Poi applica queste regole decisionali:
- Se YOLO26n richiede più del budget assegnato al modello sulla CPU del dispositivo, passa a un acceleratore (GPU, iGPU, NPU) o riduci
imgszprima di fare qualsiasi altra cosa; i benchmark di YOLO26 indicano 38,9 ms per YOLO26n su CPU con ONNX e 1,7 ms su una T4 con TensorRT. - Se un dispositivo deve servire più telecamere, dividi il budget del modello per il numero di telecamere.
- Se la flotta comprende più di una manciata di tipi di dispositivo, preferisci runtime che non richiedono build specifiche per dispositivo oppure pianifica una build per ogni classe di dispositivo.
- Se il codice chiamante è in Swift, Kotlin o C++, controlla che l'SDK del runtime supporti quel linguaggio prima di prendere una decisione.
Esegui il benchmark dei candidati sul dispositivo#
Le schede tecniche e i benchmark di altri sono un punto di partenza. La scelta si fa sull'hardware su cui distribuirai il modello e considerando i frame più lenti, non la media: un runtime veloce nella mediana ma che si blocca su un frame ogni venti continuerà a perdere frame. Questo script esporta ogni candidato, misura il tempo di 100 inferenze su un frame reale e valuta ciascun candidato in base al 95° percentile (p95):
from ultralytics import YOLO
from ultralytics.utils.downloads import safe_download
BUDGET_MS = 30 # the model's share of a 20 FPS frame budget
CANDIDATES = ("onnx", "openvino") # runtimes the decision tree allows on this machine
if __name__ == "__main__": # exports and inference can start worker processes on macOS and Windows
frame = str(safe_download("https://ultralytics.com/images/bus.jpg")) # use a real frame from your camera
for fmt in CANDIDATES:
model = YOLO(YOLO("yolo26n.pt").export(format=fmt))
for _ in range(5): # warm up: the first calls include one-time setup
model(frame, verbose=False)
runs = sorted(model(frame, verbose=False)[0].speed["inference"] for _ in range(100))
p50, p95 = runs[49], runs[94]
verdict = "meets" if p95 <= BUDGET_MS else "misses"
print(f"{fmt:9s} p50 {p50:5.1f} ms p95 {p95:5.1f} ms {verdict} the {BUDGET_MS} ms budget")Sul portatile con Apple silicon usato per testare questo corso, mentre altri processi condividevano la CPU:
onnx p50 30.0 ms p95 46.4 ms misses the 30 ms budget
openvino p50 22.8 ms p95 113.5 ms misses the 30 ms budgetEsaminiamole una per una:
speed["inference"]è il tempo impiegato dal modello per quel frame, senza decodifica né disegno, quindi consente di confrontare equamente i runtime.- OpenVINO vince sulla mediana e perde sul p95 con un fattore superiore a due. Se giudicassi in base alle medie, distribuiresti il runtime che si blocca nei momenti di maggior carico; valutando il p95, ONNX Runtime è la scelta più stabile su questa macchina.
- Entrambi superano il budget, quindi in questo caso la mossa successiva è ridurre
imgsz, usare un acceleratore o diminuire il numero di telecamere per dispositivo, non provare un altro runtime per CPU.
Per confrontare rapidamente accuratezza e velocità tra i formati, la modalità Benchmark esporta, convalida e misura il tempo di ciascuno:
yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 format=onnxRimuovi format= per provare tutti i formati supportati dalla macchina. COCO8 contiene solo quattro immagini di convalida: considera la colonna mAP un test rapido della pipeline e usa il file YAML del tuo dataset per valutare l'accuratezza.
Insidie#
Sintomo: il modello raggiungeva 60 FPS sulla tua workstation ma perde fotogrammi sul dispositivo. Soluzione: esegui il benchmark sull'hardware di destinazione, o sulla macchina più simile che riesci a trovare, e con il carico che avrà in produzione (altri processi, altre telecamere).
Sintomo: un .engine creato su una GPU da data center non si carica su un Jetson Orin. Soluzione: compila sul dispositivo di destinazione al momento dell'installazione (una compilazione YOLO26n FP16 richiede circa 5 minuti su un Jetson Orin, secondo la documentazione sull'esportazione della piattaforma) oppure mantieni una compilazione per ogni classe di dispositivo e versione TensorRT e distribuisci .pt o .onnx, così ogni dispositivo può ricompilare.
yolo benchmark misura alla imgsz specificata. Se in produzione usi imgsz=1280, esegui il benchmark a 1280: il calcolo aumenta con il numero di pixel, quindi i valori a 640 sottostimano di circa 4× le prestazioni di una distribuzione a 1280.
I dispositivi edge aggiungono quattro domande#
Le guide a Raspberry Pi, NVIDIA Jetson e DeepStream su Jetson trattano nel dettaglio i target più comuni. Prima di scegliere un dispositivo edge, rispondi a queste domande:
- Avvio a freddo: dove viene compilato il motore TensorRT e chi deve aspettare che sia pronto?
- Consumo e calore: il contenitore riesce a sostenere il modello al massimo degli FPS per tutto il giorno?
- Memoria: c'è spazio per i buffer dei frame e lo stato del tracker oltre che per il modello? INT8 dimezza la quota di memoria del modello.
- Aggiornamenti: come fa una nuova
best.pta raggiungere 1.000 dispositivi? Un'immagine Docker li mantiene coerenti.
Mostra la soluzione
Un brief d'esempio per una distribuzione di analisi del commercio al dettaglio:
| Domanda | Risposta |
|---|---|
| Dispositivo | 40 mini PC in negozio con CPU Intel Core Ultra, senza GPU dedicata |
| FPS e telecamere | 10 FPS per telecamera, 2 telecamere per dispositivo |
| Chiamante | Servizio Python su Linux |
| Flotta | 40 dispositivi, aggiornati tramite un'immagine Docker |
Budget: 1000 ÷ 10 = 100 ms per frame; sottrai circa 15 ms per la decodifica e il tracking e lascia un margine del 20%: restano circa 65 ms, condivisi da due telecamere, quindi circa 30 ms per inferenza. L'albero decisionale suggerisce OpenVINO (CPU Intel), con ONNX Runtime come alternativa; ecco i risultati su un dispositivo del negozio:
python pick_runtime.py # CANDIDATES = ("onnx", "openvino"), BUDGET_MS = 30Il benchmark della CPU Core Ultra 7 155H nella documentazione di OpenVINO indica 13,4 ms per YOLO26n con OpenVINO FP32, quindi yolo26n dovrebbe rientrare comodamente nel budget; se il p95 sul dispositivo reale, con entrambe le pipeline delle telecamere in esecuzione, è inferiore a 30 ms, distribuisci OpenVINO. Se non rientra nel budget, prova la GPU integrata del dispositivo con device="intel:gpu" prima di acquistare nuovo hardware.