Come impara

L'errore, misurato

All'inizio il modello e casuale. Dagli "Il cielo e", predira "banana" con la stessa probabilita di "blu". Cio che vogliamo e che predica "blu" (o una parola plausibile).

Per portarlo li servono due cose:

1. Una misura di quanto si sbaglia.
2. Un meccanismo per correggere i parametri nella direzione giusta.

Questo e tutto l'addestramento.

La cross-entropy, senza formula

A ogni passo diamo al modello un pezzo di testo. Predice il token successivo sotto forma di distribuzione (capitolo 01). Guardiamo la probabilita che ha assegnato al token realmente presente nel testo. Se e alta, ha ragione. Se e bassa, ha torto.

La cross-entropy misura questo errore in log-probabilita:

Piu il modello e sicuro e corretto, piu la loss e piccola. Piu e sicuro e sbagliato, piu la loss esplode.

E una misura crudele: assegnare 0,01% alla risposta giusta costa molto piu che assegnare 10%. Il modello impara a evitare le certezze false.

Scendere il pendio

Una volta calcolata la loss, come aggiustiamo i parametri?

Immagina la loss come una superficie in uno spazio gigantesco (tante dimensioni quanti sono i parametri: miliardi). Il modello e un punto su questa superficie. Vogliamo che scenda verso le valli.

L'algoritmo si chiama discesa del gradiente: a ogni passo calcoliamo la direzione del pendio piu discendente (il gradiente) e ci spostiamo un po' in quella direzione.

Parametri ← Parametri − η × Gradiente

η (eta) e il learning rate: la dimensione del passo. Troppo piccolo, non avanziamo. Troppo grande, saltiamo oltre la valle e divergiamo.

La curva della loss scende a gradini — ogni gradino corrisponde a un nuovo pattern che il modello ha appena finito di imparare. I quattro regimi di learning rate espongono i tranelli classici: troppo basso, il modello stagna; troppo alto, diverge.

Tre regimi da osservare nella visualizzazione:

• LR molto basso (≤ 0.001) — la curva scende, ma lentamente. Il modello impara, ma non abbiamo tempo di aspettare.
• LR ottimale (≈ 0.01) — discesa regolare, asintoto basso. E l'obiettivo.
• LR troppo alto (≥ 0.05) — la loss oscilla, o diverge. Il modello "salta" oltre i minimi senza riuscire a posarsi.

In pratica, si aggiusta dinamicamente il learning rate durante l'addestramento: warmup lineare all'inizio (per non rompere tutto), poi decadimento coseno.

Adam: la discesa, ma meglio

L'equazione Parametri ← Parametri − η × Gradiente descrive la discesa del gradiente pura. In pratica, nessuno la usa cosi com'e per addestrare un LLM.

L'optimizer di riferimento si chiama Adam (e la sua variante moderna AdamW). L'idea: invece di avanzare alla cieca nella direzione del gradiente corrente, si tiene una memoria della direzione media recente (il momentum) e della varianza degli aggiornamenti per ogni parametro.

• I parametri il cui gradiente punta sistematicamente nella stessa direzione fanno passi grandi.
• Quelli che oscillano (gradiente rumoroso) fanno passi piccoli.

Adam si adatta quindi automaticamente a ogni parametro, mentre SGD applica lo stesso learning rate a tutti. E piu stabile, e converge molto piu velocemente in pratica. AdamW (la variante piu usata oggi) aggiunge inoltre una regolarizzazione chiamata weight decay che impedisce ai pesi di esplodere nel corso dell'addestramento.

Oggi, addestrare un LLM senza AdamW e raro come programmare in assembler senza una buona ragione.

Backpropagation, in una frase

Per calcolare il gradiente — cioe sapere come ogni parametro influisce sulla loss — usiamo la retropropagazione. E un algoritmo che propaga l'errore dall'uscita verso l'ingresso della rete, layer per layer, applicando la regola della catena.

Non serve capire la derivazione per intuire cosa succede. Pensala cosi:

"Se avessi girato questa manopola di 0,001 unita, la loss sarebbe salita o scesa, e di quanto?"

La risposta a questa domanda, per ognuna dei miliardi di manopole del modello, in parallelo, e esattamente cio che fa la backprop. E cio che rende possibile addestrare un modello da 70 miliardi di parametri in una decina di giorni su un cluster.

Pre-addestramento = leggere internet

Perche un LLM impari qualcosa di utile serve molto testo. Moltissimo. I modelli moderni vedono:

• da 1 a 15 trilioni di token in pre-addestramento
• testo filtrato (Common Crawl, Wikipedia, libri, codice, paper)
• passando piu volte su alcune parti (i libri migliori, piu epoche)

Durante tutto questo processo, il compito e sempre lo stesso: predire il token successivo. Nessuna domanda-risposta etichettata, nessun "ecco la traduzione giusta", nessuna ricompensa umana. Solo testo grezzo, e l'obiettivo di predire il seguito.

Questo si chiama auto-supervisione: il dato fornisce da solo le "etichette". Non servono umani per annotare: basta avere testo.

Batch size: quanti esempi alla volta

Non si calcola mai il gradiente su un solo esempio. Si raggruppano piu sequenze in un batch, si calcola il gradiente medio su tutto il batch, poi si aggiornano i parametri una sola volta.

Piu il batch e grande, piu il gradiente e stabile (meno rumore), piu si puo usare un learning rate elevato. Ma serve abbastanza memoria GPU per contenere tutto.

Per gli LLM moderni, il batch size effettivo raggiunge diversi milioni di token — di solito ottenuto combinando:

• Il batch locale (per GPU) — limitato dalla VRAM.
• La gradient accumulation — calcolare diversi piccoli batch e applicare l'aggiornamento solo alla fine.
• Il parallelismo dei dati — distribuire il batch tra decine, centinaia, talvolta migliaia di GPU.

Cio che gli ingegneri chiamano global batch size e la quantita di dati che contribuisce a un singolo passo di ottimizzazione. Per GPT-4 si parla di milioni di token per passo.

I dati: meta del lavoro

Si parla molto di parametri. Si parla meno della preparazione dei dati — che pero prende meta del tempo di qualunque team serio che addestra un modello.

• Filtraggio — eliminare i contenuti di bassa qualita (spam, pagine d'errore 404, contenuto auto-generato, liste di prodotti senza contesto).
• Deduplicazione — rimuovere i duplicati. Common Crawl contiene molte copie delle stesse pagine; lasciarle dentro fa imparare il modello a memoria invece di generalizzare.
• Mescolamento — bilanciare le fonti (Wikipedia, libri, codice, paper scientifici) secondo il loro valore pedagogico, non la dimensione grezza.
• Filtraggio qualita — nei migliori team, un classificatore valuta ogni documento per tenere solo cio che assomiglia a contenuto da manuale o articolo approfondito.
• Decontaminazione — verificare che i benchmark di valutazione (MMLU, HumanEval…) non finiscano nel corpus di addestramento.

Riassunto brutale di un ricercatore di Meta: «passiamo il 10% del tempo ad addestrare il modello, il 90% a preparare i dati.»

E anche per questo che i migliori modelli aperti (Llama, Mistral, DeepSeek) non rivelano quasi mai i dettagli della loro ricetta dei dati: e il loro principale vantaggio competitivo.

Overfitting e validazione

Piu addestri un modello, piu conosce il corpus a memoria. A un certo punto comincia a memorizzare invece di generalizzare. E l'overfitting.

Per rilevarlo, teniamo da parte una parte del corpus — il validation set — su cui non addestriamo. Durante l'addestramento misuriamo la loss su entrambi. Finche entrambe scendono, tutto bene. Quando la loss di validazione risale mentre quella di addestramento continua a scendere, cominciamo a overfittare. E il momento di fermarsi (o aumentare i dati, o la regolarizzazione).

Nella visualizzazione, la curva tratteggiata rappresenta la loss di validazione. Risale leggermente alla fine: e esattamente questo.

Compute = capacita

Un'ultima cosa. Perche servono cosi tanti parametri e cosi tanti dati? Perche l'apprendimento segue leggi di scala (scaling laws) molto regolari:

Loss = A × (Compute)^−α

Raddoppiare il compute (parametri × dati × iterazioni) divide la loss per un fattore costante. La curva e liscia, prevedibile, su 6 ordini di grandezza. Su questa regolarita poggia tutta l'industria: sappiamo in anticipo che investire 10× piu GPU portera un miglioramento misurabile.

Torneremo su questo in dettaglio al capitolo 19 (leggi di scala di Kaplan e Chinchilla) — compreso perche GPT-3 era sotto-addestrato sui dati e quale sia il rapporto ottimale tra parametri e token.

Il seguito

Il modello pre-addestrato e ora un predittore di token molto competente. Puo completare qualsiasi testo con naturalezza sorprendente. Ma non e ancora un assistente.

Prima di arrivarci c'e un'altra cosa da capire: una volta predetta la distribuzione, come scegliamo un token? Torniamo su questo nel prossimo capitolo.

Aggiornato il 10 maggio 2026