Otimizadores de redes neurais: SGD, Momentum e Adam em Python

O conceito em palavras simples

Um otimizador é a regra que transforma gradientes em atualizações dos pesos. O gradiente descendente simples usa só o gradiente atual; o momentum lembra as direções anteriores, e o Adam também adapta o tamanho do passo para cada peso.

Compare o gradiente descendente simples, o momentum e o Adam minimizando passo a passo a mesma função.

Ideias principais

O momentum mantém uma velocidade, então atravessa regiões planas e pequenas irregularidades.
O Adam guarda médias móveis do gradiente e do gradiente ao quadrado.
A correção de viés (dividir por 1 − βᵗ) ajusta essas médias nos primeiros passos.
Uma boa inicialização dos pesos e os mini-lotes também deixam o treinamento mais rápido e estável.

Quando usar?

Entender o que acontece dentro das redes neurais e das bibliotecas de IA.
Aprender a ideia antes de implementá-la nos desafios correspondentes.
Se preparar para cursos de aprendizado de máquina, entrevistas e projetos.

Veja na prática

Clique em Executar para três otimizadores descerem o mesmo vale irregular. Tente uma taxa de aprendizado maior para ver o momentum passar do ponto.

Código de exemplo

Executar código →

main.py

import math

# Minimise f(x) = (x - 3)² with three optimizers. The gradient is 2(x - 3).
grad = lambda x: 2 * (x - 3)

def sgd(steps, lr=0.1):
    x = 0.0
    for _ in range(steps):
        x -= lr * grad(x)
    return x

def momentum(steps, lr=0.1, beta=0.9):
    x, v = 0.0, 0.0
    for _ in range(steps):
        v = beta * v + grad(x)        # remember the direction we were going
        x -= lr * v
    return x

def adam(steps, lr=0.3, b1=0.9, b2=0.999, eps=1e-8):
    x, m, v = 0.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = grad(x)
        m = b1 * m + (1 - b1) * g     # running mean of gradients
        v = b2 * v + (1 - b2) * g * g # running mean of squared gradients
        m_hat, v_hat = m / (1 - b1 ** t), v / (1 - b2 ** t)
        x -= lr * m_hat / (math.sqrt(v_hat) + eps)
    return x

for steps in (5, 20, 50):
    print(f"{steps:>2} steps  sgd={sgd(steps):.3f}  momentum={momentum(steps):.3f}  adam={adam(steps):.3f}")

Saída esperada

5 steps  sgd=2.017  momentum=4.741  adam=1.476
20 steps  sgd=2.965  momentum=4.048  adam=3.813
50 steps  sgd=3.000  momentum=3.091  adam=3.014

Como funciona

Os três minimizam (x − 3)², cujo ponto mais baixo é x = 3. O SGD avança de forma constante, o momentum ganha velocidade e passa do ponto antes de se estabilizar, e o Adam ajusta cada passo com médias móveis do gradiente e do seu quadrado. Depois de 50 passos, os três estão perto de 3.

Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.

Exercícios práticos

Altere as entradas e teste casos de borda antes de usar conjuntos de dados maiores.

Mude as entradas ou os pesos e preveja a saída antes de executar.
Imprima os valores intermediários para acompanhar cada passo do cálculo.
Resolva os desafios indicados abaixo para implementar a ideia você mesmo.

Executar no IDE Python →

Pratique com um desafio

Use o conteúdo desta lição para resolver um problema real. Cada desafio roda no navegador, com testes instantâneos e uma revisão por IA.

Todos os desafios