Esportazione di modelli TFLite per la distribuzione (deprecata)#

La distribuzione di modelli di visione artificiale su dispositivi edge o embedded richiede un formato che garantisca prestazioni ottimali.

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

Perché si usava TFLite per l'esportazione?#

Introdotto da Google nel maggio 2017 nell'ambito del framework TensorFlow, TensorFlow Lite, o TFLite in breve, era un framework open source di deep learning progettato per l'inferenza sul dispositivo, nota anche come edge computing. Forniva agli sviluppatori 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 microcontrollori (MCU). Le esportazioni TFLite permettevano alle applicazioni di eseguire modelli in locale e offline.

Funzionalità principali dei modelli TFLite#

I modelli TFLite offrono numerose funzionalità che consentono il machine learning sul dispositivo, aiutando gli sviluppatori a eseguire i propri modelli su dispositivi mobili, embedded ed edge:

• Ottimizzazione sul dispositivo: TFLite ottimizza i modelli per il machine learning sul dispositivo, riducendo la latenza grazie all'elaborazione locale dei dati, migliorando la privacy evitando la trasmissione di 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 microcontrollori.

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

• Prestazioni elevate: offre prestazioni superiori grazie all'accelerazione hardware e all'ottimizzazione dei modelli.

Prestazioni misurate (dati storici)#

Entrambi i formati sono stati eseguiti nella stessa sessione di test GPU consecutiva alle dimensioni di input indicate. Ogni cella riporta il tempo totale (pre-elaborazione + inferenza + post-elaborazione), con la suddivisione per fase sotto il totale; i log nativi hanno confermato che entrambi i formati hanno delegato l'intero grafo a LiteRT OpenCL (LITERT_CL) sulla GPU Adreno.

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

In questa sessione, w8a16 è passato alla CPU, impiegando circa 660 ms in totale contro circa 17 ms per i formati GPU. Questi risultati hanno motivato la distribuzione di w8a32, ma la compatibilità con il delegate e le prestazioni dipendono dal dispositivo e dalla versione del runtime. Esegui benchmark sul dispositivo di destinazione e verifica nei log del runtime l'uso dell'acceleratore.

Opzioni di distribuzione con TFLite#

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

TFLite offre diverse opzioni per distribuire modelli di machine learning sui dispositivi, tra cui:

• Distribuzione su Android e iOS: le applicazioni Android e iOS con TFLite possono analizzare i flussi delle fotocamere e i sensori edge per rilevare e identificare oggetti. TFLite offre anche librerie native per iOS scritte in Swift e Objective-C. Il diagramma dell'architettura qui sotto mostra il processo di distribuzione di un modello addestrato sulle piattaforme Android e iOS con TensorFlow Lite.

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

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

Sostituisci l'esportazione TFLite con LiteRT#

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

Installazione#

Per installare i pacchetti necessari, esegui:

# Install the required package for YOLO26
pip install ultralytics

Per istruzioni dettagliate e best practice sulla procedura 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 workflow di distribuzione che preferisci. Puoi consultare l'elenco completo dei formati di esportazione supportati e delle opzioni di configurazione per scegliere la configurazione più adatta alla tua applicazione.

Il formato LiteRT sostitutivo supporta le modalità Export, Predict e Validate. Esporta il modello, quindi carica il modello .tflite esportato per eseguire inferenze o convalidarne l'accuratezza.

from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato LiteRT
model.export(format="litert", imgsz=640)  # usa imgsz=224 per la classificazione

from ultralytics import YOLO

# Carica il modello TFLite esportato
model = YOLO("yolo26n.tflite")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carica il modello TFLite 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 di modelli YOLO26 TFLite esportati#

Dopo aver esportato il tuo 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. Per istruzioni dettagliate sulla distribuzione dei modelli TFLite in altri contesti, consulta queste risorse:

• Android: 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 dettagliate e risorse.

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

Riepilogo#

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

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

Inoltre, se ti interessano altre integrazioni di Ultralytics YOLO26, consulta la nostra pagina delle guide alle integrazioni. Troverai molte informazioni e indicazioni utili.

Domande frequenti#