Esportazione di modelli TFLite per la distribuzione (deprecata)#

La distribuzione di modelli di computer vision su dispositivi edge o embedded richiede un formato in grado di garantire prestazioni uniformi.

Il precedente formato di esportazione TensorFlow Lite o TFLite ottimizzava i modelli Ultralytics YOLO26 per attività come il rilevamento degli oggetti e la classificazione delle immagini nelle applicazioni edge. Questa guida conserva il contesto della distribuzione TFLite legacy; per le nuove esportazioni usa LiteRT.

Perché TFLite veniva usato per l'esportazione?#

Introdotto da Google nel maggio 2017 come parte del framework TensorFlow, TensorFlow Lite, o TFLite in breve, era un framework open source di deep learning progettato per l'inferenza sul dispositivo, noto anche come edge computing. Forniva agli sviluppatori gli strumenti per eseguire modelli addestrati su dispositivi mobili, embedded e IoT, oltre che sui computer tradizionali.

TensorFlow Lite supportava un'ampia gamma di piattaforme, tra cui Linux embedded, Android, iOS e i microcontrollori (MCU). Le esportazioni TFLite consentivano alle applicazioni di eseguire i modelli localmente e offline.

Funzionalità principali dei modelli TFLite#

I modelli TFLite offrono numerose funzionalità chiave che abilitano il machine learning sul dispositivo, aiutandoti a eseguire i tuoi modelli su dispositivi mobili, embedded ed edge:

• Ottimizzazione sul dispositivo: TFLite ottimizza i modelli per il machine learning sul dispositivo, riducendo la latenza elaborando i dati localmente, migliorando la privacy senza trasmettere dati personali e riducendo al minimo le dimensioni del modello per risparmiare spazio.

• Supporto per più piattaforme: TFLite offre un'ampia compatibilità con le piattaforme, supportando Android, iOS, Linux embedded e i microcontrollori.

• Supporto per diversi linguaggi: TFLite è compatibile con diversi linguaggi di programmazione, tra cui Java, Swift, Objective-C, C++ e Python.

• Prestazioni elevate: offre prestazioni superiori grazie all'accelerazione hardware e all'ottimizzazione del modello.

Prestazioni misurate (storiche)#

Entrambi i formati sono stati eseguiti nella stessa sequenza di test GPU consecutiva alle dimensioni di input mostrate. Ogni cella indica il tempo totale (preelaborazione + inferenza + postelaborazione), con la suddivisione per fase riportata sotto; i log nativi hanno confermato che entrambi i formati delegavano il grafo completo a LiteRT OpenCL (LITERT_CL) sulla GPU Adreno.

La stessa esecuzione della migrazione ha inoltre confrontato i formati di quantizzazione per il rilevamento con YOLO26n. L'inferenza è la metrica confrontabile e dipendente dal formato:

In questa esecuzione, w8a16 è passato alla CPU, con un tempo totale di circa 660 ms rispetto ai circa 17 ms dei formati GPU. Questi risultati hanno motivato la distribuzione di w8a32, ma la compatibilità e le prestazioni del delegate dipendono dal dispositivo e dalla versione del runtime. Esegui il benchmark sul dispositivo di destinazione e verifica il posizionamento dell'acceleratore nei log del runtime.

Opzioni di distribuzione in TFLite#

Prima di esaminare l'esempio di esportazione sostitutivo di LiteRT, vediamo come vengono normalmente usati i modelli TFLite.

TFLite offre diverse opzioni di distribuzione sul dispositivo per i modelli di machine learning, tra cui:

• Distribuzione con Android e iOS: le applicazioni Android e iOS con TFLite possono analizzare flussi video e sensori basati su edge per rilevare e identificare gli oggetti. TFLite offre inoltre librerie iOS native scritte in Swift e Objective-C. Il diagramma dell'architettura riportato di seguito mostra il processo di distribuzione di un modello addestrato sulle piattaforme Android e iOS usando TensorFlow Lite.

• Implementazione con Linux embedded: se l'esecuzione delle inferenze su una Raspberry Pi usando la guida di Ultralytics non soddisfa i requisiti di velocità del tuo caso d'uso, puoi usare un modello TFLite esportato per accelerare i tempi di inferenza. Inoltre, puoi migliorare ulteriormente le prestazioni utilizzando un dispositivo Coral Edge TPU.

• Distribuzione con microcontrollori: i modelli TFLite possono essere distribuiti anche su microcontrollori e altri dispositivi con appena pochi kilobyte di memoria. Il runtime principale occupa solo 16 KB su un Arm Cortex M3 e può eseguire molti modelli di base. Non richiede il supporto di un sistema operativo, librerie C o C++ standard né l'allocazione dinamica della memoria.

Sostituisci l'esportazione TFLite con LiteRT#

Per le nuove esportazioni, converti il modello in LiteRT. Il modello risultante mantiene l'estensione di file .tflite.

Installazione#

Per installare i pacchetti richiesti, esegui:

# Install the required package for YOLO26
pip install ultralytics

Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Se durante l'installazione dei pacchetti necessari per YOLO26 riscontri difficoltà, consulta la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Utilizzo#

Tutti i modelli Ultralytics YOLO26 sono progettati per supportare l'esportazione senza configurazioni aggiuntive, semplificando l'integrazione nel flusso di distribuzione che preferisci. Puoi consultare l'elenco completo dei formati di esportazione supportati e delle opzioni di configurazione per scegliere la configurazione migliore per la tua applicazione.

Il formato LiteRT sostitutivo supporta le modalità Export, Predict e Validate. Esporta il modello, quindi carica il modello .tflite esportato per eseguire l'inferenza o convalidarne 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

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

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

from ultralytics import YOLO

# Load the exported TFLite 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 YOLO26 TFLite esportati#

Dopo aver esportato il modello Ultralytics YOLO26 nel formato LiteRT, puoi distribuire il modello .tflite risultante. Il primo passaggio principale e consigliato per eseguire un modello TFLite consiste nell'usare il metodo YOLO("model.tflite"), come illustrato nel precedente frammento di codice d'uso. Tuttavia, per istruzioni dettagliate sulla distribuzione dei modelli TFLite in diverse altre configurazioni, consulta le seguenti risorse:

• Android: una guida rapida per integrare TensorFlow Lite nelle applicazioni Android, con passaggi semplici per configurare ed eseguire modelli di machine learning.

• iOS: consulta questa guida dettagliata per sviluppatori sull'integrazione e la distribuzione di modelli TensorFlow Lite nelle applicazioni iOS, con istruzioni e risorse passo passo.

• Esempi end-to-end: questa pagina offre una panoramica di vari esempi di TensorFlow Lite, mostrando applicazioni pratiche e tutorial progettati per aiutare gli sviluppatori a implementare TensorFlow Lite nei loro progetti di machine learning su dispositivi mobili ed edge.

Riepilogo#

Questa guida conserva il flusso di lavoro legacy per la distribuzione TFLite. Per le nuove esportazioni, usa LiteRT per creare modelli .tflite destinati ad ambienti di edge computing.

Per ulteriori dettagli sull'utilizzo, visita la documentazione ufficiale di TFLite.

Inoltre, se vuoi conoscere altre integrazioni di Ultralytics YOLO26, consulta la nostra pagina della guida alle integrazioni. Troverai molte informazioni e indicazioni utili.

FAQ#