Overview

Treinar uma rede neural é um problema de otimização. Temos uma função de perda \(J(\theta)\) que mede o quanto o modelo erra e procuramos os parâmetros \(\theta^\star\) que a tornam a menor possível:

Para regressão linear isso tem solução fechada e vale entender por quê. Com um modelo linear e erro quadrático, \(J\) é uma função quadrática de \(\theta\), logo o gradiente é linear em \(\theta\) — e perguntar onde o gradiente se anula vira apenas um sistema de equações lineares, que sabemos resolver exatamente:

Coloque uma ativação não linear no meio e isso desaba: \(\nabla J = 0\) passa a ser um sistema de equações não lineares, sem fórmula que isole \(\theta\). E, mesmo quando a fórmula existe, ela pede uma inversão de matriz — algo em torno de \(O(n^3)\) operações para \(n\) parâmetros, inviável quando \(n\) está na casa dos milhões. Então fazemos a única coisa que resta: começar em algum lugar e caminhar ladeira abaixo.

O gradiente aponta para cima

Para uma função de várias variáveis, o gradiente é o vetor das derivadas parciais:

Cada entrada responde a uma pergunta local: se eu aumentar um pouquinho este parâmetro, quanto a perda muda? Juntas, elas apontam na direção de subida mais acentuada e a magnitude do vetor diz o quão íngreme é a encosta. Como queremos descer, andamos contra ele — daí o sinal negativo na regra de atualização:

onde:

• \(\theta\) são os parâmetros do modelo,
• \(\eta\) é a taxa de aprendizado, hiperparâmetro que controla o tamanho do passo,
• \(\nabla J(\theta)\) é o gradiente da perda em relação aos parâmetros.

Um método baseado em gradiente é qualquer algoritmo que encontra mínimos de uma função supondo que o gradiente é barato de calcular. Exige que a função seja contínua e diferenciável quase em todo lugar — a ReLU tem um bico em zero e isso não é problema¹. Tudo neste capítulo é uma variação da regra acima: o mesmo esqueleto, com formas mais espertas de escolher a direção e o tamanho do passo.

A taxa de aprendizado: o hiperparâmetro que você precisa sentir

Considere a perda mais simples possível, \(J(\theta) = \theta^2\), cujo gradiente é \(2\theta\). A atualização vira

Todo o comportamento do gradiente descendente está dentro desse fator \((1 - 2\eta)\). Brinque com a taxa de aprendizado abaixo e veja quatro mundos qualitativamente diferentes aparecerem.

As transições nesse simulador não são arbitrárias. Para uma quadrática cuja curvatura (segunda derivada) é \(L\) — a letra vem de Lipschitz³ — o gradiente descendente converge somente se

Aqui \(L = 2\), então a fronteira fica exatamente em \(\eta = 1\) — teste. Abaixo de \(1/L = 0{,}5\) a aproximação é monótona; entre \(1/L\) e \(2/L\) ela ziguezagueia sobre o mínimo; acima de \(2/L\) explode. Superfícies de perda reais não são quadráticas, mas perto de um mínimo elas se parecem com uma — e esse limite é a razão pela qual uma taxa de aprendizado que funcionava ontem faz o modelo divergir hoje depois que você mudou a arquitetura: você mudou o \(L\).

Quantos dados por passo? Batch, Estocástico e Mini-Batch

A perda sobre um conjunto de \(N\) amostras é a média das perdas individuais:

Calcular \(\nabla J\) exatamente significa uma passada completa pelos dados para uma única atualização. As três variantes clássicas diferem apenas em quantas amostras são olhadas antes de dar o passo.

for epoch in range(num_epochs):
    gradients = compute_gradients(X, y, model)      # uma passada por tudo
    model.parameters -= learning_rate * gradients   # uma única atualização

for epoch in range(num_epochs):
    for i in random_permutation(len(X)):            # embaralhe a cada época
        gradients = compute_gradients(X[i], y[i], model)
        model.parameters -= learning_rate * gradients

for epoch in range(num_epochs):
    for batch in get_mini_batches(X, y, batch_size):
        gradients = compute_gradients(batch.X, batch.y, model)
        model.parameters -= learning_rate * gradients

O fato quantitativo essencial: fazer a média de \(B\) amostras independentes divide o desvio-padrão (dp) da estimativa do gradiente por \(\sqrt{B}\).

Essa raiz quadrada é o motivo de o tamanho do batch ter retorno decrescente: passar de 32 para 128 custa 4× mais computação por passo e reduz o ruído apenas pela metade. E o ruído nunca desaparece de vez — com taxa de aprendizado constante, o SGD não converge para o mínimo, ele converge para uma nuvem em torno do mínimo, cujo raio cresce com \(\eta\) e encolhe com \(\sqrt{B}\). Veja acontecer:

Por que o gradiente descendente puro sofre

Se a superfície de perda fosse uma tigela redonda e bem-comportada, uma única taxa de aprendizado bastaria e este capítulo acabaria aqui. Superfícies reais não são redondas e três patologias específicas explicam todos os otimizadores que vêm a seguir.

Momentum: dê massa à bolinha

Em vez de andar na direção do gradiente atual, acumule uma média móvel exponencial dos gradientes passados e ande nessa direção. Agora são duas variáveis de estado, \(V\) e \(\theta\):

\(V\) é uma média corrente dos gradientes: a cada passo amortecemos o valor antigo por \(\beta\) (entre 0 e 1) e misturamos o gradiente novo. Depois movemos \(\theta\) na direção do novo momento \(V\)¹.

Por que isso resolve os vales estreitos. Na travessia do vale o gradiente troca de sinal a cada passo, então termos consecutivos se cancelam na média e a oscilação é amortecida. Ao longo do vale o sinal nunca muda, então nada se cancela e a média se acomoda no próprio gradiente. Uma única regra, dois efeitos opostos nas duas direções — o truque é esse.

Quanto de histórico entra nessa média é dado por

o número efetivo de gradientes passados na média móvel: cerca de 10 passos com \(\beta = 0{,}9\) e cerca de 100 com \(\beta = 0{,}99\). Leia isso como comprimento de memória, não como aceleração — na forma escrita acima, quando \(V\) se acomoda sobre um gradiente constante o passo vale \(\eta V = \eta g\), exatamente o passo do SGD. (Na verdade ele chega atrasado: ao longo de uma rodada longa o momentum fica para trás do SGD puro em \(\beta/(1-\beta)\) passos de progresso, 9 deles com \(\beta = 0{,}9\).)

O que o momentum compra, portanto, não é um passo maior e sim uma direção melhor: o que alterna se cancela, o que persiste sobrevive. Ele também continua andando com gradientes velhos — por isso atravessa pequenas irregularidades e por isso pode passar direto por um mínimo em vez de frear nele.

Nesterov: olhe antes de pular

O Nesterov Accelerated Gradient⁹¹⁰ avalia o gradiente depois do passo de momentum, não antes:

A ideia é um termo de correção: já que sabemos que a inércia vai nos levar até \(\theta_t - \eta\beta V_t\), podemos muito bem medir a inclinação lá. Se a superfície já voltou a subir, o gradiente no ponto de espiada freia antes do que freraria de outro modo. Na prática o ganho é pequeno mas consistente¹¹ e está a uma flag de distância: torch.optim.SGD(..., momentum=0.9, nesterov=True).

Métodos adaptativos: uma taxa de aprendizado por parâmetro

O momentum conserta a direção. Ele não conserta o fato de que um único \(\eta\) tem que servir a todos os parâmetros da rede — o embedding de uma palavra rara, cujo gradiente é quase sempre zero, e um viés da primeira camada, cujo gradiente é grande a cada passo.

A ideia comum a todo método adaptativo: manter, por parâmetro, uma estimativa da magnitude típica do gradiente e dividir por ela. Parâmetros com gradientes consistentemente grandes dão passos menores; parâmetros com gradientes minúsculos dão passos maiores. A atualização fica praticamente livre de escala.

AdaGrad — a primeira ideia e seu defeito

Acumule a soma de todos os gradientes ao quadrado vistos até agora e divida pela sua raiz¹²:

Isso funciona lindamente para atributos esparsos e é onde toda a família começa. Mas \(G_t\) é uma soma que nunca diminui, então a taxa efetiva \(\eta/\sqrt{G_t}\) decai monotonicamente rumo a zero. Em um treino longo de deep learning, o AdaGrad para de aprender muito antes de ter convergido.

RMSProp — troque a soma por uma média móvel

A correção¹³ tem o tamanho de um caractere: transforme a soma em uma média móvel exponencial, de modo que gradientes antigos sejam esquecidos.

onde:

• \(V_t\) é a média móvel dos gradientes ao quadrado (tipicamente \(\beta = 0{,}9\); no PyTorch ele se chama alpha e o padrão é 0.99),
• \(\epsilon \approx 10^{-8}\) é uma constante pequena para estabilidade numérica, evitando divisão por zero.

Agora \(\sqrt{V_t}\) é a raiz do valor quadrático médio dos gradientes recentes — daí o nome — e acompanha o terreno atual em vez de todo o histórico. Note que \(g/\sqrt{\overline{g^2}}\) é adimensional e vale aproximadamente \(\pm 1\): o RMSProp é próximo de "dar um passo de tamanho \(\eta\) no sinal do gradiente", o que é justamente o que o torna imune a uma perda mal escalada.

Adam — momentum e RMSProp em um só

Adaptive Moment Estimation mantém as duas médias móveis: o primeiro momento (a média dos gradientes — momentum) e o segundo momento (a variância não centrada — RMSProp).

1. Calcular o gradiente:

   \[g_t = \nabla J(\theta_t)\]

2. Primeiro momento (direção, com inércia):

   \[m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t\]

3. Segundo momento (escala):

   \[v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2\]

4. Correção de viés:

   \[\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \qquad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}\]

5. Atualização:

   \[\theta_{t+1} = \theta_t - \eta \, \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}\]

onde \(\beta_1, \beta_2\) controlam o decaimento das duas médias e \(\epsilon\) protege a divisão. Os valores padrão são \(\beta_1 = 0{,}9\), \(\beta_2 = 0{,}999\) e \(\epsilon = 10^{-8}\)¹⁴¹⁵ e são notavelmente robustos — o Adam é a coisa mais próxima que temos de um otimizador que funciona já de saída.

O Adam é o padrão para treinar redes profundas: combina a suavização do momentum com adaptatividade por parâmetro e exige bem menos ajuste da taxa de aprendizado que o SGD. O preço é memória — dois tensores extras do tamanho do modelo — e uma tendência bem documentada a generalizar um pouco pior que um SGD+momentum bem ajustado em tarefas convolucionais de visão.¹⁶

AdamW — weight decay desacoplado

O AdamW¹⁷ separa o weight decay da atualização adaptativa, o que é matematicamente a coisa certa a fazer:

onde \(\lambda\) é o coeficiente de weight decay aplicado diretamente nos pesos e não no gradiente.

No Adam original, a regularização L2 é implementada somando \(\lambda\theta\) ao gradiente antes do reescalonamento adaptativo — então ela também acaba dividida por \(\sqrt{\hat{v}_t}\). A consequência é perversa: parâmetros com gradientes grandes acabam menos regularizados, o oposto do que se quer. O AdamW aplica o decaimento fora do termo adaptativo, restaurando o comportamento pretendido. É o padrão para treinar Transformers e LLMs (BERT, GPT, LLaMA), normalmente com \(\lambda \approx 0{,}01\)–\(0{,}1\).

Simulador: a corrida dos otimizadores

Tudo o que veio acima, lado a lado. Escolha um relevo, ajuste a taxa de aprendizado e veja cinco otimizadores partirem do mesmo ponto. O painel de baixo mostra a perda em escala logarítmica — o formato dessas curvas é o que você realmente vê em um log de treino.

Agendamento da taxa de aprendizado

O simulador de ruído mostrou por que uma taxa de aprendizado constante não pode ser ótima: passos grandes exploram rápido, mas deixam você orbitando o mínimo; passos pequenos assentam com precisão, mas demoram uma eternidade para chegar lá. Então faça as duas coisas — comece grande, termine pequeno.

Dois ingredientes extras importam na prática. O warmup faz \(\eta\) subir a partir de ~0 ao longo das primeiras centenas ou milhares de iterações: na inicialização os gradientes são grandes e a estimativa do segundo momento do Adam ainda é lixo, então passos de tamanho normal logo no começo podem destruir o modelo — isso é essencial em Transformers¹⁸. E o decaimento por cosseno leva \(\eta\) suavemente a zero até o fim do treino, o que empiricamente supera o decaimento em degraus em quase tudo.¹⁹

import torch, math

opt = torch.optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.01)

warmup, total = 500, 10_000
def factor(step):                                   # devolve um multiplicador sobre o lr
    if step < warmup:
        return (step + 1) / warmup                  # rampa linear (nunca exatamente 0)
    p = (step - warmup) / (total - warmup)          # progresso em [0, 1]
    return 0.5 * (1 + math.cos(math.pi * p))        # cosseno até zero

sched = torch.optim.lr_scheduler.LambdaLR(opt, factor)

for x, y in loader:
    loss = criterion(model(x), y)
    opt.zero_grad(set_to_none=True)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)   # veja abaixo
    opt.step()
    sched.step()                                    # por passo, não por época

Escolhendo um otimizador na prática

Lado a lado

Resumindo: Batch GD é exato, mas impraticável; SGD compra velocidade pagando com ruído; Momentum suaviza esse ruído e acelera nas direções consistentes; RMSProp acerta a escala de cada parâmetro; e Adam/AdamW junta os dois últimos — por isso é o padrão, embora um SGD+momentum bem ajustado ainda generalize melhor em alguns benchmarks de visão.

A escolha certa depende do tamanho do conjunto de dados, do poder computacional disponível e de quanto ajuste fino você pode pagar — valide em dados separados em vez de confiar em uma tabela.

Padrões sensatos

Diagnóstico de um treino

Os otimizadores, do zero

Todos eles cabem em dez linhas. Escritos lado a lado, o parentesco fica evidente — cada um é θ -= η · (direção) / (escala).

import numpy as np

class SGD:
    def __init__(self, lr=0.01, beta=0.0):
        self.lr, self.beta, self.v = lr, beta, None

    def step(self, theta, grad):
        if self.v is None:
            self.v = np.zeros_like(theta)
        self.v = self.beta * self.v + (1 - self.beta) * grad     # momentum (beta=0 → SGD puro)
        return theta - self.lr * self.v


class RMSProp:
    def __init__(self, lr=0.01, beta=0.9, eps=1e-8):
        self.lr, self.beta, self.eps, self.v = lr, beta, eps, None

    def step(self, theta, grad):
        if self.v is None:
            self.v = np.zeros_like(theta)
        self.v = self.beta * self.v + (1 - self.beta) * grad ** 2   # magnitude quadrática média
        return theta - self.lr * grad / (np.sqrt(self.v) + self.eps)


class Adam:
    def __init__(self, lr=1e-3, b1=0.9, b2=0.999, eps=1e-8, weight_decay=0.0):
        self.lr, self.b1, self.b2, self.eps, self.wd = lr, b1, b2, eps, weight_decay
        self.m = self.v = None
        self.t = 0

    def step(self, theta, grad):
        if self.m is None:
            self.m = np.zeros_like(theta)
            self.v = np.zeros_like(theta)
        self.t += 1
        self.m = self.b1 * self.m + (1 - self.b1) * grad            # 1o momento: direção
        self.v = self.b2 * self.v + (1 - self.b2) * grad ** 2       # 2o momento: escala
        m_hat = self.m / (1 - self.b1 ** self.t)                    # correção de viés
        v_hat = self.v / (1 - self.b2 ** self.t)
        update = m_hat / (np.sqrt(v_hat) + self.eps)
        return theta - self.lr * (update + self.wd * theta)         # AdamW: decay fora do reescalonamento

# A mesma coisa, em PyTorch
torch.optim.SGD(p, lr=0.1, momentum=0.9, nesterov=True, weight_decay=5e-4)
torch.optim.RMSprop(p, lr=1e-3, alpha=0.9)
torch.optim.Adam(p, lr=1e-3, betas=(0.9, 0.999), eps=1e-8)
torch.optim.AdamW(p, lr=3e-4, betas=(0.9, 0.95), weight_decay=0.1)

Pontos-chave

1. O gradiente descendente é uma linha; todo o resto é sobre escolher bem o tamanho do passo.
2. Uma quadrática só converge quando \(\eta < 2/L\). Divergir não é azar, é aritmética.
3. Mini-batches trocam ruído por velocidade e o ruído cai apenas com \(1/\sqrt{B}\). Uma taxa constante deixa você orbitando o mínimo — daí os agendamentos.
4. Os obstáculos reais são o mau condicionamento e os pontos de sela, não mínimos locais ruins.
5. O momentum faz média dos gradientes no tempo, então o que alterna se cancela e o que persiste sobrevive. \(1/(1-\beta)\) é o comprimento dessa memória — e, na convenção do PyTorch, também o fator pelo qual o passo cresce.
6. Os métodos adaptativos (AdaGrad → RMSProp → Adam) dão a cada parâmetro seu próprio passo, dividindo pela raiz quadrática média dos gradientes recentes. O Adam acrescenta momentum e correção de viés por cima.
7. AdamW + warmup + cosseno é o padrão moderno. Ajuste a taxa de aprendizado primeiro e quase nada mais.

Recursos Adicionais

Três materiais que continuam de onde esta página para, na ordem em que fazem sentido:

1. Who's Adam and What's He Optimizing? — Kundu, S. Refaz em animação o mesmo caminho deste capítulo — SGD, momentum, RMSProp, Adam. É a forma mais rápida de revisar a página inteira:

2. An overview of gradient descent optimization algorithms — Ruder, S. Reúne todos os métodos daqui em uma notação só, mais os que ficaram de fora (Adadelta, Nadam, AMSGrad). Leia depois de fechar a aula, para ver o mapa completo.

3. Why Momentum Really Works — Goh, G., Distill (2017). Um artigo inteiramente interativo sobre o que o número de condição faz com a convergência. É o aprofundamento natural da seção de momentum: prova com sliders o que aqui ficou na intuição.

Referências bibliográficas

As obras citadas ao longo do texto, na ordem em que aparecem: