Visão geral
Uma rede neural é uma função composta ajustada por gradiente. A arquitetura (MLP, CNN, Transformer...) é só a forma de organizar essa função para o tipo de dado. Os fundamentos — neurônio, perda, gradiente, overfitting — não mudam de uma arquitetura para outra.
Duas regras práticas: 1. Comece pelo baseline mais barato (regra simples, regressão, árvore) e só suba a complexidade se houver ganho real na validação. 2. Modelo mais complexo só compensa com dados suficientes.
Definição clássica de aprendizado (Mitchell): um programa aprende se seu desempenho D numa tarefa T melhora com a experiência E.
Tensores
- Dados em redes são tensores: escalar (rank 0), vetor (rank 1), matriz (rank 2), imagem (rank 3: altura × largura × canais), lote de imagens (rank 4).
- Rank = número de eixos (
ndim); shape = tamanho de cada eixo.
O neurônio e o MLP
- Neurônio: \(\hat y = g\left(\sum_i x_i w_i + b\right)\) — soma ponderada mais viés, passada por uma ativação \(g\).
- Ativações: ReLU \(\max(0,z)\) (camadas ocultas), sigmoide \(1/(1+e^{-z})\) (saída binária), softmax \(e^{z_i}/\sum_j e^{z_j}\) (saída multiclasse), linear (regressão).
- Por que a ativação precisa ser não linear? Combinação de funções lineares é linear: sem ela, a rede inteira seria uma reta.
- MLP (perceptron multicamadas): camadas densas empilhadas. Parâmetros de uma camada densa:
entradas × neurônios + neurônios(ex.: 4 → 8 tem 40 parâmetros).
Como a rede aprende
- Função de perda mede o erro:
- regressão: MSE ou MAE;
- binária: entropia cruzada binária \(-[y\log\hat y + (1-y)\log(1-\hat y)]\);
- multiclasse: entropia cruzada categórica (
SparseCategoricalCrossentropycom rótulo inteiro + softmax). - Gradiente descendente: \(W \leftarrow W - \eta \nabla J(W)\), onde \(\eta\) é a taxa de aprendizado.
- Backpropagation: regra da cadeia para calcular o gradiente de cada peso, da saída para a entrada.
- Batch e época: o gradiente é estimado em lotes (
batch_size); uma época é uma passada por todos os dados. - Otimizadores: SGD, SGD com momentum, RMSprop, Adam (padrão seguro), AdamW (comum em Transformers).
- A razão taxa de aprendizado / tamanho do lote funciona como uma "temperatura" do treino: ao mudar um, ajuste o outro.
Overfitting e regularização
- Sinal: a perda de validação para de cair e começa a subir enquanto a de treino continua descendo.
- Early stopping com paciência e
restore_best_weights=True. - Dropout, regularização L1/L2 nos pesos, data augmentation (imagens), mais dados, modelo menor.
- Treino é estocástico: diferenças pequenas entre modelos podem ser só a semente aleatória.
Arquiteturas e quando usar
| Arquitetura | Dado típico | Ideia central |
|---|---|---|
| MLP | tabela, vetores | camadas densas; baseline |
| CNN | imagem, sinais 1D/2D | filtros (kernels) compartilhados e pooling |
| Autoencoder | qualquer | comprimir e reconstruir; anomalias, ruído, sem rótulo |
| LSTM / GRU | séries temporais, áudio | recorrência; custo linear, bom com pouco dado |
| Transformer | texto, LLMs, multimodal | atenção; custo quadrático, pede muito dado |
| GAN / difusão | geração de imagens | gerador × discriminador / remoção de ruído |
CNN
- Um filtro desliza pela imagem detectando padrões locais (bordas, texturas); camadas seguintes combinam padrões em formas mais complexas.
- Pesos compartilhados → muito menos parâmetros que um MLP e invariância à translação.
- Max pooling mantém o maior valor de cada janela, reduzindo a resolução sem parâmetros.
- Data augmentation (girar, deslocar, espelhar) precisa preservar o rótulo e pede mais paciência no early stopping.
Autoencoder
- Codificador comprime a entrada num vetor pequeno; decodificador reconstrói.
- Treinado só com casos normais, um erro de reconstrução alto sinaliza anomalia — útil quando os casos raros são poucos demais para treino supervisionado.
Texto, embeddings e Transformer
- One-hot de palavras gera vetores enormes e esparsos; embeddings são vetores densos aprendidos (parâmetros:
vocabulário × dimensão). - Atenção: \(\text{softmax}(QK^\top/\sqrt{d})\,V\) — cada token "consulta" (Q) os demais (K) e combina seus valores (V).
- Codificação posicional informa a ordem: \(PE(pos, 2i) = \sin(pos/10000^{2i/d})\).
- Um mini-GPT é uma pilha de blocos de atenção treinada para prever o próximo token.
Passo a passo de um projeto
- Definir tarefa e métrica; coletar o dado mais simples e barato.
- Baseline simples antes de qualquer rede.
- Limpar os dados; separar treino/validação/teste (estratificado, semente fixa).
- Escalonar com
fitsó no treino; codificar categorias (one-hot, label ou embedding). - Montar o modelo (Sequential ou API funcional) e compilar com otimizador, perda e métricas.
- Treinar com
EarlyStoppingeModelCheckpoint, acompanhando as curvas por época. - Regularizar se houver overfitting.
- Avaliar no teste uma vez; com pouco dado, validação cruzada repetida.
- Empacotar o pré-processamento dentro do modelo (
Rescaling,TextVectorization) para colocar em produção.
import keras
from keras import layers
modelo = keras.Sequential([
keras.Input(shape=(n_features,)),
layers.Dense(32, activation="relu"),
layers.Dropout(0.2),
layers.Dense(16, activation="relu"),
layers.Dense(1, activation="sigmoid"),
])
modelo.compile(optimizer="adam", loss="binary_crossentropy",
metrics=[keras.metrics.AUC(name="auc"), "recall"])
pare = keras.callbacks.EarlyStopping(monitor="val_auc", mode="max",
patience=5, restore_best_weights=True)
modelo.fit(X_tr, y_tr, validation_split=0.2, epochs=100,
batch_size=32, callbacks=[pare])
Avaliação
- Regressão: MAE, MSE, R². Classificação: acurácia só com classes balanceadas; senão precisão, recall, F1, AUROC e AUPR.
- Compare sempre com um baseline aleatório (10% em 10 classes) e com ML tradicional.
- Em dados tabulares pequenos e médios, árvores de gradiente costumam vencer redes.
- Redes profundas trocam explicabilidade por poder preditivo.