Addestrare un modello, dall'inizio alla fine
Due imprese a confronto, stadio per stadio: un modello piccolo che una persona sola può portare a termine in una settimana, e un addestramento di frontiera che impegna un'organizzazione per un anno. Gli stessi diciannove passaggi, con numeri diversi di sei ordini di grandezza.
Il riquadro rosso di ogni stadio segnala il dettaglio che, se trascurato, fa fallire il progetto.
Stesso procedimento, due mestieri diversi
I passaggi sono identici e l'ordine anche. Ciò che cambia è che nel progetto piccolo ogni stadio è una scelta reversibile, mentre in quello grande ogni stadio è un impegno irrevocabile di milioni di euro deciso con settimane di anticipo.
| Semplice | Frontiera | |
|---|---|---|
| Parametri | 0,5 G densi | migliaia di G totali, ~450 G attivi |
| Token di addestramento | 100 G | ~35 T |
| Operazioni | 3 · 10²⁰ | ~10²⁶ |
| Schede | 8, un solo nodo | ~100.000, migliaia di nodi |
| Durata dell'addestramento | 3 giorni | ~70 giorni |
| Durata del progetto | 2 settimane | 12-18 mesi |
| Persone | 1 | alcune centinaia |
| Costo di un errore | si ricomincia domani | settimane e milioni |
Chi addestra il modello piccolo prova, sbaglia, riprova. Chi addestra quello di frontiera non può: la corsa finale si fa una volta sola. Tutto il lavoro preparatorio serve a poter prevedere, con modelli mille volte più piccoli, cosa succederà in quella corsa.
In entrambi i casi, l'addestramento vero è la parte più breve. Nel progetto piccolo tre giorni su due settimane; in quello grande due mesi su un anno e mezzo. Il resto sono dati, esperimenti preliminari, infrastruttura e valutazione.
Raccogliere: il collo di bottiglia vero
Alla frontiera il testo pubblico di alta qualità è una risorsa che si sta esaurendo. Da qualche anno la crescita non viene più da nuove pagine raccolte ma da dati acquisiti sotto licenza e da dati generati apposta.
Si parte da un corpus pubblico già filtrato e pronto: qualche terabyte scaricabile, licenza chiara, lavoro di preparazione già fatto da altri. Un pomeriggio di download. Il valore aggiunto sta semmai nell'aggiungere un dominio proprio.
Crawl proprio su decine di miliardi di pagine · accordi di licenza con editori e archivi · digitalizzazione di materiale non online · dati generati da modelli precedenti e filtrati, soprattutto riscritture: un modello riformula documenti esistenti in più stili, e un testo buono diventa dieci varianti invece di essere ripetuto dieci volte · trascrizioni, codice, dati strutturati. Un lavoro continuo, con una squadra dedicata e contratti.
La pipeline di pulizia, passaggio per passaggio
È la fase in cui si guadagna più qualità per euro speso. Nei confronti pubblicati, un miglioramento del filtro vale più di un raddoppio dei parametri: sette filtri in sequenza, ognuno con la sua soglia da tarare.
Non è trascurabile: elaborare 100 T di token con sette filtri, di cui uno è un modello neurale, richiede migliaia di macchine per settimane. Nei bilanci dei laboratori la preparazione dei dati vale una frazione a due cifre del costo totale.
Se un test di valutazione è finito nei dati, il punteggio è privo di significato — e la contaminazione entra per vie indirette: qualcuno che ha discusso quel test in un forum, un articolo che ne cita gli esempi. Va fatta con soglie generose e ricontrollata alla fine.
Il mix e l'ordine in cui si legge
Avere i dati non basta: bisogna decidere in che proporzione e in che ordine darli. Sono due leve distinte, e la seconda è quella che i team hanno imparato a usare più di recente.
Le fonti non si usano nella proporzione in cui esistono. Le migliori si ripetono più volte, quelle abbondanti si campionano. Il codice riceve una quota molto superiore al suo peso naturale, perché migliora il ragionamento anche fuori dal codice.
Ripetere una fonte fino a 4 volte non danneggia. Oltre, il modello inizia a memorizzarla.
Il mix non resta fisso. Nella fase finale — l'ultimo 10-20% dei token, mentre il passo di apprendimento cala — si passa a un mix molto più selezionato: manuali, testi tecnici, esercizi svolti, dati sintetici curati. Oggi questa coda ha un nome, mid-training, e un compito preciso: preparare il modello al post-training. Si aggiungono ragionamenti passo passo generati da modelli precedenti, esempi di uso di strumenti, documenti lunghi. Un modello base che ha già visto catene di ragionamento trae molto di più dal rinforzo dello stadio 17.
Quella coda finale sposta i punteggi in modo sproporzionato rispetto ai token che contiene.
80% dei token
ultimo 20%
Addestrare il tokenizer: la scelta irreversibile
Si fa una volta, prima di tutto, su un campione dei dati finali. Cambiarlo dopo significa buttare via l'addestramento: gli embedding sono legati agli indici del vocabolario e non hanno senso con un vocabolario diverso.
Si riusa il tokenizer di un modello aperto esistente. Nessun lavoro, nessun rischio, e compatibilità con gli strumenti già in giro. Vocabolario 32.000-150.000, a seconda del modello da cui si prende. Attenzione: su 0,5 G un vocabolario grande occupa fino a un terzo dei parametri solo negli embedding, e per questo i modelli piccoli condividono la matrice d'ingresso con quella d'uscita.
Addestrato apposta su un campione rappresentativo del mix definitivo, con quote di lingue decise a mano perché una lingua sottorappresentata nel campione avrà token peggiori per sempre. Vocabolario 128.000-256.000.
Impacchettare: che le schede non aspettino mai
I documenti hanno lunghezze diverse, il modello vuole sequenze di lunghezza fissa. Come si risolve questa discrepanza determina quanta capacità si spreca — e, in un caso, quanti errori sottili si introducono.
Semplice, sprecone
Un documento per sequenza, il resto riempito con token neutri e mascherato. Se i documenti sono corti si butta il 40-60% del calcolo.
Nessuno spreco
Si incollano i documenti uno dopo l'altro separati da un marcatore, e si taglia ogni 8192 token. Zero riempimento, ma i documenti finiscono spezzati a metà e mescolati.
Quello che si fa
Come sopra, ma la maschera di attenzione impedisce a un documento di guardare quello precedente nella stessa sequenza. Costa poco e toglie una fonte di rumore.
I dati si tokenizzano una volta sola, prima di iniziare, e si scrivono come sequenza binaria di interi a 16 o 32 bit in file grandi e contigui. Tokenizzare durante l'addestramento è un errore classico: la CPU non sta dietro alle schede e il cluster resta fermo ad aspettare.
L'ordine deve essere casuale ma riproducibile: si genera una permutazione deterministica da un seme, così che dopo un guasto si riprenda esattamente dagli stessi dati. Un dataloader non riproducibile rende impossibile capire cosa è successo quando qualcosa va storto.
Quanti parametri, quanti token
Dato un budget di calcolo fisso, esiste una ripartizione ottimale fra dimensione del modello e quantità di dati. Ma «ottimale» rispetto a cosa: al costo di addestramento, o al costo di tutta la vita del modello?
Con un budget C, la loss più bassa si ottiene con N ≈ √(C/120) e D ≈ 20N. Un modello da 8 G vorrebbe 160 G di token, non 15.000.
Se il modello servirà miliardi di richieste, conviene un modello più piccolo addestrato molto più a lungo: costa di più una volta, e meno per sempre. Un 8 G su 15 T ne vede ~2.000; un 0,6 G su 36 T ne vede ~60.000.
Si addestrano sei-dieci modelli piccoli, da 50 M a 1 G, con budget crescenti. Si traccia la loss in funzione del calcolo e si adatta una legge di potenza. Quella curva, estrapolata, predice la loss del modello grande con un errore di pochi punti percentuali — ed è su quella previsione che si firma l'investimento.
A parità di parametri si sceglie il rapporto fra larghezza e profondità (in pratica d/strati attorno a 100-150), il numero di teste, quante teste condividono chiavi e valori, e — nei modelli a esperti — quanti esperti e quanti se ne accendono. Ognuna di queste è decisa con esperimenti su scala ridotta.
Inizializzazione: da dove si parte
Mezzo miliardo di numeri casuali nel progetto piccolo, migliaia di miliardi in quello grande: ma non numeri casuali qualsiasi. La scala iniziale determina se le attivazioni crescono o si spengono salendo di strato, e uno sbaglio qui si manifesta come divergenza nelle prime migliaia di passi.
Un singolo passo di addestramento, per intero
Questo è il ciclo che si ripete da centinaia di migliaia a milioni di volte. Ogni riga corrisponde a millisecondi contati, e ottimizzare una sola di queste righe del 10% vale giorni di cluster.
Batch da ~500.000 token · 200.000 passi in tre giorni · circa 1,3 secondi a passo · la comunicazione è solo fra 8 schede dello stesso server, quindi quasi gratis.
Batch da 16-64 milioni di token · da mezzo milione a due milioni di passi sui 35 T · 3-11 secondi a passo · la media dei gradienti coinvolge decine di migliaia di schede e va sovrapposta al calcolo, altrimenti domina.
Gli iperparametri, con i valori
Una decina di numeri, quasi tutti convergenti su valori standard di fatto. Il punto non è inventarli: è sapere quali si possono copiare e quali vanno tarati per il proprio caso.
| Parametro | Valore tipico | Cosa succede se sbagli |
|---|---|---|
| Passo di apprendimento massimo | 3·10⁻⁴ sul piccolo, 10⁻⁴ o meno sul grande | troppo alto: diverge. Troppo basso: spreco |
| Riscaldamento | 2.000 passi, o 1% del totale | senza, i primi passi distruggono l'inizializzazione |
| Andamento del passo | oggi soprattutto stabile a lungo, poi discesa rapida quasi a zero, in coincidenza con il mix finale; in alternativa coseno | la discesa finale vale molti punti di loss, e col tratto stabile si decide quando fermarsi senza ripartire da capo |
| Ottimizzatore | AdamW (β₁ 0,9 · β₂ 0,95 · ε 10⁻⁸), oppure Muon per le matrici e AdamW per embedding e norme | con AdamW, β₂ a 0,999 è più instabile sui testi. Muon rende «ortogonale» ogni aggiornamento di matrice e tiene un solo stato per parametro invece di due: circa metà del calcolo per la stessa loss nei rapporti pubblicati, ma richiede un controllo sui logit dell'attenzione (stadio 14). Dal 2025 diversi modelli di frontiera a pesi aperti sono addestrati così |
| Decadimento dei pesi | 0,1 · escluse norme ed embedding | applicarlo alle norme peggiora e basta |
| Taglio del gradiente | norma globale a 1,0 | senza, un batch anomalo può rovinare la corsa |
| Dimensione del batch | 0,5 M token sul piccolo, 16-64 M sul grande, in crescita | troppo grande all'inizio: si spreca calcolo |
| Lunghezza di sequenza | 4-8 k, estesa a 128 k in coda | partire lunghi costa e non serve |
All'inizio il gradiente è enorme e anche pochi esempi indicano la direzione giusta. Verso la fine il segnale è sottile e serve mediarne molti per distinguerlo dal rumore. Si parte da qualche milione di token e si arriva a decine di milioni in modo graduale.
Addestrare tutto a 128 k sarebbe assurdo: l'attenzione cresce col quadrato. Si addestra a 4-8 k per il 95% dei token, poi si scalano le frequenze delle rotazioni posizionali e si continua per un breve tratto su documenti lunghi. Il contesto esteso costa pochi punti percentuali del totale.
Cinque assi di parallelismo, insieme
Su un cluster grande si usano tutti e cinque contemporaneamente, e il numero di schede è il loro prodotto. La disposizione non è libera: ogni asse va collocato dove la rete è abbastanza veloce da reggerlo.
Esempio su 16.384 schede: 256 repliche di dati × 8 tensore × 8 pipeline. Ogni asse ha il suo schema di comunicazione e il suo posto nella gerarchia di rete.
All'inizio e alla fine di ogni passo, parte delle schede è ferma perché aspetta il tratto precedente. La frazione sprecata è circa (P−1)/(m+P−1) con P stadi e m micro-batch: con 8 stadi e 8 micro-batch è il 47%, con 64 micro-batch scende al 10%. È il motivo per cui i micro-batch devono essere molti.
Gli stati dell'ottimizzatore, i gradienti e persino i pesi possono essere distribuiti fra le repliche di dati invece che replicati: ognuna custodisce una fetta e la ricompone al volo quando serve. Si scambia memoria con comunicazione, in tre livelli di aggressività crescente.
Precisione mista: cosa resta in alta precisione
Non tutto si può fare a 16 bit, e ancora meno a 8. La regola è: le moltiplicazioni di matrici in bassa precisione, le somme lunghe e gli aggiornamenti in alta.
Otto bit hanno un intervallo strettissimo. Si tiene un fattore di scala per ogni piccolo blocco di valori (32-128 elementi), calcolato al momento sul massimo del blocco: un valore anomalo rovina solo il suo blocco, non l'intero tensore. Le schede più recenti fanno questa scalatura in hardware (formati MX). È la grana fine che ha reso stabile fp8 alla frontiera.
Passare da bf16 a fp8 sulle moltiplicazioni dà, nella pratica, un 30-50% di throughput in più — non il doppio, perché il resto del passo non accelera. Su un addestramento da due mesi sono tre settimane risparmiate.
Sulle schede più recenti si addestra anche a 4 bit: un modello da 12 G è stato portato a 10 T token restando vicino a fp8. Servono però blocchi di 16 valori con la loro scala, arrotondamento casuale sui gradienti, e una parte degli strati lasciata a 16 bit. È la frontiera attuale, non ancora la pratica corrente.
Il cluster si rompe, e va messo in conto
Con decine di migliaia di componenti e due mesi di corsa, la domanda non è se qualcosa si romperà. L'addestramento è sincrono: una scheda che cade ferma tutte le altre.
Otto schede per tre giorni: la probabilità di un guasto è bassa. Si salva ogni mille passi per prudenza, il salvataggio pesa 8 GB e dura secondi. Se cade, si riparte a mano.
In un addestramento documentato su 16.000 schede si sono registrate oltre 400 interruzioni impreviste in 54 giorni — circa una ogni tre ore — per tre quarti dovute a guasti hardware. Il tempo effettivamente produttivo si è mantenuto attorno al 90% solo grazie all'automazione della ripresa. Scalato a 100.000 schede, lo stesso tasso dà un'interruzione ogni 30 minuti circa: la ripresa deve durare pochi minuti, non ore.
Cosa si guarda, ogni ora, per due mesi
Un addestramento lungo si sorveglia come un impianto. Quattro grandezze bastano a diagnosticare quasi tutto, e riconoscere per tempo un'anomalia è la differenza fra perdere un'ora e perdere due settimane.
Deve scendere in modo regolare, quasi una retta in scala logaritmica. Uno scalino verso l'alto è un picco; un appiattimento precoce significa passo di apprendimento troppo basso o dati esauriti.
È l'indicatore che anticipa i guai: sale prima che la loss se ne accorga. Se comincia a oscillare in modo anomalo, il problema è già in corso.
Token al secondo per scheda. Un calo improvviso senza cambiamenti al codice indica un nodo lento, una rete degradata o un disco che non tiene il passo.
Perplexity su corpora di controllo mai visti, per dominio e per lingua. È qui che si vede se una fonte è sparita dal mix o se una lingua sta regredendo.
Sono la patologia caratteristica: la loss salta improvvisamente e o rientra da sola, o resta alta per sempre. Le cause sono un batch anomalo, un'instabilità numerica, o la divergenza dei valori interni della softmax.
La procedura standard: tornare al salvataggio precedente, saltare i batch incriminati, e ripartire con il passo di apprendimento leggermente ridotto. Come prevenzione si usa un termine aggiuntivo che scoraggia i valori interni della softmax dall'allontanarsi da zero — costa quasi nulla e riduce nettamente la frequenza dei picchi. Per l'attenzione si normalizzano query e chiavi prima del prodotto, o si riducono i pesi che le producono quando i punteggi superano una soglia: con questo accorgimento un modello da mille G è stato addestrato su 15 T token senza un solo picco.
Valutare un modello base
Un modello base non risponde a domande: continua testi. Va misurato di conseguenza, e i benchmark pubblici vanno trattati con più diffidenza di quanta se ne usi di solito.
Adattamento supervisionato: stesso codice, altro mondo
Tecnicamente è identico al pre-training: si prevede il token successivo. Cambiano i dati — conversazioni scritte o revisionate da persone — e cambiano tre dettagli che, se sbagliati, rovinano tutto.
10.000-50.000 conversazioni da raccolte pubbliche. Poche ore su una scheda sola. È lo stadio con il miglior rapporto fra fatica e risultato percepito: il modello smette di farfugliare e comincia a rispondere.
Centinaia di migliaia o milioni di esempi, molti scritti da esperti retribuiti del dominio, altri generati e poi selezionati. La qualità di questa raccolta è uno dei beni più gelosamente custoditi di un laboratorio.
Rinforzo: il modello genera i propri dati
Qui l'infrastruttura cambia natura. Non si legge più un file: a ogni passo il modello produce risposte, qualcuno le giudica, e da quei giudizi si ricava il gradiente. L'addestramento contiene un sistema di generazione al suo interno.
Persone scelgono fra due risposte; da quelle scelte si addestra un giudice automatico. Insegna tono, utilità, rifiuti. Rischio: ottimizza il piacere, non la correttezza.
Il premio è oggettivo: i test passano, il risultato è quello atteso. Si può iterare all'infinito senza persone. È ciò che ha prodotto il salto su codice, matematica e ragionamento lungo.
Si salta il modello di giudizio e si ottimizza direttamente sulle coppie preferite. Molto più semplice e leggero, e per questo la scelta ragionevole nel progetto piccolo.
Su larga scala generazione e aggiornamento non si alternano: corrono in parallelo, su schede separate. I pesi nuovi arrivano ai generatori mentre stanno ancora scrivendo, e una parte delle risposte viene da una versione del modello vecchia di qualche passo; la loss lo corregge pesando ogni token. Con i compiti agentici, dove una sola risposta usa strumenti per minuti, è l'unico modo di non lasciare ferme le schede.
Produrre 32 risposte da 2.000 token per ognuna di 1.000 richieste significa generare 64 milioni di token — un token alla volta, con tutti i limiti di banda del caso — per ottenere un solo passo di aggiornamento. Il rinforzo è costoso non per l'aggiornamento ma per ciò che serve a produrlo.
Il modello ottimizza ciò che viene misurato, non ciò che si intendeva. Se il giudice premia le risposte lunghe, le risposte si allungano. Se i test si possono superare senza risolvere il problema, li supererà. Il freno verso il modello di partenza, dove si usa, e la revisione umana periodica servono esattamente a questo.
Distillazione: dove i due progetti si incontrano
Quasi tutti i modelli piccoli buoni di oggi non sono stati addestrati da soli: hanno imparato da un modello grande. È la ragione per cui i due soggetti di questo diagramma non sono indipendenti.
Imparare dalle risposte
Il modello grande genera milioni di risposte, si filtrano quelle corrette, e il piccolo si addestra su quelle come se fossero dati normali.
Semplicissimo, non richiede accesso ai pesi del maestro. È il metodo più diffuso.
Imparare dalle incertezze
Invece del solo token scelto, si insegna al piccolo l'intera distribuzione di probabilità del maestro su tutto il vocabolario.
Molto più informativo — ogni token trasmette un vettore invece di una scelta — ma richiede di eseguire il maestro e di conservarne le probabilità.
Imparare dai propri errori
Lo studente scrive, il maestro dà un voto a ogni token, lo studente corregge proprio i punti in cui ha sbagliato.
È un rinforzo con un premio per ogni token invece che uno solo alla fine, e costa una frazione dell'RL.
Il testo del web è pieno di rumore e ambiguità; le risposte di un buon modello sono già ripulite, coerenti nello stile e corrette nel formato. Il modello piccolo impara da un curriculum ideale invece che da internet — e infatti un modello da 8 G distillato bene supera facilmente un 8 G addestrato da zero sugli stessi dati grezzi.
Come si distribuisce il tempo, davvero
In entrambi i progetti la corsa vera è una minoranza del calendario. Chi si aspetta che «addestrare un modello» significhi soprattutto guardare una loss scendere, ha in mente la parte più breve.
I diciannove stadi, a confronto
| Stadio | Semplice | Frontiera |
|---|---|---|
| 02 Raccolta dati | scarica un corpus pronto | crawl, licenze, sintetico · squadra dedicata |
| 03 Pulizia | già fatta da altri | 7 filtri su 100 T · migliaia di macchine |
| 04 Mix | quello di default | deciso con decine di esperimenti |
| 05 Tokenizer | riusato · 32-150 k | addestrato apposta · 128-256 k |
| 06 Impacchettamento | concatenazione semplice | + isolamento documenti · 140 TB su disco |
| 07 Taglia | quello che sta su 8 schede | leggi di scala su 10 modelli pilota |
| 08 Inizializzazione | valori di libreria | parametrizzazione trasferibile |
| 09 Passo | 1,3 s · 0,5 M token | 3-11 s · 16-64 M token |
| 10 Iperparametri | copiati da una ricetta nota | tarati su modelli pilota, trasferiti · AdamW o Muon |
| 11 Parallelismo | un asse, dentro un server | cinque assi, migliaia di server |
| 12 Precisione | bf16 e basta | fp8 con una scala per ogni piccolo blocco |
| 13 Guasti | improbabili | su 100.000 schede uno ogni mezz'ora circa · ripresa automatica |
| 14 Sorveglianza | si guarda la loss | turni continui per 70 giorni |
| 15 Valutazione | prove pubbliche | + batteria interna mai pubblicata |
| 16 SFT | 30 k esempi · poche ore | 10⁶ esempi, molti scritti da esperti |
| 17 Rinforzo | ottimizzazione diretta sulle preferenze | verifica automatica su vasta scala, generazione asincrona |
| 18 Distillazione | impara da un modello grande | è il maestro |
La ricetta è pubblica. Ciò che non lo è sono i dati e la disciplina.
Ogni passaggio di questo diagramma è descritto in letteratura, e il codice per eseguirlo è aperto. La distanza fra i due soggetti non sta in un segreto architetturale: sta in quanti dati sono stati raccolti e ripuliti, in quante volte si è misurato invece di discutere, e in quanto rigore si è messo nel non sbagliare niente per due mesi di fila.