Descida de gradiente: aprender em pequenos passos

Na lição anterior, uma fórmula nos entregou a melhor reta de uma vez. Mas uma rede neural com milhões de pesos não tem fórmula assim. Como um computador pode encontrar bons valores para milhões de botões de ajuste se ninguém consegue dizer onde fica a melhor configuração? A resposta é quase constrangedora de tão simples: ele sente para que lado o terreno desce e dá um passinho. Depois faz de novo.

Experimente

• Escolha uma taxa de aprendizado pequena e clique em Passo algumas vezes. Veja a reta se mexer um pouco a cada passo e a curva de perda descer devagar.
• Clique em Executar e deixe rodar. A reta termina perto da reta de mínimos quadrados da lição anterior?
• Recomece com a maior taxa de aprendizado e clique em Passo de novo. Observe a curva de perda: em vez de cair, ela sobe, e a reta balança descontrolada. Isso é divergência.
• Teste as taxas intermediárias e encontre a maior com a qual a perda ainda cai de forma constante.

A ideia em poucas palavras

Vamos ver agora, em palavras simples, o que você acabou de manipular.

Imagine que você está na encosta de uma montanha, no meio de uma neblina densa. Você quer chegar ao vale, mas só enxerga um metro à sua volta. Uma estratégia sensata: tatear o chão com os pés, achar a direção em que ele desce mais íngreme, dar um passo para lá e repetir. Você nunca vê a paisagem inteira e, mesmo assim, passo a passo, vai descendo.

No aprendizado de máquina, a “paisagem” é o erro do modelo. Cada par possível de inclinação e intercepto é uma posição no mapa, e a altura nessa posição é o erro quadrático médio da lição 3. O fundo do vale é a melhor reta. A descida de gradiente (ou gradiente descendente) é essa caminhada na neblina: começar em algum lugar, medir para que lado o erro diminui, mexer um pouco os parâmetros nessa direção e repetir até o erro parar de cair.

Por que funciona

A direção de subida mais íngreme de uma função é dada pelo seu gradiente — uma lista de derivadas, uma para cada parâmetro, que diz quanto o erro cresceria se aquele parâmetro subisse um pouquinho. Vá no sentido contrário e o erro cai. Para cada parâmetro w, um passo é:

w ← w − η · ∂L/∂w

Aqui L é a perda (o erro que minimizamos), ∂L/∂w indica com que força a perda reage a w, e η (a letra grega eta) é a taxa de aprendizado, que define o tamanho do passo. Onde a encosta é íngreme, os passos são grandes; perto do fundo, a encosta fica suave e os passos encurtam sozinhos.

Tudo depende da taxa de aprendizado. Se ela for pequena demais, cada passo é minúsculo e a caminhada leva uma eternidade. Se for adequada, o erro cai rápido e se acomoda perto do mínimo. Se for grande demais, cada passo passa do vale e aterrissa mais alto na encosta oposta; o passo seguinte passa ainda mais, e o erro cresce sem limite. Isso se chama divergência, e é o motivo mais comum para um treinamento “explodir”.

A beleza do método é que ele só precisa de uma coisa: conseguir calcular o gradiente na posição atual. Não precisa de uma fórmula para a resposta, e funciona do mesmo jeito para dois parâmetros ou para dois bilhões. Por isso ele é o motor de quase todas as redes neurais, inclusive dos modelos de linguagem da lição 12. Na prática, o gradiente costuma ser estimado num pequeno lote aleatório de exemplos em vez de em todos, o que deixa cada passo mais barato e mais ruidoso, mas funciona surpreendentemente bem.

Erro comum

Quando a perda dispara de repente ou vira “NaN” (not a number, “não é um número”), quem está começando costuma desconfiar de um bug no código. Muito mais frequentemente, a taxa de aprendizado é simplesmente grande demais. A solução é diminuí-la, não reescrever o modelo. O erro oposto é menos visível: uma taxa tão pequena que a perda ainda está caindo quando o treinamento para, e o modelo parece pior do que poderia ser. Uma armadilha relacionada são atributos em escalas muito diferentes — por exemplo, idade em anos ao lado de renda em reais —, que transformam o vale num cânion longo e estreito, onde nenhuma taxa de aprendizado serve para todas as direções. Padronizar os atributos antes facilita muito a caminhada.

Agora temos as duas metades da receita do aprendizado: uma pontuação e um jeito de melhorá-la. Na próxima lição usamos as duas para um novo tipo de pergunta — não “quanto?”, mas “qual?”.

import numpy as np
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True, as_frame=True, scaled=False)
bmi = X["bmi"].to_numpy()
z = (bmi - bmi.mean()) / bmi.std()  # IMC padronizado, como no lab
mse = lambda w, b: np.mean((y - (b + w * z)) ** 2)
for lr in [0.01, 0.1, 0.8, 1.1]:
    w, b = 0.0, 0.0  # começar na origem
    for _ in range(5):  # cinco passos com o conjunto inteiro
        r = y - (b + w * z)
        w, b = w + lr * 2 * np.mean(r * z), b + lr * 2 * np.mean(r)
    print(f"lr {lr}: loss after 5 steps {mse(w, b):.0f}")
w_best, b_best = np.polyfit(z, y, 1)
print(f"minimum: {mse(w_best, b_best):.0f}")

lr 0.01: loss after 5 steps 24468
lr 0.1: loss after 5 steps 6595
lr 0.8: loss after 5 steps 4043
lr 1.1: loss after 5 steps 159823
minimum: 3890