Redes Neurais: o Cérebro Artificial

Pesos (w) são os números que o modelo aprende durante o treino. Bias (b) é um deslocamento que permite ao neurônio ativar mesmo quando todas as entradas são zero. A função de ativação (f) introduz não-linearidade — sem ela, empilhar 100 camadas seria o mesmo que ter uma só (composição de lineares é linear).

A profundidade (número de hidden layers) dá nome ao deep learning. Camadas iniciais aprendem features simples (bordas, texturas); camadas profundas compõem essas features em representações abstratas (rostos, objetos, conceitos). Cada camada faz a mesma coisa: multiplicação matricial + bias + ativação.

O forward pass é simplesmente passar os dados pela rede da entrada até a saída, camada por camada. O resultado é uma previsão. A loss function mede quão longe essa previsão está do valor correto:

A loss é o único número que a rede tenta minimizar. Tudo que o modelo "aprende" durante o treino é ajustar os pesos para reduzir essa loss. A escolha da loss function errada pode fazer o modelo convergir para algo inútil.

Backpropagation é o algoritmo que calcula quanto cada peso contribuiu para o erro e em que direção ajustá-lo. Funciona em 3 passos:

A chain rule do cálculo é o coração: o gradiente de cada camada depende do gradiente da camada seguinte, multiplicado pelas derivadas locais. Assim o erro se propaga da saída até a entrada — cada peso sabe exatamente quanto e em que direção se mover.

O learning rate (lr) controla o tamanho do passo em cada atualização.lr = 0.001 é um ponto de partida comum. Alto demais: o treino oscila e diverge. Baixo demais: converge tão devagar que parece não aprender. Otimizadores modernos (Adam, AdamW) adaptam o learning rate por parâmetro, mas o valor inicial ainda importa muito.

Redes muito profundas (100+ camadas) sofriam com um problema fundamental: o gradiente desaparecia antes de chegar às camadas iniciais (vanishing gradient), e as camadas extras não ajudavam — ou até pioravam o desempenho. A ResNet (2015) resolveu isso com uma ideia elegante: skip connections (ou residual connections).

A insight: em vez do bloco aprender a transformação completa H(x), ele aprende apenas o resíduo F(x) = H(x) - x. Se o bloco não for necessário,F(x) → 0 e a rede simplesmente passa o input adiante (identidade). Com isso, o gradiente tem um caminho direto da saída até as camadas iniciais — sem multiplicações que o encolhem.

Durante o treino, as distribuições das ativações mudam a cada batch (covariate shift interno). Isso instabiliza o treino e exige learning rates menores. Normalização resolve: padroniza as ativações para média≈0, desvio≈1 em um determinado eixo.

Overfitting é quando o modelo decora o dataset de treino — incluindo o ruído — e perde a capacidade de generalizar para dados novos. É a diferença entre um estudante que entende a matéria e um que decora as respostas da prova anterior.

Diagnóstico: loss de treino cai mas loss de validação sobe (ou estagna). Soluções:

Nunca use o test set pra tomar decisões durante o treino. Se fizer isso, está implicitamente overfittando no test — e o número final não vale nada. O validation set existe exatamente pra isso: tomar decisões (learning rate, quando parar, qual modelo é melhor) sem contaminar a avaliação final.

import torch
import torch.nn as nn

# Rede simples: 784 inputs → 256 hidden → 10 classes
model = nn.Sequential(
    nn.Linear(784, 256),   # camada 1: 784×256 + 256 = 200.960 params
    nn.ReLU(),             # ativação
    nn.Dropout(0.3),       # regularização: desliga 30% por batch
    nn.Linear(256, 10),    # camada de saída: 256×10 + 10 = 2.570 params
)

loss_fn = nn.CrossEntropyLoss()   # loss pra classificação
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 1 epoch de treino
for images, labels in train_loader:
    pred = model(images)           # forward pass
    loss = loss_fn(pred, labels)   # calcula loss
    loss.backward()                # backpropagation (calcula gradientes)
    optimizer.step()               # atualiza pesos
    optimizer.zero_grad()          # limpa gradientes pro próximo batch

São 14 linhas. É isso que acontece debaixo de todo framework de ML. loss.backward() é o backpropagation. optimizer.step() é w = w - lr × grad.