Função Sigmoide

Definição

A função sigmoide (também chamada de função logística (logistic function)) é uma função suave, em formato de S, que mapeia qualquer entrada real para o intervalo aberto ((0, 1)). Ela é definida como:

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

Como sua saída fica entre 0 e 1, a sigmoide é amplamente usada em aprendizado de máquina (machine learning) para converter logits (pontuações não normalizadas) em probabilidades para classificação binária e classificação multi-rótulo.

No aprendizado profundo (deep learning) moderno, a sigmoide é mais comumente usada na camada de saída, enquanto outras ativações (por exemplo, variantes de ReLU) geralmente são preferidas em camadas ocultas devido ao comportamento de saturação da sigmoide (discutido abaixo).

Forma e intuição

Propriedades-chave

  • Intervalo: (\sigma(x) \in (0, 1)) para todo (x) real
  • Monotônica: se (x_1 < x_2), então (\sigma(x_1) < \sigma(x_2))
  • Simetria: (\sigma(-x) = 1 - \sigma(x))
  • Ponto médio: (\sigma(0) = 0.5)
  • Assíntotas:
    • (x \to +\infty \Rightarrow \sigma(x) \to 1)
    • (x \to -\infty \Rightarrow \sigma(x) \to 0)

Interpretação geométrica

A função sigmoide “comprime” a reta real em ((0, 1)):

  • Logits positivos grandes tornam-se probabilidades próximas de 1.
  • Logits negativos grandes tornam-se probabilidades próximas de 0.
  • Entradas próximas de 0 produzem probabilidades próximas de 0.5.

Esse comportamento faz dela uma função de ligação natural entre pontuações lineares e probabilidades.

Derivada e gradientes

A sigmoide tem uma derivada particularmente conveniente:

[ \frac{d}{dx}\sigma(x) = \sigma(x)\left(1 - \sigma(x)\right) ]

Consequências da derivada

  • A derivada é máxima em (x = 0), onde (\sigma(0)=0.5): [ \sigma'(0) = 0.5(1-0.5)=0.25 ]
  • A derivada se torna muito pequena quando (x) é muito positivo ou muito negativo (saturação):
    • Se (\sigma(x) \approx 1), então (1-\sigma(x)\approx 0), logo (\sigma'(x)\approx 0)
    • Se (\sigma(x) \approx 0), então (\sigma(x)\approx 0), logo (\sigma'(x)\approx 0)

Isso leva diretamente ao clássico problema de gradiente que desaparece (vanishing gradient) quando a sigmoide é usada repetidamente em redes profundas (veja “Saturação e gradientes que desaparecem”).

Sigmoide como mapeamento de probabilidade para classificação binária

Logits e probabilidades

Em muitos modelos, a rede produz um número real (z), chamado de logit. A sigmoide o converte em uma probabilidade:

[ p(y=1 \mid x) = \sigma(z) ]

Então:

[ p(y=0 \mid x) = 1 - \sigma(z) ]

Uma regra de decisão comum é aplicar um limiar em 0.5:

  • prever classe 1 se (\sigma(z) \ge 0.5)
  • prever classe 0 caso contrário

Como (\sigma(0)=0.5), isso é equivalente a aplicar um limiar no logit:

  • prever classe 1 se (z \ge 0)
  • prever classe 0 se (z < 0)

Odds e a ligação logit

A sigmoide está intimamente ligada às odds. Se (p=\sigma(z)), então:

[ \frac{p}{1-p} = e^{z} ]

Aplicando logaritmo, obtemos:

[ \log\left(\frac{p}{1-p}\right) = z ]

Assim, o logit (z) é literalmente o log-odds. Por isso, a sigmoide é o elo canônico para desfechos Bernoulli em estatística e fundamenta a Regressão Logística.

Relação com regressão logística

A regressão logística (logistic regression) modela o logit como uma função linear das características:

[ z = w^\top x + b ] [ p(y=1\mid x) = \sigma(w^\top x + b) ]

Embora a regressão logística seja um modelo “raso”, essa mesma camada de saída aparece em redes neurais: um modelo profundo aprende uma representação (h(x)), depois aplica uma camada linear final para produzir (z) e usa a sigmoide para interpretar (z) como probabilidade.

Em outras palavras, um classificador binário com rede neural frequentemente termina com “regressão logística sobre características aprendidas”.

Sigmoide e entropia cruzada binária (BCE)

Visão de verossimilhança Bernoulli

Para alvos binários (y \in {0,1}) e probabilidade prevista (p), a verossimilhança Bernoulli é:

[ P(y \mid p) = p^y (1-p)^{1-y} ]

A log-verossimilhança negativa (negative log-likelihood, NLL) é:

[ -\log P(y \mid p) = -\left[ y\log p + (1-y)\log(1-p)\right] ]

Essa é a perda de entropia cruzada binária (binary cross-entropy, BCE):

[ \mathcal{L}_{\text{BCE}}(y,p) = -\left[ y\log p + (1-y)\log(1-p)\right] ]

Quando você define (p = \sigma(z)), obtém o pareamento padrão usado em classificação binária: sigmoide + BCE. Veja também Perda de Entropia Cruzada para a perspectiva mais ampla.

Uma simplificação de gradiente muito importante

Ao combinar sigmoide com BCE como função do logit (z), a derivada fica especialmente simples:

[ \frac{\partial \mathcal{L}}{\partial z} = \sigma(z) - y ]

Essa é uma das razões pelas quais a combinação “sigmoide + BCE” é tão usada: ela produz um sinal de aprendizado estável e interpretável — probabilidade prevista menos o alvo.

Classificação multi-rótulo

Para problemas multi-rótulo com (K) rótulos independentes, normalmente você aplica sigmoide por rótulo:

[ p_k = \sigma(z_k) ]

e soma a BCE entre rótulos:

[ \mathcal{L} = \sum_{k=1}^K \mathcal{L}_{\text{BCE}}(y_k, p_k) ]

Isso difere da Função Softmax, que cria uma única distribuição de probabilidade sobre classes mutuamente exclusivas.

Notas práticas: saturação e gradientes que desaparecem

Saturação

A sigmoide satura para (|x|) grande:

  • Se (x \gg 0), (\sigma(x)\approx 1)
  • Se (x \ll 0), (\sigma(x)\approx 0)

Em ambos os casos, a derivada (\sigma'(x)) fica próxima de zero, então os gradientes podem desaparecer.

Gradientes que desaparecem em redes profundas

Se a sigmoide é usada em muitas camadas, os gradientes propagados para trás pela rede (via Retropropagação) podem encolher de forma multiplicativa porque cada camada contribui com fatores (\sigma'(x)\le 0.25). Ao longo de muitas camadas, isso pode tornar o aprendizado extremamente lento ou até travar completamente.

Essa é uma razão-chave pela qual redes profundas modernas frequentemente usam ativações da família ReLU em camadas ocultas, reservando a sigmoide principalmente para:

  • probabilidades de saída em tarefas binárias ou multi-rótulo
  • portas (gates) em LSTMs/GRUs (onde o intervalo ((0,1)) da sigmoide é útil para controlar o fluxo de informação)

Estabilidade numérica: computando sigmoide e BCE com segurança

Por que a instabilidade acontece

A sigmoide envolve (e^{-x}). Para (|x|) grande, um cálculo ingênuo pode causar overflow/underflow:

  • Se (x \ll 0), (e^{-x} = e^{|x|}) pode estourar (overflow)
  • Se (x \gg 0), (e^{-x}) tende a 0 por underflow (geralmente seguro, mas ainda pode causar problemas no (\log(1-p)) a jusante)

De forma semelhante, calcular BCE ingenuamente a partir de probabilidades pode levar a (\log(0)) se (p) se tornar exatamente 0 ou 1 por causa de precisão finita.

Implementação estável da sigmoide

Uma abordagem estável comum ramifica pelo sinal de (x):

[ \sigma(x) = \begin{cases} \frac{1}{1+e^{-x}} & x \ge 0 \ \frac{e^{x}}{1+e^{x}} & x < 0 \end{cases} ]

Isso evita overflow quando (x) é muito negativo.

Prefira “BCE com logits” a “sigmoide e depois BCE”

Na prática, a maioria das bibliotecas fornece uma função combinada e numericamente estável que recebe logits diretamente:

  • PyTorch: torch.nn.BCEWithLogitsLoss
  • TensorFlow: tf.nn.sigmoid_cross_entropy_with_logits

Essas funções calculam BCE de um modo que evita cancelamento catastrófico e (\log(0)).

Uma forma estável comum usa a função softplus:

[ \text{softplus}(t) = \log(1 + e^{t}) ]

Uma expressão estável para BCE com logit (z) é:

[ \mathcal{L}(y, z) = \max(z,0) - zy + \log(1 + e^{-|z|}) ]

Ela é amplamente usada porque se mantém estável tanto para logits grandes positivos quanto para logits grandes negativos.

Se você precisar usar probabilidades, faça clamp

Se você calcular explicitamente (p=\sigma(z)) e depois BCE, faça clamp para evitar (\log(0)):

[ p \leftarrow \text{clip}(p, \epsilon, 1-\epsilon) ]

com (\epsilon) como (10^{-7}) ou (10^{-12}), dependendo da precisão.

Exemplos trabalhados

Exemplo 1: Mapeando logits para probabilidades

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

logits = np.array([-4.0, -1.0, 0.0, 1.0, 4.0])
probs = sigmoid(logits)

print("logits:", logits)
print("probs :", probs)

Saída típica:

  • (-4 \to \sigma(-4)\approx 0.018)
  • (-1 \to 0.269)
  • (0 \to 0.5)
  • (1 \to 0.731)
  • (4 \to 0.982)

Interpretação: o logit é um escore de confiança em uma escala de log-odds; a sigmoide o converte em uma probabilidade.

Exemplo 2: Treinamento de classificação binária com logits (PyTorch)

import torch
import torch.nn as nn

# A simple linear model producing logits
model = nn.Linear(10, 1)

criterion = nn.BCEWithLogitsLoss()  # stable: combines sigmoid + BCE
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

x = torch.randn(32, 10)
y = torch.randint(0, 2, (32, 1)).float()

logits = model(x)                  # shape: (batch, 1)
loss = criterion(logits, y)

optimizer.zero_grad()
loss.backward()
optimizer.step()

# If you want probabilities for evaluation:
probs = torch.sigmoid(logits)
pred = (probs >= 0.5).float()

Prática-chave: treine com logits + BCEWithLogitsLoss e só aplique sigmoid quando precisar de probabilidades.

Quando (e quando não) usar sigmoide

Usos comuns

  • Camada de saída para classificação binária: um logit, sigmoide para obter (p(y=1))
  • Camada de saída para classificação multi-rótulo: (K) logits, sigmoide por rótulo
  • Mecanismos de gating: LSTMs/GRUs usam portas sigmoides para controlar o fluxo de informação entre 0 e 1
  • Calibração de probabilidade e interpretabilidade: as saídas da sigmoide podem ser interpretadas como probabilidades (embora nem sempre sejam perfeitamente calibradas sem técnicas adicionais)

Menos comum na prática moderna

  • Camadas ocultas em redes feedforward profundas: a sigmoide frequentemente prejudica a otimização devido à saturação/gradientes que desaparecem. Ativações da família ReLU tipicamente têm melhor desempenho em arquiteturas profundas.

Conexões com conceitos relacionados

  • BCE e NLL: a sigmoide transforma logits em probabilidades para um modelo Bernoulli; BCE é a log-verossimilhança negativa desse Bernoulli. Veja Perda de Entropia Cruzada.
  • Softmax vs sigmoide:
    • sigmoide: probabilidades independentes por saída (binária ou multi-rótulo)
    • softmax: uma distribuição de probabilidade sobre classes mutuamente exclusivas. Veja Função Softmax.
  • Otimização e gradientes: a estabilidade e o tamanho dos gradientes afetam o aprendizado via Descida do Gradiente e Retropropagação.
  • Visão de modelo: a regressão logística é o caso especial “linear + sigmoide” de um classificador com rede neural. Veja Regressão Logística.

Resumo

  • A função sigmoide (logística) é (\sigma(x)=\frac{1}{1+e^{-x}}), mapeando números reais para ((0,1)).
  • Ela é usada para converter logits em probabilidades para classificação binária e multi-rótulo.
  • Sua derivada (\sigma'(x)=\sigma(x)(1-\sigma(x))) é simples, mas leva à saturação e a gradientes que desaparecem para (|x|) grande, tornando a sigmoide menos adequada para camadas ocultas profundas.
  • A sigmoide está fortemente ligada à entropia cruzada binária: BCE é a log-verossimilhança negativa Bernoulli com (p=\sigma(z)), e o gradiente em relação ao logit simplifica para (\sigma(z)-y).
  • Para estabilidade numérica, prefira implementações de BCE com logits (por exemplo, BCEWithLogitsLoss) em vez de calcular sigmoide e depois BCE manualmente.