Decaimento de Peso

Visão geral

Decaimento de pesos (weight decay) é uma técnica de regularização durante o treinamento que desencoraja uma rede neural (neural network) a aprender pesos excessivamente grandes. Em sua forma mais comum, é equivalente à regularização L2 (L2 regularization): adicionar uma penalidade proporcional à magnitude ao quadrado dos parâmetros. Ao enviesar as soluções em direção a pesos menores, o decaimento de pesos frequentemente melhora a generalização (generalization), reduz o sobreajuste (overfitting) e pode estabilizar o treinamento.

O decaimento de pesos é frequentemente usado junto a outros regularizadores, como Dropout, Parada Antecipada e Suavização de Rótulos. Ele interage fortemente com a escolha do otimizador (optimizer) e do cronograma de taxa de aprendizado (learning rate schedule), e a prática moderna normalmente usa decaimento de pesos desacoplado (decoupled weight decay) (por exemplo, AdamW) ao treinar com otimizadores adaptativos (adaptive optimizers) como o Adam.

Que problema o decaimento de pesos resolve?

Redes neurais modernas conseguem ajustar os dados de treinamento extremamente bem, incluindo ruído. Essa flexibilidade aumenta o risco de sobreajuste, em que o desempenho no treinamento é excelente, mas o desempenho em validação/teste é ruim.

Pesos grandes podem contribuir para fronteiras de decisão excessivamente “afiadas” ou características frágeis. O decaimento de pesos reduz essa tendência ao:

  • Penalizar o crescimento dos parâmetros, favorecendo funções mais suaves ou mais simples
  • Melhorar a estabilidade numérica (ativações menos extremas)
  • Atuar como uma restrição suave que pode complementar aumento de dados e normalização

Ele não é uma garantia contra sobreajuste, mas é um regularizador amplamente eficaz e computacionalmente barato.

O objetivo com regularização L2

Considere que os parâmetros do modelo sejam (w) e a perda dos dados seja (\mathcal{L}(w)) (por exemplo, entropia cruzada (cross-entropy)). A regularização L2 modifica o objetivo de treinamento para:

[ \mathcal{L}_{\text{reg}}(w) = \mathcal{L}(w) + \frac{\lambda}{2}|w|_2^2 ]

onde:

  • (\lambda \ge 0) é a força de regularização (regularization strength) (frequentemente chamada weight_decay)
  • (|w|_2^2 = \sum_i w_i^2)

O gradiente torna-se:

[ \nabla \mathcal{L}_{\text{reg}}(w) = \nabla \mathcal{L}(w) + \lambda w ]

Assim, a regularização L2 adiciona um termo proporcional ao vetor de pesos atual, empurrando os pesos em direção a zero.

Interpretação bayesiana (intuição que importa na prática)

A regularização L2 corresponde à estimação de máximo a posteriori (maximum a posteriori, MAP) com um prior gaussiano de média zero (zero-mean Gaussian prior) sobre os pesos:

[ p(w) \propto \exp\left(-\frac{\lambda}{2}|w|^2\right) ]

Isso fornece um modelo mental útil: o decaimento de pesos codifica uma preferência por pesos menores, a menos que os dados sustentem fortemente o contrário.

“Decaimento de pesos” vs “penalidade L2”: quando são a mesma coisa?

Historicamente, “decaimento de pesos” e “regularização L2” foram frequentemente usados de forma intercambiável. Eles são equivalentes sob a descida estocástica do gradiente (stochastic gradient descent, SGD) (e intimamente relacionados sob SGD com momento (momentum)), mas diferem sob otimizadores adaptativos como o Adam.

Entender essa distinção é essencial, porque muitas bibliotecas expõem um argumento weight_decay que pode implementar um entre:

  • Penalidade L2 (acoplada) (L2 penalty (coupled)): adicionar (\lambda w) ao gradiente
  • Decaimento de pesos desacoplado: encolher os pesos separadamente da atualização baseada em gradiente

Equivalência sob SGD

Considere SGD com taxa de aprendizado (learning rate) (\eta). Se otimizarmos o objetivo regularizado por L2:

[ w_{t+1} = w_t - \eta(\nabla \mathcal{L}(w_t) + \lambda w_t) ]

Reorganizando:

[ w_{t+1} = (1 - \eta \lambda) w_t - \eta \nabla \mathcal{L}(w_t) ]

Isso mostra que a atualização é equivalente a:

  1. Encolher os pesos por um fator ((1 - \eta \lambda))
  2. Dar o passo de gradiente usual

Esse encolhimento multiplicativo é a origem do termo decaimento de pesos.

Por que eles divergem sob Adam (e outros métodos adaptativos)

Otimizadores adaptativos (por exemplo, Adam, RMSProp, Adagrad) escalonam atualizações por estimativas móveis dos momentos do gradiente. Uma atualização simplificada do Adam é:

[ w_{t+1} = w_t - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} ]

Se você implementar a regularização L2 adicionando (\lambda w) ao gradiente, o termo L2 também é escalonado por (\frac{1}{\sqrt{\hat{v}_t} + \epsilon}) por parâmetro:

[ w_{t+1} = w_t - \eta \frac{\hat{m}_t + \lambda w_t}{\sqrt{\hat{v}_t} + \epsilon} ]

Isso significa que o encolhimento efetivo não é uniforme. Parâmetros com (\hat{v}_t) pequeno sofrem regularização mais forte, e aqueles com (\hat{v}_t) grande sofrem regularização mais fraca. Em outras palavras:

  • A “força de regularização” fica entrelaçada com a adaptividade do Adam.
  • O comportamento deixa de corresponder à interpretação limpa do decaimento de pesos como uma simples contração dos pesos.

Esse descompasso é uma das razões pelas quais a comunidade migrou para o decaimento de pesos desacoplado (AdamW).

Decaimento de pesos desacoplado (AdamW): o que é e por que é comum

Decaimento de pesos desacoplado aplica o decaimento como um encolhimento direto dos parâmetros separadamente da atualização baseada em gradiente. Para um otimizador do tipo Adam, o AdamW faz algo como:

[ w_{t+1} = (1 - \eta \lambda) w_t ;-; \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} ]

Ponto-chave: o termo de decaimento não é dividido por (\sqrt{\hat{v}_t}). Assim, cada parâmetro experimenta o decaimento pretendido proporcional à sua própria magnitude e a (\eta\lambda), independente do escalonamento adaptativo.

Consequências práticas

O desacoplamento tende a:

  • Tornar o hiperparâmetro weight_decay mais previsível e transferível
  • Melhorar a generalização para modelos treinados com Adam em muitos regimes (notavelmente em visão computacional (computer vision) e transformadores (transformers))
  • Alinhar-se melhor com a intuição de “encolher os pesos”

Por isso, o AdamW é amplamente usado para modelos baseados em transformadores (transformer-based models) e muitas receitas modernas de aprendizado profundo.

Tópicos relacionados: Descida do Gradiente, Otimização Adaptativa, Otimizador Adam, Descida Estocástica do Gradiente.

Padrões de implementação (exemplos em PyTorch)

Exemplo 1: SGD com decaimento de pesos (comportamento L2 clássico)

import torch
import torch.optim as optim

optimizer = optim.SGD(
    model.parameters(),
    lr=0.1,
    momentum=0.9,
    weight_decay=1e-4,  # classic L2 regularization / weight decay
)

Para SGD, weight_decay normalmente corresponde de perto à regularização L2 e à visão de “encolhimento”.

Exemplo 2: AdamW (decaimento de pesos desacoplado)

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=3e-4,
    weight_decay=0.01,  # decoupled weight decay
)

No PyTorch, AdamW implementa decaimento de pesos desacoplado, enquanto Adam historicamente aplicava a penalidade L2 via gradiente (acoplada). Sempre confirme o comportamento no seu framework/versão.

Exemplo 3: Excluindo vieses e parâmetros de normalização (boa prática comum)

Em muitas arquiteturas, é comum não aplicar decaimento de pesos a:

  • Termos de viés (bias)
  • Parâmetros de normalização (escala e deslocamento de normalização em lote (BatchNorm)/normalização por camada (LayerNorm))

Motivo: decair esses parâmetros pode prejudicar a otimização ou reduzir a flexibilidade representacional sem um benefício de regularização significativo.

decay, no_decay = [], []
for name, param in model.named_parameters():
    if not param.requires_grad:
        continue
    if name.endswith(".bias") or "bn" in name.lower() or "ln" in name.lower() or "norm" in name.lower():
        no_decay.append(param)
    else:
        decay.append(param)

optimizer = torch.optim.AdamW(
    [
        {"params": decay, "weight_decay": 0.01},
        {"params": no_decay, "weight_decay": 0.0},
    ],
    lr=3e-4,
)

Isso é especialmente comum no treinamento de transformadores, onde a normalização por camada é onipresente.

Como ajustar o decaimento de pesos na prática

O decaimento de pesos é um hiperparâmetro (hyperparameter); seu valor ótimo depende do tamanho do modelo, do tamanho dos dados, do aumento de dados, do otimizador e do cronograma de taxa de aprendizado.

Faixas típicas (regras de bolso)

Elas não são universais, mas são pontos de partida comuns:

  • SGD (visão computacional, redes neurais convolucionais (convolutional neural networks, CNNs)): 1e-4 a 5e-4 (às vezes 1e-3)
  • AdamW (transformadores): 0.01 é um ponto de partida clássico; 0.1 pode funcionar em algumas configurações de grande escala; valores menores como 1e-3 podem ser apropriados quando os dados são limitados ou quando se usa forte regularização adicional.
  • Conjuntos de dados pequenos / alto risco de sobreajuste: aumente o decaimento de pesos (com bom senso)
  • Subajuste (underfitting) ou dificuldade de otimização: diminua o decaimento de pesos

Interação com a taxa de aprendizado (importante)

Como o fator de encolhimento é ((1 - \eta\lambda)), taxa de aprendizado e decaimento de pesos são acoplados no efeito:

  • Maior taxa de aprendizado (\eta) → decaimento por passo mais forte para o mesmo (\lambda)
  • Cronogramas de taxa de aprendizado (por exemplo, decaimento cosseno (cosine decay), decaimento por degraus (step decay) etc.) mudam implicitamente a força do decaimento ao longo do treinamento

Implicação: se você mudar sua taxa de aprendizado em 10×, frequentemente precisa reajustar o decaimento de pesos.

Relacionado: Cronogramas de Taxa de Aprendizado.

Interação com BatchNorm e LayerNorm

Camadas de normalização introduzem parâmetros (por exemplo, (\gamma), (\beta)) que escalam/deslocam ativações normalizadas. O decaimento de pesos nesses parâmetros muitas vezes é indesejável:

  • Decair (\gamma) pode colapsar a escala das características
  • Pode reduzir o benefício da normalização e, às vezes, degradar a acurácia

Prática comum: aplicar decaimento de pesos a matrizes de “peso” (convoluções, camadas lineares), mas excluir parâmetros de normalização e viés (como mostrado acima).

Relacionado: Normalização em Lote.

Interação com dropout e outros regularizadores

O decaimento de pesos frequentemente complementa outros métodos de regularização:

  • Com Dropout: ambos reduzem sobreajuste, mas de maneiras diferentes; você pode conseguir usar menos dropout se o decaimento de pesos for forte (ou vice-versa).
  • Com Parada Antecipada: a parada antecipada pode reduzir a necessidade de um decaimento de pesos muito forte, mas eles também podem ser combinados.
  • Com Suavização de Rótulos: a suavização de rótulos regulariza as predições; o decaimento de pesos regulariza os parâmetros. O uso combinado é comum em classificação.

Interação com aumento de dados

Aumento de dados forte reduz a pressão de sobreajuste, às vezes permitindo um decaimento de pesos menor. Em visão computacional, receitas com aumento pesado (RandAugment, Mixup/CutMix) frequentemente ajustam decaimento de pesos e taxas de aprendizado em conjunto.

O que o decaimento de pesos faz geometricamente?

O decaimento de pesos puxa os pesos em direção à origem no espaço de parâmetros (parameter space). Para regressão linear (linear regression), a regularização L2 produz regressão ridge (ridge regression), que:

  • Encolhe coeficientes
  • Reduz a variância
  • Melhora a estabilidade sob multicolinearidade (multicollinearity)

Para redes profundas, a geometria é mais complexa, mas intuições semelhantes se aplicam: encolher parâmetros tende a reduzir soluções excessivamente complexas e pode enviesar o treinamento em direção a funções “mais simples”.

Uma sutileza: devido a simetrias e reparametrizações em redes profundas (por exemplo, escalonamento em redes ReLU), “pesos pequenos” nem sempre se mapeiam de forma limpa para “função simples”. Ainda assim, o decaimento de pesos permanece empiricamente eficaz.

Armadilhas comuns e nuances

“Meu framework tem `weight_decay` no Adam — estou usando AdamW?”

Não necessariamente. Em algumas bibliotecas ou versões antigas, weight_decay no Adam implementa a penalidade L2 acoplada, e não o decaimento de pesos desacoplado. A diferença pode ser relevante.

Boa prática:

  • Use um otimizador explicitamente chamado AdamW (ou uma opção desacoplada documentada).
  • Verifique a documentação e/ou o código-fonte se os resultados forem sensíveis.

Decaimento de pesos não é a mesma coisa que recorte de gradiente

  • Decaimento de pesos penaliza parâmetros grandes.
  • Recorte de gradiente (gradient clipping) limita gradientes grandes durante a Retropropagação para estabilizar o treinamento.

Eles podem ser usados juntos sem conflito.

Decaimento de pesos excessivo pode prejudicar a otimização

Decaimento demais pode:

  • Levar os pesos a zero mais rápido do que o modelo consegue aprender
  • Causar subajuste (o desempenho tanto em treino quanto em validação piora)
  • Interagir mal com taxas de aprendizado pequenas (o treinamento fica lento)

Modelos esparsos ou com muitas embeddings

Para grandes tabelas de embeddings (embeddings), aplicar decaimento às embeddings pode ou não ajudar dependendo da tarefa. Algumas receitas de processamento de linguagem natural (natural language processing, NLP) excluem embeddings; outras as mantêm com decaimento. É uma escolha de ajuste.

Decaimento de pesos e regularização L2 “verdadeira” sob momentum

Com momento ou momento de Nesterov (Nesterov momentum), a equivalência entre “penalidade L2 na perda” e “decaimento de pesos multiplicativo” ainda é próxima em espírito, mas a dinâmica exata difere ligeiramente porque o momento introduz estado. Na prática, a maioria das receitas trata weight_decay para SGD+momento como o regularizador L2 padrão e ajusta empiricamente.

Fluxo de trabalho prático de ajuste

Uma forma pragmática de ajustar o decaimento de pesos:

  1. Escolha primeiro o otimizador e o cronograma de taxa de aprendizado (eles dominam a dinâmica de treinamento).
  2. Escolha um decaimento de pesos padrão razoável:
    • SGD: 1e-4 a 5e-4
    • AdamW: 0.01
  3. Faça uma pequena varredura (por exemplo, 3–6 valores):
    • AdamW: 0.0, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1
    • SGD: 0.0, 1e-5, 1e-4, 5e-4, 1e-3
  4. Observe:
    • Lacuna de sobreajuste (treino vs val)
    • Subajuste (desempenho de treino cai)
    • Sensibilidade a mudanças na taxa de aprendizado
  5. Aplique a regra “excluir vieses e normas” a menos que você tenha um motivo para não fazê-lo.

Resumo

  • Decaimento de pesos é um método central de regularização que desencoraja pesos grandes, tipicamente melhorando a generalização.
  • Como penalidade na perda, ele corresponde à regularização L2: adicionar (\frac{\lambda}{2}|w|^2).
  • Sob SGD, a regularização L2 é efetivamente equivalente ao decaimento de pesos multiplicativo.
  • Sob otimizadores adaptativos como o Adam, acoplar L2 ao gradiente muda seu comportamento; isso motiva o decaimento de pesos desacoplado.
  • AdamW é amplamente usado porque aplica decaimento de pesos independentemente do escalonamento adaptativo do Adam, tornando o comportamento de regularização mais consistente e frequentemente melhorando resultados.
  • O sucesso prático depende de ajuste e interações — especialmente com cronogramas de taxa de aprendizado e com a exclusão de parâmetros de viés/normalização do decaimento.

Métodos de regularização relacionados: Dropout, Parada Antecipada, Suavização de Rótulos.