Pré-treinando um LLM: dados, computação, leis de escala e custo

Nada no objetivo muda. O modelo ainda prevê o próximo token, a perda ainda é a entropia cruzada do Capítulo 4 aplicada à fatoração do Capítulo 8, o otimizador ainda é o AdamW do Capítulo 6. Pré-treinamento não é um novo algoritmo; é o mesmo algoritmo rodado em um corpus grande o suficiente para que a execução precise ter orçamento. Duas coisas tornam isso possível: os rótulos são gratuitos, já que o alvo para a posição $t$ é o token em $t+1$ e já está no texto; e a última seção do Capítulo 6 removeu a objeção, porque um modelo com muito mais parâmetros do que as regras clássicas permitem não desmorona, ele melhora. O que sai é um modelo base — algo que continua texto, em vez de responder.

Antes que qualquer coisa disso possa entrar no orçamento, ela precisa ser contada, e a área a conta com uma fórmula:

em que $N$ é a contagem de parâmetros, $D$ são os tokens de treinamento e $C$ é o total de operações de ponto flutuante. Kaplan et al. a derivam em duas etapas.¹ Forward: 2 FLOPs por parâmetro por token, já que cada parâmetro em uma multiplicação de matrizes é usado uma vez por token, em uma multiplicação e uma soma. Backward: duas vezes o forward, já que a passagem backward do Capítulo 5 calcula dois gradientes em cada camada — em relação às entradas da camada, para que o sinal continue viajando, e em relação aos seus pesos — cada um uma multiplicação de matrizes do tamanho da forward, então $4N$.

Essa é a derivação inteira, e vale conferir em vez de acreditar. O PyTorch vem com um contador real de FLOPs, torch.utils.flop_counter.FlopCounterMode, que intercepta cada operação que um modelo despacha e soma o trabalho real. Rode-o ao longo de quatro ordens de grandeza, a maior no dispositivo meta, que aloca shapes e nenhuma memória:

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))

A razão forward+backward sobre forward é 3,000, exatamente, em todas as escalas: não uma aproximação que por acaso é boa, mas a identidade aritmética acima devolvida como número redondo por um contador que não sabe nada sobre a derivação.

O total medido então fica entre 3% e 17% acima de $6ND$, uma vez que $N$ conta as matrizes de embedding — e essa cláusula importa, porque os dois artigos fundadores contam $N$ de maneiras diferentes. Kaplan exclui “all vocabulary and positional embeddings” porque isso “produces significantly cleaner scaling laws” (§1.3); o Apêndice F de Chinchilla diz “we also count embeddings matrices in the total parameter count”.² Para um vocabulário amplo e uma dimensão oculta estreita, os dois diferem por um fator de nove, como mostra a primeira linha.

A lacuna residual é o que $6ND$ omite deliberadamente: os scores de attention. A Eq. (2.2) de Kaplan escreve o custo forward como $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ e descarta o segundo termo porque $d_{\text{model}} \gg n_{\text{ctx}}/12$ — seguro em 2020, menos seguro agora, e o motivo pelo qual a razão deriva para cima conforme $T/d$ cresce — é por isso que duas linhas aqui compartilham um $T$ de 1.024 e a razão cai, de 1,145 para 1,100, quando $d$ vai de 768 para 1.600. É o custo $O(T^2)$ que o Capítulo 9 introduziu e que o Capítulo 16 transforma em preço.

A computação decide quanto tempo uma execução leva; a memória decide se ela pode começar. Treine com AdamW fp32 puro e cada parâmetro carrega quatro números: o peso, seu gradiente, e a média móvel $m$ e a variância $v$ do Adam — as duas médias construídas à mão no Capítulo 6. Quatro números a quatro bytes cada são 16 bytes por parâmetro, antes de uma única ativação. Medido em uma GPU de laptop de 8 GB, tomando a alocação residente no ponto da etapa em que nenhum grafo está vivo:

Previsão e medição concordam dentro de 3%. A surpresa está na última coluna: as ativações superam o modelo por muito. O mesmo modelo de 5,8 milhões de parâmetros que precisa de 89 MB de estado persistente precisa de 4.681 MB de ativações com batch de 128 — cinquenta e duas vezes o modelo — e boa parte disso nem é o transformer. São os logits, um vetor do tamanho do vocabulário por token, a quatro bytes por entrada: 512 MB na última linha, 393 MB na primeira. O tamanho do vocabulário foi escolhido no Capítulo 7, e ele ainda decide o que cabe na placa.

Qual termo domina depende do formato da execução, por isso Micikevicius et al. dizem que a memória “is dominated by activations”³ enquanto o ZeRO diz que um modelo de 1,5 bilhão de parâmetros precisa de “at least 24 GB” apenas de estados do modelo.⁴ O ZeRO chega aos mesmos 16 bytes por outro caminho — $2\Psi$ para pesos fp16, $2\Psi$ para gradientes fp16, $4\Psi$ cada para os pesos master fp32 e os dois momentos do Adam — o que, para 70 bilhões de parâmetros, dá 1,12 terabytes, o equivalente a quatorze GPUs de 80 GB antes de uma única ativação.

Nada disso cabe em um único dispositivo na escala de fronteira, então a execução é dividida de quatro maneiras ao mesmo tempo. Paralelismo de dados coloca uma cópia do modelo em cada GPU e tira a média dos gradientes — o padrão, e aquele que o ZeRO melhora ao se recusar a manter cópias redundantes do estado do otimizador. Paralelismo de tensores divide matrizes individuais entre dispositivos. Paralelismo de pipeline dá a cada dispositivo um grupo contíguo de camadas. Paralelismo de contexto divide a própria sequência, necessário apenas quando $T$ é longo o bastante para o termo de attention dominar. A Tabela 4 do Llama 3 lista todos os quatro de uma vez: tensor 8, contexto até 16, pipeline 16, dados até 128, em 16.384 GPUs H100.⁵ Isso é tudo que este curso dirá sobre o assunto; engenharia de treinamento distribuído é um semestre próprio, e o CS336 de Stanford é esse semestre, aulas 5 a 8, com código.⁶ O que sobrevive à delegação é um único número, utilização de FLOPs do modelo — a fração do pico aritmético de uma GPU que uma execução real alcança — que é o que transforma o organizado $6ND$ em tempo de relógio e, portanto, em dinheiro.

Em janeiro de 2020, Kaplan et al. treinaram uma grade de transformers e descobriram que a perda de teste segue uma lei de potência em cada um dos três recursos ao longo de mais de seis ordens de grandeza.¹ A §1.2 deles dá três leis ajustadas:

com companheiras $\alpha_D \approx 0.095$ para dados e $\alpha_C^{\min} \approx 0.050$ para computação alocada de forma ótima. As constantes não são universais, e o artigo diz isso: “the precise numerical values of $N_c$, $C_c^{\min}$ and $D_c$ depend on the vocabulary size and tokenization and hence do not have a fundamental meaning.”

Os expoentes são minúsculos: dez vezes os parâmetros compra um fator $10^{0.076} \approx 1.19$ a menos na perda restante. Isso parece nada, e é o fato mais importante aqui — os retornos são terríveis e nunca param. Uma lei de potência com expoente pequeno promete que a próxima ordem de grandeza vai ajudar, menos do que a anterior ajudou, para sempre. Comprar computação deixa de ser aposta e vira uma compra com taxa de câmbio publicada, que é exatamente o argumento que destravou o capital.

Então veio a prescrição, e é aqui que o artigo estava errado de um jeito que custou muito dinheiro à indústria. A Tabela 6 de Kaplan dá $N_{\text{opt}} \propto C^{0.73}$ e $D_{\text{opt}} \propto C^{0.27}$: dez vezes a computação significa um modelo 5,4 vezes maior alimentado com apenas 1,9 vez mais texto. O resumo é explícito — “optimally compute-efficient training involves training very large models on a relatively modest amount of data and stopping significantly before convergence.” A área fez exatamente isso: GPT-3 tem 175 bilhões de parâmetros em 300 bilhões de tokens,⁷ Gopher 280 bilhões em 300 bilhões, Megatron-Turing NLG 530 bilhões em 270 bilhões.² Meio token a dois tokens por parâmetro, em todos os casos.

Em março de 2022, Hoffmann et al. treinaram mais de 400 modelos, de 70 milhões a 16 bilhões de parâmetros, e chegaram à conclusão oposta por três rotas independentes.² A Tabela 2 deles relata o expoente $a$ em $N_{\text{opt}} \propto C^{a}$ como 0,50, 0,49 e 0,46, contra 0,73 de Kaplan. Em termos simples: tamanho do modelo e dados de treinamento devem crescer na mesma proporção.

A segunda abordagem deles é a reproduzida pela varredura no topo deste capítulo, em um milionésimo da escala: fixe um orçamento, treine muitos tamanhos exatamente nesse orçamento, trace a perda final contra o tamanho do modelo.

Perda held-out em nats por token, tokens por parâmetro entre parênteses, negrito para o melhor modelo em cada orçamento; um travessão é um ponto não executado, porque o orçamento exigia mais texto do que o corpus contém ou o tamanho ficou fora dos varridos ali.

Leia uma coluna de cima para baixo: a perda cai, chega ao fundo e volta a subir. Um modelo pode ser grande demais para seu orçamento com a mesma facilidade com que pode ser pequeno demais — em $10^{14}$, a penalidade por escolher 665.280 parâmetros em vez de 295.808 é 0,08 nats, o que no envelope ajustado acima é a perda que um modelo corretamente dimensionado alcança com 18% menos computação. Escolher o formato errado joga fora um quinto do orçamento. Essa é a Figura 3 de Chinchilla em uma tarde em uma GPU, em vez de com quatrocentos modelos.

Agora leia na horizontal. Em $10^{13}$, o melhor modelo é o menor da varredura; em $10^{14}$, é o de 295.808 parâmetros, cercado dos dois lados. O ótimo se move para a direita conforme o orçamento cresce, que é todo o conteúdo da correção. Ajuste a terceira abordagem do artigo — a superfície $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ sobre todas as execuções — e minimize sujeita 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, vindo de um laptop, contra 0,73 de Kaplan. Concordância em três dígitos a partir de um ajuste com três orçamentos é sorte; concordância no primeiro não é. O expoente viaja — a constante não, já que a razão token-parâmetro nesses ótimos é de 170 a 540, não 20. Três motivos, todos instrutivos. $E$ ajusta para zero porque, em uma perda acima de 4 nats, a execução não está nem perto do piso de entropia que domina o ajuste de Chinchilla. Batch size e learning rate foram fixos em vez de ajustados por ponto, o que prejudica as execuções que recebem menos etapas — e essas são os modelos grandes: em $10^{13}$ FLOPs, um modelo de 1,28 milhão de parâmetros recebe 159 etapas de otimizador no total, muito abaixo dos poucos milhares que o termo $S_{\min}$ de Kaplan diz que qualquer modelo precisa. Uma lei de escala é ajustada dentro de um regime, e esta está seis ordens de grandeza abaixo da de Chinchilla.

Daí o resumo do artigo: “current large language models are significantly undertrained”. Chinchilla é a demonstração — 70 bilhões de parâmetros em 1,4 trilhão de tokens, a mesma computação total que o Gopher de 280 bilhões em 300 bilhões, vencendo-o em 51 de 57 tarefas MMLU, 67,5% contra 60%.² Quatro vezes menor, quatro vezes e meia mais texto, mesmo dinheiro, modelo melhor.

Duas ressalvas sobre essa razão famosa. “Vinte tokens por parâmetro” não é uma frase no artigo, que diz apenas que “for every doubling of model size the number of training tokens should also be doubled”; o 20 é uma inferência da Tabela 3 e dos próprios 70 B em 1,4 T de Chinchilla. E sua precisão é pior do que a publicada: Besiroglu et al. reajustaram a partir de uma digitalização da Figura 4, descobriram que os parâmetros originais “fit the reconstructed data poorly”, com intervalos “implausibly tight given the number of data points”, e colocaram a faixa honesta em “between 4 and 40” tokens por parâmetro.⁸

Um detalhe do método de Chinchilla cumpre uma promessa que o Capítulo 1 fez sobre schedules de learning rate. O cosine schedule precisa ser combinado ao orçamento de tokens. Um modelo que verá 10 milhões de tokens deve decair seu learning rate para zero em 10 milhões de tokens; dê a ele um schedule dimensionado para 100 milhões, pare cedo, e você está lendo uma perda no meio da descida a uma taxa alta demais. Chinchilla treina cada modelo em quatro comprimentos de ciclo para controlar exatamente isso; a varredura acima define seu schedule a partir do orçamento pelo mesmo motivo.

Elas são o resultado empírico mais útil da área e são rotineiramente vendidas além do que dizem. Quatro limites.

Elas preveem perda, não capacidade. O lado esquerdo é entropia cruzada em texto held-out. Nada nesses artigos autoriza uma afirmação sobre se um modelo escreverá SQL correto, recusará uma solicitação prejudicial ou usará uma ferramenta. Esta é a lição do Capítulo 5 de novo: uma previsão da perda não é uma previsão do comportamento pelo qual você está pagando.

Elas são ajustadas, não derivadas. Nenhuma teoria produz $\alpha_N = 0.076$. As constantes se movem com o tokenizer — por isso uma comparação de perplexidade entre dois tokenizers não tem sentido, como o Capítulo 8 explicou — e com a mistura de dados, arquitetura e otimizador. Toda lei publicada é uma lei do setup que a produziu, e é por isso que a Meta reajustou a sua antes do Llama 3.⁵

Elas assumem um token novo a cada etapa, o que silenciosamente assume um corpus infinito. Muennighoff et al. mediram o que acontece quando ele acaba: até quatro épocas de dados repetidos custam quase nada — um modelo de 8,7 bilhões de parâmetros em 44 bilhões de tokens únicos vistos quatro vezes terminou com “only 0.5 % higher validation loss” do que o mesmo modelo em 178 bilhões de tokens únicos — enquanto, depois de cerca de dezesseis épocas, computação adicional não compra nada.⁹

E ninguém treina mais de forma compute-optimal. Chinchilla minimiza o custo de treinamento; um modelo implantado então paga aproximadamente $2N$ FLOPs por token gerado, para sempre. LLaMA 1 disse isso claramente: “given a target level of performance, the preferred model is not the fastest to train but the fastest at inference”.¹⁰ Sardana et al. formalizaram isso minimizando $6ND_{\text{train}} + 2ND_{\text{inference}}$ em vez disso, e descobriram que qualquer um esperando um bilhão de solicitações deve treinar “smaller and longer than Chinchilla-optimal”.¹¹ A §9.1 do Llama 3 concorda: seus modelos pequenos treinam “far beyond the point of compute optimal training, effectively trading training compute for inference efficiency”.⁵ A razão não está obsoleta; ela responde a uma pergunta que já não é a que está sendo feita.

A perda cai suavemente. Scores de benchmark às vezes não. Wei et al. reuniram casos em que uma tarefa fica no acaso ao longo de ordens de grandeza de computação de treinamento e então salta — aritmética de três dígitos aparecendo no GPT-3 por volta de $2 \times 10^{22}$ FLOPs, MMLU subindo acima de chute entre $3$ e $5 \times 10^{23}$ — e deram nome ao padrão: “an ability is emergent if it is not present in smaller models but is present in larger models”.¹² Se isso é uma propriedade real, extrapolar a partir de experimentos baratos é inseguro, porque a capacidade que você está comprando pode não existir em nenhuma escala que você possa se dar ao luxo de testar.

Schaeffer, Miranda e Koyejo argumentaram que a maior parte disso é um artefato de medição, e o mecanismo é aritmético.¹³ A perda por token cai suavemente, então a probabilidade de um token estar certo, $\exp(-\mathcal{L})$, melhora gradualmente. Avalie o modelo com correspondência exata de string em uma resposta de $L$ tokens e você eleva essa probabilidade à potência $L$ — uma curva suave elevada a uma potência grande parece um precipício. Troque por uma métrica que conta tokens em vez de exigir todos eles, nas mesmas saídas, e “the family's performance smoothly, continuously and predictably improves with increasing scale”.

A auditoria deles é o número a lembrar — “of the 39 preferred metrics in BIG-Bench, at most 5 display emergence”, com duas métricas descontínuas respondendo por mais de 92% dos casos alegados — e a cautela deles também: “nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities”. Um salto em um gráfico é evidência sobre a métrica até prova em contrário. O Capítulo 29 é onde isso vira seu problema, porque escolher uma métrica com corte rígido é uma decisão que você tomará sem perceber.

O corpus é a parte de uma execução de pré-treinamento que não tem equação associada, e onde vivem a maioria das decisões consequenciais. A matéria-prima é um rastreamento da web: o arquivo de agosto de 2026 do Common Crawl contém “2.14 billion web pages or 360 TiB of uncompressed content”, um mês dele, gratuito para baixar.¹⁴ Quase nada é utilizável como está. O artigo do T5 diz que o crawl “largely comprises gibberish or boiler-plate text like menus, error messages, or duplicate text”, e o pipeline C4 que ele introduziu é uma lista de heurísticas grosseiras — manter apenas linhas que terminam com pontuação final, descartar páginas com menos de três frases, descartar qualquer página que contenha uma chave ou uma palavra de uma lista pública de obscenidades — transformando vinte terabytes de texto mensal em cerca de 750 GB.¹⁵

Grosseiras é a palavra. Dodge et al. auditaram o que esses filtros removem e descobriram que a blocklist de obscenidades apaga 42% dos documentos em inglês afro-americano e 32% em inglês alinhado a hispânicos, contra 6,2% do inglês alinhado a brancos, deixando um corpus 97,8% da última categoria.¹⁶ Uma regra sem opinião sobre dialeto tinha uma.

Depois vem deduplicação, que não é arrumação: Lee et al. encontraram uma frase de 61 palavras repetida 61.036 vezes no C4, e mostraram que deduplicar reduz em dez vezes a taxa com que modelos “emit memorized text”, de 1,9% dos tokens gerados para 0,19%.¹⁷ Mais não é melhor, porém — a equipe do FineWeb deduplicou globalmente ao longo de 96 crawls, obteve 4 trilhões de tokens e nenhum ganho mensurável, depois deduplicou cada crawl separadamente, obteve 20 trilhões, e igualou o melhor corpus existente.¹⁸

Depois, contaminação. O Llama 3 mediu a sua e publicou: 98% do AGIEval, 95% do BIG-Bench Hard e 85% do HellaSwag sobrepostos ao conjunto de treinamento por 8-grams, e para o MMLU uma sobreposição tão alta que “it is impossible to get a good performance gain estimate”.⁵ A §4 do GPT-3 relata um bug de filtragem que deixou benchmarks nos dados sem volta: “because of cost considerations it was infeasible to retrain the model”.⁷

Proveniência é a parte não resolvida. The Pile trouxe um componente de 100,96 GiB chamado Books3 — 12% do corpus e, pela própria tabela de consentimento do artigo, livros de um tracker privado de torrent;¹⁹ ele foi tirado do ar em agosto de 2023 após uma reclamação de copyright. A posição jurídica em setembro de 2026 é incerta, e as três decisões dos EUA citadas como tendência discordam entre si. Alsup considerou treinamento em livros adquiridos legalmente “exceedingly transformative” enquanto decidiu que uma biblioteca construída a partir de cópias pirateadas não era, e a Anthropic fez acordo nessa metade por $1,5 bilhão cobrindo 482.460 obras, cerca de $3.000 cada, aprovado em 20 de julho de 2026.²⁰ Chhabria concedeu julgamento sumário à Meta escrevendo que sua decisão “does not stand for the proposition that Meta's use of copyrighted materials to train its language models is lawful”, apenas que “these plaintiffs made the wrong arguments”.²¹ Bibas, decidindo contra a Ross Intelligence, observou que “only non-generative AI is before me today”.²² Nenhum tribunal recursal dos EUA decidiu a questão.

Pessoas fazem as partes que a perda não consegue. A TIME noticiou em janeiro de 2023 que trabalhadores rotulando texto tóxico para a OpenAI por meio da empresa Sama levavam para casa “between around $1.32 and $2 per hour” lendo trechos que descreviam abuso sexual infantil, tortura e automutilação, enquanto a OpenAI pagava à Sama $12,50 por hora pelo trabalho; a Sama contesta tanto a faixa de pagamento quanto a cota.²³ Isso é a filtragem ao redor do pré-treinamento, não o pré-treinamento em si — mas está na mesma fatura, e é onde uma pessoa se senta.

A eletricidade é real e geralmente citada de forma errada. O número publicado mais cuidadoso é o do BLOOM: 1.082.990 horas de GPU, 433 MWh e 24,7 toneladas de CO₂ equivalente para a execução, 50,5 contando fabricação e nós ociosos;²⁴ Patterson et al. colocam o GPT-3 em 1.287 MWh e 552 toneladas.²⁵ Duas cautelas. A vantagem do BLOOM é a matriz nuclear francesa a 57 g CO₂ por kWh, não eficiência — ele usou mais energia do que o OPT-175B. E o número de emissões mais citado da área, as 626.155 lb de Strubell et al. para uma busca de arquitetura neural, depois se mostrou 88 vezes alto demais, por ter assumido que a busca rodou no tamanho completo do modelo quando ela rodou em um proxy.²⁶ O enquadramento do LBNL é o defensável: data centers dos EUA usaram 192 TWh em 2024, 4,7% da eletricidade nacional — um número ligado a uma indústria, não a uma execução específica.²⁷

A linha que atravessa tudo isso é o que Bender et al. chamaram de dívida de documentação: “putting ourselves in a situation where the datasets are both undocumented and too large to document post hoc”.²⁸ Cada fato acima existe porque alguém olhou. Para os corpora por trás dos modelos que a maioria das pessoas usa, ninguém consegue.

Agora a aritmética que todo mundo quer, a partir de quatro entradas citadas, para que, quando envelhecerem, fique óbvio qual substituir.

Leia as duas últimas colunas juntas. Com $10.000 você obtém um modelo de 5 bilhões de parâmetros em um nó alugado em quinze dias. Com $100.000.000, a aritmética diz 546 bilhões de parâmetros — e doze mil H100s conectadas por três meses, o que não é algo que você aluga com cartão de crédito. Depois de cerca de $100.000, a restrição vinculante deixa de ser dinheiro e passa a ser o cluster.

Antes de confiar em uma tabela assim, teste-a contra execuções cujo custo real foi publicado — llm.c reproduz o GPT-2 124M em “~90 minutes” em um nó 8×A100 “for about $20”, e o GPT-2 1.6B em 24 horas em um nó 8×H100 por $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

Ambos dentro de cerca de 15%, que é aproximadamente a precisão que esse tipo de estimativa merece e consideravelmente melhor do que a precisão com que ela costuma ser citada.

O número mais repetido neste assunto é que um modelo da classe GPT-2 que custava cerca de $43.000 em 2019 pode ser reproduzido hoje por algumas dezenas de dólares. A metade moderna é bem documentada; a metade histórica, não.

Hoje. README do nanochat de Karpathy: “you can train your own GPT-2 capability LLM ... for only $48 (~2 hours of 8XH100 GPU node) ... On a spot instance, the total cost can be closer to ~$15.”³² “GPT-2 capability” aqui é preciso e publicado — superar o score CORE do GPT-2 de 0,256525 — em um leaderboard cuja melhor entrada em 14 de março de 2026 é 1,65 hora. Os $48 assumem $3 por GPU-hora, abaixo do preço de tabela de $3,99 da Lambda; no preço de tabela, fica mais perto de $64.

Em 2019. Não há fonte primária: a OpenAI nunca publicou duração ou custo. A cadeia passa por The Register, fevereiro de 2019, relatando “256 Google TPU3 cores” sem preço e sem duração; depois Synced, junho de 2019, observando que o hardware custava $256 por hora no Google Cloud e afirmando explicitamente que “OpenAI didn't specify the training duration”. $43.008 são $256 por hora vezes 168 horas presumidas que ninguém jamais referenciou.

Então a manchete honesta é: um modelo que iguala o score de benchmark publicado do GPT-2 pode ser treinado hoje por bem menos de $100 em hardware alugado, contra um custo de 2019 que nunca foi publicado e cuja estimativa famosa repousa em um palpite sem fonte sobre a duração. O colapso é real e a metade moderna é reproduzível por qualquer pessoa com cartão de crédito; a razão é aritmética sobre um número que não existe. Esse é o estado dos custos de treinamento publicados em geral. O artigo do GPT-3 não contém nenhum valor em dólares, apenas $3.14 \times 10^{23}$ FLOPs na Tabela D.1;⁷ o artigo do Llama 3 também não contém.⁵ Todo custo de treinamento que você leu é uma estimativa a partir de uma contagem de FLOPs, uma suposição de hardware e uma suposição de preço — sempre vale perguntar de quem.

O que sai viu um corpus fixo montado em um momento fixo, e duas propriedades decorrem disso.

A primeira é o knowledge cutoff. Depois da data de coleta, o modelo não sabe nada — não “está incerto”, nada — e vai confabular fluentemente em vez de dizer isso, porque dizer isso nunca foi um comportamento em que ele foi treinado. O model card do Llama 3.1 dá dezembro de 2023;³³ todo modelo tem um, e ele é uma propriedade dos dados de treinamento, não do deployment. Contornar isso é um problema de recuperação, que é o Capítulo 19.

A segunda é que um modelo base completa em vez de responder. Dê a ele “Qual é a capital da França?” e uma continuação plausível é outra pergunta, porque no corpus essa string aparece com mais frequência em uma lista de exercícios.

Um completador de texto não é um assistente. Ele não segue instruções, porque nada no corpus lhe disse que um pedido deve ser obedecido em vez de continuado. Ele não tem noção de uma conversa com dois participantes. Ele produzirá tranquilamente a continuação mais provável de um prompt prejudicial, porque provável é a única coisa para a qual ele foi otimizado.

Transformá-lo em algo que responde exige uma segunda etapa que custa uma fração de um por cento da primeira, e consiste quase inteiramente em mostrar exemplos do comportamento que você quer e então comparar pares das próprias saídas dele. Essa etapa é de onde vêm seguimento de instruções, templates de chat, recusas e — isso surpreende as pessoas — a capacidade de chamar uma ferramenta. O Capítulo 11 é essa etapa: supervised fine-tuning, RLHF, DPO e GRPO, e a pergunta sobre o que “alinhado” significa e quem decide.

Também vale ler junto com este capítulo: o build-nanogpt de Karpathy e seu vídeo acompanhante, que percorrem uma reprodução completa do GPT-2 de ponta a ponta em um ritmo que este capítulo não consegue; e Stanford CS324, Large Language Models, cujas aulas sobre dados e impacto ambiental aprofundam mais do que a seção acima em material que este curso trata uma vez e delega.