Esporta modelli YOLO in LiteRT per il deployment su Edge e Web#

LiteRT (abbreviazione di Lite Runtime) è il runtime ad alte prestazioni di Google per l'IA su dispositivo. È la nuova generazione e il nuovo nome di TensorFlow Lite (TFLite), ed esegue lo stesso formato di modello .tflite. Con LiteRT, un singolo modello Ultralytics YOLO esportato viene distribuito su dispositivi mobili, embedded, edge e browser, coprendo tutto ciò che i precedenti formati di esportazione tflite e tfjs gestivano separatamente, ora riuniti sotto un unico ombrello.

Il formato di esportazione LiteRT ottimizza i tuoi modelli per attività come rilevamento oggetti, segmentazione, stima della posa e classificazione in modo che vengano eseguiti velocemente 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 su dispositivo, noto anche come edge computing. Offre 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 unico formato di modello, ogni destinazione:

• Mobile & 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 separata in TensorFlow.js.

Caratteristiche principali dei modelli LiteRT#

• Ottimizzazione on-device: Riduce la latenza elaborando i dati localmente, migliora la privacy non trasmettendo dati personali e minimizza la dimensione del modello per risparmiare spazio.
• Supporto multipiattaforma: Funziona su Android, iOS, Linux embedded, microcontrollori e moderni browser web.
• Accelerazione hardware: Sfrutta XNNPACK su CPU e l'accelerazione GPU tramite OpenCL, Metal e WebGPU. Il delegato GPU viene eseguito in FP16 per impostazione predefinita per una maggiore velocità.
• Quantizzazione: Supporta FP32, INT8 statico (quantize=8, pesi int8 + attivazioni int8), INT16 statico per l'attivazione (quantize="w8a16", pesi int8 + attivazioni int16 per una maggiore precisione) e INT8 dinamico (quantize="w8a32", pesi int8 + attivazioni FP32, senza bisogno di dati di calibrazione) per comprimere i modelli e velocizzare l'inferenza con una perdita minima di precisione.
• Supporto multilingue: 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 (SM8850) a 3 nm è dotato 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 in burst per singola immagine (la media di 15 esecuzioni dopo 3 esecuzioni di riscaldamento su bus.jpg), misurati con il plugin Flutter di Ultralytics 0.6.10 e le risorse standardizzate v0.6.6. L'ordine CPU/GPU è alternato tra le attività in una singola scansione sequenziale. I log nativi hanno confermato che ogni riga della CPU ha utilizzato LiteRT CPU/XNNPACK e ogni riga della GPU ha delegato l'intero grafo a LiteRT OpenCL (LITERT_CL).
• L'esportazione LiteRT traccia direttamente il modello PyTorch, producendo un .tflite NCHW con un input float: il delegato GPU compila l'intero grafo (tutte e sette le attività vengono eseguite sulla GPU Adreno qui) e w8a32 non richiede dati di calibrazione. I consumatori dovrebbero leggere le forme dei tensori e i nomi delle firme anziché dare per scontato il layout NHWC onnx2tf legacy o i nomi di output Identity; impacchetta i dati RGB direttamente come CHW planare o trasponili prima dell'inferenza. Le esportazioni semantiche restituiscono logit NCHW e richiedono un argmax di classe lato host. Le risorse Android ufficiali sono ospitate nella release yolo-flutter-app v0.6.6, con il record di benchmark dettagliato nella documentazione sulle prestazioni di Flutter.
• I numeri corrispondenti della NPU Hexagon di Snapdragon e della CPU/GPU LiteRT sono disponibili nell'integrazione Qualcomm QNN.
• Confronta i risultati della CPU e degli acceleratori Apple nell'integrazione CoreML.

Le seguenti scansioni dei dispositivi utilizzano le stesse risorse standardizzate 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 ha 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. I clock del core e il nome del driver della GPU sono stati letti dal dispositivo di benchmark poiché 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 le risorse ufficiali v0.6.6. L'ordine CPU/GPU si alterna tra le attività in una scansione sequenziale. I log nativi hanno confermato che ogni riga della CPU ha utilizzato LiteRT CPU/XNNPACK e ogni riga della GPU ha delegato 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 ha una CPU Armv9.3 a 10 core (1 core C1-Ultra fino a 3,8 GHz, 3 core C1-Pro di prestazioni fino a 3,26 GHz e 6 core C1-Pro di efficienza fino a 2,76 GHz), GPU Xclipse 960 e Samsung NPU.

Benchmark: Media di 15 chiamate predict() dopo 3 riscaldamenti su bus.jpg, utilizzando ultralytics_yolo 0.6.10 e le risorse ufficiali v0.6.6. L'ordine CPU/GPU si alterna tra le attività in una scansione sequenziale. I log nativi hanno confermato che ogni riga della CPU ha utilizzato LiteRT CPU/XNNPACK e ogni riga della GPU ha delegato 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 (MT6993) a 3 nm ha 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 MediaTek NPU 990.

Benchmark: Media di 15 chiamate predict() dopo 3 riscaldamenti su bus.jpg, utilizzando ultralytics_yolo 0.6.10 e le risorse ufficiali v0.6.6. L'ordine CPU/GPU si alterna tra le attività in una scansione sequenziale. I log nativi hanno confermato che ogni riga della CPU ha utilizzato LiteRT CPU/XNNPACK e ogni riga della GPU ha delegato l'intero grafo 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 teste.

Esportare in LiteRT: Convertire il tuo modello YOLO#

Puoi migliorare l'efficienza dell'esecuzione on-device 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. In caso di difficoltà, consulta la nostra guida ai problemi comuni.

Utilizzo#

Tutti i modelli Ultralytics YOLO supportano l'esportazione per impostazione predefinita. Il formato LiteRT supporta le modalità Export, Predict e Validate, consentendoti di esportare un modello e caricarlo per eseguire l'inferenza o convalidarne la precisione localmente.

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 di Ultralytics sull'esportazione.

Distribuire i modelli YOLO LiteRT esportati#

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

Mobile & Embedded#

• Android: Una guida 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, eventualmente accelerati con una Coral Edge TPU.
• Microcontrollori: Distribuisci su MCU con solo pochi kilobyte di memoria: il runtime principale occupa circa 16 KB su un Arm Cortex-M3.

Browser & Node.js (LiteRT.js)#

• Panoramica di LiteRT.js: Esegui lo stesso modello .tflite direttamente nel browser con accelerazione WebGPU/WASM, eliminando il calcolo lato server e mantenendo i dati sul dispositivo dell'utente.
• Esempi End-to-End: Esempi pratici e tutorial per l'implementazione di LiteRT su dispositivi mobili, edge e web.

Riepilogo#

In questa guida abbiamo spiegato come esportare i modelli Ultralytics YOLO nel formato LiteRT. Consolidando la distribuzione mobile/edge (precedentemente TFLite) e browser (precedentemente TF.js) in un unico modello .tflite, LiteRT rende i tuoi modelli YOLO più veloci, più piccoli e portabili su praticamente qualsiasi destinazione su dispositivo.

Per ulteriori dettagli, visita la documentazione ufficiale di LiteRT.

Inoltre, se sei curioso di conoscere altre integrazioni di Ultralytics YOLO, dai un'occhiata alla nostra pagina della guida alle integrazioni per molte risorse utili.

FAQ#

Come posso esportare un modello YOLO in formato LiteRT?#

Usa la libreria Ultralytics per esportare un modello YOLO in LiteRT (.tflite). Per prima cosa, installa il pacchetto:

pip install ultralytics

Quindi esporta il tuo modello:

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

Per gli utenti CLI:

yolo export model=yolo26n.pt format=litert imgsz=640 # use imgsz=224 for classification

Per maggiori dettagli, visita la guida all'esportazione di Ultralytics.

Qual è la differenza tra LiteRT, TFLite e TF.js?#

LiteRT è il nuovo nome di TensorFlow Lite: stesso formato di modello .tflite, stessa linea di runtime, ribattezzato da Google. In Ultralytics, il singolo formato di esportazione litert copre ora entrambi i casi d'uso che in precedenza richiedevano due formati separati:

• Il vecchio formato tflite → distribuzione mobile, embedded ed edge.
• Il vecchio formato tfjs → distribuzione su browser e Node.js, ora gestito da LiteRT.js che esegue lo stesso file .tflite.

Se hai un file .tflite esistente, puoi caricarlo direttamente con YOLO("model.tflite") e verrà eseguito tramite il backend LiteRT.

Posso eseguire modelli YOLO LiteRT su un Raspberry Pi?#

Sì. Esporta il tuo modello nel formato LiteRT, quindi eseguilo su un Raspberry Pi per migliorare le velocità di inferenza. Per un'ulteriore ottimizzazione, prendi in considerazione una Coral Edge TPU. Per i passaggi dettagliati, fai riferimento alla nostra guida alla distribuzione su Raspberry Pi.

Posso eseguire modelli YOLO nel browser con LiteRT?#

Sì. LiteRT.js esegue lo stesso modello esportato .tflite direttamente in un browser web o in un'applicazione Node.js, con accelerazione WebGPU/WASM. Questo sostituisce il precedente flusso di lavoro TensorFlow.js: non esiste un'esportazione separata per il browser, basta distribuire il tuo modello LiteRT con il runtime LiteRT.js.

LiteRT supporta l'inferenza FP16 (mezza precisione)?#

Sì, al momento dell'esecuzione. Un modello LiteRT FP32 viene eseguito automaticamente in FP16 quando viene eseguito su un delegato GPU (WebGPU, OpenCL o Metal), che è l'approccio ufficiale di LiteRT. Pertanto, non è necessaria un'esportazione dedicata in FP16; per un'ulteriore compressione, usa la quantizzazione INT8 con quantize=8.

Come risolvo i problemi comuni durante l'esportazione LiteRT?#

Se riscontri errori durante l'esportazione di modelli YOLO in LiteRT, le soluzioni comuni includono:

• Controlla la piattaforma: L'esportazione LiteRT è supportata su Linux x86_64 e macOS. Verifica che il tuo ambiente corrisponda.
• Controlla la compatibilità del pacchetto: Assicurati di utilizzare una versione compatibile di Ultralytics. Fai riferimento alla nostra guida all'installazione.
• Problemi di quantizzazione: Quando usi la quantizzazione INT8, assicurati che il percorso del dataset sia specificato correttamente nel parametro data.

Per ulteriori suggerimenti sulla risoluzione dei problemi, visita la nostra guida ai problemi comuni.