# 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.

```python
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.

## Perguntas de revisão

1. **O que é aprendizado, segundo Mitchell?** Quando o desempenho D numa tarefa T melhora com a experiência E.
2. **Por que a ativação precisa ser não linear?** Porque composições de funções lineares continuam lineares.
3. **Qual a fórmula de um neurônio?** $\hat y = g(\sum x_i w_i + b)$.
4. **Quantos parâmetros tem uma camada densa de 4 entradas e 8 neurônios?** 4 × 8 + 8 = 40.
5. **Qual a diferença entre rank e shape?** Rank é o número de eixos; shape é o tamanho de cada eixo.
6. **Como o gradiente descendente atualiza os pesos?** $W \leftarrow W - \eta\nabla J(W)$.
7. **O que faz o backpropagation?** Calcula o gradiente de cada peso pela regra da cadeia, da saída para a entrada.
8. **Qual otimizador usar se não houver tempo de testar?** Adam (AdamW em Transformers).
9. **Quando parar o treino?** Quando a perda de validação deixa de melhorar, com paciência e restaurando os melhores pesos.
10. **Qual perda usar em multiclasse com rótulos inteiros?** `SparseCategoricalCrossentropy` com saída softmax.
11. **Por que a CNN é melhor que o MLP em imagens?** Usa padrões locais e hierárquicos, compartilha pesos, é invariante à translação e tem menos parâmetros.
12. **O que faz o max pooling?** Mantém o maior valor de cada janela, reduzindo a resolução sem parâmetros.
13. **O que o data augmentation exige?** Que as transformações preservem o rótulo.
14. **Para que serve um autoencoder na detecção de anomalias?** Treinado com casos normais, erro de reconstrução alto indica anomalia.
15. **O que é um embedding?** Um vetor denso aprendido que representa uma palavra ou categoria.
16. **Qual a fórmula da atenção?** $\text{softmax}(QK^\top/\sqrt d)\,V$.
17. **Por que o Transformer precisa de codificação posicional?** Porque a atenção, sozinha, não sabe a ordem dos tokens.
18. **LSTM ou Transformer para série temporal com pouco dado?** LSTM costuma ser competitiva; Transformer pede muito dado.
19. **Redes neurais vencem sempre em dados tabulares?** Não; em tabelas pequenas e médias, árvores de gradiente costumam vencer.
20. **Por que empacotar o pré-processamento dentro do modelo?** Para que a produção receba o dado bruto e aplique exatamente o mesmo tratamento do treino.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/deep-learning
