C'è un modello di Google che pesa meno di una foto del telefono. Si chiama Gemma 3 270M — 270 milioni di parametri, circa 300 MB su disco una volta quantizzato — e la prima reazione di tutti è la stessa: "e che ci faccio con un modello così piccolo?".
La risposta breve: se gli chiedi di ragionare, fare conti o ricordarsi una conversazione, niente. Fallisce, e va bene così: non è nato per quello. Ma se gli dai un compito stretto e ben definito, e gli mostri qualche decina di esempi fatti da te, diventa qualcosa che non ti aspetti: un classificatore che batte un modello 30 volte più grande, gira in mezzo giga di RAM e risponde in millisecondi. Su un Raspberry Pi, senza cloud.
Questo non è l'ennesimo post "ho provato il modellino, carino". È una masterclass con i numeri veri: ogni cifra qui sotto è misurata a mano sulla mia RTX 5080, su dataset che ho costruito ed etichettato io, con intervalli di confidenza e zero cherry-picking. Vediamo dove funziona, dove crolla, e come si rimette in piedi.
Il metodo: dati fatti in casa, niente trucchi
Prima dei risultati, una promessa. È la parte che separa una masterclass da un post che sbandiera un numero fortunato.
Tutto quello che leggi è misurato così. I dataset li ho costruiti ed etichettati io — ticket di supporto, frasi per il riconoscimento di entità, recensioni di prodotto, metà in inglese e metà in italiano — non scaricati da un benchmark: roba scaricata la rifà chiunque, un dataset costruito e validato a mano è la prova che sai cosa stai misurando. Il test set "gold" è verificato a mano, con zero sovrapposizioni tra ciò su cui il modello si allena e ciò su cui lo giudico (altrimenti misuri la memoria, non la capacità). Ogni numero di copertina è la media su cinque ripetizioni con intervallo di confidenza al 95%, mai un singolo run. E niente 99% finto: dove la curva si appiattisce lo dico, dove restano errori te li mostro.
Il modello base è gemma-3-270m-it. Il fine-tuning è un LoRA — modifico l'1,4% dei pesi — che gira in un paio di minuti sulla GPU. Tutto riproducibile.
Dove il 270M funziona già da solo
Partiamo dalle cose che il 270M fa bene senza addestramento, perché esistono e sono utili.
Routing di tool e function calling, con la variante FunctionGemma: seleziona la funzione giusta e ne compila gli argomenti nell'80% circa dei casi, e sa astenersi quando nessuno strumento serve. È il suo mestiere: smistare chiamate on-device.
Sentiment binario, positivo contro negativo: solido, anche su input pieno di typo e maiuscole.
Iscriviti alla newsletter per ricevere i migliori articoli direttamente nella tua inbox.
Intelligenza Artificiale
Q3, Q4 o Q8? Quale versione di un'AI locale scaricare (la quantizzazione)
Siamo all'ultima tappa. Nei primi due articoli abbiamo installato LM Studio e misurato quanto corre su una RTX 5080 16GB; poi, nei bonus, abbiamo spinto la scheda lungo due dei suoi tre assi: la memoria del contesto e la dimensione del modello. Resta il terzo asse, e per i princi
Riconoscimento entità ad alto richiamo: trova quasi tutte le entità di una frase (persone, organizzazioni, luoghi, date).
Formato forzato (constrained decoding): se gli imponi uno schema JSON sul decoder, l'output esce sempre parseable.
Il filo conduttore: decisioni strette, ben definite, ad alto volume. Lì il modellino vive.
Dove crolla, da solo
E qui la parte onesta: i tre crolli che, a zero-shot, lo rendono inservibile per compiti veri.
Routing a set chiuso. Messo a smistare ticket in 5 categorie, collassa su una sola etichetta: nel mio test sceglie BILLING per tutti e 100 i ticket, e si ferma al 23% di accuratezza (praticamente il caso base).
Sentiment a 3 classi. Aggiungi NEUTRAL e collassa verso il negativo: le recensioni miste finiscono quasi tutte in NEGATIVE, accuratezza 35%.
Entità. Trova tutto ma sovra-estrae brutalmente: 217 falsi positivi contro 157 veri, sbaglia il tipo, inventa entità non presenti. Precisione 0,42.
Sembra una condanna. È invece esattamente il punto di partenza, perché tutti e tre questi crolli si curano con la stessa ricetta.
Le tre mosse della produzione
Chi mette davvero in produzione un tiny model fa tre cose, in quest'ordine.
1. Vincola la forma
Imporre lo schema JSON al decoder ripara il formato e lo slotting per tipo, e azzera l'allucinazione spuria. Ma non ripara la competenza: il routing collassa identico anche vincolato. Il vincolo è necessario, non sufficiente.
2. Fine-tuna la competenza (è qui la magia)
Questa è la mossa che trasforma tutto. E la domanda giusta non è "funziona?", ma "quanti pochi esempi mi servono?".
Ho addestrato il router su sottoinsiemi crescenti del mio dataset — 10, 20, 50, 100, 200, 386 esempi — misurando ogni volta sullo stesso test gold da 100, e ripetendo cinque volte per avere le barre d'errore. I numeri parlano da soli: con 10 esempi sei al 59%, con 20 ancora fermo al 56%, ma a 50 esempi schizzi all'82%, e a dati pieni arrivi all'89,2% (più o meno 2,8).
Tre cose che questo grafico ti dice, e che valgono più di mille slogan.
Il salto vero è tra 20 e 50 esempi: più 27 punti. Con una cinquantina di ticket scritti a mano — il lavoro di un pomeriggio — passi da un modello che collassa a uno utile, intorno all'82%. Da lì in poi è rendimento decrescente.
A pochi esempi conta quali peschi: a 100 esempi una ripetizione fa 63%, un'altra 93%, e la barra d'errore è enorme. Più dati aggiungi, più la curva sale e si stringe (fino a più o meno 2,8 a dati pieni). Chi ti mostra un solo numero ti sta nascondendo questa varianza.
E niente miracoli al 99%: il modello si stabilizza in fascia 85-90%, e gli unici due o tre errori residui sono ticket genuinamente ambigui (un "ho fatto l'upgrade ma non funziona" sta tra il commerciale e il tecnico anche per un essere umano).
E il dato che chiude il discorso:
3. Concatena (cascade)
Una volta che hai un router vero, puoi metterci sopra l'architettura "il modellino gestisce l'80% facile on-device, il caso difficile lo passa a un modello grande". Ma — lezione importante — la cascata ha senso solo dopo il fine-tuning: un 270M zero-shot che collassa non può esserne la base, perché è sicuro di sé e sbagliato, e nessun trucco di voto lo salva.
La ricetta generalizza (non è fortuna su un task)
Per dimostrare che non è un colpo di fortuna sul routing, ho applicato la stessa identica ricetta agli altri due crolli.
Sul riconoscimento entità il problema era la sovra-estrazione. Dopo il fine-tuning la precisione passa da 0,42 a 0,88 e l'F1 da 0,54 a 0,85, mentre il richiamo addirittura sale (da 0,76 a 0,82). I falsi positivi crollano da 217 a 22 — sulle persone, da 80 a 1. Da "generatore di candidati rumoroso" a "estrattore di precisione".
Sul sentiment a 3 classi il problema era il collasso verso il negativo. La stessa ricetta porta l'accuratezza da 35,2% a 87,9%. E si vede meglio di così:
A sinistra, il modello base: ogni recensione — positiva, negativa o neutra — finisce inghiottita nella colonna NEGATIVE. A destra, dopo il fine-tuning: una diagonale pulita, con il NEUTRAL finalmente riconosciuto.
Tre task, tre crolli diversi, una sola ricetta: pochi esempi fatti a mano più un LoRA da due minuti. Funziona sempre.
Il verdetto onesto
Cosa non chiedergli, mai: ragionamento, matematica, fatti dal mondo (allucina con sicurezza), memoria di conversazioni lunghe. Non è una knowledge base, è un classificatore.
Cosa gli puoi affidare, e bene: qualunque decisione stretta e ripetitiva dove puoi scrivere da 50 a 300 esempi — instradare ticket, taggare entità, classificare polarità, smistare tool. Lì, fine-tunato, è uno strumento di precisione che si stabilizza intorno al 90% e ci sta in mezzo giga.
E il finale che rende tutto questo concreto: ci sta su un Raspberry Pi. Circa 0,3 GB di RAM, inferenza su CPU via llama.cpp, una decisione di routing in meno di un secondo, sempre acceso, senza cloud, senza mandare un solo dato fuori da casa tua. È letteralmente la ragione per cui questo modello esiste. Quel deployment edge — con i numeri veri di token al secondo, latenza e consumo misurati sul mio NAS Pi — è il prossimo capitolo di questa serie.
Il 270M non è un giocattolo. È un bisturi: inutile se ci provi a tagliare tutto, micidiale se gli insegni un taglio.
