In questo articolo vengono definite le peculiarità dell’utilizzo dell’Intelligenza artificiale su dispositivi edge, come sistemi di Internet of Things (IoT) o dispostivi mobile, e di come trasformare il proprio modello allenato su workstation con Pytorch o Tensorflow in Tensorflo Lite, la più famosa libreria mobile per la distribuzione di modelli su dispositivi mobili, microcontrollori e altri dispositivi edge.
Immagine da: Tensorflow: for Mobile & Edge
L’intelligenza artificiale sui dispositive edge
L’IA sui dispositivi edge, nota anche come “AI on edge computing” o “Edge AI”, è un paradigma di elaborazione dati che prevede l’esecuzione di algoritmi di intelligenza artificiale direttamente sui dispositivi o sui nodi di rete periferici, piuttosto che trasmettere i dati a server remoti o al cloud per l’elaborazione. In altre parole, mentre tradizionalmente l’elaborazione dei dati e l’apprendimento automatico richiedevano l’invio dei dati a server potenti e centralizzati, con l’IA sul bordo, queste operazioni avvengono localmente, più vicino alla fonte dei dati. Ciò significa che i dispositivi intelligenti, come telefoni cellulari, telecamere, veicoli, sensori IoT e persino alcuni elettrodomestici, possono eseguire analisi complesse e prendere decisioni autonome senza dipendere totalmente da connessioni di rete stabili e godendo di una miglior gestione della privacy e sicurezza dei dati.
Ma come devono modificarsi ed adattarsi i modelli di Deeplearning che alleniamo per poter funzionare in questo paradigma ?
Le caratteristich di un modello di Deep Learning per effettuare inferenze on Edge sono le seguenti:
- Consumo ottimale di energia: Il consumo energetico ottimale è essenziale per i dispositivi Edge, specialmente quando non sono sempre collegati a una fonte di alimentazione considerato che solitamnte i modelli di DL sono dispondiosi.
- Leggerezza: I dispositivi Edge hanno risorse limitate in termini di spazio di archiviazione e capacità di calcolo. Pertanto, i modelli di deep learning che vengono implementati su questi dispositivi devono essere leggeri, con dimensioni binarie ridotte.
- Multipiattaforma e linguaggio: dispositivi Edge possono essere basati su diverse piattaforme hardware e sistemi operativi. Pertanto, è importante sviluppare modelli di DL che siano multipiattaforma e compatibili con una varietà di dispositivi, ambienti e linguaggi di integrazione
Una delle soluzioni più utilizzate per soddisfare queste caratteristiche è TensorFlow Lite. TensorFlow Lite è una versione ottimizzata per dispositivi mobili e Edge del rinomato framework di deep learning TensorFlow.
Tensorflow Lite
TensorFlow Lite è una libreria mobile per la distribuzione di modelli su dispositivi mobili, microcontrollori e altri dispositivi edge. TFLite deriva dal del rinomato framework di deep learning TensorFlow ed è disponibile per Android, iOS, macOS, Linux e Windows supportando vari linguaggi di programmazione (Python, C, Java, Go e Rust).
Per scoprire di più su Tensorflow Lite: TFLite.
Come convertire il tuo modello in TFLite
Individuati i vantaggi dell’utilizzo di Tensorflow Lite non resta che capire come trasformare il nostro modello, sia se implementato con Tensorflow (e Keras) che con Pytorch. Nei prossimi sottocapitoli viene perciò presentata un step by step tutorial per entrambi i casi.
Come passare da Tensorflow o Keras a TFLite
La conversione partendo da un modello allenato nel framework di Tensorflow risulta molto semplice e immediata grazie all’API TFLiteConverter. Questa API convertirà il modello partendo da uno dei seugenti input:
- Modello Tansorflow salvato (consigliato): un modello TensorFlow salvato su disco.
- Modello Keras: un modello creato utilizzando l’API di alto livello Keras.
- Formato Keras H5: un’alternativa leggera al formato SavedModel supportato dall’API di Keras.
- Modelli creati da funzioni concrete: un modello creato utilizzando l’API di basso livello di TensorFlow.
Il convertitore accetta ha principlamente 3 opzioni che personalizzano la conversione per il modello:
- Compatibility flags: consentono di specificare se la conversione deve consentire operatori personalizzati.
- Optimization flags: che consentono di specificare il tipo di ottimizzazione da applicare durante la conversione. La tecnica di ottimizzazione più comunemente utilizzata è la quanitizzazione post-training.
- Metadata flags: consentono di aggiungere metadati al modello convertito, facilitando la creazione di codice wrapper specifico per la piattaforma quando si distribuiscono i modelli sui dispositivi.
Esempio pratico utilizzando API Python.
# Converting a SavedModel to a TensorFlow Lite model.
import tensorflow as tf
model_name = "MyFirstTFLite"
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops =
tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops
tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
# Save the TFLite model
with open("/path/to/save/model/"+ model_name +".tflite", "wb") as f:
f.write(tflite_model)Come passare da Pytorch a TFLite
Nel panorama attuale, PyTorch ha guadagnato una notevole popolarità in molti settori, superando l’uso di TensorFlow in diverse applicazioni. Pertanto, è fondamentale comprendere come effettuare la transizione dai pesi di PyTorch a TensorFlow Lite (TFLite). Questo passaggio, tuttavia, non è così immediato come la conversione diretta da TensorFlow a TFLite, inffati, richiede un passaggio intermedio attraverso ONNX, un formato di scambio di modelli neutro rispetto alla piattaforma.
ONNX funge peciò da ponte tra PyTorch e TFLite, consentendo la conversione agevole dei modelli. Prima di poter adattare il tuo modello a TFLite, sarà necessario trasformare il modello PyTorch in un formato compatibile con ONNX. Una volta completata questa fase, potrai procedere alla successiva trasformazione da ONNX a TFLite.
I passaggi chiave per fare questa operazione sono:
- Carica il modello PyTorch pre-addestrato utilizzando torch.load.
- Esporta il modello PyTorch nel formato ONNX utilizzando torch.onnx.export. Nota che è necessario fornire un tensore di input fittizio alla funzione di esportazione per specificare la forma dell’input del modello.
- Utilizza ONNX-TensorFlow per convertire il modello ONNX nel formato TensorFlow. ONNX-TensorFlow è un pacchetto Python che converte i modelli ONNX in grafi TensorFlow, e fornisce una funzione di preparazione che prende un modello ONNX in input e restituisce un grafo TensorFlow.
- Utilizza il Convertitore TensorFlow Lite per convertire il modello TensorFlow nel formato TensorFlow Lite, e salva il modello risultante in un file utilizzando le funzioni open e write
Trasformare il modello Pytorch in ONNX
Installa i pachetti necesari.
!pip3 install onnx
!pip3 install onnx_tf
In qusto articolo viene riportato un banale esempio basato su una MobilNetv2 che prendendo in input un’immagine resitituisce in outuput un valore. Il processo è facilmente estendibile a tutti gli altri tipi di architetture.
from torchvision import models
from torch import nn
import torch
import random
#Definizione del modello
model = models.mobilenet_v2()
num_ftrs = model.classifier[1].in_features
model.classifier = nn.Sequential(
nn.Linear(num_ftrs, 1, bias=True), nn.Sigmoid())
# Caricamento dei pesi del modello
model.load_state_dict(torch.load("/path/pesiPTH", map_location=torch.device('cpu')))
# Impostazione del modello in modalità di evaluation
model.eval()
# Creazione di un dummy input
dummy_input = torch.randn(1,3,300,300)
#Esportazione del modello in ONNX
torch.onnx.export(model, dummy_input, "/path/onnxModel", operator_export_type=torch.onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK, verbose=True, input_names=['input'], output_names=['output']) #opset_version=12)Trasformazione da ONNX a Tensorflow
from onnx_tf.backend import prepare
import onnx
# I modelli TensorFlow vengono generalmente salvati in file con estensione ".h5" o ".pb" su disco.
TF_PATH = "/path/converted.pb"
# Il percorso al tuo modello ONNX esistente dipende da dove lo hai salvato sul tuo sistema.
ONNX_PATH = "/path/onnxModel"
# Caricamento del modello ONNX
onnx_model = onnx.load(ONNX_PATH)
# Creazione di un oggetto TensorflowRep
tf_rep = prepare(onnx_model)
# Esportazione del modello TF
tf_rep.export_graph(TF_PATH)Conversione da Tensorflow a Tensorflow Lite
# Conversione del modello da TF a TFLite
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(TF_PATH) # path to the SavedModel directory
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.
tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
# Salvataggio del modello
with open("path/salvataggio/"+ model_name +".tflite", "wb") as f:
f.write(tflite_model)Conclusioni
In conclusione, abbiamo esplorato con successo le possibilità offerte da TensorFlow Lite nell’implementare l’intelligenza artificiale on edge. Attraverso una dettagliata analisi delle caratteristiche di TFLite, abbiamo compreso come questo strumento si dimostri cruciale nel portare modelli di machine learning direttamente sui dispositivi. Inoltre, abbiamo fornito una guida pratica su come convertire modelli da TensorFlow e PyTorch a TensorFlow Lite, aprendo così la porta a un’ampia gamma di applicazioni edge-based. Grazie a TFLite, siamo in grado di sfruttare appieno il potenziale dell’edge computing, consentendo ai nostri dispositivi di prendere decisioni intelligenti in tempo reale, senza la necessità di connessioni costanti alla cloud. Questo rappresenta un passo significativo verso un futuro in cui l’intelligenza artificiale sarà onnipresente, integrata nei nostri dispositivi quotidiani per migliorare le nostre vite in modi nuovi e innovativi.
EN 
IT