Transformers

Visão geral

Transformadores (Transformers) são uma família de arquiteturas de aprendizado profundo (deep learning) construídas em torno de atenção (attention) — um mecanismo que permite que um modelo “foque” dinamicamente nas partes mais relevantes de uma entrada ao produzir uma saída. Desde o artigo de 2017 Attention Is All You Need, os transformadores se tornaram a arquitetura dominante para:

  • modelos de linguagem grandes (large language models, LLMs) (por exemplo, modelos somente decodificador no estilo GPT)
  • compreensão de texto baseada em codificador (por exemplo, modelos no estilo BERT)
  • sistemas de sequência a sequência (sequence-to-sequence) como tradução e sumarização
  • modelos multimodais (multimodal models) que combinam texto com imagens, áudio, vídeo ou ações

Em comparação com modelos de sequência anteriores como RNNs/LSTMs, os transformadores evitam em grande parte a recorrência sequencial, permitindo alto paralelismo durante o treinamento e uma forte escalabilidade com dados e computação. Em comparação com CNNs, os transformadores dependem menos de suposições fixas de localidade e, em vez disso, aprendem interações flexíveis e dependentes do conteúdo.

Em alto nível, um transformador processa tokens (tokens de texto, patches de imagem, quadros de áudio etc.) por meio de blocos de Transformador (Transformer blocks) repetidos, que misturam informações entre posições usando atenção e, em seguida, aplicam transformações não lineares por token usando redes feed-forward (feed-forward networks).

Por que a atenção importa

Muitos problemas em IA (AI) exigem modelar relações:

  • Na linguagem: resolução de pronomes (“it”), dependências de longo alcance, estrutura sintática
  • Em visão: relações objeto–objeto (por exemplo, “person holding cup”)
  • Em tarefas multimodais: alinhar palavras com regiões de imagem ou segmentos de áudio

A atenção fornece um caminho direto para o fluxo de informação entre qualquer par de posições, em vez de forçar a informação a passar passo a passo pelo tempo (como em RNNs). Isso ajuda no raciocínio com contexto longo e melhora o fluxo de gradientes durante o treinamento (via Retropropagação padrão).

Mecanismo central: autoatenção (queries, keys, values)

A operação central é a atenção por produto escalar com escalonamento (scaled dot-product attention). Cada representação de token é projetada em:

  • um vetor de consulta (query) (Q)
  • um vetor de chave (key) (K)
  • um vetor de valor (value) (V)

Os pesos de atenção são computados comparando consultas com chaves:

[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}} + \text{mask}\right)V ]

Intuição:

  • (QK^\top) mede similaridade: “o que estou procurando?” (consulta) vs “o que eu contenho?” (chave)
  • a função softmax (softmax) transforma similaridades em uma distribuição de probabilidade sobre as posições
  • a saída é uma soma ponderada dos valores (V)

Quando as consultas/chaves/valores vêm da mesma sequência, isso é autoatenção (self-attention). Quando as consultas vêm de uma sequência e chaves/valores de outra (por exemplo, texto atendendo a tokens de imagem), isso é atenção cruzada (cross-attention).

Para um aprofundamento, veja Mecânica da Atenção.

Atenção multi-cabeças

Em vez de um único cálculo de atenção, os transformadores usam atenção multi-cabeças (multi-head attention): dividem a dimensão do modelo em múltiplas “cabeças”, cada uma aprendendo diferentes padrões de interação (sintaxe, correferência, contexto local etc.). As cabeças são concatenadas e projetadas linearmente de volta para a dimensão do modelo.

Benefícios:

  • representações mais ricas por meio de padrões de atenção diversos
  • maior capacidade sem aumentar excessivamente a dimensão por cabeça

O bloco do Transformador

Um transformador padrão é construído empilhando blocos com duas subcamadas principais:

  1. (Auto)Atenção
  2. Rede Feed-Forward por Posição (Position-wise Feed-Forward Network, FFN)

Cada subcamada é envolvida com:

  • conexões residuais (residual connections) (skip connections)
  • normalização de camada (layer normalization)
  • dropout (dropout) (comumente)

Uma variante moderna comum é “Pre-LN” (normalização de camada antes da subcamada), que costuma ser mais estável para redes profundas.

Rede feed-forward (perceptron multicamadas (multi-layer perceptron, MLP) / FFN)

A FFN é aplicada de forma independente a cada token:

[ \text{FFN}(x) = W_2 , \sigma(W_1 x + b_1) + b_2 ]

Onde (\sigma) é tipicamente GELU ou SiLU. Muitos modelos de linguagem grandes usam variantes com gating como SwiGLU.

Embora a atenção misture informações entre tokens, a FFN fornece a maior parte da não linearidade por token e uma grande fração dos parâmetros.

Exemplo mínimo de atenção no estilo PyTorch

Abaixo está um módulo de autoatenção simplificado (não otimizado para produção):

import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        assert d_model % n_heads == 0
        self.d_model = d_model
        self.n_heads = n_heads
        self.d_head = d_model // n_heads

        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.out = nn.Linear(d_model, d_model, bias=False)

    def forward(self, x, causal=False):
        B, T, D = x.shape
        qkv = self.qkv(x)                      # (B, T, 3D)
        q, k, v = qkv.chunk(3, dim=-1)

        # (B, nh, T, dh)
        q = q.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        k = k.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        v = v.view(B, T, self.n_heads, self.d_head).transpose(1, 2)

        scores = (q @ k.transpose(-2, -1)) / (self.d_head ** 0.5)  # (B, nh, T, T)

        if causal:
            mask = torch.triu(torch.ones(T, T, device=x.device), diagonal=1).bool()
            scores = scores.masked_fill(mask, float("-inf"))

        attn = F.softmax(scores, dim=-1)
        y = attn @ v                               # (B, nh, T, dh)

        y = y.transpose(1, 2).contiguous().view(B, T, D)
        return self.out(y)

Em sistemas reais, a atenção é altamente otimizada (por exemplo, kernels fundidos (fused kernels) como FlashAttention) e usa cacheamento de K/V (KV caching) durante a decodificação autorregressiva (autoregressive decoding).

Informação posicional: por que é necessária

A autoatenção sozinha é invariante a permutação (permutation-invariant): se você embaralhar tokens, a atenção não tem uma noção inerente de ordem. Linguagem e muitos sinais dependem de ordem, então os transformadores adicionam informação posicional via:

  • codificações posicionais absolutas (Absolute positional encodings) (aprendidas ou senoidais)
  • codificações posicionais relativas (Relative positional encodings) (a atenção depende da distância)
  • embeddings posicionais rotativos (Rotary position embeddings, RoPE) (comuns em modelos de linguagem grandes modernos)
  • ALiBi (Attention with Linear Biases) e outros métodos baseados em viés

O projeto posicional afeta a extrapolação para contextos mais longos e a eficiência. Veja Codificações Posicionais.

Principais variantes de Transformadores

Transformadores são frequentemente categorizados por como lidam com atenção e objetivos.

Somente codificador (atenção bidirecional (bidirectional attention))

Modelos somente codificador (encoder-only) (por exemplo, no estilo BERT) usam autoatenção completa (full self-attention) (tokens atendem tanto ao contexto à esquerda quanto à direita). Eles são comumente treinados com objetivos mascarados e se destacam em:

  • classificação
  • recuperação e embeddings semânticos
  • rotulagem de tokens (NER)
  • tarefas gerais de “entendimento”

Somente decodificador (causal / autorregressivo)

Modelos somente decodificador (decoder-only) (no estilo GPT) usam autoatenção causal (causal self-attention): cada token atende apenas a tokens anteriores. Eles são treinados para prever o próximo token, permitindo geração de texto:

[ p(x) = \prod_t p(x_t \mid x_{<t}) ]

Esta é a arquitetura dominante para modelos de linguagem grandes modernos porque ela naturalmente suporta:

  • geração aberta
  • seguimento de instruções (após ajuste fino)
  • uso de ferramentas e loops agênticos (com scaffolding adicional)

Codificador–decodificador (sequência a sequência)

Transformadores codificador–decodificador (encoder–decoder) usam:

  • um codificador que lê a sequência de entrada
  • um decodificador que gera a sequência de saída
  • atenção cruzada do decodificador para os estados do codificador

Isso é padrão para tradução e sumarização e é abordado mais em Sequência a Sequência.

Treinando Transformadores na prática

Transformadores são treinados com variantes de Descida do Gradiente estocástica (tipicamente AdamW), além de técnicas modernas de estabilidade:

  • warmup de taxa de aprendizado + agendas de decaimento
  • clipping de gradiente
  • precisão mista (FP16/BF16)
  • inicialização e normalização cuidadosas (Pre-LN é comum)

Objetivos de pré-treinamento

Objetivos comuns incluem:

  • modelagem causal de linguagem (causal language modeling) (somente decodificador): prever o próximo token
  • modelagem de linguagem mascarada (masked language modeling) (somente codificador): prever tokens mascarados
  • sequência a sequência com remoção de ruído (denoising seq2seq) (codificador–decodificador): reconstruir entrada corrompida (por exemplo, corrupção de spans)
  • contrastivo multimodal (multimodal contrastive) (por exemplo, alinhando embeddings de imagem/texto)
  • predição do próximo token sobre tokens multimodais (modelagem generativa unificada)

Ajuste fino e alinhamento

Para tornar transformadores pré-treinados úteis para tarefas downstream, passos típicos incluem:

  • ajuste fino supervisionado (Supervised fine-tuning, SFT) em dados de tarefa/instrução
  • otimização por preferências (preference optimization) (por exemplo, pipelines no estilo RLHF)
  • métodos eficientes em parâmetros (parameter-efficient methods) (LoRA/adaptadores) para reduzir o custo de treinamento

Inferência: decodificação e cache K/V

Para modelos de linguagem grandes somente decodificador, a inferência gera tokens passo a passo. Recalcular ingenuamente a atenção sobre todo o prefixo a cada passo é caro. Em vez disso, sistemas usam um cache de chave/valor (key/value cache):

  • armazenar (K) e (V) passados para cada camada
  • no passo (t), computar (Q_t) para o novo token e atender a (K_{<t},V_{<t}) em cache

Isso reduz a computação por passo por evitar recomputar todas as projeções anteriores, embora a atenção ainda escale com o comprimento do contexto.

Um esboço conceitual:

for each new token:
  for each layer:
    (k_t, v_t) = proj(new_hidden)
    append to cache
    new_hidden = Attention(q_t, K_cache, V_cache)
    new_hidden = FFN(new_hidden)

Aplicações práticas

Modelos de linguagem grandes

Transformadores habilitam capacidades de modelos de linguagem grandes como:

  • sumarização, tradução, perguntas e respostas
  • geração e depuração de código
  • saída estruturada (JSON, SQL) com prompting/decodificação apropriados e restrições
  • geração aumentada por recuperação (retrieval-augmented generation, RAG) quando combinada com busca vetorial (vector search)

Exemplo prático: classificação via prompting (prompting) (somente decodificador)

Prompt:
Review: "The battery life is fantastic but the screen is dim."
Label (positive/negative/mixed):

Com poucos exemplos (com poucos exemplos (few-shot)), um modelo de linguagem grande pode atuar como um classificador sem treinamento. Por confiabilidade e custo, muitos sistemas de produção ainda ajustam finamente modelos codificadores ou pequenos decodificadores.

Transformadores de Visão e modelos multimodais

Transformadores se estendem naturalmente além de texto:

  • Transformadores de Visão (Vision Transformers, ViT) tratam patches de imagem como tokens e aplicam autoatenção.
  • Transformadores multimodais (Multimodal Transformers) combinam modalidades usando:
    • fusão precoce (early fusion) (concatenar tokens)
    • atenção cruzada (consultas de texto atendem a chaves/valores de imagem)
    • codificadores específicos por modalidade alimentando um decodificador conjunto

Exemplo: legendagem de imagens frequentemente usa um codificador de imagem + decodificador de texto com atenção cruzada para embeddings de imagem.

Áudio, vídeo e séries temporais

  • Áudio: reconhecimento de fala, modelagem de locutor, geração de música
  • Vídeo: reconhecimento de ações, legendagem de vídeo (frequentemente exige truques de eficiência devido a sequências longas)
  • Séries temporais: previsão e detecção de anomalias (embora alternativas como Modelos de Espaço de Estados possam ser mais eficientes para contextos muito longos)

Uso de ferramentas e agentes (aplicações em nível de sistema)

Embora “agentes (agents)” não sejam puramente um recurso arquitetural, modelos de linguagem grandes baseados em transformadores comumente atuam como planejadores/controladores que:

  • chamam ferramentas externas (busca, calculadoras, execução de código)
  • interagem com ambientes
  • seguem instruções em múltiplas etapas

Essas capacidades tipicamente exigem ajuste fino, engenharia de prompts e salvaguardas (guardrails).

Eficiência, escalonamento e engenharia moderna

Custo computacional

A autoatenção padrão tem complexidade de tempo/memória quadrática (quadratic) no comprimento da sequência (n): (O(n^2)). Isso se torna um gargalo para contextos longos (documentos, vídeo, conversas longas).

Mitigações comuns:

  • otimizações de kernel (kernel optimizations) (FlashAttention e operações fundidas)
  • atenção esparsa (sparse attention) (atender a um subconjunto de tokens)
  • janela deslizante / atenção local (sliding window / local attention) (boa para sequências longas com localidade)
  • aproximações de atenção linear (linear attention) (reduzem o comportamento quadrático)
  • segmentação em blocos (chunking) e truques do tipo recorrência (projetos híbridos)

Leis de escalonamento e capacidade

O desempenho de transformadores frequentemente melhora de forma previsível com:

  • mais parâmetros
  • mais dados
  • mais computação

Para aumentar a contagem de parâmetros sem computação proporcional por token, muitos sistemas usam Mistura de Especialistas (Mixture-of-Experts, MoE): apenas um subconjunto de FFNs especialistas ativa por token.

Largura de banda de memória e quantização

A inferência frequentemente é limitada por memória. Técnicas incluem:

  • quantização (quantization) (por exemplo, pesos de 8 bits/4 bits) para reduzir largura de banda
  • paralelismo de tensores / paralelismo de pipeline (tensor parallelism / pipeline parallelism) para modelos grandes
  • decodificação especulativa (speculative decoding) para acelerar a geração

Limitações e modos de falha

Transformadores são poderosos, mas não fazem milagres:

  • Limites de comprimento de contexto: o desempenho degrada além dos comprimentos treinados; atenção de contexto longo é cara.
  • Alucinações (hallucinations): modelos podem gerar saídas plausíveis, porém incorretas, sem ancoragem.
  • Sensibilidade a prompts: o comportamento pode variar com formulação e formatação.
  • Problemas de dados e viés: modelos pré-treinados herdam vieses e artefatos dos dados.
  • Interpretabilidade (interpretability): pesos de atenção não são uma explicação completa do raciocínio; a compreensão mecanicista (mechanistic understanding) permanece uma área ativa.
  • Generalização fora da distribuição (out-of-distribution generalization): pode ser frágil em cenários desconhecidos.

Mitigações geralmente combinam arquitetura + dados + treinamento + design de sistema (geração aumentada por recuperação, verificação, decodificação com restrições (constraint decoding), monitoramento (monitoring)).

Como Transformadores se relacionam com outras arquiteturas

  • Versus RNNs/LSTMs: transformadores paralelizam o treinamento e modelam dependências de longo alcance mais diretamente, mas podem ser mais pesados para sequências longas sem otimizações.
  • Versus CNNs: CNNs incorporam localidade e equivariância a translação; transformadores aprendem interações globais flexíveis, mas podem precisar de mais dados/computação.
  • Versus MLPs: MLPs puros não têm um mecanismo explícito para misturar posições na sequência; transformadores fornecem comunicação token-a-token via atenção.
  • Versus Modelos de Espaço de Estados: modelos de espaço de estados podem ser mais eficientes para contextos longos; híbridos buscam combinar a eficiência desses modelos com a flexibilidade da atenção.

Principais aprendizados

  • Um transformador é uma pilha de blocos de atenção + feed-forward com normalização e conexões residuais.
  • Autoatenção permite interação flexível e dependente do conteúdo entre tokens e escala bem com dados/computação.
  • Diferentes arranjos — somente codificador, somente decodificador, codificador–decodificador — se adequam a diferentes tarefas.
  • O sucesso prático depende tanto de objetivos de treinamento, dados, otimização e engenharia de inferência quanto da arquitetura central.
  • Para mais detalhes, veja Mecânica da Atenção, Codificações Posicionais e Sequência a Sequência.