Ir para o conteúdo

Redes Neurais

A Parte VI começa na fronteira — e a fronteira é construída com peças que você já possui. Uma rede neural são regressões logísticas empilhadas e compostas, treinadas por gradiente descendente, regularizadas com penalidades que você conhece do Ridge. Esta é a aula de transição; a jornada completa — CNNs, transformers, modelos generativos — está no curso complementar ANN-DL.

De um neurônio a uma rede

O perceptron de Rosenblatt (1958) calcula \(\hat{y} = \operatorname{step}(w^\top x + b)\) — um classificador linear. Sua regra de aprendizado é lindamente simples: percorra os dados ponto a ponto e, a cada erro, empurre os pesos em direção ao ponto classificado incorretamente: \(w \leftarrow w + \eta\, y_i x_i\). Observe-o convergir:

Minsky & Papert (1969) provaram que uma única unidade dessas não consegue resolver o XOR (nenhuma reta o separa), desencadeando o primeiro inverno da IA. A saída, tornada treinável pela retropropagação (backpropagation) (Rumelhart, Hinton & Williams, 1986): compor neurônios em camadas.

Um perceptron multicamadas (MLP) com uma camada oculta:

[ h = \sigma(W_1 x + b_1) \qquad\text{(camada oculta: atributos aprendidos)} ] [ \hat{y} = \operatorname{softmax}(W_2\, h + b_2) \qquad\text{(uma camada logística/softmax no topo)} ]

Leia no vocabulário do curso: a camada de saída é exatamente a regressão logística multiclasse — mas, em vez de rodar sobre atributos construídos à mão (os polinômios que você montou aqui), roda sobre atributos \(h\) que a rede aprende sozinha. Essa é toda a revolução: a engenharia de atributos vira parte da otimização.

Funções de ativação: a não linearidade essencial

Sem \(\sigma\), empilhar camadas colapsa: \(W_2(W_1 x) = (W_2 W_1)x\) — ainda linear. A não linearidade entre camadas é o que compra poder expressivo. Padrão moderno: ReLU, \(\max(0, z)\) — barata e amigável ao gradiente. O teorema da aproximação universal (Cybenko, 1989; Hornik, 1991): uma camada oculta com neurônios suficientes pode aproximar qualquer função contínua — a existência é garantida; aprendê-la eficientemente é para o que servem a profundidade, os dados e os truques de otimização.

Regressão logística vs fronteira de decisão do MLP em duas luas

O neurônio único traça sua única reta; dezesseis unidades ReLU ocultas aprendem uma fronteira curva — sem atributos polinomiais fornecidos, a camada oculta inventou a representação.

Treino: retropropagação

O treino minimiza a entropia cruzada (ou o MSE) por gradiente descendente em mini-batch. A retropropagação calcula os gradientes: é a regra da cadeia, aplicada camada por camada da perda para trás, reaproveitando resultados intermediários:

  1. Passo para frente (forward pass) — calcular as ativações camada por camada, armazenando-as;
  2. Passo para trás (backward pass) — propagar \(\partial L / \partial \text{ativação}\) da saída para a entrada, obtendo cada \(\partial L / \partial W_\ell\) em uma única varredura;
  3. Atualizar — dar um passo em todos os pesos: \(W_\ell \mathrel{-}= \eta\, \partial L / \partial W_\ell\).

Nova complicação: a superfície de perda é não convexa — ao contrário da regressão logística, sem garantia de ótimo global. Na prática, bons mínimos locais são abundantes; métodos de momento e o Adam (taxas de aprendizado adaptativas, 2015) navegam de forma confiável.

Regularização, traduzida: penalidade L2 (chamada de weight decay), parada antecipada (versão da perda de validação, como no boosting) e um truque genuinamente novo — o dropout (silenciar neurônios aleatoriamente durante o treino), que treina um ensemble implícito de subredes.

from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

mlp = make_pipeline(StandardScaler(),               # treinado por gradiente ⇒ escalone!
    MLPClassifier(hidden_layer_sizes=(64, 32), activation='relu',
                  alpha=1e-4,                        # penalidade L2
                  early_stopping=True, max_iter=500, random_state=0))
mlp.fit(X_train, y_train)

(O MLP do scikit-learn serve para experimentos tabulares; deep learning sério usa PyTorch/JAX — veja ANN-DL.)

Por que profundidade, e quando

Redes profundas empilham muitas camadas ocultas, aprendendo hierarquias de atributos (bordas → texturas → partes → objetos, em visão). A profundidade compensa quando as entradas brutas são perceptuais — pixels, áudio, texto — onde bons atributos são desconhecidos e há dados em abundância. Foi aí que o deep learning esmagou o campo a partir de 2012 (AlexNet).

Para dados tabulares, a resposta atual honesta permanece: o gradient boosting geralmente vence, com menos ajuste e menos dados. Escolha pelo tipo de dado, não pelo hype:

Dado Primeira escolha
tabular / estruturado árvores com boosting (Parte V)
imagens, áudio, vídeo CNNs / vision transformers → ANN-DL
texto transformers (os embeddings que você já usou)
conjuntos minúsculos modelos lineares, k-NN

Quiz