Retropropagação, visualizada

01 · Conceito

Conceito

A lição 2.4 produziu um único número: a loss. Para melhorar o modelo você precisa saber, para cada parâmetro, se cutucá-lo para cima ou para baixo tornaria aquele número menor. Existe uma forma óbvia de descobrir. Perturbe um parâmetro por uma quantidade minúscula, rode o modelo de novo, veja quanto a loss se moveu, e divida. Repita para o parâmetro seguinte.

Precifique esse plano honestamente, porque ele é o erro no qual vale entrar. Uma estimativa cuidadosa de dois lados precisa de dois forward passes por parâmetro. Para uma rede pequena com dez mil parâmetros isso são vinte mil forward passes por gradiente — lento, mas suportável. Para o Qwen3.8-27B, com aproximadamente 27 bilhões de parâmetros (Qwen3.8-27B Model Card, 2026), são 54 bilhões de forward passes para obter o gradiente de um único passo de treinamento. Se um forward pass levasse um milissegundo, um passo levaria cerca de vinte meses. Diferenças finitas não escalam mal; elas simplesmente não escalam.

A retropropagação é o que a substitui, e a melhoria não é incremental. Uma varredura para trás produz o gradiente de todo parâmetro de uma vez, a um custo da mesma ordem de avaliar o grafo. Um modelo maior ainda encarece as duas passagens; a economia é que o modo reverso não exige uma avaliação separada para cada parâmetro.

O mecanismo é a regra da cadeia aplicada a um grafo registrado. O forward pass avalia operações em ordem, salvando os valores intermediários de que as derivadas vão precisar. O backward pass começa no fim com $\partial L/\partial L=1$ e percorre as operações ao contrário, e em toda operação a regra é a mesma: gradiente de jusante vezes derivada local. Cada operação só precisa saber como suas próprias saídas respondem às suas próprias entradas; ela nunca precisa saber nada sobre o resto da rede.

Faça um à mão, usando a loss da lição 2.4. Tome três logits $z=(2.0,\,1.0,\,0.1)$ com a classe observada sendo a primeira. Para frente: as exponenciais são cerca de $7.389$, $2.718$ e $1.105$, somando $11.212$, então $p\approx(0.659,\,0.242,\,0.099)$ e $L=-\ln 0.659\approx0.417$. Para trás: para softmax seguido de cross-entropy o gradiente em relação aos logits colapsa no belíssimo e simples $\partial L/\partial z=p-y$, que aqui é $(0.659-1,\;0.242-0,\;0.099-0)=(-0.341,\,0.242,\,0.099)$. Leia isso como uma instrução. A classe correta carrega gradiente negativo, então o gradient descent vai elevar o logit dela. As duas classes erradas carregam gradientes positivos em proporção exata à probabilidade que tomaram, então seus logits são empurrados para baixo, a mais confiantemente errada com mais força. Agora suponha que esses logits vieram de $z=Wh+b$ para um vetor oculto $h$. A mesma regra continua: $\partial L/\partial b=p-y$, $\partial L/\partial W=(p-y)h^{\top}$, e $\partial L/\partial h=W^{\top}(p-y)$ — esta última é a mensagem entregue à camada de baixo, que vai aplicar o procedimento idêntico com a própria derivada local.

Grafos se ramificam, e a ramificação é onde as implementações ficam sutis. Se um valor influencia a loss por dois caminhos, seu gradiente é a soma das duas contribuições, porque é isso que a regra da cadeia multivariada diz. É por isso que frameworks de autodiff acumulam em buffers de gradiente em vez de sobrescrevê-los, e consequentemente por que um loop de treinamento precisa zerar esses buffers nas fronteiras de batch: a soma é o padrão matematicamente correto para uso repetido, e só o loop sabe onde um batch termina.

A conta chega em forma de memória, não de tempo. O backward pass precisa de valores que o forward computou, então o treinamento mantém ativações vivas desde o momento em que são produzidas até que seus gradientes sejam consumidos. Multiplique isso por 64 camadas, pela largura intermediária de 17.408 dentro de cada bloco feed-forward, por toda posição de token no batch, e a memória de ativações rivaliza ou supera a memória de parâmetros. Gradient checkpointing recompra memória guardando apenas fronteiras selecionadas e recomputando o resto durante o backward — mais computação por menos memória, e uma alavanca que a lição 5.10 puxa explicitamente.

Dois hábitos mantêm isso honesto. Para qualquer operação customizada nova, faça gradient-check contra diferenças finitas numa entrada minúscula — o método que falha em escala é perfeitamente bom como teste unitário, dada precisão e tamanho de passo sensatos, longe de pontos não diferenciáveis. E antes de uma execução longa, confirme que todo parâmetro que você espera treinar tem gradiente finito e não nulo após uma loss. A imagem duradoura é um fluxo reverso de responsabilidade por um grafo registrado, onde regras puramente locais se compõem em sensibilidade global, e onde o otimizador da lição 2.7 ainda não fez absolutamente nada.