Pular para o conteúdo
Atlas de Dados

Machine learning

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