Encoder vs decoder:
o confronto

1 A linha

Chegamos ao ponto que o curso vinha preparando desde a apostila 00. Aqui está, na íntegra, a diferença arquitetural entre o GPT-2 e o RoBERTa:

if causal:
    att = att.masked_fill(futuro, float("-inf"))

É isso. Tudo o mais é igual ou quase igual: o mesmo bloco Transformer, a mesma equação de atenção, o mesmo algoritmo de tokenização (byte-level BPE), a mesma GELU, o mesmo LayerNorm, tamanhos praticamente idênticos (124 M vs 125 M, ambos com 12 camadas, 768 dimensões e 12 cabeças).

O gpt2 e o roberta-base são gêmeos estruturais que fazem coisas opostas. É o experimento controlado perfeito, e é por isso que estudá-los juntos ensina mais do que estudar qualquer um dos dois sozinho.

2 A prova experimental

Isto não é argumento — é medição. No lab 04 você roda duas frases idênticas até a metade e diferentes no fim, e mede o quanto a representação de cada posição mudou:

A: "The cat sat on the mat and slept   peacefully all afternoon"
B: "The cat sat on the mat and screamed furiously  all afternoon"
                                 ^^^^^^^^^^^^^^^^ so isto muda

GPT-2 (causal)                    RoBERTa (bidirecional)
 pos token      |dif|              pos token      |dif|
   0 'The'    0.00e+00               0 '<s>'     3.31e-01
   1 'cat'    0.00e+00               1 'The'     3.66e-01
   2 'sat'    0.00e+00               2 'cat'     2.88e-01
   3 'on'     0.00e+00               3 'sat'     3.91e-01
   4 'the'    0.00e+00               4 'on'      3.40e-01
   5 'mat'    0.00e+00               5 'the'     3.01e-01
   6 'and'    0.00e+00               6 'mat'     2.59e-01
   7 'slept'  7.86e+00  <- muda      7 'and'     3.36e-01
   8 ...      1.30e+01               8 'slept'   3.97e-01
                                     ...
                                    12 '</s>'    3.27e-01

ZERO ate a palavra trocada.        TUDO muda, inclusive o <s>.
O passado e intocavel.             Uma palavra reescreve a frase.

Não é aproximadamente zero. É exatamente 0,00e+00, bit a bit. O futuro não existe para o passado num modelo causal. E no RoBERTa, trocar uma palavra no fim altera até o token de abertura.

3 A árvore de consequências

Tudo o que segue desce daquela linha. Acompanhe a cadeia:

Ramo A — o decoder

1. A máscara impede ver o futuro.
2. → Logo, prever o próximo token é uma tarefa legítima, sem vazamento.
3. → Logo, todas as n posições geram sinal de treino. Eficiência máxima.
4. → Logo, o modelo aprende P(próximo | anteriores), que é exatamente o que se precisa para gerar.
5. → Logo, o passado nunca muda quando se acrescenta um token.
6. → Logo, o cache KV é possível, e a geração cai de O(n²) para O(n) por token.
7. → Logo, escalar é viável, e a escala trouxe o in-context learning.

Ramo B — o encoder

1. Sem máscara, cada token vê a frase inteira.
2. → Logo, prever o próximo token seria copiar. Objetivo inviável.
3. → Logo, é preciso outro objetivo: MLM, mascarar palavras sorteadas.
4. → Logo, só 15% das posições geram sinal. 85% do cômputo é desperdiçado.
5. → Logo, o treino é menos eficiente por token processado.
6. → Mas cada representação é construída com contexto dos dois lados, e é mais rica para compreender.
7. → E acrescentar um token muda tudo, então não há nada estável para cachear. Geração autoregressiva é impossível.

4 A tabela de decisão prática

5 A terceira família: encoder-decoder

Existe um terceiro arranjo, que vale conhecer para completar o mapa. O Transformer original de 2017 era assim, e o T5 e o BART seguem o mesmo desenho:

• Um encoder bidirecional lê a entrada inteira e produz representações ricas.
• Um decoder causal gera a saída token a token, com uma peça extra: cross-attention, onde as queries vêm do decoder e as keys e values vêm do encoder.

É o melhor dos dois mundos, ao custo de aproximadamente o dobro do modelo. Ideal quando entrada e saída são objetos distintos — traduzir do português para o inglês, resumir um artigo. Menos útil para diálogo aberto, onde a "entrada" e a "saída" são o mesmo fluxo de conversa contínuo — o que ajuda a explicar por que o mundo dos assistentes convergiu para decoders puros.

6 A linhagem, em uma página

                    Transformer (2017)
                    encoder + decoder
                           |
              +------------+------------+
              |                         |
        so o DECODER              so o ENCODER
     (com mascara causal)      (sem mascara causal)
              |                         |
         GPT-1 (2018)             BERT (2018)
         117M, BooksCorpus        MLM + NSP, WordPiece
              |                         |
         GPT-2 (2019)             RoBERTa (2019)
         124M-1.5B, WebText       MLM dinamico, sem NSP,
         Pre-LN, BPE de byte      BPE de byte do GPT-2, 160GB
              |                         |
         GPT-3 (2020)                   +--> roberta-*-openai-detector
         175B, few-shot                      classificador binario
              |                             treinado nas saidas do GPT-2
         InstructGPT / ChatGPT                        ^
         fine-tuning + RLHF                           |
              |                                       |
         LLMs modernos  -------- gera o texto --------+
                                que o detector julga

Repare no fecho do desenho: os dois galhos, separados em 2018 por uma linha de código, se reencontram no detector. A OpenAI construiu o caçador com a arquitetura oposta à da caça. É a apostila 12.

7 No laboratório

.venv\Scripts\python.exe lab\04_multihead_mask.py   (seção 3 — a prova)
.venv\Scripts\python.exe lab\10_roberta_mlm.py         (a comparação)

A apostila 12 fecha a Parte III com o modelo mais curioso da coleção: o detector.
E ele traz uma resposta desconfortável para a pergunta 3 do Exercício 0.