Arquivo de scikit-learn - Página 2 de 4

Detalhes de implementação: Por trás dos SVMs do Scikit-Learn

19/12/202528/10/2025 Por antonino

Compreendendo a Engenharia por Trás dos Algoritmos SVM

Os 1.4.8. Implementation details revelam as decisões de engenharia e otimizações que tornam os Support Vector Machines do Scikit-Learn eficientes e práticos. Esta seção é crucial para entender o comportamento em tempo de execução, consumo de memória e limitações dos algoritmos implementados.

Bibliotecas Subjacentes: LIBSVM e LIBLINEAR

Primeiramente, o Scikit-Learn não implementa os algoritmos SVM do zero, mas sim utiliza bibliotecas otimizadas em C++. Para a maioria dos casos, emprega-se o LIBSVM, enquanto para problemas lineares em grande escala usa-se o LIBLINEAR.

Características das Bibliotecas

Certamente, cada biblioteca tem suas especialidades:

LIBSVM: Suporte completo para kernels não lineares, multiclasse
LIBLINEAR: Otimizado para problemas lineares em grande escala
Ambas implementam SMO (Sequential Minimal Optimization) como algoritmo base
Suporte a caching de kernel para melhor performance

from sklearn.svm import SVC, LinearSVC
from sklearn.datasets import make_classification
import time

# Comparando implementações para problemas lineares
X, y = make_classification(n_samples=10000, n_features=100, 
                          n_classes=2, random_state=42)

# SVC com kernel linear (usa LIBSVM)
start_time = time.time()
svc_linear = SVC(kernel='linear', random_state=42)
svc_linear.fit(X, y)
libsvm_time = time.time() - start_time

# LinearSVC (usa LIBLINEAR - otimizado para linear)
start_time = time.time()
linear_svc = LinearSVC(random_state=42, max_iter=2000)
linear_svc.fit(X, y)
liblinear_time = time.time() - start_time

print(f"LIBSVM (SVC linear): {libsvm_time:.2f} segundos")
print(f"LIBLINEAR (LinearSVC): {liblinear_time:.2f} segundos")
print(f"LIBLINEAR é {libsvm_time/liblinear_time:.1f}x mais rápido")

# Verificando similaridade nas predições
from sklearn.metrics import accuracy_score
y_pred_libsvm = svc_linear.predict(X)
y_pred_liblinear = linear_svc.predict(X)

print(f"\nAcurácia LIBSVM: {accuracy_score(y, y_pred_libsvm):.4f}")
print(f"Acurácia LIBLINEAR: {accuracy_score(y, y_pred_liblinear):.4f}")
print(f"Concordância entre predições: {accuracy_score(y_pred_libsvm, y_pred_liblinear):.4f}")

from sklearn.svm import SVC, LinearSVC

from sklearn.datasets import make_classification

import time

# Comparando implementações para problemas lineares

X, y = make_classification(n_samples=10000, n_features=100,

n_classes=2, random_state=42)

# SVC com kernel linear (usa LIBSVM)

start_time = time.time()

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

svc_linear.fit(X, y)

libsvm_time = time.time() - start_time

# LinearSVC (usa LIBLINEAR - otimizado para linear)

start_time = time.time()

linear_svc = LinearSVC(random_state=42, max_iter=2000)

linear_svc.fit(X, y)

liblinear_time = time.time() - start_time

print(f"LIBSVM (SVC linear): {libsvm_time:.2f} segundos")

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

print(f"LIBLINEAR é {libsvm_time/liblinear_time:.1f}x mais rápido")

# Verificando similaridade nas predições

from sklearn.metrics import accuracy_score

y_pred_libsvm = svc_linear.predict(X)

y_pred_liblinear = linear_svc.predict(X)

print(f"\nAcurácia LIBSVM: {accuracy_score(y, y_pred_libsvm):.4f}")

print(f"Acurácia LIBLINEAR: {accuracy_score(y, y_pred_liblinear):.4f}")

print(f"Concordância entre predições: {accuracy_score(y_pred_libsvm, y_pred_liblinear):.4f}")

Cache de Kernel e Otimizações de Memória

Conquanto o cálculo da matriz do kernel seja computacionalmente custoso, o Scikit-Learn implementa estratégias inteligentes de caching. O parâmetro cache_size controla o tamanho máximo em MB do cache para a matriz do kernel.

Impacto do Cache Size na Performance

Embora valores maiores de cache possam melhorar performance, decerto existe um trade-off com consumo de memória. Portanto, é importante entender este balanceamento:

import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import make_classification
import time
import psutil
import os

def get_memory_usage():
    """Retorna uso de memória em MB"""
    process = psutil.Process(os.getpid())
    return process.memory_info().rss / 1024 / 1024

# Dataset moderadamente grande
X, y = make_classification(n_samples=2000, n_features=50, random_state=42)

cache_sizes = [50, 100, 200, 500]  # em MB
results = []

initial_memory = get_memory_usage()

for cache_size in cache_sizes:
    start_time = time.time()
    start_memory = get_memory_usage()
    
    svc = SVC(kernel='rbf', cache_size=cache_size, random_state=42)
    svc.fit(X, y)
    
    training_time = time.time() - start_time
    memory_used = get_memory_usage() - start_memory
    
    results.append({
        'cache_size': cache_size,
        'training_time': training_time,
        'memory_used': memory_used,
        'support_vectors': len(svc.support_vectors_)
    })
    
    print(f"Cache: {cache_size}MB | Tempo: {training_time:.2f}s | "
          f"Memória: {memory_used:.1f}MB | VS: {len(svc.support_vectors_)}")

# Análise dos resultados
print(f"\nMemória inicial: {initial_memory:.1f}MB")
best_cache = min(results, key=lambda x: x['training_time'])
print(f"Melhor cache: {best_cache['cache_size']}MB "
      f"(tempo: {best_cache['training_time']:.2f}s)")

import numpy as np

from sklearn.svm import SVC

from sklearn.datasets import make_classification

import time

import psutil

import os

def get_memory_usage():

"""Retorna uso de memória em MB"""

process = psutil.Process(os.getpid())

return process.memory_info().rss / 1024 / 1024

# Dataset moderadamente grande

X, y = make_classification(n_samples=2000, n_features=50, random_state=42)

cache_sizes = [50, 100, 200, 500] # em MB

results = []

initial_memory = get_memory_usage()

for cache_size in cache_sizes:

start_time = time.time()

start_memory = get_memory_usage()

svc = SVC(kernel='rbf', cache_size=cache_size, random_state=42)

svc.fit(X, y)

training_time = time.time() - start_time

memory_used = get_memory_usage() - start_memory

results.append({

'cache_size': cache_size,

'training_time': training_time,

'memory_used': memory_used,

'support_vectors': len(svc.support_vectors_)

})

print(f"Cache: {cache_size}MB | Tempo: {training_time:.2f}s | "

f"Memória: {memory_used:.1f}MB | VS: {len(svc.support_vectors_)}")

# Análise dos resultados

print(f"\nMemória inicial: {initial_memory:.1f}MB")

best_cache = min(results, key=lambda x: x['training_time'])

print(f"Melhor cache: {best_cache['cache_size']}MB "

f"(tempo: {best_cache['training_time']:.2f}s)")

Algoritmo SMO e Critério de Parada

Atualmente, o Sequential Minimal Optimization é o algoritmo preferido para treinar SVMs devido à sua eficiência. O critério de parada é controlado pelo parâmetro tol (tolerância), que determina a precisão da solução.

Entendendo a Tolerância e Número de Iterações

Enquanto valores menores de tol produzem soluções mais precisas, igualmente aumentam o tempo de treinamento. Similarmente, max_iter controla o número máximo de iterações:

from sklearn.svm import SVC
from sklearn.datasets import make_classification
import time
import numpy as np

# Dataset para teste de convergência
X, y = make_classification(n_samples=1000, n_features=10, 
                          n_informative=8, random_state=42)

tolerances = [1e-2, 1e-3, 1e-4, 1e-5]
max_iter_values = [500, 1000, 2000, -1]  # -1 significa sem limite

convergence_results = []

for tol in tolerances:
    for max_iter in max_iter_values:
        start_time = time.time()
        
        try:
            svc = SVC(kernel='rbf', tol=tol, max_iter=max_iter, random_state=42)
            svc.fit(X, y)
            converged = True
        except Exception as e:
            converged = False
            n_iter = "N/A"
        
        training_time = time.time() - start_time
        
        if converged:
            convergence_results.append({
                'tol': tol,
                'max_iter': max_iter,
                'training_time': training_time,
                'n_iter': svc.n_iter_,
                'converged': True
            })
        else:
            convergence_results.append({
                'tol': tol,
                'max_iter': max_iter,
                'training_time': training_time,
                'n_iter': 'Não convergiu',
                'converged': False
            })

# Exibindo resultados
print("Resultados de Convergência:")
print("Tol\tMaxIter\tTempo(s)\tIterações\tConvergiu")
for result in convergence_results:
    print(f"{result['tol']:.0e}\t{result['max_iter']}\t{result['training_time']:.2f}\t"
          f"{result['n_iter']}\t{result['converged']}")

from sklearn.svm import SVC

from sklearn.datasets import make_classification

import time

import numpy as np

# Dataset para teste de convergência

X, y = make_classification(n_samples=1000, n_features=10,

n_informative=8, random_state=42)

tolerances = [1e-2, 1e-3, 1e-4, 1e-5]

max_iter_values = [500, 1000, 2000, -1] # -1 significa sem limite

convergence_results = []

for tol in tolerances:

for max_iter in max_iter_values:

start_time = time.time()

try:

svc = SVC(kernel='rbf', tol=tol, max_iter=max_iter, random_state=42)

svc.fit(X, y)

converged = True

except Exception as e:

converged = False

n_iter = "N/A"

training_time = time.time() - start_time

if converged:

convergence_results.append({

'tol': tol,

'max_iter': max_iter,

'training_time': training_time,

'n_iter': svc.n_iter_,

'converged': True

})

else:

convergence_results.append({

'tol': tol,

'max_iter': max_iter,

'training_time': training_time,

'n_iter': 'Não convergiu',

'converged': False

})

# Exibindo resultados

print("Resultados de Convergência:")

print("Tol\tMaxIter\tTempo(s)\tIterações\tConvergiu")

for result in convergence_results:

print(f"{result['tol']:.0e}\t{result['max_iter']}\t{result['training_time']:.2f}\t"

f"{result['n_iter']}\t{result['converged']}")

Shrinking Heuristic

Surpreendentemente, uma otimização frequentemente ignorada é a shrinking heuristic. Esta técnica identifica e remove variáveis que provavelmente não serão vetores suporte, reduzindo o problema de otimização ao longo do tempo.

Impacto da Shrinking Heuristic

from sklearn.svm import SVC
from sklearn.datasets import make_classification
import time

# Dataset para comparar shrinking
X, y = make_classification(n_samples=2000, n_features=20, random_state=42)

shrinking_options = [True, False]
results_shrinking = []

for shrinking in shrinking_options:
    # Múltiplas execuções para média
    times = []
    n_iters = []
    
    for _ in range(5):  # 5 execuções para estabilidade
        start_time = time.time()
        
        svc = SVC(kernel='rbf', shrinking=shrinking, random_state=42)
        svc.fit(X, y)
        
        times.append(time.time() - start_time)
        n_iters.append(svc.n_iter_)
    
    results_shrinking.append({
        'shrinking': shrinking,
        'mean_time': np.mean(times),
        'std_time': np.std(times),
        'mean_iter': np.mean(n_iters),
        'support_vectors': len(svc.support_vectors_)
    })

print("Comparação Shrinking vs Não-Shrinking:")
for result in results_shrinking:
    status = "COM shrinking" if result['shrinking'] else "SEM shrinking"
    print(f"{status}:")
    print(f"  Tempo médio: {result['mean_time']:.2f} ± {result['std_time']:.2f}s")
    print(f"  Iterações médias: {result['mean_iter']:.1f}")
    print(f"  Vetores suporte: {result['support_vectors']}")
    print()

speedup = (results_shrinking[1]['mean_time'] - results_shrinking[0]['mean_time']) / results_shrinking[1]['mean_time']
print(f"Shrinking proporciona {speedup:.1%} de melhoria no tempo")

from sklearn.svm import SVC

from sklearn.datasets import make_classification

import time

# Dataset para comparar shrinking

X, y = make_classification(n_samples=2000, n_features=20, random_state=42)

shrinking_options = [True, False]

results_shrinking = []

for shrinking in shrinking_options:

# Múltiplas execuções para média

times = []

n_iters = []

for _ in range(5): # 5 execuções para estabilidade

start_time = time.time()

svc = SVC(kernel='rbf', shrinking=shrinking, random_state=42)

svc.fit(X, y)

times.append(time.time() - start_time)

n_iters.append(svc.n_iter_)

results_shrinking.append({

'shrinking': shrinking,

'mean_time': np.mean(times),

'std_time': np.std(times),

'mean_iter': np.mean(n_iters),

'support_vectors': len(svc.support_vectors_)

})

print("Comparação Shrinking vs Não-Shrinking:")

for result in results_shrinking:

status = "COM shrinking" if result['shrinking'] else "SEM shrinking"

print(f"{status}:")

print(f" Tempo médio: {result['mean_time']:.2f} ± {result['std_time']:.2f}s")

print(f" Iterações médias: {result['mean_iter']:.1f}")

print(f" Vetores suporte: {result['support_vectors']}")

print()

speedup = (results_shrinking[1]['mean_time'] - results_shrinking[0]['mean_time']) / results_shrinking[1]['mean_time']

print(f"Shrinking proporciona {speedup:.1%} de melhoria no tempo")

Tratamento de Dados Esparsos

Contudo, dados esparsos requerem considerações especiais. O Scikit-Learn detecta automaticamente matrizes esparsas e utiliza rotas de computação otimizadas:

from sklearn.svm import SVC
from sklearn.datasets import make_classification
from scipy import sparse
import time
import numpy as np

# Criando dados densos e esparsos equivalentes
X_dense, y = make_classification(n_samples=1000, n_features=100, 
                                n_informative=20, random_state=42)

# Convertendo para formato esparso (simulando dados textuais)
X_sparse = sparse.csr_matrix(X_dense)

# Comparando performance
formats = ['Denso', 'Esparso']
datasets = [X_dense, X_sparse]

results_sparse = []

for format_name, X_data in zip(formats, datasets):
    start_time = time.time()
    memory_before = get_memory_usage()
    
    svc = SVC(kernel='linear', random_state=42)
    svc.fit(X_data, y)
    
    training_time = time.time() - start_time
    memory_after = get_memory_usage()
    
    results_sparse.append({
        'format': format_name,
        'training_time': training_time,
        'memory_used': memory_after - memory_before,
        'sparsity': f"{(1 - (X_data.nnz / (X_data.shape[0] * X_data.shape[1]))):.1%}" 
                    if sparse.issparse(X_data) else "0%"
    })

print("Comparação Denso vs Esparso:")
for result in results_sparse:
    print(f"Formato: {result['format']}")
    print(f"  Tempo: {result['training_time']:.2f}s")
    print(f"  Memória: {result['memory_used']:.1f}MB")
    print(f"  Esparsidade: {result['sparsity']}")
    print()

from sklearn.svm import SVC

from sklearn.datasets import make_classification

from scipy import sparse

import time

import numpy as np

# Criando dados densos e esparsos equivalentes

X_dense, y = make_classification(n_samples=1000, n_features=100,

n_informative=20, random_state=42)

# Convertendo para formato esparso (simulando dados textuais)

X_sparse = sparse.csr_matrix(X_dense)

# Comparando performance

formats = ['Denso', 'Esparso']

datasets = [X_dense, X_sparse]

results_sparse = []

for format_name, X_data in zip(formats, datasets):

start_time = time.time()

memory_before = get_memory_usage()

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

svc.fit(X_data, y)

training_time = time.time() - start_time

memory_after = get_memory_usage()

results_sparse.append({

'format': format_name,

'training_time': training_time,

'memory_used': memory_after - memory_before,

'sparsity': f"{(1 - (X_data.nnz / (X_data.shape[0] * X_data.shape[1]))):.1%}"

if sparse.issparse(X_data) else "0%"

})

print("Comparação Denso vs Esparso:")

for result in results_sparse:

print(f"Formato: {result['format']}")

print(f" Tempo: {result['training_time']:.2f}s")

print(f" Memória: {result['memory_used']:.1f}MB")

print(f" Esparsidade: {result['sparsity']}")

print()

Parallelização e Uso de Múltiplos Núcleos

Inegavelmente, a parallelização é crucial para performance. Entretanto, diferente de outros algoritmos no Scikit-Learn, os SVMs têm limitações específicas:

LIBSVM não é paralelizado internamente
Parallelização ocorre no nível do GridSearchCV ou cross-validation
O parâmetro n_jobs não está disponível diretamente nos estimadores SVM

Estratégias de Parallelização Eficiente

from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.datasets import make_classification
import time
import joblib

# Dataset para testes de parallelização
X_parallel, y_parallel = make_classification(n_samples=2000, n_features=20, 
                                            random_state=42)

# Estratégia 1: GridSearchCV com n_jobs
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': [0.001, 0.01, 0.1, 1]
}

print("Comparando estratégias de parallelização:")

# Sem parallelização
start_time = time.time()
grid_search_single = GridSearchCV(SVC(kernel='rbf'), param_grid, cv=5, 
                                 n_jobs=1, verbose=0)
grid_search_single.fit(X_parallel, y_parallel)
single_time = time.time() - start_time

# Com parallelização
start_time = time.time()
grid_search_parallel = GridSearchCV(SVC(kernel='rbf'), param_grid, cv=5, 
                                   n_jobs=-1, verbose=0)
grid_search_parallel.fit(X_parallel, y_parallel)
parallel_time = time.time() - start_time

print(f"Tempo sem parallelização: {single_time:.2f}s")
print(f"Tempo com parallelização: {parallel_time:.2f}s")
print(f"Speedup: {single_time/parallel_time:.1f}x")

# Estratégia 2: cross_val_score com parallelização
print(f"\nCross-validation paralelizada:")
with joblib.parallel_backend('threading', n_jobs=-1):
    start_time = time.time()
    scores_parallel = cross_val_score(SVC(kernel='rbf'), X_parallel, y_parallel, 
                                     cv=5, n_jobs=-1)
    cv_parallel_time = time.time() - start_time

start_time = time.time()
scores_single = cross_val_score(SVC(kernel='rbf'), X_parallel, y_parallel, 
                               cv=5, n_jobs=1)
cv_single_time = time.time() - start_time

print(f"CV tempo single: {cv_single_time:.2f}s")
print(f"CV tempo parallel: {cv_parallel_time:.2f}s")
print(f"CV speedup: {cv_single_time/cv_parallel_time:.1f}x")

from sklearn.svm import SVC

from sklearn.model_selection import GridSearchCV, cross_val_score

from sklearn.datasets import make_classification

import time

import joblib

# Dataset para testes de parallelização

X_parallel, y_parallel = make_classification(n_samples=2000, n_features=20,

random_state=42)

# Estratégia 1: GridSearchCV com n_jobs

param_grid = {

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

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

}

print("Comparando estratégias de parallelização:")

# Sem parallelização

start_time = time.time()

grid_search_single = GridSearchCV(SVC(kernel='rbf'), param_grid, cv=5,

n_jobs=1, verbose=0)

grid_search_single.fit(X_parallel, y_parallel)

single_time = time.time() - start_time

# Com parallelização

start_time = time.time()

grid_search_parallel = GridSearchCV(SVC(kernel='rbf'), param_grid, cv=5,

n_jobs=-1, verbose=0)

grid_search_parallel.fit(X_parallel, y_parallel)

parallel_time = time.time() - start_time

print(f"Tempo sem parallelização: {single_time:.2f}s")

print(f"Tempo com parallelização: {parallel_time:.2f}s")

print(f"Speedup: {single_time/parallel_time:.1f}x")

# Estratégia 2: cross_val_score com parallelização

print(f"\nCross-validation paralelizada:")

with joblib.parallel_backend('threading', n_jobs=-1):

start_time = time.time()

scores_parallel = cross_val_score(SVC(kernel='rbf'), X_parallel, y_parallel,

cv=5, n_jobs=-1)

cv_parallel_time = time.time() - start_time

start_time = time.time()

scores_single = cross_val_score(SVC(kernel='rbf'), X_parallel, y_parallel,

cv=5, n_jobs=1)

cv_single_time = time.time() - start_time

print(f"CV tempo single: {cv_single_time:.2f}s")

print(f"CV tempo parallel: {cv_parallel_time:.2f}s")

print(f"CV speedup: {cv_single_time/cv_parallel_time:.1f}x")

Limitações e Considerações de Escalabilidade

Embora otimizados, os SVMs do Scikit-Learn têm limitações práticas importantes:

Complexidade de memória: O(n²) para matrizes de kernel completas
Complexidade computacional: O(n³) no pior caso
Limitações com datasets muito grandes (>100,000 amostras)
Requer normalização prévia para melhor performance

Estratégias para Datasets Grandes

from sklearn.svm import LinearSVC, SVC
from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification
import time

# Simulando dataset grande
X_large, y_large = make_classification(n_samples=50000, n_features=50, 
                                      random_state=42)

strategies = [
    ('LinearSVC', LinearSVC(random_state=42, max_iter=1000)),
    ('SVC linear', SVC(kernel='linear', random_state=42)),
    ('SGDClassifier', SGDClassifier(loss='hinge', random_state=42, max_iter=1000))
]

print("Estratégias para datasets grandes:")
for name, model in strategies:
    start_time = time.time()
    
    try:
        model.fit(X_large, y_large)
        training_time = time.time() - start_time
        accuracy = model.score(X_large, y_large)
        print(f"{name}: {training_time:.2f}s, Acurácia: {accuracy:.4f}")
    except Exception as e:
        print(f"{name}: Falhou - {e}")

# Para problemas não lineares em grande escala
print(f"\nAlternativas para não-linear em grande escala:")
print("- Kernel Approximation (Nystroem, RBFSampler)")
print("- Ensemble methods com SVMs base")
print("- Amostragem estratégica dos dados")
print("- Uso de GPUs com implementações especializadas")

from sklearn.svm import LinearSVC, SVC

from sklearn.linear_model import SGDClassifier

from sklearn.datasets import make_classification

import time

# Simulando dataset grande

X_large, y_large = make_classification(n_samples=50000, n_features=50,

random_state=42)

strategies = [

('LinearSVC', LinearSVC(random_state=42, max_iter=1000)),

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

('SGDClassifier', SGDClassifier(loss='hinge', random_state=42, max_iter=1000))

]

print("Estratégias para datasets grandes:")

for name, model in strategies:

start_time = time.time()

try:

model.fit(X_large, y_large)

training_time = time.time() - start_time

accuracy = model.score(X_large, y_large)

print(f"{name}: {training_time:.2f}s, Acurácia: {accuracy:.4f}")

except Exception as e:

print(f"{name}: Falhou - {e}")

# Para problemas não lineares em grande escala

print(f"\nAlternativas para não-linear em grande escala:")

print("- Kernel Approximation (Nystroem, RBFSampler)")

print("- Ensemble methods com SVMs base")

print("- Amostragem estratégica dos dados")

print("- Uso de GPUs com implementações especializadas")

Conclusão e Melhores Práticas de Implementação

Enfim, entender os detalhes de implementação é crucial para usar SVMs efetivamente no Scikit-Learn. Inegavelmente, as escolhas de engenharia feitas pela biblioteca representam compromissos cuidadosos entre precisão, performance e usabilidade.

Afinal, o conhecimento desses detalhes permite tomar decisões informadas sobre configurações de parâmetros, seleção de algoritmos e estratégias de otimização. Eventualmente, este entendimento profundo separa usuários básicos de praticantes avançados.

Portanto, considere sempre as características específicas do seu problema ao configurar SVMs. Inclusive para situações onde otimizações específicas podem fazer a diferença entre sucesso e fracasso prático.

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.