Redes Neurais

Visão geral: redes neurais como funções aprendíveis

Uma rede neural (neural network) é um aproximador de funções parametrizado (parameterized function approximator): uma família de funções (f(x; \theta)) em que os parâmetros (\theta) (pesos (weights) e vieses (biases)) são aprendidos a partir de dados. Você escolhe:

  • uma família de modelos (model family) (a arquitetura da rede (network architecture)),
  • uma função de perda (loss function) (o que significa fazer previsões “boas”),
  • e um algoritmo de otimização (optimization algorithm) (como ajustar os parâmetros),

e então treina o modelo para que suas saídas correspondam aos alvos desejados (aprendizado supervisionado (supervised learning)) ou satisfaçam outros sinais de aprendizado (auto-supervisionado (self-supervised), aprendizado por reforço (reinforcement learning) etc.).

No aprendizado profundo (deep learning) moderno, redes neurais são o componente central em uma “pilha” maior que inclui pipelines de dados, aceleradores (accelerators) (GPUs/TPUs), bibliotecas numéricas, ciclos de treinamento (training loops), avaliação e implantação (deployment). Este artigo foca no vocabulário e nos modelos mentais centrais: neurônios, camadas, parâmetros, passagens para frente (forward passes) e treinamento baseado em gradiente (gradient-based training) — a base que você vai querer antes de se aprofundar em arquiteturas específicas como MLPs, CNNs, RNNs e transformers.

Um modelo mental útil: “componha funções simples em uma função poderosa”

A maioria das redes neurais é construída compondo funções simples:

  1. Transformações lineares (afins) (linear (affine) transformations): misturam e reescalam características de entrada.
  2. Não linearidades (ativações) (nonlinearities (activations)): permitem que a rede represente relações não lineares.
  3. Composição repetida (profundidade) (depth): constrói características hierárquicas e fronteiras de decisão complexas.

Matematicamente, uma rede frequentemente se parece com:

[ h_1 = \phi(W_1 x + b_1), \quad h_2 = \phi(W_2 h_1 + b_2), \quad \dots \quad \hat{y} = g(W_L h_{L-1} + b_L) ]

Onde:

  • (x) é a entrada,
  • (\hat{y}) é a previsão,
  • (\phi) é uma função de ativação (activation function) (ex.: ReLU),
  • (W_i, b_i) são parâmetros aprendidos.

Esse ponto de vista de “pilha de transformações” se generaliza pela maioria dos modelos de aprendizado profundo, incluindo a Arquitetura Transformer (onde as transformações incluem atenção) e Redes Neurais Convolucionais (onde as transformações incluem convolução).

Neurônios: a unidade básica de computação

Um neurônio (neuron) (mais precisamente, uma unidade de neurônio artificial (artificial neuron unit)) calcula:

  1. Uma soma ponderada das entradas (mais viés)
  2. Uma ativação não linear

[ z = w^\top x + b,\quad a = \sigma(z) ]

  • (x \in \mathbb{R}^d): vetor de entrada
  • (w \in \mathbb{R}^d): vetor de pesos (aprendido)
  • (b \in \mathbb{R}): termo de viés (aprendido)
  • (\sigma(\cdot)): função de ativação
  • (a): saída do neurônio (ativação)

Por que precisamos de ativações não lineares?

Se você empilhar apenas camadas lineares, toda a rede colapsa em uma única função linear — não importa quantas camadas você adicione. Não linearidades permitem que redes modelem padrões complexos, como:

  • interações do tipo XOR,
  • fronteiras de decisão curvas,
  • estruturas composicionais em imagens e linguagem.

Funções de ativação comuns (intuição prática)

  • ReLU: (\max(0, z))
    Padrão em muitas camadas ocultas; rápida e funciona bem em escala.
  • GELU: ReLU-like suave; comum em transformers.
  • Sigmoide (sigmoid): produz ((0,1))
    Útil para probabilidades (ex.: saída de classificação binária), mas pode saturar em camadas ocultas profundas.
  • Tanh: produz ((-1,1))
    Historicamente comum; ainda aparece em alguns modelos recorrentes.

Camadas: neurônios organizados em operações vetorizadas

Uma camada (layer) aplica o mesmo tipo de transformação a um vetor (ou tensor (tensor)) inteiro de ativações. Na prática, raramente pensamos em neurônios individuais; pensamos em termos de operações sobre tensores.

Camada totalmente conectada (densa) (fully connected (dense) layer)

Dada uma entrada (x \in \mathbb{R}^{d}), uma camada densa com (m) unidades calcula:

[ h = \phi(Wx + b) ]

  • (W \in \mathbb{R}^{m \times d})
  • (b \in \mathbb{R}^{m})
  • (h \in \mathbb{R}^{m})

Esta é a principal ferramenta dos perceptrons multicamadas (multi-layer perceptrons, MLPs).

Outros tipos de camada (prévia)

Arquiteturas diferentes diferem principalmente em quais camadas usam e nos vieses indutivos (inductive biases) que essas camadas codificam:

  • Camadas convolucionais (convolutional layers) (CNNs): assumem localidade e estrutura de translação em imagens.
    Veja Redes Neurais Convolucionais.
  • Camadas recorrentes (recurrent layers) (RNNs/LSTMs/GRUs): processam sequências passo a passo com um estado.
    Veja Redes Neurais Recorrentes.
  • Camadas de atenção (attention layers) (Transformers): permitem fluxo flexível de informação entre qualquer par de tokens (tokens).
    Veja Arquitetura Transformer.

Parâmetros: o que a rede aprende

Os parâmetros (parameters) (\theta) são tipicamente:

  • Pesos (W): controlam como as entradas são misturadas.
  • Vieses (b): permitem deslocar ativações independentemente das entradas.

Uma ideia-chave de escalabilidade: o aprendizado profundo moderno funciona treinando modelos com muitos parâmetros em grandes conjuntos de dados usando otimização baseada em gradiente eficiente.

Exemplo de contagem de parâmetros

Uma camada densa de (d=784) (ex.: uma imagem 28×28 achatada) para (m=256) tem:

  • pesos: (784 \times 256 = 200{,}704)
  • vieses: (256)

Total: 200,960 parâmetros apenas nessa camada.

A inicialização importa

Treinar redes profundas é sensível a como os parâmetros começam. Inicializações comuns (ex.: Xavier/Glorot, He/Kaiming) visam manter as magnitudes de ativações e gradientes em uma faixa razoável ao longo da profundidade.

A passagem para frente: “execute a função”

Uma passagem para frente (forward pass) significa calcular (\hat{y} = f(x; \theta)) para um lote de entradas. Em frameworks de aprendizado profundo, a passagem para frente constrói (ou corresponde a) um grafo computacional (computational graph) de operações com tensores.

Pontos práticos:

  • As entradas geralmente são agrupadas em lotes: (X \in \mathbb{R}^{B \times d})
  • Camadas operam sobre lotes inteiros por eficiência.
  • A passagem para frente é a fase de “previsão”; o treinamento adiciona cálculo de gradientes e atualizações de parâmetros.

Exemplo: uma pequena passagem para frente de um MLP (estilo NumPy)

import numpy as np

def relu(z):
    return np.maximum(0, z)

def softmax(logits):
    exps = np.exp(logits - logits.max(axis=1, keepdims=True))
    return exps / exps.sum(axis=1, keepdims=True)

# Parameters
W1 = np.random.randn(784, 256) * 0.01
b1 = np.zeros((1, 256))
W2 = np.random.randn(256, 10) * 0.01
b2 = np.zeros((1, 10))

def forward(X):
    h = relu(X @ W1 + b1)      # (B, 256)
    logits = h @ W2 + b2       # (B, 10)
    probs = softmax(logits)    # (B, 10)
    return probs

Isso ilustra o padrão central: afim → ativação → afim → saída.

Funções de perda: definem o que significa “boas previsões”

O treinamento precisa de um objetivo escalar para otimizar. Uma função de perda mede quão distantes as previsões estão dos alvos.

Perdas comuns:

  • Erro quadrático médio (mean squared error, MSE) para regressão: [ \mathcal{L} = \frac{1}{B}\sum_i (\hat{y}_i - y_i)^2 ]
  • Perda de entropia cruzada (cross-entropy loss) para classificação (com probabilidades softmax): [ \mathcal{L} = -\frac{1}{B}\sum_i \log p(y_i \mid x_i) ]

Frequentemente minimizamos perda + penalidades de regularização (regularization penalties) (ex.: decaimento de pesos (weight decay)).

Treinamento: otimização baseada em gradiente em uma figura

Treinar significa escolher parâmetros (\theta) que minimizam a perda esperada:

[ \min_\theta \ \mathbb{E}_{(x,y)\sim \mathcal{D}} \left[\mathcal{L}(f(x;\theta), y)\right] ]

Na prática, usamos mini-lotes (mini-batches) para estimar gradientes e atualizar parâmetros iterativamente.

O loop de treinamento (conceitual)

  1. Amostrar um mini-lote ((X, Y))
  2. Passagem para frente: calcular previsões (\hat{Y})
  3. Calcular a perda
  4. Calcular gradientes (gradients) (\nabla_\theta \mathcal{L}) (geralmente via Retropropagação)
  5. Atualizar parâmetros usando um otimizador (SGD, Adam etc.)

É aqui que redes neurais se conectam fortemente à Descida do Gradiente e à otimização numérica.

Por que gradientes?

Redes neurais normalmente são diferenciáveis de ponta a ponta. Gradientes dizem como alterar cada parâmetro para reduzir a perda da forma mais eficiente (localmente).

Otimizadores que você verá na prática

  • Descida estocástica do gradiente (stochastic gradient descent, SGD): simples e forte, especialmente com momento (momentum).
  • Adam/AdamW: taxas de aprendizado adaptativas; padrão comum para transformers e muitos setups modernos.
  • Cronogramas de taxa de aprendizado (learning rate schedules): aquecimento (warmup), decaimento cosseno (cosine decay) e decaimento em degraus (step decay) podem importar tanto quanto a escolha do otimizador.

A pilha mais ampla do aprendizado profundo: onde redes neurais se encaixam

Redes neurais não “funcionam sozinhas”. Um sistema prático de aprendizado profundo tipicamente inclui:

  • Pipeline de dados: coleta, limpeza, rotulagem, aumento, criação de lotes, embaralhamento
  • Definição do modelo: arquitetura + inicialização de parâmetros
  • Objetivo: perda + métricas
  • Otimização: otimizador + cronograma de taxa de aprendizado
  • Infraestrutura de treinamento: GPUs/TPUs, precisão mista (mixed precision), treinamento distribuído (distributed training)
    (veja Treinamento em Escala)
  • Avaliação: divisões de validação, conjuntos de teste, checagens de robustez
  • Implantação: latência, vazão (throughput), quantização, monitoramento, detecção de deriva (drift detection)

Essa pilha é o motivo de o aprendizado profundo ser tanto uma disciplina de engenharia quanto de modelagem.

Aprendizado de representações: o que as redes “aprendem” internamente

Um dos principais motivos pelos quais redes neurais são poderosas é que elas podem aprender representações (representations) — características intermediárias que tornam a tarefa mais fácil.

Por exemplo, em um classificador de imagens:

  • camadas iniciais detectam bordas e texturas,
  • camadas intermediárias detectam partes (rodas, olhos),
  • camadas finais detectam objetos.

Essa ideia se generaliza além de visão e é central para Aprendizado de Representações. Também é por isso que o pré-treinamento (pretraining) funciona: modelos aprendem características amplas que se transferem para novas tarefas.

Exemplos práticos: onde redes neurais brilham

Exemplo 1: regressão tabular (prever preços de casas)

  • Entradas: metragem quadrada, quartos, bairro etc.
  • Modelo: pequeno perceptron multicamadas
  • Perda: MSE ou perda de Huber (Huber loss)
  • Nota prática: dados tabulares frequentemente se beneficiam de forte pré-processamento (preprocessing) e boas linhas de base (baselines) (modelos lineares, árvores com boosting de gradiente). Redes neurais podem funcionar bem, mas nem sempre são a melhor escolha mais simples.

Exemplo 2: classificação de imagens (gatos vs. cachorros)

  • Entradas: pixels
  • Modelo: CNN
  • Por que CNN: a convolução codifica localidade e invariância a translação
  • Treinamento: entropia cruzada, aumento de dados (data augmentation) (recortes aleatórios (random crops), espelhamentos (flips))

Exemplo 3: modelagem de linguagem (prever o próximo token)

  • Entradas: sequências de tokens
  • Modelo: transformer
  • Sinal de treinamento: previsão do próximo token (auto-supervisionado)
    Veja Aprendizado Auto-Supervisionado.

Profundidade, largura e viés indutivo (como pensar sobre escolhas de arquitetura)

Profundidade vs. largura

  • Redes mais largas (mais unidades por camada) podem memorizar e representar muitas funções.
  • Redes mais profundas (mais camadas) frequentemente representam funções complexas de forma mais eficiente (com menos parâmetros), ao compor características reutilizáveis.

Na prática, profundidade é um ingrediente-chave no aprendizado “profundo”.

Viés indutivo: suposições embutidas que ajudam no aprendizado

Arquiteturas têm sucesso quando sua estrutura combina com os dados:

  • CNNs assumem que pixels próximos se relacionam fortemente.
  • RNNs assumem dependência sequencial com um estado em execução.
  • Transformers assumem que relações podem ser aprendidas via padrões de atenção.

Viés indutivo pode reduzir requisitos de dados e melhorar generalização.

Generalização e sobreajuste (importante, mesmo neste nível)

Redes neurais podem sofrer sobreajuste (overfitting): alcançar baixa perda no treinamento, mas ter desempenho ruim em novos dados. Mitigações comuns incluem:

  • Mais dados ou melhores rótulos
  • Aumento de dados (especialmente em visão e áudio)
  • Decaimento de pesos (L2 regularization)
  • Dropout (dropout)
  • Parada antecipada (early stopping)
  • Camadas de normalização (normalization layers) (BatchNorm (normalização em lote, batch normalization), LayerNorm (normalização por camada, layer normalization)) para estabilidade de treinamento
  • Práticas adequadas de validação para evitar vazamento

Esses tópicos se conectam à dinâmica de treinamento e normalmente são expandidos em artigos sobre Regularização e otimização.

Terminologia comum (referência rápida)

  • Modelo / rede: a função parametrizada (f(x;\theta))
  • Arquitetura: o arranjo específico de camadas e conexões
  • Parâmetros / pesos: números aprendíveis ajustados durante o treinamento
  • Hiperparâmetros (hyperparameters): definidos por você (taxa de aprendizado, profundidade, tamanho do lote)
  • Logits (logits): saídas brutas não normalizadas antes de sigmoide/softmax
  • Ativação: saída de um neurônio ou camada após a não linearidade
  • Lote (batch): um grupo de exemplos processados em conjunto
  • Época (epoch): uma passagem por todo o conjunto de treinamento
  • Passo de treinamento / iteração (training step / iteration): uma atualização de parâmetros

Limitações e considerações

Redes neurais são extremamente capazes, mas não são mágicas:

  • Exigentes em dados e computação: o melhor desempenho frequentemente requer grandes conjuntos de dados e aceleradores.
  • Sensibilidade à otimização: taxas de aprendizado, inicialização e normalização podem fazer o treinamento dar certo ou errado.
  • Fragilidade: mudanças de distribuição (distribution shifts) e entradas adversariais (adversarial inputs) podem causar falhas.
  • Interpretabilidade (interpretability): representações internas podem ser difíceis de explicar.
  • Segurança e equidade (safety and fairness): dados enviesados podem produzir resultados enviesados; monitoramento é essencial.

Para onde ir a seguir

Com o básico no lugar, os próximos passos naturais são:

Redes neurais são melhor entendidas como programas diferenciáveis (differentiable programs) que aprendem a partir de dados. Quando você estiver confortável com passagens para frente, parâmetros, perdas e atualizações baseadas em gradiente, o restante do aprendizado profundo é, em grande parte, sobre escolher arquiteturas melhores, procedimentos de treinamento melhores e dados melhores.