Arquivo de maquina-vetores-suporte

Se você já trabalhou com Support Vector Machines (SVM) no scikit-learn, certamente percebeu como essa técnica é poderosa para classificação e regressão. Contudo, o verdadeiro poder do SVM é revelado quando entendemos as Kernel Functions – o segredo para lidar com problemas não lineares de forma elegante.

O Que São Kernel Functions?

Primordialmente, kernel functions são funções que permitem ao SVM operar em um espaço de características de alta dimensão sem precisar calcular explicitamente as coordenadas dos dados nesse espaço. Em outras palavras, é um “atalho matemático” que possibilita encontrar fronteiras de decisão não lineares mantendo a eficiência computacional.

O Problema que os Kernels Resolvem

Conforme documentação do scikit-learn, o SVM original funciona principalmente para dados linearmente separáveis. Mas, e quando os dados não podem ser separados por uma simples linha ou plano? Surpreendentemente, os kernels resolvem exatamente esse problema!

Principais Kernel Functions no scikit-learn

1. Linear Kernel

Fórmula: \(K(x_i, x_j) = x_i \cdot x_j\)
Utilizado quando a separação é linear
Mais simples e computacionalmente eficiente

2. Polynomial Kernel

Fórmula: \(K(x_i, x_j) = (\gamma x_i \cdot x_j + r)^d\)
Onde d é o grau do polinômio
Ideal para dados com relações polinomiais

3. RBF (Radial Basis Function) Kernel

Fórmula: \(K(x_i, x_j) = \exp(-\gamma ||x_i – x_j||^2)\)
Também conhecido como Gaussian Kernel
Sobretudo versátil e amplamente utilizado
Lida bem com fronteiras complexas e não lineares

4. Sigmoid Kernel

Fórmula: \(K(x_i, x_j) = \tanh(\gamma x_i \cdot x_j + r)\)
Similar à função de ativação de redes neurais

Por Que os Kernels São Tão Importantes?

Inegavelmente, os kernels representam uma vantagem computacional significativa. Afinal, calcular transformações explícitas para espaços de alta dimensão seria extremamente custoso. Ademais, eles permitem que o SVM:

Lide com dados não linearmente separáveis
Mantenha a eficiência computacional através do “kernel trick”
Seja aplicado a diversos tipos de dados e problemas

Exemplo Prático no scikit-learn

Veja como é simples utilizar diferentes kernels:

from sklearn import svm, datasets
from sklearn.model_selection import train_test_split

# Carregar dados
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Dividir dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Criar classificadores com diferentes kernels
linear_svc = svm.SVC(kernel='linear')
rbf_svc = svm.SVC(kernel='rbf')
poly_svc = svm.SVC(kernel='poly', degree=3)

# Treinar modelos
linear_svc.fit(X_train, y_train)
rbf_svc.fit(X_train, y_train)
poly_svc.fit(X_train, y_train)

from sklearn import svm, datasets

from sklearn.model_selection import train_test_split

# Carregar dados

iris = datasets.load_iris()

X = iris.data

y = iris.target

# Dividir dados

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Criar classificadores com diferentes kernels

linear_svc = svm.SVC(kernel='linear')

rbf_svc = svm.SVC(kernel='rbf')

poly_svc = svm.SVC(kernel='poly', degree=3)

# Treinar modelos

linear_svc.fit(X_train, y_train)

rbf_svc.fit(X_train, y_train)

poly_svc.fit(X_train, y_train)

Considerações Finais

Embora o kernel RBF seja frequentemente a escolha padrão por sua versatilidade, é fundamental testar diferentes kernels para cada problema específico. Analogamente, parâmetros como gamma e C devem ser cuidadosamente ajustados.

Enfim, entender kernel functions é essencial para dominar o SVM. Portanto, experimente diferentes abordagens em seus projetos e observe como a escolha do kernel pode impactar significativamente o desempenho do modelo.

Referências

Anteriormente exploramos os Support Vector Machines (SVM) para problemas supervisionados. Analogamente, o scikit-learn oferece implementações para problemas não supervisionados através do One-Class SVM, focando em estimativa de densidade e detecção de novidades.

Conceito Fundamental do One-Class SVM

Primordialmente, o One-Class SVM é uma técnica que aprende um limite de decisão para englobar os dados normais de treinamento. Similarmente aos SVM tradicionais, este método busca encontrar um hiperplano que maximize a margem em relação à origem no espaço de características.

Conforme a documentação, o OneClassSVM é particularmente útil quando temos muitos exemplos da classe “normal” e poucos ou nenhum exemplo de anomalias durante o treinamento. Decerto, esta característica o torna ideal para cenários de detecção de novidades onde as anomalias são raras ou desconhecidas.

Formulação Matemática

O objetivo do One-Class SVM pode ser expresso pela seguinte formulação:

\(\min_{w,\xi,\rho} \frac{1}{2}||w||^2 + \frac{1}{\nu n}\sum_{i=1}^n \xi_i – \rho\)

Sujeito a:

\((w \cdot \phi(x_i)) \geq \rho – \xi_i, \quad \xi_i \geq 0\)

Onde:

w é o vetor de pesos do hiperplano
φ(xᵢ) representa a transformação para o espaço de características
ξᵢ são variáveis de folga
ν é o parâmetro crucial que controla a fração de outliers
ρ é o termo de bias

Interpretação do Parâmetro ν

Inegavelmente, o parâmetro ν merece atenção especial. Conquanto possa parecer complexo inicialmente, sua interpretação é fundamental:

ν representa um limite superior para a fração de outliers de treinamento
Simultaneamente, é um limite inferior para a fração de vetores de suporte
Valores típicos variam entre 0.01 e 0.5

Portanto, ao definir ν=0.1, estamos instruindo o modelo a considerar que aproximadamente 10% dos dados de treinamento podem ser outliers.

Aplicações Práticas

Atualmente, as aplicações do One-Class SVM são vastas:

Detecção de fraude: Identificação de transações financeiras anômalas
Monitoramento industrial: Detecção de falhas em equipamentos
Qualidade de produtos: Identificação de itens defeituosos
Segurança cibernética: Detecção de intrusões em redes

Exemplo Prático em Python

Ademais, vejamos uma implementação prática utilizando o scikit-learn:

'''
Exemplo de Detecção de Novidades usando OneClassSVM
Este exemplo demonstra a aplicação do One-Class SVM
para identificar observações anômalas
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.datasets import make_blobs

# Gerar dados de exemplo
X, y = make_blobs(n_samples=300, centers=1, cluster_std=0.60, random_state=42)

# Adicionar outliers para simular dados anômalos
rng = np.random.RandomState(42)
X_outliers = rng.uniform(low=-6, high=6, size=(20, 2))
X_combined = np.vstack([X, X_outliers])

# Configurar e treinar o modelo OneClassSVM
nu_value = 0.1  # Parâmetro nu controla tolerância a outliers
clf = svm.OneClassSVM(nu=nu_value, kernel='rbf', gamma=0.1)
clf.fit(X_combined)

# Fazer previsões (1 = inlier, -1 = outlier)
y_pred = clf.predict(X_combined)

# Identificar os outliers detectados
outlier_indices = np.where(y_pred == -1)[0]

# Visualização dos resultados
plt.figure(figsize=(10, 8))

# Plotar os inliers (dados normais)
plt.scatter(X_combined[y_pred == 1, 0], X_combined[y_pred == 1, 1], 
           c='white', s=20, edgecolor='k', label='Inliers')

# Plotar os outliers detectados
plt.scatter(X_combined[y_pred == -1, 0], X_combined[y_pred == -1, 1], 
           c='red', s=50, edgecolor='k', label='Outliers Detectados')

plt.legend()
plt.title(f'Detecção de Novidades com One-Class SVM (nu={nu_value})')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.grid(True, alpha=0.3)
plt.show()

# Estatísticas do modelo
n_outliers_detected = len(outlier_indices)
total_samples = len(X_combined)
print(f'Total de amostras: {total_samples}')
print(f'Outliers detectados: {n_outliers_detected}')
print(f'Percentual de outliers: {(n_outliers_detected/total_samples)*100:.2f}%')

'''

Exemplo de Detecção de Novidades usando OneClassSVM

Este exemplo demonstra a aplicação do One-Class SVM

para identificar observações anômalas

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn import svm

from sklearn.datasets import make_blobs

# Gerar dados de exemplo

X, y = make_blobs(n_samples=300, centers=1, cluster_std=0.60, random_state=42)

# Adicionar outliers para simular dados anômalos

rng = np.random.RandomState(42)

X_outliers = rng.uniform(low=-6, high=6, size=(20, 2))

X_combined = np.vstack([X, X_outliers])

# Configurar e treinar o modelo OneClassSVM

nu_value = 0.1 # Parâmetro nu controla tolerância a outliers

clf = svm.OneClassSVM(nu=nu_value, kernel='rbf', gamma=0.1)

clf.fit(X_combined)

# Fazer previsões (1 = inlier, -1 = outlier)

y_pred = clf.predict(X_combined)

# Identificar os outliers detectados

outlier_indices = np.where(y_pred == -1)[0]

# Visualização dos resultados

plt.figure(figsize=(10, 8))

# Plotar os inliers (dados normais)

plt.scatter(X_combined[y_pred == 1, 0], X_combined[y_pred == 1, 1],

c='white', s=20, edgecolor='k', label='Inliers')

# Plotar os outliers detectados

plt.scatter(X_combined[y_pred == -1, 0], X_combined[y_pred == -1, 1],

c='red', s=50, edgecolor='k', label='Outliers Detectados')

plt.legend()

plt.title(f'Detecção de Novidades com One-Class SVM (nu={nu_value})')

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.grid(True, alpha=0.3)

plt.show()

# Estatísticas do modelo

n_outliers_detected = len(outlier_indices)

total_samples = len(X_combined)

print(f'Total de amostras: {total_samples}')

print(f'Outliers detectados: {n_outliers_detected}')

print(f'Percentual de outliers: {(n_outliers_detected/total_samples)*100:.2f}%')

Considerações Importantes

Embora o One-Class SVM seja poderoso, algumas considerações são essenciais:

O modelo assume que a maioria dos dados de treinamento representa comportamento “normal”
A escolha do kernel e dos hiperparâmetros é crítica para o desempenho
O escalonamento dos dados é recomendado
Para datasets muito grandes, a complexidade computacional pode ser limitante

Enfim, compreender a estimativa de densidade e detecção de novidades com SVM complementa nosso conhecimento sobre as capacidades versáteis desta família de algoritmos no scikit-learn.

Referência: https://scikit-learn.org/0.21/modules/svm.html#estimating-the-density-and-detecting-novelties

Kernel Functions no SVM: A Mágica Por Trás da Separação de Dados Não Lineares