# Support Vector Machines (SVM)

> Classificação (SVC) e regressão (SVR) por margem máxima — vetores de suporte, parâmetro C, kernels linear, polinomial e RBF, pipeline com pré-processamento, grid search e permutation importance.

## Visão geral

O SVM é um modelo supervisionado que serve para **classificação** (`SVC`, $Y$ categórica) e **regressão** (`SVR`, $Y$ métrica). A ideia é encontrar a fronteira que separa as classes com a **maior margem possível**, tolerando algumas violações. Com **kernels**, essa fronteira pode ser não linear sem que você precise criar interações à mão.

O roteiro prático é sempre o mesmo: **pré-tratar (padronizar e dummizar) → separar treino e teste → Pipeline + GridSearchCV → avaliar no teste → interpretar → prever casos novos.**

## Conceitos centrais

- **Fronteira de decisão (hiperplano)**: com 2 variáveis é uma reta; com muitas, um hiperplano. A previsão depende do lado em que a observação cai.
- **Margem**: distância entre a fronteira e as observações mais próximas de cada classe. Margem larga = menos sensibilidade a pequenas variações de $X$ e melhor generalização.
- **Vetores de suporte**: as observações sobre a margem ou violando-a. São elas que fixam a fronteira; as demais não influenciam.
- **Hard margin**: nenhuma violação (raro na prática). **Soft margin**: violações permitidas e penalizadas — é o que se usa.
- **C**: penalização das violações.
  - C alto → margens justas, modelo complexo, risco de **overfitting**;
  - C baixo → margens largas, modelo tolerante, risco de **underfitting**.

## Kernels

O kernel é uma função de similaridade entre pares de observações num espaço transformado. A separação linear nesse espaço aparece como uma fronteira curva no espaço original — e isso sem calcular as coordenadas transformadas (*kernel trick*).

| Kernel | Fórmula | Hiperparâmetros |
|---|---|---|
| Linear | $K(a,b) = a^\top b$ | C |
| Polinomial | $K(a,b) = (\gamma\, a^\top b + r)^d$ | C, `degree` (d), `coef0` (r), `gamma` |
| RBF (gaussiano) | $K(a,b) = \exp(-\gamma \lVert a-b \rVert^2)$ | C, `gamma` |

- **gamma** define o alcance da influência de cada observação: gamma alto → influência localizada e fronteira complexa (risco de overfitting).
- Não há regra intuitiva entre polinomial e RBF: teste os dois.

## SVR (regressão)

O SVR ajusta um "tubo" de largura **ε (epsilon)** ao redor da função. Erros dentro do tubo não são penalizados; só os de fora entram, ponderados por C. O epsilon deve respeitar a escala de $Y$ — grande demais causa underfitting.

## Multiclasse

O `SVC` usa **one-vs-one**: treina um SVM para cada par de classes e decide por votação. O código é idêntico ao binário; a matriz de confusão vira $n \times n$ e as métricas usam média macro.

## Passo a passo (receita)

1. Separe as listas de variáveis métricas e categóricas (sem o alvo e sem IDs).
2. Monte o pré-processamento com `ColumnTransformer`: `StandardScaler` nas métricas e `OneHotEncoder` nas categóricas (variáveis já dummizadas passam direto).
3. Separe treino e teste (30% para teste, `stratify` na classificação).
4. Crie o Pipeline e a grade, um dicionário por kernel, com o prefixo `svm__`.
5. Ajuste o `GridSearchCV` com os dados **sem** pré-tratar (o pipeline cuida disso dentro de cada dobra).
6. Avalie treino e teste e compare (overfitting?). Não reajuste depois de olhar o teste.
7. Interprete com `permutation_importance` no teste.
8. Preveja casos novos com `best_estimator_.predict(novos)` usando os valores originais.

```python
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split, GridSearchCV

pre = ColumnTransformer([
    ("num", StandardScaler(), metricas),
    ("cat", OneHotEncoder(drop="if_binary", handle_unknown="ignore",
                          sparse_output=False), categoricas),
])
X = dados.drop(columns=["alvo", "id"]); y = dados["alvo"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3,
                                          stratify=y, random_state=42)
pipe = Pipeline([("pre", pre), ("svm", SVC())])
grade = [
    {"svm__kernel": ["linear"], "svm__C": [0.1, 1, 10]},
    {"svm__kernel": ["rbf"], "svm__C": [0.1, 1, 10], "svm__gamma": ["scale", 0.1, 1]},
    {"svm__kernel": ["poly"], "svm__C": [0.1, 1], "svm__degree": [2, 3]},
]
busca = GridSearchCV(pipe, grade, scoring="f1", cv=5, n_jobs=-1).fit(X_tr, y_tr)
print(busca.best_params_, busca.best_score_)
```

## Por que padronizar

O SVM se baseia em **distâncias**: uma variável medida em milhares domina outra medida em unidades. Por isso `StandardScaler` (escore z) nas métricas — ajustado **só no treino** (`fit`) e aplicado ao teste e a casos novos (`transform`). O Pipeline garante isso automaticamente e evita vazamento.

## Quando usar

- Bases pequenas e médias; com bases muito grandes o treino fica lento (sobretudo com kernel não linear e C alto).
- Quando se quer fronteira não linear sem criar interações à mão.
- Não substitui árvores e ensembles: teste todos e compare no mesmo conjunto de teste.
- Limitações: não dá probabilidade nativa nem coeficientes interpretáveis (exceto no kernel linear) — daí o uso de permutation importance.

## Avaliação

- **Classificação**: matriz de confusão, acurácia $(VP+VN)/\text{total}$, sensibilidade/recall $VP/(VP+FN)$, especificidade $VN/(VN+FP)$, precisão $VP/(VP+FP)$, F1.
- **Regressão**: MSE, RMSE, MAE (menor é melhor) e R² (mais perto de 1 é melhor); no grid, `scoring="neg_mean_squared_error"`.
- **Desbalanceamento** (80/20, 90/10): acurácia engana; use recall, precisão e F1; SMOTE ou undersampling, com cautela e validando no teste.

## Perguntas de revisão

1. **Para que serve o SVM?** Classificação (SVC) e regressão (SVR), com fronteiras lineares ou não lineares.
2. **O que é um vetor de suporte?** Uma observação sobre a margem ou violando-a, que determina a posição da fronteira.
3. **Por que maximizar a margem?** Uma fronteira afastada das observações é menos sensível a pequenas variações e generaliza melhor.
4. **Qual a diferença entre hard margin e soft margin?** Hard exige separação perfeita; soft permite violações penalizadas por C.
5. **O que faz o parâmetro C?** Penaliza violações: C alto dá margem justa e risco de overfitting; C baixo dá margem larga e risco de underfitting.
6. **Por que padronizar as variáveis no SVM?** Porque ele se baseia em distâncias e é sensível à escala.
7. **Como tratar variáveis categóricas preditoras?** Com `OneHotEncoder`; `drop="if_binary"` evita dummy redundante nas binárias.
8. **O que é o kernel?** Uma função de similaridade num espaço transformado que permite fronteiras não lineares sem calcular as coordenadas (kernel trick).
9. **Quais os hiperparâmetros de cada kernel?** Linear: C. Polinomial: C, degree, coef0, gamma. RBF: C, gamma.
10. **O que faz o gamma?** Define o alcance da influência de cada observação; alto produz fronteiras complexas.
11. **Como escolher os hiperparâmetros?** Com grid search e validação cruzada k-fold no conjunto de treino.
12. **Por que usar Pipeline no grid search?** Para aplicar o pré-processamento dentro de cada dobra e evitar vazamento de dados.
13. **Como evitar vazamento ao padronizar?** `fit` só no treino; `transform` no teste e nos casos novos.
14. **Por que olhar o teste só no fim?** Para medir a generalização de forma independente; ajustar depois de vê-lo é "treinar disfarçado".
15. **Quando privilegiar recall ou precisão?** Recall quando perder positivos custa caro; precisão quando falso positivo custa caro.
16. **Como o SVC trata mais de duas classes?** Por one-vs-one: um modelo por par de classes e votação.
17. **O que muda no SVR?** Erros dentro do tubo de largura epsilon não são penalizados; só os de fora, via C.
18. **O que é permutation importance?** Embaralhar uma variável por vez no teste e medir a piora da métrica.
19. **Quando o SVM sofre?** Em bases muito grandes, especialmente com kernel não linear e C alto.
20. **Como lidar com classes desbalanceadas?** Usando recall, precisão e F1, e técnicas como SMOTE ou undersampling validadas no teste.

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