Redes neurais e backpropagation

Camadas que dobram o espaço

Vimos que um perceptron só traça uma reta — e falha no XOR. A saída é empilhar neurônios em camadas. Cada neurônio da primeira camada aprende uma fronteira simples; as camadas seguintes combinam essas fronteiras em formas cada vez mais complexas. É como dobrar uma folha de papel várias vezes: o que era inseparável com um corte reto passa a ser separável.

O ingrediente mágico é a função de ativação não-linear (tanh, ReLU) entre as camadas. Sem ela, empilhar camadas seria inútil — várias transformações lineares em sequência equivalem a uma só. A não-linearidade é o que dá às redes seu poder de aproximar qualquer função.

Uma rede aprende o XOR ao vivo

Clique em "treinar" e observe: as arestas (pesos) mudam de cor e espessura, a perda cai, a tabela XOR vai ficando verde e a fronteira aprendida (à esquerda) curva-se para separar os cantos. Se a rede travar num mínimo ruim, "↺ novo" reinicializa os pesos para outra trajetória.

Forward pass: da entrada à previsão

// Rede neural: camadas de neurônios + ativações não-lineares

// Forward pass de uma rede 2 → 4 → 1 (resolvendo XOR):
def forward(x):
    // camada oculta: soma ponderada + tanh (não-linearidade)
    z1 = W1 @ x + b1          // 4 somas ponderadas
    a1 = tanh(z1)             // ativação → "dobra" o espaço

    // camada de saída: + sigmoide → probabilidade em [0,1]
    z2 = W2 @ a1 + b2
    saida = sigmoid(z2)
    return saida

// A ativação é o segredo: SEM ela (a1 = z1), empilhar camadas
// colapsa numa única transformação linear — inútil para XOR.
// Com tanh/ReLU, a rede aprende fronteiras curvas arbitrárias.

Backpropagation: como os gradientes fluem para trás

// Backpropagation: a regra da cadeia em escala

// 1. Forward: calcula a saída e a perda L = (saída − alvo)²
// 2. Backward: propaga o erro da saída para trás, camada a camada,
//    usando a REGRA DA CADEIA para achar ∂L/∂w de CADA peso.

// camada de saída
dz2 = (saida - alvo) * saida * (1 - saida)   // erro · sigmoid'
dW2 = dz2 * a1
// propaga para a camada oculta
da1 = W2.T * dz2
dz1 = da1 * (1 - a1**2)               // · tanh'
dW1 = outer(dz1, x)

// 3. Atualiza todos os pesos com gradiente descendente:
//    W -= alpha * dW   (igual à lição de regressão!)

// Backprop só calcula gradientes de forma eficiente —
// quem de fato "aprende" é o gradiente descendente.

Construindo e treinando uma rede

Mini projeto: implemente uma rede 2→2→1 em NumPy que aprende o XOR — forward, backward e a atualização dos pesos, exatamente como na visualização. Plote a curva de perda. Experimente sem a ativação (rede puramente linear) e confirme que ela nunca resolve o XOR (a perda estaciona em ~0.25).

Projeto principal: use PyTorch ou Keras para classificar dígitos manuscritos (MNIST) com uma rede densa (ex: 784→128→10). Treine com mini-batches e o otimizador Adam, e acompanhe acurácia de treino e validação por época. Você deve passar de ~97% de acurácia. Depois visualize alguns erros — quais dígitos a rede mais confunde?

Desafio extra: implemente backpropagation totalmente do zero (sem autograd) para uma rede com camadas e profundidade configuráveis, suportando ReLU e sigmoide. Valide os gradientes por gradient checking (comparando com a derivada numérica). Depois adicione mini-batches e compare a velocidade de convergência com batch completo no MNIST.

Teste sua intuição

Onde você encontra isso