Laboratório GPT-2 · RoBERTa · Parte II — A família GPT

GPT-2 de ponta a ponta,
e o que a escala compra

A montagem completa das peças — e uma medição honesta do que muda de 124 milhões para 1,5 bilhão de parâmetros.

Apostila 06 de 15 Pré-requisito: apostilas 01 a 05

1 O modelo inteiro, de cima a baixo

Você já conhece todas as peças. Aqui está a montagem, sem nada omitido:

TEXTO   "The capital of France is"
   |
   |  tokenizador BPE (apostila 01)          — nao e parte do modelo
   v
IDs     [464, 3139, 286, 4881, 318]                        (5,)
   |
   |  wte[IDs]  +  wpe[0..4]                 (apostila 02)
   v
h_0                                                        (5, 768)
   |
   +-- BLOCO  1 ---+                                                 .
   |   x = x + attn(ln_1(x))   comunicacao   (apostilas 03, 04)      .
   |   x = x + mlp (ln_2(x))   computacao    (apostila 05)           .
   +---------------+                                                 .
   |                                                                 .
   |  ... 12 blocos identicos, forma sempre (5, 768) ...             .
   |                                                                 .
   +-- BLOCO 12 ---+
   |
   v
h_12                                                       (5, 768)
   |
   |  ln_f   — LayerNorm final (so existe por causa do Pre-LN)
   v
   |  @ wte.T   — weight tying (apostila 02, secao 6)
   v
LOGITS                                                   (5, 50257)
   |
   |  pegamos SO a ultima linha: a previsao do proximo token
   v
logits[-1]                                                 (50257,)
   |
   |  softmax + estrategia de amostragem     (apostila 07)
   v
PROXIMO TOKEN  ->  volta para o topo, agora com 6 tokens

O que o modelo devolve — e o que se joga fora

Para uma entrada de 5 tokens, o GPT-2 devolve 5 previsões, uma por posição: "o que vem depois de The", "o que vem depois de The capital", e assim por diante. Todas as 5 são calculadas, sempre.

No treino, todas as 5 são usadas — é isso que torna o pré-treino tão eficiente (apostila 08). Na geração, 4 são jogadas fora e só a última interessa. Esse "desperdício" é exatamente o que o cache KV recupera.

2 A família inteira em uma tabela

Os quatro GPT-2 são o mesmo modelo. Nenhuma peça nova, nenhum truque diferente. Só três números mudam.

Note que d_k = d_model / cabeças = **64 em todos**. Essa constante atravessa a família inteira, e não é acidente: 64 é o tamanho de subespaço em que o √d_k mantém o softmax bem comportado.
Modelo	Camadas	d_model	Cabeças	d_k	MLP	Parâmetros	fp32
`gpt2`	12	768	12	64	3072	124 M	0,5 GB
`gpt2-medium`	24	1024	16	64	4096	355 M	1,4 GB
`gpt2-large`	36	1280	20	64	5120	774 M	3,0 GB
`gpt2-xl`	48	1600	25	64	6400	1558 M	6,0 GB

Todos compartilham: vocabulário de 50 257, contexto de 1024, BPE byte-level, Pre-LN, GELU, expansão 4× no MLP, weight tying. O treino também foi o mesmo — o mesmo WebText, os mesmos 40 GB de texto. A única variável experimental foi o tamanho.

Era essa, aliás, a tese do artigo do GPT-2 ("Language Models are Unsupervised Multitask Learners", 2019): manter tudo fixo e crescer, para mostrar que capacidades novas emergem da escala sozinha.

A fórmula da contagem

N ≈ V·d + n_ctx·d + L · (12d² + 13d) Por bloco: 4d² na atenção (QKV são 3d², a projeção é d²) + 8d² no MLP (duas matrizes de d×4d) = 12d². Os 13d são vieses e os γ/β dos LayerNorms.

O termo que importa é L · 12d². Como d está ao quadrado, dobrar a largura quadruplica o custo daquele bloco. É por isso que os modelos crescem mais em profundidade do que em largura: sai mais barato.

3 O que a escala realmente compra

A resposta intuitiva ("modelos maiores escrevem melhor") não se sustenta no laboratório.

No teste inicial deste curso, pedi a mesma coisa aos quatro modelos, em modo greedy (sempre a palavra mais provável). O prompt foi "The capital of France is":

Resultado real, medido nesta máquina. Leia a coluna da direita com atenção.
Modelo	Parâmetros	Continuação gerada	Acertou?
`openai-gpt`	117 M	"a great city , and the city is a great city ."	não
`gpt2`	124 M	"the capital of the French Republic, and the capital of the"	não
`gpt2-medium`	355 M	"Paris, and the capital of France is Paris."	sim
`gpt2-large`	774 M	"the capital of France.\n\nThe capital of France is"	não
`gpt2-xl`	1558 M	"the city of Paris. It is the capital of France and"	sim

A escala não é monotônica

O large (774 M) errou uma pergunta que o medium (355 M) acertou. Isso contraria a intuição de que "mais parâmetros = melhor", e é um resultado real, reprodutível na sua máquina.

Duas coisas estão acontecendo. Primeiro, o greedy é uma medida frágil: ele pega a palavra mais provável e nunca mais volta atrás, então um empate quase-técnico no primeiro token decide tudo. Segundo — e mais importante — uma única amostra não mede capacidade. Para dizer algo sério sobre um modelo, é preciso medir uma distribuição sobre muitos exemplos. É exatamente isso que a perplexidade faz, e é o assunto da apostila 08.

Guarde isso como higiene mental: quando alguém te mostrar um print de um modelo acertando ou errando uma pergunta, você está vendo uma amostra de tamanho 1.

Então o que melhora de verdade?

Quando você mede direito, sobre muitos exemplos, três coisas melhoram de forma consistente com a escala:

Perplexidade. A medida de "o quanto o modelo se surpreende com texto real" cai de forma limpa e previsível. Você vai medir isso no lab 08.
Coerência de longo alcance. O small perde o fio em 2–3 frases; o XL sustenta um parágrafo. É o que o logit lens da apostila 05 sugeriu: o problema do small não é ignorar o fato, é não conseguir sustentá-lo até a saída.
Aprendizado em contexto (in-context learning). Esta é a capacidade genuinamente emergente: dar exemplos no prompt e o modelo seguir o padrão sem nenhum treino. Veja a medição abaixo.

A medição que mostra a escala com clareza

O mesmo prompt da tabela anterior, agora com três exemplos antes:

Portugal -> Lisbon
Japan -> Tokyo
Italy -> Rome
France ->

Probabilidade atribuída a `" Paris"` como próximo token, medida nesta máquina. Nenhum peso foi atualizado — a única diferença é o texto do prompt.
Modelo	Sem exemplos	Com 3 exemplos	Ganho	2º e 3º colocados
`gpt2`	0,032	0,385	12×	`" Marse"`, `" Nice"`
`gpt2-medium`	0,174	0,871	5×	`" Marse"`, `" Lyon"`
`gpt2-xl`	0,086	0,904	10×	`" Lyon"`, `" Nice"`

Olhe a última coluna. Os segundos colocados são Marselha, Lyon, Nice — outras cidades francesas. O modelo não apenas acertou: ele entendeu que a tarefa era "país → cidade daquele país" e passou a errar dentro da categoria certa. Isso é o padrão sendo capturado, não uma correspondência decorada.

E note: nenhum peso foi atualizado. A única diferença entre 3,2% e 38,5% foi o texto que veio antes da pergunta. Levada ao GPT-3 (175 bilhões de parâmetros), essa capacidade ficou tão forte que tornou o fine-tuning desnecessário para a maioria das tarefas — e é a razão pela qual "engenharia de prompt" virou uma disciplina.

E o que não melhora

Aritmética. A causa é o tokenizador (apostila 01), não o tamanho. Nenhum GPT-2 soma bem.
Factualidade confiável. Todos alucinam. O XL alucina com mais fluência, o que é pior, não melhor.
Português. O corpus era inglês. Escala não cria dados que não existiam.
Contexto. Continua 1024 tokens em todos — é o wpe, não a capacidade.

4 O custo de rodar, medido

Numa CPU comum de desktop, de 8 núcleos, em fp32 e sem GPU, medido na prática:

Modelo	RAM necessária	Carga do disco	Geração
`gpt2`	~0,6 GB	~1 s	~40 tok/s
`gpt2-medium`	~1,6 GB	~2 s	~15 tok/s
`gpt2-large`	~3,3 GB	~4 s	~7 tok/s
`gpt2-xl`	~6,5 GB	~8 s	~3 tok/s

A regra de bolso: fp32 custa 4 bytes por parâmetro. Um modelo de 1,5 B ocupa 6 GB só de pesos. É por isso que quantização existe — em 8 bits, o mesmo modelo cabe em 1,5 GB, e em 4 bits, em 800 MB. A qualidade cai pouco e o alcance prático muda completamente.

5 No laboratório

.venv\Scripts\python.exe lab\06_scale.py

Confere a arquitetura de cada modelo lendo o config.json real, e verifica a fórmula da contagem de parâmetros contra o número verdadeiro.
Roda o mesmo prompt nos cinco modelos, greedy, e mostra a tabela acima ao vivo na sua máquina.
Mede a probabilidade que cada modelo atribui à resposta certa — não só o que ele gerou. Isso é muito mais informativo que a amostra única: você vai ver que o large "quase" acertou.
Testa aprendizado em contexto com exemplos no prompt, comparando small e XL. É onde a escala aparece de forma mais clara.
Cronometra tudo e monta a tabela de custo da sua máquina.

Exercício 6 — preveja antes de rodar

Use a fórmula da seção 2 para calcular os parâmetros do gpt2-medium (L=24, d=1024). Compare com 355 M. De quanto você errou, e de onde vem a diferença?
O gpt2-xl tem 12,5× os parâmetros do gpt2. Ele gera 12,5× mais devagar? Meça e explique a diferença.
Se você tivesse que escolher UM modelo para usar nesta máquina no dia a dia, qual seria e por quê? Justifique com números, não com intuição.
Difícil: a fórmula tem o termo V·d (embedding) e o termo L·12d². Para qual valor de d os dois se igualam, com V=50257 e L=12? O que isso diz sobre modelos muito pequenos?

Referências

As fontes primárias dos conceitos deste capítulo. Os números do texto foram medidos no laboratório; as ideias vêm daqui.

Os termos técnicos têm aqui o sentido de aprendizado de máquina. O glossário do curso mostra esse sentido ao lado dos outros que as mesmas palavras têm na TI.

Radford, A., Wu, J., Child, R., Luan, D., Amodei, D. e Sutskever, I. (2019). Language Models are Unsupervised Multitask Learners. Relatório técnico, OpenAI. cdn.openai.com
Press, O. e Wolf, L. (2017). Using the Output Embedding to Improve Language Models. EACL 2017. arXiv:1608.05859
Xiong, R. et al. (2020). On Layer Normalization in the Transformer Architecture. ICML 2020. arXiv:2002.04745

O modelo produz uma distribuição de probabilidade sobre 50 257 tokens. Transformar isso em texto é uma decisão sua, não dele.
A apostila 07 mostra que essa decisão muda o resultado mais do que trocar de modelo.

GPT-2 de ponta a ponta,e o que a escala compra