Carregando
0x80Lição 9 de 17

Treine uma rede de ponta a ponta

Apresente passes, perdas, backprop e atualizações juntos e treine uma rede do zero.

34 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • 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.

train_xor.py
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))
Saída
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.

Exercício 1

Escreva o passe para trás

+25 XP

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
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

Embaralhe em minilotes

+25 XP

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
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…