Introduzione: Deep Learning sul Bordo della Rete
TinyML e il campo che porta il deep learning su dispositivi con risorse estremamente limitate: microcontrollori con pochi kilobyte di RAM, smartphone, sensori IoT e dispositivi embedded. Invece di inviare dati al cloud per l'inferenza, il modello gira direttamente sul dispositivo, offrendo latenza zero, privacy completa e funzionamento offline.
La sfida e comprimere modelli che normalmente richiedono gigabyte di memoria in pochi megabyte o addirittura kilobyte, mantenendo un'accuratezza accettabile. Tecniche come quantizzazione, pruning e knowledge distillation rendono questo possibile. In questo articolo esploreremo le tecniche di compressione, i framework di deployment e casi d'uso reali.
Cosa Imparerai
- Vincoli dei dispositivi embedded: memoria, calcolo, energia
- Quantizzazione: da float32 a int8 e oltre
- Pruning: rimuovere pesi non essenziali
- Knowledge distillation: trasferire conoscenza da modelli grandi a piccoli
- TensorFlow Lite e ONNX: framework per deployment edge
- Privacy e inferenza on-device
- Casi d'uso: gesture recognition, anomaly detection, keyword spotting
Vincoli dei Dispositivi Embedded
I dispositivi embedded operano sotto vincoli severi che rendono impossibile eseguire modelli deep learning standard:
- Memoria (RAM): da 256 KB (microcontrollori) a 4-8 GB (smartphone). Un modello ResNet-50 richiede ~100 MB, un GPT-2 small ~500 MB
- Calcolo (CPU/NPU): da decine di MHz (microcontrollori) a pochi GHz (mobile). Nessuna GPU dedicata nella maggior parte dei casi
- Energia: da milliwatt (sensori a batteria) a pochi watt (smartphone). L'inferenza deve essere energeticamente efficiente
- Storage: da pochi MB (flash) a gigabyte (mobile). Il modello deve entrare nello storage disponibile
perchè l'Edge AI e Importante
L'inferenza on-device offre vantaggi cruciali: latenza zero (nessun round-trip al cloud), privacy (i dati non lasciano mai il dispositivo), affidabilità (funziona senza connessione internet), costo (nessun costo cloud per l'inferenza) e scalabilità (miliardi di dispositivi possono fare inferenza simultaneamente).
Quantizzazione: Ridurre la Precisione Numerica
La quantizzazione converte i pesi e le attivazioni del modello da float32 (32 bit) a rappresentazioni con meno bit: int8 (8 bit), int4 (4 bit) o addirittura binary (1 bit). Questo riduce la dimensione del modello e velocizza l'inferenza, poichè le operazioni su interi sono più efficienti di quelle in virgola mobile.
Post-Training Quantization (PTQ)
La quantizzazione più semplice: si prende un modello già addestrato e si convertono i pesi. Non richiede ri-addestramento, ma può comportare una leggera perdita di accuratezza.
Quantization-Aware Training (QAT)
Il modello viene addestrato simulando la quantizzazione durante il forward pass. Questo permette alla rete di adattarsi alla ridotta precisione, tipicamente recuperando l'accuratezza persa con PTQ.
import torch
import torch.quantization as quant
# --- Post-Training Quantization ---
model = load_trained_model()
model.eval()
# Configurazione quantizzazione: int8 per pesi e attivazioni
model.qconfig = quant.get_default_qconfig('fbgemm') # Per x86
# model.qconfig = quant.get_default_qconfig('qnnpack') # Per ARM
# Preparare il modello
model_prepared = quant.prepare(model)
# Calibrazione: passa dati reali per determinare range
with torch.no_grad():
for batch in calibration_loader:
model_prepared(batch)
# Convertire a modello quantizzato
model_quantized = quant.convert(model_prepared)
# Confronto dimensioni
import os
torch.save(model.state_dict(), 'model_fp32.pth')
torch.save(model_quantized.state_dict(), 'model_int8.pth')
size_fp32 = os.path.getsize('model_fp32.pth') / 1e6
size_int8 = os.path.getsize('model_int8.pth') / 1e6
print(f"FP32: {size_fp32:.1f} MB")
print(f"INT8: {size_int8:.1f} MB")
print(f"Compression: {size_fp32/size_int8:.1f}x")
Pruning: Rimuovere Pesi Non Essenziali
Il pruning rimuove connessioni (pesi) o intere strutture (neuroni, canali, layer) che contribuiscono poco all'output del modello. Le reti neurali sono tipicamente sovra-parametrizzate: fino al 90% dei pesi può essere rimosso con perdita minima di accuratezza.
- Unstructured pruning: rimuove singoli pesi (impostandoli a zero). Alto rapporto di compressione ma richiede hardware specializzato per accelerazione
- Structured pruning: rimuove interi canali, filtri o layer. Compatibile con hardware standard, accelerazione reale immediata
import torch.nn.utils.prune as prune
model = load_trained_model()
# Pruning non strutturato: rimuovi 50% dei pesi per magnitudine
for name, module in model.named_modules():
if isinstance(module, torch.nn.Conv2d):
prune.l1_unstructured(module, name='weight', amount=0.5)
elif isinstance(module, torch.nn.Linear):
prune.l1_unstructured(module, name='weight', amount=0.3)
# Contare pesi zero (pruned)
total = 0
pruned = 0
for name, param in model.named_parameters():
if 'weight' in name:
total += param.numel()
pruned += (param == 0).sum().item()
print(f"Parametri totali: {total:,}")
print(f"Parametri pruned: {pruned:,} ({100*pruned/total:.1f}%)")
# Rendere il pruning permanente
for name, module in model.named_modules():
if isinstance(module, (torch.nn.Conv2d, torch.nn.Linear)):
prune.remove(module, 'weight')
Knowledge Distillation: Insegnante e Studente
La knowledge distillation trasferisce la conoscenza di un modello grande (teacher) a un modello piccolo (student). Invece di addestrare lo studente solo sulle label corrette, viene addestrato a replicare le soft predictions del teacher (le probabilità complete dell'output, non solo la classe predetta). Queste soft predictions contengono informazione più ricca: ad esempio, un'immagine di un gatto ha probabilità simili a una tigre e basse per un aereo, e questa struttura aiuta lo studente.
TensorFlow Lite: Deployment su Mobile ed Edge
TensorFlow Lite e il framework di riferimento per il deployment di modelli ML su dispositivi mobili e embedded. Offre un converter che ottimizza il modello (quantizzazione, fusione operatori) e un runtime leggero per l'inferenza.
import tensorflow as tf
# Convertire modello Keras a TFLite con quantizzazione
model = tf.keras.models.load_model('my_model.h5')
converter = tf.lite.TFLiteConverter.from_keras_model(model)
# Quantizzazione int8 completa
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_data_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_model = converter.convert()
# Salvare modello TFLite
with open('model_quantized.tflite', 'wb') as f:
f.write(tflite_model)
print(f"Modello TFLite: {len(tflite_model)/1024:.0f} KB")
# Inferenza con TFLite
interpreter = tf.lite.Interpreter(model_path='model_quantized.tflite')
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])
ONNX: Interoperabilità tra Framework
ONNX (Open Neural Network Exchange) e un formato aperto che permette di esportare modelli da qualsiasi framework (PyTorch, TensorFlow, etc.) e eseguirli con runtime ottimizzati. ONNX Runtime offre ottimizzazioni automatiche per diverse piattaforme hardware, mentre TVM compila modelli in codice nativo ottimizzato per specifici dispositivi.
Casi d'Uso Reali
- Keyword Spotting: riconoscere comandi vocali ("Hey Siri", "OK Google") su dispositivi con pochi KB di RAM. Modelli da 20-50 KB con accuratezza >95%
- Gesture Recognition: riconoscere gesti con sensori IMU (accelerometro, giroscopio). Modelli per smartwatch e wearable
- Anomaly Detection: rilevare anomalie in macchinari industriali con sensori di vibrazione. Predictive maintenance senza connessione cloud
- Object Detection su Mobile: MobileNet e EfficientDet per riconoscimento oggetti in tempo reale su smartphone
- Facial Recognition On-Device: Face ID di Apple usa un modello neurale dedicato nel chip A-series
Prossimi Passi nella Serie
- Nell'ultimo articolo esploreremo l'Explainable AI (XAI)
- Vedremo come interpretare le decisioni dei modelli con SHAP, LIME e GradCAM
- Analizzeremo perchè la trasparenza dei modelli e fondamentale per compliance GDPR e fairness