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

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!

Indice