Ultralytics YOLO27: Iscriviti alla lista d'attesa.
Get Started
Ultralytics YOLO in produzione·Scegli un runtime·Lezione 1/9
Lezioneintermedio

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.

Telecamera del traffico sopra un'autostrada cittadina al tramonto, con Ultralytics YOLO che traccia automobili, un furgone e camion, ciascuno contrassegnato con una classe e un ID

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.

Esito

Scegli il runtime e il valore di format= per un dispositivo, converti un obiettivo in FPS in un budget in millisecondi e verifica la scelta con benchmark ripetuti.

Percorso rapido
Se sai già come muoverti, ecco la versione breve.
  1. GPU NVIDIA o Jetson → TensorRT (engine), compilato sul dispositivo di destinazione. CPU, iGPU o NPU Intel → OpenVINO (openvino).

  2. Apple → CoreML (coreml). Android → LiteRT (litert). NPU Snapdragon → QNN (qnn). Raspberry Pi → NCNN (ncnn).

  3. Qualsiasi altro dispositivo → ONNX Runtime (onnx). Se non vuoi gestire server → un endpoint gestito di Ultralytics Platform.

  4. Budget = 1000 ÷ FPS, meno il tempo di decodifica e post-elaborazione. Misura i candidati sul dispositivo e valuta il p95, non la media.

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:

ObiettivoRuntimeformat=Attenzione a
GPU NVIDIA, JetsonTensorRTengineUn engine funziona solo sulla famiglia di GPU e con la versione di TensorRT con cui è stato compilato
CPU, iGPU, NPU IntelOpenVINOopenvinoOttimizzato per Intel; misurane le prestazioni prima di usarlo altrove
Qualsiasi CPU o GPUONNX RuntimeonnxScegli esplicitamente il provider di esecuzione
iPhone, iPad, MacCoreMLcoremlL'esportazione viene eseguita su macOS o Linux, non su Windows
Android, sistemi embeddedLiteRTlitertINT8 richiede dati di calibrazione data
NPU SnapdragonQualcomm QNNqnnSolo esportazione quantizzata; passa il target Hexagon come name
Raspberry Pi, CPU ARMNCNNncnnIl formato più veloce nella guida a Raspberry Pi
BrowserONNX Runtime WebonnxAttieniti 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:

Scheda Deployments del profilo di Ultralytics Platform con una mappa mondiale delle regioni di distribuzione e schede riepilogative per le distribuzioni attive, le richieste HTTP, il tasso di errore e la latenza P95

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:

PassaggioEsempio: 20 FPS per telecamera
Budget per frame = 1000 ÷ FPS50 ms
Meno la decodifica (RTSP, 1080p)circa 10 ms
Meno tracking, conteggio e sinkcirca 5 ms
Meno il 20% di margine per i picchi10 ms
Disponibile per il modellocirca 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 imgsz prima 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 budget

Esaminiamole 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=onnx

Rimuovi 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#

Eseguire il benchmark sulla macchina sbagliata

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).

I motori TensorRT sono specifici per dispositivo

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.

Esegui il benchmark alla dimensione che userai in produzione

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.pt a raggiungere 1.000 dispositivi? Un'immagine Docker li mantiene coerenti.
Provalo

Scrivi un brief di distribuzione di cinque righe per un progetto reale o pianificato: dispositivo target, FPS per telecamera, telecamere per dispositivo, linguaggio chiamante e dimensione della flotta. Converti i dati in un budget del modello in millisecondi, scegli i candidati con l'albero decisionale ed esegui pick_runtime.py (con il tuo modello e i candidati) sul dispositivo target o sulla macchina più simile che hai a disposizione.

Criteri di completamento
La lezione è completata quando tutte le seguenti condizioni sono soddisfatte.
  • Il brief specifica il dispositivo, il runtime e il valore esatto di format=.

  • Hai ricavato il budget del modello in millisecondi dal target FPS, indicando cosa hai sottratto.

  • Hai i tempi di inferenza p50 e p95 di ciascun candidato, misurati sul dispositivo, e un verdetto rispetto al budget.

Mostra la soluzione

Un brief d'esempio per una distribuzione di analisi del commercio al dettaglio:

DomandaRisposta
Dispositivo40 mini PC in negozio con CPU Intel Core Ultra, senza GPU dedicata
FPS e telecamere10 FPS per telecamera, 2 telecamere per dispositivo
ChiamanteServizio Python su Linux
Flotta40 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 = 30

Il 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.

Prossimi passi

Scelto il target, nella prossima lezione esporterai il modello in ONNX e verificherai che l'esportazione produca gli stessi risultati di PyTorch.

Accedi per salvare i progressi