Phase 10 - Lesson 14

Modelos Abertos: Análise Detalhada de Arquitetura

Você construiu um GPT-2 Small do zero na Lição 04. Os modelos abertos de fronteira em 2026 pertencem à mesma família, com cinco ou seis mudanças concretas. RMSNorm em vez de LayerNorm. SwiGLU em vez de GELU. RoPE em vez de posições aprendidas. GQA ou MLA em vez de MHA completo. Mixture-of-Experts em escala. A matemática que você já conhece cobre 95% deles. Esta lição lê Llama 3, DeepSeek-V3, Mixtral, Qwen e Gemma lado a lado e aponta a linha exata onde cada arquitetura diverge.

Tipo: Aprender Idiomas: Python (stdlib) Pré-requisitos: Fase 10, Lições 04, 05, 12 (Pré-treinamento, Escala, Inferência) Tempo: ~45 minutos

Objetivos de Aprendizado

• Ler o config.json do Llama 3, Mistral, Mixtral, Gemma 2, Qwen 2.5 e DeepSeek-V3 e explicar cada campo
• Nomear a mudança arquitetônica específica que cada modelo fez em relação ao GPT-2 Small e justificá-la a partir de princípios fundamentais
• Calcular a contagem de parâmetros, o tamanho do KV cache e a memória de ativação para qualquer modelo aberto a partir apenas de sua configuração
• Escolher o modelo aberto correto para um alvo de implantação dadas as restrições de latência, memória e capacidade

O Problema

Na Lição 04, você escreveu 350 linhas de numpy e obteve um modelo no formato do GPT-2. O Llama 3 405B possui um relatório técnico de 200 páginas. Seu instinto lhe diz que esses são monstros diferentes. Eles não são. As 200 páginas descrevem o mesmo objeto com com cinco ou seis modificações bem fundamentadas, além de milhares de detalhes de implementação sobre escala. O esqueleto — incorporação (embedding), blocos de transformer, atenção, MLP, normalização, cabeça (head) — permanece inalterado.

Esta lição é um diff. Para cada família principal de modelos abertos, listamos exatamente o que mudou em relação ao GPT-2, o porquê e qual foi o custo. Ao terminar, você poderá ler um novo card de modelo e traduzi-lo mentalmente de volta para a linha de base do GPT-2.

O retorno prático é que quando a Meta lançar o Llama 5 ou a DeepSeek lançar o V4, você não precisará de um novo modelo mental. Você olhará para a configuração, verá quais dos botões (knobs) conhecidos foram movidos e saberá quais são as implicações downstream. As arquiteturas de 2026 são uma caixa de ferramentas finita. Cada modelo novo escolhe um subconjunto diferente.

O Conceito

O Núcleo Invariante

Todos os modelos abertos autorregressivos compartilham:

• Matriz de incorporação de tokens (vocab_size x hidden_dim).
• Pilha de N blocos decodificadores: normalização, autoatenção, residual, normalização, MLP, residual.
• Normalização final e cabeça linear projetando para vocab_size (frequentemente com pesos compartilhados com as incorporações).
• Máscara causal, perda de entropia cruzada para o próximo token.

Essa é a estrutura. O resto são botões (knobs).

Os Seis Botões que Realmente Importam

Em todos os modelos abertos de fronteira de 2024 a 2026, as mesmas seis escolhas de design são feitas repetidamente:

1. Normalização. LayerNorm -> RMSNorm.
2. Codificação posicional. Absoluta aprendida -> RoPE (mais variantes: YaRN, NTK).
3. Ativação. GELU -> SwiGLU (ou GeGLU).
4. Compartilhamento de cabeças de atenção. MHA -> GQA -> MQA -> MLA.
5. MLP denso vs esparso. Denso -> Mixture-of-Experts.
6. Posicionamento da pré-normalização. A pré-normalização (pre-norm) permanece. A pós-normalização (post-norm) desapareceu.

Tudo o mais (cronograma de taxa de aprendizado, mix de dados, tamanho de lote, comprimento do contexto) vive na configuração de treinamento, não na arquitetura. Seis botões.

Knob 1: RMSNorm

A LayerNorm subtrai a média, divide pelo desvio padrão, escala e desloca. A RMSNorm mantém apenas a escala:

RMSNorm(x) = x / sqrt(mean(x^2) + eps) * gamma

Sem subtração de média. Sem viés (bias). Uma multiplicação de matriz (matmul) a menos por token. Zhang e Sennrich (2019) argumentaram que ela se iguala à LayerNorm em tradução automática, sendo 10% mais rápida. Todos os modelos abertos modernos a utilizam.

Custo: nenhum. Benefício: pequeno ganho de taxa de transferência (throughput), código mais simples.

Knob 2: RoPE

As incorporações de posição aprendidas eram uma tabela de busca de 1024 slots no GPT-2. O contexto 1025 fica fora da tabela. Os modelos não conseguem extrapolar além do comprimento de treinamento.

A Incorporação Posicional Rotativa (RoPE, Su et al. 2021) injeta posição rotacionando cada vetor Q e K em pares antes do produto escalar da atenção. O ângulo de rotação é uma função determinística da posição, portanto não há nada aprendido e nada para esgotar. Com truques de escala (interpolação sensível a NTK, YaRN), um modelo treinado com contexto de 8k pode se estender para 128k na inferência com perda modesta de precisão.

q_rotated = rotate(q, angle(pos))
k_rotated = rotate(k, angle(pos))
score = q_rotated . k_rotated

Todos os modelos Llama, Mistral, Qwen, DeepSeek e Gemma usam RoPE. O Gemma 2 usa uma abordagem híbrida (RoPE na maioria das camadas, atenção local com janela deslizante em outras).

Knob 3: SwiGLU

O MLP do GPT-2 é x -> gelu(xW1 + b1) -> (...)W2 + b2. O SwiGLU (Shazeer 2020) substitui a ativação por um produto controlado (gated product):

SwiGLU(x) = (xW1) * sigmoid(xW1) * xV

Duas projeções em paralelo em vez de uma, controladas pela ativação Swish. Empiricamente mais robusto em perplexidade por parâmetro. O Llama 2 o adotou, e todos o seguiram. O tamanho oculto (hidden size) do MLP é geralmente definido de modo que a contagem total de parâmetros corresponda ao MLP denso original: se o GPT-2 usava ff_dim = 4 * hidden, o SwiGLU usa ff_dim = (2/3) * 4 * hidden = 8/3 * hidden.

Knob 4: Compartilhamento de Cabeças de Atenção

O GPT-2 usava Multi-Head Attention (MHA): cada cabeça possui sua própria projeção Q, K, V.

Multi-Query Attention (MQA, Shazeer 2019) compartilha uma chave (K) e um valor (V) entre todas as cabeças. Reduz o KV cache pela quantidade de cabeças (num_heads), o que representa uma redução de 12x a 32x em um modelo típico. A precisão cai ligeiramente em benchmarks difíceis.

Grouped-Query Attention (GQA, Ainslie et al. 2023) é o meio-termo: G grupos de cabeças Q compartilham uma chave (K) e um valor (V). O Llama 3 8B usa GQA com 32 cabeças Q e 8 cabeças KV (G=8), de modo que o KV cache encolhe 4x em relação ao MHA completo.

Multi-Head Latent Attention (MLA, DeepSeek 2024) comprime K e V em um espaço latente compartilhado de baixo posto (low-rank), projetando-os de volta por cabeça. Reduz ainda mais o KV cache enquanto preserva a expressividade de cada cabeça. O DeepSeek-V2 e V3 dependem disso para seu desempenho em contextos longos.

Para qualquer modelo acima de ~13B parâmetros, o uso de GQA ou MLA é efetivamente obrigatório. O MHA completo em grande escala é um desastre para o tamanho do KV cache.

Knob 5: Mixture of Experts

Um MLP denso ativa todos os seus parâmetros para cada token. Um MLP MoE possui K especialistas por bloco e um roteador que escolhe os melhores $k$ especialistas por token (normalmente top-2). Apenas os pesos desses especialistas passam por uma etapa de propagação direta (forward pass) para aquele token.

router_logits = xW_r
indices, weights = top_k(router_logits, k=2)
output = sum_i weights[i] * expert[indices[i]](x)

O atrativo: você pode ver 64 especialistas com tamanho de 7B cada (de modo que a contagem total de parâmetros é enorme) enquanto executa apenas 2 deles por token (de modo que a computação por token corresponde a um modelo denso de 7B). O Mixtral 8x7B possui 47B parâmetros totais, mas ativa apenas 13B por token. O DeepSeek-V3 possui 671B parâmetros totais, mas ativa apenas 37B por token.

graph LR
    I["Token hidden state"] --> R["Router\n(linear -> softmax)"]
    R --> T["Top-k selection"]
    T --> E1["Expert 1\n(MLP)"]
    T --> E2["Expert 2\n(MLP)"]
    T --> EN["Expert 64\n(MLP, unused)"]
    E1 --> S["Weighted sum"]
    E2 --> S
    S --> O["Output"]

    style EN fill:#eeeeee,stroke:#999,color:#999
    style E1 fill:#1a1a2e,stroke:#51cf66,color:#fff
    style E2 fill:#1a1a2e,stroke:#51cf66,color:#fff
    style R fill:#1a1a2e,stroke:#e94560,color:#fff

Prós: mesma computação, mais parâmetros, melhor capacidade. Contras: a memória dos especialistas ainda precisa estar armazenada em algum lugar (portanto, a hospedagem exige mais VRAM do que um equivalente denso), balancear a carga do roteador é difícil e refinar o roteador durante o alinhamento é uma área de pesquisa à parte.

Knob 6: A Pré-normalização Permanece

O transformer original aplicava a normalização de camada após cada subcamada. Todos os modelos abertos desde o GPT-2 a colocam antes de cada subcamada. A pré-normalização é estritamente mais fácil de treinar em profundidade. Não há o que discutir aqui.

Diff Modelo a Modelo

Aqui está a tabela que torna tudo isso concreto.

Examine as colunas. RMSNorm é universal. SwiGLU ou seu equivalente GeGLU é universal. RoPE é universal. GQA é universal acima de 7B, exceto quando substituído por MLA. MoE é o diferencial na extremidade superior.

Lendo um config.json

Configuração do Llama 3 8B:

{
  "hidden_size": 4096,
  "intermediate_size": 14336,
  "num_hidden_layers": 32,
  "num_attention_heads": 32,
  "num_key_value_heads": 8,
  "max_position_embeddings": 131072,
  "rope_theta": 500000.0,
  "rms_norm_eps": 1e-5,
  "vocab_size": 128256
}

Cada campo corresponde a algo que você já implementou.

• hidden_size: dimensão de incorporação (embedding).
• intermediate_size: tamanho oculto do MLP (3,5x o tamanho oculto — matemática do SwiGLU).
• num_hidden_layers: profundidade da pilha.
• num_attention_heads: cabeças Q.
• num_key_value_heads: cabeças KV (GQA).
• max_position_embeddings: comprimento do contexto de treinamento.
• rope_theta: frequência base do RoPE. A Meta o escalou do padrão de 10k para 500k para extrapolação de contexto longo.
• rms_norm_eps: estabilidade numérica.
• vocab_size: tokens.

A partir apenas disso você calcula os parâmetros totais, o KV cache e o pico de memória de ativação. Veja code/main.py para as fórmulas exatas.

Orçamento de memória de ativação

As ativações dominam a memória de treinamento acima de alguns bilhões de parâmetros. A regra geral para o pré-treinamento (com checkpointing de gradiente):

activation_mem ~ batch_size * seq_len * hidden_size * num_layers * bytes_per_element

Para o Llama 3 8B com lote (batch) 1, sequência 8192, BF16, 32 camadas, hidden 4096: cerca de 8 GB apenas para ativações com checkpointing, 40 GB sem. É por isso que flash-attention e ring-attention são importantes — eles reescrevem o cálculo da atenção para que as ativações caibam.

Orçamento do KV Cache

Para inferência no contexto máximo:

kv_cache = 2 * num_layers * num_kv_heads * head_dim * max_seq_len * bytes_per_element

Llama 3 8B com contexto de 128k, BF16, head_dim = hidden / num_heads = 128: 2 * 32 * 8 * 128 * 131072 * 2 = 17.2 GB por sequência.

Os pesos do modelo 8B ocupam 16 GB em BF16. O KV cache para uma única sequência de 128k é maior do que os pesos. Essa é a pressão de memória que impulsiona as pesquisas em GQA, MLA e quantização de KV cache.

Quando Cada Modelo Vence

• Uma única GPU de 80GB, sem MoE: Llama 3 8B, Mistral 7B, Gemma 2 9B. Fácil de servir, ampla gama de ferramentas.
• Nó único (8x80GB), grande capacidade: Llama 3 70B, Qwen 2.5 72B. Maior capacidade densa de código aberto.
• Maior capacidade aberta, aceitando complexidade de MoE: DeepSeek V3, Mixtral 8x22B. Melhor capacidade por FLOP ativo.
• Necessidades de contexto longo: Llama 3 (128k com escala RoPE), DeepSeek (vantagem do MLA).
• Serviço de baixa latência: Gemma 2 9B (a janela deslizante reduz a computação em contexto longo).

Construa

O código da lição é uma calculadora. Dada qualquer configuração config.json, ele imprime a contagem de parâmetros por componente, o KV cache no contexto máximo, a proporção SwiGLU MLP e um veredito curto sobre a arquitetura (denso / GQA / MLA / MoE).

config = {
    "hidden_size": 4096, "intermediate_size": 14336,
    "num_hidden_layers": 32, "num_attention_heads": 32,
    "num_key_value_heads": 8, "vocab_size": 128256,
    "max_position_embeddings": 131072,
}

O script percorre a arquitetura campo a campo, calcula a contagem de parâmetros para incorporação, atenção (com redução GQA), MLP (com expansão SwiGLU), layernorms e a cabeça final. Em seguida, calcula o KV cache no comprimento de contexto indicado e imprime um resumo.

Veja code/main.py para a implementação.

Use

Execute a calculadora nas configurações do Llama 3 8B, Mistral 7B, Mixtral 8x7B e DeepSeek V3 incluídas no script. Compare as divisões de parâmetros. Observe que os modelos MoE possuem uma contagem total de parâmetros que deixa os modelos densos para trás, mas uma contagem de parâmetros ativos que costuma ser menor. Observe que o KV cache do DeepSeek V3 é menor do que o do Llama 3 405B, apesar de ter mais parâmetros totais — isso é o MLA em ação.

Depois, insira a configuração de qualquer modelo que você tenha localmente, leia o resumo e decida se ele cabe na sua GPU.

Envie

Esta lição produz outputs/skill-open-model-picker.md. Dado um alvo de implantação (tipo de GPU, VRAM, comprimento de contexto, orçamento de latência) e um perfil de tarefa (chat, código, raciocínio, contexto longo), ela recomenda um modelo aberto, um esquema de quantização da Lição 11 e uma pilha de inferência da Lição 12, com raciocínio explícito sobre os seis botões arquitetônicos.

Exercícios

1. Leia a configuração do Qwen 2.5 72B no HuggingFace. Calcule os parâmetros totais do zero. Compare com o valor reportado pelo HF e identifique de onde vem qualquer diferença (arredondamento da dimensão da cabeça, fator de compartilhamento de KV, etc.).

2. O DeepSeek V3 usa 256 especialistas com roteamento top-8. Calcule a proporção de especialistas ativados em relação ao total de especialistas e compare com o top-2 de 8 do Mixtral 8x7B. O que a mudança de esparso (25%) para esparso mais denso (3%) implica sobre a capacidade por FLOP?

3. Calcule o KV cache do Llama 3 405B com contexto de 128k em FP8 e BF16. Em FP8 ele é metade do valor em BF16. Quantas sequências paralelas você consegue servir em um único nó 8xH100 (80GB cada = 640GB no total, menos a memória dos pesos)?

4. O Gemma 2 alterna camadas de atenção total e atenção de janela deslizante. Escreva a matemática para o KV cache quando metade das camadas usa uma janela deslizante de 4096 tokens em vez do contexto completo. Quanta memória isso economiza em um contexto total de 8k?

5. Encontre um modelo aberto de fronteira recente que foi lançado após a escrita desta lição. Identifique quais dos seis botões ele escolheu e se introduziu um sétimo botão. O currículo parecerá desatualizado no momento em que uma nova arquitetura for lançada — o objetivo é atualizar sua tabela sem reconstruir seu modelo mental.

Termos-Chave

Leitura Adicional

• Dubey et al., 2024 -- "The Llama 3 Herd of Models" -- a referência arquitetônica e de treinamento para a família densa do Llama 3
• DeepSeek-AI, 2024 -- "DeepSeek-V3 Technical Report" -- MLA mais balanceamento de carga livre de perda auxiliar mais MoE de 671B
• Jiang et al., 2024 -- "Mixtral of Experts" -- o artigo canônico sobre modelo aberto MoE
• Su et al., 2021 -- "RoFormer: Enhanced Transformer with Rotary Position Embedding" -- o artigo do RoPE
• Shazeer, 2020 -- "GLU Variants Improve Transformer" -- SwiGLU, GeGLU e variantes
• Ainslie et al., 2023 -- "GQA: Training Generalized Multi-Query Transformer Models" -- o artigo do GQA
• Gemma 2 Team, 2024 -- "Gemma 2: Improving Open Language Models at a Practical Size" -- atenção híbrida total+deslizante, pré+pós-normalização
• Qwen Team, 2024 -- "Qwen 2.5 Technical Report" -- extensão de contexto YaRN e receitas de treinamento em contexto longo