Adam Optimizer

O otimizador Adam, abreviação de Adaptive Moment Estimation, é um algoritmo de otimização para treinar redes neurais que atribui a cada parâmetro um tamanho de passo adaptativo próprio. Apresentado por Kingma e Ba em Adam: um método para otimização estocástica, ele amplia a descida do gradiente estocástica (SGD) com médias móveis dos gradientes anteriores e de seus quadrados. O rápido progresso inicial e as configurações padrão tolerantes fizeram do Adam o ponto de partida mais comum no aprendizado profundo, e sua variante AdamW é a escolha padrão para treinar Transformers e grandes modelos de linguagem.

Como funciona o Adam#

O treinamento minimiza uma função de perda atualizando repetidamente cada peso na direção oposta ao seu gradiente. A SGD simples multiplica todos os gradientes pela mesma taxa de aprendizado. O Adam mantém dois valores adicionais por parâmetro e os atualiza em cada etapa t com base no gradiente atual g:

1. Primeiro momento (momentum): m = β1·m + (1 − β1)·g, uma média dos gradientes com decaimento exponencial que mantém a atualização em uma direção consistente.
2. Segundo momento: v = β2·v + (1 − β2)·g², uma média dos gradientes ao quadrado com decaimento que acompanha a magnitude típica dos gradientes de cada parâmetro.
3. Correção de viés: m̂ = m / (1 − β1^t) e v̂ = v / (1 − β2^t), que compensam o fato de ambas as médias começarem em zero.
4. Atualização: θ = θ − lr · m̂ / (√v̂ + ε).

Os valores padrão do artigo, também usados pelo torch.optim.Adam do PyTorch, são lr = 0.001, β1 = 0.9, β2 = 0.999 e ε = 1e-8. Dividir por √v̂ normaliza cada etapa de acordo com a magnitude típica do gradiente do parâmetro, de modo que as etapas fiquem próximas da taxa de aprendizado, quer os gradientes sejam minúsculos ou enormes; elas também diminuem em direções ruidosas, onde gradientes positivos e negativos se anulam dentro de m̂. O trecho abaixo compara a primeira etapa da SGD e do Adam para dois parâmetros cujos gradientes diferem em escala por um fator de 1.000:

import torch

# Two parameters whose gradients differ in scale by 1,000x
scale = torch.tensor([1000.0, 1.0])

for name, optimizer_cls in [("SGD", torch.optim.SGD), ("Adam", torch.optim.Adam)]:
    w = torch.zeros(2, requires_grad=True)
    optimizer = optimizer_cls([w], lr=0.001)

    loss = (scale * w).sum()  # gradient is [1000, 1]
    loss.backward()
    optimizer.step()
    print(f"{name} first step: {[round(v, 4) for v in w.tolist()]}")

A SGD desloca o primeiro parâmetro para -1.0 e o segundo para -0.001, uma diferença de 1.000 vezes que acompanha os gradientes. O Adam desloca ambos exatamente pela taxa de aprendizado, -0.001, pois sua etapa normalizada depende da direção e da consistência do gradiente, em vez da sua magnitude bruta.

Adam e AdamW#

Na implementação mais comum do Adam, aplica-se decaimento de pesos, uma forma de regularização, como uma penalidade L2 adicionada ao gradiente; em seguida, essa penalidade é dividida por √v̂ junto com todo o restante, de modo que pesos com gradientes grandes recebem pouca regularização. O decaimento de pesos desacoplado de Loshchilov e Hutter corrige isso diminuindo diretamente os pesos a cada etapa, separadamente da atualização adaptativa. Nos experimentos do artigo, o AdamW resultante melhorou a generalização do Adam na classificação de imagens e está disponível como torch.optim.AdamW.

Adam vs. SGD#

O SGD com momentum usa uma taxa de aprendizado global e armazena um buffer por parâmetro, enquanto o Adam armazena dois buffers: 8 bytes por parâmetro em precisão de 32 bits, o que totaliza 56 GB de estado do otimizador para um modelo com 7 bilhões de parâmetros. Em geral, o Adam avança mais rapidamente no início, é menos sensível à taxa de aprendizado e treina modelos Transformer com muito mais confiabilidade do que o SGD. Um SGD bem ajustado costuma alcançar uma acurácia final igual ou superior em modelos convolucionais de imagem, e Wilson et al. constataram que os métodos adaptativos muitas vezes generalizaram pior do que o SGD nas tarefas de classificação de imagens e nas tarefas de linguagem que testaram.

O treinamento YOLO da Ultralytics reflete essa compensação: o padrão optimizer="auto" escolhe AdamW, com uma taxa de aprendizado inicial ajustada ao número de classes, para execuções de até 10.000 iterações; para cronogramas mais longos, muda para o MuSGD, uma combinação de SGD e Muon. Definir explicitamente o otimizador também exige definir a taxa de aprendizado, pois o valor padrão lr0=0.01 é adequado à SGD e corresponde a dez vezes a taxa usual do Adam.

from ultralytics import YOLO

# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")

# Treina com AdamW e uma taxa de aprendizado inicial adequada ao Adam
results = model.train(data="coco8.yaml", epochs=5, optimizer="AdamW", lr0=0.001)

Quando o YOLO26 treina com um otimizador da família Adam, o argumento momentum (padrão 0.937) define β1, enquanto β2 permanece fixo em 0.999.

Adam e otimizadores relacionados#

• AdaGrad: Divide cada etapa pela raiz quadrada de todos os gradientes anteriores ao quadrado. Assim, os tamanhos das etapas só diminuem, o que é adequado para características esparsas, mas desacelera treinamentos longos.
• RMSProp: Substitui a soma acumulada da AdaGrad por uma média dos gradientes ao quadrado com decaimento exponencial. O Adam é essencialmente a RMSProp com momentum e correção de viés.
• Muon: Otimizador para as matrizes de pesos 2D das camadas ocultas que ortogonaliza cada atualização de momentum com iterações de Newton–Schulz e mantém um único buffer de estado por parâmetro, metade do estado do otimizador do Adam.