Come impara

L'errore, misurato

All'inizio il modello è casuale. Dagli "Il cielo è", predirà "banana" con la stessa probabilità di "blu". Ciò che vogliamo è che predica "blu" (o una parola plausibile).

Per portarlo lì servono due cose:

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

Questo è 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 probabilità che ha assegnato al token realmente presente nel testo. Se è alta, ha ragione. Se è bassa, ha torto.

La cross-entropy misura questo errore in log-probabilità:

Più il modello è sicuro e corretto, più la loss è piccola. Più è sicuro e sbagliato, più la loss esplode.

È una misura crudele: assegnare 0,01% alla risposta giusta costa molto più 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 è 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 più discendente (il gradiente) e ci spostiamo un po' in quella direzione.

Parametri ← Parametri − η × Gradiente

η (eta) è 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. È l'obiettivo.
• LR troppo alto (≥ 0.05) — la loss oscilla, o diverge. Il modello "salta" oltre i minimi senza riuscire a posarsi.

Una precisazione per evitare un malinteso: questi tre valori sono quelli della demo, scelti per rendere visibili i regimi. Il pre-addestramento di un vero LLM gira piuttosto attorno a 1e-4 / 6e-4, cioè cento volte meno. Fedeli sono i regimi, non i numeri.

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 così com'è 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. È più stabile, e converge molto più velocemente in pratica. AdamW (la variante più usata oggi) aggiunge inoltre una regolarizzazione chiamata weight decay che impedisce ai pesi di esplodere nel corso dell'addestramento.

AdamW resta l'opzione di default, quella che si sceglie quando non si ha motivo di fare altrimenti. Ma il suo monopolio si è incrinato: dal 2025 l'optimizer Muon è servito ad addestrare modelli di produzione di primissimo piano (Kimi K2, GLM-4.5), ed è ormai integrato nelle grandi librerie di addestramento, Megatron di NVIDIA compresa.

Un optimizer non è un dettaglio di idraulica: è ciò che decide a che velocità milioni di euro di GPU si trasformano in un modello.

Backpropagation, in una frase

Per calcolare il gradiente — cioè sapere come ogni parametro influisce sulla loss — usiamo la retropropagazione. È 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 così:

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

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

Pre-addestramento = leggere internet

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

• da qualche migliaio di miliardi di token a diverse decine di migliaia di miliardi in pre-addestramento (Llama 3: 15.000 miliardi nel 2024; Qwen3: 36.000 miliardi nel 2025). La cifra sale a ogni generazione
• testo filtrato (Common Crawl, Wikipedia, libri, codice, paper)
• passando più volte su alcune parti (i libri migliori, più epoche)

Durante tutto questo processo, il compito è 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 più sequenze in un batch, si calcola il gradiente medio su tutto il batch, poi si aggiornano i parametri una sola volta.

Più il batch è grande, più il gradiente è stabile (meno rumore), più si può 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.

Ciò che gli ingegneri chiamano global batch size è la quantità di dati che contribuisce a un singolo passo di ottimizzazione. Per GPT-4 si parla di milioni di token per passo.

I dati: metà del lavoro

Si parla molto di parametri. Si parla meno della preparazione dei dati — che però prende metà del tempo di qualunque team serio che addestra un modello.

• Filtraggio — eliminare i contenuti di bassa qualità (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 qualità — nei migliori team, un classificatore valuta ogni documento per tenere solo ciò 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.»

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

Overfitting e validazione

Più addestri un modello, più conosce il corpus a memoria. A un certo punto comincia a memorizzare invece di generalizzare. È 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. Finché entrambe scendono, tutto bene. Quando la loss di validazione risale mentre quella di addestramento continua a scendere, cominciamo a overfittare. È 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: è esattamente questo.

Un dettaglio importante, perché sorprende: questo scenario è quello del fine-tuning, in cui si ripassa più volte su un piccolo insieme di dati. In pre-addestramento la loss di validazione non risale quasi mai. Il motivo è semplice: il modello vede migliaia di miliardi di token unici e fa meno di un'epoca completa, quindi non ha mai occasione di imparare il corpus a memoria. Il problema tipico di un LLM pre-addestrato non è essere sovra-addestrato, è essere sotto-addestrato.

Compute = capacità

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

Loss = L_∞ + A × (Compute)^−α

Il termine L∞ è essenziale, e spesso dimenticato quando si cita la formula: è un pavimento, la parte di imprevedibilità irriducibile del linguaggio. Nemmeno un modello perfetto può indovinare con certezza la parola successiva di una frase. Ciò che segue la legge di potenza non è quindi la loss in sé, è la loss in eccesso — ciò che supera quel pavimento.

Con questa precisazione: raddoppiare il compute (parametri × dati × iterazioni) divide quell'eccesso per un fattore costante. La curva è liscia, prevedibile, su 6 ordini di grandezza. Su questa regolarità poggia tutta l'industria: sappiamo in anticipo che investire 10× più GPU porterà un miglioramento misurabile.

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

Il seguito

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

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

Aggiornato il 2 agosto 2026