Un'idea sola: indovinare la parola dopo
Un LLM (Large Language Model, modello linguistico di grandi dimensioni) fa una cosa sola: dato un pezzo di testo, prevede cosa viene dopo. Non una frase intera, non un ragionamento: solo il prossimo pezzetto di testo.
Se leggi «Il gatto è salito sul…», nella tua testa compare subito «tetto». Forse «divano». Sicuramente non «vulcano». Un LLM fa esattamente questo, ma invece di un'intuizione produce una lista di probabilità per ogni possibile continuazione.
Tutto il resto, rispondere a domande, scrivere codice, tradurre, riassumere, nasce dal ripetere questo gesto migliaia di volte: si prevede una parola, la si aggiunge al testo, si prevede la successiva. Si chiama generazione autoregressiva.
La domanda vera
Dal testo ai numeri: i token
Un computer non sa leggere: sa solo fare conti. Il primo passo quindi è trasformare il testo in numeri. Il modo più ovvio sarebbe dare un numero a ogni parola, ma le parole sono troppe (e ne nascono di nuove ogni giorno). Dare un numero a ogni lettera, al contrario, renderebbe i testi lunghissimi.
La soluzione usata da tutti i modelli moderni sta nel mezzo: i token. Le parole frequenti diventano un token solo, quelle rare vengono spezzate in pezzi riutilizzabili. L'algoritmo che costruisce questo vocabolario si chiama BPE (Byte-Pair Encoding): parte dalle singole lettere e fonde, una alla volta, le coppie che compaiono più spesso nei testi.
35
caratteri
35
byte
7
token
5,00
caratteri/token
Nota due cose. Lo spazio fa parte del token («␣gatto» e «gatto» sono token diversi). E una parola lunga e rara come «precipitevolissimevolmente» viene smontata in molti pezzi: il modello non la conosce come blocco unico, ma può comunque scriverla. Al peggio si scende alle singole lettere, quindi nessun testo è impossibile da rappresentare.
Numeri che hanno un significato: gli embedding
Ora ogni token è un numero, per esempio «gatto» = 3873. Ma 3873 non dice niente: non è «più vicino» a «cane» di quanto lo sia a «pizza». Serve una rappresentazione in cui il significato si veda.
Ecco l'idea: ogni token diventa un vettore, cioè una lista di numeri, che possiamo immaginare come le coordinate di un punto in uno spazio. In un modello piccolo ogni token ha 512 coordinate; nei modelli più grandi oltre 16.000. Questi numeri non li sceglie nessuno: partono casuali e si sistemano da soli durante l'addestramento. Il risultato è che parole usate in contesti simili finiscono vicine.
parola scelta
gatto
le 3 più vicine
- 1. cane0,83
- 2. topo0,83
- 3. leone0,74
Clicca un punto qualsiasi della mappa.
- animali
- cibo
- città
- persone e ruoli
- verbi di movimento
La cosa più sorprendente è che anche le direzioni hanno un significato. Spostarsi da «uomo» a «re» è come aggiungere il concetto di «regalità»; applicare lo stesso spostamento a «donna» porta vicino a «regina». Nessuno l'ha programmato: è emerso dall'aver letto molto testo.
L'attention: ogni parola si guarda intorno
C'è un problema. Il vettore di «era» è sempre lo stesso, in qualunque frase compaia. Ma in «Il gatto non è salito sul tetto perché era stanco», per capire chi era stanco devi collegare «era» a «gatto». Il significato di una parola dipende dal contesto.
L'attention è il meccanismo che risolve questo problema, ed è l'invenzione chiave del 2017 (l'articolo si intitolava, non a caso, Attention Is All You Need). Funziona come una ricerca:
- Queryogni parola formula una domanda: «cosa sto cercando?»
- Keyogni parola espone un'etichetta: «ecco cosa offro»
- Valuee un contenuto: «ecco cosa ti passo se mi scegli»
Le domande di ogni parola vengono confrontate con le etichette di tutte le parole precedenti. Più combaciano, più quella parola «presta attenzione» all'altra e ne assorbe il contenuto. In formula: softmax(Q·Kᵀ / √d) · V, ma l'intuizione è tutta qui.
Il confronto è un prodotto scalare tra la Query e ogni Key: si moltiplicano i due vettori dimensione per dimensione e si sommano i risultati. È una misura di similarità: il numero è alto quando i due vettori puntano nella stessa direzione (la domanda e l'etichetta combaciano), vicino a zero quando non hanno niente in comune. La softmax trasforma poi questi punteggi in pesi che sommano a 100%.
Cosa cerca questa testa: Di chi si sta parlando?
Tocca una parola per vedere dove guarda e i conti che lo decidono.
- Il5%Key0,4000Value0,3000Q·K/√40,4
- gatto70%Key1,51,500Value1,01,000Q·K/√43,0
- non3%Key000,40Value000,30Q·K/√40
- è3%Key000,90Value000,60Q·K/√40
- salito3%Key001,50,4Value001,00,3Q·K/√40
- sul3%Key000,31,2Value000,20,8Q·K/√40
- tetto3%Key0001,5Value0001,0Q·K/√40
- perché3%Key000,40Value000,30Q·K/√40
- era3%Key000,80Value000,50Q·K/√40
Output = somma dei Value pesata con i pesi
0,70,70,10,1
| parola | Key | Q·K / √4 | peso (softmax) | Value |
|---|---|---|---|---|
| Il | 0,4000 | 0,4 | 5% | 0,3000 |
| gatto | 1,51,500 | 3,0 | 70% | 1,01,000 |
| non | 000,40 | 0 | 3% | 000,30 |
| è | 000,90 | 0 | 3% | 000,60 |
| salito | 001,50,4 | 0 | 3% | 001,00,3 |
| sul | 000,31,2 | 0 | 3% | 000,20,8 |
| tetto | 0001,5 | 0 | 3% | 0001,0 |
| perché | 000,40 | 0 | 3% | 000,30 |
| era | 000,80 | 0 | 3% | 000,50 |
| Output = somma dei Value pesata con i pesi | 0,70,70,10,1 | |||
La Key dice «cosa sono», la Query dice «cosa cerco». «era» cerca un soggetto vivente: la Key di «gatto» combacia. I Value hanno 4 dimensioni: soggetto, vivente, azione, luogo.
Query, Key e Value nell'esempio
Prendi la parola «era» con la Testa A selezionata. Le 4 dimensioni dei vettori sono soggetto, vivente, azione e luogo.
- Queryche cosa cerco.
[2, 2, 0, 0]vuol dire: «era» cerca con forza 2 qualcosa che sia un soggetto e con forza 2 qualcosa di vivente, mentre azioni e luoghi non le interessano (0). È la domanda «chi è che era stanco?» tradotta in numeri. - Keyche cosa sono. Ogni parola precedente ha una Key, cioè la sua «etichetta» sulle stesse 4 dimensioni. Quella di «gatto» è
[1,5, 1,5, 0, 0]: «sono un soggetto e sono vivente». Il prodotto scalare con la Query di «era» vale (2 × 1,5 + 2 × 1,5) / √4 = 3: la similarità più alta della frase. - Valueche cosa ti passo, se mi scegli. Ogni parola ha anche un Value: il contenuto che consegna a chi la guarda. Nell'esempio usa le stesse 4 dimensioni. Il Value di «gatto» è
[1, 1, 0, 0]: «se mi guardi, ti passo l'informazione "sono un soggetto, sono vivente"». Quello di «tetto» è[0, 0, 0, 1]: «ti passo "sono un luogo"».
Key e Value hanno ruoli diversi. La Key serve solo a farsi trovare: viene confrontata con la Query e decide il peso. Il Value è ciò che viene consegnato una volta che il peso è deciso.
Un'analogia: la biblioteca
Due dettagli importanti. Primo: ogni parola può guardare solo indietro, mai avanti (la mask causale), altrimenti prevedere la parola dopo sarebbe barare. Secondo: le attention lavorano in parallelo, divise in più teste, e ognuna impara a cercare cose diverse: chi è il soggetto, qual è la parola precedente, dove si svolge l'azione.
Il Transformer, pezzo per pezzo
Ora abbiamo tutti i pezzi. Il Transformer è il modo in cui vengono montati, ed è l'architettura di praticamente ogni LLM moderno. L'idea è un blocco che si ripete identico, impilato molte volte. Ogni blocco fa due cose:
- Attention: le parole si scambiano informazioni (la comunicazione).
- MLP: ogni parola, da sola, rielabora ciò che ha raccolto (il ragionamento locale).
Strato dopo strato, i vettori si arricchiscono: nei primi blocchi catturano grammatica e parole vicine, negli ultimi concetti più astratti. Segui il viaggio di «Il gatto è sul» attraverso tutto il modello:
Testo
«Il gatto è sul»Tutto parte da una stringa di testo. Il modello non sa leggere: prima di tutto va trasformata in numeri.
Il gatto è sul ▍
I dettagli che fanno funzionare tutto
Due accorgimenti tengono in piedi la pila. Le connessioni residuali: ogni blocco aggiunge il suo contributo al vettore invece di sostituirlo, così l'informazione (e il segnale di apprendimento) può attraversare decine di strati senza perdersi. E la normalizzazione (RMSNorm), che prima di ogni passaggio riporta i numeri su una scala comune.
Rispetto al Transformer originale del 2017, i modelli di oggi usano alcune varianti più efficienti: RoPE per codificare la posizione delle parole ruotando i vettori, SwiGLU nell'MLP, e la Grouped-Query Attention che condivide le Key e i Value tra più teste per risparmiare memoria. Ma lo schema è identico.
Scegliere la parola: probabilità e temperatura
In cima alla pila, l'ultimo vettore viene confrontato con tutti i token del vocabolario. Ne esce un punteggio per ciascuno, che una funzione chiamata softmax trasforma in probabilità. A questo punto bisogna scegliere.
Prendere sempre la parola più probabile sembra la scelta ovvia, ma produce testi piatti e ripetitivi. Così si estrae a sorte, pesando ogni parola con la sua probabilità. Due manopole controllano quanto rischiare: la temperatura (che appiattisce o accentua le differenze) e il top-k (che scarta le parole meno probabili).
Il gatto è salito sul ___
Prova a portare la temperatura vicino a zero: il modello sceglierà sempre «tetto». Alzala sopra 1,5: comincerà a salire sul «pianoforte» e sul «vulcano». Ecco perché la stessa domanda a ChatGPT dà risposte diverse ogni volta.
Come impara
Un modello appena creato ha tutti i numeri a caso: alla domanda «cosa viene dopo?» risponde distribuendo la probabilità in modo uniforme su tutto il vocabolario. Per insegnargli, gli si fa leggere moltissimo testo e, per ogni posizione, si confronta la sua previsione con la parola che c'era davvero.
L'errore si misura con la loss: è alta quando il modello dava poca probabilità alla parola giusta, vicina a zero quando ci aveva scommesso. Prova a metterti nei suoi panni:
Nel mezzo del cammin di nostra ___
Dopo ogni gruppo di esempi, un algoritmo chiamato backpropagation calcola come ritoccare ciascuno dei milioni di numeri del modello per rendere la risposta giusta un po' più probabile. Poi si ripete. Milioni di volte.
Per dare un'idea delle proporzioni, ecco il budget di addestramento del modello di prova che vedremo nel prossimo capitolo: 31 milioni di parametri, 16.000 passi, circa 524 milioni di token letti in 13 ore su una GPU da laptop.
1.200
step su 16.000
39 M
token letti
1,0 h
su una GPU da laptop (GTX 1660 Ti)
Parole e grammatica
Le parole diventano coerenti, compaiono accordi e costruzioni tipiche dell'italiano.
Come leggere la loss
e^loss dice tra quante parole il modello è «indeciso». All'inizio tra 16.384, cioè tutte. Man mano che impara, il numero crolla: i candidati plausibili diventano poche decine, e spesso uno solo.Un LLM di prova: jo-llm in 3D
A scopo di test ho creato jo-llm, un LLM proof of concept scritto da zero in PyTorch: tokenizer BPE, embedding, attention con RoPE e Grouped-Query Attention, MLP SwiGLU, RMSNorm, training loop, generazione e le fasi di post-training del prossimo capitolo. È minuscolo, ma ha la stessa architettura dei modelli di frontiera.
Questo esploratore mostra il modello medio (31 milioni di parametri) in tre dimensioni: ogni blocco è un tensore con le proporzioni reali. In basso c'è la pipeline completa, dal token alle probabilità; in alto, staccato, l'interno di uno degli 8 blocchi Transformer. Usa «Avanti» e «Indietro» per percorrere il modello un pezzo alla volta, oppure tocca un blocco per vederne la spiegazione.
- Avanti / Indietropercorri il modello un blocco alla volta, dal token alle probabilità
- Dentro il bloccopassa all'interno di uno degli 8 blocchi Transformer, e ritorno
- Tocca un bloccoforma, parametri e uno schema dettagliato di come funziona
Quanto è piccolo jo-llm?
L'architettura è la stessa dei modelli di frontiera. La differenza è la scala, e la scala conta moltissimo:
| jo-llm small | jo-llm medio | Llama 3 405B | |
|---|---|---|---|
| Parametri | 11 M | 31 M | 405 miliardi |
| Blocchi Transformer | 6 | 8 | 126 |
| Dimensione dei vettori | 384 | 512 | 16.384 |
| Vocabolario | 4.096 | 16.384 | 128.000 |
| Contesto (token) | 256 | 512 | 128.000 |
| Token di addestramento | 47 M | ~524 M | 15.600 miliardi |
| Hardware | 1 GPU da laptop, 25 min | 1 GPU da laptop, ~13 ore | 16.000 GPU H100, ~2 mesi |
In termini di calcolo, addestrare un modello come Llama 3 405B richiede circa dieci miliardi di volte le operazioni usate per jo-llm small. Questo singolo numero spiega gran parte della differenza di qualità, prima ancora di qualsiasi trucco architetturale.
Da completatore di testo ad assistente
Un modello addestrato solo a prevedere la parola successiva (un base model) è un ottimo completatore di testo, ma non un assistente: se gli scrivi una domanda, potrebbe continuare con altre domande. Per arrivare a ChatGPT o Claude si aggiungono altre fasi, il post-training, ognuna con un tipo di segnale diverso:
- SFTun testo da imitare: «rispondi così».
- RLHF e DPOun confronto: «questa risposta è meglio di quella».
- RLVRun voto calcolato da un programma: «giusto» o «sbagliato».
Si continua l'addestramento, con la stessa loss di prima, ma su migliaia di conversazioni scritte con cura nel formato domanda e risposta. Un dettaglio importante: la loss si calcola solo sui token della risposta. Il modello deve imparare a rispondere, non a inventare domande.
un esempio di addestramento
barrati = esclusi dalla loss · evidenziati = il modello viene corretto qui
Limite: il modello impara a imitare, ma non ha idea di quale risposta sia migliore di un'altra.
Ogni fase parte dai pesi della precedente, e jo-llm le implementa tutte e tre in piccolo, su dati sintetici. Il motore però resta lo stesso: un Transformer che prevede il prossimo token. Cambia solo cosa ha imparato a considerare una buona continuazione.
In sintesi
01
Token
Il testo viene spezzato in pezzi e ogni pezzo diventa un numero.
02
Embedding
Ogni numero diventa un vettore: parole simili, vettori vicini.
03
Attention
Ogni parola raccoglie informazioni dalle parole precedenti.
04
Transformer
Attention + MLP, ripetuti in decine di blocchi impilati.
05
Probabilità
In cima, una distribuzione sul vocabolario da cui si estrae la parola.
06
Addestramento
Miliardi di correzioni per dare più probabilità alla parola giusta.
Nessuna di queste idee, da sola, è magica. La magia, se vogliamo chiamarla così, sta nella scala: miliardi di parametri, migliaia di miliardi di parole lette, e un compito semplicissimo ripetuto finché, per prevedere bene la parola successiva, il modello non è costretto a imparare grammatica, fatti e perfino un po' di ragionamento.