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)
- Separe as listas de variáveis métricas e categóricas (sem o alvo e sem IDs).
- Monte o pré-processamento com
ColumnTransformer:StandardScalernas métricas eOneHotEncodernas categóricas (variáveis já dummizadas passam direto). - Separe treino e teste (30% para teste,
stratifyna classificação). - Crie o Pipeline e a grade, um dicionário por kernel, com o prefixo
svm__. - Ajuste o
GridSearchCVcom os dados sem pré-tratar (o pipeline cuida disso dentro de cada dobra). - Avalie treino e teste e compare (overfitting?). Não reajuste depois de olhar o teste.
- Interprete com
permutation_importanceno teste. - Preveja casos novos com
best_estimator_.predict(novos)usando os valores originais.
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.