O bloco Transformer
completo

1 O que falta na atenção

A atenção resolve o transporte de informação: ela move conteúdo de uma posição para outra. Mas repare no que ela é, matematicamente: uma média ponderada de vetores V. Isto é, uma combinação linear.

E aí está o problema. Empilhar operações lineares não adianta nada: a composição de duas transformações lineares é outra transformação linear. Cem camadas de atenção pura teriam exatamente a mesma expressividade de uma camada só. Você não ganharia nada empilhando.

Precisamos de não-linearidade. E precisamos de um lugar onde o modelo possa processar a informação que a atenção trouxe, em vez de só transportá-la. Esse lugar é o MLP.

2 Peça 1 — o MLP (onde mora o conhecimento)

O MLP é surpreendentemente simples: duas camadas lineares com uma não-linearidade no meio.

A forma é característica: expande, processa, contrai. Por que expandir para 3072 antes de voltar? Porque o espaço largo dá room para o modelo separar padrões que estão emaranhados em 768 dimensões — é o mesmo princípio de um kernel em SVM. A camada larga é onde os conceitos ficam linearmente separáveis.

A conta que assusta

O MLP tem duas vezes mais parâmetros que a atenção em cada bloco:

A não-linearidade: GELU, não ReLU

O GPT-2 usa GELU (Gaussian Error Linear Unit). A diferença para a ReLU clássica importa:

Leia a GELU como uma porta probabilística: em vez de cortar bruscamente em zero, ela multiplica a entrada pela probabilidade dela "merecer passar". Valores muito negativos são quase zerados, valores muito positivos passam quase intactos, e no meio há uma transição suave.

Duas vantagens concretas sobre a ReLU:

• É diferenciável em toda parte. A ReLU tem um bico em x=0. Gradientes gostam de curvas suaves.
• Não mata neurônios. Na ReLU, um neurônio que caiu em região negativa recebe gradiente exatamente 0 e pode nunca mais se recuperar (o problema do "dying ReLU"). A GELU sempre deixa passar um fiapo de gradiente.

O GPT-2 usa, na prática, uma aproximação por tangente hiperbólica da GELU — mais barata de calcular e numericamente idêntica para os fins do modelo.

3 Peça 2 — a conexão residual (a mais importante)

Se você só puder guardar uma coisa desta apostila, guarde esta. A conexão residual é o que torna redes profundas treináveis, e ela é ridiculamente simples:

Por que isso salva o treino

Numa rede profunda sem residual, o gradiente precisa atravessar todas as camadas por multiplicação sucessiva. Se cada camada multiplica o gradiente por, digamos, 0,9, então depois de 48 camadas sobra 0,9⁴⁸ ≈ 0,006 — o gradiente desapareceu. As primeiras camadas nunca aprendem. Esse é o problema clássico do vanishing gradient, que travou o aprendizado profundo por anos.

Com a residual, a derivada da soma é:

A leitura conceitual: o fluxo residual

Há um jeito melhor de enxergar isso, e ele mudou a forma como as pessoas pensam sobre Transformers. Em vez de "camadas que transformam", pense num quadro-negro compartilhado de 768 dimensões que atravessa o modelo inteiro do começo ao fim.

• O embedding escreve a informação inicial no quadro.
• Cada bloco lê o quadro, pensa, e acrescenta sua contribuição.
• Nenhum bloco apaga o que estava lá — a soma só adiciona.
• No fim, o quadro é lido para produzir a previsão.

Esse quadro é chamado de residual stream. É o conceito central da interpretabilidade moderna de Transformers, e explica por que dá para "ler" o que o modelo está pensando nas camadas intermediárias — a informação está literalmente acumulada ali, disponível.

4 Peça 3 — LayerNorm (e a mudança do GPT-1 para o GPT-2)

Conforme os vetores atravessam dezenas de blocos somando contribuições, suas magnitudes tendem a crescer descontroladamente. O LayerNorm renormaliza:

A mudança que define o GPT-2: Pre-LN

Esta é a alteração arquitetural mais importante entre GPT-1 e GPT-2, e ela é só uma questão de onde colocar o LayerNorm.

Essa mudança sozinha é o que permitiu o GPT-2 XL ter 48 camadas. Com Post-LN, treinar 48 camadas seria uma batalha de estabilidade numérica. Depois dele, a normalização antes da atenção virou a escolha padrão dos Transformers grandes, muitas vezes na forma do RMSNorm.

O GPT-2 também acrescenta um LayerNorm final (chamado ln_f) depois do último bloco, antes de projetar para os logits — necessário justamente porque, com Pre-LN, a saída do último bloco nunca passou por uma normalização.

5 O bloco montado

class Bloco(nn.Module):
    def __init__(self, d=768, h=12):
        super().__init__()
        self.ln_1 = nn.LayerNorm(d)
        self.attn = AtencaoMultiCabeca(d, h, causal=True)
        self.ln_2 = nn.LayerNorm(d)
        self.mlp  = nn.Sequential(
            nn.Linear(d, 4 * d),   # c_fc  : expande 768 -> 3072
            nn.GELU(),
            nn.Linear(4 * d, d),   # c_proj: contrai 3072 -> 768
        )

    def forward(self, x):
        # comunicacao: os tokens conversam
        x = x + self.attn(self.ln_1(x))
        # computacao: cada token pensa sozinho
        x = x + self.mlp(self.ln_2(x))
        return x

Duas linhas no forward. Repare que x = x + … nas duas: o x original nunca é destruído, só acrescido. É o quadro-negro sendo preenchido.

O fluxo dentro de um bloco (5 tokens, GPT-2 small):

x            (5, 768) ---------------------------+  guarda a copia
  ln_1       (5, 768)                            |
  attn       (5, 768)                            |
                                                 v
x = x + attn(ln_1(x))                        (5, 768)  <- soma
  |
  +----------------------------------------------+
  ln_2       (5, 768)                            |
  c_fc       (5, 3072)  <- expande 4x            |
  GELU       (5, 3072)  <- nao-linearidade       |
  c_proj     (5, 768)   <- contrai               |
                                                 v
x = x + mlp(ln_2(x))                         (5, 768)  <- soma

FORMA DE ENTRADA = FORMA DE SAIDA. Por isso da para empilhar
12, 24, 36 ou 48 desses sem mudar mais nada.

6 No laboratório

.venv\Scripts\python.exe lab\05_block.py

1. Monta um bloco do zero e confirma que a forma entra e sai igual.
2. Compara Pre-LN e Post-LN numa pilha de 40 camadas, medindo a norma do gradiente que chega na primeira camada. O Post-LN some; o Pre-LN sobrevive. É a demonstração do porquê da mudança.
3. Mede o crescimento do fluxo residual camada a camada no GPT-2 real. Você vai ver a norma crescer de forma quase monotônica — o quadro-negro sendo preenchido.
4. Lê o quadro-negro no meio do caminho — a técnica chamada logit lens. Veja a caixa abaixo: este é o experimento mais surpreendente da apostila.
5. Contabiliza os parâmetros de um bloco real, peça por peça, confirmando que o MLP leva dois terços.
6. Desenha a GELU contra a ReLU em ASCII, para você ver a diferença na região crítica perto de zero.

Você agora conhece todas as peças. A apostila 06 as monta no GPT-2 completo
e mostra o que realmente muda quando se vai de 124 milhões para 1,5 bilhão de parâmetros.