Esporta modelli YOLO in LiteRT per la distribuzione su dispositivi edge e sul web#

LiteRT (abbreviazione di Lite Runtime) è il runtime ad alte prestazioni di Google per l'IA on-device. È la nuova generazione e il nuovo nome di TensorFlow Lite (TFLite) e utilizza lo stesso formato di modello .tflite. Con LiteRT, un singolo modello Ultralytics YOLO esportato può essere distribuito su dispositivi mobili, sistemi embedded, dispositivi edge e browser: copre tutto ciò che i precedenti formati di esportazione tflite e tfjs gestivano separatamente, riunendolo ora in un'unica soluzione.

Guarda: Come esportare Ultralytics YOLO26 in Google LiteRT | Distribuisci l'IA per la visione su Android e iOS | IA mobile 📱🚀

Il formato di esportazione LiteRT ottimizza i tuoi modelli per attività come il rilevamento degli oggetti, la segmentazione, la stima della posa e la classificazione, così possono funzionare rapidamente e offline su un'ampia gamma di dispositivi.

npm i @ultralytics/yolo @litertjs/core

Perché esportare in LiteRT?#

LiteRT è un framework open source progettato per l'inferenza on-device, nota anche come edge computing. Offre agli sviluppatori gli strumenti per eseguire modelli addestrati su dispositivi mobili, sistemi embedded e IoT, computer tradizionali e, tramite LiteRT.js, direttamente nei browser web e in Node.js.

Un formato di modello, ogni destinazione:

• Dispositivi mobili e sistemi embedded: Android, iOS, Linux embedded e microcontrollori (MCU).
• Acceleratori edge: compatibile con Coral Edge TPU per un'ulteriore accelerazione.
• Browser e Node.js: LiteRT.js esegue sul web lo stesso modello .tflite con accelerazione WebGPU/WASM, eliminando la necessità di un'esportazione TensorFlow.js separata.

Funzionalità principali dei modelli LiteRT#

• Ottimizzazione sul dispositivo: riduce la latenza elaborando i dati localmente, migliora la privacy evitando di trasmettere dati personali e riduce al minimo le dimensioni del modello per risparmiare spazio.
• Supporto di più piattaforme: funziona su Android, iOS, Linux embedded, microcontrollori e browser web moderni.
• Accelerazione hardware: sfrutta XNNPACK sulla CPU e l'accelerazione GPU tramite OpenCL, Metal e WebGPU. Per impostazione predefinita, il delegate GPU esegue i calcoli in FP16 per offrire prestazioni ancora migliori.
• Quantizzazione: supporta FP32, INT8 statica (quantize=8, pesi int8 + attivazioni int8), INT16 statica per le attivazioni (quantize="w8a16", pesi int8 + attivazioni int16 per una maggiore precisione) e INT8 dinamica (quantize="w8a32", pesi int8 + attivazioni FP32, senza necessità di dati di calibrazione) per comprimere i modelli e velocizzare l'inferenza con una perdita minima di precisione.
• Supporto per diversi linguaggi: compatibile con Java/Kotlin, Swift, Objective-C, C++, Python e JavaScript.

Prestazioni misurate#

Hardware: Xiaomi 17 con 12 GB di memoria LPDDR5X e Android 17 / API 37. Il suo Snapdragon 8 Elite Gen 5 a 3 nm (SM8850) integra una CPU Qualcomm Oryon a 8 core (2 core Prime fino a 4.6 GHz e 6 core Performance fino a 3.62 GHz), una GPU Adreno e una NPU Hexagon.

• I valori di velocità sono latenze a raffica su singola immagine: la media di 15 esecuzioni dopo 3 esecuzioni di riscaldamento su bus.jpg, misurata con il plugin Flutter di Ultralytics 0.7.1 e gli asset ufficiali v0.7.0 (esportazioni di Ultralytics 8.4.188). L'ordine CPU/GPU è stato alternato tra le attività in un'unica sequenza di test. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL).
• L'esportazione LiteRT traccia direttamente il modello PyTorch, generando un .tflite NCHW con input float: il delegate GPU compila l'intero grafo (qui tutte e sette le attività vengono eseguite sulla GPU Adreno) e w8a32 non richiede dati di calibrazione. Chi utilizza il modello dovrebbe leggere le forme dei tensori e i nomi delle signature anziché dare per scontato il layout NHWC legacy di onnx2tf o i nomi di output Identity; i dati RGB vanno organizzati direttamente in CHW planare o trasposti prima dell'inferenza. Le esportazioni semantiche restituiscono logits NCHW e richiedono un argmax delle classi sul lato host. Gli asset Android ufficiali sono disponibili nella release v0.7.0 di yolo-flutter-app; il documento sulle prestazioni di Flutter contiene i dettagli completi del benchmark.
• La colonna NPU indica il percorso NPU di LiteRT: un'esportazione FP32 (yolo export format=litert, senza quantize) compilata sul dispositivo dai runtime litert-npu-runtime-qualcomm e -mediatek 2.3.0, misurata con una build prototipo del plugin Flutter per NPU (non ancora rilasciata). Il primo caricamento include la compilazione (circa 0.3 s per n, fino a 6 s per x). Gli asset w8a32 non vengono compilati completamente su queste NPU. LiteRT segnala una compilazione NPU anche quando esegue silenziosamente il grafo sulla GPU, quindi ogni riga NPU è stata confrontata con il tempo GPU; le righe che sono passate alla GPU sono indicate con —.
• I valori corrispondenti per la NPU Hexagon Snapdragon con gli asset QNN ufficiali sono disponibili nell'integrazione Qualcomm QNN.
• Confronta i risultati di CPU/acceleratore Apple nell'integrazione CoreML.

I seguenti test comparativi sui dispositivi utilizzano gli stessi asset ufficiali v0.7.0.

Google Pixel 10#

Hardware: Google Pixel 10 con 12 GB di memoria e Android 17 / API 37. Il suo Google Tensor G5 a 3 nm integra una CPU a 8 core (1 core Prime fino a 3.78 GHz, 5 core Performance fino a 3.05 GHz e 2 core Efficiency fino a 2.25 GHz), una GPU PowerVR D-Series e una TPU Google. Le frequenze dei core e il nome del driver GPU sono stati rilevati dal dispositivo usato per i test comparativi, perché Google non li pubblica nelle specifiche collegate.

Test comparativo: media di 15 chiamate predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.7.1 e gli asset ufficiali v0.7.0. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza di test. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL). La TPU Tensor non ha una riga LiteRT: il servizio EdgeTPU di Google rifiuta le app che non sono nella relativa lista di autorizzazione e LiteRT esegue quindi il modello sulla GPU.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) con 12 GB di memoria e Android 17 / API 37. Il suo Exynos 2600 a 2 nm integra una CPU Armv9.3 a 10 core (1 core C1-Ultra fino a 3.8 GHz, 3 core C1-Pro ad alte prestazioni fino a 3.26 GHz e 6 core C1-Pro a basso consumo fino a 2.76 GHz), una GPU Xclipse 960 e una NPU Samsung.

Test comparativo: media di 15 chiamate predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.7.1 e gli asset ufficiali v0.7.0. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza di test. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL). La colonna NPU usa gli asset w8a32 compilati in anticipo per Exynos 2600 (E9965) con il plugin del compilatore Samsung di LiteRT. Samsung non dispone di un compilatore sul dispositivo in LiteRT 2.3 e Google non pubblica ancora un runtime per NPU Samsung, quindi per queste righe è stata usata una libreria di dispatch creata dai sorgenti di LiteRT 2.3.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) con 12 GB di memoria LPDDR5X e Android 16 / API 36. Il suo MediaTek Dimensity 9500 a 3 nm (MT6993) integra una CPU Armv9.3 a 8 core (1 core C1-Ultra fino a 4.21 GHz, 3 core C1-Premium fino a 3.5 GHz e 4 core C1-Pro fino a 2.7 GHz), una GPU Mali-G1 Ultra MC12 e una NPU MediaTek 990.

Benchmark: media di 15 chiamate a predict() dopo 3 fasi di riscaldamento su bus.jpg, usando ultralytics_yolo 0.7.1 e gli asset ufficiali v0.7.0. L'ordine CPU/GPU si alterna tra le attività durante un'unica esecuzione sequenziale. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e che ogni riga GPU delegava l'intero grafo a LiteRT OpenCL (LITERT_CL). Profondità e OBB non hanno risultati NPU: il compilatore NPU di MediaTek rifiuta le operazioni esponenziali e trigonometriche e LiteRT esegue questi grafi sulla GPU.

Attività supportate#

L'esportazione LiteRT supporta tutte e sette le attività Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

Esportazione in LiteRT: convertire il tuo modello YOLO#

Puoi migliorare l'efficienza dell'esecuzione sul dispositivo e ampliare le opzioni di deployment convertendo i tuoi modelli nel formato LiteRT.

Installazione#

Per installare il pacchetto richiesto, esegui:

# Install the required package for YOLO
pip install ultralytics

Per istruzioni dettagliate e best practice, consulta la nostra guida all'installazione di Ultralytics. Se riscontri difficoltà, consulta la nostra guida ai problemi comuni.

Utilizzo#

Tutti i modelli Ultralytics YOLO supportano l'esportazione senza configurazioni aggiuntive. Il formato LiteRT supporta le modalità Export, Predict e Validate: puoi esportare un modello e poi caricarlo per eseguire inferenze o convalidarne localmente la precisione.

from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato LiteRT
model.export(format="litert", imgsz=640)  # crea 'yolo26n.tflite'; usa imgsz=224 per la classificazione

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# INT8 dinamica: pesi int8, attivazioni FP32: non sono necessari dati di calibrazione
model.export(format="litert", quantize="w8a32", imgsz=640)  # crea 'yolo26n_w8a32.tflite'

# INT8 statica: pesi int8 + attivazioni int8: richiede dati di calibrazione
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # crea 'yolo26n_int8.tflite'

# w8a16 statica: pesi int8 + attivazioni int16 (maggiore precisione): richiede dati di calibrazione
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # crea 'yolo26n_w8a16.tflite'

from ultralytics import YOLO

# Carica il modello LiteRT esportato
model = YOLO("yolo26n.tflite")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carica il modello LiteRT esportato
model = YOLO("yolo26n.tflite")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Argomenti di esportazione#

Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione Ultralytics dedicata all'esportazione.

Inferenza su CPU e NPU Intel#

I modelli .tflite esportati vengono eseguiti sull'hardware Intel tramite il plugin LiteRT Intel OpenVINO. Passa device=intel:cpu oppure device=intel:npu e Ultralytics installa ai-edge-litert>=2.3.0 e ai-edge-litert-sdk-intel al primo utilizzo. La NPU richiede un processore Intel Core Ultra con il driver Intel NPU installato.

from ultralytics import YOLO

model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="intel:npu")  # oppure "intel:cpu"

Hardware: Intel Core Ultra X7 358H (Panther Lake) e Intel AI Boost NPU 5010, Fedora Linux, driver NPU 1.38.0, ai-edge-litert 2.3.0.

Benchmark: Media di 15 chiamate predict() dopo 3 cicli di riscaldamento su bus.jpg, usando ultralytics 8.4.174 e ai-edge-litert 2.3.0 con esportazioni w8a32. Ogni cella mostra il tempo totale, con la suddivisione tra pre-elaborazione, inferenza e post-elaborazione riportata sotto.

Distribuzione dei modelli YOLO LiteRT esportati#

Dopo aver esportato il tuo modello Ultralytics YOLO in LiteRT, puoi distribuirlo su diverse piattaforme. Il modo più rapido per verificarlo localmente è il metodo YOLO("yolo26n.tflite") mostrato sopra. Per distribuirlo in altri ambienti, consulta le risorse seguenti:

Mobile e sistemi embedded#

• Android: una guida introduttiva rapida per integrare LiteRT nelle applicazioni Android.
• iOS: una guida per integrare e distribuire modelli LiteRT nelle applicazioni iOS.
• Linux embedded e Raspberry Pi: esegui modelli LiteRT su computer a scheda singola, con accelerazione opzionale tramite Coral Edge TPU.
• Microcontrollori: distribuisci su MCU con solo pochi kilobyte di memoria: il runtime di base occupa circa 16 KB su un Arm Cortex-M3.

Browser e Node.js (LiteRT.js)#

• Panoramica di LiteRT.js: esegui lo stesso modello .tflite direttamente nel browser con accelerazione WebGPU/WASM, eliminando i calcoli lato server e mantenendo i dati sul dispositivo dell'utente.
• Esempi end-to-end: esempi pratici ed esercitazioni per implementare LiteRT su dispositivi mobili, edge e web.

Riepilogo#

In questa guida abbiamo illustrato come esportare i modelli Ultralytics YOLO nel formato LiteRT. Riunendo la distribuzione su dispositivi mobili/edge (in precedenza TFLite) e nel browser (in precedenza TF.js) in un unico modello .tflite, LiteRT rende i tuoi modelli YOLO più veloci, più piccoli e portabili praticamente su qualsiasi destinazione on-device.

Per ulteriori dettagli, visita la documentazione ufficiale di LiteRT.

Inoltre, se vuoi conoscere altre integrazioni Ultralytics YOLO, consulta la nostra pagina della guida alle integrazioni, ricca di risorse utili.

Domande frequenti#