A mesma rede, os mesmos 300 exemplos.
Quase oito pontos de acurácia.

Uma rede com 109 mil parâmetros e 300 exemplos de treino tem capacidade de sobra para guardar a tabela: para cada imagem, o rótulo que veio junto. Isso zera a perda de treino sem aprender nada sobre dígitos. Para que a diferença fique impossível de ignorar, trocamos de propósito o rótulo de 30 dos 300 exemplos — 10% de ruído, uma taxa perfeitamente realista em dados anotados na pressa.

Agora existem duas coisas que a rede pode aprender, e elas competem pela mesma capacidade:

O digits do scikit-learn são 1 797 imagens de 8 × 8 pixels em tons de cinza, dez classes. É o MNIST reduzido ao osso — pequeno o bastante para 17 treinos completos caberem numa aula, grande o bastante para que overfitting seja um problema de verdade.

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

digits = load_digits()
X, y = digits.data / 16.0, digits.target        # pixels 0..16 -> 0..1

# teste primeiro, e ele sai da nossa frente até o fim da aula
X_pool, X_test, y_pool, y_test = train_test_split(
    X, y, test_size=500, random_state=0, stratify=y)

# de propósito pequeno: 300 exemplos para 109 mil parâmetros
X_tr, X_rest, y_tr, y_rest = train_test_split(
    X_pool, y_pool, train_size=300, random_state=0, stratify=y_pool)
X_val, y_val = X_rest[:400], y_rest[:400]

# 10% de ruído de rótulo: o que a rede vai decorar primeiro
rng = np.random.default_rng(7)
y_tr = y_tr.copy()
idx  = rng.choice(len(y_tr), size=30, replace=False)
y_tr[idx] = (y_tr[idx] + rng.integers(1, 10, size=30)) % 10

print(X_tr.shape, X_val.shape, X_test.shape)
# (300, 64) (400, 64) (500, 64)

A rede é escrita à mão, em NumPy, porque cada técnica desta aula é uma linha dentro dela — e é mais fácil confiar no que se viu do que no nome de um argumento. O código completo está no apêndice B; por ora, o essencial:

class MLP:
    # 64 -> 128 -> 128 -> 10, ReLU, softmax

    def forward(self, X, p_drop=0.0, rng=None):
        a = X
        for i, (W, b) in enumerate(zip(self.W, self.b)):
            z = a @ W + b
            if i < len(self.W) - 1:
                a = np.maximum(z, 0)                       # ReLU
                if p_drop > 0 and rng is not None:         # só no treino
                    m = (rng.random(a.shape) >= p_drop) / (1 - p_drop)
                    a = a * m                              # dropout invertido
            else:
                a = softmax(z)
        return a

    def step(self, Xb, yb, lr, lam, p_drop, eps, rng, mom=0.9):
        ...
        gW = cache[i].T @ d + lam * self.W[i]   # <- a penalidade L2 mora aqui,
        gb = d.sum(0)                          #    e nunca toca o viés

Repare que toda a regularização desta aula cabe em quatro argumentos: lam (L2), p_drop (dropout), eps (label smoothing) e a decisão externa de quando parar. Nenhum deles muda a arquitetura.

Treinando com os quatro desligados, 200 épocas, mini-batches de 32, SGD com momentum 0,9 e learning rate 0,1:

Aquelas exceções estreitas em torno de pontos isolados só existem se a rede puder mudar de opinião muito rápido dentro de um espaço muito pequeno — e a inclinação de uma camada linear é o tamanho dos seus pesos. Medindo ‖W‖² época a época, ao lado da lacuna entre treino e validação:

Essa correlação é o motivo de existir a família inteira de técnicas do próximo bloco. Se decorar exige norma grande, cobrar pela norma encarece decorar — sem proibir nada, sem tirar um parâmetro sequer da rede.

O gráfico do bloco 2 já contém o resultado: o melhor modelo daquele treino aconteceu na época 13 e foi jogado fora. Guardá-lo é isto:

melhor = (np.inf, 0, None)

for e in range(epochs):
    treina_uma_epoca(...)
    vll, vla = net.loss_acc(X_val, y_val)
    if vll < melhor[0]:
        melhor = (vll, e, copia_dos_pesos(net))   # <- a parte que todo mundo esquece

    if e - melhor[1] > paciencia:               # nada melhorou há `paciencia` épocas
        break

net.W, net.b = melhor[2]                        # restaura. sem isto, parar não adianta

A perda passa a ser \( J(W) + \tfrac{\lambda}{2}\Vert W\Vert^2 \), o que no gradiente é exatamente o + lam * self.W[i] que você já viu. Sete valores de λ, tudo o mais idêntico:

A implementação inteira é a linha que você já viu no bloco 2:

m = (rng.random(a.shape) >= p_drop) / (1 - p_drop)
a = a * m

Duas coisas acontecem aí. A máscara m zera cada ativação com probabilidade p_drop; a divisão por 1 - p_drop devolve a média ao valor que ela tinha — é o dropout invertido, e é por isso que na inferência não se faz nada: basta não chamar a linha. Se você esquecer a divisão, a rede treina com ativações menores do que as que verá na inferência, e a inferência sai errada sem nenhum erro aparecer.

Um 3 girado 10° continua sendo um 3, e um 3 deslocado um pixel para a direita também. Cada afirmação dessas é um exemplo novo de graça:

from scipy.ndimage import rotate, shift

def augment(X, y, rng, factor=4):
    imgs, Xs, ys = X.reshape(-1, 8, 8), [X], [y]
    for _ in range(factor):
        out = np.empty_like(imgs)
        for i, im in enumerate(imgs):
            r      = rng.uniform(-12, 12)        # graus
            dx, dy = rng.uniform(-1, 1, 2)        # pixels
            out[i] = shift(rotate(im, r, reshape=False, order=1, mode="constant"),
                           (dy, dx), order=1, mode="constant")
        Xs.append(np.clip(out.reshape(len(X), -1), 0, 1)); ys.append(y)
    return np.concatenate(Xs), np.concatenate(ys)

De 300 exemplos passamos a 1 500. O resultado: acurácia de validação de 86,0% para 88,5%, teste de 88,8% para 89,2% — e a rede ainda chega a 100% de acurácia de treino, porque decorar 1 500 imagens continua ao alcance de 109 mil parâmetros.

Com alvo one-hot, a entropia cruzada só é minimizada quando o logit correto vai a infinito: a perda nunca fica satisfeita. Com ε = 0,1 e dez classes, o alvo passa a valer 0,91 na classe certa e 0,01 nas outras nove — e o ótimo passa a ser uma diferença de logits finita, que a rede consegue alcançar e parar. São duas linhas:

T = np.full((n, 10), eps / 10)
T[np.arange(n), yb] += 1 - eps         # em vez do one-hot puro

O efeito na acurácia é modesto: 88,8% → 89,6% no teste. O efeito na confiança não é:

A configuração final usa λ = 0,001, p = 0,2, aumento de dados ×5, ε = 0,1 e early stopping com restore — cada valor escolhido na validação, nenhum no teste. O teste entra agora, uma vez:

Com o código do apêndice B rodando, o trabalho é este:

1. Reproduza a linha de base. Rode a configuração sem nada e confirme os números do bloco 2 (100,0% / 86,0%, melhor época 13). Se não bater, a semente ou a partição estão diferentes — resolva isso antes de continuar.
2. Encontre o seu λ. Varra λ ∈ {0,003, 0,006, 0,01, 0,02} com early stopping ligado, e não sem, como fizemos no bloco 5. A escolha muda? Anote qual λ vence e por quanto.
3. Combine dois. Escolha L2 + dropout e faça uma grade 3 × 3 com os valores em torno dos vencedores individuais. Você vai encontrar o que a literatura chama de interação: o melhor λ na presença de dropout não é o melhor λ sozinho. Explique, em duas linhas, por quê.
4. Quebre alguma coisa. Escolha uma das técnicas e ache o valor a partir do qual ela passa a prejudicar. Registre o número. Toda técnica desta aula tem esse valor, e saber onde ele fica vale mais do que decorar o valor recomendado.
5. Uma única medida no teste. Escolha uma configuração final pela validação, meça no teste, e escreva a frase que você colocaria num relatório — com o número, o tamanho do conjunto de teste e o que você fez para que ele seja honesto.

Este é o arquivo que gerou todos os números e todas as figuras desta página. No repositório do curso ele está em scripts/handouts/regularizacao_digits.py; abaixo, a parte que interessa para a aula.

class MLP:
    """64 -> 128 -> 128 -> 10, ReLU, softmax. Tudo explícito, para poder ver cada peça."""

    def __init__(self, sizes=(64, 128, 128, 10), seed=0):
        rng = np.random.default_rng(seed)
        self.W = [rng.normal(0, np.sqrt(2 / a), (a, b)) for a, b in zip(sizes, sizes[1:])]
        self.b = [np.zeros(b) for b in sizes[1:]]
        self.vW = [np.zeros_like(w) for w in self.W]
        self.vb = [np.zeros_like(b) for b in self.b]

    def forward(self, X, p_drop=0.0, rng=None):
        a, cache = X, [X]
        masks = []
        for i, (W, b) in enumerate(zip(self.W, self.b)):
            z = a @ W + b
            if i < len(self.W) - 1:
                a = np.maximum(z, 0)
                if p_drop > 0 and rng is not None:
                    m = (rng.random(a.shape) >= p_drop) / (1 - p_drop)   # dropout invertido
                    a = a * m
                    masks.append(m)
                else:
                    masks.append(None)
            else:
                z = z - z.max(axis=1, keepdims=True)
                a = np.exp(z); a /= a.sum(axis=1, keepdims=True)
            cache.append(a)
        return cache, masks

    def loss_acc(self, X, y, eps=0.0):
        cache, _ = self.forward(X)
        P = cache[-1]
        T = np.full((len(y), 10), eps / 10)
        T[np.arange(len(y)), y] += 1 - eps
        loss = -(T * np.log(P + 1e-12)).sum(axis=1).mean()
        return loss, float((P.argmax(1) == y).mean())

    def step(self, Xb, yb, lr, lam, p_drop, eps, rng, mom=0.9):
        cache, masks = self.forward(Xb, p_drop, rng)
        P, n = cache[-1], len(yb)
        T = np.full((n, 10), eps / 10)
        T[np.arange(n), yb] += 1 - eps
        d = (P - T) / n
        for i in reversed(range(len(self.W))):
            gW = cache[i].T @ d + lam * self.W[i]        # a penalidade nunca toca os vieses
            gb = d.sum(0)
            if i > 0:
                d = d @ self.W[i].T
                if masks[i - 1] is not None:
                    d *= masks[i - 1]
                d = d * (cache[i] > 0)
            self.vW[i] = mom * self.vW[i] - lr * gW
            self.vb[i] = mom * self.vb[i] - lr * gb
            self.W[i] += self.vW[i]
            self.b[i] += self.vb[i]

    def wnorm(self):
        return float(sum((W ** 2).sum() for W in self.W))


def augment(X, y, rng, factor=4):
    """Deslocamentos de ate 1px e rotacoes de ate 12 graus — invariancias reais de digitos."""
    imgs = X.reshape(-1, 8, 8)
    Xs, ys = [X], [y]
    for _ in range(factor):
        out = np.empty_like(imgs)
        for i, im in enumerate(imgs):
            r = rng.uniform(-12, 12)
            dx, dy = rng.uniform(-1, 1, 2)
            out[i] = shift(rotate(im, r, reshape=False, order=1, mode="constant"), (dy, dx),
                           order=1, mode="constant")
        Xs.append(np.clip(out.reshape(len(X), -1), 0, 1)); ys.append(y)
    return np.concatenate(Xs), np.concatenate(ys)


def train(lam=0.0, p_drop=0.0, eps=0.0, aug=False, epochs=200, lr=0.1, batch=32, seed=0):
    rng = np.random.default_rng(seed)
    Xt, yt = (augment(X_tr, y_tr, rng) if aug else (X_tr, y_tr))
    net = MLP(seed=seed)
    hist = []
    best = (1e9, 0, None)
    for e in range(epochs + 1):
        if e:
            idx = rng.permutation(len(Xt))
            for k in range(0, len(Xt), batch):
                j = idx[k:k + batch]
                net.step(Xt[j], yt[j], lr, lam, p_drop, eps, rng)
        trl, tra = net.loss_acc(X_tr, y_tr)
        vll, vla = net.loss_acc(X_val, y_val)
        hist.append((e, trl, tra, vll, vla, net.wnorm()))
        if vll < best[0]:
            best = (vll, e, ([W.copy() for W in net.W], [b.copy() for b in net.b]))
    tel, tea = net.loss_acc(X_test, y_test)
    net_best = MLP(seed=seed); net_best.W, net_best.b = best[2]
    bl, ba = net_best.loss_acc(X_test, y_test)
    return dict(hist=np.array(hist), final_test=tea, best_epoch=best[1], best_test=ba,
                net=net, net_best=net_best)

net       = nn.Sequential(nn.Linear(64,128), nn.ReLU(), nn.Dropout(0.2),
                          nn.Linear(128,128), nn.ReLU(), nn.Dropout(0.2),
                          nn.Linear(128,10))
otim      = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9,
                            weight_decay=1e-2)        # L2 (em Adam, use AdamW)
criterio  = nn.CrossEntropyLoss(label_smoothing=0.1)  # label smoothing
net.train() / net.eval()                              # liga e desliga o dropout

Este handout acompanha a página 7. Regularização, que traz os nove simuladores interativos — inclusive um em que você empilha estas mesmas técnicas e vê a fronteira de decisão mudar em tempo real.