Dropout

Descarte Aleatório (Dropout): Removendo Unidades Aleatoriamente para Melhorar a Generalização

Descarte aleatório é uma técnica de regularização (regularization) amplamente usada para treinar Redes Neurais (Neural Networks). Durante o treinamento (training), o descarte aleatório zera aleatoriamente um subconjunto de ativações (activations) (ou, às vezes, pesos (weights)), de modo que a rede não possa depender de um único caminho através do modelo. Isso reduz a coadaptação (co-adaptation) entre neurônios e ajuda a evitar sobreajuste (overfitting), especialmente em modelos de alta capacidade.

Em alto nível:

  • Treinamento: “descartar” unidades aleatoriamente com probabilidade p (a taxa de descarte).
  • Inferência (inference): usar a rede completa, normalmente com o escalonamento apropriado para que as previsões permaneçam bem calibradas.

O descarte aleatório é simples, barato de implementar e é suportado essencialmente em todos os frameworks de aprendizado profundo (deep learning frameworks).

Por que o Descarte Aleatório Funciona

Reduzindo a coadaptação

Sem descarte aleatório, grupos de neurônios podem desenvolver dependências — por exemplo, o neurônio A só se torna útil quando o neurônio B dispara. Essa coadaptação pode levar a características frágeis que têm bom desempenho nos dados de treinamento, mas não generalizam.

Com o descarte aleatório, um neurônio não pode assumir que outros neurônios específicos estarão presentes, então ele é incentivado a aprender características úteis em muitas “sub-redes” diferentes.

Um comitê implícito de sub-redes

Cada máscara (mask) de descarte define uma sub-rede (subnetwork) diferente (uma rede “afinada”). Treinar com descarte aleatório pode ser visto como treinar um comitê de modelos (ensemble) extremamente grande de sub-redes que compartilham pesos. No momento da inferência, usar a rede completa aproxima a média das previsões desse comitê, o que tende a melhorar a generalização.

A injeção de ruído regulariza a função

O descarte aleatório injeta ruído de Bernoulli (Bernoulli noise) multiplicativo nas ativações. Esse ruído suaviza a função aprendida e desencoraja o modelo a depender de soluções estreitas e de alta variância — conceitualmente semelhante, em espírito, a outros regularizadores como Decaimento de Peso (Weight Decay) ou Parada Antecipada (Early Stopping), embora o mecanismo seja diferente.

Uma perspectiva bayesiana (MC Dropout)

O descarte aleatório também tem uma interpretação bayesiana (Bayesian) aproximada bem conhecida: manter o descarte aleatório ativo na inferência e amostrar várias passagens diretas estocásticas pode aproximar estimativas de incerteza (abordado mais adiante em descarte de Monte Carlo (MC dropout)). Isso se relaciona a ideias em Redes Neurais Bayesianas (Bayesian Neural Networks) e Estimativa de Incerteza (Uncertainty Estimation).

Descarte Aleatório Padrão (Standard Dropout) (Descarte de Ativação (Activation Dropout))

Definição

Seja (h) um vetor de ativação de alguma camada. O descarte aleatório padrão amostra uma máscara (m) com:

[ m_i \sim \text{Bernoulli}(q), \quad q = 1 - p ]

e forma:

  • Descarte ingênuo (naïve dropout) (conceitual): ( \tilde{h} = m \odot h )
  • Descarte invertido (inverted dropout) (comum na prática): ( \tilde{h} = \frac{m}{q} \odot h )

Aqui:

  • (p) é a taxa de descarte (dropout rate) (probabilidade de descartar).
  • (q) é a probabilidade de manter (keep probability).

Por que o “descarte invertido” é preferível

Com descarte invertido, a ativação esperada permanece a mesma durante o treinamento:

[ \mathbb{E}\left[\frac{m}{q}\odot h\right] = h ]

Assim, no momento da inferência você não faz nada de especial — não é necessário escalonamento. A maioria das bibliotecas modernas implementa o descarte aleatório dessa forma.

Onde ele é tipicamente aplicado

Posicionamentos comuns incluem:

  • Após uma não linearidade (por exemplo, ReLU/GELU) em um perceptron multicamadas (MLP)
  • Nas saídas de camadas densas (dense layers) em cabeças (heads) de classificação/regressão
  • Em incorporações (embeddings) em modelos de processamento de linguagem natural (NLP) (descarte de incorporação (embedding dropout))
  • Dentro de blocos de atenção (attention blocks) e blocos de alimentação direta (feed-forward blocks) em modelos de Arquitetura Transformer (Transformer Architecture) (normalmente com taxas menores)

Comportamento em Treinamento vs Inferência

O descarte aleatório tem comportamento diferente nos modos de treinamento e inferência:

  • Modo de treinamento: aplica mascaramento aleatório
  • Modo de avaliação/inferência: desabilita o mascaramento

Frameworks expõem isso explicitamente (por exemplo, model.train() vs model.eval() no PyTorch).

Implicação prática: cuidado ao avaliar

Um erro comum é esquecer de alternar para o modo de avaliação, o que torna as métricas ruidosas e geralmente piores porque o descarte aleatório ainda está ativo.

Semântica de minilote (mini-batch)

As máscaras de descarte aleatório normalmente são amostradas:

  • Por exemplo (cada amostra recebe sua própria máscara), e
  • Por passagem direta (forward pass) (nova máscara a cada iteração)

Algumas variantes compartilham máscaras intencionalmente ao longo de passos de tempo ou posições espaciais (coberto abaixo).

Variantes Comuns de Descarte Aleatório

1) DropConnect / Descarte de Pesos (Weight Dropout) (descartando pesos)

Em vez de zerar ativações, o DropConnect zera aleatoriamente pesos durante o treinamento. Conceitualmente:

[ W' = M \odot W ]

onde (M) é uma máscara de Bernoulli.

Isso pode ser útil quando você quer regularização diretamente no uso de parâmetros. Na prática, ele é menos comum do que o descarte de ativação, mas descarte de pesos aparece em alguns contextos recorrentes e em código de pesquisa.

2) Descarte Espacial (Spatial Dropout) (descarte por canal para CNNs)

Em Redes Neurais Convolucionais (Convolutional Neural Networks), descartar pixels/ativações individuais geralmente não é ideal porque ativações vizinhas são fortemente correlacionadas. O descarte espacial (frequentemente implementado como Dropout2d/Dropout3d) descarta mapas de características (feature maps) inteiros (canais (channels)), em vez de elementos individuais.

  • Descarte padrão: máscara independente por elemento
  • Descarte espacial: um valor de máscara por canal (compartilhado entre localizações espaciais)

Isso incentiva redundância entre canais e tende a funcionar melhor do que o descarte ingênuo em extratores de características convolucionais.

Uso típico: após blocos convolucionais, especialmente em cenários com poucos dados, ou em modelos de segmentação.

3) Descarte Aleatório em RNNs (cuidado: correlações temporais importam)

Para Redes Neurais Recorrentes (Recurrent Neural Networks), aplicar descarte aleatório de forma independente a cada passo de tempo pode injetar ruído demais e prejudicar o aprendizado. Abordagens comuns:

a) Descarte de entrada/saída

Aplique descarte aleatório em:

  • As incorporações de entrada que entram na RNN
  • As saídas entre camadas de RNN empilhadas

Isso é direto e comumente eficaz.

b) Descarte variacional (variational dropout) (descarte travado (locked dropout))

Use a mesma máscara de descarte em todos os passos de tempo para uma determinada sequência (às vezes chamado de descarte travado). Isso preserva a consistência temporal enquanto ainda regulariza.

c) Descarte recorrente (recurrent dropout) / descarte de pesos em conexões oculto-para-oculto (hidden-to-hidden connections)

Alguns métodos aplicam descarte aleatório às conexões recorrentes (oculto-para-oculto). Isso pode funcionar, mas é sensível; muitos praticantes preferem:

  • descarte de entrada/saída + máscaras travadas,
  • ou alternativas arquiteturais (por exemplo, modelos de atenção).

4) Descarte Aleatório em Transformers (descarte oculto/de atenção)

Modelos Transformer comumente usam vários pontos de descarte:

  • Descarte de atenção (attention dropout): nas probabilidades de atenção
  • Descarte oculto/residual (hidden/residual dropout): nas saídas das subcamadas
  • Descarte na FFN (FFN dropout): dentro da rede feed-forward

Taxas típicas de descarte em Transformers modernos e grandes frequentemente são pequenas (por exemplo, 0.0–0.1), especialmente ao treinar em conjuntos de dados massivos com forte aumento de dados ou regularização em outras partes.

Técnicas relacionadas como profundidade estocástica (stochastic depth) ou descartes de caminho (DropPath) às vezes são usadas em vez de (ou junto com) descarte aleatório, mas são métodos distintos.

Escolhendo Taxas de Descarte (Orientação Prática)

O descarte aleatório é um hiperparâmetro (hyperparameter); você deve ajustá-lo em um conjunto de validação (validation set). Ainda assim, há pontos de partida comuns.

Regras práticas

  • MLPs / classificadores densos: p = 0.2–0.5
    Um p maior pode ajudar quando os dados são poucos ou o modelo está com forte sobreajuste.
  • CNNs (extrator de características): p = 0.0–0.3
    Prefira descarte espacial para mapas de características convolucionais; use descarte mais alto com mais frequência na cabeça do classificador do que nas camadas convolucionais iniciais.
  • RNNs/LSTMs (Long Short-Term Memory)/GRUs (Gated Recurrent Unit): p = 0.1–0.5 para descarte de entrada/saída
    Considere descarte travado/variacional para sequências.
  • Transformers: frequentemente p = 0.0–0.1
    Aumente se você observar sobreajuste, mas cuidado: descarte demais pode desestabilizar a otimização em modelos profundos de atenção.

Como decidir na prática

  1. Procure o sintoma

    • A perda de treinamento diminui, a perda de validação aumenta → sobreajuste → aumente o descarte (ou adicione outra regularização).
    • A perda de treinamento é alta e não melhora → subajuste (underfitting) → reduza o descarte.

  2. Considere outros regularizadores Se você já usa forte Decaimento de Peso, aumento de dados e Parada Antecipada, você pode precisar de menos descarte.

  3. Atenção ao BatchNorm O descarte aleatório e a Normalização em Lote (Batch Normalization) podem interagir de formas não triviais:

    • A normalização em lote já injeta algum ruído via estatísticas do lote durante o treinamento.
    • Descarte intenso às vezes pode tornar a otimização mais difícil quando combinado com normalização em lote. Um padrão comum é usar menos descarte em redes com normalização em lote extensa, ou concentrar o descarte nas camadas finais.

  4. Comece pequeno e aumente Um fluxo de trabalho seguro é:

    • Começar com p = 0.1 (ou até 0.0 para treinamento com muitos dados).
    • Aumentar para 0.2, 0.3, etc., se as métricas de validação ficarem atrás das métricas de treinamento.

Exemplos Práticos

Exemplo 1: Descarte Aleatório Padrão em um MLP no PyTorch

import torch
import torch.nn as nn
import torch.nn.functional as F

class MLP(nn.Module):
    def __init__(self, d_in=784, d_hidden=512, d_out=10, p=0.5):
        super().__init__()
        self.fc1 = nn.Linear(d_in, d_hidden)
        self.drop = nn.Dropout(p)  # active only in model.train()
        self.fc2 = nn.Linear(d_hidden, d_out)

    def forward(self, x):
        x = self.fc1(x)
        x = F.relu(x)
        x = self.drop(x)
        return self.fc2(x)

model = MLP(p=0.5)
model.train()  # dropout ON
# ...
model.eval()   # dropout OFF

Ponto-chave: nn.Dropout(p) usa descarte invertido internamente, então a inferência não requer escalonamento manual.

Exemplo 2: Descarte Espacial em uma CNN (Dropout2d)

import torch.nn as nn

class SmallCNN(nn.Module):
    def __init__(self, p=0.2):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1),
            nn.ReLU(),
            nn.Dropout2d(p),  # drops whole channels
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(),
        )
        self.classifier = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Dropout(0.5),
            nn.Linear(64, 10)
        )

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

O descarte espacial geralmente é mais apropriado do que o descarte por elemento em mapas de características convolucionais.

Exemplo 3: Descarte de Monte Carlo para Estimativa de Incerteza

O descarte de Monte Carlo (MC dropout) mantém o descarte aleatório ativo na inferência e realiza múltiplas passagens diretas para aproximar uma distribuição preditiva (predictive distribution).

Casos de uso:

  • “Quão confiante é o modelo?”
  • Detectar entradas fora da distribuição (out-of-distribution) ou ambíguas (imperfeito, mas frequentemente útil)
  • Sistemas de tomada de decisão que precisam de limites de incerteza

Esboço em PyTorch:

import torch

def mc_predict(model, x, T=30):
    model.train()  # intentionally keep dropout ON
    preds = []
    with torch.no_grad():
        for _ in range(T):
            logits = model(x)
            preds.append(torch.softmax(logits, dim=-1))
    preds = torch.stack(preds, dim=0)  # [T, batch, classes]
    mean = preds.mean(dim=0)
    var = preds.var(dim=0)
    return mean, var

Notas:

  • Isso não é uma distribuição a posteriori (posterior) bayesiana completa; é uma aproximação.
  • A variância aqui reflete uma incerteza do tipo epistêmica (epistemic-like) sob a aproximação por descarte, mas depende da calibração e das condições de modelo/dados.

Descarte Aleatório no Conjunto Mais Amplo de Ferramentas de Regularização

O descarte aleatório raramente é usado sozinho. Combinações comuns:

  • Descarte + decaimento de peso: muito comum; ambos combatem o sobreajuste de formas complementares.
  • Descarte + aumento de dados: especialmente em visão; o aumento de dados reduz sobreajuste ao expandir o conjunto efetivo de dados.
  • Descarte + suavização de rótulos: frequentemente usado em classificação para evitar logits excessivamente confiantes; veja Suavização de Rótulos (Label Smoothing).
  • Descarte + parada antecipada: uma combinação simples e eficaz; veja Parada Antecipada.

Em cenários em grande escala (conjuntos de dados enormes, modelos grandes), o descarte pode ser reduzido ou removido porque:

  • O sobreajuste é menos severo,
  • Estabilidade de otimização e velocidade de treinamento se tornam mais importantes,
  • Outros regularizadores (aumento de dados, decaimento de peso, escolhas arquiteturais) são suficientes.

Boas Práticas e Armadilhas Comuns

Não exagere

Descarte demais pode causar subajuste:

  • a perda de treinamento permanece alta,
  • o aprendizado se torna lento ou instável.

Se você observar subajuste, reduza o descarte primeiro antes de aumentar o modelo.

Posicione o descarte de forma criteriosa

Padrões comuns:

  • MLP: Linear -> Activation -> Dropout -> Linear
  • CNN: descarte espacial em blocos convolucionais mais profundos; descarte mais forte na cabeça do classificador
  • Transformer: siga receitas estabelecidas em implementações de referência (descarte em caminhos de atenção/FFN/residual)

Evite colocar descarte em locais que quebram estrutura importante (por exemplo, máscaras ingênuas por passo de tempo em RNNs sem usar uma abordagem travada/variacional).

Cuidado com erros de avaliação

Se você avaliar com descarte habilitado sem intenção, as métricas ficarão ruidosas e tipicamente piores. Sempre mude para o modo de avaliação, a menos que esteja explicitamente fazendo descarte de Monte Carlo.

Descarte aleatório não substitui qualidade de dados

O descarte ajuda na generalização, mas não corrige:

  • ruído de rótulos,
  • vazamento de dados (data leakage),
  • descasamento de distribuição entre treino e teste (train/test distribution mismatch).

Interações com normalização em lote

Se você estiver usando normalização em lote em toda a rede e seu modelo já generaliza bem, o descarte pode oferecer pouco benefício — ou até prejudicar — especialmente nas camadas iniciais. Considere restringir o descarte às camadas mais tardias ou à cabeça.

Resumo

O descarte aleatório é uma técnica de regularização simples e eficaz que:

  • zera ativações (ou pesos) aleatoriamente durante o treinamento,
  • reduz coadaptação e sobreajuste,
  • aproxima o treinamento de um comitê de sub-redes,
  • é desabilitado na inferência (exceto ao usar descarte de Monte Carlo para incerteza).

Principais conclusões:

  • Use descarte invertido (padrão em frameworks modernos): escale durante o treinamento, sem escalonamento na inferência.
  • Prefira descarte espacial para mapas de características convolucionais.
  • Use descarte travado/variacional para modelos de sequência quando apropriado.
  • Ajuste a taxa de descarte com validação e considere interações com decaimento de peso, normalização em lote e tamanho do conjunto de dados.
  • Para estimativa de incerteza, o descarte de Monte Carlo pode fornecer uma aproximação prática com múltiplas passagens diretas estocásticas.