Treine uma rede de ponta a ponta
Apresente passes, perdas, backprop e atualizações juntos e treine uma rede do zero.
- Escreva o ciclo de treinamento completo: avanço, perda, retrocesso, atualização
- Retropropague manualmente através de uma rede de duas camadas em numpy
- Embaralhe os dados em minilotes e rastreie a perda e a precisão ao longo das épocas
É hora de juntar tudo e treinar a primeira rede real do Neuro. Cada treinamento de aprendizagem profunda, de XOR a Claude, é este ciclo:
1for each epoch:
2 shuffle the training data
3 for each mini-batch:
4 1. forward: predictions = model(batch)
5 2. loss: how wrong are they?
6 3. backward: gradient of the loss for every parameter
7 4. update: parameters -= learning_rate * gradients
8 check progress (loss, accuracy)XOR, aprendi desta vez
Na primeira lição você conectou o XOR manualmente. Agora a própria rede encontra os pesos. É 2 → 8 (tanh) → 1 (sigmóide), treinado com entropia cruzada binária. A passagem para trás usa um atalho famoso: para sigmóide seguido por entropia cruzada binária (e da mesma forma softmax com entropia cruzada), o gradiente da perda em relação aos logits simplifica-se para apenas predições − rótulos.
1import numpy as np
2
3X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
4y = np.array([[0], [1], [1], [0]], dtype=float)
5
6rng = np.random.default_rng(3)
7W1, b1 = rng.normal(0, 1, size=(2, 8)), np.zeros(8)
8W2, b2 = rng.normal(0, 1, size=(8, 1)), np.zeros(1)
9lr = 0.5
10
11for epoch in range(2001):
12 # 1. passagem direta
13 h = np.tanh(X @ W1 + b1)
14 p = 1 / (1 + np.exp(-(h @ W2 + b2)))
15 # 2. perda (entropia cruzada binária)
16 loss = -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
17 # 3. retropropagação
18 d_logits = (p - y) / len(X) # sigmoid + BCE shortcut
19 dW2, db2 = h.T @ d_logits, d_logits.sum(axis=0)
20 d_h = d_logits @ W2.T * (1 - h ** 2) # back through tanh
21 dW1, db1 = X.T @ d_h, d_h.sum(axis=0)
22 # 4. atualização
23 W1 -= lr * dW1; b1 -= lr * db1
24 W2 -= lr * dW2; b2 -= lr * db2
25 if epoch % 500 == 0:
26 print(f"epoch {epoch:4}: loss {loss:.4f}")
27
28print("predictions:", np.round(p.ravel(), 2))epoch 0: loss 0.8362 epoch 500: loss 0.0086 epoch 1000: loss 0.0038 epoch 1500: loss 0.0023 epoch 2000: loss 0.0016 predictions: [0. 1. 1. 0.]
Trace as formas na passagem para trás: d_logits é (4, 1) como os logits; dW2 = h.T @ d_logits é (8, 1) como W2; d_h é (4, 8) como h, multiplicado elemento a elemento pela derivada de tanh 1 − h²; e dW1 é (2, 8) como W1. Cada gradiente corresponde à forma do seu parâmetro.
Minilotes e épocas
XOR tem 4 exemplos, então cada etapa utilizou todos eles. Com dados reais, você embaralha cada época e percorre minilotes. O embaralhamento é importante: se os dados fossem classificados por classe, cada lote empurraria a rede para uma classe por vez.
1for epoch in range(epochs):
2 order = rng.permutation(len(X))
3 for start in range(0, len(X), batch_size):
4 batch = order[start:start + batch_size]
5 loss, grads = forward_backward(X[batch], y[batch])
6 update(grads)Observe a perda conforme você avança - e retenha um conjunto de validação no qual a rede nunca treina, para ver se ela aprende padrões ou memoriza exemplos. Esse é o tópico da Unidade 3.
Principais conclusões
O treinamento é um loop: avanço, perda, retrocesso, atualização - em minilotes embaralhados, época após época.
Softmax/sigmóide com entropia cruzada fornece as previsões de gradiente - rótulos nos logits.
Cada gradiente tem a mesma forma que seu parâmetro - uma verificação de bug gratuita.
Acompanhe a perda e mantenha um conjunto de validação para ver se o aprendizado se generaliza.
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.
Escreva o passe para trás
O código inicial treina uma rede 2 → 8 → 1 em uma porta lógica fornecida pela entrada (cada linha: a b label), mas falta a passagem para trás, então ele nunca aprende. Preencha os gradientes para W1, b1, W2, b2 (tanh camada oculta, saída sigmóide, entropia cruzada binária).
Ele imprime a perda nas épocas 0 e 2000, depois as previsões arredondadas e a precisão.
- XOR
- XNOR
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.
Embaralhe em minilotes
A entrada é examples batch_size epochs seed. Usando rng = np.random.default_rng(seed), imprima os minilotes de índices de exemplo para cada época: desenhe um rng.permutation(examples) novo em cada época e divida-o em lotes (o último lote pode ser menor). Imprima linhas de estilo epoch 0: [3 0 2] [1 4] e depois steps per epoch: 2.
- Cinco exemplos
- Mesmo dividido
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…