(Lezione 06.04 · 18 minuti · Nessun sensore · Per tutti)

Formati e motori.

LiteRT, Core ML, ONNX Runtime, ExecuTorch, MediaPipe, WebGPU. Qui metti ordine tra i nomi, capisci cosa c'è dentro il file di un modello e chi riesce ad arrivare alla NPU del telefono.

Cosa impari

Cosa contiene il file di un modello e cosa fa un motore di inferenza
Quali motori si usano su Android, su iPhone e nel browser
Come si sceglie il motore giusto per un progetto

Ti serve sapere

Se non ti ricordi una di queste cose, il link ti porta al capitolo che la spiega.

Come vuoi seguirla

Preparo la scena…

01 Il file e il motore
Un modello è un file, e lo usa un motore.

Dopo l'addestramento il modello si salva in un file. Dentro ci sono i pesi e la ricetta, cioè l'ordine delle operazioni. Per usarlo sul telefono serve un programma che legga il file e faccia i calcoli, il motore di inferenza^01.03. Ogni motore legge i suoi formati e decide su quale parte del chip lavorare.

In pratica. Scegli il motore prima di addestrare. Alcune operazioni esistono in un formato e non in un altro, e scoprirlo alla fine costa caro.
02 LiteRT
Il motore di Google, nato per Android.

LiteRT, fino al 2024 TensorFlow Lite, legge file con estensione tflite. Gira su Android, iPhone, computer e microcontrollori. Per usare GPU e NPU passa il lavoro a dei delegati, pezzi di codice che parlano con l'acceleratore giusto. È il motore dietro MediaPipe e dietro molti modelli di Google.

In pratica. Se un delegato non sa fare un'operazione, quella torna sulla CPU. Troppi passaggi tra NPU e CPU possono rendere il modello più lento di prima.
03 Core ML
Su iPhone c'è Core ML, che sceglie da solo.

Su iPhone il motore di Apple si chiama Core ML e legge file mlpackage. Decide da solo se usare Neural Engine, GPU o CPU, strato per strato. Per portare un modello da PyTorch si usa coremltools. Durante la conversione il modello si può anche comprimere a 8 o a 4 bit.

In pratica. Core ML non dice sempre dove sta girando il modello. Con lo strumento Instruments di Xcode vedi se usa davvero il Neural Engine.
04 ONNX
ONNX, il formato che passa da un mondo all'altro.

ONNX è un formato aperto, nato per spostare modelli tra librerie diverse. Si esporta da PyTorch e si usa con ONNX Runtime, su Android, iPhone, computer e anche nel browser. Per arrivare agli acceleratori usa dei fornitori di esecuzione, simili ai delegati di LiteRT. Per esempio Core ML su iPhone, o QNN sui chip Qualcomm.

In pratica. Quando esporti in ONNX, prova subito il file con qualche esempio e confronta le risposte con quelle del modello originale. Le differenze vanno trovate adesso, non dopo.
05 ExecuTorch
Il motore di PyTorch per il telefono.

ExecuTorch è il motore di Meta per portare i modelli PyTorch su telefoni e dispositivi piccoli senza passare da altri formati. Il modello viene preparato sul computer in un file pte, già diviso tra le parti che andranno su CPU, GPU o NPU. Meta lo usa nelle sue app e per i modelli Llama sul telefono.

In pratica. Se il tuo modello nasce in PyTorch, ExecuTorch ti risparmia una conversione. Meno conversioni vogliono dire meno sorprese.
06 Nel browser
Nel browser la GPU si raggiunge con WebGPU.

Una pagina web per ora non può chiamare la NPU. Usa la CPU con WebAssembly e la GPU con WebGL o WebGPU. Su questo si basano TensorFlow.js, ONNX Runtime Web, MediaPipe e transformers.js. È la strada del laboratorio di questo corso. Niente da installare, in cambio di un po' di efficienza.

In pratica. WebNN è la proposta per arrivare alla NPU dal browser. Quando sarà disponibile ovunque, le stesse pagine andranno più veloci senza cambiare il modello.
07 Scegliere
Si sceglie guardando il telefono e il modello.

Per un'app solo Android, LiteRT è la scelta più semplice. Solo iPhone, Core ML. Per tutte e due con un solo modello, ONNX Runtime o LiteRT. Se il modello nasce in PyTorch e deve correre sulla NPU, ExecuTorch. Se non vuoi installare niente, il browser. MediaPipe copre i casi già pronti, come mani, volti e oggetti.

In pratica. Qualunque motore scegli, misura sul telefono di riferimento. Lo stesso modello può cambiare molto di velocità da un motore all'altro.

01 / 07

(Approfondisci)

Qualche numero in più.

(01)

Cosa c'è dentro un file tflite

Un file tflite è un unico blocco di byte organizzato per essere letto senza essere copiato, in un formato che si chiama FlatBuffers. Contiene l'elenco delle operazioni, come convoluzioni e somme, l'elenco dei tensori con la loro forma, i pesi, e per i modelli quantizzati la scala e lo zero di ogni tensore.

Per guardarci dentro c'è Netron, un visualizzatore gratuito che funziona anche nel browser. Mostra la rete come un disegno a blocchi, con la forma di ingressi e uscite. Legge anche i file di ONNX, Core ML e molti altri formati.

(02)

Chi arriva dove, dentro e fuori dal telefono

La tabella riassume come ogni motore raggiunge le tre parti del chip. Sulla CPU quasi tutti usano XNNPACK, una libreria di Google molto ottimizzata. Per la NPU servono pezzi scritti da chi fa il chip, come Qualcomm, MediaTek o Apple. Per questo una NPU può funzionare con un motore e non con un altro, o solo con modelli a 8 bit.

Gli stessi modelli girano anche fuori dal telefono. Su un microcontrollore da pochi euro, con LiteRT per microcontrollori, un modello di qualche decina di KB riconosce un gesto o un suono con una batteria piccola. Su un Raspberry Pi gira un modello come quelli del laboratorio, con una fotocamera e senza schermo. Sulle schede con una GPU, come le Jetson di NVIDIA, girano modelli che seguono un video in tempo reale.

Motore	File	CPU	GPU	NPU
LiteRT	tflite	XNNPACK	Delegato GPU	Delegati dei produttori
Core ML	mlpackage	Sì	Sì	Neural Engine
ONNX Runtime	onnx	Sì	Sì	Fornitori come QNN e Core ML
ExecuTorch	pte	XNNPACK	Vulkan e Metal	Backend dei produttori
Browser	vari	WebAssembly	WebGL e WebGPU	Non ancora, con WebNN in arrivo

Le esercitazioni, una per ogni corso →

(03)

Convertire senza sorprese

Ogni conversione può cambiare le risposte di poco o di tanto. Un'operazione tradotta in modo diverso, un ordine dei colori invertito, una normalizzazione dimenticata. Il controllo è semplice. Si fanno passare gli stessi cento esempi nel modello originale e in quello convertito e si confrontano le uscite.

Per i modelli con i numeri a virgola le differenze devono essere minuscole, alla terza o quarta cifra dopo la virgola. Per quelli quantizzati si guarda che la classe scelta sia la stessa quasi sempre. Se non torna, il problema è quasi sempre nella preparazione dell'ingresso, non nel motore.

(Prova sul telefono)

Dentro un modello vero

Scarica il modello che sfoca lo sfondo nella lezione sulla segmentazione, pesa 250 KB. Poi aprilo con Netron, dal telefono o dal computer, e cerca queste cose nel disegno a blocchi.

Scarica selfie_segmenter.tflite Apri Netron ↗