Carregando
0x50Lição 6 de 17

Retropropagação

Calcule cada gradiente em uma rede com uma varredura para trás da regra da cadeia.

32 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Aplicar a regra da cadeia ao longo de um gráfico de computação
  • Calcular gradientes de trás para frente como “gradiente a montante × derivada local”, somando os ramos
  • Derive os gradientes de uma camada linear e verifique-os numericamente

Para melhorar um peso, o treino precisa do seu gradiente: quanto muda a perda quando esse peso muda um pouco, ∂L∂w\frac{\partial L}{\partial w}. Uma rede pode ter bilhões de pesos. A retropropagação obtém cada um desses gradientes em uma única passagem para trás que custa aproximadamente o mesmo que a passagem para frente. É o algoritmo que torna possível o aprendizado profundo.

A ideia é a regra da cadeia. Se LL depende de dd e dd depende de ww, então:

∂L∂w=∂L∂d⋅∂d∂w\frac{\partial L}{\partial w} = \frac{\partial L}{\partial d} \cdot \frac{\partial d}{\partial w}

Divida qualquer cálculo em etapas simples - um grafo computacional - e cada nó precisará apenas de sua derivada local. Retrocedendo a partir da perda, o gradiente de cada nó é o gradiente que flui de cima (upstream) vezes sua derivada local. Quando um valor alimenta vários lugares, os gradientes de cada lugar se somam.

Os derivados locais de que você precisa são poucos:

NóDerivada localEntão o gradiente...
c = a + b∂c/∂a = 1, ∂c/∂b = 1é copiado para ambas as entradas
c = uma − b1 e −1é copiado, negado para b
c = a × b∂c/∂a = b, ∂c/∂b = aé multiplicado pela outra entrada
c = a²2aé dimensionado por 2a
c = relu(a)1 se a > 0 senão 0passa ou está bloqueado
c = σ(a)σ(uma)(1 − σ(uma))encolhe (no máximo ×0,25)

Experimente

Até 15 XP

Passo traseiro

Execute cada gráfico para frente, um nó por vez, e depois para trás. Antes que alguns gradientes sejam revelados, preveja-os: pegue o gradiente do nó acima e multiplique pela derivada local.

No último gráfico, observe o que um ReLU desligado faz com tudo abaixo dele.

Previsões 0/0

Um modelo de peso único prevê p=w⋅x+bp = w \cdot x + b e é pontuado com L=(p−y)2L = (p - y)^2, para w=2,x=3,b=1w = 2, x = 3, b = 1 e alvo y=10y = 10.

NóValorGradiente dL/d·Como
w (entrada)?
x (entrada)?
b (entrada)?
y (entrada)?
z = w × x?
p = z + b?
d = p − y?
L = d²?

Backprop através de uma camada inteira

Camadas reais funcionam em matrizes, mas as regras são as mesmas. Para uma camada linear Y=XW+bY = XW + b com lote de entrada XX (N × entrada) e o gradiente upstream G=∂L∂YG = \frac{\partial L}{\partial Y} (N × saída):

∂L∂W=X⊤G,∂L∂b=∑rowsG,∂L∂X=GW⊤\frac{\partial L}{\partial W} = X^\top G, \qquad \frac{\partial L}{\partial b} = \sum_{\text{rows}} G, \qquad \frac{\partial L}{\partial X} = G W^\top

Uma boa verificação de sanidade: cada gradiente tem a mesma forma do objeto do qual é o gradiente. E dX é o que você passa, upstream, para a camada anterior.

gradient_check.py
1import numpy as np
2
3rng = np.random.default_rng(1)
4X, W, b = rng.normal(size=(4, 3)), rng.normal(size=(3, 2)), rng.normal(size=2)
5target = rng.normal(size=(4, 2))
6
7def loss(W):
8    return np.mean((X @ W + b - target) ** 2)
9
10# Retropropagação: L = média(D²), com D = XW + b - alvo; portanto, dL/dD = 2D / D.size
11G = 2 * (X @ W + b - target) / target.size
12dW = X.T @ G
13
14# Verificação numérica: altere cada peso em h e observe a perda
15h = 1e-6
16numeric = np.zeros_like(W)
17for i in range(W.shape[0]):
18    for j in range(W.shape[1]):
19        nudged = W.copy()
20        nudged[i, j] += h
21        numeric[i, j] = (loss(nudged) - loss(W)) / h
22print(dW.shape, np.abs(dW - numeric).max() < 1e-5)
Saída
(3, 2) True

Principais conclusões

  • Backprop aplica a regra da cadeia de trás para frente por meio de um gráfico de computação, obtendo cada gradiente em uma varredura.

  • Gradiente de cada nó = gradiente a montante × derivada local; ramos se somam.

  • Para Y = XW + b: dW = Xᵀ G, db = soma das linhas de G, dX = G Wᵀ.

  • Verifique os gradientes numericamente ao escrever algo personalizado.

Quiz da aula

7 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: escreva código em Python

Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.

Exercício 1

Gradientes de um neurônio sigmóide

+25 XP

Um neurônio calcula p=σ(w⋅x+b)p = \sigma(w \cdot x + b) e é pontuado com L=(p−y)2L = (p - y)^2. Cada linha de entrada é w x b y. Retropropague manualmente (regra da cadeia!) e imprima a perda e os gradientes dL/dw e dL/db com 4 casas decimais:

L=0.2500 dw=-0.5000 db=-0.2500

O código inicial verifica sua resposta numericamente, para que você possa ver se acertou.

  • O neurônio do stepper
  • Mais dois
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Passagem para trás de uma camada linear

+25 XP

O código inicial constrói um lote X (a partir das linhas de entrada), pondera W, polariza b e um gradiente upstream G. Calcule dW, db e dX para Y=XW+bY = XW + b e imprima suas formas, depois os valores de cada uma com 2 casas decimais (linha por linha, separados por espaço). Por fim, imprima se uma verificação numérica de dW está de acordo (check: True).

  • Dois exemplos
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…