01-02-03 — CNNs, RNNs, Transformers: Zoológico de Arquiteturas

Visão Geral: O Problema que Cada Arquitetura Resolve

Arquiteturas diferentes são respostas a perguntas diferentes sobre os dados:

• CNN: "Onde estão os padrões locais nesta imagem?"
• RNN/LSTM: "O que aconteceu antes importa para o que vem agora?"
• Transformer: "Qual parte do input todo é relevante para entender cada parte?"

CNN — Convolutional Neural Network

A Intuição

Olhe para a letra "A". Você a reconhece independentemente de onde ela está na página — no canto superior esquerdo ou inferior direito. CNNs exploram essa propriedade chamada translational invariance: o que importa é o padrão, não a posição.

Um filtro convolucional é uma pequena "janela" que percorre a imagem procurando um padrão específico. Um filtro pode detectar bordas verticais. Outro, bordas horizontais. Combinando os outputs desses filtros, camadas mais profundas detectam formas, depois partes de objetos, depois objetos inteiros.

Quando usar CNNs hoje

• Visão computacional em edge (câmeras industriais, OCR local, face detection)
• Processamento de séries temporais com padrões locais (anomalias em sinais)
• Modelos pequenos que precisam rodar sem GPU

RNN / LSTM — Redes Recorrentes

A Intuição

RNNs (Recurrent Neural Networks) processam sequências passando um "estado oculto" de um passo para o próximo. Ao processar a frase "O banco aprovou o empréstimo", a rede carrega informação de palavras anteriores ao processar cada nova palavra.

O problema fundamental: esse estado oculto é pequeno e vai sendo sobrescrito. Com sequências longas (documentos inteiros), as RNNs "esquecem" o que estava lá atrás. Uma referência feita 500 palavras antes é quase invisível ao processar a palavra atual.

LSTM: Memória com Controle

LSTMs (Long Short-Term Memory, 1997 — Hochreiter & Schmidhuber) adicionam "gates" — mecanismos que decidem o que lembrar e o que esquecer. Funcionou melhor que RNNs simples para sequências mais longas. Dominaram NLP até 2017.

Transformer: A Arquitetura Dominante

Attention is All You Need (2017)

Vaswani et al. do Google publicaram o paper que mudou tudo. A ideia central: ao processar cada token, o modelo atende a todos os outros tokens ao mesmo tempo, com pesos diferentes de atenção. "banco" num contexto financeiro atende mais a "empréstimo" do que a "parque".

O mecanismo de self-attention calcula, para cada token: "quanto devo me importar com cada outro token no contexto?" Esse cálculo acontece em paralelo para todos os tokens — não sequencialmente como nas RNNs.

Por que Transformers Venceram

1. Paralelismo: todo o cálculo de atenção pode rodar em GPU/TPU em paralelo. Treinar 10.000 tokens não requer 10.000 passos sequenciais
2. Contexto longo: qualquer token pode atender a qualquer outro diretamente — sem o problema de "esquecimento" das RNNs
3. Escala: a arquitetura escala bem — mais parâmetros, mais dados, mais compute → melhor performance. Nenhuma arquitetura anterior demonstrou isso tão consistentemente

Diagrama Comparativo

Encoder, Decoder, e Encoder-Decoder

Transformers têm dois componentes principais usados em combinações diferentes:

• Encoder: lê o input e cria uma representação rica. BERT usa apenas encoder — ótimo para entender texto (classificação, busca semântica)
• Decoder: gera output token por token. GPT usa apenas decoder — ótimo para gerar texto
• Encoder-Decoder: o encoder lê o input (por exemplo, texto em português) e o decoder gera o output (texto em inglês). T5, BART — ótimo para tradução e sumarização

Vision Transformers (ViT) — Quando Transformers Invadem Visão

Em 2020, Dosovitskiy et al. mostraram que você pode usar Transformers para imagens dividindo a imagem em "patches" (pedaços 16x16 pixels) e tratando cada patch como um token. ViTs superam CNNs em datasets grandes. Isso unificou ainda mais as arquiteturas — hoje GPT-4V, Gemini e Claude processam imagens com variações de Transformers.

Exemplo Prático: Usando ONNX Runtime no .NET

// Usando um modelo Transformer (BERT) via ONNX no .NET
// Modelo pré-exportado do Hugging Face para ONNX
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;

var session = new InferenceSession("bert-base-uncased.onnx");

// Tokenização (simplificada — use HuggingFace.Tokenizers na prática)
var inputIds = new DenseTensor<long>(new long[] { 101, 2023, 2003, 1037, 3231, 102 }, new[] { 1, 6 });
var attentionMask = new DenseTensor<long>(new long[] { 1, 1, 1, 1, 1, 1 }, new[] { 1, 6 });

var inputs = new List<NamedOnnxValue>
{
    NamedOnnxValue.CreateFromTensor("input_ids", inputIds),
    NamedOnnxValue.CreateFromTensor("attention_mask", attentionMask)
};

// Inference — forward pass pelo Transformer
using var results = session.Run(inputs);
var embeddings = results.First().AsEnumerable<float>().ToArray();
// 'embeddings' agora é a representação do texto — 768 dimensões por token

Desafio