Arquivo de Aprendizado de Máquina - Página 3 de 12

Critério de parada: sabendo quando seu modelo já aprendeu o suficiente

19/12/202528/10/2025 Por antonino

Quando parar de treinar é tão importante quanto começar

Imagine que você está ensinando alguém a andar de bicicleta. No início, cada correção faz uma diferença enorme – ajustar o guidão, mostrar como pedalar. Mas chega um momento em que mais instruções não vão melhorar significativamente o desempenho. No machine learning, o critério de parada do SGD funciona exatamente assim – ele sabe quando parar de “ensinar” o modelo porque os ajustes deixaram de fazer diferença prática.

Como o algoritmo sabe que já aprendeu o suficiente?

Você deve estar se perguntando: “como o SGD decide que já treinou o suficiente?” É uma pergunta excelente! O segredo está em monitorar a melhoria do modelo a cada iteração. Se a melhoria fica menor que um determinado limiar por várias iterações consecutivas, o algoritmo entende que chegou num ponto onde continuar não trará benefícios significativos.

Matematicamente, o critério é baseado na norma do gradiente ou na mudança na função custo. Quando a melhoria fica abaixo de uma tolerância tol:

\(\frac{|f(w_{t}) – f(w_{t-1})|}{max(|f(w_{t})|, |f(w_{t-1})|, 1)} \leq tol\)

O algoritmo para. É como estacionar um carro: quando você está suficientemente perto da vaga, para em vez de tentar chegar milimetricamente perfeito.

Mãos na massa: visualizando a convergência

Vamos ver na prática como diferentes critérios de parada afetam o treinamento:

from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np

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

# Testando diferentes tolerâncias
tolerances = [1e-1, 1e-2, 1e-3, 1e-4]
results = []

for tol in tolerances:
    classifier = SGDClassifier(
        tol=tol,
        max_iter=1000,
        random_state=42
    )
    
    # Treinando e coletando métricas
    classifier.fit(X_train, y_train)
    
    train_score = classifier.score(X_train, y_train)
    test_score = classifier.score(X_test, y_test)
    
    results.append({
        'tol': tol,
        'iterations': classifier.n_iter_,
        'train_score': train_score,
        'test_score': test_score
    })
    
    print(f"Tol: {tol:.0e} | Iterações: {classifier.n_iter_} | "
          f"Train: {train_score:.3f} | Test: {test_score:.3f}")

# Encontrando o ponto ideal
best_tol = min(results, key=lambda x: x['iterations'] if x['test_score'] > 0.85 else float('inf'))
print(f"\nMelhor compromisso: tol={best_tol['tol']:.0e} "
      f"({best_tol['iterations']} iterações, {best_tol['test_score']:.3f} acurácia)")

from sklearn.linear_model import SGDClassifier

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt

import numpy as np

# Criando dados de exemplo

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

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

# Testando diferentes tolerâncias

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

results = []

for tol in tolerances:

classifier = SGDClassifier(

tol=tol,

max_iter=1000,

random_state=42

)

# Treinando e coletando métricas

classifier.fit(X_train, y_train)

train_score = classifier.score(X_train, y_train)

test_score = classifier.score(X_test, y_test)

results.append({

'tol': tol,

'iterations': classifier.n_iter_,

'train_score': train_score,

'test_score': test_score

})

print(f"Tol: {tol:.0e} | Iterações: {classifier.n_iter_} | "

f"Train: {train_score:.3f} | Test: {test_score:.3f}")

# Encontrando o ponto ideal

best_tol = min(results, key=lambda x: x['iterations'] if x['test_score'] > 0.85 else float('inf'))

print(f"\nMelhor compromisso: tol={best_tol['tol']:.0e} "

f"({best_tol['iterations']} iterações, {best_tol['test_score']:.3f} acurácia)")

Os três pilares do critério de parada inteligente

O SGD no scikit-learn usa uma combinação de três estratégias para decidir quando parar:

Tolerância (tol): a melhoria mínima necessária para continuar treinando
Número máximo de iterações (max_iter): limite absoluto para prevenir loops infinitos
Número máximo de épocas sem melhoria: para se não houver progresso por um certo período

Comparando estratégias de parada

Vamos ver como diferentes configurações afetam o tempo de treinamento e a qualidade do modelo:

import time
from sklearn.linear_model import SGDClassifier

# Configurações para testar
configs = [
    {'tol': 1e-1, 'max_iter': 1000, 'name': 'Parada rápida'},
    {'tol': 1e-3, 'max_iter': 1000, 'name': 'Padrão'},
    {'tol': 1e-5, 'max_iter': 1000, 'name': 'Preciso'},
    {'tol': 1e-7, 'max_iter': 1000, 'name': 'Super preciso'}
]

performance_data = []

for config in configs:
    start_time = time.time()
    
    classifier = SGDClassifier(
        tol=config['tol'],
        max_iter=config['max_iter'],
        random_state=42
    )
    
    classifier.fit(X_train, y_train)
    training_time = time.time() - start_time
    
    train_score = classifier.score(X_train, y_train)
    test_score = classifier.score(X_test, y_test)
    
    performance_data.append({
        'name': config['name'],
        'tol': config['tol'],
        'iterations': classifier.n_iter_,
        'time': training_time,
        'train_score': train_score,
        'test_score': test_score
    })

# Mostrando resultados
for data in performance_data:
    print(f"{data['name']:15} | Tol: {data['tol']:.0e} | "
          f"Iters: {data['iterations']:3d} | Time: {data['time']:.3f}s | "
          f"Test: {data['test_score']:.3f}")

# Encontrando o melhor trade-off
best_tradeoff = max(performance_data, 
                   key=lambda x: x['test_score'] / x['time'] if x['time'] > 0 else 0)
print(f"\nMelhor custo-benefício: {best_tradeoff['name']}")

import time

from sklearn.linear_model import SGDClassifier

# Configurações para testar

configs = [

{'tol': 1e-1, 'max_iter': 1000, 'name': 'Parada rápida'},

{'tol': 1e-3, 'max_iter': 1000, 'name': 'Padrão'},

{'tol': 1e-5, 'max_iter': 1000, 'name': 'Preciso'},

{'tol': 1e-7, 'max_iter': 1000, 'name': 'Super preciso'}

]

performance_data = []

for config in configs:

start_time = time.time()

classifier = SGDClassifier(

tol=config['tol'],

max_iter=config['max_iter'],

random_state=42

)

classifier.fit(X_train, y_train)

training_time = time.time() - start_time

train_score = classifier.score(X_train, y_train)

test_score = classifier.score(X_test, y_test)

performance_data.append({

'name': config['name'],

'tol': config['tol'],

'iterations': classifier.n_iter_,

'time': training_time,

'train_score': train_score,

'test_score': test_score

})

# Mostrando resultados

for data in performance_data:

print(f"{data['name']:15} | Tol: {data['tol']:.0e} | "

f"Iters: {data['iterations']:3d} | Time: {data['time']:.3f}s | "

f"Test: {data['test_score']:.3f}")

# Encontrando o melhor trade-off

best_tradeoff = max(performance_data,

key=lambda x: x['test_score'] / x['time'] if x['time'] > 0 else 0)

print(f"\nMelhor custo-benefício: {best_tradeoff['name']}")

Os segredos que eu gostaria de ter sabido antes

Quando comecei com SGD, gastei muito tempo ajustando critérios de parada desnecessariamente. Aqui estão minhas lições:

tol=1e-3 é um bom ponto de partida: funciona bem para a maioria dos problemas
max_iter deve ser suficientemente alto: pelo menos 1000, mas raramente precisa ser maior que 10000
Monitore overfitting: se a acurácia de treino continua subindo mas a de teste estagna, você já passou do ponto ideal
Use early stopping: em problemas com dados de validação, parar quando a validação para de melhorar

Quando parar mais cedo (e quando esperar mais)

O critério ideal depende do seu contexto:

# Cenário 1: desenvolvimento rápido - tolerância mais relaxada
dev_classifier = SGDClassifier(tol=1e-2, max_iter=500, random_state=42)
dev_classifier.fit(X_train, y_train)
print(f"Desenvolvimento: {dev_classifier.n_iter_} iterações")

# Cenário 2: produção - busca por máxima performance
prod_classifier = SGDClassifier(tol=1e-4, max_iter=2000, random_state=42)
prod_classifier.fit(X_train, y_train)
print(f"Produção: {prod_classifier.n_iter_} iterações")

# Cenário 3: dados muito ruidosos - parada mais conservadora
noisy_classifier = SGDClassifier(tol=1e-2, max_iter=1000, random_state=42)
# Dados ruidosos beneficiam de parada mais cedo para evitar overfitting

# Cenário 1: desenvolvimento rápido - tolerância mais relaxada

dev_classifier = SGDClassifier(tol=1e-2, max_iter=500, random_state=42)

dev_classifier.fit(X_train, y_train)

print(f"Desenvolvimento: {dev_classifier.n_iter_} iterações")

# Cenário 2: produção - busca por máxima performance

prod_classifier = SGDClassifier(tol=1e-4, max_iter=2000, random_state=42)

prod_classifier.fit(X_train, y_train)

print(f"Produção: {prod_classifier.n_iter_} iterações")

# Cenário 3: dados muito ruidosos - parada mais conservadora

noisy_classifier = SGDClassifier(tol=1e-2, max_iter=1000, random_state=42)

# Dados ruidosos beneficiam de parada mais cedo para evitar overfitting

Escolha sua estratégia baseada em:

Velocidade vs precisão: desenvolvimento vs produção
Complexidade do problema: problemas simples convergem mais rápido
Qualidade dos dados: dados ruidosos precisam de parada mais conservadora
Recursos computacionais: hardware limitado pode precisar de tolerâncias mais altas

Perguntas que todo iniciante faz sobre critério de parada

“Meu modelo para muito cedo – o que fazer?”
Diminua a tolerância (valores menores de tol) ou aumente max_iter. Também verifique se o learning_rate não está muito alto.

“O modelo não para nunca – é normal?”
Pode indicar que o learning_rate está muito baixo ou os dados são muito complexos. Aumente tol ou defina um max_iter razoável.

“Como escolher o tol certo?”
Comece com 1e-3. Se parar muito cedo, tente 1e-4. Se demorar muito, tente 1e-2.

“Devo usar early stopping com validação?”
Sim! É especialmente útil para evitar overfitting. Use um conjunto de validação separado.

Implementando early stopping personalizado

Às vezes você quer mais controle sobre quando parar. Veja como implementar early stopping customizado:

from sklearn.base import clone
import numpy as np

class CustomEarlyStopping:
    def __init__(self, patience=5, min_delta=1e-4):
        self.patience = patience
        self.min_delta = min_delta
        self.best_loss = np.inf
        self.wait = 0
        
    def should_stop(self, current_loss):
        if current_loss < self.best_loss - self.min_delta:
            self.best_loss = current_loss
            self.wait = 0
            return False
        else:
            self.wait += 1
            return self.wait >= self.patience

# Usando early stopping customizado
X_train_main, X_val, y_train_main, y_val = train_test_split(
    X_train, y_train, test_size=0.2, random_state=42
)

classifier_custom = SGDClassifier(max_iter=10000, random_state=42)
early_stopping = CustomEarlyStopping(patience=3, min_delta=1e-4)

# Treinamento com early stopping manual
for epoch in range(1000):
    classifier_custom.partial_fit(X_train_main, y_train_main, classes=np.unique(y))
    
    # Calcular loss no conjunto de validação
    val_score = classifier_custom.score(X_val, y_val)
    val_loss = 1 - val_score  # Simulando loss
    
    if early_stopping.should_stop(val_loss):
        print(f"Early stopping na época {epoch}")
        break

print(f"Treinamento parou após {epoch} épocas")
print(f"Melhor loss de validação: {early_stopping.best_loss:.4f}")

from sklearn.base import clone

import numpy as np

class CustomEarlyStopping:

def __init__(self, patience=5, min_delta=1e-4):

self.patience = patience

self.min_delta = min_delta

self.best_loss = np.inf

self.wait = 0

def should_stop(self, current_loss):

if current_loss < self.best_loss - self.min_delta:

self.best_loss = current_loss

self.wait = 0

return False

else:

self.wait += 1

return self.wait >= self.patience

# Usando early stopping customizado

X_train_main, X_val, y_train_main, y_val = train_test_split(

X_train, y_train, test_size=0.2, random_state=42

)

classifier_custom = SGDClassifier(max_iter=10000, random_state=42)

early_stopping = CustomEarlyStopping(patience=3, min_delta=1e-4)

# Treinamento com early stopping manual

for epoch in range(1000):

classifier_custom.partial_fit(X_train_main, y_train_main, classes=np.unique(y))

# Calcular loss no conjunto de validação

val_score = classifier_custom.score(X_val, y_val)

val_loss = 1 - val_score # Simulando loss

if early_stopping.should_stop(val_loss):

print(f"Early stopping na época {epoch}")

break

print(f"Treinamento parou após {epoch} épocas")

print(f"Melhor loss de validação: {early_stopping.best_loss:.4f}")

Próximos passos para otimizar seu treinamento

Agora que você domina os critérios de parada, aqui estão algumas otimizações avançadas:

Experimente learning_rate adaptativo: ‘invscaling’ ajusta automaticamente a taxa baseado no progresso
Use callbacks personalizados: para salvar checkpoints ou logging detalhado
Implemente learning rate scheduling: reduza a taxa quando a melhoria estagnar
Monitore múltiplas métricas: acurácia, loss, e outras métricas relevantes para seu problema

Assuntos relacionados para aprofundar

Para entender completamente critérios de parada, esses conceitos são essenciais:

Análise de convergência: taxas de convergência, condições de otimalidade
Otimização convexa: condições de Karush-Kuhn-Tucker (KKT), pontos estacionários
Teoria de aproximação: erro de aproximação, trade-off viés-variância
Análise numérica: estabilidade numérica, precisão de máquina
Estatística: testes de hipótese, significância estatística
Complexidade computacional: análise assintótica, limites de tempo de execução
Learning theory: generalização, overfitting, capacidade de modelo

Referências que valem a pena

Lembre-se: saber quando parar é uma habilidade tão importante quanto saber começar. Um bom critério de parada pode economizar horas de treinamento desnecessário enquanto mantém a qualidade do seu modelo!

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.