Dominando o RBF no SVM - Área de Trampo

Compreendendo o Kernel Radial Basis Function no Support Vector Machines

O tópico 1.4.6.1.3. Parameters of the RBF Kernel aborda um dos kernels mais utilizados e versáteis no Scikit-Learn. O Radial Basis Function Kernel, frequentemente chamado de RBF kernel ou Gaussian kernel, é fundamental para problemas de classificação não linear.

Definição Matemática do Kernel RBF

Primeiramente, o RBF kernel é definido pela fórmula matemática:

\(K(x, x’) = \exp\left(-\gamma \|x – x’\|^2\right)\)

onde γ (gamma) é o parâmetro que controla a influência de cada amostra individual. Analogamente a um botão de controle, este parâmetro determina o alcance da influência de cada ponto de treinamento.

Interpretação do Parâmetro Gamma

Certamente, gamma é o coração do comportamento do RBF kernel. Valores baixos indicam influência ampla, enquanto valores altos criam regiões de decisão mais complexas e localizadas.

import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Gerando dados não lineares
X, y = make_moons(n_samples=300, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Comparando diferentes valores de gamma
gammas = [0.1, 1, 10, 100]
resultados = {}

for gamma in gammas:
    svm_model = SVC(kernel='rbf', gamma=gamma, random_state=42)
    svm_model.fit(X_train, y_train)
    y_pred = svm_model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    resultados[gamma] = accuracy
    print(f"Gamma: {gamma}, Acurácia: {accuracy:.4f}")

import numpy as np

from sklearn.svm import SVC

from sklearn.datasets import make_moons

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

# Gerando dados não lineares

X, y = make_moons(n_samples=300, noise=0.2, random_state=42)

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

# Comparando diferentes valores de gamma

gammas = [0.1, 1, 10, 100]

resultados = {}

for gamma in gammas:

svm_model = SVC(kernel='rbf', gamma=gamma, random_state=42)

svm_model.fit(X_train, y_train)

y_pred = svm_model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

resultados[gamma] = accuracy

print(f"Gamma: {gamma}, Acurácia: {accuracy:.4f}")

O Parâmetro C e sua Interação com Gamma

Conquanto gamma seja crucial, o parâmetro C desempenha papel igualmente importante. Enquanto gamma controla a complexidade do limite de decisão, C controla a penalidade por classificações incorretas.

Combinação Ótima de Parâmetros

Embora cada parâmetro tenha seu papel, decerto a combinação ideal é essencial para performance máxima. Portanto, considere esta abordagem sistemática:

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

# Busca em grade para encontrar melhores parâmetros
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': [0.001, 0.01, 0.1, 1, 10]
}

svm_model = SVC(kernel='rbf', random_state=42)
grid_search = GridSearchCV(svm_model, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print("Melhores parâmetros:", grid_search.best_params_)
print("Melhor score:", grid_search.best_score_)

from sklearn.model_selection import GridSearchCV

from sklearn.svm import SVC

# Busca em grade para encontrar melhores parâmetros

param_grid = {

'C': [0.1, 1, 10, 100],

'gamma': [0.001, 0.01, 0.1, 1, 10]

}

svm_model = SVC(kernel='rbf', random_state=42)

grid_search = GridSearchCV(svm_model, param_grid, cv=5, scoring='accuracy')

grid_search.fit(X_train, y_train)

print("Melhores parâmetros:", grid_search.best_params_)

print("Melhor score:", grid_search.best_score_)

Efeitos Práticos dos Diferentes Valores de Gamma

Atualmente, compreender os efeitos visuais de gamma é tão importante quanto a compreensão teórica. Aliás, vejamos os comportamentos típicos:

Gamma Baixo vs Gamma Alto

Gamma baixo (< 0.1): Limites de decisão suaves, modelo mais generalizado
Gamma médio (0.1-1): Balanceamento entre bias e variance
Gamma alto (> 1): Limites complexos, risco de overfitting

import matplotlib.pyplot as plt
from sklearn.inspection import DecisionBoundaryDisplay

# Visualizando efeito do gamma
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
gammas = [0.01, 0.1, 1, 10]

for ax, gamma in zip(axes.ravel(), gammas):
    svm_model = SVC(kernel='rbf', gamma=gamma, C=1)
    svm_model.fit(X_train, y_train)
    
    DecisionBoundaryDisplay.from_estimator(
        svm_model, X_train, response_method="predict",
        alpha=0.5, ax=ax
    )
    
    # Plotando pontos de treinamento
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k')
    ax.set_title(f'Gamma = {gamma}')
    ax.set_xlabel('Feature 1')
    ax.set_ylabel('Feature 2')

plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt

from sklearn.inspection import DecisionBoundaryDisplay

# Visualizando efeito do gamma

fig, axes = plt.subplots(2, 2, figsize=(12, 10))

gammas = [0.01, 0.1, 1, 10]

for ax, gamma in zip(axes.ravel(), gammas):

svm_model = SVC(kernel='rbf', gamma=gamma, C=1)

svm_model.fit(X_train, y_train)

DecisionBoundaryDisplay.from_estimator(

svm_model, X_train, response_method="predict",

alpha=0.5, ax=ax

)

# Plotando pontos de treinamento

ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k')

ax.set_title(f'Gamma = {gamma}')

ax.set_xlabel('Feature 1')

ax.set_ylabel('Feature 2')

plt.tight_layout()

plt.show()

Escolha Automática de Gamma

Enquanto a busca em grade é eficaz, igualmente existem heurísticas úteis. Surpreendentemente, o Scikit-Learn oferece opções automáticas:

Gamma Scale e Auto

O Scikit-Learn fornece duas opções convenientes para gamma:

# Gamma automático baseado na heurística 1/(n_features * X.var())
svm_auto = SVC(kernel='rbf', gamma='auto')
svm_auto.fit(X_train, y_train)

# Gamma scale: 1/(n_features * X.std())
svm_scale = SVC(kernel='rbf', gamma='scale')
svm_scale.fit(X_train, y_train)

print("Acurácia com gamma='auto':", accuracy_score(y_test, svm_auto.predict(X_test)))
print("Acurácia com gamma='scale':", accuracy_score(y_test, svm_scale.predict(X_test)))

# Gamma automático baseado na heurística 1/(n_features * X.var())

svm_auto = SVC(kernel='rbf', gamma='auto')

svm_auto.fit(X_train, y_train)

# Gamma scale: 1/(n_features * X.std())

svm_scale = SVC(kernel='rbf', gamma='scale')

svm_scale.fit(X_train, y_train)

print("Acurácia com gamma='auto':", accuracy_score(y_test, svm_auto.predict(X_test)))

print("Acurácia com gamma='scale':", accuracy_score(y_test, svm_scale.predict(X_test)))

Considerações de Performance e Complexidade

Contudo, valores altos de gamma impactam significativamente a performance computacional. Assim, é importante balancear complexidade e eficiência:

Gamma alto aumenta o tempo de treinamento exponencialmente
Pode requerer mais memória para armazenar a matriz do kernel
Afeta a capacidade de generalização do modelo

Otimização para Grandes Conjuntos de Dados

Para conjuntos de dados extensos, estratégias específicas são necessárias:

from sklearn.svm import SVC
import time

# Estratégia para grandes datasets
def treinar_svm_eficiente(X, y, gamma=0.1, C=1.0, cache_size=500):
    """
    Treina SVM com otimizações para performance
    """
    inicio = time.time()
    
    svm_model = SVC(
        kernel='rbf',
        gamma=gamma,
        C=C,
        cache_size=cache_size,  # Aumenta cache para melhor performance
        random_state=42
    )
    
    svm_model.fit(X, y)
    tempo_treinamento = time.time() - inicio
    
    print(f"Tempo de treinamento: {tempo_treinamento:.2f} segundos")
    return svm_model

# Exemplo de uso
modelo_otimizado = treinar_svm_eficiente(X_train, y_train, gamma=0.1, C=1.0)

from sklearn.svm import SVC

import time

# Estratégia para grandes datasets

def treinar_svm_eficiente(X, y, gamma=0.1, C=1.0, cache_size=500):

"""

Treina SVM com otimizações para performance

"""

inicio = time.time()

svm_model = SVC(

kernel='rbf',

gamma=gamma,

C=C,

cache_size=cache_size, # Aumenta cache para melhor performance

random_state=42

)

svm_model.fit(X, y)

tempo_treinamento = time.time() - inicio

print(f"Tempo de treinamento: {tempo_treinamento:.2f} segundos")

return svm_model

# Exemplo de uso

modelo_otimizado = treinar_svm_eficiente(X_train, y_train, gamma=0.1, C=1.0)

Boas Práticas e Recomendações

Inegavelmente, a escolha adequada de gamma é fundamental. Então, considere estas diretrizes práticas:

Comece com gamma=’scale’ como baseline
Use validação cruzada para tuning fino
Considere a escala das features – normalize os dados
Monitore overfitting através de curvas de aprendizado

Exemplo Completo de Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score

# Pipeline completo com pré-processamento
pipeline_svm = Pipeline([
    ('scaler', StandardScaler()),  # Normalização crucial para RBF
    ('svm', SVC(kernel='rbf', gamma='scale', C=1.0))
])

# Validação cruzada
scores = cross_val_score(pipeline_svm, X_train, y_train, cv=5, scoring='accuracy')
print(f"Acurácia média na validação cruzada: {scores.mean():.4f} (+/- {scores.std() * 2:.4f})")

# Treinamento final
pipeline_svm.fit(X_train, y_train)
acuracia_final = accuracy_score(y_test, pipeline_svm.predict(X_test))
print(f"Acurácia final no teste: {acuracia_final:.4f}")

from sklearn.pipeline import Pipeline

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import cross_val_score

# Pipeline completo com pré-processamento

pipeline_svm = Pipeline([

('scaler', StandardScaler()), # Normalização crucial para RBF

('svm', SVC(kernel='rbf', gamma='scale', C=1.0))

])

# Validação cruzada

scores = cross_val_score(pipeline_svm, X_train, y_train, cv=5, scoring='accuracy')

print(f"Acurácia média na validação cruzada: {scores.mean():.4f} (+/- {scores.std() * 2:.4f})")

# Treinamento final

pipeline_svm.fit(X_train, y_train)

acuracia_final = accuracy_score(y_test, pipeline_svm.predict(X_test))

print(f"Acurácia final no teste: {acuracia_final:.4f}")

Conclusão e Aplicações Práticas

Enfim, o domínio dos parâmetros do RBF kernel é essencial para aproveitar todo o potencial dos Support Vector Machines. Inegavelmente, a compreensão de gamma e sua interação com C separa usuários básicos de praticantes avançados.

Afinal, o RBF kernel continua sendo uma das escolhas mais populares e eficazes para problemas de classificação não linear. Eventualmente, você desenvolverá intuição para selecionar parâmetros adequados para diferentes tipos de dados.

Portanto, pratique extensivamente com diversos conjuntos de dados. Inclusive experimentando valores extremos de gamma para compreender completamente seus efeitos no comportamento do modelo.

Indice