20 novembre 2026
Generare immagini direttamente nel browser (davvero) sotto i 50 MB: architettura, compromessi e trucchi pratici
Un approccio “tiny” basato su GAN, ONNX Runtime Web e precisione ridotta: come portare l’inferenza di image generation su CPU/WebGPU senza installazioni.
Portare un generatore di immagini nel browser significa eliminare installazioni, driver e dipendenze, ma soprattutto rispettare vincoli severi di download, memoria e compatibilità. In questo articolo vediamo un design concreto per restare sotto i 50 MB: scelta di una GAN stile StyleGAN2, riduzione mirata dei canali, esportazione in ONNX, patch delle operazioni non compatibili (come la modulated convolution) e runtime con ONNX Runtime Web in WebGPU o fallback WebAssembly/CPU. Chiudiamo con una riflessione: quando il modello diventa l’asset, basta scambiarsi un seed invece di un’immagine.
Perché puntare al browser (e perché il limite “sotto i 50 MB” cambia tutto)
Se l’obiettivo è far generare immagini “a quasi chiunque, su quasi qualsiasi dispositivo”, il browser è una scelta sorprendentemente pragmatica:
- Zero installazioni: niente Python, CUDA, driver o setup complessi.
- Sandbox e sicurezza: l’esecuzione è confinata, l’esperienza è più prevedibile.
- Distribuzione immediata: l’unico requisito è scaricare un payload (modello + runtime).
A quel punto, però, entra in gioco il vero vincolo: dimensione e footprint. Restare sotto i 50 MB non è solo un tema di UX (download più rapido), ma anche di memoria e calcolo: significa poter girare su device datati, con poca RAM e senza GPU dedicata.
In più c’è un requisito spesso sottovalutato: CPU-first. Se il modello riesce a funzionare bene su CPU, si allarga enormemente la platea di dispositivi supportati, e WebGPU diventa un’accelerazione, non un prerequisito.
Perché una GAN (e non una diffusion) è la scorciatoia giusta per stare piccoli
Oggi l’immaginario collettivo associa la generazione immagini a diffusion model “text-to-image”. Ma se il vincolo è tiny + in-browser, una GAN (nello specifico una famiglia tipo StyleGAN2) ha vantaggi strutturali:
- Niente text encoder: enorme risparmio di parametri e dipendenze.
- Generazione in un singolo forward pass: latenza e costi prevedibili; niente decine di step di denoising.
Il compromesso è netto: senza text conditioning il modello genera solo ciò che ha visto in training. Il caso d’uso ideale non è “tutto”, ma un soggetto ben definito (es. paesaggi, chiese, volti, un singolo tipo di oggetto). Questo vincolo, però, porta un vantaggio collaterale importante: dataset più piccolo e più auditabile, e quindi minore probabilità di output indesiderati.
In uno scenario “sotto 50 MB”, l’approccio vincente è: qualità sufficiente + latenza bassa + footprint minimo, non la generalità assoluta.
Ridurre StyleGAN2 senza distruggerla: tagliare dove costa di più
La riduzione dimensionale efficace non è “taglia tutto ovunque”, ma tagliare nel posto giusto.
Una strategia concreta:
- Preservare i canali nei layer a bassa risoluzione (le prime “tier”): lì il modello impara la struttura globale (composizione, forme, layout: cielo/acqua/terra, geometrie principali, ecc.).
- Ridurre i canali nei layer ad alta risoluzione: è la parte con più densità di pixel e quindi quella che pesa di più in compute e memoria. Ridurre qui fa risparmiare tanto, con un impatto spesso accettabile sulla qualità percepita.
Il risultato può essere un generatore molto compatto (decine di milioni di parametri, o meno) con immagini 256×256 credibili per diversi domini.
Nota operativa: modelli più “specialistici” significano anche più training run (uno per soggetto/dominio). Il lato positivo è che, essendo piccoli, il costo di training resta relativamente contenuto.
La parte difficile: far girare il modello nel browser (davvero)
Allenare una rete oggi è spesso la parte “standard”. Portarla nel browser è dove emergono i dettagli scomodi: molte architetture non sono pensate per WebGPU/WebAssembly e non esportano pulite.
Un pattern pratico funziona quasi sempre:
- Esporti il modello in ONNX (formato aperto, multi-runtime).
- Provi a eseguirlo con ONNX Runtime Web.
- Vedi cosa rompe (operatori non supportati, shape dinamiche, ecc.).
- Patching mirato: riscrivi l’operazione mantenendo la matematica equivalente, ma usando primitive supportate.
- Ripeti finché l’export + inference sono stabili.
Caso classico: la “modulated convolution” di StyleGAN2
StyleGAN2 usa convoluzioni “modulate/demodulate”: i pesi del filtro cambiano al volo in base allo stile, ed è parte del motivo per cui genera una varietà maggiore rispetto a GAN più semplici.
In training si usa spesso una group convolution per efficienza su batch. Il problema: in ONNX alcuni parametri (come il numero di gruppi) devono essere statici all’export, mentre in quel setup possono dipendere dal batch.
La soluzione, per un generatore in-browser, è sorprendentemente semplice:
- Fissare batch size = 1 (nel browser generi un’immagine per volta nella stragrande maggioranza dei casi).
- Implementare la modulated conv come:
- modulate (applica lo stile ai pesi),
- demodulate (riscalatura per stabilità),
- poi una
conv2dstandard supportata dai runtime.
Il punto chiave è concettuale: non stai “semplificando” il modello togliendo capacità; stai riscrivendo gli operatori in un modo compatibile con la toolchain web.
Runtime e delivery: ONNX Runtime Web, FP16, cache e fallback
Una pipeline robusta in produzione, lato browser, tipicamente include:
- Fetch del modello da CDN.
- Precisione ridotta (FP16): spesso è il miglior compromesso perché:
- dimezza circa l’impronta dei pesi,
- la perdita visiva può essere minima,
- molte GPU gestiscono bene FP16.
- Cache nel browser storage: evita re-download ad ogni visita.
WebGPU vs WebAssembly/CPU
ONNX Runtime Web consente due strade:
- WebGPU: massime prestazioni, ma c’è un costo iniziale di compilazione shader (warm-up) che può pesare sulla percezione di “prontezza”.
- WebAssembly/CPU: avvio più immediato, performance inferiori ma spesso sorprendentemente utilizzabili con modelli piccoli.
Un approccio “da prodotto” è:
- provare WebGPU,
- se fallisce (o non disponibile), fallback automatico a CPU.
Con un modello compatto, anche un’iGPU integrata può essere sufficiente per throughput elevati rispetto alle necessità reali di una UI.
Quando il modello diventa l’asset: condividere un seed invece di un’immagine
C’è un’idea interessante che emerge appena il modello diventa piccolo: il generatore può sostituire parte degli asset statici.
In certi contesti (giochi, UI generative, contenuti decorativi, variazioni controllate), anziché distribuire centinaia di immagini si può distribuire:
- un singolo modello,
- e per ogni “immagine” solo un seed (pochi byte) per rigenerarla localmente in modo deterministico.
Due client che condividono il seed ottengono lo stesso output senza trasferire un file immagine vero e proprio. Non è la soluzione universale, ma è un cambio di paradigma interessante quando banda e storage contano più della compute locale.
E se serve il testo? Diffusion “compressa” e step distillation
Se il requisito è il text-to-image, una GAN senza encoder non basta. Qui entrano diffusion model più pesanti (text encoder + VAE + UNet/trasformatori). Una strada praticabile è:
- prendere un checkpoint pre-addestrato,
- potare layer,
- quantizzare aggressivamente,
- e usare tecniche come step distillation per arrivare a generazione in singolo step.
Il costo è chiaro: dimensioni molto maggiori (ordine delle centinaia di MB) e qualità che può degradare per la compressione lossy. Ma in cambio ottieni la generalità del prompt.
Estremo “tiny”: inferenza anche su microcontrollori
Riducendo ulteriormente (pochi milioni di parametri) si entra in un territorio quasi dimostrativo ma istruttivo: inferenza su hardware con pochi MB di RAM. È un promemoria utile per chi lavora sul web: quando l’architettura e l’export sono pensati bene, la frontiera del “dove può girare un modello” si sposta molto più in là di quanto immaginiamo.
Sintesi: una ricetta concreta per shipping in-browser sotto i 50 MB
- Scegli un dominio ristretto (un soggetto o una famiglia coerente di immagini).
- Preferisci una GAN per singolo forward pass e footprint ridotto.
- Riduci in modo mirato: preserva i layer a bassa risoluzione, taglia quelli ad alta.
- Esporta in ONNX e prepara un ciclo di “export → errore → patch”.
- Riscrivi gli operatori non compatibili usando primitive supportate, mantenendo la matematica equivalente.
- FP16 + cache + fallback CPU: UX stabile e compatibilità ampia.
Il risultato è un generatore realmente “distribuibile come una pagina web”: leggero, immediato, e abbastanza veloce da essere utile senza dipendere da stack ML tradizionali. La implicazione pratica è potente: quando la generazione diventa un asset scaricabile, il web può iniziare a trattare i modelli come una nuova forma di media, non solo come una chiamata a un servizio remoto.