A mesma rede, a mesma base.
Vinte curvas diferentes.

Nas três aulas anteriores o assunto foi a arquitetura — quantas camadas, quantos neurônios, qual ativação — e as regras de atualização — como momentum acumula, como Adam normaliza. Tudo isso define o modelo e o algoritmo. Nada disso define o treino.

Treinar exige mais três decisões, e elas não estão na arquitetura nem na regra de atualização:

0.1A base e a rede de referência

MNIST: 70 000 imagens de dígitos manuscritos, 28 × 28 pixels em tons de cinza, 60 000 para treino e 10 000 para teste. É a base mais gasta do aprendizado de máquina e é exatamente por isso que serve aqui: qualquer MLP razoável passa de 97% de acurácia, então as diferenças que você vai ver não são da rede — são das escolhas de treino.

import torch, time
import torch.nn as nn
import matplotlib.pyplot as plt
from torchvision import datasets, transforms

torch.manual_seed(42)

# normalização: média e desvio do próprio conjunto de treino
tf = transforms.Compose([transforms.ToTensor(),
                         transforms.Normalize((0.1307,), (0.3081,))])

treino = datasets.MNIST("./dados", train=True,  download=True, transform=tf)
teste  = datasets.MNIST("./dados", train=False, download=True, transform=tf)

# tudo cabe na memória: viramos tensores de uma vez e evitamos o DataLoader,
# que domina o tempo quando o batch é pequeno
X_tr = treino.data.reshape(-1, 784).float().div(255).sub(0.1307).div(0.3081)
y_tr = treino.targets
X_te = teste.data.reshape(-1, 784).float().div(255).sub(0.1307).div(0.3081)
y_te = teste.targets
X_tr.shape, y_tr.shape          # (60000, 784) (60000,)

def criar_rede(semente=42):
    torch.manual_seed(semente)                # mesma inicialização em todos os testes
    return nn.Sequential(
        nn.Linear(784, 128), nn.ReLU(),
        nn.Linear(128,  64), nn.ReLU(),
        nn.Linear( 64,  10),           # sem softmax: CrossEntropyLoss já aplica
    )

O loop de treino de qualquer rede tem sempre a mesma anatomia. Vale escrevê-lo com atenção uma vez, porque os experimentos dos próximos blocos são literalmente chamadas diferentes desta mesma função.

def avaliar(rede, X, y, bs=2000):
    """Perda média e acurácia sobre um conjunto inteiro, sem gradiente."""
    rede.eval()
    perda_total, acertos = 0.0, 0
    lf = nn.CrossEntropyLoss(reduction="sum")
    with torch.no_grad():
        for i in range(0, len(X), bs):
            saida = rede(X[i:i+bs])
            perda_total += lf(saida, y[i:i+bs]).item()
            acertos     += (saida.argmax(1) == y[i:i+bs]).sum().item()
    rede.train()
    return perda_total / len(X), acertos / len(X)


def treinar(X_tr, y_tr, X_te, y_te, *, batch_size, otimizador, lr, epocas, semente=42):
    rede = criar_rede(semente)
    opt  = criar_otimizador(otimizador, rede.parameters(), lr)   # bloco 3
    lf   = nn.CrossEntropyLoss()

    n  = len(X_tr)
    bs = n if batch_size == "full" else int(batch_size)   # batch completo = uma única fatia
    g  = torch.Generator().manual_seed(semente)

    hist = {"epoca": [], "perda_treino": [], "perda_teste": [],
            "acc_teste": [], "tempo": [], "passos": []}
    passos, t0 = 0, time.time()

    for ep in range(1, epocas + 1):
        perm = torch.randperm(n, generator=g)          # embaralha a cada época
        for i in range(0, n, bs):
            idx = perm[i:i+bs]
            opt.zero_grad(set_to_none=True)
            perda = lf(rede(X_tr[idx]), y_tr[idx])     # forward no mini-batch
            perda.backward()                           # gradiente
            opt.step()                                 # atualização
            passos += 1

        p_tr, _      = avaliar(rede, X_tr, y_tr)     # perda no treino INTEIRO
        p_te, ac_te  = avaliar(rede, X_te, y_te)
        for k, v in zip(hist, [ep, p_tr, p_te, ac_te, time.time()-t0, passos]):
            hist[k].append(v)

    return rede, hist

O gradiente que interessa é o da função de custo sobre a base inteira:

Calculá-lo exige uma passada completa pelos N exemplos. As três estratégias são três respostas diferentes para a pergunta "quantos dos N eu realmente preciso ver antes de mexer nos pesos?".

2.1O experimento: mesmo learning rate para todos

Para isolar o efeito do batch, tudo o mais fica fixo: mesma rede, mesma inicialização, otimizador SGD sem momentum, lr = 0,1, 20 épocas, 10 000 exemplos de treino (um subconjunto do MNIST — cabe no tempo da aula e o efeito é o mesmo).

configs = [("full", "batch completo"), (1024, "mini-batch 1024"),
           (128, "mini-batch 128"), (16, "mini-batch 16"), (1, "SGD puro")]

resultados = {}
for bs, nome in configs:
    _, h = treinar(X_tr[:10_000], y_tr[:10_000], X_te, y_te,
                    batch_size=bs, otimizador="sgd", lr=0.1, epocas=20)
    resultados[nome] = h
    print(f"{nome:>16}  perda {h['perda_treino'][-1]:.4f}  "
          f"acc {h['acc_teste'][-1]:.4f}  passos {h['passos'][-1]}")

2.2Por que o batch pequeno exige passo pequeno

O gradiente de um mini-batch é uma média amostral do gradiente verdadeiro. Se os gradientes individuais têm variância σ², a média de B deles tem variância σ²/B — e o desvio padrão, que é o que se sente na prática, cai com 1/√B:

Isso é teoria de amostragem, não de redes neurais. Dá para medir diretamente: congela-se a rede num ponto qualquer do treino, calcula-se o gradiente exato g sobre os 10 000 exemplos e compara-se com estimativas de vários tamanhos de batch.

def gradiente(rede, lf, X, y, idx):
    rede.zero_grad(set_to_none=True)
    lf(rede(X[idx]), y[idx]).backward()
    return torch.cat([p.grad.reshape(-1) for p in rede.parameters()]).clone()

g = gradiente(rede, lf, X, y, torch.arange(len(X)))     # gradiente exato

for B in [1, 4, 16, 64, 256, 1024, 4096]:
    erros = []
    for _ in range(150):                                  # 150 sorteios por tamanho
        idx = torch.randint(0, len(X), (B,))
        gB  = gradiente(rede, lf, X, y, idx)
        erros.append(((gB - g).norm() / g.norm()).item())
    print(B, sum(erros)/len(erros))

O simulador abaixo mostra o resultado dessa medição de outro jeito: cada seta clara é um mini-batch sorteado de verdade, projetado no plano que contém o gradiente exato. Arraste o controle e veja o leque fechar.

Repetindo a medição para vários tamanhos e resumindo em duas curvas:

Com o erro relativo em 3,7, o passo do SGD puro é dominado pelo ruído: a componente aleatória é quase quatro vezes maior que o sinal. Multiplicar esse vetor por lr = 0,1 e somá-lo aos pesos, 10 000 vezes por época, é um passeio aleatório com passo grande — e é exatamente isso que a curva tracejada da figura anterior mostra. A correção é reduzir o learning rate na mesma proporção em que se reduz o batch.

2.3O mapa completo: 36 treinos, 6 batches × 6 learning rates

A seção anterior explicou por que o batch e o learning rate estão amarrados. Esta mede o quanto. São 36 treinos de 20 épocas sobre os mesmos 10 000 exemplos — tudo idêntico, menos essas duas escolhas. Explore antes de ler a conclusão: escolha um tamanho de batch e passeie pelos learning rates; depois fixe uma curva e mude o batch.

Todo otimizador desta aula recebe o mesmo ĝ_B e devolve um novo vetor de pesos. O SGD puro faz o mínimo:

Os demais acrescentam memória. Momentum guarda a média dos gradientes recentes; AdaGrad, RMSProp e Adam guardam também a magnitude típica de cada coordenada, para dar passos maiores nas direções que se movem pouco. A tabela abaixo é o resumo operacional — a derivação de cada um foi a aula de Otimização.

def criar_otimizador(nome, params, lr):
    if nome == "sgd":      return torch.optim.SGD(params, lr=lr)
    if nome == "momentum": return torch.optim.SGD(params, lr=lr, momentum=0.9)
    if nome == "nesterov": return torch.optim.SGD(params, lr=lr, momentum=0.9, nesterov=True)
    if nome == "adagrad":  return torch.optim.Adagrad(params, lr=lr)
    if nome == "rmsprop":  return torch.optim.RMSprop(params, lr=lr, alpha=0.99)
    if nome == "adam":     return torch.optim.Adam(params, lr=lr)
    if nome == "adamw":    return torch.optim.AdamW(params, lr=lr, weight_decay=0.01)
    raise ValueError(nome)

3.1Primeiro erro: comparar todos no mesmo learning rate

É o teste que quase todo mundo faz primeiro — fixa lr = 0,01, roda os sete, e conclui alguma coisa. Vale fazer, desde que se saiba o que está sendo medido. MNIST completo, 60 000 exemplos, mini-batch 128, 15 épocas:

3.2Agora com o melhor learning rate de cada um

Refazendo com o lr vencedor da grade da seção 4 para cada otimizador — 0,3 para SGD, 0,03 para momentum, Nesterov e AdaGrad, 0,003 para os três adaptativos restantes:

O padrão de busca mais barato que existe é uma grade logarítmica: potências de dez e os pontos intermediários em 3 — 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1. A razão de 3,16 entre vizinhos cobre quatro ordens de grandeza em nove pontos, e é fina o bastante para achar a região certa. Refinar dentro dela é uma segunda passada, opcional.

OPTS = ["sgd", "momentum", "nesterov", "adagrad", "rmsprop", "adam", "adamw"]
LRS  = [1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1.0]

grade = {}
for o in OPTS:
    for lr in LRS:
        _, h = treinar(X_tr[:10_000], y_tr[:10_000], X_te, y_te,
                        batch_size=128, otimizador=o, lr=lr, epocas=6)
        v = h["perda_treino"][-1]
        grade[(o, lr)] = v if math.isfinite(v) and v < 10 else None   # None = divergiu

5.1Três curvas do mesmo treino

Durante um treino existem pelo menos três séries que podem ser chamadas de "perda de treino":

5.2Treino e validação na mesma figura

O painel da direita da figura acima é Adam com lr = 0,001 sobre 10 000 exemplos, 40 épocas. A perda de treino cai até 0,0004 — a rede memorizou o conjunto. A perda de teste atinge o mínimo de 0,1558 na época 13 e depois sobe, terminando em 0,2020. Tudo o que foi treinado depois da época 13 piorou o modelo em dados novos.

5.3O código do gráfico

Nada de sofisticado — mas com quatro decisões que fazem diferença: escala logarítmica no eixo da perda (senão as últimas épocas viram uma linha reta colada no zero), as duas séries na mesma figura, marcador no mínimo de validação e rótulo direto em vez de legenda quando são poucas curvas.

def plotar_curva(hist, titulo=""):
    fig, ax = plt.subplots(figsize=(7, 4))
    ax.plot(hist["epoca"], hist["perda_treino"], label="treino")
    ax.plot(hist["epoca"], hist["perda_teste"],  label="validação")

    i = min(range(len(hist["perda_teste"])), key=lambda k: hist["perda_teste"][k])
    ax.plot(hist["epoca"][i], hist["perda_teste"][i], "o", ms=9, mfc="none")
    ax.axvline(hist["epoca"][i], ls=":", lw=1)
    ax.annotate(f"mínimo: época {hist['epoca'][i]}",
                (hist["epoca"][i], hist["perda_teste"][i]),
                xytext=(12, 18), textcoords="offset points")

    ax.set_yscale("log")                     # sem isso o fim da curva some
    ax.set_xlabel("época"); ax.set_ylabel("perda")
    ax.set_title(titulo); ax.legend(); ax.grid(alpha=.3)
    return fig


def comparar(historicos, chave="perda_treino"):
    """historicos: dict nome -> hist. Uma curva por configuração."""
    fig, ax = plt.subplots(figsize=(7, 4))
    for nome, h in historicos.items():
        ax.plot(h["epoca"], h[chave], label=nome)
        ax.annotate(nome, (h["epoca"][-1], h[chave][-1]),      # rótulo direto
                    xytext=(6, 0), textcoords="offset points", fontsize=9)
    ax.set_yscale("log"); ax.set_xlabel("época"); ax.set_ylabel(chave)
    ax.grid(alpha=.3)
    return fig

melhor, melhores_pesos, paciencia = float("inf"), None, 0
# ... dentro do laço de épocas, depois de avaliar:
if p_te < melhor:
    melhor, melhores_pesos, paciencia = p_te, copy.deepcopy(rede.state_dict()), 0
else:
    paciencia += 1
    if paciencia >= 5: break          # 5 épocas sem melhorar
rede.load_state_dict(melhores_pesos)

A pergunta: qual configuração chega a 97% de acurácia de teste no menor tempo de relógio? Base: os 60 000 exemplos de treino, no máximo 10 épocas por tentativa.

6.1A sua tabela

def epocas_ate(hist, alvo=0.97):
    """Primeira época em que a acurácia de teste atinge o alvo, ou None."""
    for k, ac in enumerate(hist["acc_teste"]):
        if ac >= alvo:
            return hist["epoca"][k], hist["tempo"][k]
    return None, None

MEU_OTIMIZADOR = "momentum"            # o que você vai testar

tentativas = {}
for bs in [64, 512]:
    for lr in [0.03, 0.1]:            # os dois que você escolheu
        nome = f"{MEU_OTIMIZADOR} · b={bs} · lr={lr}"
        _, h = treinar(X_tr, y_tr, X_te, y_te, batch_size=bs,
                        otimizador=MEU_OTIMIZADOR, lr=lr, epocas=10)
        tentativas[nome] = h
        ep, t = epocas_ate(h)
        print(f"{nome:>28}  " + (f"97% na época {ep} ({t:.1f}s)" if ep
              else f"não chegou — acc final {h['acc_teste'][-1]:.4f}"))

comparar(tentativas, chave="perda_teste")

import copy, math, time
import torch, torch.nn as nn
import matplotlib.pyplot as plt
from torchvision import datasets, transforms

torch.set_num_threads(2)

# ---------- dados ----------
treino = datasets.MNIST("./dados", train=True,  download=True)
teste  = datasets.MNIST("./dados", train=False, download=True)
def prep(d):
    X = d.data.reshape(-1, 784).float().div(255)
    return X.sub(0.1307).div(0.3081), d.targets
X_tr, y_tr = prep(treino)
X_te, y_te = prep(teste)

# ---------- modelo e otimizador ----------
def criar_rede(semente=42):
    torch.manual_seed(semente)
    return nn.Sequential(nn.Linear(784, 128), nn.ReLU(),
                         nn.Linear(128, 64),  nn.ReLU(),
                         nn.Linear(64, 10))

OTIM = {
    "sgd":      lambda p, lr: torch.optim.SGD(p, lr=lr),
    "momentum": lambda p, lr: torch.optim.SGD(p, lr=lr, momentum=0.9),
    "nesterov": lambda p, lr: torch.optim.SGD(p, lr=lr, momentum=0.9, nesterov=True),
    "adagrad":  lambda p, lr: torch.optim.Adagrad(p, lr=lr),
    "rmsprop":  lambda p, lr: torch.optim.RMSprop(p, lr=lr),
    "adam":     lambda p, lr: torch.optim.Adam(p, lr=lr),
    "adamw":    lambda p, lr: torch.optim.AdamW(p, lr=lr, weight_decay=0.01),
}

# ---------- avaliação e treino ----------
def avaliar(rede, X, y, bs=2000):
    rede.eval(); lf = nn.CrossEntropyLoss(reduction="sum")
    total, acertos = 0.0, 0
    with torch.no_grad():
        for i in range(0, len(X), bs):
            o = rede(X[i:i+bs])
            total   += lf(o, y[i:i+bs]).item()
            acertos += (o.argmax(1) == y[i:i+bs]).sum().item()
    rede.train()
    return total/len(X), acertos/len(X)

def treinar(X_tr, y_tr, X_te, y_te, *, batch_size, otimizador, lr, epocas,
            semente=42, registrar_passos=False):
    rede = criar_rede(semente)
    opt  = OTIM[otimizador](rede.parameters(), lr)
    lf   = nn.CrossEntropyLoss()
    n    = len(X_tr)
    bs   = n if batch_size == "full" else int(batch_size)
    g    = torch.Generator().manual_seed(semente)

    hist = {k: [] for k in ("epoca", "perda_treino", "perda_teste",
                            "acc_teste", "tempo", "passos")}
    passos_perda, passos, t0 = [], 0, time.time()

    for ep in range(1, epocas + 1):
        perm = torch.randperm(n, generator=g)
        for i in range(0, n, bs):
            idx = perm[i:i+bs]
            opt.zero_grad(set_to_none=True)
            perda = lf(rede(X_tr[idx]), y_tr[idx])
            perda.backward()
            opt.step()
            passos += 1
            if registrar_passos:
                passos_perda.append(perda.item())
        p_tr, _     = avaliar(rede, X_tr, y_tr)
        p_te, ac_te = avaliar(rede, X_te, y_te)
        for k, v in zip(hist, [ep, p_tr, p_te, ac_te, time.time()-t0, passos]):
            hist[k].append(v)
        if not math.isfinite(p_tr):
            print(f"  divergiu na época {ep}"); break

    if registrar_passos:
        hist["perda_passo"] = passos_perda
    return rede, hist