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.

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 16 / API 36. 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 medie di burst su una singola immagine: la media di 15 esecuzioni dopo 3 esecuzioni di riscaldamento su bus.jpg, misurate con il plugin Flutter di Ultralytics 0.6.10 e gli asset standardizzati v0.6.6. L'ordine CPU/GPU è stato alternato tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava l'intero grafo 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.6.6 di yolo-flutter-app; il documento sulle prestazioni di Flutter contiene i dettagli completi del benchmark.
• I valori corrispondenti per la NPU Hexagon Snapdragon e per CPU/GPU LiteRT sono disponibili nell'integrazione Qualcomm QNN.
• Confronta i risultati di CPU/acceleratore Apple nell'integrazione CoreML.

Le seguenti prove su dispositivi utilizzano gli stessi asset standardizzati v0.6.6.

Google Pixel 10#

Hardware: Google Pixel 10 con 12 GB di memoria e Android 16 / API 36. 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 sul dispositivo di benchmark, perché Google non li pubblica nelle specifiche collegate.

Benchmark: media di 15 chiamate predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.6.10 e gli asset ufficiali v0.6.6. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava l'intero grafo a LiteRT OpenCL (LITERT_CL).

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) con 12 GB di memoria e Android 16 / API 36. 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.

Benchmark: media di 15 chiamate predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.6.10 e gli asset ufficiali v0.6.6. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava l'intero grafo a LiteRT OpenCL (LITERT_CL).

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 predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.6.10 e gli asset ufficiali v0.6.6. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava l'intero grafo a LiteRT OpenCL (LITERT_CL).

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.

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#