Pretraining di un LLM: dati, compute, scaling laws e costi

Nell’obiettivo non cambia nulla. Il modello predice ancora il prossimo token, la loss è ancora la cross-entropy del Capitolo 4 applicata alla fattorizzazione del Capitolo 8, l’ottimizzatore è ancora AdamW del Capitolo 6. Il pretraining non è un nuovo algoritmo; è lo stesso algoritmo eseguito su un corpus abbastanza grande da dover essere messo a budget. Due cose lo rendono possibile: le etichette sono gratis, perché il target per la posizione $t$ è il token in $t+1$ ed è già nel testo; e l’ultima sezione del Capitolo 6 ha rimosso l’obiezione, perché un modello con molti più parametri di quanto consentano le regole classiche non collassa: migliora. Ciò che ne esce è un modello base — qualcosa che continua testo, invece di rispondere.

Prima di poterlo mettere a budget bisogna contarlo, e il settore lo conta con una sola formula:

dove $N$ è il numero di parametri, $D$ i token di addestramento e $C$ le operazioni floating-point totali. Kaplan et al. la derivano in due passaggi.¹ Forward: 2 FLOP per parametro per token, perché ogni parametro in una moltiplicazione di matrici viene usato una volta per token, in una moltiplicazione e un’addizione. Backward: due volte il forward, perché il backward pass del Capitolo 5 calcola due gradienti a ogni layer — rispetto agli input del layer, così il segnale continua a viaggiare, e rispetto ai suoi pesi — ciascuno una moltiplicazione di matrici della stessa dimensione di quella forward, quindi $4N$.

Questa è tutta la derivazione, e vale la pena verificarla invece di crederci. PyTorch include un contatore FLOP reale, torch.utils.flop_counter.FlopCounterMode, che intercetta ogni operazione dispatchata da un modello e somma il lavoro effettivo. Eseguilo su quattro ordini di grandezza, il più grande sul dispositivo meta, che alloca forme e non memoria:

from torch.utils.flop_counter import FlopCounterMode

counter = FlopCounterMode(display=False)
with counter:                       
    loss = model(x, targets)[1]     
    loss.backward()                 
measured = counter.get_total_flops()
print(measured / (6 * n_params * n_tokens))

Il rapporto forward+backward su forward è 3,000, esattamente, a ogni scala: non un’approssimazione che per caso funziona bene, ma l’identità aritmetica sopra restituita come numero tondo da un contatore che non sa nulla della derivazione.

Il totale misurato si colloca poi tra il 3% e il 17% sopra $6ND$, una volta che $N$ conta le matrici di embedding — e quella clausola conta, perché i due paper fondativi contano $N$ in modo diverso. Kaplan esclude «tutti gli embeddings di vocabolario e posizionali» perché così «si producono scaling laws significativamente più pulite» (§1.3); l’Appendice F di Chinchilla dice «contiamo anche le matrici di embeddings nel conteggio totale dei parametri».² Per un vocabolario ampio e una dimensione hidden stretta, le due scelte differiscono di un fattore nove, come mostra la prima riga.

Lo scarto residuo è ciò che $6ND$ omette deliberatamente: gli score di attention. L’Eq. (2.2) di Kaplan scrive il costo forward come $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ e scarta il secondo termine perché $d_{\text{model}} \gg n_{\text{ctx}}/12$ — sicuro nel 2020, meno sicuro ora, e il motivo per cui il rapporto deriva verso l’alto al crescere di $T/d$ — ed è per questo che due righe qui condividono un $T$ di 1.024 e il rapporto scende, da 1,145 a 1,100, quando $d$ passa da 768 a 1.600. È il costo $O(T^2)$ introdotto nel Capitolo 9 e trasformato in prezzo dal Capitolo 16.

Il compute decide quanto dura una run; la memoria decide se può partire. Addestra con AdamW fp32 semplice e ogni parametro porta quattro numeri: il peso, il suo gradiente, e la media mobile $m$ e la varianza $v$ di Adam — le due medie costruite a mano nel Capitolo 6. Quattro numeri a quattro byte ciascuno fanno 16 byte per parametro, prima di una singola activation. Misurato su una GPU da laptop da 8 GB, prendendo l’allocazione residente nel punto dello step in cui nessun grafo è vivo:

Previsione e misura concordano entro il 3%. La sorpresa è l’ultima colonna: le activations fanno impallidire il modello. Lo stesso modello da 5,8 milioni di parametri che richiede 89 MB di stato persistente richiede 4.681 MB di activations con un batch di 128 — cinquantadue volte il modello — e gran parte di questo non è affatto il transformer. Sono i logits, un vettore della dimensione del vocabolario per token a quattro byte per elemento: 512 MB nell’ultima riga, 393 MB nella prima. La dimensione del vocabolario è stata scelta nel Capitolo 7, e sta ancora decidendo cosa entra nella scheda.

Quale termine domina dipende dalla forma della run, motivo per cui Micikevicius et al. dicono che la memoria «è dominata dalle activations»³ mentre ZeRO dice che un modello da 1,5 miliardi di parametri richiede «almeno 24 GB» solo di stati del modello.⁴ ZeRO arriva agli stessi 16 byte per un’altra via — $2\Psi$ per i pesi fp16, $2\Psi$ per i gradienti fp16, $4\Psi$ ciascuno per i pesi master fp32 e i due momenti di Adam — che per 70 miliardi di parametri sono 1,12 terabyte, l’equivalente di quattordici GPU da 80 GB prima di una singola activation.

Niente di tutto questo entra su un solo dispositivo alla scala frontier, quindi la run viene divisa in quattro modi contemporaneamente. Data parallelism mette una copia del modello su ogni GPU e media i gradienti — l’impostazione predefinita, e quella che ZeRO migliora rifiutandosi di mantenere copie ridondanti dello stato dell’ottimizzatore. Tensor parallelism divide singole matrici tra dispositivi. Pipeline parallelism assegna a ogni dispositivo un gruppo contiguo di layer. Context parallelism divide la sequenza stessa, necessario solo quando $T$ è abbastanza lungo da far dominare il termine di attention. La Tabella 4 di Llama 3 elenca tutti e quattro insieme: tensor 8, context fino a 16, pipeline 16, data fino a 128, su 16.384 GPU H100.⁵ Questo è tutto ciò che questo corso dirà in merito; l’ingegneria del distributed training è un semestre a sé, e Stanford CS336 è quel semestre, lezioni 5–8, con il codice.⁶ Dalla delega sopravvive un solo numero, model FLOPs utilisation — la frazione dell’aritmetica di picco di una GPU che una run reale raggiunge — che trasforma il pulito $6ND$ in tempo di calendario e quindi in denaro.

Nel gennaio 2020, Kaplan et al. addestrarono una griglia di transformers e scoprirono che la test loss segue una power law in ciascuna delle tre risorse su più di sei ordini di grandezza.¹ La loro §1.2 dà tre leggi fittate:

con compagne $\alpha_D \approx 0.095$ per i dati e $\alpha_C^{\min} \approx 0.050$ per il compute allocato in modo ottimale. Le costanti non sono universali, e il paper lo dice: «i valori numerici precisi di $N_c$, $C_c^{\min}$ e $D_c$ dipendono dalla dimensione del vocabolario e dalla tokenization e quindi non hanno un significato fondamentale».

Gli esponenti sono minuscoli: dieci volte i parametri comprano un fattore $10^{0.076} \approx 1.19$ sulla loss residua. Sembra nulla, ed è il fatto più importante qui — i ritorni sono terribili e non finiscono mai. Una power law con un esponente piccolo promette che il prossimo ordine di grandezza aiuterà, meno del precedente, per sempre. Comprare compute smette di essere una scommessa e diventa un acquisto con un tasso di cambio pubblicato, esattamente l’argomento che ha sbloccato il capitale.

Poi arrivò la prescrizione, ed è qui che il paper sbagliò in un modo che costò all’industria moltissimo denaro. La Tabella 6 di Kaplan dà $N_{\text{opt}} \propto C^{0.73}$ e $D_{\text{opt}} \propto C^{0.27}$: dieci volte il compute significa un modello 5,4 volte più grande alimentato con solo 1,9 volte più testo. L’abstract è esplicito: «l’addestramento ottimale in termini di compute efficiency implica addestrare modelli molto grandi su una quantità di dati relativamente modesta e fermarsi significativamente prima della convergenza». Il settore fece esattamente così: GPT-3 è 175 miliardi di parametri su 300 miliardi di token,⁷ Gopher 280 miliardi su 300 miliardi, Megatron-Turing NLG 530 miliardi su 270 miliardi.² Da mezzo token a due token per parametro, ovunque.

Nel marzo 2022, Hoffmann et al. addestrarono oltre 400 modelli da 70 milioni a 16 miliardi di parametri e raggiunsero la conclusione opposta attraverso tre strade indipendenti.² La loro Tabella 2 riporta l’esponente $a$ in $N_{\text{opt}} \propto C^{a}$ come 0,50, 0,49 e 0,46, contro lo 0,73 di Kaplan. In parole semplici: dimensione del modello e dati di addestramento devono crescere nella stessa proporzione.

Il loro secondo approccio è quello riprodotto dallo sweep in cima a questo capitolo, a un milionesimo della scala: fissa un budget, addestra molte dimensioni esattamente a quel budget, traccia la loss finale contro la dimensione del modello.

Loss held-out in nats per token, token per parametro tra parentesi, grassetto per il modello migliore a ciascun budget; un trattino è un punto non eseguito, perché il budget richiedeva più testo di quanto il corpus contenesse o la dimensione cadeva fuori da quelle esplorate lì.

Leggi una colonna verso il basso: la loss scende, tocca il fondo e risale. Un modello può essere troppo grande per il suo budget esattamente con la stessa facilità con cui può essere troppo piccolo — a $10^{14}$ la penalità per scegliere 665.280 parametri invece di 295.808 è 0,08 nats, che sull’inviluppo fittato sopra è la loss che un modello dimensionato correttamente raggiunge con il 18% di compute in meno. Scegliere la forma sbagliata butta via un quinto del budget. È la Figura 3 di Chinchilla in un pomeriggio su una GPU invece che con quattrocento modelli.

Ora leggi in orizzontale. A $10^{13}$ il modello migliore è il più piccolo dello sweep; a $10^{14}$ è quello da 295.808 parametri, incorniciato da entrambi i lati. L’ottimo si sposta a destra al crescere del budget, che è tutto il contenuto della correzione. Fitta il terzo approccio del paper — la superficie $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ su ogni run — e minimizza soggetto a $C = 6ND$:

L(N, D) = 24.7 / N^0.195 + 46.8 / D^0.169       (E fits to ~0; see below)
implied   N_opt ∝ C^0.464
  compare   Chinchilla 0.46-0.50 · Besiroglu 0.513 · Kaplan 0.73

0,46, da un laptop, contro lo 0,73 di Kaplan. L’accordo alla terza cifra da un fit su tre budget è fortuna; l’accordo alla prima no. L’esponente viaggia — la costante no, perché il rapporto token-parametro in questi ottimi è tra 170 e 540, non 20. Tre ragioni, tutte istruttive. $E$ fitta a zero perché con una loss sopra 4 nats la run non è nemmeno vicina al floor di entropia che domina il fit di Chinchilla. Batch size e learning rate sono stati fissati invece che ottimizzati per punto, cosa che penalizza le run che ricevono meno step — e quelle sono i modelli grandi: a $10^{13}$ FLOP un modello da 1,28 milioni di parametri riceve 159 step di ottimizzatore in totale, molto sotto le poche migliaia che il termine $S_{\min}$ di Kaplan dice siano necessarie a qualunque modello. Una scaling law viene fittata dentro un regime, e questa sta sei ordini di grandezza sotto Chinchilla.

Da qui l’abstract del paper: «gli attuali large language models sono significativamente undertrained». Chinchilla è la dimostrazione — 70 miliardi di parametri su 1,4 trilioni di token, lo stesso compute totale di Gopher da 280 miliardi su 300 miliardi, battendolo in 51 task MMLU su 57, 67,5% contro 60%.² Quattro volte più piccolo, quattro volte e mezzo più testo, stesso denaro, modello migliore.

Due avvertenze su quel famoso rapporto. «Venti token per parametro» non è una frase del paper, che dice solo che «per ogni raddoppio della dimensione del modello anche il numero di token di addestramento dovrebbe raddoppiare»; il 20 è un’inferenza dalla Tabella 3 e dal Chinchilla stesso, 70 B su 1,4 T. E la sua precisione è peggiore di quella pubblicata: Besiroglu et al. hanno rifittato da una digitalizzazione della Figura 4, hanno trovato che i parametri originali «fittano male i dati ricostruiti» con intervalli «implausibilmente stretti dato il numero di punti dati», e hanno posto l’intervallo onesto tra «4 e 40» token per parametro.⁸

Un dettaglio del metodo di Chinchilla salda una promessa fatta dal Capitolo 1 sui learning-rate schedules. La schedule coseno deve essere abbinata al budget di token. Un modello che vedrà 10 milioni di token deve far decadere il suo learning rate a zero a 10 milioni di token; dagli una schedule dimensionata per 100 milioni, fermalo presto, e stai leggendo una loss a metà discesa con un rate troppo alto. Chinchilla addestra ogni modello a quattro lunghezze di ciclo per controllare esattamente questo; lo sweep sopra imposta la sua schedule dal budget per la stessa ragione.

Sono il risultato empirico più utile del campo e vengono regolarmente sopravendute. Quattro limiti.

Predicono la loss, non la capacità. Il lato sinistro è la cross-entropy su testo held-out. Nulla in questi paper autorizza un’affermazione sul fatto che un modello scriverà SQL corretto, rifiuterà una richiesta dannosa o userà un tool. È di nuovo la lezione del Capitolo 5: una predizione della loss non è una predizione del comportamento per cui stai pagando.

Sono fittate, non derivate. Nessuna teoria produce $\alpha_N = 0.076$. Le costanti si spostano con il tokenizer — ed è per questo che un confronto di perplexity tra due tokenizer non ha senso, come spiegava il Capitolo 8 — e con il mix di dati, l’architettura e l’ottimizzatore. Ogni legge pubblicata è una legge del setup che l’ha prodotta, motivo per cui Meta ha rifittato la propria prima di Llama 3.⁵

Assumono un token fresco per ogni step, il che assume silenziosamente un corpus infinito. Muennighoff et al. hanno misurato cosa succede quando finisce: fino a quattro epoch di dati ripetuti costano quasi nulla — un modello da 8,7 miliardi di parametri su 44 miliardi di token unici visti quattro volte ha finito con una «validation loss solo dello 0,5% più alta» dello stesso modello su 178 miliardi di token unici — mentre oltre circa sedici epoch il compute aggiuntivo non compra più nulla.⁹

E nessuno addestra più in modo compute-optimal. Chinchilla minimizza il costo di addestramento; un modello distribuito poi paga circa $2N$ FLOP per token generato, per sempre. LLaMA 1 lo disse chiaramente: «dato un livello target di performance, il modello preferito non è quello più veloce da addestrare ma quello più veloce in inference».¹⁰ Sardana et al. lo formalizzarono minimizzando invece $6ND_{\text{train}} + 2ND_{\text{inference}}$, e scoprirono che chiunque si aspetti un miliardo di richieste dovrebbe addestrare «più piccolo e più a lungo del Chinchilla-optimal».¹¹ La §9.1 di Llama 3 concorda: i suoi modelli piccoli vengono addestrati «ben oltre il punto di training compute optimal, scambiando di fatto training compute per efficienza in inference».⁵ Il rapporto non è obsoleto; risponde a una domanda che non è più quella che si sta ponendo.

La loss scende in modo liscio. Gli score dei benchmark a volte no. Wei et al. hanno raccolto casi in cui un task resta al livello del caso su ordini di grandezza di training compute e poi salta — l’aritmetica a tre cifre che compare in GPT-3 a circa $2 \times 10^{22}$ FLOP, MMLU che sale sopra l’indovinare tra 3 e $5 \times 10^{23}$ — e hanno dato un nome al pattern: «un’abilità è emergente se non è presente nei modelli più piccoli ma è presente nei modelli più grandi».¹² Se è una proprietà reale, estrapolare da esperimenti economici non è sicuro, perché la capacità che stai comprando potrebbe non esistere a nessuna scala che puoi permetterti di testare.

Schaeffer, Miranda e Koyejo hanno sostenuto che per lo più è un artefatto della misura, e il meccanismo è aritmetico.¹³ La loss per-token scende in modo liscio, quindi la probabilità che un token sia giusto, $\exp(-\mathcal{L})$, migliora gradualmente. Valuta il modello con exact string match su una risposta di $L$ token e porti quella probabilità alla potenza $L$ — una curva liscia elevata a una grande potenza sembra una scogliera. Sostituisci una metrica che conta i token invece di pretendere che siano tutti corretti, sugli stessi output, e «la performance della famiglia migliora in modo liscio, continuo e prevedibile con l’aumentare della scala».

Il loro audit è il numero da ricordare — «delle 39 metriche preferite in BIG-Bench, al massimo 5 mostrano emergence», con due metriche discontinue responsabili di oltre il 92% dei casi dichiarati — e lo è anche la loro cautela: «nulla in questo paper dovrebbe essere interpretato come un’affermazione che i large language models non possano mostrare abilità emergenti». Un salto in un grafico è evidenza sulla metrica finché non si dimostra il contrario. Il Capitolo 29 è dove questo diventa un tuo problema, perché scegliere una metrica a cutoff rigido è una decisione che prenderai senza accorgertene.

Il corpus è la parte di una run di pretraining a cui non è attaccata nessuna equazione, e dove vivono la maggior parte delle decisioni consequenziali. La materia prima è un web crawl: l’archivio di agosto 2026 di Common Crawl contiene «2,14 miliardi di pagine web o 360 TiB di contenuto non compresso», un mese, scaricabile gratis.¹⁴ Quasi nulla è utilizzabile così com’è. Il paper T5 dice che il crawl «comprende in gran parte testo senza senso o boiler-plate come menu, messaggi di errore o testo duplicato», e la pipeline C4 che introdusse è una lista di euristiche grossolane — tieni solo le righe che finiscono con punteggiatura terminale, elimina le pagine con meno di tre frasi, elimina qualunque pagina contenente una parentesi graffa o una parola da una lista pubblica di oscenità — trasformando venti terabyte di testo mensile in circa 750 GB.¹⁵

Grossolane è la parola. Dodge et al. hanno auditato ciò che quei filtri rimuovono e hanno scoperto che la blocklist di oscenità elimina il 42% dei documenti in African-American English e il 32% in English allineato all’ispanico, contro il 6,2% dell’English allineato ai bianchi, lasciando un corpus al 97,8% dell’ultima categoria.¹⁶ Una regola senza opinioni sul dialetto ne aveva una.

Poi deduplication, che non è pulizia: Lee et al. hanno trovato una frase di 61 parole ripetuta 61.036 volte in C4, e hanno mostrato che deduplicare riduce di dieci volte il tasso con cui i modelli «emettono testo memorizzato», dall’1,9% dei token generati allo 0,19%.¹⁷ Di più non è meglio, però: il team di FineWeb ha deduplicato globalmente su 96 crawl, ottenuto 4 trilioni di token e nessun guadagno misurabile, poi deduplicato ogni crawl separatamente, ottenuto 20 trilioni, e pareggiato il miglior corpus esistente.¹⁸

Poi contamination. Llama 3 ha misurato la propria e l’ha pubblicata: il 98% di AGIEval, il 95% di BIG-Bench Hard e l’85% di HellaSwag sovrapposti al training set per 8-grammi, e per MMLU una sovrapposizione così alta che «è impossibile ottenere una buona stima del guadagno di performance».⁵ La §4 di GPT-3 riporta un bug di filtraggio che lasciò benchmark nei dati senza possibilità di tornare indietro: «per considerazioni di costo era irrealizzabile riaddestrare il modello».⁷

La provenance è la parte irrisolta. The Pile includeva un componente da 100,96 GiB chiamato Books3 — 12% del corpus e, secondo la tabella dei consensi del paper stesso, libri da un tracker torrent privato;¹⁹ è stato portato offline nell’agosto 2023 dopo un reclamo di copyright. La posizione legale a settembre 2026 è instabile, e le tre sentenze USA citate come tendenza sono in disaccordo tra loro. Alsup ha ritenuto il training su libri acquisiti legalmente «estremamente trasformativo» pur sostenendo che una biblioteca costruita da copie piratate non lo fosse, e Anthropic ha transato quella metà per $1,5 miliardi coprendo 482.460 opere, circa $3.000 ciascuna, approvato il 20 luglio 2026.²⁰ Chhabria ha concesso a Meta il summary judgment scrivendo però che la sua decisione «non sostiene la proposizione che l’uso da parte di Meta di materiali protetti da copyright per addestrare i suoi language models sia lecito», solo che «questi querelanti hanno avanzato gli argomenti sbagliati».²¹ Bibas, decidendo contro Ross Intelligence, ha notato che «oggi davanti a me c’è solo AI non-generative».²² Nessuna corte d’appello USA si è pronunciata sulla questione.

Le persone fanno le parti che la loss non può fare. TIME ha riportato nel gennaio 2023 che lavoratori che etichettavano testo tossico per OpenAI tramite la società Sama portavano a casa «tra circa $1,32 e $2 all’ora» leggendo passaggi che descrivevano abuso sessuale di minori, tortura e autolesionismo, mentre OpenAI pagava Sama $12,50 all’ora per il lavoro; Sama contesta sia l’intervallo di paga sia la quota.²³ È il filtraggio intorno al pretraining, non il pretraining stesso — ma sta sulla stessa fattura, ed è lì che siede una persona.

L’elettricità è reale e di solito citata male. Il dato pubblicato più attento è quello di BLOOM: 1.082.990 GPU-ore, 433 MWh e 24,7 tonnellate di CO₂ equivalente per la run, 50,5 contando produzione e nodi idle;²⁴ Patterson et al. stimano GPT-3 a 1.287 MWh e 552 tonnellate.²⁵ Due cautele. Il vantaggio di BLOOM è la rete nucleare francese a 57 g CO₂ per kWh, non l’efficienza — ha usato più energia di OPT-175B. E la cifra di emissioni più citata del settore, le 626.155 lb di Strubell et al. per una neural architecture search, è stata poi mostrata come 88 volte troppo alta, avendo assunto che la search fosse eseguita alla dimensione piena del modello quando invece girava su un proxy.²⁶ Il framing di LBNL è quello difendibile: i data centre statunitensi hanno usato 192 TWh nel 2024, il 4,7% dell’elettricità nazionale — un numero attaccato a un’industria, non a una singola run.²⁷

Il filo conduttore è ciò che Bender et al. hanno chiamato documentation debt: «metterci in una situazione in cui i dataset sono sia non documentati sia troppo grandi per essere documentati post hoc».²⁸ Ogni fatto sopra esiste perché qualcuno ha guardato. Per i corpora dietro i modelli che la maggior parte delle persone usa, nessuno può farlo.

Ora l’aritmetica che tutti vogliono, da quattro input citati, così quando invecchieranno sarà ovvio cosa sostituire.

Leggi insieme le ultime due colonne. Con $10.000 ottieni un modello da 5 miliardi di parametri su un nodo affittato in due settimane. A $100.000.000 l’aritmetica dice 546 miliardi di parametri — e dodicimila H100 cablate insieme per tre mesi, cosa che non affitti con una carta di credito. Oltre circa $100.000 il vincolo stringente smette di essere il denaro e diventa il cluster.

Prima di fidarti di una tabella così, testala contro run il cui costo reale è pubblicato — llm.c riproduce GPT-2 124M in «~90 minuti» su un nodo 8×A100 «per circa $20», e GPT-2 1.6B in 24 ore su un nodo 8×H100 per $672.³¹

$672, against what $672 actually bought (llm.c GPT-2 1.6B, one 8xH100 node, 24 h)
  this table predicts:      168 H100-hours   N = 1.41 B params   D = 28.3 B tokens
  what was actually run:    192 H100-hours   N = 1.558 B params  D = 33.6 B tokens

Llama 3 405B, against Meta's own published GPU-hours
  from the paper's 3.8e25 FLOPs at 40 % MFU:   26.67 M H100-hours
  published in Meta's Llama 3.1 model card:    30.84 M H100-hours    ratio 0.86

Entrambi entro circa il 15%, che è più o meno l’accuratezza che questo tipo di stima merita e considerevolmente migliore dell’accuratezza con cui viene di solito citata.

La cifra più ripetuta in questo argomento è che un modello di classe GPT-2 costato circa $43.000 nel 2019 può essere riprodotto oggi per poche decine di dollari. La metà moderna è ben documentata; quella storica no.

Oggi. Il README di nanochat di Karpathy: «puoi addestrare il tuo LLM con capacità GPT-2 ... per soli $48 (~2 ore di nodo GPU 8XH100) ... Su un’istanza spot, il costo totale può avvicinarsi a ~$15».³² «Capacità GPT-2» qui è preciso e pubblicato — battere il CORE score di GPT-2 pari a 0,256525 — su una leaderboard il cui miglior risultato al 14 marzo 2026 è 1,65 ore. I $48 assumono $3 per GPU-ora, sotto il listino Lambda di $3,99; a listino sono più vicini a $64.

Nel 2019. Non c’è una fonte primaria: OpenAI non ha mai pubblicato una durata o un costo. La catena passa da The Register, febbraio 2019, che riporta «256 Google TPU3 cores» senza prezzo e senza durata; poi Synced, giugno 2019, che nota che l’hardware costava $256 l’ora su Google Cloud e afferma esplicitamente che «OpenAI non ha specificato la durata dell’addestramento». $43.008 è $256 l’ora moltiplicato per 168 ore assunte che nessuno ha mai documentato.

Quindi il titolo onesto è: un modello che eguaglia lo score benchmark pubblicato di GPT-2 può essere addestrato oggi per ben meno di $100 su hardware affittato, contro un costo 2019 che non è mai stato pubblicato e la cui famosa stima poggia su un’ipotesi senza fonte sulla durata. Il crollo è reale e la metà moderna è riproducibile da chiunque abbia una carta di credito; il rapporto è aritmetica su un numero che non esiste. Questo è lo stato dei costi di training pubblicati in generale. Il paper GPT-3 non contiene alcun importo in dollari, solo $3.14 \times 10^{23}$ FLOP nella Tabella D.1;⁷ nemmeno il paper Llama 3 ne contiene.⁵ Ogni costo di training che hai letto è una stima da un conteggio FLOP, un’ipotesi hardware e un’ipotesi di prezzo — vale sempre la pena chiedere di chi.

Ciò che esce ha visto un corpus fisso assemblato in un momento fisso, e ne seguono due proprietà.

La prima è il knowledge cutoff. Dopo la data di raccolta il modello non sa nulla — non «è incerto», nulla — e confabulerà fluentemente invece di dirlo, perché dirlo non è mai stato un comportamento su cui è stato addestrato. La model card di Llama 3.1 indica dicembre 2023;³³ ogni modello ne ha uno, ed è una proprietà dei dati di training, non del deployment. Aggirarlo è un problema di retrieval, che è il Capitolo 19.

La seconda è che un modello base completa invece di rispondere. Dagli «Qual è la capitale della Francia?» e una continuazione plausibile è un’altra domanda, perché nel corpus quella stringa compare più spesso in una lista di esercizi.

Un completatore di testo non è un assistente. Non segue istruzioni, perché nulla nel corpus gli ha detto che una richiesta debba essere obbedita invece che continuata. Non ha nozione di una conversazione con due partecipanti. Produrrà volentieri la continuazione più probabile di un prompt dannoso, perché probabile è l’unica cosa per cui sia mai stato ottimizzato.

Trasformarlo in qualcosa che risponde richiede una seconda fase che costa una frazione di punto percentuale della prima, e consiste quasi interamente nel mostrargli esempi del comportamento desiderato e poi confrontare coppie dei suoi stessi output. Quella fase è da dove arrivano instruction following, chat templates, rifiuti e — cosa che sorprende molti — la capacità di chiamare un tool. Il Capitolo 11 è quella fase: supervised fine-tuning, RLHF, DPO e GRPO, e la domanda su cosa significhi «aligned» e chi lo decida.

Vale anche la pena leggere insieme a questo capitolo build-nanogpt di Karpathy e il video che lo accompagna, che percorrono una riproduzione completa di GPT-2 end to end a un ritmo che questo capitolo non può sostenere; e Stanford CS324, Large Language Models, le cui lezioni sui dati e sull’impatto ambientale vanno più a fondo della sezione sopra in materiale che questo corso tratta una volta e poi delega.