Arquivo de svc - Área de Trampo

NuSVC: Uma abordagem alternativa para Support Vector Classification

19/12/202528/10/2025 Por antonino

Compreendendo o Nu-SVC e suas Vantagens

O NuSVC é uma variação do Support Vector Classification que introduz o parâmetro nu como alternativa ao parâmetro C tradicional. Esta abordagem oferece uma interpretação mais intuitiva do trade-off entre erro de treinamento e margem, controlando diretamente o número de vetores suporte e erros de margem.

Diferenças Fundamentais entre NuSVC e SVC

Primeiramente, enquanto o SVC convencional usa o parâmetro C para controlar a penalização por erros, o NuSVC emprega o parâmetro nu que representa um limite superior para a fração de erros de margem e um limite inferior para a fração de vetores suporte. A formulação matemática é expressa como:

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

sujeito a:

\(y_i (w \cdot \phi(x_i) + b) \geq \rho – \xi_i \quad \text{e} \quad \xi_i \geq 0, \rho \geq 0\)

Parâmetros Principais do NuSVC

Certamente, entender os parâmetros específicos do NuSVC é essencial para seu uso eficaz:

from sklearn.svm import NuSVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score

# Criando dados de exemplo
X, y = make_classification(n_samples=1000, n_features=4, n_classes=2, 
                          n_redundant=0, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, 
                                                   random_state=42)

# Inicializando NuSVC com parâmetros principais
nusvc_model = NuSVC(
    nu=0.5,            # Parâmetro nu principal (0 < nu <= 1)
    kernel='rbf',      # Tipo de kernel
    gamma='scale',     # Parâmetro do kernel
    degree=3,          # Grau para kernel polinomial
    coef0=0.0,        # Termo independente
    shrinking=True,    # Usar heurística shrinking
    probability=False, # Estimativas de probabilidade
    tol=1e-3,         # Tolerância
    cache_size=200,   # Tamanho do cache
    class_weight=None, # Peso das classes
    verbose=False,
    max_iter=-1,      # Iterações ilimitadas
    decision_function_shape='ovr'
)

# Treinando o modelo
nusvc_model.fit(X_train, y_train)

# Fazendo predições e avaliando
y_pred = nusvc_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
n_support_vectors = len(nusvc_model.support_vectors_)

print(f"Acurácia: {accuracy:.4f}")
print(f"Número de vetores suporte: {n_support_vectors}")
print(f"Fração de vetores suporte: {n_support_vectors / len(X_train):.4f}")
print("\n" + classification_report(y_test, y_pred))

from sklearn.svm import NuSVC

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import classification_report, accuracy_score

# Criando dados de exemplo

X, y = make_classification(n_samples=1000, n_features=4, n_classes=2,

n_redundant=0, random_state=42)

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

random_state=42)

# Inicializando NuSVC com parâmetros principais

nusvc_model = NuSVC(

nu=0.5, # Parâmetro nu principal (0 < nu <= 1)

kernel='rbf', # Tipo de kernel

gamma='scale', # Parâmetro do kernel

degree=3, # Grau para kernel polinomial

coef0=0.0, # Termo independente

shrinking=True, # Usar heurística shrinking

probability=False, # Estimativas de probabilidade

tol=1e-3, # Tolerância

cache_size=200, # Tamanho do cache

class_weight=None, # Peso das classes

verbose=False,

max_iter=-1, # Iterações ilimitadas

decision_function_shape='ovr'

)

# Treinando o modelo

nusvc_model.fit(X_train, y_train)

# Fazendo predições e avaliando

y_pred = nusvc_model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

n_support_vectors = len(nusvc_model.support_vectors_)

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

print(f"Número de vetores suporte: {n_support_vectors}")

print(f"Fração de vetores suporte: {n_support_vectors / len(X_train):.4f}")

print("\n" + classification_report(y_test, y_pred))

Interpretação do Parâmetro Nu

Conquanto o parâmetro nu possa parecer abstrato inicialmente, sua interpretação é bastante intuitiva. Ele representa:

Limite superior para a fração de erros de margem
Limite inferior para a fração de vetores suporte
Controla diretamente a complexidade do modelo

O parâmetro nu deve estar no intervalo (0, 1], onde valores mais altos permitem mais erros mas resultam em modelos mais simples.

Efeito do Parâmetro Nu no Comportamento do Modelo

Embora a teoria seja importante, decerto ver o efeito prático do parâmetro nu é crucial para o entendimento. Portanto, analisemos sistematicamente:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import NuSVC
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score

# Criando dados não linearmente separáveis
X, y = make_classification(n_samples=300, n_features=2, n_redundant=0,
                          n_informative=2, n_clusters_per_class=1,
                          flip_y=0.1, random_state=42)

# Testando diferentes valores de nu
nu_values = [0.01, 0.1, 0.3, 0.5, 0.7, 0.9]
results = []

for nu in nu_values:
    nusvc = NuSVC(nu=nu, kernel='rbf', gamma='scale', random_state=42)
    
    # Validação cruzada
    scores = cross_val_score(nusvc, X, y, cv=5, scoring='accuracy')
    mean_score = scores.mean()
    std_score = scores.std()
    
    # Treinando para contar vetores suporte
    nusvc.fit(X, y)
    n_sv = len(nusvc.support_vectors_)
    fraction_sv = n_sv / len(X)
    
    results.append({
        'nu': nu,
        'accuracy': mean_score,
        'accuracy_std': std_score,
        'n_support_vectors': n_sv,
        'fraction_support_vectors': fraction_sv
    })
    
    print(f"nu={nu}: Acurácia={mean_score:.4f} (±{std_score:.4f}), "
          f"Vetores Suporte={n_sv} ({fraction_sv:.2%})")

# Encontrando o melhor nu
best_result = max(results, key=lambda x: x['accuracy'])
print(f"\nMelhor nu: {best_result['nu']} com acurácia {best_result['accuracy']:.4f}")

import numpy as np

import matplotlib.pyplot as plt

from sklearn.svm import NuSVC

from sklearn.datasets import make_classification

from sklearn.model_selection import cross_val_score

# Criando dados não linearmente separáveis

X, y = make_classification(n_samples=300, n_features=2, n_redundant=0,

n_informative=2, n_clusters_per_class=1,

flip_y=0.1, random_state=42)

# Testando diferentes valores de nu

nu_values = [0.01, 0.1, 0.3, 0.5, 0.7, 0.9]

results = []

for nu in nu_values:

nusvc = NuSVC(nu=nu, kernel='rbf', gamma='scale', random_state=42)

# Validação cruzada

scores = cross_val_score(nusvc, X, y, cv=5, scoring='accuracy')

mean_score = scores.mean()

std_score = scores.std()

# Treinando para contar vetores suporte

nusvc.fit(X, y)

n_sv = len(nusvc.support_vectors_)

fraction_sv = n_sv / len(X)

results.append({

'nu': nu,

'accuracy': mean_score,

'accuracy_std': std_score,

'n_support_vectors': n_sv,

'fraction_support_vectors': fraction_sv

})

print(f"nu={nu}: Acurácia={mean_score:.4f} (±{std_score:.4f}), "

f"Vetores Suporte={n_sv} ({fraction_sv:.2%})")

# Encontrando o melhor nu

best_result = max(results, key=lambda x: x['accuracy'])

print(f"\nMelhor nu: {best_result['nu']} com acurácia {best_result['accuracy']:.4f}")

Comparação Direta: NuSVC vs SVC

Atualmente, muitos praticantes questionam quando usar NuSVC em vez do SVC tradicional. Aliás, cada abordagem tem suas vantagens específicas:

Análise Comparativa Prática

Enquanto ambas as implementações resolvem problemas similares, igualmente importante é entender suas diferenças práticas:

from sklearn.svm import SVC, NuSVC
from sklearn.model_selection import cross_val_score
import pandas as pd
import numpy as np

# Dataset para comparação
X_comp, y_comp = make_classification(n_samples=500, n_features=4, 
                                    n_classes=2, random_state=42)

# Configurações equivalentes (aproximadamente)
comparison_results = []

# Testando SVC com diferentes valores de C
C_values = [0.1, 1, 10, 100]
for C in C_values:
    svc = SVC(C=C, kernel='rbf', gamma='scale', random_state=42)
    scores = cross_val_score(svc, X_comp, y_comp, cv=5, scoring='accuracy')
    
    svc.fit(X_comp, y_comp)
    n_sv_svc = len(svc.support_vectors_)
    
    comparison_results.append({
        'model': 'SVC',
        'param_name': 'C',
        'param_value': C,
        'accuracy': scores.mean(),
        'n_support_vectors': n_sv_svc
    })

# Testando NuSVC com diferentes valores de nu
nu_values = [0.1, 0.3, 0.5, 0.7]
for nu in nu_values:
    nusvc = NuSVC(nu=nu, kernel='rbf', gamma='scale', random_state=42)
    scores = cross_val_score(nusvc, X_comp, y_comp, cv=5, scoring='accuracy')
    
    nusvc.fit(X_comp, y_comp)
    n_sv_nusvc = len(nusvc.support_vectors_)
    
    comparison_results.append({
        'model': 'NuSVC',
        'param_name': 'nu',
        'param_value': nu,
        'accuracy': scores.mean(),
        'n_support_vectors': n_sv_nusvc
    })

# Criando DataFrame para análise
df_comparison = pd.DataFrame(comparison_results)
print("\nComparação SVC vs NuSVC:")
print(df_comparison.to_string(index=False))

from sklearn.svm import SVC, NuSVC

from sklearn.model_selection import cross_val_score

import pandas as pd

import numpy as np

# Dataset para comparação

X_comp, y_comp = make_classification(n_samples=500, n_features=4,

n_classes=2, random_state=42)

# Configurações equivalentes (aproximadamente)

comparison_results = []

# Testando SVC com diferentes valores de C

C_values = [0.1, 1, 10, 100]

for C in C_values:

svc = SVC(C=C, kernel='rbf', gamma='scale', random_state=42)

scores = cross_val_score(svc, X_comp, y_comp, cv=5, scoring='accuracy')

svc.fit(X_comp, y_comp)

n_sv_svc = len(svc.support_vectors_)

comparison_results.append({

'model': 'SVC',

'param_name': 'C',

'param_value': C,

'accuracy': scores.mean(),

'n_support_vectors': n_sv_svc

})

# Testando NuSVC com diferentes valores de nu

nu_values = [0.1, 0.3, 0.5, 0.7]

for nu in nu_values:

nusvc = NuSVC(nu=nu, kernel='rbf', gamma='scale', random_state=42)

scores = cross_val_score(nusvc, X_comp, y_comp, cv=5, scoring='accuracy')

nusvc.fit(X_comp, y_comp)

n_sv_nusvc = len(nusvc.support_vectors_)

comparison_results.append({

'model': 'NuSVC',

'param_name': 'nu',

'param_value': nu,

'accuracy': scores.mean(),

'n_support_vectors': n_sv_nusvc

})

# Criando DataFrame para análise

df_comparison = pd.DataFrame(comparison_results)

print("\nComparação SVC vs NuSVC:")

print(df_comparison.to_string(index=False))

Casos de Uso Específicos do NuSVC

Surpreendentemente, o NuSVC brilha em situações específicas onde o controle direto sobre vetores suporte é desejável:

Quando se deseja limitar explicitamente o número de vetores suporte
Para problemas onde a interpretação do modelo é crucial
Em situações com restrições computacionais severas
Quando se trabalha com dados muito ruidosos

Aplicação em Dados com Ruído

from sklearn.svm import NuSVC, SVC
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt
from sklearn.inspection import DecisionBoundaryDisplay

# Criando dados com ruído significativo
X_noisy, y_noisy = make_classification(n_samples=200, n_features=2, 
                                      n_redundant=0, n_informative=2,
                                      flip_y=0.3, random_state=42)  # 30% de ruído

# Comparando SVC e NuSVC em dados ruidosos
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

models = [
    ('SVC (C=1)', SVC(C=1, kernel='rbf', gamma='scale', random_state=42)),
    ('NuSVC (nu=0.1)', NuSVC(nu=0.1, kernel='rbf', gamma='scale', random_state=42)),
    ('NuSVC (nu=0.5)', NuSVC(nu=0.5, kernel='rbf', gamma='scale', random_state=42))
]

for ax, (name, model) in zip(axes, models):
    model.fit(X_noisy, y_noisy)
    
    DecisionBoundaryDisplay.from_estimator(
        model, X_noisy, response_method="predict",
        alpha=0.5, ax=ax
    )
    
    # Plotando pontos e vetores suporte
    ax.scatter(X_noisy[:, 0], X_noisy[:, 1], c=y_noisy, edgecolors='k')
    ax.scatter(model.support_vectors_[:, 0], model.support_vectors_[:, 1],
              s=100, facecolors='none', edgecolors='red', linewidths=1.5)
    
    accuracy = model.score(X_noisy, y_noisy)
    n_sv = len(model.support_vectors_)
    ax.set_title(f'{name}\nAcurácia: {accuracy:.3f}, VS: {n_sv}')

plt.tight_layout()
plt.show()

from sklearn.svm import NuSVC, SVC

from sklearn.datasets import make_classification

import matplotlib.pyplot as plt

from sklearn.inspection import DecisionBoundaryDisplay

# Criando dados com ruído significativo

X_noisy, y_noisy = make_classification(n_samples=200, n_features=2,

n_redundant=0, n_informative=2,

flip_y=0.3, random_state=42) # 30% de ruído

# Comparando SVC e NuSVC em dados ruidosos

fig, axes = plt.subplots(1, 3, figsize=(15, 5))

models = [

('SVC (C=1)', SVC(C=1, kernel='rbf', gamma='scale', random_state=42)),

('NuSVC (nu=0.1)', NuSVC(nu=0.1, kernel='rbf', gamma='scale', random_state=42)),

('NuSVC (nu=0.5)', NuSVC(nu=0.5, kernel='rbf', gamma='scale', random_state=42))

]

for ax, (name, model) in zip(axes, models):

model.fit(X_noisy, y_noisy)

DecisionBoundaryDisplay.from_estimator(

model, X_noisy, response_method="predict",

alpha=0.5, ax=ax

)

# Plotando pontos e vetores suporte

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

ax.scatter(model.support_vectors_[:, 0], model.support_vectors_[:, 1],

s=100, facecolors='none', edgecolors='red', linewidths=1.5)

accuracy = model.score(X_noisy, y_noisy)

n_sv = len(model.support_vectors_)

ax.set_title(f'{name}\nAcurácia: {accuracy:.3f}, VS: {n_sv}')

plt.tight_layout()

plt.show()

Otimização de Hiperparâmetros para NuSVC

Contudo, encontrar o nu ideal requer abordagens sistemáticas. Assim, técnicas de busca são igualmente importantes:

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.svm import NuSVC
from sklearn.datasets import make_classification
import numpy as np

# Dataset para tuning
X_tune, y_tune = make_classification(n_samples=800, n_features=5, random_state=42)

# Busca em Grade para NuSVC
param_grid_nu = {
    'nu': [0.01, 0.1, 0.3, 0.5, 0.7, 0.9],
    'kernel': ['linear', 'rbf', 'poly'],
    'gamma': ['scale', 'auto', 0.1, 1],
    'degree': [2, 3]  # Para kernel poly
}

nusvc = NuSVC(random_state=42)
grid_search_nu = GridSearchCV(nusvc, param_grid_nu, cv=5, 
                             scoring='accuracy', n_jobs=-1)
grid_search_nu.fit(X_tune, y_tune)

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

# Análise dos resultados
results_df = pd.DataFrame(grid_search_nu.cv_results_)
best_nu_results = results_df[results_df['rank_test_score'] == 1]
print(f"\nMelhor configuração encontrada:")
print(f"Nu: {best_nu_results['param_nu'].values[0]}")
print(f"Kernel: {best_nu_results['param_kernel'].values[0]}")
print(f"Gamma: {best_nu_results['param_gamma'].values[0]}")

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV

from sklearn.svm import NuSVC

from sklearn.datasets import make_classification

import numpy as np

# Dataset para tuning

X_tune, y_tune = make_classification(n_samples=800, n_features=5, random_state=42)

# Busca em Grade para NuSVC

param_grid_nu = {

'nu': [0.01, 0.1, 0.3, 0.5, 0.7, 0.9],

'kernel': ['linear', 'rbf', 'poly'],

'gamma': ['scale', 'auto', 0.1, 1],

'degree': [2, 3] # Para kernel poly

}

nusvc = NuSVC(random_state=42)

grid_search_nu = GridSearchCV(nusvc, param_grid_nu, cv=5,

scoring='accuracy', n_jobs=-1)

grid_search_nu.fit(X_tune, y_tune)

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

print("Melhor score NuSVC:", grid_search_nu.best_score_)

# Análise dos resultados

results_df = pd.DataFrame(grid_search_nu.cv_results_)

best_nu_results = results_df[results_df['rank_test_score'] == 1]

print(f"\nMelhor configuração encontrada:")

print(f"Nu: {best_nu_results['param_nu'].values[0]}")

print(f"Kernel: {best_nu_results['param_kernel'].values[0]}")

print(f"Gamma: {best_nu_results['param_gamma'].values[0]}")

Limitações e Considerações Práticas

Inegavelmente, o NuSVC tem suas limitações. Então, é importante considerar:

O parâmetro nu deve ser maior que 0 e menor ou igual a 1
Pode não convergir para valores de nu muito baixos em dados ruidosos
A interpretação de nu é menos direta que C para iniciantes
O desempenho pode ser similar ao SVC com tuning adequado

Tratamento de Casos Especiais

from sklearn.svm import NuSVC
from sklearn.exceptions import ConvergenceWarning
import warnings

# Demonstrando casos problemáticos
X_small, y_small = make_classification(n_samples=50, n_features=2, random_state=42)

problematic_nu_values = [0.001, 0.95, 0.99]

for nu in problematic_nu_values:
    try:
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            
            nusvc_problem = NuSVC(nu=nu, kernel='rbf', random_state=42)
            nusvc_problem.fit(X_small, y_small)
            
            if w:
                print(f"Nu={nu}: Aviso - {w[-1].message}")
            else:
                print(f"Nu={nu}: Convergiu com {len(nusvc_problem.support_vectors_)} vetores suporte")
                
    except ValueError as e:
        print(f"Nu={nu}: Erro - {e}")

from sklearn.svm import NuSVC

from sklearn.exceptions import ConvergenceWarning

import warnings

# Demonstrando casos problemáticos

X_small, y_small = make_classification(n_samples=50, n_features=2, random_state=42)

problematic_nu_values = [0.001, 0.95, 0.99]

for nu in problematic_nu_values:

try:

with warnings.catch_warnings(record=True) as w:

warnings.simplefilter("always")

nusvc_problem = NuSVC(nu=nu, kernel='rbf', random_state=42)

nusvc_problem.fit(X_small, y_small)

if w:

print(f"Nu={nu}: Aviso - {w[-1].message}")

else:

print(f"Nu={nu}: Convergiu com {len(nusvc_problem.support_vectors_)} vetores suporte")

except ValueError as e:

print(f"Nu={nu}: Erro - {e}")

Conclusão e Recomendações Práticas

Enfim, o NuSVC oferece uma perspectiva valiosa e complementar ao SVC tradicional. Inegavelmente, seu maior valor está no controle direto sobre a fração de vetores suporte, o que pode ser crucial para aplicações específicas.

Afinal, a escolha entre NuSVC e SVC frequentemente se reduz à preferência do praticante e à natureza específica do problema. Eventualmente, experimentar ambas as abordagens pode revelar insights valiosos sobre os dados.

Portanto, considere o NuSVC quando a interpretabilidade do modelo for importante ou quando se deseja controle explícito sobre a complexidade. Inclusive para problemas onde limites teóricos sobre erros e vetores suporte são desejáveis.

Referências

SVC: Support Vector Classification no Scikit-Learn

19/12/202528/10/2025 Por antonino

Compreendendo o SVC para Problemas de Classificação

O SVC (Support Vector Classification) é a implementação principal para problemas de classificação nos Support Vector Machines do Scikit-Learn. Esta classe implementa o algoritmo clássico de SVM para classificação binária e multiclasse usando a abordagem one-vs-one.

Funcionamento Básico do SVC

Primeiramente, o SVC busca encontrar o hiperplano ótimo que separa as classes maximizando a margem entre os pontos mais próximos de cada classe. A formulação matemática resolve o problema de otimização:

\(\min_{w, b} \frac{1}{2} \|w\|^2 + C \sum_{i=1}^n \xi_i\)

sujeito a:

\(y_i (w \cdot \phi(x_i) + b) \geq 1 – \xi_i \quad \text{e} \quad \xi_i \geq 0\)

onde φ(x_i) é a transformação para o espaço de características através do kernel trick.

Parâmetros Principais do SVC

Certamente, entender os parâmetros é crucial para usar efetivamente o SVC. Os mais importantes incluem:

from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Criando dados de exemplo
X, y = make_classification(n_samples=1000, n_features=4, n_classes=2, 
                          n_redundant=0, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, 
                                                   random_state=42)

# Inicializando SVC com parâmetros principais
svc_model = SVC(
    C=1.0,              # Parâmetro de regularização
    kernel='rbf',       # Tipo de kernel
    gamma='scale',      # Parâmetro do kernel RBF
    degree=3,           # Grau para kernel polinomial
    coef0=0.0,         # Termo independente para poly/sigmoid
    shrinking=True,     # Usar heurística shrinking
    probability=False,  # Habilitar estimativas de probabilidade
    tol=1e-3,          # Tolerância para critério de parada
    cache_size=200,    # Tamanho do cache (MB)
    class_weight=None,  # Peso das classes
    verbose=False,
    max_iter=-1,       # Número máximo de iterações
    decision_function_shape='ovr'  # Estratégia multiclasse
)

# Treinando o modelo
svc_model.fit(X_train, y_train)

# Fazendo predições
y_pred = svc_model.predict(X_test)
print(classification_report(y_test, y_pred))

from sklearn.svm import SVC

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import classification_report

# Criando dados de exemplo

X, y = make_classification(n_samples=1000, n_features=4, n_classes=2,

n_redundant=0, random_state=42)

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

random_state=42)

# Inicializando SVC com parâmetros principais

svc_model = SVC(

C=1.0, # Parâmetro de regularização

kernel='rbf', # Tipo de kernel

gamma='scale', # Parâmetro do kernel RBF

degree=3, # Grau para kernel polinomial

coef0=0.0, # Termo independente para poly/sigmoid

shrinking=True, # Usar heurística shrinking

probability=False, # Habilitar estimativas de probabilidade

tol=1e-3, # Tolerância para critério de parada

cache_size=200, # Tamanho do cache (MB)

class_weight=None, # Peso das classes

verbose=False,

max_iter=-1, # Número máximo de iterações

decision_function_shape='ovr' # Estratégia multiclasse

)

# Treinando o modelo

svc_model.fit(X_train, y_train)

# Fazendo predições

y_pred = svc_model.predict(X_test)

print(classification_report(y_test, y_pred))

Kernels e Suas Aplicações

Conquanto o kernel linear seja o mais simples, a verdadeira potência do SVC surge com kernels não lineares. Cada kernel tem características específicas:

linear: \(K(x_i, x_j) = x_i \cdot x_j\) – Para problemas linearmente separáveis
poly: \(K(x_i, x_j) = (\gamma x_i \cdot x_j + r)^d\) – Para relações polinomiais
rbf: \(K(x_i, x_j) = \exp(-\gamma \|x_i – x_j\|^2)\) – Kernel mais popular e flexível
sigmoid: \(K(x_i, x_j) = \tanh(\gamma x_i \cdot x_j + r)\) – Similar a redes neurais

Comparação Prática de Kernels

Embora a teoria seja importante, decerto a aplicação prática revela diferenças cruciais. Portanto, vejamos uma comparação sistemática:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.datasets import make_circles, make_moons, make_classification
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler

# Criando diferentes tipos de dados
datasets = {
    'Linear': make_classification(n_features=2, n_redundant=0, 
                                 n_informative=2, random_state=1),
    'Moons': make_moons(noise=0.3, random_state=0),
    'Circles': make_circles(noise=0.2, factor=0.5, random_state=1)
}

kernels = ['linear', 'rbf', 'poly', 'sigmoid']
results = {}

for data_name, (X, y) in datasets.items():
    # Normalizando os dados
    X_scaled = StandardScaler().fit_transform(X)
    
    data_results = {}
    for kernel in kernels:
        if kernel == 'poly':
            svc = SVC(kernel=kernel, degree=3, gamma='scale')
        else:
            svc = SVC(kernel=kernel, gamma='scale')
        
        scores = cross_val_score(svc, X_scaled, y, cv=5, scoring='accuracy')
        data_results[kernel] = scores.mean()
    
    results[data_name] = data_results
    print(f"\n{data_name}:")
    for kernel, score in data_results.items():
        print(f"  {kernel}: {score:.4f}")

import numpy as np

import matplotlib.pyplot as plt

from sklearn.svm import SVC

from sklearn.datasets import make_circles, make_moons, make_classification

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import StandardScaler

# Criando diferentes tipos de dados

datasets = {

'Linear': make_classification(n_features=2, n_redundant=0,

n_informative=2, random_state=1),

'Moons': make_moons(noise=0.3, random_state=0),

'Circles': make_circles(noise=0.2, factor=0.5, random_state=1)

}

kernels = ['linear', 'rbf', 'poly', 'sigmoid']

results = {}

for data_name, (X, y) in datasets.items():

# Normalizando os dados

X_scaled = StandardScaler().fit_transform(X)

data_results = {}

for kernel in kernels:

if kernel == 'poly':

svc = SVC(kernel=kernel, degree=3, gamma='scale')

else:

svc = SVC(kernel=kernel, gamma='scale')

scores = cross_val_score(svc, X_scaled, y, cv=5, scoring='accuracy')

data_results[kernel] = scores.mean()

results[data_name] = data_results

print(f"\n{data_name}:")

for kernel, score in data_results.items():

print(f" {kernel}: {score:.4f}")

O Parâmetro C e Controle de Overfitting

Atualmente, o parâmetro C é um dos mais mal compreendidos no SVC. Aliás, ele controla o trade-off entre maximizar a margem e minimizar o erro de classificação:

C baixo: Margem larga, pode underfit, mas generaliza melhor
C alto: Margem estreita, ajusta-se mais aos dados, risco de overfitting

Visualizando o Efeito do Parâmetro C

Enquanto a descrição teórica ajuda, igualmente importante é ver o efeito visual:

from sklearn.inspection import DecisionBoundaryDisplay

# Demonstrando o efeito de C
X, y = make_classification(n_samples=200, n_features=2, n_redundant=0, 
                          n_informative=2, random_state=1, n_clusters_per_class=1)

C_values = [0.01, 0.1, 1, 10, 100]
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.ravel()

for i, C in enumerate(C_values):
    svc = SVC(C=C, kernel='linear', random_state=42)
    svc.fit(X, y)
    
    DecisionBoundaryDisplay.from_estimator(
        svc, X, response_method="predict",
        alpha=0.5, ax=axes[i]
    )
    
    # Plotando pontos e vetores suporte
    axes[i].scatter(X[:, 0], X[:, 1], c=y, edgecolors='k')
    axes[i].scatter(svc.support_vectors_[:, 0], svc.support_vectors_[:, 1], 
                   s=100, facecolors='none', edgecolors='red', linewidths=1.5)
    axes[i].set_title(f'C = {C}\nVetores Suporte: {len(svc.support_vectors_)}')

plt.tight_layout()
plt.show()

from sklearn.inspection import DecisionBoundaryDisplay

# Demonstrando o efeito de C

X, y = make_classification(n_samples=200, n_features=2, n_redundant=0,

n_informative=2, random_state=1, n_clusters_per_class=1)

C_values = [0.01, 0.1, 1, 10, 100]

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

axes = axes.ravel()

for i, C in enumerate(C_values):

svc = SVC(C=C, kernel='linear', random_state=42)

svc.fit(X, y)

DecisionBoundaryDisplay.from_estimator(

svc, X, response_method="predict",

alpha=0.5, ax=axes[i]

)

# Plotando pontos e vetores suporte

axes[i].scatter(X[:, 0], X[:, 1], c=y, edgecolors='k')

axes[i].scatter(svc.support_vectors_[:, 0], svc.support_vectors_[:, 1],

s=100, facecolors='none', edgecolors='red', linewidths=1.5)

axes[i].set_title(f'C = {C}\nVetores Suporte: {len(svc.support_vectors_)}')

plt.tight_layout()

plt.show()

Problemas Multiclasse

Surpreendentemente, o SVC nativamente implementa apenas classificação binária. Para problemas multiclasse, duas estratégias são empregadas:

one-vs-one: Constrói \(\frac{n(n-1)}{2}\) classificadores
one-vs-rest: Constrói n classificadores (um por classe)

Implementação Multiclasse

from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

# Criando problema multiclasse
X_multi, y_multi = make_classification(n_samples=1000, n_features=4, 
                                      n_classes=3, n_informative=3, 
                                      n_redundant=0, random_state=42)

# Comparando estratégias multiclasse
strategies = ['ovr', 'ovo']  # one-vs-rest e one-vs-one

for strategy in strategies:
    svc_multi = SVC(kernel='rbf', decision_function_shape=strategy, random_state=42)
    
    # Validação cruzada
    scores = cross_val_score(svc_multi, X_multi, y_multi, cv=5)
    print(f"Estratégia {strategy}: Acurácia média = {scores.mean():.4f}")

# Treinando modelo final e matriz de confusão
svc_final = SVC(kernel='rbf', decision_function_shape='ovr', random_state=42)
svc_final.fit(X_train, y_train)

# Matriz de confusão
y_pred_multi = svc_final.predict(X_test)
cm = confusion_matrix(y_test, y_pred_multi)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
plt.title('Matriz de Confusão - SVC Multiclasse')
plt.show()

from sklearn.svm import SVC

from sklearn.datasets import make_classification

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

import matplotlib.pyplot as plt

# Criando problema multiclasse

X_multi, y_multi = make_classification(n_samples=1000, n_features=4,

n_classes=3, n_informative=3,

n_redundant=0, random_state=42)

# Comparando estratégias multiclasse

strategies = ['ovr', 'ovo'] # one-vs-rest e one-vs-one

for strategy in strategies:

svc_multi = SVC(kernel='rbf', decision_function_shape=strategy, random_state=42)

# Validação cruzada

scores = cross_val_score(svc_multi, X_multi, y_multi, cv=5)

print(f"Estratégia {strategy}: Acurácia média = {scores.mean():.4f}")

# Treinando modelo final e matriz de confusão

svc_final = SVC(kernel='rbf', decision_function_shape='ovr', random_state=42)

svc_final.fit(X_train, y_train)

# Matriz de confusão

y_pred_multi = svc_final.predict(X_test)

cm = confusion_matrix(y_test, y_pred_multi)

disp = ConfusionMatrixDisplay(confusion_matrix=cm)

disp.plot()

plt.title('Matriz de Confusão - SVC Multiclasse')

plt.show()

Otimização de Hiperparâmetros

Contudo, escolher os parâmetros corretos manualmente pode ser desafiador. Assim, técnicas sistemáticas de otimização são essenciais:

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.datasets import make_classification
import numpy as np

# Criando dataset para tuning
X_tune, y_tune = make_classification(n_samples=1000, n_features=10, random_state=42)

# Busca em Grade para SVC
param_grid = {
    'C': [0.1, 1, 10, 100],
    'kernel': ['linear', 'rbf', 'poly'],
    'gamma': ['scale', 'auto', 0.1, 1, 10],
    'degree': [2, 3, 4]  # Apenas para kernel poly
}

svc = SVC(random_state=42)
grid_search = GridSearchCV(svc, param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid_search.fit(X_tune, y_tune)

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

# Busca aleatória para espaços de parâmetros maiores
param_dist = {
    'C': np.logspace(-3, 3, 10),
    'gamma': np.logspace(-3, 3, 10),
    'kernel': ['rbf', 'linear', 'poly']
}

random_search = RandomizedSearchCV(svc, param_dist, n_iter=50, 
                                  cv=5, scoring='accuracy', 
                                  random_state=42, n_jobs=-1)
random_search.fit(X_tune, y_tune)
print("\nMelhores parâmetros (Randomized):", random_search.best_params_)

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV

from sklearn.svm import SVC

from sklearn.datasets import make_classification

import numpy as np

# Criando dataset para tuning

X_tune, y_tune = make_classification(n_samples=1000, n_features=10, random_state=42)

# Busca em Grade para SVC

param_grid = {

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

'kernel': ['linear', 'rbf', 'poly'],

'gamma': ['scale', 'auto', 0.1, 1, 10],

'degree': [2, 3, 4] # Apenas para kernel poly

}

svc = SVC(random_state=42)

grid_search = GridSearchCV(svc, param_grid, cv=5, scoring='accuracy', n_jobs=-1)

grid_search.fit(X_tune, y_tune)

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

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

# Busca aleatória para espaços de parâmetros maiores

param_dist = {

'C': np.logspace(-3, 3, 10),

'gamma': np.logspace(-3, 3, 10),

'kernel': ['rbf', 'linear', 'poly']

}

random_search = RandomizedSearchCV(svc, param_dist, n_iter=50,

cv=5, scoring='accuracy',

random_state=42, n_jobs=-1)

random_search.fit(X_tune, y_tune)

print("\nMelhores parâmetros (Randomized):", random_search.best_params_)

Considerações de Performance

Inegavelmente, o SVC pode ser computacionalmente intensivo para grandes conjuntos de dados. Então, considere estas estratégias:

Use LinearSVC para problemas lineares em grande escala
Reduza cache_size se memory for limitada
Ajuste tol para trade-off entre precisão e tempo
Considere amostragem para datasets muito grandes

Comparação com LinearSVC

from sklearn.svm import LinearSVC
import time

# Dataset maior para comparação
X_large, y_large = make_classification(n_samples=10000, n_features=20, random_state=42)

# SVC com kernel linear
start_time = time.time()
svc_linear = SVC(kernel='linear', random_state=42)
svc_linear.fit(X_large, y_large)
svc_time = time.time() - start_time

# LinearSVC
start_time = time.time()
linear_svc = LinearSVC(random_state=42)
linear_svc.fit(X_large, y_large)
linear_svc_time = time.time() - start_time

print(f"SVC (linear kernel): {svc_time:.2f} segundos")
print(f"LinearSVC: {linear_svc_time:.2f} segundos")
print(f"LinearSVC é {svc_time/linear_svc_time:.1f}x mais rápido")

# Comparando acurácia
svc_score = svc_linear.score(X_large, y_large)
linear_svc_score = linear_svc.score(X_large, y_large)
print(f"\nSVC Acurácia: {svc_score:.4f}")
print(f"LinearSVC Acurácia: {linear_svc_score:.4f}")

from sklearn.svm import LinearSVC

import time

# Dataset maior para comparação

X_large, y_large = make_classification(n_samples=10000, n_features=20, random_state=42)

# SVC com kernel linear

start_time = time.time()

svc_linear = SVC(kernel='linear', random_state=42)

svc_linear.fit(X_large, y_large)

svc_time = time.time() - start_time

# LinearSVC

start_time = time.time()

linear_svc = LinearSVC(random_state=42)

linear_svc.fit(X_large, y_large)

linear_svc_time = time.time() - start_time

print(f"SVC (linear kernel): {svc_time:.2f} segundos")

print(f"LinearSVC: {linear_svc_time:.2f} segundos")

print(f"LinearSVC é {svc_time/linear_svc_time:.1f}x mais rápido")

# Comparando acurácia

svc_score = svc_linear.score(X_large, y_large)

linear_svc_score = linear_svc.score(X_large, y_large)

print(f"\nSVC Acurácia: {svc_score:.4f}")

print(f"LinearSVC Acurácia: {linear_svc_score:.4f}")

Conclusão e Melhores Práticas

Enfim, o SVC é uma ferramenta poderosa mas que requer entendimento adequado para uso efetivo. Inegavelmente, seu desempenho depende criticamente da escolha correta de kernel e parâmetros.

Afinal, dominar o SVC significa compreender não apenas como usá-lo, mas quando usá-lo. Eventualmente, você desenvolverá intuição para selecionar a configuração ideal para cada problema.

Portanto, pratique com diversos datasets e experimente diferentes configurações. Inclusive para problemas onde outros algoritmos podem falhar, o SVC frequentemente surpreende com sua eficácia.