Fazer a rede treinar — e fazê-la generalizar

Comece olhando, em vez de adivinhar. Passe um batch de entradas pela rede e imprima o desvio padrão das ativações em cada camada, e depois o desvio padrão dos gradientes dos pesos:

def profile(model, x):
    h = x
    for layer in model:
        h = layer(h)
        if isinstance(layer, (nn.Tanh, nn.ReLU)):
            print(f"activation std: {h.std().item():.4f}")
    model(x).sum().backward()
    for p in model.parameters():
        if p.dim() == 2:
            print(f"gradient std: {p.grad.std().item():.2e}")

Três inicializações, mesma arquitetura, seis camadas de $\tanh$:

A primeira linha é a rede acima, e ela não está aprendendo devagar — não resta sinal nenhum. Na camada quatro, o desvio padrão da ativação sofreu underflow para zero em quatro casas decimais. Toda entrada produz a mesma saída, a saída é uma constante, e o gradiente de uma constante é nada. Os pesos foram inicializados pequenos "por segurança", e pequeno foi fatal.

A segunda linha é a falha oposta, e vale entendê-la porque ela é contraintuitiva. As ativações parecem saudáveis — em torno de 0,96 —, mas isso é $\tanh$ saturada, presa perto do seu limite, exatamente o regime que o Capítulo 5 mediu como perdendo um fator de quase dez mil no gradiente. E, ainda assim, os gradientes são enormes: 1940 na primeira camada. As duas coisas são verdadeiras ao mesmo tempo. Cada passo para trás multiplica por $W^\top$, e com 128 entradas em variância unitária esse fator tem um ganho de cerca de $\sqrt{128} \approx 11$, o que sobrecarrega o encolhimento da $\tanh$ saturada. Os gradientes crescem geometricamente no caminho de volta. Esse é o gradiente explosivo, e ele produz valores de perda de nan em poucos passos em qualquer execução de treinamento real.

A terceira linha é o que você quer: ativações com escala aproximadamente constante ao longo da profundidade, gradientes com escala aproximadamente constante ao longo da profundidade. Nada morre, nada explode.

Inicializar bem corrige a escala no passo zero. Não a mantém fixa: os pesos se movem, e no passo cinco mil o argumento cuidadoso da variância já não se aplica.

Camadas de normalização impõem a escala continuamente. Dado um vetor de ativações, subtraia uma média, divida por um desvio padrão, depois aplique uma escala aprendida $\gamma$ e um deslocamento $\beta$ para que a camada possa desfazer a normalização se isso acabar sendo o que ela quer:

A única pergunta real é sobre o que você faz a média. Batch normalization³ calcula $\mu$ e $\sigma$ ao longo da dimensão do batch, uma estatística por feature. Layer normalization⁴ calcula essas estatísticas ao longo das features, uma estatística por exemplo.

Essa escolha parece pequena e decide quase tudo depois:

É por isso que LayerNorm é a que você encontrará de novo no Capítulo 9 sem alterações: o bloco transformer a usa, e a usa pelos motivos da coluna da direita, não porque ela funciona melhor em abstrato.

Quatro possíveis correções para a rede morta: inicialização Xavier, LayerNorm, conexões residuais e Adam em vez de SGD. A tentação é aplicar as quatro e seguir em frente. Faça isso e você nunca saberá qual delas importou, e na próxima vez que acontecer você não terá método — só um ritual.

Então aplique uma por vez. Mesma seed, mesmos dados, mesma arquitetura, 800 passos:

Leia essa tabela como você a leria às 2 da manhã, e a conclusão é: nada funciona sozinho, tudo funciona junto, portanto deep learning é alquimia. Essa conclusão está errada, e descobrir por quê é a coisa mais útil deste capítulo.

Dê a cada execução seis vezes o orçamento — 5000 passos em vez de 800 — e tudo muda:

Agora o quadro é nítido, e é um diagnóstico em vez de um ritual.

A inicialização sozinha corrige. A normalização sozinha corrige. Cada uma trata a doença real — o sinal para frente colapsando para zero — e qualquer uma das duas é suficiente. Em 800 passos, elas apenas pareciam crédito parcial, porque tinham resolvido o problema e ainda estavam saindo do buraco.

Conexões residuais e Adam não corrigem, em nenhum orçamento. Não porque sejam ruins, mas porque tratam outra doença. Uma conexão residual dá ao gradiente um caminho em volta de uma camada bloqueante; isso vale muito quando o gradiente é o problema, e nada quando o sinal para frente já é zero, porque um atalho em volta de uma camada morta ainda carrega um valor morto. Adam redimensiona o passo de cada parâmetro pelo seu próprio histórico de gradientes; isso ajuda quando gradientes têm magnitudes muito diferentes, e não consegue ressuscitar uma rede cuja saída não depende da entrada.

E "nada" continua sendo exatamente 0.6931 depois de cinco mil passos. Não 0.6929. Não é lenta; está morta, e essa distinção fica visível de um jeito que antes não ficava, porque você tem a linha que diz que uma correção funciona para comparar.

Daqui em diante, este curso usa PyTorch. Isso deve ser merecido, não apenas anunciado, então aqui está exatamente o que ele faz e que você já sabe fazer.

Um otimizador é uma regra para transformar gradientes em atualizações de parâmetros. O gradient descent simples usa o gradiente. Momentum usa uma média móvel dele, o que suaviza o ruído e ganha velocidade nas direções que permanecem consistentes:

v = beta * v + p.grad          
p -= lr * v                    

Adam⁵ mantém duas médias móveis — do gradiente e do gradiente ao quadrado — e divide uma pela raiz quadrada da outra, de modo que cada parâmetro recebe um passo escalado para a magnitude recente do seu próprio gradiente:

m = b1 * m + (1 - b1) * g          # mean of the gradient          
v = b2 * v + (1 - b2) * g * g      # mean of the squared gradient  
m_hat = m / (1 - b1 ** t)          # bias correction: both averages start at zero
v_hat = v / (1 - b2 ** t)
p -= lr * m_hat / (v_hat.sqrt() + eps)   

Dez linhas. Rode ambos contra torch.optim no mesmo problema por 50 passos:

SGD+momentum   by hand [2.7781870365142822, -1.0304985046386719]
               torch   [2.7781870365142822, -1.0304983854293823]   max |diff| = 1.19e-07
Adam           by hand [0.4893140196800232, -0.46317872405052185]
               torch   [0.48931416869163513, -0.46317875385284424]   max |diff| = 1.49e-07

Idênticos até a precisão de float32. torch.optim.Adam são aquelas cinco linhas, mais décadas de cuidado com casos de borda e um kernel em C++. Essa é a troca que você fará daqui em diante: não magia no lugar do entendimento, mas velocidade no lugar de linhas que você já escreveu.

A explicação usual de Adam é "taxas de aprendizado adaptativas por parâmetro", o que é uma descrição, não um motivo. O motivo é geometria, e ela pode ser medida.

Pegue uma perda cuja curvatura difere entre direções: íngreme em uma, rasa em outra. SGD tem uma única taxa de aprendizado global, então precisa escolher um valor pequeno o bastante para ser estável na direção mais íngreme — e esse valor então é pequeno demais para a direção rasa, onde o progresso se arrasta. É isso que causa a imagem clássica do gradient descent ziguezagueando por um vale estreito.

Duas razões de curvatura, três otimizadores, 300 passos, e cada otimizador recebendo a melhor taxa de aprendizado de uma varredura para que ninguém fique em desvantagem:

Com uma razão de dez, tudo funciona e não há o que discutir. Com mil, SGD simples não consegue chegar à resposta em nenhuma taxa de aprendizado testada — seu melhor resultado ainda é um erro de 1,93 — e diverge diretamente em metade das taxas. Adam chega exatamente ao alvo e não diverge em nenhuma delas.

Essa última coluna é o motivo prático pelo qual Adam é o padrão. Não é que Adam encontre soluções melhores; em problemas bem condicionados, SGD ajustado muitas vezes iguala ou supera. É que Adam é muito menos sensível à taxa de aprendizado que você escolheu, e redes reais têm razões de curvatura muito piores do que mil entre seus milhões de parâmetros.

Mais duas peças pertencem aqui, e ambas cabem em uma linha. Gradient clipping redimensiona o vetor de gradiente sempre que sua norma excede um limite, o que transforma a linha "perda de repente salta para um valor enorme" da tabela de diagnóstico em um não evento. E cronogramas de taxa de aprendizado: um warmup curto a partir de quase zero nos primeiros poucos centenas de passos, porque as estimativas de variância de Adam são lixo até terem visto alguns gradientes, e um passo de tamanho cheio dado sobre lixo pode destruir uma inicialização; depois cosine decay em direção a zero, porque terminar uma execução com o mesmo tamanho de passo com que você começou significa tremer em torno do mínimo em vez de se assentar nele.

Tudo até aqui foi sobre fazer a perda cair. Agora vem a metade mais difícil, porque a perda cair não é o objetivo — é uma aproximação do objetivo, e essa aproximação falha de uma forma específica e famosa.

Doze pontos de uma função suave com um pouco de ruído. Ajuste polinômios de grau crescente:

Grau 11 passando por 12 pontos atravessa cada um deles exatamente — erro de treino zero em seis casas decimais — e é oito vezes pior que o grau 5 em dados que não viu. Peça ao grau 3 e ao grau 11 que prevejam em $x = 3.25$, logo fora do intervalo de treinamento:

degree  3: predicts   -1.053   (truth -0.012)
degree 11: predicts  +61.224   (truth -0.012)

Sessenta e um, onde a resposta é aproximadamente zero. O modelo não aprendeu a função; aprendeu os doze pontos, e entre eles faz o que a aritmética exigir.

Isso é overfitting, e seu oposto — grau 1, que não consegue representar a curva de jeito nenhum e é ruim em todos os lugares — é underfitting. A explicação clássica divide o erro esperado de um modelo em três partes: viés, o erro por o modelo ser rígido demais para representar a verdade; variância, o erro por o modelo ser flexível demais e perseguir o ruído nesta amostra específica; e ruído irredutível, que nada corrige. Modelos simples são enviesados, modelos flexíveis têm alta variância, e a prescrição clássica é encontrar o ponto ideal no meio — grau 5 na tabela acima.

As ferramentas padrão atacam o termo da variância:

• Regularização L2 (weight decay) adiciona $\lambda \lVert w \rVert^2$ à perda, puxando pesos em direção a zero e tornando a função mais suave. Na tabela acima, o maior coeficiente do grau 11 causa o estrago; penalizar o tamanho o desarma.
• L1 adiciona $\lambda \sum |w_i|$ em vez disso. A diferença não é cosmética: o gradiente de L2 é proporcional ao peso e, portanto, encolhe conforme o peso encolhe, aproximando-se de zero sem chegar lá, enquanto o gradiente de L1 é uma constante $\pm\lambda$ que continua empurrando até o fim. Portanto, L1 produz pesos que são exatamente zero — ela seleciona features. L2 produz pesos pequenos. Use L2 quando quiser suavidade, L1 quando quiser esparsidade.
• Dropout⁷ zera um subconjunto aleatório de ativações em cada passo de treinamento, para que nenhuma unidade possa depender de uma unidade específica estar presente.
• Early stopping observa a perda de validação e para quando ela começa a subir.
• Data augmentation fabrica mais exemplos de treinamento a partir dos que você tem, atacando o problema na fonte: overfitting é falta de dados tanto quanto é excesso de parâmetros.
• Cross-validation divide os dados de $k$ maneiras e treina $k$ vezes, o que compra uma estimativa confiável do erro de teste quando você tem dados demais em falta para separar um conjunto retido.

Agora o fato que quebra o quadro.

A história de viés-variância diz que, depois do ponto ideal, mais parâmetros significam pior generalização. Modelos de linguagem modernos têm muito mais parâmetros do que as regras clássicas permitiriam para os dados que veem, e generalizam de forma excelente. As duas afirmações são verdadeiras, e conciliá-las é a coisa mais útil deste capítulo.

Quarenta pontos de treinamento, entradas de vinte dimensões, features ReLU aleatórias, e o número de features $P$ varrido de 2 a 5000 — com a solução de norma mínima escolhida sempre que houver muitas que se ajustem:

Leia em três partes. Até $P/n = 0.5$, a história clássica vale exatamente: o erro cai, depois começa a subir. Em $P = n = 40$ — o limiar de interpolação, onde o modelo tem exatamente parâmetros suficientes para passar por todos os pontos de treinamento — o erro de teste atinge o pico, em 5,81, cinco vezes pior que o modelo pequeno. Esse pico é o alerta clássico, e ele é real.

Então ele desce de novo. E continua descendo, passando de $P = 5n$, passando de $P = 37n$, até $P = 125n$, onde o erro de teste de 0,5664 é melhor do que o melhor modelo subparametrizado já conseguiu. Um modelo com 5000 parâmetros ajustado a 40 pontos é o melhor modelo da tabela.

Isso é double descent,⁸⁹ e o mecanismo está visível na última coluna. Quando $P > n$, há infinitas configurações de parâmetros que ajustam os dados de treinamento exatamente, e qual delas você obtém depende de como escolhe. A solução de norma mínima escolhe a menor, e $\lVert w \rVert$ mostra o que isso significa: ela atinge o pico em 14,83 exatamente no limiar — onde há exatamente uma solução interpoladora e você fica preso a ela, por mais extrema que seja — e depois cai monotonicamente conforme $P$ cresce, porque mais parâmetros significam mais soluções interpoladoras para escolher, o que significa que a menor disponível fica menor. Em $P = 5000$, a norma é 0,18, oitenta vezes menor do que no limiar.

Então os parâmetros extras não estão adicionando complexidade. Estão adicionando escolha, e a regra de seleção gasta essa escolha em simplicidade. A regularização não está na função de perda; está no algoritmo. Gradient descent a partir de uma inicialização pequena tem um viés documentado em direção a soluções de norma pequena, e é por isso que esse comportamento aparece em redes reais treinadas da forma comum, não apenas na álgebra linear acima.

A consequência prática, da qual o Capítulo 10 depende: "o modelo tem mais parâmetros do que dados, então vai sofrer overfit" não é um argumento válido. Era uma boa regra quando os modelos viviam à esquerda do limiar. Tudo que é interessante agora vive muito à direita dele, onde a regra se inverte.

As ferramentas deste capítulo bastam para treinar uma rede que funciona em dados que você consegue colocar em uma tabela: linhas de números, uma coluna de rótulos.

Linguagem não é isso. Antes que um modelo possa prever a próxima palavra, algo precisa decidir o que uma "palavra" sequer é — e a resposta não são letras nem palavras, mas um vocabulário que o modelo aprende a partir dos bytes brutos dos dados de treinamento. Essa decisão, tomada uma vez antes do treinamento começar, determina quantas coisas o modelo pode dizer, quanto custa uma solicitação, e por que modelos que conseguem passar em uma prova de direito não conseguem contar de forma confiável as letras em strawberry.

O Capítulo 7 constrói um tokenizer.

Para as conexões residuais usadas acima, He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Building makemore Part 3: Activations & Gradients, BatchNorm, de Andrej Karpathy, percorre o diagnóstico por histograma de ativações em um modelo real e é o melhor tratamento prático da primeira metade deste capítulo. As aulas 8 e 11–13 de Learning From Data, de Yaser Abu-Mostafa, apresentam corretamente a teoria clássica de generalização, incluindo as partes que este capítulo comprimiu em um parágrafo.