Redes Neurais Profundas — Arquiteturas, Treinamento e Regularização

Redes neurais profundas (Deep Neural Networks — DNNs) são modelos computacionais inspirados no sistema nervoso biológico, compostos por camadas de unidades de processamento (neurônios artificiais) capazes de aprender representações hierárquicas a partir de dados. O avanço do deep learning desde 2012 revolucionou visão computacional, processamento de linguagem natural, síntese de áudio e muito mais.

Papers de referência: arXiv cs.LG — Machine Learning | cs.NE — Neural and Evolutionary Computing

O neurônio artificial

A unidade básica é o perceptron: recebe entradas, aplica pesos, soma, passa por uma função de ativação e produz uma saída.

saída = f(w₁x₁ + w₂x₂ + ... + wₙxₙ + b)

Onde:
- x₁...xₙ: entradas
- w₁...wₙ: pesos (parâmetros aprendidos)
- b: bias
- f: função de ativação

Funções de ativação

Arquitetura de uma rede profunda

Entrada → [Camada Oculta 1] → [Camada Oculta 2] → ... → [Camada de Saída]
         (feature extraction)   (abstração)              (predição)

Profundidade (número de camadas) vs Largura (neurônios por camada): redes mais profundas capturam abstrações mais complexas; mais largas capturam mais variações no mesmo nível de abstração.

Backpropagation — como redes aprendem

O algoritmo de retropropagação do gradiente é o motor do treinamento de redes neurais:

1. Forward pass: calcula a saída da rede dado um input
2. Calcula o erro (loss function): diferença entre saída prevista e real
3. Backward pass: calcula o gradiente do erro em relação a cada peso usando a regra da cadeia
4. Atualiza os pesos: subtrai o gradiente multiplicado pelo learning rate

# Pseudocódigo do loop de treinamento
for epoch in range(num_epochs):
    for batch in dataloader:
        # Forward pass
        predictions = model(batch.inputs)
        loss = criterion(predictions, batch.targets)

        # Backward pass
        optimizer.zero_grad()
        loss.backward()        # calcula gradientes
        optimizer.step()       # atualiza pesos

Otimizadores

Arquiteturas principais

CNNs — Redes Convolucionais

Projetadas para dados com estrutura espacial (imagens, séries temporais).

Operação de convolução: aplica filtros locais que detectam padrões (bordas, texturas, formas). O mesmo filtro é reutilizado em toda a imagem — parameter sharing — tornando a rede eficiente e invariante à translação.

Imagem (3×224×224) → Conv → ReLU → Pooling → Conv → ... → FC → Saída

Evolução das arquiteturas:

• LeNet (1989) — primeiras CNNs práticas
• AlexNet (2012) — breakthrough no ImageNet, início do deep learning moderno
• VGG (2014) — redes muito profundas com filtros 3×3
• ResNet (2015) — conexões residuais (skip connections), permite treinar redes de 100+ camadas
• EfficientNet (2019) — escalonamento balanceado de profundidade, largura e resolução

RNNs e LSTMs — dados sequenciais

Redes Recorrentes processam sequências mantendo um estado oculto que carrega informação de passos anteriores.

Problema: vanishing gradient em sequências longas — o gradiente desaparece ao ser retropropagado por muitos passos.

Solução — LSTM (Long Short-Term Memory): introduz gates (forget, input, output) que controlam explicitamente o que manter ou descartar na memória.

Aplicações de RNN/LSTM:
- Modelagem de linguagem
- Séries temporais financeiras
- Tradução de texto (pre-Transformer)
- Geração de música

Transformers — a arquitetura dominante

Publicado em "Attention Is All You Need" (Vaswani et al., 2017), o Transformer substituiu RNNs como padrão em NLP e expandiu para visão, áudio e mais.

Mecanismo de atenção (Self-Attention):

Attention(Q, K, V) = softmax(QKᵀ / √dₖ) × V

Onde:
- Q (Query), K (Key), V (Value): projeções lineares do input
- √dₖ: fator de escala para estabilizar gradientes

Cada token "presta atenção" a todos os outros tokens, aprendendo quais relações são relevantes — independente da distância na sequência.

Vantagens sobre RNNs:

• Paralelizável no treinamento (não sequencial)
• Captura dependências de longa distância
• Escala melhor com dados e parâmetros

Famílias derivadas:

• Encoder-only: BERT, RoBERTa — classificação, extração
• Decoder-only: GPT, Llama, Claude — geração de texto
• Encoder-Decoder: T5, BART — tradução, sumarização

Problemas de treinamento e soluções

Overfitting

O modelo memoriza os dados de treino mas não generaliza para dados novos.

Soluções:

Vanishing/Exploding Gradient

Vanishing: gradientes ficam extremamente pequenos em camadas iniciais — rede não aprende. Exploding: gradientes crescem exponencialmente — instabilidade.

Soluções:

• Inicialização cuidadosa de pesos (Xavier/He initialization)
• Skip connections (ResNet)
• Gradient clipping (limita norma do gradiente)
• Layer normalization

Batch normalization e Layer normalization

Batch Norm (Ioffe & Szegedy, 2015): normaliza ativações usando média e variância do mini-batch. Acelera convergência, permite learning rates maiores, funciona como regularizador.

Layer Norm: normaliza ao longo das features de um único exemplo (não do batch). Padrão em Transformers — funciona bem com tamanhos de batch pequenos e sequências variáveis.

Transfer Learning e Fine-tuning

A maior parte dos modelos de ponta hoje usa transfer learning: pré-treino em dataset enorme (ImageNet, Common Crawl) seguido de fine-tuning para tarefa específica.

Pré-treino (dataset gigante, auto-supervisionado)
    ↓
Fine-tuning (dataset menor, tarefa específica)
    ↓
Produção

Por que funciona: as camadas iniciais aprendem features genéricas (bordas, formas, estrutura sintática) reutilizáveis. Apenas as camadas finais precisam ser adaptadas.

Conexões com outras seções

• Aprendizado por Reforço — deep RL combina redes neurais profundas com RL
• Visão Computacional — CNNs e ViTs são a base de visão moderna
• LLMs — Transformers escalonados como GPT, Claude, Gemini
• Inferência Bayesiana — deep learning bayesiano para quantificação de incerteza
• Séries Temporais com ML — LSTMs e Transformers para previsão temporal

Aviso Legal: Conteúdo educativo. Não constitui recomendação de investimento.