Esporta i 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 sul dispositivo. È la generazione successiva e il nuovo nome di TensorFlow Lite (TFLite) ed esegue lo stesso formato di modello .tflite. Con LiteRT, un singolo modello Ultralytics YOLO esportato può essere distribuito su dispositivi mobili, embedded, edge e browser, coprendo tutto ciò che i precedenti formati di esportazione tflite e tfjs gestivano separatamente, ora sotto un unico ombrello.

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, consentendo loro di 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 sul dispositivo, noto anche come edge computing. Fornisce agli sviluppatori gli strumenti per eseguire modelli addestrati su dispositivi mobili, 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 ed 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 lo stesso modello .tflite sul web con accelerazione WebGPU/WASM, eliminando la necessità di un'esportazione TensorFlow.js separata.

Caratteristiche principali dei modelli LiteRT#

• Ottimizzazione sul dispositivo: riduce la latenza elaborando i dati localmente, migliora la privacy non trasmettendo dati personali e riduce al minimo le dimensioni del modello per risparmiare spazio.
• Supporto per 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 delegato GPU esegue i calcoli in FP16 per una velocità aggiuntiva.
• Quantizzazione: supporta FP32, INT8 statico (quantize=8, pesi int8 + attivazioni int8), attivazioni INT16 statiche (quantize="w8a16", pesi int8 + attivazioni int16 per una maggiore accuratezza) e INT8 dinamico (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 accuratezza.
• Ampio supporto dei 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) dispone di una CPU Qualcomm Oryon a 8 core (2 core Prime fino a 4,6 GHz e 6 core Performance fino a 3,62 GHz), GPU Adreno e NPU Hexagon.

• I valori di velocità sono latenze burst su singola immagine, ovvero 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 v0.6.6 standardizzati. L'ordine CPU/GPU è stato alternato tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga della CPU utilizzava LiteRT CPU/XNNPACK e che ogni riga della GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL).
• L'esportazione LiteRT traccia direttamente il modello PyTorch, producendo un .tflite NCHW con input float; il delegato GPU compila l'intero grafo (qui tutte e sette le attività vengono eseguite sulla GPU Adreno) e w8a32 non richiede dati di calibrazione. Chi integra il modello deve leggere le forme dei tensori e i nomi delle signature invece di presumere il layout NHWC legacy di onnx2tf o i nomi di output Identity; inserisci direttamente i dati RGB come CHW planare oppure trasponili prima dell'inferenza. Le esportazioni semantiche restituiscono logit NCHW e richiedono un argmax della classe sul lato host. Gli asset Android ufficiali sono ospitati nella release v0.6.6 di yolo-flutter-app, con il benchmark dettagliato nel documento sulle prestazioni di Flutter.
• I risultati della NPU Hexagon Snapdragon corrispondente e quelli di LiteRT su CPU/GPU sono disponibili nell'integrazione Qualcomm QNN.
• Confronta i risultati di CPU/acceleratore Apple nell'integrazione CoreML.

Le seguenti serie di test sui dispositivi utilizzano gli stessi asset v0.6.6 standardizzati.

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 dispone di 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), GPU PowerVR D-Series e Google TPU. Le frequenze dei core e il nome del driver GPU sono stati letti dal dispositivo usato per il benchmark, perché Google non li pubblica nelle specifiche collegate.

Benchmark: media di 15 chiamate predict() dopo 3 riscaldamenti su bus.jpg, utilizzando ultralytics_yolo, 0.6.10 e gli asset ufficiali v0.6.6. L'ordine CPU/GPU alterna tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga della CPU utilizzava LiteRT CPU/XNNPACK e che ogni riga della GPU delegava il grafo completo 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 dispone di 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 ad alta efficienza fino a 2,76 GHz), GPU Xclipse 960 e NPU Samsung.

Benchmark: media di 15 chiamate predict() dopo 3 riscaldamenti su bus.jpg, utilizzando ultralytics_yolo, 0.6.10 e gli asset ufficiali v0.6.6. L'ordine CPU/GPU alterna tra le attività in un'unica sequenza. I log nativi hanno confermato che ogni riga della CPU utilizzava LiteRT CPU/XNNPACK e che ogni riga della GPU delegava il grafo completo 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 (MT6993) dispone di 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), GPU Mali-G1 Ultra MC12 e NPU MediaTek 990.

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

Attività supportate#

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

Esportazione in LiteRT: conversione del tuo modello YOLO#

Puoi migliorare l'efficienza dell'esecuzione sul dispositivo e ampliare le opzioni di distribuzione 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 gli Ultralytics YOLO models supportano l'esportazione immediatamente. Il formato LiteRT supporta le modalità Export, Predict e Validate, quindi puoi esportare un modello e poi caricarlo per eseguire l'inferenza o verificarne localmente l'accuratezza.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to LiteRT format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32", imgsz=640)  # use imgsz=224 for classification

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # use 224 for classification

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # use 224 for classification

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argomenti di esportazione#

Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione Ultralytics sull'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 la distribuzione in altri ambienti, consulta le risorse seguenti:

Dispositivi mobili e sistemi embedded#

• Android: guida introduttiva rapida per integrare LiteRT nelle applicazioni Android.
• iOS: 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 una Coral Edge TPU.
• Microcontrollori: distribuisci i modelli su MCU con solo pochi kilobyte di memoria: il runtime principale 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 e tutorial 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 nei browser (in precedenza TF.js) in un unico modello .tflite, LiteRT rende i tuoi modelli YOLO più veloci, compatti e portabili su quasi tutti i target 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, che offre numerose risorse utili.

FAQ#