Overview

Um modelo que acerta perfeitamente os dados de treino não é o objetivo — é um sinal de alerta. O que queremos de fato é um modelo que vá bem em dados que ele nunca viu e essas duas coisas puxam para lados opostos. Regularização é o nome de toda técnica que piora de propósito o ajuste no treino em troca de um ajuste melhor em todo o resto.

Formalmente, o treinamento minimiza a perda que conseguimos medir, sobre os \(N\) exemplos que por acaso temos:

mas o que nos interessa é a perda sobre toda a distribuição de onde os dados vieram, que não conseguimos medir:

A diferença \(R(\theta) - \hat{R}(\theta)\) é a lacuna de generalização e toda técnica deste capítulo é uma tentativa de mantê-la pequena.

Sobre o que é este capítulo

Cada seção abaixo responde a uma pergunta e elas foram escritas para serem lidas nesta ordem:

flowchart TD
    A["Erro de treino e de validação<br/>lidos juntos"] --> B{Qual falha?}
    B -->|"os dois altos"| C["Underfitting<br/>mais capacidade, treinar mais,<br/>regularizar menos"]
    B -->|"treino baixo,<br/>validação alto"| D["Overfitting"]
    D --> E["1. Mais dados<br/>ou aumento de dados"]
    D --> F["2. Restringir os pesos<br/>L2 / L1"]
    D --> G["3. Injetar ruído<br/>dropout, BatchNorm"]
    D --> H["4. Limitar a busca<br/>early stopping"]
    D --> I["5. Suavizar o alvo<br/>label smoothing, mixup"]

Nove simuladores rodam ao longo da página. Nenhum deles exige instalar nada — a ideia é justamente que você mova um controle e veja a falha aparecer e desaparecer antes de escrevermos uma única equação sobre ela.

Vendo acontecer

Nada explica overfitting melhor do que assistir a ele. Abaixo, 12 pontos com ruído são sorteados de uma função suave e um polinômio do grau que você escolher é ajustado a eles por mínimos quadrados. A linha tracejada é a verdade que queremos recuperar; os "×" são pontos separados que o ajuste nunca viu.

Três experimentos que valem a pena, nesta ordem:

1. Grau 1, depois 3, depois 14, com \(\lambda = 0\). O grau 1 não consegue curvar. O grau 3 chega perto da verdade. O grau 14 passa por cima de cada ponto de treino — o erro de treino desaba para praticamente zero — e dá guinadas violentas entre eles. Isso é overfitting: não um modelo errado e sim um modelo que está certo sobre o ruído.
2. Fique no grau 14 e aumente o \(\lambda\). Nada no modelo encolhe; ele continua com 15 coeficientes. Mas a curva selvagem se acalma e o erro fora da amostra cai. Capacidade nunca foi o problema — capacidade sem restrição era.
3. Fique no grau 14, \(\lambda = 0\) e arraste o número de pontos para cima. O mesmo modelo que era inútil com 12 pontos fica razoável com 60. Mais dados também é regularização e é a mais eficaz de todas.

Viés e variância

As duas falhas daquele simulador têm nome e vêm de decompor o erro esperado de um modelo em partes. Para a perda quadrática, em um ponto \(x\), tomando a média sobre todos os conjuntos de treino que poderíamos ter sorteado:

A porta de entrada clássica é um alvo de tiro. Fixe um ponto \(x\) e imagine treinar o mesmo modelo muitas vezes, cada vez com um sorteio diferente dos dados de treino, marcando onde cada um desses modelos cai. O centro do alvo é a verdade \(f(x)\); cada ponto é a previsão de um modelo.

As duas falhas são independentes — um modelo pode ter uma, as duas ou nenhuma — e é justamente por isso que vale a pena escrever a decomposição. Leia os três termos como três reclamações diferentes:

• Viés — o modelo erra sistematicamente, do mesmo jeito, não importa qual conjunto de treino ele receba. No alvo: a linha tracejada, do centro até onde os pontos caem em média. O ajuste de grau 1 é enviesado: ele não consegue curvar, então erra a curva sempre.
• Variância — o modelo muda radicalmente conforme o conjunto de treino que calhou de ver. No alvo: o espalhamento dos pontos em torno da própria média. O ajuste de grau 14 tem variância enorme: sorteie outros 12 pontos e você obtém uma curva completamente diferente.
• Ruído — a parte irredutível, \(\sigma^2 = 0{,}032\) no simulador. No alvo: uma rajada de vento a cada tiro — nenhuma mira elimina isso. Nenhum modelo vence esse termo e um modelo que fica abaixo dele nos dados de treino está ajustando ruído por definição.

A capacidade do modelo troca o primeiro pelo segundo e é esse o clássico tradeoff viés-variância:

Essa é a versão desenhada. A medida é esta. Para cada grau do polinômio, o mesmo ajuste é repetido em 140 conjuntos de treino diferentes, sorteados da mesma verdade e o erro em 41 pontos fora da amostra é separado nas duas parcelas da equação lá de cima — \(\big(\text{média} - \text{verdade}\big)^2\) e o espalhamento em torno dessa média:

O U é a curva branca e ele é um U por um motivo que agora dá para ver e não apenas afirmar: as duas curvas embaixo dele correm em direções opostas, então a soma precisa ter um fundo em algum lugar. Quatro coisas para fazer com ele:

1. Leia as duas pontas. No grau 1 o erro é quase todo viés² — todo conjunto de treino produz mais ou menos a mesma curva errada. No grau 11 é quase todo variância — cada conjunto de treino produz uma curva diferente. Mesmo erro total, doenças opostas, remédios opostos.
2. Aumente a penalidade L2. Aparece uma linha fantasma: o erro total sem ela. O braço direito do U se achata enquanto o esquerdo quase não se mexe — a penalidade compra uma redução grande de variância por um aumento pequeno de viés. Essa troca é o assunto inteiro deste capítulo.
3. Arraste os pontos de treino de 12 para 60. O vale se alarga e o braço direito afunda: com mais dados, capacidade alta deixa de ser perigosa. Compare com o experimento 3 do primeiro simulador.
4. Diminua o ruído σ. O ótimo anda para a direita — quanto menos ruído houver para ser confundido com sinal, mais capacidade você pode bancar.

Penalizando os pesos: L1 e L2

A lição do simulador foi que decorar exige coeficientes enormes. Então some o tamanho deles à perda e deixe o otimizador equilibrar os dois objetivos:

Por que a L1 dá zeros e a L2 não

Isso é mais fácil de ver do que de provar. Abaixo, as elipses são as curvas de nível da perda sem regularização e a região sombreada é o que a penalidade permite; a solução penalizada fica onde a menor elipse toca essa região. Arraste o ponto branco — o ótimo sem penalidade — e veja o que cada penalidade faz com ele.

As formas são o argumento inteiro. A região da L2 é um círculo, que é liso em todo ponto, então o lugar onde ele encosta pela primeira vez em uma elipse quase nunca cai sobre um eixo — as duas coordenadas terminam pequenas, mas vivas. A região da L1 é um losango e um losango é só quinas; as quinas ficam sobre os eixos e uma elipse que encolhe atinge uma quina vindo de uma faixa larga de direções. Isso é esparsidade: não um acidente numérico, mas consequência da forma.

Tente arrastar o \(\hat{w}\) para perto de um dos eixos e aumentar o \(\lambda\) — a solução da L1 gruda no eixo e fica lá, enquanto a da L2 desliza rumo à origem sem nunca chegar.

Dropout: quebrar as co-adaptações

O dropout⁷ ataca uma falha diferente. Uma rede consegue decorar formando grupos co-adaptados de neurônios: detectores que só funcionam porque algum outro neurônio específico está ali para corrigi-los. Um comitê desses é frágil e é exatamente ele que falha em dados novos.

A solução é bruta. A cada passo de treino, cada unidade é apagada de forma independente com probabilidade \(p\):

Nenhuma unidade pode contar com a presença de outra, porque qualquer uma delas pode sumir no próximo passo. Cada neurônio é forçado a ser útil sozinho e a rede para de depositar toda a confiança em poucos caminhos frágeis.

Há uma segunda leitura da mesma equação. Cada máscara é uma sub-rede diferente e com \(n\) unidades existem \(2^n\) delas compartilhando pesos. Treinar com dropout treina esse conjunto inteiro um pouquinho de cada vez e testar sem dropout aproxima a média das previsões de todas — um ensemble pelo preço de um único modelo.

O \(1/(1-p)\) que todo mundo erra

Apagar unidades no treino diminui o valor esperado do que a camada seguinte recebe. Isso precisa ser compensado e há duas formas de fazer:

Todo framework em uso hoje faz a versão invertida e é por isso que o model.eval() simplesmente desliga o dropout em vez de reescalar coisa alguma. Veja a esperança sendo preservada:

Deixe rodando: a média da saída de treino converge para a saída de inferência, qualquer que seja o \(p\). É esse o sentido inteiro de dividir por \(1-p\) — a camada seguinte enxerga a mesma entrada esperada nos dois modos, então a rede que você treina é a rede que você põe em produção. Suba o \(p\) para 0,9 e veja a média demorar muito mais para assentar: dropout pesado preserva a média mas acrescenta uma variância enorme e é por isso que ele atrasa a convergência.

Onde o dropout é usado hoje

Camadas de normalização

A batch normalization⁹ padroniza a entrada de uma camada usando as estatísticas do mini-batch atual:

onde \(\mu_B\) e \(\sigma_B^2\) são a média e a variância sobre o batch, e \(\epsilon \approx 10^{-5}\) mantém a raiz longe de zero. O \(\gamma\) e o \(\beta\) aprendidos deixam a camada desfazer a normalização se for isso que ajuda — inclusive recuperando a identidade, de modo que a camada nunca custa poder de representação à rede.

Treino e inferência são contas diferentes

Esta é a parte que derruba as pessoas e vale ser exato aqui, porque é também de onde vem o efeito regularizador.

No treino, o valor normalizado de uma amostra depende de quais outras amostras caíram no batch dela — então a mesma imagem ganha uma representação um pouco diferente dependendo da companhia. Isso é ruído injetado na passagem direta e é por isso que a batch normalization regulariza. Na inferência o batch não existe e a rede precisa ser determinística, então as médias armazenadas assumem.

Repare no que isso não diz: a batch normalization não é "desligada" na inferência. Ela sempre roda — apenas troca quais estatísticas usa. Desligá-la mudaria a escala de toda ativação e destruiria o modelo.

Esse último parágrafo fica mais fácil de acreditar depois de ver. Abaixo, uma ativação fixa \(x^\star = 2,3\) é normalizada várias e várias vezes, cada vez dentro de um batch recém-sorteado. Nada na amostra muda — só a companhia dela.

O histograma laranja é o mesmo número calculado centenas de vezes e ele é largo. A linha verde é o que a inferência calcula — um valor, sempre. Duas coisas para testar:

1. Arraste o B de 4 até 128. O histograma se aperta em torno do valor de inferência: batches maiores significam menos ruído e portanto menos regularização. É por isso que a batch normalization deixa de ajudar como regularizador em batches muito grandes e por que aí as pessoas recolocam o ruído por outro caminho.
2. Volte para B = 4 e olhe a média do histograma, não só a largura. Com batches muito pequenos o valor de treino não é apenas ruidoso, ele é enviesado em relação ao que a inferência vai calcular — daí a BatchNorm degradar tanto com batches minúsculos e o GroupNorm ou o LayerNorm serem usados no lugar.

A passagem reversa: uma amostra mexe em todas

Na ida, \(\mu\) e \(\sigma^2\) saem do batch. Isso tem uma consequência que quase todo mundo erra ao implementar à mão: o gradiente de uma amostra não depende só dela. Mexer em \(x_i\) muda a média e a variância; com elas, muda o \(\hat{x}_j\) de todas as outras amostras do batch.

Escrevendo \(g_i = \gamma\,\partial L/\partial y_i\) e \(m\) para o tamanho do batch:

Os dois parâmetros da própria camada são mais simples: cada um soma, ao longo do batch, o gradiente que chega até ele.

As duas somas dentro de \(\partial L/\partial x_i\) são os dois caminhos extras: a primeira é o que passa pela média, a segunda é o que passa pela variância. Sem elas a conta vira \(g_i/\sigma\), que é o erro clássico de quem escreve a camada do zero — e ele não estoura, só treina pior.

Há uma conferência barata para essa fórmula: \(\sum_i \partial L/\partial x_i = 0\), sempre. Deslocar o batch inteiro não muda coisa alguma depois da normalização, então o gradiente não pode ter componente nessa direção. O script abaixo imprime essa soma e compara a fórmula com diferenças finitas.

"""A passagem reversa da batch normalization, conferida por diferenças finitas.

O ponto da conta: como μ e σ² dependem do batch inteiro, o gradiente de UMA amostra
carrega termos de TODAS as outras. É por isso que a forma compacta tem duas somas.
"""
import numpy as np

EPS = 1e-4

def forward(x, gamma, beta):
    mu, var = x.mean(), x.var()
    xhat = (x - mu) / np.sqrt(var + EPS)
    return gamma * xhat + beta, xhat, np.sqrt(var + EPS)

def backward(dy, xhat, sigma, gamma):
    m = dy.size
    g = dy * gamma                                    # ∂L/∂x̂
    dx = (m * g - g.sum() - xhat * (g * xhat).sum()) / (m * sigma)
    return dx, (dy * xhat).sum(), dy.sum()            # dx, dgamma, dbeta

x = np.array([1.0, 2.0, 3.0, 4.0])
dy = np.array([0.1, 0.2, -0.1, 0.3])
gamma, beta = 1.0, 0.0

y, xhat, sigma = forward(x, gamma, beta)
dx, dgamma, dbeta = backward(dy, xhat, sigma, gamma)

h, num = 1e-6, np.zeros_like(x)
for i in range(x.size):
    xp, xm = x.copy(), x.copy()
    xp[i] += h; xm[i] -= h
    num[i] = ((dy * forward(xp, gamma, beta)[0]).sum() - (dy * forward(xm, gamma, beta)[0]).sum()) / (2 * h)

np.set_printoptions(precision=4, suppress=True)
print("x       =", x)
print("x̂       =", xhat, " (média 0, desvio 1)")
print("dy      =", dy)
print("dx      =", dx)
print("dgamma  =", round(dgamma, 4), " dbeta =", round(dbeta, 4))
print("soma de dx =", round(dx.sum(), 12), " — sempre zero: deslocar o batch inteiro não muda x̂")
print("erro máximo contra diferenças finitas:", f"{np.abs(num - dx).max():.1e}")

x       = [1. 2. 3. 4.]
x̂       = [-1.3416 -0.4472  0.4472  1.3416]  (média 0, desvio 1)
dy      = [ 0.1  0.2 -0.1  0.3]
dx      = [ 0.0179  0.0805 -0.2147  0.1163]
dgamma  = 0.1342  dbeta = 0.5
soma de dx = 0.0  — sempre zero: deslocar o batch inteiro não muda x̂
erro máximo contra diferenças finitas: 1.7e-10

A LayerNorm é a mesma fórmula com as somas correndo sobre as features de uma amostra, em vez de sobre o batch. É literalmente a conta que o painel de profundidade do capítulo 9 executa em cada camada.

LayerNorm e por que os Transformers a usam no lugar

A batch normalization tem uma fraqueza estrutural: ela precisa de um batch. Isso quebra com batch de tamanho 1, com sequências de comprimento variável e faz treino e inferência se comportarem de forma diferente por construção.

A LayerNorm¹¹ normaliza sobre as features de uma única amostra, em vez de sobre o batch:

Cada amostra passa a ser normalizada pelas próprias estatísticas. Não há nada a promediar no batch, então não há estatísticas correntes, treino e inferência são a mesma conta e o tamanho do batch é irrelevante. É por isso que todo Transformer a usa — e também por que a LayerNorm não regulariza: sem batch, não há ruído vindo da composição do batch.

A diferença entre as duas fica mais fácil de ver numa matriz concreta. Abaixo, as linhas são as amostras de um batch e as colunas são features. Clique numa célula e o contorno roxo marca os valores de onde vêm o \(\mu\) e o \(\sigma\) dela; a caixa embaixo escreve a conta, com \(\gamma = 1\) e \(\beta = 0\). Cada botão muda uma coisa só e conta o que ela fez com a saída da amostra 1, a linha laranja.

Quatro coisas para experimentar, cada uma isolando uma propriedade:

1. Clique numa célula e alterne entre as duas. O grupo da BatchNorm é a coluna — uma feature ao longo do batch. O da LayerNorm é a linha — uma amostra ao longo das suas features. Mesma fórmula, outro eixo.
2. Sorteie de novo as outras amostras. Na BatchNorm a saída da amostra 1 muda, embora a amostra 1 não tenha mudado: é o ruído que o histograma acima mostrou, feito da companhia dela. Na LayerNorm ela não muda nada.
3. Arraste B até 1. A BatchNorm fica com um valor por coluna, que é a própria média: toda saída vira 0 e a entrada é apagada. O PyTorch se recusa a treinar assim e levanta um erro. A LayerNorm nem percebe.
4. Multiplique a amostra 1 por 10 e depois ponha a feature 3 em milhares. Cada normalização é cega a exatamente uma dessas mudanças. A LayerNorm apaga a escala de uma amostra, então o ×10 deixa a saída dela idêntica. A BatchNorm apaga a escala de uma feature, então os milhares deixam todas as saídas idênticas. A outra paga a conta: na BatchNorm a amostra ×10 arrasta a média e o desvio de todas as colunas e o resto do batch se move junto; na LayerNorm a feature 3 toma conta do \(\sigma\) de cada amostra e as outras quatro features saem quase iguais, perto de \(-0{,}5\).

Esse último par é a regra prática. Quando as features vivem em escalas diferentes — dados tabulares, os canais de uma CNN — o que você quer são estatísticas por feature: a BatchNorm. Quando toda coordenada de um vetor é o mesmo tipo de grandeza e as amostras diferem no tamanho total — o embedding de um token — o que você quer são estatísticas por amostra: a LayerNorm, que ainda não traz dependência nenhuma do batch.

Parar cedo

Treine tempo suficiente um modelo com capacidade sobrando e ele vai começar a ajustar o ruído. A perda de validação registra o momento: ela cai junto com a de treino por um tempo, atinge o fundo e depois sobe enquanto a de treino continua descendo. Early stopping é a decisão de guardar o modelo do fundo dessa curva.

A receita tem três partes e a terceira é a que as pessoas esquecem:

1. Avalie em uma partição de validação a cada época (ou a cada \(k\) passos).
2. Paciência¹² — quantas avaliações sem melhora você tolera antes de parar. Pequena demais e você desiste por causa de ruído; grande demais e você gasta computação depois do ponto sem volta.
3. Restaure o melhor checkpoint. Parar não basta — os pesos que estão na memória quando você para são os piores, de paciência épocas depois do mínimo. Guarde uma cópia do melhor.

Abaixo, um polinômio de grau 15 é ajustado a 10 pontos ruidosos por gradiente descendente puro. Nada é penalizado e nada é descartado; a única coisa que varia é quando você para.

O painel da direita é o ponto: um treino, dois modelos muito diferentes. A curva verde — a que você guarda — acompanha a verdade. A vermelha custou 160 vezes mais computação (20 000 épocas contra 125), passa por cima de cada ponto de treino e é pior em todo o resto. E a perda de treino dela é genuinamente menor. A armadilha é essa.

Mais dados e como fabricá-los

Volte ao primeiro simulador e arraste o número de pontos de 12 para 60 com grau 14 e sem penalidade. O modelo que era inútil fica bom. Nada no modelo mudou — a restrição veio dos dados. Vale dizer isso sem rodeios, porque reordena todas as prioridades deste capítulo: quando o problema é overfitting, mais dados é a melhor resposta disponível e todo o resto é o que se faz quando não dá para conseguir mais.

Muitas vezes dá para fabricar alguns, porém, explorando invariâncias que você já conhece:

train_tf = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.6, 1.0)),
    transforms.RandomHorizontalFlip(),          # um gato espelhado é um gato
    transforms.ColorJitter(0.3, 0.3, 0.3),      # um gato sob luz mais quente também
    transforms.ToTensor(),
])
val_tf = transforms.Compose([                   # nunca aumente a validação
    transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(),
])

Label smoothing e mixup são mais fáceis de ver do que de descrever: um muda onde o alvo está, o outro muda quais exemplos existem.

À esquerda, arraste o \(\alpha\). Com \(\alpha = 0{,}05\) quase todo \(\lambda\) cai perto de 0 ou de 1 e os pontos misturados ficam colados em exemplos reais — uma edição leve. Com \(\alpha = 2\) o meio é sorteado com a mesma frequência e o conjunto de treino se enche de pontos que são genuinamente metade de cada classe. É por isso que \(\alpha\) entre 0,1 e 0,4 é a escolha usual em imagens: o bastante para suavizar o espaço entre exemplos, não o bastante para gastar o modelo em quimeras.

À direita, arraste o \(\varepsilon\). Com \(\varepsilon = 0\) o alvo é um 1 duro e o ótimo é uma diferença de logits infinita — a perda empurra para sempre, que é exatamente o que o excesso de confiança é. Qualquer \(\varepsilon > 0\) coloca o ótimo num lugar finito e alcançável.

Juntando tudo

Nenhuma técnica isolada é o regularizador; treinos reais empilham várias e elas não são intercambiáveis. Ordenadas pelo que de fato fazem:

E agora você pode empilhá-las por conta própria. O simulador abaixo treina uma rede de verdade — 2 → h → h → 1, tanh, gradiente descendente full-batch — em 40 pontos de duas luas entrelaçadas, dos quais 8% têm o rótulo errado. Cada controle é uma das técnicas acima; o painel da esquerda mostra a fronteira de decisão que o modelo de fato aprendeu e o da direita mostra as duas perdas.

Cinco experimentos, nesta ordem. Cada um leva uns quinze segundos:

1. Tudo desligado. Treine com \(\lambda = 0\), \(p = 0\), \(\sigma = 0\) e 24 neurônios. Desmarque mostrar o modelo com early stopping para ver os pesos finais: a perda de treino continua caindo enquanto a de validação faz a volta e sobe e a fronteira cria uma ilhota em torno de cada ponto de rótulo trocado. Algo como 95% no treino contra 78% na validação.
2. Marque a caixa de novo. Mesma execução, mesmo custo — mas ler os pesos da melhor época de validação, em vez da última, recupera acurácia de validação, de 78% para 81% neste sorteio dos dados. Isso é early stopping e não custou nada.
3. Aumente o weight decay. Perto de \(\lambda \approx 10^{-2}\) as ilhotas se dissolvem e a fronteira vira uma curva suave só; a validação alcança o treino. Continue até o topo do controle e veja tudo desabar em underfitting: em algum momento a penalidade afoga também o sinal.
4. Desligue o weight decay e aumente o dropout. \(p = 0{,}2\) ajuda. \(p = 0{,}4\) numa rede tão pequena a destrói — não sobra redundância para metade dos neurônios sumir. Dropout é técnica para redes com capacidade de sobra.
5. Desligue tudo e arraste os pontos de treino de 40 para 200. A diferença se fecha sozinha, sem regularizador nenhum. É a ordem de prioridades deste capítulo em um experimento só.

Lendo as duas curvas

Pontos-chave

1. O alvo é a lacuna de generalização, não a perda de treino. Perda de treino zero é um sintoma a investigar, não uma conquista.
2. Underfitting e overfitting se diagnosticam com dois números, nunca com um: erro de treino e erro de validação, lidos juntos.
3. O overfitting aparece nos pesos — coeficientes enormes de sinais alternados — e é isso que faz penalizá-los funcionar.
4. A L2 encolhe os pesos proporcionalmente e nunca chega a zero; a L1 empurra com força constante e produz zeros exatos. A diferença é a forma da região que cada uma permite.
5. O dropout quebra co-adaptações e aproxima um ensemble de \(2^n\) sub-redes. As implementações modernas escalam por \(1/(1-p)\) durante o treino, então a inferência é uma passagem direta comum.
6. A normalização ajuda primeiro a otimização e regulariza em segundo lugar; o ruído regularizador da batch norm vem da composição do batch, que é exatamente o que a LayerNorm abre mão.
7. Early stopping não é um truque — para modelos lineares está provado que ele fica perto do ridge, com \(\lambda \approx 1/(\eta t)\).
8. Mais dados vence tudo isso. Aumento de dados é a segunda melhor coisa, porque é mais dados construídos a partir do que você já sabia.

Recursos Adicionais

Três lugares para ir em seguida, na ordem que faz sentido:

1. Machine Learning Fundamentals: Bias and Variance — Starmer, J., StatQuest. Dez minutos sobre a decomposição com que este capítulo abre, em ritmo mais calmo e com outro conjunto de figuras. Assista primeiro se a seção de viés-variância pareceu abstrata:

2. A Recipe for Training Neural Networks — Karpathy, A. A contraparte prática desta página: a ordem em que realmente se fazem as coisas, por que você deve provocar overfitting em um único batch antes de qualquer outra coisa e um catálogo dos erros que parecem overfitting mas são bugs.

3. Deep Learning, capítulo 7 — Regularization for Deep Learning — Goodfellow, I., Bengio, Y., & Courville, A. O tratamento de referência, com as derivações que esta página só menciona — inclusive a prova de que early stopping e L2 coincidem em modelos lineares.

Referências bibliográficas

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