Pular para o conteúdo
Atlas de Dados

Machine learning

Deep Learning e Redes Neurais

Do perceptron ao Transformer — tensores, MLP, ativações, funções de perda, gradiente descendente, otimizadores, regularização, CNN, autoencoder, embeddings e atenção, com Keras.

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 (SparseCategoricalCrossentropy com 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

  1. Definir tarefa e métrica; coletar o dado mais simples e barato.
  2. Baseline simples antes de qualquer rede.
  3. Limpar os dados; separar treino/validação/teste (estratificado, semente fixa).
  4. Escalonar com fit só no treino; codificar categorias (one-hot, label ou embedding).
  5. Montar o modelo (Sequential ou API funcional) e compilar com otimizador, perda e métricas.
  6. Treinar com EarlyStopping e ModelCheckpoint, acompanhando as curvas por época.
  7. Regularizar se houver overfitting.
  8. Avaliar no teste uma vez; com pouco dado, validação cruzada repetida.
  9. 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.