Link to this sectionEsporta 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 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, embedded, edge e browser, coprendo tutto ciò che i precedenti formati di esportazione tflite e tfjs gestivano separatamente, ora riuniti sotto un'unica soluzione.

Il formato di esportazione LiteRT ottimizza i tuoi modelli per attività come object detection, segmentazione, stima della posa e classificazione, in modo che vengano eseguiti velocemente e offline su un'ampia gamma di dispositivi.

Link to this sectionPerché esportare in LiteRT?#

LiteRT è un framework open-source progettato per l'inferenza on-device, 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 & Node.js: LiteRT.js esegue lo stesso modello .tflite sul web con accelerazione WebGPU/WASM, eliminando la necessità di un'esportazione TensorFlow.js separata.

Link to this sectionCaratteristiche 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), attivazione INT16 statica (quantize="w8a16", pesi int8 + attivazioni int16 per una maggiore precisione) 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 di accuratezza minima.
• Supporto multilingue: Compatibile con Java/Kotlin, Swift, Objective-C, C++, Python e JavaScript.

Link to this sectionEsportare 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.

Link to this sectionInstallazione#

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.

Link to this sectionUtilizzo#

Tutti i modelli Ultralytics YOLO supportano l'esportazione nativa. Il formato LiteRT supporta le modalità Esportazione, Predizione e Validazione, così puoi esportare un modello e poi caricarlo per eseguire l'inferenza o convalidarne l'accuratezza localmente.

from ultralytics import YOLO

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

# Export the model to LiteRT format
model.export(format="litert")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32")  # creates 'yolo26n_w8a32.tflite'

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8.tflite'

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml")  # creates 'yolo26n_w8a16.tflite'

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

Link to this sectionArgomenti di esportazione#

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

Link to this sectionDistribuire i modelli YOLO LiteRT esportati#

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

Link to this sectionMobile & Embedded#

• Android: Una guida rapida per integrare LiteRT nelle applicazioni Android.
• iOS: Una guida per integrare e distribuire modelli LiteRT nelle applicazioni iOS.
• Embedded Linux & Raspberry Pi: Esegui i 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.

Link to this sectionBrowser & 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 implementare LiteRT su dispositivi mobili, edge e web.

Link to this sectionRiepilogo#

In questa guida abbiamo spiegato come esportare i modelli Ultralytics YOLO nel formato LiteRT. Consolidando il deployment 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 praticamente su ogni target on-device.

Per ulteriori dettagli, visita la documentazione ufficiale di LiteRT.

Inoltre, se sei curioso riguardo ad altre integrazioni di Ultralytics YOLO, dai un'occhiata alla nostra pagina delle guide di integrazione per molte risorse utili.

Link to this sectionFAQ#

Link to this sectionCome 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")  # creates 'yolo26n.tflite'

Per gli utenti CLI:

yolo export model=yolo26n.pt format=litert # creates 'yolo26n.tflite'

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

Link to this sectionQual è la differenza tra LiteRT, TFLite e TF.js?#

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

• Il vecchio formato tflite → deployment mobile, embedded ed edge.
• Il vecchio formato tfjs → deployment 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.

Link to this sectionPosso eseguire modelli YOLO LiteRT su un Raspberry Pi?#

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

Link to this sectionPosso eseguire modelli YOLO nel browser con LiteRT?#

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

Link to this sectionLiteRT supporta l'inferenza FP16 (mezza precisione)?#

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

Link to this sectionCome 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 utilizzi la quantizzazione INT8, assicurati che il percorso del tuo dataset sia specificato correttamente nel parametro data.

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