Phase 07 - Lesson 01

Por que Transformers — Os problemas com RNNs

RNNs processam tokens um de cada vez. Transformers processam todos os tokens de uma só vez. Essa única aposta arquitetural mudou todas as curvas de escalonamento do deep learning depois de 2017.

Tipo: Aprender Linguagens: Python Pré-requisitos: Fase 3 (Núcleo de Deep Learning), Fase 5 · 09 (Sequence-to-Sequence), Fase 5 · 10 (Mecanismo de Atenção) Tempo: ~45 minutos

O Problema

Antes de 2017, todos os modelos de sequência estado da arte do planeta — linguagem, tradução, fala — eram redes neurais recorrentes. LSTMs e GRUs venceram benchmarks de tradução equivalentes ao ImageNet por meia década. Eram a única ferramenta que qualquer um tinha.

Elas tinham três fraquezas fatais. Computação sequencial significava que você não podia paralelizar ao longo do eixo do tempo: o token t+1 precisa do estado oculto do token t. Uma sequência de 1.024 tokens significava 1.024 passos seriais em uma GPU capaz de fazer 1.000.000 de operações de ponto flutuante por ciclo. O tempo de relógio de treinamento escalava linearmente com o comprimento da sequência em hardware projetado para paralelismo.

Gradientes que desaparecem significavam que a informação 50 tokens atrás já estava comprimida através de 50 não-linearidades. Unidades recorrentes com portões (LSTM, GRU) amenizaram o esmagamento mas nunca o eliminaram. Dependências de longo alcance — "o livro que eu li no verão passado num avião para Kyoto era…" — falhavam rotineiramente.

Estados ocultos de largura fixa significavam que o encoder espremia toda a sequência de origem em um único vetor antes do decoder ver qualquer coisa. Não importa se a origem tem 5 tokens ou 500; o gargalo tem o mesmo formato.

O artigo de 2017 "Attention Is All You Need" propôs algo radical: abandonar a recorrência por completo. Deixar cada posição atender a todas as outras posições em paralelo. Treinar em uma grande multiplicação de matrizes em vez de 1.024 multiplicações sequenciais.

O resultado domina todas as modalidades até 2026. Linguagem (GPT-5, Claude 4, Llama 4), visão (ViT, DINOv2, SAM 3), áudio (Whisper), biologia (AlphaFold 3), robótica (RT-2). Mesmo bloco, entradas diferentes.

O Conceito

Recorrência como gargalo. Uma RNN computa h_t = f(h_{t-1}, x_t). Cada passo depende do anterior. Você não pode computar h_5 antes de h_4. Em GPUs modernas com mais de 10.000 núcleos paralelos, isso desperdiça 99% do silício em uma sequência longa.

Atenção como broadcast. A self-attention computa output_i = sum_j(a_ij * v_j) para cada par (i, j) simultaneamente. Toda a matriz de atenção N×N é preenchida em um único matmul em lote. Nenhum passo depende de outro. GPUs adoram isso.

O ganho de velocidade não é uma constante. É a diferença entre profundidade serial O(N) e profundidade serial O(1). Na prática, transformers treinam de 5 a 10× mais rápido por época em hardware equivalente com N=512, e a diferença aumenta com o comprimento da sequência até você bater na parede de memória O(N²) da atenção (que o Flash Attention depois resolveu — veja a Lição 12).

O que os transformers custam. A memória da atenção escala como O(N²). Para um contexto de 2K, tudo bem. Para um contexto de 128K, você precisa de janelas deslizantes, extrapolação RoPE, ladrilhamento (tiling) do Flash Attention ou variantes de atenção linear. A recorrência era O(N) tanto em tempo quanto em memória; transformers trocam tempo por memória e depois recuperam o tempo de volta através do paralelismo.

A mudança de viés indutivo. RNNs assumem localidade e proximidade temporal. Transformers não assumem nada — todo par é um candidato à atenção. É por isso que transformers precisam de mais dados para treinar bem mas escalam mais longe quando os têm. O Chinchilla (2022) formalizou isso: dado tokens suficientes, um transformer sempre vence uma RNN com a mesma contagem de parâmetros.

Construa

Não há rede neural aqui — simulamos o gargalo central numericamente para você sentir a diferença no seu laptop.

Passo 1: medir a profundidade serial

Veja code/main.py. Construímos duas funções. Uma codifica uma sequência como uma cadeia de adições (serial, como uma RNN). A outra a codifica como uma redução paralela (broadcast, como atenção). Mesma matemática, grafo de dependência diferente.

def rnn_style(xs):
    h = 0.0
    for x in xs:
        h = 0.9 * h + x   # can't parallelize: h depends on previous h
    return h

def attention_style(xs):
    return sum(xs) / len(xs)  # every x is independent

Cronometramos ambas em sequências de até 100.000 elementos. A versão RNN é O(N) e um único pipeline de CPU. Mesmo em Python puro, a redução no estilo atenção a supera em comprimento ≥ 1.000 porque o sum() do Python é implementado em C e itera sem sobrecarga do interpretador por passo.

Passo 2: contar operações teóricas

Ambos os algoritmos fazem N adições. A diferença é a profundidade de dependência: quantas operações precisam acontecer sequencialmente antes que a próxima possa começar. Profundidade da RNN = N. Profundidade da atenção = log(N) com uma redução em árvore, ou 1 com um scan paralelo. A profundidade, não a contagem de operações, decide o tempo de GPU.

Passo 3: escalonamento empírico em sequências longas

Imprimimos uma tabela de tempos que torna o gap O(N) visível. Em um laptop Mac de 2026, sequências com menos de 1.000 elementos são rápidas demais para medir. Sequências de 100.000 mostram um scan linear limpo. Escale isso para um transformer de 16.384 tokens com um LSTM equivalente de 12 camadas e você vê por que o tempo de relógio de treinamento era um obstáculo em 2016.

Use

Quando ainda escolher uma RNN em 2026:

Modelos de espaço de estados (SSMs) como o Mamba são essencialmente RNNs com parametrização estruturada que lhes dá o melhor dos dois mundos: memória de scan O(N), treinamento paralelo via scan seletivo. Eles recuperam 90% da qualidade do transformer com melhor escalonamento para contexto longo. Em 2026, a maioria dos laboratórios de fronteira treina modelos híbridos SSM+transformer (por exemplo Jamba, Samba) — a recorrência não está morta, é um componente.

Entregue

Veja outputs/skill-architecture-picker.md. A skill escolhe uma arquitetura para um novo problema de sequência dadas restrições de comprimento, throughput e orçamento de treinamento. Ela deve sempre se recusar a recomendar uma RNN pura para execuções de treinamento acima de 1B tokens sem declarar o trade-off.

Exercícios

1. Fácil. Pegue o rnn_style de code/main.py e substitua o estado oculto escalar por um vetor de comprimento 64 de estados ocultos. Remeça. Quanto a sobrecarga serial cresce com a dimensão do estado oculto?
2. Médio. Implemente uma soma de prefixos paralela (scan de Hillis-Steele) em Python puro. Verifique que ela produz a mesma saída numérica de um scan serial em comprimento 1024. Conte a profundidade.
3. Difícil. Porte a redução no estilo atenção para PyTorch na GPU. Cronometre ambas conforme você varre o comprimento da sequência de 64 a 65.536. Plote e explique o formato da curva.

Termos-chave

Leitura Adicional

• Vaswani et al. (2017). Attention Is All You Need — o artigo que matou a recorrência no NLP mainstream.
• Bahdanau, Cho, Bengio (2014). Neural MT by Jointly Learning to Align and Translate — onde a atenção nasceu, acoplada a uma RNN.
• Hochreiter, Schmidhuber (1997). Long Short-Term Memory — o artigo original do LSTM, para registro.
• Gu, Dao (2023). Mamba: Linear-Time Sequence Modeling with Selective State Spaces — a resposta recorrente moderna aos transformers.