SVMs

Visão geral: que problema as SVMs resolvem?

Máquinas de Vetores de Suporte (SVMs, Support Vector Machines) são uma família de modelos de aprendizado supervisionado (supervised learning) mais comumente usados para classificação (classification). Sua ideia definidora é geométrica:

Em vez de apenas encontrar uma fronteira de decisão que separe as classes, as SVMs tentam encontrar a fronteira com a maior margem (largest margin) — o maior “amortecedor de segurança” entre as classes.

Esse princípio de “margem máxima” frequentemente produz forte capacidade de generalização, especialmente em espaços de características de alta dimensão (high-dimensional feature spaces) (por exemplo, características de texto do tipo bag-of-words) e quando você deseja um classificador robusto e bem regularizado.

SVMs podem ser:

• Lineares (linear) (um hiperplano reto no espaço de entrada)
• Com kernel (kernelized) (um separador linear em um espaço de características implícito e de maior dimensão, permitindo fronteiras de decisão não lineares)

As SVMs ficam conceitualmente entre:

• Modelos lineares como Regressão Linear/Logística (baselines simples e interpretáveis)
• Modelos probabilísticos baseados em kernel como Processos Gaussianos (também construídos em torno de kernels, mas com estimativas de incerteza)
• Conjuntos de árvores não lineares como Árvores de Decisão & Conjuntos (frequentemente dominantes em dados tabulares hoje)

Intuição geométrica: hiperplanos, margens e vetores de suporte

Hiperplanos como fronteiras de decisão

Na classificação binária com rótulos (y \in {-1, +1}), um classificador linear prediz usando:

[ f(\mathbf{x}) = \mathbf{w}^\top \mathbf{x} + b ]

e classifica pelo sinal: (\text{sign}(f(\mathbf{x}))).

O conjunto de pontos onde (f(\mathbf{x}) = 0) é um hiperplano (hyperplane) (uma linha em 2D, um plano em 3D e assim por diante).

Margem: “quão separadas com confiança” estão as classes?

Para um hiperplano ((\mathbf{w}, b)), a distância (geométrica) de um ponto (\mathbf{x}) ao hiperplano é:

[ \frac{|\mathbf{w}^\top \mathbf{x} + b|}{|\mathbf{w}|} ]

As SVMs escolhem (\mathbf{w}) e (b) para maximizar a distância mínima dos pontos de treino à fronteira de decisão. Intuitivamente:

• Uma fronteira com margem pequena pode ser sensível a ruído e sofrer overfitting.
• Uma fronteira com margem grande é mais estável: pequenas perturbações nas entradas têm menor probabilidade de mudar as previsões.

Vetores de suporte

Nem todos os pontos de treino importam igualmente. A fronteira de decisão é determinada por um subconjunto de pontos mais próximos dela: os vetores de suporte (support vectors).

Um modelo mental útil:

• Se você remove muitos pontos “fáceis”, longe da fronteira, a solução da SVM quase não muda.
• Se você move ou remove vetores de suporte, a fronteira pode mudar significativamente.

Essa é uma das razões pelas quais as SVMs podem generalizar bem: elas focam nos exemplos mais difíceis e mais ambíguos.

SVM de margem rígida: caso separável

Se os dados forem perfeitamente separáveis de forma linear, as SVMs resolvem:

[ \min_{\mathbf{w}, b} \frac{1}{2}|\mathbf{w}|^2 \quad\text{subject to}\quad y_i(\mathbf{w}^\top \mathbf{x}_i + b) \ge 1 ;; \forall i ]

Ideias-chave:

• As restrições impõem classificação correta com margem.
• Minimizar (|\mathbf{w}|^2) maximiza a margem (a largura da margem é (2/|\mathbf{w}|)).

Em dados do mundo real, separabilidade perfeita é rara (ruído, erros de rótulo, classes sobrepostas). Isso motiva margens suaves (soft margins).

SVM de margem suave: robustez via folga e perda hinge

Variáveis de folga e o papel de \(C\)

SVMs de margem suave permitem violações das restrições de margem usando variáveis de folga (\xi_i \ge 0):

[ \min_{\mathbf{w}, b, \xi} \frac{1}{2}|\mathbf{w}|^2 + C\sum_i \xi_i \quad\text{subject to}\quad y_i(\mathbf{w}^\top \mathbf{x}_i + b) \ge 1 - \xi_i ]

O hiperparâmetro (C) controla o trade-off:

• (C) grande: penaliza violações fortemente → ajusta os dados de treino de forma mais agressiva (maior risco de variância)
• (C) pequeno: permite mais violações → regularização mais forte (maior viés)

Na prática, ajustar (C) é central para bom desempenho de SVM.

Perda hinge: a função de perda da SVM

SVMs de margem suave correspondem a minimizar perda hinge (hinge loss) mais regularização:

[ \min_{\mathbf{w}, b} \frac{1}{2}|\mathbf{w}|^2 + C \sum_i \max(0, 1 - y_i f(\mathbf{x}_i)) ]

A perda hinge incentiva:

• Classificação correta com margem (se (y f(\mathbf{x}) \ge 1), a perda é 0)
• Penalidade linear por estar dentro da margem ou classificado incorretamente

Comparada à log-loss da regressão logística, a perda hinge não tenta modelar probabilidades; ela foca em uma regra de decisão baseada em margem.

Formulação dual: por que kernels funcionam

Uma grande razão para as SVMs terem se tornado influentes é sua formulação dual (dual formulation), em que a solução depende de produtos internos entre pontos de treino.

A função de decisão da SVM linear pode ser escrita como:

[ f(\mathbf{x}) = \sum_{i \in SV} \alpha_i y_i \langle \mathbf{x}_i, \mathbf{x}\rangle + b ]

Apenas vetores de suporte têm (\alpha_i > 0). Essa forma é a porta de entrada para kernels.

Kernels e o truque do kernel

Motivação: fronteiras não lineares sem engenharia explícita de características

Suponha que as classes não sejam separáveis linearmente no espaço de entrada original (por exemplo, círculos concêntricos). Uma abordagem é mapear as entradas para um espaço de características de maior dimensão:

[ \phi(\mathbf{x}) ]

e aprender um separador linear ali. Mas calcular (\phi(\mathbf{x})) explicitamente pode ser caro ou ter dimensão infinita.

Truque do kernel

Se o algoritmo só precisa de produtos internos (\langle \phi(\mathbf{x}), \phi(\mathbf{z})\rangle), podemos substituí-los por uma função kernel (kernel function):

[ K(\mathbf{x}, \mathbf{z}) = \langle \phi(\mathbf{x}), \phi(\mathbf{z})\rangle ]

Isso produz fronteiras de decisão não lineares no espaço de entrada enquanto treina um modelo linear no espaço de características implícito.

Função de decisão da SVM com kernel:

[ f(\mathbf{x}) = \sum_{i \in SV} \alpha_i y_i K(\mathbf{x}_i, \mathbf{x}) + b ]

Kernels comuns

1. Kernel linear [ K(\mathbf{x}, \mathbf{z}) = \mathbf{x}^\top \mathbf{z} ] Melhor quando as características já são ricas/alta dimensão (texto TF-IDF, características esparsas). Muitas vezes é competitivo e escalável.

2. Kernel RBF (Gaussiano) [ K(\mathbf{x}, \mathbf{z}) = \exp(-\gamma |\mathbf{x}-\mathbf{z}|^2) ] Muito flexível; pode modelar fronteiras complexas. Hiperparâmetros:

   • (C): regularização
   • (\gamma): localidade/suavidade ((\gamma) grande → muito local, pode sofrer overfitting)

3. Kernel polinomial [ K(\mathbf{x}, \mathbf{z}) = (\mathbf{x}^\top \mathbf{z} + c)^d ] Captura interações até o grau (d). Pode funcionar bem, mas pode ser sensível à escala e à escolha do grau.

Nota prática: SVMs são sensíveis ao escalonamento de características (feature scaling), especialmente com kernels RBF/polinomial. Padronização geralmente é necessária.

Fluxo de trabalho prático: treinando SVMs bem

1) Pré-processar características (quase sempre)

• Padronize características numéricas densas (média zero, variância unitária).
• Para características de texto esparsas (por exemplo, TF-IDF), escalonamento é menos padrão, mas você ainda tipicamente normaliza.

Se seus dados forem de alta dimensão, considere Redução de Dimensionalidade para visualização, ou como etapa de pré-processamento em alguns pipelines (embora SVMs lineares frequentemente lidem bem com características esparsas de alta dimensão).

2) Escolher SVM linear vs SVM com kernel

Regra geral:

• SVM linear: características de altíssima dimensão, grandes conjuntos de dados, classificação de texto.
• SVM RBF: tamanhos de conjunto de dados moderados, espera-se fronteira não linear, e é aceitável fazer ajuste cuidadoso.

Em grandes conjuntos de dados com padrões não lineares, alternativas modernas (por exemplo, gradient boosting, redes neurais) podem escalar melhor.

3) Ajustar hiperparâmetros via validação cruzada

Ajuste típico:

• Linear: (C)
• RBF: (C) e (\gamma)

Use divisões estratificadas, especialmente sob desbalanceamento de classes (e considere class_weight="balanced").

(Veja também: k-NN, Naive Bayes para baselines; e Árvores de Decisão & Conjuntos para concorrentes fortes em dados tabulares.)

4) Avaliar adequadamente

Use métricas alinhadas com a tarefa:

• Acurácia para classes balanceadas
• Precisão/recall/F1 para classes desbalanceadas
• ROC-AUC / PR-AUC dependendo da prevalência da classe

Exemplo prático: SVM linear para classificação de texto (scikit-learn)

SVMs lineares são uma escolha clássica para texto porque TF-IDF cria vetores de características esparsos gigantes, nos quais separadores lineares frequentemente funcionam surpreendentemente bem.

from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.model_selection import GridSearchCV

pipe = Pipeline([
    ("tfidf", TfidfVectorizer(ngram_range=(1, 2), min_df=2)),
    ("svm", LinearSVC())
])

param_grid = {
    "svm__C": [0.1, 1, 10]
}

search = GridSearchCV(pipe, param_grid=param_grid, cv=5, n_jobs=-1)
search.fit(train_texts, train_labels)

print("Best params:", search.best_params_)
print("CV score:", search.best_score_)

Notas:

• LinearSVC usa solucionadores eficientes para SVMs lineares e escala bem.
• Ele retorna escores de decisão, não probabilidades calibradas (mais sobre isso abaixo).

Exemplo prático: classificação não linear com SVM RBF

SVMs RBF são poderosas quando as fronteiras são curvas ou complexas.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("svm", SVC(kernel="rbf"))
])

param_grid = {
    "svm__C": [0.1, 1, 10, 100],
    "svm__gamma": ["scale", 0.1, 0.01, 0.001]
}

search = GridSearchCV(pipe, param_grid=param_grid, cv=5, n_jobs=-1)
search.fit(X_train, y_train)

print(search.best_params_)
print("Test accuracy:", search.score(X_test, y_test))

Interpretação de (\gamma):

• (\gamma) pequeno: influência mais suave e ampla de cada ponto → fronteira mais simples
• (\gamma) grande: cada ponto influencia uma região minúscula → pode produzir fronteiras muito “onduladas”

Classificação multiclasse

SVMs são nativamente binárias. Estratégias multiclasse comuns:

• Um-contra-resto (OvR, One-vs-rest): treina (K) classificadores binários, cada classe vs todas as outras
• Um-contra-um (OvO, One-vs-one): treina (K(K-1)/2) classificadores para cada par de classes

No scikit-learn:

• LinearSVC usa OvR por padrão
• SVC frequentemente usa OvO internamente

A escolha afeta velocidade e, às vezes, acurácia; OvO pode ser forte, mas pode ser mais pesado com muitas classes.

Probabilidades e calibração

As saídas padrão de SVM são escores de decisão (decision scores) (medidas parecidas com distância), não probabilidades.

Se você precisa de probabilidades calibradas (por exemplo, para ranqueamento, definição de limiar, ou análise de decisão a jusante):

• Use métodos de calibração como escalonamento de Platt ou regressão isotônica.
• No scikit-learn, SVC(probability=True) treina uma etapa interna de calibração (aumenta o custo).
• Alternativamente, use CalibratedClassifierCV em torno de uma SVM linear.

Esse tema se conecta naturalmente a modelos probabilísticos; veja Modelos Bayesianos e Processos Gaussianos para abordagens que produzem incerteza de forma mais direta.

Variantes de SVM além de classificação

Regressão por Vetores de Suporte (SVR, Support Vector Regression)

SVR adapta a ideia de margem para regressão usando uma perda (\epsilon)-insensível ((\epsilon)-insensitive loss): erros dentro de um tubo de raio (\epsilon) não incorrem perda, e pontos fora do tubo agem como “vetores de suporte”.

SVR pode ser eficaz em conjuntos de dados de tamanho médio com estrutura não linear (especialmente com kernels RBF), mas pode ser computacionalmente pesada em grande escala.

SVM de Uma Classe para detecção de anomalias

SVM de Uma Classe (One-Class SVM) aprende uma fronteira em torno de dados “normais” e sinaliza pontos fora como anomalias. É um método clássico em Detecção de Anomalias, especialmente quando você tem apenas exemplos normais.

Quando SVMs brilham (e quando não)

Pontos fortes

• Forte generalização via princípio de margem máxima
• Eficazes em alta dimensão, especialmente SVMs lineares em características esparsas (texto, algumas áreas de genômica)
• Truque do kernel permite fronteiras não lineares flexíveis com teoria sólida
• A decisão depende de um subconjunto de pontos (vetores de suporte), o que pode ser conceitualmente elegante

Limitações

• SVMs com kernel escalam mal com o tamanho do conjunto de dados (tempo/memória podem crescer aproximadamente de forma quadrática com o número de amostras)
• Sensíveis ao escalonamento de características e a hiperparâmetros (especialmente (C), (\gamma))
• Menos diretas de interpretar do que modelos lineares simples (embora os pesos de uma SVM linear sejam interpretáveis de modo semelhante a classificadores lineares)
• Não são inerentemente probabilísticas; estimativas de probabilidade exigem calibração
• Em muitos problemas tabulares modernos, Árvores de Decisão & Conjuntos frequentemente superam com menos escalonamento/ajuste

Conexões com outras ideias centrais de AM

• Regularização e margens: SVMs tornam explícito o trade-off viés–variância por meio de (C) e do objetivo de margem, em paralelo com a regularização em Regressão Linear/Logística.
• Kernels como medidas de similaridade: kernels codificam noções de similaridade, intimamente relacionadas a métodos baseados em distância como k-NN, Naive Bayes (k-NN usa distâncias explícitas; SVM usa similaridades em um arcabouço de otimização).
• Aprendizado de métricas e de representações: enquanto SVMs clássicas dependem de kernels fixos, abordagens modernas frequentemente aprendem embeddings; veja Aprendizado de Métricas para espaços de similaridade aprendidos.
• Ecossistema de métodos de kernel: SVMs são um método emblemático de kernel; Processos Gaussianos também usam kernels, mas como priors sobre funções com estimativas de incerteza.

Resumo

SVMs são melhor compreendidas geometricamente:

• Elas aprendem uma fronteira de decisão que maximiza a margem.
• Apenas um subconjunto de pontos (vetores de suporte) determina o classificador.
• Com o truque do kernel, SVMs podem representar fronteiras não lineares substituindo produtos internos por similaridades de kernel.

Na prática:

• Use SVMs lineares para dados em larga escala e de alta dimensão (especialmente texto).
• Use SVMs RBF para problemas não lineares quando o tamanho do conjunto de dados for administrável e você puder ajustar (C) e (\gamma).
• Escalone as características, valide com cuidado e calibre as saídas se probabilidades forem necessárias.

---