Todas as apostilas anteriores comparam rodadas nossas entre si. Esta compara com fora: GPT‑1, GPT‑2 e os nossos, na única métrica que vale entre tokenizadores diferentes, e com o preço de cada treino em dólares. A pergunta é simples e desconfortável: um modelo com menos parâmetros, treinado por menos de um dólar, entrega o quê?
A tentação é dizer "o nosso modelo tem perplexidade 31 e o GPT‑2 tem 29, então o GPT‑2 é melhor". Isso não significa nada. Perplexidade é medida por token, e token não é uma unidade universal: é uma escolha do tokenizador. O nosso vocabulário tem 16.392 entradas treinadas neste corpus; o do GPT‑2 tem 50.257, treinadas em texto da web em inglês. A palavra "antevisão" pode virar dois pedaços no nosso e seis no do GPT‑2. Perplexidade por token compara duas coisas que estão contando unidades diferentes — é como comparar consumo de combustível em litros por quilômetro com galões por milha, sem converter.
A conversão existe e é antiga: bits por caractere. Some a log-verossimilhança negativa de todos os tokens de um texto, converta de nats para bits, e divida pelo número de caracteres do texto — não de tokens. O resultado responde a uma pergunta física: quantos bits este modelo precisa, em média, para transmitir um caractere deste texto? Um caractere é a mesma coisa para todo mundo. É a métrica da literatura de compressão, e é a única honesta aqui.
Nada de texto escolhido a dedo. O texto de teste sai do próprio conjunto de validação (model/data/validacao.bin), decodificado de volta para caracteres: blocos de 8.192 tokens que o preparo dos dados separou antes do treino e embaralhou. Nenhum modelo nosso os viu. O domínio de cada bloco — português, inglês ou código — é decidido por uma regra de contagem escrita no código (model/cost_vs_gpt2.py), não por julgamento: marcas estruturais de código, marcas do português, e o resto é inglês.
O nosso maior modelo tem a mesma geometria de corpo do GPT‑2 small: 12 camadas, 12 cabeças, 768 dimensões. A diferença inteira está no vocabulário, e ela não é pequena.
| modelo | total | embedding | corpo | embedding como % do total | camadas × d |
|---|---|---|---|---|---|
mini | 7.410.432 | 4.196.608 | 3.213.824 | 56,6% | 4 × 256 |
pequeno | 16.917.120 | 6.294.912 | 10.622.208 | 37,2% | 6 × 384 |
medio | 34.092.544 | 8.393.216 | 25.699.328 | 24,6% | 8 × 512 |
grande | 97.544.448 | 12.589.824 | 84.954.624 | 12,9% | 12 × 768 |
| GPT‑2 small | 124.439.808 | 38.597.376 | 85.054.464 | 31,0% | 12 × 768 |
| GPT‑1 | 116.534.784 | 31.087.104 | 85.054.464 | 26,7% | 12 × 768 |
O corpo é o mesmo; o vocabulário é que pesa. O nosso grande tem 97,5 milhões de parâmetros contra os 124,4 do GPT‑2 small — 21,6% a menos — e os dois têm praticamente o mesmo corpo, 85 milhões. Os 26,9 milhões de diferença são quase inteiramente tabela de tradução: 50.257 entradas contra 16.392. Isso não é esperteza nossa, é consequência de treinar o tokenizador neste corpus em vez de herdar um de outro. A apostila 01 mediu o outro lado da mesma moeda: um vocabulário ajustado ao corpus gasta menos tokens por caractere, então a mesma janela de contexto carrega mais texto.
Todas as rodadas até aqui foram medidas em CPU, e isso é escolha de método: é o que garante que qualquer pessoa repita o experimento inteiro sem depender de placa. O preço da escolha é tempo — 700 passos levam 25 minutos. Os mesmos 700 passos numa RTX 5090 levam 40 segundos. A diferença não é conforto: é o que permite medir a escada inteira de tamanhos numa sessão, em vez de num fim de semana.
| modelo | CPU (tok/s) | RTX 5090 (tok/s) | quantas vezes mais rápido |
|---|---|---|---|
mini | ≈ 3.800 | 575.752 | 151× |
pequeno | 2.185 | 509.073 | 233× |
medio | 1.203 | 225.341 | 187× |
grande | 361 | 98.725 | 273× |
A leitura que interessa não é "GPU é rápida", que todo mundo sabe. É a forma da curva: do mini para o pequeno a placa quase não perde velocidade (576 mil para 509 mil tokens por segundo) enquanto o modelo triplica de corpo. Nesses tamanhos a placa está ociosa — o gargalo é o lote pequeno, não o cálculo. Só a partir do medio a curva começa a se comportar como se espera, caindo com o tamanho. Quem treina modelos pequenos numa placa grande está pagando por silício parado, e a conta abaixo mostra quanto.
A CPU não tem esse regime ocioso: ela cai com o tamanho desde o primeiro degrau (4.108, 2.185, 1.203, 361 tok/s). Por isso a vantagem da placa cresce com o modelo, de 151× no mini a 273× no grande. Na CPU daqui, os 1,7 bilhão de tokens que o Chinchilla pede para o grande levariam cerca de 54 dias; na placa, 4,8 horas.
A regra de Chinchilla (apostila 07) diz que o treino eficiente usa cerca de 20 tokens por parâmetro. A apostila 07 aplicou isso ao corpo e não ao modelo inteiro, pelo mesmo motivo da seção 2: o embedding é tabela, não capacidade de cálculo. Aplicando ao nosso corpus de 309.083.117 tokens de treino:
| modelo | corpo | orçamento (20× corpo) | épocas do corpus | tempo na 5090 | custo |
|---|---|---|---|---|---|
mini | 3,2 M | 64 M tokens | 0,21 | 1,9 min | US$ 0,03 |
pequeno | 10,6 M | 212 M tokens | 0,69 | 7,0 min | US$ 0,10 |
medio | 25,7 M | 514 M tokens | 1,66 | 38 min | US$ 0,57 |
grande | 85,0 M | 1,70 G tokens | 5,50 | 4,8 h | US$ 4,28 |
Não temos corpus para o modelo grande, e isso é o resultado, não um obstáculo a esconder. Treinar 85 milhões de parâmetros de corpo até o ótimo de Chinchilla pediria 1,7 bilhão de tokens; o corpus tem 309 milhões. Seriam cinco épocas e meia sobre o mesmo texto. A partir daí o modelo passa a decorar em vez de generalizar, e a perda de validação para de acompanhar a de treino. O medio já pede 1,66 época — está no limite do que o corpus sustenta. A conclusão prática desta coleção fica registrada aqui: a partir de ~34 milhões de parâmetros, o nosso limite deixou de ser a placa e passou a ser o corpus. Mais GPU não compra mais qualidade; mais texto compra.
Os dois primeiros degraus, treinados no corpus completo com o orçamento da seção 4. As células se preenchem quando cada rodada fecha.
| modelo | passos | tokens vistos | perda de validação | PPL | tempo | custo |
|---|---|---|---|---|---|---|
controle do duelo (mini, 60 M tokens) | 700 | 5,7 M | 5,2577 | 192,0 | 40 s | US$ 0,010 |
mini | 1.961 | 64 M | 3,7503 | 42,5 | 1 min 25 s | US$ 0,021 |
pequeno | 6.483 | 212 M | 2,8611 | 17,5 | 7 min 06 s | US$ 0,106 |
O orçamento importa mais que o tamanho. O mesmo mini, com a mesma arquitetura e os mesmos 7,4 milhões de parâmetros, sai de perplexidade 192 para 42,5 — quatro vezes e meia melhor — só por ver 64 milhões de tokens em vez dos 5,7 milhões da rodada do duelo. Não mudou uma linha do modelo: mudou o quanto ele leu. A fila inteira desta coleção, das apostilas 03 a 14, rodou com 5,7 milhões de tokens por rodada, porque era o que a CPU permitia em vinte minutos. Isso não invalida as comparações entre rodadas, que continuam justas entre si, mas coloca todas elas num regime de treino curto que a placa acabou de mostrar ser bem abaixo do que o corpus permite.
O degrau seguinte confirma a direção: o pequeno, com 2,3 vezes os parâmetros e 3,3 vezes os tokens, chega a perplexidade 17,5 por dez centavos de dólar. Os dois treinos juntos custaram US$ 0,13 e levaram oito minutos e meio. É esse o número que dá escala ao resto da apostila: se oito minutos e treze centavos compram um salto de 192 para 17,5, o que limita não é mais o dinheiro nem a placa.
| orçamento | só gerador | + modelo de mundo (EMA) | o que o mapa custa |
|---|---|---|---|
duelo, mini — 5,7 M tokens, validação sorteada | 5,2744 ± 0,0443 | 5,3351 ± 0,0455 | +1,15% |
escada, mini — 64 M tokens, só a semente 1337 | 3,7503 | 3,6236 | −3,38% |
escada, mini — 64 M tokens, três sementes, validação sorteada | 3,6452 ± 0,0925 | 3,6870 ± 0,0959 | +1,15% |
escada, mini — três sementes, validação fixa | 3,6367 ± 0,0318 | 3,7011 ± 0,0154 | +1,77% |
escada, pequeno — 212 M tokens, duas sementes, validação fixa | 2,9477 ± 0,0002 | 3,0927 ± 0,0073 | +4,92% |
A primeira versão desta seção lia a segunda linha da tabela como uma inversão: com onze vezes mais tokens, o modelo de mundo deixaria de custar e passaria a render 3,38%. Os dados não confirmaram essa leitura. Nas sementes 2 e 3 o mapa voltou a custar (+1,79% e +5,22%), e o −3,38% era uma semente favorável, num protocolo em que a validação sorteada oscilava mais que o próprio efeito.
Com a validação fixa, que a apostila 19 explica, a régua ficou limpa: o desvio entre sementes caiu para 0,87% da perda no mini e para quase zero no pequeno. Nessa régua, o modelo de mundo custa em todas as sementes dos dois tamanhos: +1,77% no mini e +4,92% no pequeno. O custo não some com mais orçamento; ele cresce com o tamanho do modelo.
O modelo de mundo com hierarquia e alvo EMA custa ao gerador em todos os orçamentos medidos: cerca de 1% no duelo, 1,77% no mini da escada e 4,92% no pequeno. As frases da coleção sobre o custo do mapa, medidas com 5,7 milhões de tokens, continuam valendo com 64 e 212 milhões. O que o mapa entrega em troca — o leme, a violação de expectativa, o guardrail — está nas apostilas 12 e 13, e não aparece na perda de validação. A apostila 19 conta como a leitura de uma semente só foi parar num capítulo, e o que isso mudou no método: o treino ganhou --eval-seed, e rodada de escada sai com validação fixa.
A tabela central desta apostila. Menor é melhor. As três colunas de domínio existem porque a média esconde o que importa: um modelo pode ir bem no português e mal no inglês, e dizer só a média seria escolher o número que favorece.
| modelo | parâmetros | custo do treino | bits/char (média) | português | inglês | código |
|---|---|---|---|---|---|---|
pequeno (nosso) | 16.917.120 | US$ 0,106 | 1,273 | 1,360 | 1,486 | 0,972 |
mini (nosso) | 7.410.432 | US$ 0,021 | 1,637 | 1,737 | 1,821 | 1,354 |
| GPT‑2 small | 124.439.808 | — | 1,710 | 2,628 | 1,105 | 1,398 |
| GPT‑1 | 116.534.784 | — | 2,152 | 3,055 | 1,396 | 2,006 |
O resultado esperado não é "o nosso vai melhor". É o nosso vai melhor em português e em código, o GPT‑2 vai melhor em inglês — e por um motivo que não tem nada de misterioso: o GPT‑2 foi treinado em texto da web em inglês e nunca viu português estruturado, enquanto 39% do nosso corpus é Wikipédia em português e 33% é código Python. Se o nosso for melhor no inglês também, a explicação mais provável não é que o nosso modelo seja melhor, e sim que o texto de teste em inglês seja fácil demais ou curto demais — e a tabela precisa ser refeita com mais blocos antes de qualquer comemoração. Um resultado que favorece quem mede merece mais desconfiança que um que o contraria.
| modelo | bits/char em inglês simples | leitura |
|---|---|---|
| GPT‑2 small | 1,121 | dentro do esperado |
| GPT‑1 | 1,327 | dentro do esperado |
pequeno (nosso) | 1,449 | dentro do esperado |
mini (nosso) | 1,564 | no limite de cima |
A primeira versão desta tabela dava ao GPT‑2 4,772 bits por caractere — quatro vezes o valor real — e ao nosso pequeno 1,273. Era bom demais, e a caixa "como ler" desta seção, escrita antes de qualquer número existir, mandava desconfiar exatamente disso. O erro era da medida e não do modelo: os modelos da biblioteca transformers deslocam os rótulos sozinhos, e o script passava rótulos já deslocados. O GPT‑2 estava sendo obrigado a prever dois tokens à frente. A linha de sanidade agora roda sempre, e um valor acima de 2,5 sai marcado como suspeito na própria saída do programa.
O resultado é o que a caixa previu, e nenhuma surpresa favorável. O nosso vai melhor em português por uma margem larga — 1,360 contra os 2,628 do GPT‑2, quase o dobro — e em código, 0,972 contra 1,398. O GPT‑2 vai melhor em inglês, 1,105 contra 1,486, e a explicação não tem mistério: ele foi treinado em texto da web em inglês, e só 14% do nosso corpus é inglês da web. Cada modelo vai melhor no que leu.
O número que importa para a tese da coleção está na primeira linha. O pequeno, com 16,9 milhões de parâmetros contra 124,4 — sete vezes e meia menos — e dez centavos de dólar de treino, fica em 1,273 bits por caractere contra 1,710 do GPT‑2: 26% melhor na média dos três domínios. E o mini, com 7,4 milhões de parâmetros e dois centavos, já passa o GPT‑2 na média (1,637 contra 1,710) perdendo só no inglês. Isso não diz que treinamos melhor que a OpenAI em 2019; diz que um modelo pequeno treinado no seu próprio domínio supera, nesse domínio, um modelo dezessete vezes maior que foi treinado para outro. É um argumento sobre dados, não sobre engenhosidade, não diz nada contra o GPT‑2 no inglês para o qual ele foi feito, e é o mesmo argumento da seção 4 visto do outro lado.
O GPT‑1 fica atrás em tudo, inclusive no inglês onde deveria estar em casa (1,396 contra 1,105 do GPT‑2). Os dois têm o mesmo corpo de 85 milhões de parâmetros; o que separa um do outro é a quantidade de texto lido e o tamanho do vocabulário. É a mesma lição da nossa escada, medida numa geração de diferença.
Bits por caractere mede uma coisa só: prever o próximo pedaço de texto. É a tarefa para a qual o GPT‑2 foi feito, e comparar só nisso é comparar no terreno dele. As peças que esta coleção construiu não aparecem nessa métrica, e é justamente por isso que elas existem.
| função | o que faz | custo ao gerador | onde foi medida |
|---|---|---|---|
| modelo de mundo | prevê o próximo estado latente, não o próximo token: dá ao planejador um mapa para imaginar antes de escrever | +0,45% (alvo EMA) | 13 §4 |
| leme por energia | escolhe o token que mais aproxima de um rumo declarado, buscando no espaço latente | 0 (só inferência) | 12, 13 §4 |
| guardrail no estado imaginado | bloqueia o que o modelo vai escrever, não o que já escreveu: 0,0% de dígitos em 4 de 4 mapas | 0 (só inferência) | 13 §5 |
| energia de dependência | detecta violação de ordem sem receber o token: +130% a +142% contra +38% do erro simples | 0 (só inferência) | 13 §11 |
| memória consultada | banco de estados abstratos lido por atenção, persistido em disco com índice quantizado | +9,73% (indistinguível do mapa sem banco) | 14 |
| surpresa calibrada | mede quando o mapa errou, e devolve o controle à política nesses passos | 0 (só inferência) | 13 §11 |
A soma é o argumento desta coleção: as funções custam 0,45% de perda e nenhum parâmetro extra no caminho de geração, porque quase todas vivem na inferência. Essas funções pedem um modelo de mundo. Dá para acrescentar um a um modelo já treinado, como o GPT‑2, mas sai mais caro — a apostila 13 mediu que o mapa em segundo estágio, sobre encoder congelado, sai mais caro que treiná-lo junto.
grande não cabe no corpus. Ou o corpus cresce para 1,7 bilhão de tokens, ou o medio é o maior modelo honesto desta coleção. Medir onde a perda de validação descola da de treino, por tamanho, diria qual dos dois.