Capítulo 2: História - Dos RNNs aos Transformers

Introdução

A jornada até os Large Language Models modernos abrange décadas de pesquisa em redes neurais e processamento de linguagem natural. Compreender essa história nos ajuda a entender por que a arquitetura Transformer foi uma inovação tão importante.

Era Pré-Neural (1950-2000)

Sistemas Baseados em Regras

Os primeiros sistemas de PLN dependiam de regras feitas manualmente:

IF input contains "weather" AND "tomorrow"
THEN search weather database for tomorrow
RETURN formatted weather response

Limitações:

• Não lidavam bem com a variabilidade da linguagem
• Exigiam muita engenharia manual
• Baixa capacidade de generalização

Modelos Estatísticos de Linguagem

A abordagem estatística modelava a linguagem como distribuições de probabilidade:

$$P(w_1, w_2, ..., w_n) = \prod_{i=1}^{n} P(w_i | w_1, ..., w_{i-1})$$

Modelos N-gram:

# Exemplo de modelo bigrama
bigram_counts = {
    ("the", "cat"): 100,
    ("the", "dog"): 80,
    ("cat", "sat"): 50,
}

# P("cat" | "the") = count("the cat") / count("the")

Limitações:

• Escassez de dados para contextos longos
• Sem compreensão semântica
• Vocabulário fixo

A Revolução Neural (2000-2017)

Modelos de Linguagem Neurais Feed-Forward (2003)

Bengio et al. introduziram modelos neurais de linguagem:

[w_{t-3}] [w_{t-2}] [w_{t-1}]
    ↓         ↓         ↓
[Embedding] [Embedding] [Embedding]
         ↘     ↓     ↙
        [Hidden Layer]
              ↓
        [Softmax Output]
              ↓
           P(w_t)

Inovação principal: Representações distribuídas aprendidas (embeddings)

Redes Neurais Recorrentes (RNNs)

As RNNs trouxeram o conceito de memória por meio da recorrência:

class SimpleRNN:
    def forward(self, x, h_prev):
        """
        x: current input
        h_prev: previous hidden state
        """
        h_new = tanh(W_xh @ x + W_hh @ h_prev + b)
        return h_new

Arquitetura:

h_0 → [RNN] → h_1 → [RNN] → h_2 → [RNN] → h_3
        ↑            ↑            ↑
       x_1          x_2          x_3

Problemas:

• Gradientes Desvanecentes: Sinais diminuem em sequências longas
• Processamento Sequencial: Não permite paralelização do treinamento

Long Short-Term Memory (LSTM) - 1997

Hochreiter & Schmidhuber criaram as LSTMs para resolver o problema dos gradientes desvanecentes:

class LSTMCell:
    def forward(self, x, h_prev, c_prev):
        # Forget gate
        f = sigmoid(W_f @ [h_prev, x] + b_f)
        
        # Input gate
        i = sigmoid(W_i @ [h_prev, x] + b_i)
        
        # Candidate values
        c_tilde = tanh(W_c @ [h_prev, x] + b_c)
        
        # Update cell state
        c = f * c_prev + i * c_tilde
        
        # Output gate
        o = sigmoid(W_o @ [h_prev, x] + b_o)
        h = o * tanh(c)
        
        return h, c

Componentes principais:

Porta	Finalidade
Forget Gate	O que remover da memória
Input Gate	Que nova informação armazenar
Output Gate	O que emitir da memória

Sequence-to-Sequence (2014)

Sutskever et al. introduziram arquiteturas encoder-decoder:

Encoder:                    Decoder:
"Hello world" → [LSTM] → Context Vector → [LSTM] → "Bonjour monde"

Limitação: Gargalo do vetor de contexto único

Mecanismo de Atenção (2014-2015)

Bahdanau et al. introduziram o mecanismo de atenção para resolver o gargalo:

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

def attention(query, keys, values):
    """
    query: o que estamos procurando
    keys: o que cada posição oferece
    values: conteúdo real em cada posição
    """
    scores = query @ keys.T / sqrt(d_k)
    weights = softmax(scores)
    output = weights @ values
    return output

Principal insight: Permitir que o modelo aprenda quais partes da entrada são relevantes para cada saída.

A Revolução dos Transformers (2017)

"Attention Is All You Need"

Vaswani et al. propuseram remover totalmente a recorrência:

Key Paper

"Attention Is All You Need" (2017)

• Autores: Vaswani, Shazeer, Parmar, Uszkoreit, Jones, Gomez, Kaiser, Polosukhin
• Introduziu a arquitetura Transformer
• Permitiu paralelização massiva
• Base de todos os LLMs modernos

Visão Geral da Arquitetura Transformer

Input Tokens
     ↓
[Embedding + Positional Encoding]
     ↓
┌─────────────────────────────┐
│   Multi-Head Attention      │
│         ↓                   │
│   Add & Normalize           │
│         ↓                   │
│   Feed-Forward Network      │
│         ↓                   │
│   Add & Normalize           │
└─────────────────────────────┘ × N layers
     ↓
Output Probabilities

Por que os Transformers venceram

Recurso	RNN/LSTM	Transformer
Paralelização	Sequencial	Totalmente paralelo
Dependências de longo alcance	Difícil	Atenção direta
Velocidade de treinamento	Lenta	Rápida
Escalabilidade	Limitada	Excelente

A Era GPT (2018-presente)

GPT-1 (2018)

O primeiro "Generative Pre-trained Transformer" da OpenAI:

• 117M parâmetros
• Paradigma de pré-treinamento + fine-tuning
• Arquitetura apenas de decodificador

# Arquitetura GPT-1 (simplificada)
class GPT1:
    def __init__(self):
        self.layers = 12
        self.heads = 12
        self.d_model = 768
        self.vocab_size = 40478

BERT (2018)

Abordagem bidirecional do Google:

• 340M parâmetros (BERT-Large)
• Arquitetura apenas de codificador
• Modelagem de linguagem mascarada

# Objetivo de pré-treinamento do BERT
def masked_lm_loss(input_ids, model):
    # Mascara aleatoriamente 15% dos tokens
    masked_input = mask_tokens(input_ids, mask_prob=0.15)
    
    # Prediz os tokens originais
    predictions = model(masked_input)
    
    # Perda apenas nas posições mascaradas
    return cross_entropy(predictions[masked_positions], 
                        input_ids[masked_positions])

GPT-2 (2019)

Escalando e demonstrando capacidades emergentes:

• 1,5B parâmetros
• Desempenho zero-shot em tarefas
• Inicialmente retido devido a preocupações de uso indevido

GPT-3 (2020)

A escala que mudou tudo:

• 175B parâmetros
• Aprendizagem em contexto
• Prompting few-shot

# Escala do GPT-3
gpt3_config = {
    "n_params": 175_000_000_000,
    "n_layers": 96,
    "d_model": 12288,
    "n_heads": 96,
    "context_length": 2048,
}

Era Moderna (2022-presente)

Modelo	Ano	Parâmetros	Inovação Principal
ChatGPT	2022	~175B	RLHF para alinhamento
GPT-4	2023	~1,8T*	Multimodal, MoE*
Claude 2/3	2023-24	Desconhecido	Constitutional AI
Llama 2	2023	7B-70B	Pesos abertos
Mistral	2023	7B	Arquitetura eficiente

*Estimativa/não confirmado

Visualização da Linha do Tempo

Por que a História Importa

Compreender essa evolução nos ajuda a:

1. Valorizar decisões de design nas arquiteturas modernas
2. Reconhecer padrões que levam a avanços
3. Antecipar direções futuras com base nas tendências
4. Depurar e aprimorar sistemas atuais

Principais Lições

Summary

1. RNNs introduziram o modelamento de sequências, mas não permitiam paralelização
2. LSTMs resolveram gradientes desvanecentes, mas continuaram sequenciais
3. Atenção permitiu foco em entradas relevantes
4. Transformers eliminaram a recorrência, permitindo escala massiva
5. Escala provou ser ingrediente chave para o surgimento de capacidades

Olhando para Frente

No próximo capítulo, vamos explorar o cenário atual dos Large Language Models, conhecendo os principais players, seus modelos e o debate contínuo entre abordagens open-source e proprietárias.

---

← Capítulo 1: O que são LLMs?

Capítulo 3: Panorama dos LLMs →