Redes neurais: do neurônio ao MLP

As redes neurais estão por trás de reconhecimento de imagem, tradução automática e dos assistentes de IA. A ideia é bem mais simples do que a fama sugere: uma rede é um monte de contas pequenas encadeadas, e o “aprendizado” é ajustar os números dessas contas.

O neurônio artificial

Um neurônio recebe várias entradas, multiplica cada uma por um peso, soma tudo com um viés (bias) e passa o resultado por uma função de ativação, que decide a “força” da saída.

import numpy as np

def neuronio(entradas, pesos, vies):
    soma = np.dot(entradas, pesos) + vies      # soma ponderada
    return 1 / (1 + np.exp(-soma))              # ativação sigmoide

saida = neuronio(np.array([0.5, 0.8]), np.array([0.4, -0.2]), 0.1)
print(saida)   # cerca de 0.53

A sigmoide “espreme” qualquer número para o intervalo entre 0 e 1. Pesos positivos fazem a entrada empurrar a saída para cima, e pesos negativos para baixo. São os pesos e o viés que o treino ajusta.

Do neurônio à rede: camadas

Um neurônio sozinho só aprende relações simples. Empilhando neurônios em camadas, a rede aprende padrões complexos:

• Camada de entrada: recebe as features.
• Camadas ocultas: neurônios que combinam as entradas em padrões intermediários.
• Camada de saída: entrega a previsão.

Uma rede assim, com camadas totalmente conectadas, é um MLP (Multi-Layer Perceptron, ou perceptron multicamadas).

Como a rede aprende

O treino repete três passos, milhares de vezes:

1. A rede faz uma previsão com os pesos atuais.
2. Mede o erro entre a previsão e a resposta certa.
3. Ajusta cada peso um pouquinho na direção que reduz o erro. Esse método é o gradiente descendente, e o cálculo de quanto ajustar cada peso se chama backpropagation.

Cada passada completa pelos dados é uma época. O tamanho de cada ajuste é a taxa de aprendizado (learning rate): pequena demais e o treino demora, grande demais e ele oscila sem convergir.

Treinando um MLP com scikit-learn

O scikit-learn tem um MLP pronto, que funciona bem para dados em tabela:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

modelo = make_pipeline(
    StandardScaler(),
    MLPClassifier(hidden_layer_sizes=(16, 8), max_iter=1000, random_state=42),
)
modelo.fit(X_treino, y_treino)

print(modelo.score(X_teste, y_teste))

hidden_layer_sizes=(16, 8) cria duas camadas ocultas, a primeira com 16 neurônios e a segunda com 8. max_iter limita o número de épocas.

Exercícios