Um MLP trata todas as entradas como um vetor plano — o que joga fora estrutura preciosa. Uma imagem tem estrutura espacial (pixels vizinhos se relacionam); um texto tem estrutura sequencial (a ordem das palavras importa). As arquiteturas desta aula — CNNs para dados espaciais, RNNs e Transformers para sequências, GANs para geração — foram desenhadas para explorar essa estrutura. São a fundação da IA moderna, de reconhecimento de imagem a modelos de linguagem.

Compreender CNNs (convolução, pooling, transfer learning), o processamento de sequências (RNN/LSTM e a revolução dos Transformers com atenção) e modelos generativos (GANs), sabendo escolher a arquitetura certa para cada tipo de dado.

CNNs — redes convolucionais para dados espaciais

O problema com um MLP para imagens: uma imagem 224×224×3 tem ~150 mil entradas; conectar tudo a uma camada densa gera milhões de pesos e ignora que pixels próximos formam padrões locais. A convolução resolve isso com dois princípios:

  • Conectividade local: cada neurônio olha só uma pequena região (campo receptivo).
  • Compartilhamento de pesos: o mesmo filtro desliza por toda a imagem, detectando um padrão (borda, textura) onde quer que ele apareça. Isso reduz drasticamente os parâmetros e dá invariância à translação.
import torch.nn as nn

class CNN(nn.Module):
    def __init__(self, n_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(),
            nn.BatchNorm2d(32),
            nn.MaxPool2d(2),                       # reduz resolução pela metade
            nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(),
            nn.BatchNorm2d(64),
            nn.MaxPool2d(2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(),
            nn.AdaptiveAvgPool2d(1),               # global average pooling
        )
        self.classifier = nn.Linear(128, n_classes)

    def forward(self, x):
        x = self.features(x)
        x = x.flatten(1)
        return self.classifier(x)

Componentes-chave: camadas convolucionais (extraem features hierárquicas — bordas → texturas → objetos), pooling (reduz dimensão e dá robustez), e uma cabeça densa para a decisão final. Arquiteturas históricas: LeNet, AlexNet, VGG, ResNet (conexões residuais permitiram redes muito profundas), EfficientNet.

Transfer learning — o superpoder prático das CNNs

Você raramente treina uma CNN do zero. Pega uma rede pré-treinada em milhões de imagens (ImageNet), que já aprendeu detectores visuais gerais, e a adapta ao seu problema com poucos dados. É a técnica mais impactante em visão aplicada.

import torchvision.models as models
import torch.nn as nn

modelo = models.resnet18(weights="IMAGENET1K_V1")

# Congela o extrator de features
for p in modelo.parameters():
    p.requires_grad = False

# Substitui a cabeça pela sua tarefa (ex.: 5 classes)
modelo.fc = nn.Linear(modelo.fc.in_features, 5)   # só isto treina inicialmente

# Fine-tuning: depois, descongele as últimas camadas com lr pequeno

Estratégia: comece congelando a base e treinando só a nova cabeça; depois, descongele gradualmente as camadas superiores com taxa de aprendizado baixa (fine-tuning). Funciona com pouquíssimos dados.

Data augmentation em visão

Fundamental para regularizar CNNs: gerar variações realistas das imagens (giros, cortes, mudanças de cor) multiplica os dados efetivos.

from torchvision import transforms

treino_tf = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(0.2, 0.2, 0.2),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],   # médias do ImageNet
                         std=[0.229, 0.224, 0.225]),
])

RNNs e LSTMs — o processamento clássico de sequências

Para dados sequenciais (texto, séries, áudio), as RNNs mantêm um estado oculto que carrega "memória" ao longo da sequência. As LSTMs e GRUs adicionam portas que controlam o fluxo de informação, resolvendo o vanishing gradient das RNNs simples e permitindo capturar dependências mais longas.

import torch.nn as nn

class ClassificadorLSTM(nn.Module):
    def __init__(self, vocab, emb=128, hidden=256, n_classes=2):
        super().__init__()
        self.embedding = nn.Embedding(vocab, emb)
        self.lstm = nn.LSTM(emb, hidden, num_layers=2,
                            batch_first=True, bidirectional=True, dropout=0.3)
        self.fc = nn.Linear(hidden * 2, n_classes)

    def forward(self, x):
        x = self.embedding(x)
        _, (h, _) = self.lstm(x)
        h = torch.cat([h[-2], h[-1]], dim=1)   # estados das duas direções
        return self.fc(h)

Limitação das RNNs: processam sequencialmente (lento, não paraleliza) e ainda têm dificuldade com dependências muito longas. Isso motivou a arquitetura que redefiniu o campo.

Transformers e o mecanismo de atenção

O Transformer (2017, "Attention is All You Need") abandonou a recorrência e passou a processar a sequência inteira de uma vez, usando auto-atenção (self-attention): cada elemento "olha" para todos os outros e decide, de forma ponderada, quais são relevantes para ele. Isso captura dependências de longo alcance e paraleliza o treino — permitindo escalar para os modelos gigantes de hoje (BERT, GPT, etc.).

A intuição da atenção: para cada token, computam-se três vetores — query (o que busco), key (o que ofereço) e value (o que carrego). A relevância entre tokens vem do produto query·key; as saídas são médias ponderadas dos values por essas relevâncias.

# Usando um modelo pré-treinado (transfer learning para texto)
# pip install transformers
from transformers import AutoTokenizer, AutoModelForSequenceClassification

nome = "distilbert-base-uncased-finetuned-sst-2-english"
tok = AutoTokenizer.from_pretrained(nome)
modelo = AutoModelForSequenceClassification.from_pretrained(nome)

inputs = tok("This course is excellent!", return_tensors="pt")
logits = modelo(**inputs).logits
print("Sentimento:", logits.argmax(dim=1).item())   # 1 = positivo

Assim como em visão, na prática você raramente treina um Transformer do zero — usa um modelo pré-treinado e faz fine-tuning na sua tarefa. Esse paradigma (pré-treino em larga escala + fine-tuning) é a base dos modelos de linguagem modernos.

GANs — redes generativas adversariais

As GANs aprendem a gerar dados novos e realistas (imagens, por exemplo) por meio de um jogo entre duas redes:

  • Gerador: tenta criar amostras falsas convincentes a partir de ruído.
  • Discriminador: tenta distinguir amostras reais das falsas.

Elas treinam em competição (adversarial): o gerador melhora ao enganar o discriminador, que melhora ao detectar as falsificações. No equilíbrio, o gerador produz amostras indistinguíveis das reais.

import torch.nn as nn

class Gerador(nn.Module):
    def __init__(self, dim_ruido=100, dim_saida=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim_ruido, 256), nn.LeakyReLU(0.2),
            nn.Linear(256, 512), nn.LeakyReLU(0.2),
            nn.Linear(512, dim_saida), nn.Tanh(),   # saída em [-1, 1]
        )
    def forward(self, z):
        return self.net(z)

class Discriminador(nn.Module):
    def __init__(self, dim_entrada=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim_entrada, 512), nn.LeakyReLU(0.2), nn.Dropout(0.3),
            nn.Linear(512, 256), nn.LeakyReLU(0.2), nn.Dropout(0.3),
            nn.Linear(256, 1), nn.Sigmoid(),        # probabilidade de ser real
        )
    def forward(self, x):
        return self.net(x)

GANs são notoriamente difíceis de treinar: instabilidade, oscilação e mode collapse (o gerador produz pouca variedade) são comuns. Variantes como DCGAN, WGAN-GP e StyleGAN atacam esses problemas. Hoje, para geração de imagens, os modelos de difusão (Stable Diffusion, DALL·E) superaram as GANs em qualidade e estabilidade, mas as GANs continuam importantes conceitualmente e em nichos.

Escolhendo a arquitetura pelo dado

Tipo de dado Arquitetura recomendada
Tabular (pequeno/médio)Gradient boosting (não deep learning)
ImagensCNN + transfer learning (ResNet, EfficientNet)
Texto / linguagemTransformers pré-treinados (BERT, GPT) + fine-tuning
Séries temporais / sequênciasLSTM/GRU ou Transformers temporais
Geração de imagensModelos de difusão (ou GANs)

A lição transversal do módulo: escolha a arquitetura que respeita a estrutura do dado, e sempre que possível aproveite transfer learning — treinar do zero é a exceção, não a regra.

As CNNs exploram a estrutura espacial pela convolução — conectividade local somada a compartilhamento de pesos — e pelo pooling, aprendendo features visuais em hierarquia; foram as conexões residuais da ResNet que tornaram a grande profundidade treinável. Em visão aplicada, a técnica de maior impacto é o transfer learning, partindo de redes pré-treinadas no ImageNet e fazendo fine-tuning, com a aumentação de dados no papel de regularizador. As RNNs e LSTMs processam sequências mantendo estado, mas são lentas e têm alcance limitado em dependências longas. Os Transformers trocaram a recorrência pela auto-atenção, com query, key e value, capturando dependências longas e permitindo paralelizar — é a base dos modelos de linguagem modernos, usados no esquema de pré-treino seguido de fine-tuning. As GANs geram dados por um jogo adversarial entre gerador e discriminador, são instáveis pelo mode collapse, e em geração de imagens foram em boa parte superadas pelos modelos de difusão. A regra que fecha: escolha a arquitetura pela estrutura do dado, e prefira transfer learning a treinar do zero.

Exercícios

  1. Quais dois princípios da convolução tornam as CNNs muito mais eficientes que MLPs para imagens, e o que cada um traz?

    ✓ Resposta:

    (1) Conectividade local (campo receptivo): cada neurônio convolucional se conecta apenas a uma pequena região da entrada, não a todos os pixels. Isso reflete o fato de que padrões visuais relevantes (bordas, texturas) são locais e reduz enormemente o número de conexões. (2) Compartilhamento de pesos: o mesmo filtro (conjunto de pesos) desliza por toda a imagem, procurando o mesmo padrão em qualquer posição. Isso reduz drasticamente o número de parâmetros (um filtro em vez de pesos distintos por posição) e confere invariância à translação — um objeto é detectado independentemente de onde aparece. Juntos, esses princípios tornam o treino viável e mais generalizável do que conectar cada pixel a cada neurônio como num MLP.

  2. O que é transfer learning em visão computacional e por que ele é tão eficaz quando se tem poucos dados?

    ✓ Resposta:

    Transfer learning consiste em pegar uma CNN já pré-treinada em um dataset enorme e genérico (tipicamente o ImageNet, com milhões de imagens) e adaptá-la à sua tarefa específica, substituindo a camada final e treinando (fine-tuning) a rede nos seus dados. É eficaz com poucos dados porque as camadas iniciais/intermediárias já aprenderam detectores visuais gerais e reutilizáveis (bordas, texturas, formas, partes de objetos) que são úteis para praticamente qualquer tarefa de imagem. Em vez de aprender esses padrões do zero (o que exigiria muitíssimos dados), você apenas reaproveita esse conhecimento e ajusta as camadas finais ao seu problema. Isso reduz enormemente a quantidade de dados e de computação necessários e costuma superar treinar do zero.

  3. Qual limitação das RNNs os Transformers resolvem, e como o mecanismo de auto-atenção funciona em alto nível?

    ✓ Resposta:

    As RNNs processam a sequência elemento por elemento, de forma serial, o que (a) impede paralelização eficiente no treino e (b) dificulta capturar dependências de longo alcance, pois a informação precisa atravessar muitos passos (com risco de vanishing gradient). Os Transformers eliminam a recorrência e processam a sequência inteira de uma vez via auto-atenção: para cada elemento (token), a rede computa vetores de query, key e value; a relevância entre dois tokens vem do produto entre a query de um e a key do outro, gerando pesos de atenção; a nova representação de cada token é a média ponderada dos values de todos os tokens, segundo esses pesos. Assim, qualquer token pode "olhar" diretamente para qualquer outro (dependências longas em um passo) e todo o cálculo é altamente paralelizável — o que permitiu escalar para modelos enormes.

  4. Descreva o jogo adversarial entre gerador e discriminador em uma GAN e explique o que é mode collapse.

    ✓ Resposta:

    Uma GAN treina duas redes em competição. O gerador recebe ruído aleatório e tenta produzir amostras falsas (ex.: imagens) que pareçam reais. O discriminador recebe amostras reais e falsas e tenta classificá-las corretamente como reais ou geradas. Os dois treinam em oposição: o gerador é recompensado quando engana o discriminador, e o discriminador quando detecta as falsificações. Idealmente, o processo converge para um equilíbrio em que o gerador produz amostras indistinguíveis das reais. O mode collapse é uma falha comum em que o gerador aprende a produzir apenas um pequeno subconjunto de saídas (ou até uma única) que enganam bem o discriminador, perdendo a diversidade dos dados reais — por exemplo, gerar sempre o mesmo tipo de rosto. Isso ocorre porque o gerador encontra um "atalho" que reduz sua perda sem cobrir toda a distribuição, e é um dos motivos pelos quais GANs são difíceis de treinar.

  5. Para cada tipo de dado a seguir, indique a arquitetura mais apropriada e justifique: (a) 8.000 imagens de raio-X para classificar pneumonia; (b) avaliações de produtos em texto para análise de sentimento; (c) uma tabela com 10.000 linhas e 25 features numéricas para prever churn.

    ✓ Resposta:

    (a) CNN com transfer learning (ex.: ResNet/EfficientNet pré-treinada, com fine-tuning) — imagens têm estrutura espacial que as CNNs exploram, e com apenas 8.000 imagens o transfer learning é essencial para bom desempenho sem overfitting. Data augmentation também ajuda. (b) Transformer pré-treinado (ex.: BERT/DistilBERT) com fine-tuning — texto é sequencial e a auto-atenção captura contexto e dependências entre palavras; usar um modelo de linguagem pré-treinado entrega ótimos resultados mesmo com dados moderados. (c) Gradient boosting (XGBoost/LightGBM/CatBoost) — para dados tabulares desse porte, boosting tipicamente supera redes neurais, treina rápido e exige menos ajuste; deep learning traria pouca vantagem aqui. A lição: casar a arquitetura com a estrutura do dado.

Fontes e leituras recomendadas