Ativações e Perdas

Visão geral: por que ativações e perdas importam

Em uma rede neural (neural network), funções de ativação (activation functions) definem como os sinais são transformados entre camadas, e funções de perda (loss functions) definem o que significa “bom desempenho” durante o treinamento. Juntas, elas determinam:

  • Poder de representação (por exemplo, a não linearidade permite fronteiras de decisão complexas)
  • Fluxo de gradientes (gradient flow) (o quão bem os sinais de aprendizado se propagam; veja Problemas de Gradiente e Retropropagação)
  • Comportamento de otimização (curvatura da perda, estabilidade; veja Otimizadores)
  • Significado estatístico (muitas perdas correspondem a maximizar a verossimilhança sob um modelo de ruído assumido)

Um modelo mental útil:

  • Ativações de camadas ocultas moldam como o modelo consegue computar.
  • Ativações de saída + perdas moldam o que o modelo é treinado para prever (probabilidades, valores reais, distribuições, vetores de incorporação (embeddings), etc.).

Funções de ativação

Uma função de ativação aplica uma transformação não linear à pré-ativação de um neurônio: [ z = W x + b,\quad a = \phi(z) ] Sem não linearidade, empilhar camadas colapsa em um único mapeamento linear.

O que torna uma ativação “boa”?

Requisitos comuns:

  • Não linearidade: permite modelos expressivos.
  • Bons gradientes: evita gradientes que desaparecem (regiões planas) e ativações que explodem.
  • Eficiência computacional: importante em escala.
  • Saídas bem comportadas: por exemplo, saídas limitadas podem estabilizar, mas podem saturar.

Muitos tópicos de estabilidade de treinamento se conectam a Inicialização e Normalização (por exemplo, a inicialização de He está ligada a ativações do tipo ReLU) e à Diferenciação Automática (autodiff) (frameworks calculam derivadas dessas funções automaticamente).

Sigmoide (Sigmoid)

[ \sigma(z) = \frac{1}{1+e^{-z}} ]

  • Intervalo: (0, 1)
  • Prós: interpretável como probabilidade; historicamente usada em portas (por exemplo, LSTMs).
  • Contras: satura para |z| grande, causando gradientes que desaparecem; saídas não são centradas em zero.

Onde é usada

  • Camada de saída para probabilidade binária (frequentemente combinada com entropia cruzada binária).
  • Portas em arquiteturas recorrentes (menos comum em blocos Transformer modernos).

Nota prática: para estabilidade numérica, prefira perdas “com logits (logits)” (por exemplo, BCEWithLogitsLoss) em vez de aplicar a sigmoide explicitamente.

Tangente hiperbólica (Tanh)

[ \tanh(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}} ]

  • Intervalo: (-1, 1), centrada em zero.
  • Prós: frequentemente melhor do que sigmoide em camadas ocultas.
  • Contras: ainda satura → gradientes que desaparecem.

Onde é usada

  • Algumas redes recorrentes e saídas limitadas.

ReLU (Unidade Linear Retificada, Rectified Linear Unit)

[ \mathrm{ReLU}(z)=\max(0,z) ]

  • Prós: simples, rápida, ativações esparsas, mitiga gradientes que desaparecem para z positivo.
  • Contras: “ReLUs mortas” quando neurônios ficam presos gerando 0 (gradiente 0 para z<0).

Onde é usada

  • Padrão para muitas redes MLP (perceptrons multicamadas) e CNNs (redes neurais convolucionais).

ReLU com vazamento (Leaky ReLU) / PReLU

[ \mathrm{LeakyReLU}(z)=\begin{cases} z & z>0\ \alpha z & z\le 0 \end{cases} ]

  • Prós: reduz neurônios mortos ao permitir pequena inclinação negativa.
  • PReLU aprende (\alpha) a partir dos dados.

ELU / SELU

  • ELU: região negativa suave ajuda a manter a média das ativações mais próxima de zero.
  • SELU: projetada para “redes auto-normalizantes” sob condições específicas (notavelmente com AlphaDropout e inicialização cuidadosa). Na prática, normalização por lote (Batch Normalization, BatchNorm) e normalização por camada (Layer Normalization, LayerNorm) são mais comuns.

Softplus

[ \mathrm{softplus}(z)=\log(1+e^z) ]

  • Alternativa suave à ReLU (nunca tem gradiente exatamente 0).
  • Usada quando você quer saídas positivas de forma suave (por exemplo, parâmetros de escala).

GELU e Swish (comuns em Transformers)

  • GELU (Unidade Linear de Erro Gaussiano, Gaussian Error Linear Unit): usada em modelos do tipo BERT.
  • Swish: (z \cdot \sigma(z)), família relacionada; frequentemente forte empiricamente.

Elas são suaves, não monotônicas (em partes) e tendem a funcionar bem com normalização moderna (por exemplo, LayerNorm) na Arquitetura Transformer.

Softmax (para saídas multiclasse)

[ \mathrm{softmax}(z)_i=\frac{e^{z_i}}{\sum_j e^{z_j}} ]

  • Produz uma distribuição categórica sobre classes.
  • Geralmente combinada com perda de entropia cruzada calculada a partir de logits para estabilidade (CrossEntropyLoss).

Linear / identidade (sem ativação)

Usada para saídas de regressão não restritas: [ \phi(z)=z ]

Em geral, você não quer restringir o intervalo de saída, a menos que o alvo exija isso.

Escolhendo ativações na prática (regras de bolso)

  • Camadas ocultas:
    • Padrão: ReLU, GELU (especialmente em Transformers) ou SiLU/Swish.
    • Se unidades mortas aparecerem: LeakyReLU.
  • Camada de saída:
    • Probabilidade de classe binária: sigmoide + entropia cruzada binária (prefira BCE-com-logits).
    • Multiclasse com um único rótulo: softmax + entropia cruzada (prefira entropia cruzada a partir de logits).
    • Multirrótulo (rótulos independentes): sigmoide por classe + entropia cruzada binária.
    • Regressão sem limites: saída linear + perda de regressão (erro quadrático médio/perda de Huber/erro absoluto médio).
    • Valores apenas positivos (taxas, escalas): softplus ou exponencial + perda apropriada baseada em verossimilhança.

Funções de perda: o que elas otimizam

Uma função de perda (L(\theta)) mede o erro ao longo de um conjunto de dados. O treinamento tipicamente minimiza o risco empírico: [ \min_\theta \frac{1}{N}\sum_{n=1}^N \ell(f_\theta(x_n), y_n) ] A maior parte do aprendizado profundo usa métodos baseados em gradiente; veja Descida do Gradiente e Otimizadores.

Uma ideia-chave: muitas perdas populares são log-verossimilhanças negativas (negative log-likelihood, NLL) sob um modelo probabilístico. Minimizar NLL corresponde à estimação por máxima verossimilhança (maximum likelihood estimation, MLE).

Perdas de regressão

Erro Quadrático Médio (Mean Squared Error, MSE, L2)

[ \ell(\hat{y},y)=|\hat{y}-y|_2^2 ]

  • Otimiza: equivalente à MLE sob ruído Gaussiano com variância fixa.
  • Comportamento: penaliza fortemente erros grandes (sensível a outliers).
  • Gradiente: linear no erro, pode ser grande para resíduos elevados.

Quando usar

  • Alvos com ruído aproximadamente Gaussiano.
  • Você quer penalizar fortemente erros grandes.

Erro Absoluto Médio (Mean Absolute Error, MAE, L1)

[ \ell(\hat{y},y)=|\hat{y}-y|_1 ]

  • Otimiza: a mediana sob certas suposições; corresponde a ruído de Laplace.
  • Comportamento: mais robusto a outliers do que o erro quadrático médio.
  • Desvantagem: gradiente com magnitude constante (exceto em 0), pode ser menos suave para otimização.

Perda de Huber (Huber loss) (L1 suave)

Quadrática perto de zero, linear para erros grandes.

  • Otimiza: um compromisso robusto entre erro quadrático médio e erro absoluto médio.
  • Quando usar: regressão com outliers ocasionais (padrão comum em regressão de caixas de detecção).

Perda de quantil (pinball loss)

Usada para prever quantis condicionais (por exemplo, percentis 10/50/90), útil para estimativas de incerteza.

Exemplo prático: prever demanda com penalidade assimétrica (subprevisão pior do que superprevisão).

Regressão distribucional (distributional regression) (heteroscedástica (heteroscedastic))

Em vez de prever apenas (\hat{y}), preveja parâmetros de uma distribuição, por exemplo, Gaussiana ((\mu,\sigma)), e minimize NLL: [ \ell = \frac{(y-\mu)^2}{2\sigma^2} + \log \sigma ]

  • Otimiza: verossimilhança; aprende incerteza dependente da entrada.
  • Requer restringir (\sigma>0) (por exemplo, saída softplus).

Perdas de classificação

Entropia cruzada binária (binary cross-entropy, BCE)

Para (y\in{0,1}), com probabilidade prevista (p): [ \ell = -y\log p -(1-y)\log(1-p) ]

  • Otimiza: NLL Bernoulli (MLE).
  • Caso de uso: classificação binária, classificação multirrótulo (por rótulo).

Dica de estabilidade: calcule BCE diretamente a partir de logits (z):

  • (p=\sigma(z)) internamente
  • evita overflow/underflow para |z| grande

Entropia cruzada categórica (categorical cross-entropy) (entropia cruzada softmax)

Para classificação multiclasse com um único rótulo, com logits (z) e classe verdadeira (k): [ \ell = -\log \mathrm{softmax}(z)_k ]

  • Otimiza: NLL categórica (MLE).
  • Caso de uso: uma entre K classes.

Importante: a maioria das bibliotecas espera logits brutos, não probabilidades softmax.

Suavização de rótulos (label smoothing)

Substitui alvos one-hot rígidos por uma distribuição suavizada (por exemplo, 0.9 para a classe correta, restante distribuído entre as outras).

  • Efeito: reduz excesso de confiança, frequentemente melhora calibração e generalização.
  • Interpretação: adiciona um viés regularizador em direção a previsões de maior entropia.
  • Relacionado a Regularização.

Perda focal (focal loss)

Reduz o peso de exemplos fáceis para focar o aprendizado em exemplos difíceis/raros: [ \ell = -(1-p_t)^\gamma \log(p_t) ]

  • Caso de uso: desbalanceamento de classes (por exemplo, detecção densa de objetos).
  • Trade-off: pode piorar a calibração; adiciona um hiperparâmetro (\gamma).

Perda hinge (hinge loss) (estilo SVM)

Incentiva uma margem: [ \ell = \max(0, 1 - y \cdot f(x)) ] (com (y\in{-1,+1}))

  • Otimiza: separação por margem em vez de verossimilhança probabilística.
  • Menos comum em redes profundas modernas para classificação, mas usada em algumas formulações de aprendizado métrico.

Perdas para segmentação e métricas de sobreposição

Entropia cruzada por pixel é comum, mas perdas baseadas em sobreposição miram diretamente a similaridade de regiões.

Perda Dice (Dice loss) / perda F1 (F1 loss)

Coeficiente Dice: [ \mathrm{Dice} = \frac{2|A\cap B|}{|A|+|B|} ] A perda Dice frequentemente usa uma versão “suave” diferenciável.

  • Otimiza: sobreposição; útil para desbalanceamento entre primeiro plano/fundo.
  • Caso de uso: segmentação de imagens médicas.

Perda IoU / Jaccard

[ \mathrm{IoU} = \frac{|A\cap B|}{|A\cup B|} ]

  • Motivação similar; às vezes mais difícil de otimizar do que Dice dependendo da formulação.

Frequentemente, profissionais combinam:

  • entropia cruzada (boa supervisão por pixel)
    • Dice/IoU (bom objetivo global de sobreposição)

Perdas de aprendizado métrico (metric learning) e aprendizado de representações (representation learning)

Essas perdas moldam a geometria de espaços de vetores de incorporação.

Perda contrastiva (contrastive loss) / perdas siamesas (Siamese losses)

Incentivam pares similares a ficarem próximos e pares dissimilares a ficarem distantes (frequentemente com uma margem).

  • Caso de uso: reconhecimento facial, recuperação (retrieval).

Perda de tríplice (triplet loss)

Dado âncora (a), positivo (p), negativo (n): [ \ell = \max(0, d(a,p) - d(a,n) + m) ]

  • Otimiza: ranqueamento relativo com uma margem.
  • Desafio: requer boa estratégia de mineração (negativos difíceis/semi-difíceis).

InfoNCE / NT-Xent (entropia cruzada contrastiva)

Comum em aprendizado auto-supervisionado: trata visões correspondentes como positivas entre muitos negativos.

  • Otimiza: um limite inferior relacionado à informação mútua em alguns cenários; na prática, aprende vetores de incorporação discriminativos.

Perdas de alinhamento de distribuições (distribution matching)

Divergência KL (KL divergence)

[ D_{KL}(p|q) = \sum_i p_i \log\frac{p_i}{q_i} ]

  • Usada em destilação (distillation) (professor-aluno), autoencoders variacionais (variational autoencoders, VAEs) e quando se alinham distribuições previstas.
  • Não é simétrica; a direção importa.

Entropia cruzada vs KL

Entropia cruzada (H(p,q) = H(p) + D_{KL}(p|q)). Se (p) (alvos) é fixo, minimizar entropia cruzada é equivalente a minimizar KL.

Perdas de modelagem de sequência (sequence modeling)

Para modelagem de linguagem (language modeling), o padrão é entropia cruzada em nível de token (token-level cross-entropy) sobre um vocabulário, somada/mediada ao longo das posições (frequentemente com mascaramento (masking)). Isso é a NLL da distribuição do próximo token, isto é, MLE.

Combinando saídas, ativações e perdas (padrões comuns)

Classificação binária

  • Saída do modelo: um logit (z)
  • Ativação: (implícita) sigmoide
  • Perda: BCE-com-logits

Exemplo em PyTorch

import torch
import torch.nn as nn

logits = model(x)              # shape: [batch]
loss_fn = nn.BCEWithLogitsLoss()
loss = loss_fn(logits, y.float())

Classificação multiclasse com um único rótulo (K classes)

  • Saída do modelo: K logits
  • Ativação: (implícita) softmax
  • Perda: entropia cruzada
loss_fn = nn.CrossEntropyLoss(label_smoothing=0.1)  # optional smoothing
logits = model(x)            # [batch, K]
loss = loss_fn(logits, y)    # y: [batch] int class indices

Classificação multirrótulo (K rótulos independentes)

  • Saída do modelo: K logits
  • Ativação: sigmoide por classe
  • Perda: BCE-com-logits (frequentemente com pesos por classe para desbalanceamento)
loss_fn = nn.BCEWithLogitsLoss(pos_weight=pos_weight_tensor)  # optional
logits = model(x)                 # [batch, K]
loss = loss_fn(logits, y.float()) # y: 0/1 multi-hot

Regressão

  • Saída do modelo: valor(es) real(is)
  • Ativação: linear (identidade)
  • Perda: erro quadrático médio / erro absoluto médio / Huber dependendo de outliers e do comportamento desejado
loss_fn = nn.HuberLoss(delta=1.0)
pred = model(x)
loss = loss_fn(pred, y)

Prevendo quantidades positivas

Exemplos: parâmetros de taxa, variâncias, escalas, contagens.

  • Saída do modelo: log-parâmetro não restrito
  • Ativação: softplus (ou exp) para garantir positividade
  • Perda: baseada em verossimilhança (por exemplo, NLL de Poisson, NLL Gaussiana com sigma previsto)
sigma = torch.nn.functional.softplus(raw_sigma) + 1e-6
nll = ((y - mu)**2) / (2*sigma**2) + torch.log(sigma)
loss = nll.mean()

Considerações práticas e armadilhas comuns

“Não coloque softmax/sigmoide antes da entropia cruzada” (geralmente)

Muitos frameworks fornecem perdas fusionadas e numericamente estáveis:

  • CrossEntropyLoss espera logits, não saídas softmax.
  • BCEWithLogitsLoss espera logits, não saídas sigmoide.

Aplicar softmax/sigmoide por conta própria pode levar a:

  • pior estabilidade numérica
  • computação duplicada
  • às vezes gradientes piores devido a arredondamento

Saturação e fluxo de gradientes

  • Sigmoide/tanh saturam nos extremos → gradientes quase zero → aprendizado lento.
  • ReLU evita saturação para valores positivos, mas pode morrer para negativos.

Esses problemas se conectam a:

A escolha da perda muda o que “melhor” significa

Duas perdas podem ranquear modelos de forma diferente porque codificam prioridades distintas:

  • Erro quadrático médio prefere reduzir erros grandes agressivamente.
  • Erro absoluto médio trata todos os erros absolutos de forma linear (robusto).
  • Entropia cruzada treina classificadores probabilísticos; hinge treina classificadores por margem.
  • Dice/IoU otimizam diretamente sobreposição, frequentemente alinhando melhor com métricas de avaliação de segmentação do que acurácia por pixel.

Um fluxo de trabalho prático é escolher uma perda que se alinhe com:

  1. as suposições do processo gerador de dados (modelo de ruído),
  2. a métrica de avaliação que você considera,
  3. a estabilidade de otimização que você consegue obter.

Desbalanceamento de classes

Opções incluem:

  • Reponderação (pesos de classe, pos_weight em BCE)
  • Perda focal
  • Reamostragem (nível de dados)
  • Ajuste de limiar e calibração pós-treinamento

Atenção: reponderação pesada e perda focal podem reduzir a calibração de probabilidades; você pode precisar de métodos de calibração depois.

Regularização interage com perdas

Exemplos comuns:

  • Suavização de rótulos atua como regularização para classificação.
  • Decaimento de pesos (weight decay) muda o ótimo efetivo sob perdas convexas e afeta generalização (veja Regularização).
  • Algumas perdas (por exemplo, contrastivas) são sensíveis à composição do lote; regularização e aumentação (augmentation) passam a fazer parte do “sistema de perda”.

Recomendações rápidas (“cheat sheet”)

  • Blocos MLP de Transformers: GELU (ou SiLU/Swish), LayerNorm; entropia cruzada para modelagem de linguagem.
  • Classificação geral: logits + entropia cruzada; considere suavização de rótulos.
  • Binária / multirrótulo: logits + BCE-com-logits; considere pos_weight ou perda focal para desbalanceamento.
  • Regressão robusta: Huber é um ótimo padrão; erro absoluto médio se você realmente quer comportamento de mediana.
  • Segmentação: entropia cruzada + Dice (especialmente com desbalanceamento).
  • Incerteza: prever parâmetros de distribuição e usar NLL (por exemplo, NLL Gaussiana).

Tópicos relacionados