O dataset

Support Vector Machine (SVM)

Support Vector Machine

O Support Vector Machine (SVM) é um algoritmo supervisionado amplamente utilizado para classificação (e também disponível em variantes de regressão, como SVR). O objetivo do SVM é encontrar a melhor fronteira (linha, plano ou hiperplano) que separa classes no espaço de features.

Conceito básico

Em problemas de classificação binária (por exemplo, "sobreviveu" vs "não sobreviveu"), o SVM busca o hiperplano que maximize a margem — ou seja, a distância entre o hiperplano e os pontos mais próximos de cada classe (os vetores de suporte).

Quanto maior a margem, mais robusta tende a ser a separação entre classes.

Intuição visual

Imagine duas nuvens de pontos. Embora várias linhas possam separar as nuvens, o SVM seleciona a que:

maximiza a margem;
está o mais distante possível dos pontos das duas classes;
é definida por poucos pontos críticos (os vetores de suporte).

Kernel Trick

Quando os dados não são linearmente separáveis no espaço original, o SVM pode aplicar uma transformação (kernel) que projeta os dados para um espaço de maior dimensão onde a separação é possível.

Principais kernels

Linear: separação por uma linha/hiperplano;
Polinomial: permite curvas polinomiais (grau 2, 3, ...);
RBF (Radial Basis Function): produz fronteiras complexas; é o mais usado na prática;
Sigmoid: comportamento similar a redes neurais simples.

Script e resultado

outputcode

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.inspection import DecisionBoundaryDisplay
from io import StringIO
from sklearn.preprocessing import StandardScaler

# ============================
# Carregar dataset
# ============================
df = pd.read_csv("Titanic-Dataset.csv")

# Selecionar apenas as colunas necessárias
df = df[['Survived', 'Age', 'Fare', 'Sex']]

# Converter variável categórica
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1})

# Remover valores faltantes
df = df.dropna()

# ============================
# Seleção de Features para plot 2D
# ============================
# Usaremos apenas Age e Fare para plotar a fronteira
X = df[['Age', 'Fare']].values
y = df['Survived'].values

# Padronizar
scaler = StandardScaler()
X = scaler.fit_transform(X)

# ============================
# Plot
# ============================
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(10, 6))

kernels = {
    'linear': ax1,
    'sigmoid': ax2,
    'poly': ax3,
    'rbf': ax4
}

for k, ax in kernels.items():
    svm = SVC(kernel=k, C=1)
    svm.fit(X, y)

    DecisionBoundaryDisplay.from_estimator(
        svm,
        X,
        response_method="predict",
        alpha=0.8,
        cmap="Pastel1",
        ax=ax
    )

    ax.scatter(
        X[:, 0], X[:, 1],
        c=y,
        s=20,
        edgecolors="k"
    )

    ax.set_title(f"SVM Kernel: {k}")
    ax.set_xticks([])
    ax.set_yticks([])

# Salvar como SVG em buffer
buffer = StringIO()
plt.savefig(buffer, format="svg", transparent=True)
print(buffer.getvalue())
plt.close()

O script explicado

Esta seção descreve passo a passo o script utilizado no exemplo (arquivo docs/svm/svm.py). Trechos de código relevantes foram convertidos em blocos Python para facilitar a leitura e a execução em MkDocs.

1. Carregamento e preparação dos dados

df = pd.read_csv("Titanic-Dataset.csv")
df = df[['Survived', 'Age', 'Fare', 'Sex']]
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1})
df = df.dropna()

Carrega o dataset do Titanic;
Seleciona variáveis relevantes;
Converte Sex para valores numéricos;
Remove valores faltantes (necessário para treinar o modelo).

2. Seleção de features para visualização

X = df[['Age', 'Fare']].values
y = df['Survived'].values

Nesta demonstração usamos apenas Age e Fare para manter os dados em 2D (necessário para plotar as fronteiras de decisão com DecisionBoundaryDisplay).

3. Padronização

scaler = StandardScaler()
X = scaler.fit_transform(X)

O SVM costuma se beneficiar de dados escalonados, especialmente para kernels como RBF e polinomial.

4. Treinamento com múltiplos kernels

kernels = {
    'linear': ax1,
    'sigmoid': ax2,
    'poly': ax3,
    'rbf': ax4
}

for k, ax in kernels.items():
    svm = SVC(kernel=k, C=1)
    svm.fit(X, y)

O script treina um modelo SVM para cada kernel (linear, sigmoid, poly, rbf) para comparar as fronteiras de decisão.

5. Plotando a fronteira de decisão

DecisionBoundaryDisplay.from_estimator(
    svm,
    X,
    response_method="predict",
    alpha=0.8,
    cmap="Pastel1",
    ax=ax
)

Essa função desenha a fronteira de decisão aprendida pelo SVM. A forma da fronteira varia conforme o kernel:

linear: linha reta;
poly: curvas suaves;
rbf: fronteiras detalhadas e não lineares;
sigmoid: separações parecidas com funções tipo rede neural.

6. Plotando os pontos de dados

ax.scatter(
    X[:, 0], X[:, 1],
    c=y,
    s=20, edgecolors="k"
)

Isso plota os pontos reais do dataset sobre a superfície de decisão (1 = sobrevivente, 0 = não sobrevivente).

7. Salvando a figura como SVG em buffer

buffer = StringIO()
plt.savefig(buffer, format="svg", transparent=True)
print(buffer.getvalue())

Em vez de mostrar a imagem interativamente, o script pode retornar o conteúdo SVG — útil para inclusão em páginas HTML ou MkDocs.

O que a visualização permite analisar

Regiões onde o modelo prevê sobrevivência vs. não sobrevivência;
Complexidade das fronteiras de decisão e flexibilidade do modelo;
Comparação direta entre kernels (rigidez vs. flexibilidade).

Exemplos:

Linear: fronteira reta;
Poly: curvas mais suaves;
RBF: fronteiras com muitos detalhes;
Sigmoid: comportamento intermediário.

Conclusão

O SVM é um modelo poderoso que:

Busca a melhor separação entre classes;
Utiliza vetores de suporte como pontos críticos;
Pode gerar fronteiras lineares ou altamente não lineares via kernels;
Se beneficia de escalonamento dos dados.

O exemplo prático demonstra como diferentes kernels afetam a decisão do modelo no problema do Titanic e ajuda a entender seu comportamento.