# Árvores de Decisão e Modelos Ensemble

> Árvore de decisão, overfitting, métricas, validação cruzada, ajuste de hiperparâmetros, bagging, boosting, Random Forest, XGBoost e importância de variáveis.

## Visão geral

Árvores e seus ensembles são os modelos mais usados em dados **tabulares**. O caminho recomendado é progressivo:

**árvore (baseline explicável) → Random Forest (robusto) → XGBoost (desempenho máximo, com mais ajuste).**

Não existe "o melhor modelo": existe o mais adequado ao problema, aos dados e ao custo do erro.

## Árvore de decisão

- Modelo supervisionado, não paramétrico e "caixa branca": raiz, nós internos (um teste em uma variável) e folhas (a previsão).
- **Classificação**: a folha prevê a classe mais frequente. **Regressão**: a folha prevê a **média** dos casos que caíram nela.
- **Critério de divisão**: escolhe a variável e o corte que mais reduzem a impureza.
  - Gini: $1 - \sum_k p_k^2$ (0 = nó puro).
  - Entropia: $-\sum_k p_k \log_2 p_k$.
  - Regressão: erro quadrático (padrão) ou absoluto.
- Não exige padronização. No scikit-learn, categóricas precisam virar números (one-hot).
- **Fraquezas**: overfitting (a árvore completa decora o treino), instabilidade (poucas linhas mudam a árvore), sensibilidade a desbalanceamento e **não extrapola** (nunca prevê fora da faixa vista no treino).

## Overfitting

- **Diagnóstico**: métrica de treino muito acima da de teste (ex.: 100% no treino e 80% no teste).
- O que importa é a **distância treino × teste** e o desempenho absoluto no teste.
- 100% de acerto também no teste deve levantar suspeita de **vazamento de dados** (o alvo, ou algo derivado dele, entre as variáveis).
- **Controles**: limitar `max_depth`, aumentar `min_samples_split` e `min_samples_leaf`, usar ensembles, regularização, subamostragem, early stopping e validação cruzada.

## Hiperparâmetros principais

| Modelo | Hiperparâmetro | Efeito |
|---|---|---|
| Árvore | `max_depth` | profundidade; principal freio de overfitting |
| Árvore | `min_samples_split` / `min_samples_leaf` | mínimo para dividir / por folha; maior = mais conservador |
| Árvore | `criterion` | gini, entropy; costuma mudar pouco |
| Árvore | `class_weight` | pesos por classe (desbalanceamento) |
| Random Forest | `n_estimators` | nº de árvores; mais estabiliza, raramente piora |
| Random Forest | `max_features` | variáveis sorteadas por divisão; descorrelaciona as árvores |
| XGBoost | `learning_rate` | tamanho do passo; menor = mais lento e estável |
| XGBoost | `max_depth`, `min_child_weight` | complexidade de cada árvore |
| XGBoost | `subsample`, `colsample_bytree` | fração de linhas / colunas por árvore |
| XGBoost | `reg_alpha` (L1), `reg_lambda` (L2), `gamma` | regularização |
| XGBoost | `early_stopping_rounds` | para quando a validação não melhora |

Em Random Forest, limitar a profundidade costuma **piorar**: as árvores individuais precisam de viés baixo; a média é que reduz a variância.

## Validação e seleção de modelo

- **Hold-out**: `train_test_split` 80/20 ou 70/30, com `stratify=y` em classificação e `random_state` fixo. O teste só serve para a avaliação **final**.
- **Treino / validação / teste**: a validação escolhe hiperparâmetros e decide quando parar.
- **K-Fold** (`cross_val_score`, `cross_validate`): K treinos, cada um validado num bloco diferente; reporte **média ± desvio** (o desvio mostra estabilidade). `StratifiedKFold` em classificação.
- **GridSearchCV** testa todas as combinações (cada uma com CV); **RandomizedSearchCV** sorteia `n_iter` combinações — mais barato. Estratégia: busca aleatória ampla, depois grade pequena ao redor do melhor.
- `scoring` define o que otimizar (ex.: `recall` quando a classe rara importa).
- **Faça a busca só no treino** (ou use CV aninhada). Buscar com todos os dados e avaliar no teste dá uma estimativa otimista.
- **Séries temporais**: separe por data (treino no passado, teste no futuro) e use `TimeSeriesSplit`; embaralhar mistura o futuro no treino.

## Métricas

### Classificação
- **Matriz de confusão**: VN, FP, FN, VP.
- Acurácia $= (VP+VN)/\text{total}$ — engana com classes desbalanceadas (prever só a classe majoritária já dá número alto).
- **Precisão** $= VP/(VP+FP)$; **recall** $= VP/(VP+FN)$; **F1** = média harmônica das duas (pune desequilíbrio: 90% e 10% dão F1 ≈ 18%).
- **ROC/AUC**: separação entre classes independente do corte; calcule com **probabilidades** (`predict_proba`), não com classes.
- Escolha pela regra de negócio: se deixar passar um positivo custa caro (FN), maximize recall; se alarme falso custa caro (FP), precisão.
- Baixar o limiar de 0,5 aumenta o recall à custa da precisão.

### Regressão
- **MAE**: média dos erros absolutos (mesma unidade, robusto).
- **MSE**: média dos erros ao quadrado (penaliza erros grandes).
- **RMSE**: raiz do MSE (mesma unidade).
- **R²**: fração da variância explicada (1 = perfeito).
- **MAPE**: erro percentual; quebra com valores reais próximos de zero.

Exemplo: reais 300, 500, 700, 900 e previstos 280, 550, 650, 1000 → erros 20, 50, 50, 100 → MAE = 55, MSE = 3850, RMSE ≈ 62.

## Ensembles

A ideia do **júri**: muitos modelos diversos, combinados, erram menos que um só.

| Família | Como combina | Efeito | Exemplo |
|---|---|---|---|
| Voting / averaging | voto (hard) ou média de probabilidades (soft) | reduz o erro individual | `VotingClassifier` |
| Bagging | modelos em paralelo, cada um num **bootstrap** | reduz **variância** | Random Forest |
| Boosting | modelos em **sequência**, cada um corrige o resíduo do anterior | reduz **viés** | AdaBoost, Gradient Boosting, XGBoost |
| Stacking | modelos base alimentam um metamodelo | aprende a combinar | `StackingClassifier` |

**Viés × variância**: árvore profunda = viés baixo, variância alta; árvore rasa = o inverso. Bagging ataca a variância; boosting, o viés.

### Random Forest, passo a passo
1. Gerar B amostras bootstrap (cada uma com ~63% das linhas únicas; ~37% ficam **fora da amostra**, OOB).
2. Em cada nó, sortear um subconjunto de variáveis e escolher a melhor divisão entre elas.
3. Crescer cada árvore profunda.
4. Classificação: voto ou média de probabilidades; regressão: média.
5. OOB como validação "gratuita"; `feature_importances_` para ranking.

### XGBoost, passo a passo
1. Começar com uma previsão simples.
2. Calcular o resíduo (gradiente da perda).
3. Ajustar uma árvore rasa a esse resíduo.
4. Somar a nova árvore multiplicada pelo `learning_rate`.
5. Repetir até `n_estimators` ou até o early stopping.
6. Objetivo = erro nos dados + penalidade de complexidade (L1/L2 nos pesos das folhas e `gamma` por divisão).

Aceita `NaN` nativamente e o tipo `category` do pandas; é muito sensível a hiperparâmetros.

## Importância de variáveis

- `feature_importances_` (redução de impureza/ganho): rápida, mas **favorece variáveis contínuas e de alta cardinalidade**, divide o crédito entre variáveis correlacionadas e **não mostra o sentido** do efeito.
- **Permutation importance**: embaralha uma variável no teste e mede a queda da métrica.
- **SHAP (valores de Shapley)**: contribuição de cada variável em cada previsão, com sinal.

## Comparação rápida

| | Árvore | Random Forest | XGBoost |
|---|---|---|---|
| Ideia | modelo único | bagging | boosting |
| Overfitting | alto | menor | controlável com regularização |
| Sensibilidade a hiperparâmetros | média | baixa | alta |
| Pré-processamento | mínimo | mínimo | mínimo |
| Interpretabilidade | muito alta | média | média/baixa (use SHAP) |

## Perguntas de revisão

1. **Como uma árvore escolhe a divisão?** Pela variável e corte que mais reduzem a impureza (Gini/entropia) ou o erro quadrático.
2. **O que a folha prevê?** A classe mais frequente na classificação e a média do alvo na regressão.
3. **Como diagnosticar overfitting?** Métrica de treino muito acima da de teste.
4. **O que sugere 100% de acerto no teste?** Possível vazamento de dados.
5. **Quais hiperparâmetros controlam o overfitting numa árvore?** `max_depth`, `min_samples_split` e `min_samples_leaf`.
6. **Por que usar `stratify=y`?** Para manter a proporção das classes no treino e no teste.
7. **Para que serve a validação cruzada?** Estimar desempenho e estabilidade (média ± desvio) sem gastar o teste.
8. **Grid search ou random search?** Grid testa todas as combinações; random sorteia algumas e é mais barato.
9. **Por que a acurácia engana?** Com classe rara, prever só a majoritária já dá acurácia alta.
10. **Precisão ou recall?** Depende do custo: FN caro → recall; FP caro → precisão.
11. **Por que o F1 usa média harmônica?** Porque penaliza o desequilíbrio entre precisão e recall.
12. **Qual a diferença entre MAE e RMSE?** Os dois estão na unidade do alvo; o RMSE penaliza mais os erros grandes.
13. **Bagging ou boosting?** Bagging: paralelo, reduz variância; boosting: sequencial, corrige resíduos, reduz viés.
14. **O que é OOB?** As linhas que ficaram fora do bootstrap de uma árvore (~37%), usadas como validação.
15. **O que o Random Forest faz além do bagging?** Sorteia um subconjunto de variáveis em cada divisão, descorrelacionando as árvores.
16. **Qual o papel do learning rate e do early stopping no XGBoost?** O learning rate é o tamanho do passo; o early stopping para quando a validação deixa de melhorar.
17. **O que L1 e L2 fazem no XGBoost?** Penalizam os pesos das folhas; L1 pode zerá-los, L2 os suaviza.
18. **Por que `feature_importances_` não basta?** É enviesada e não mostra o sentido do efeito; use permutation importance e SHAP.
19. **Como validar modelos com séries temporais?** Separando por data e usando `TimeSeriesSplit`, nunca embaralhando.
20. **As árvores extrapolam?** Não; nunca preveem fora da faixa de valores vista no treino.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/arvores-ensembles
