Arquivo de Python - Página 33 de 93

SGD: o motor por trás do aprendizado em larga escala

19/12/202528/10/2025 Por antonino

Quando seus dados são grandes demais para métodos tradicionais

Imagine que você precisa analisar milhões de transações de cartão de crédito para detectar fraudes, ou processar milhares de reviews de produtos para entender o sentimento dos clientes. Métodos tradicionais de machine learning simplesmente travam com essa quantidade de dados. É aqui que o Stochastic Gradient Descent (SGD) se torna seu herói – ele permite treinar modelos com quantidades massivas de dados processando apenas pequenos pedaços de cada vez, como alguém que lê um livro gigante uma página por dia.

Como o SGD consegue aprender sem ver todos os dados?

Você deve estar se perguntando: “como é possível um modelo aprender corretamente se só vê pequenas partes dos dados por vez?” É uma dúvida completamente natural! Pense em como você aprendeu a reconhecer animais. Você não precisou ver todos os gatos do mundo – viu alguns exemplos, depois mais alguns, e gradualmente desenvolveu a capacidade de reconhecer gatos. O SGD faz exatamente isso, mas de forma matemática e sistemática.

A ideia central é surpreendentemente simples: em vez de calcular o erro usando todos os dados (o que seria muito lento), usamos apenas uma amostra ou um pequeno lote:

\(w_{t+1} = w_t – \eta \nabla Q_i(w_t)\)

onde w_t são os pesos no tempo t, η é a taxa de aprendizado, e ∇Q_i(w_t) é o gradiente para a amostra i. É como ajustar gradualmente uma receita provando pequenas porções em vez de comer o prato inteiro a cada ajuste.

Mãos na massa: seu primeiro classificador com SGD

Vamos criar um sistema para classificar emails como spam ou não spam, um problema perfeito para o SGD:

from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, classification_report
import numpy as np

# Simulando dados de emails: características como comprimento, palavras-chave, etc.
# Na prática, isso seria extraído de emails reais
X, y = make_classification(
    n_samples=10000,           # 10,000 emails
    n_features=20,             # 20 características por email
    n_classes=2,               # spam ou não spam
    n_informative=15,          # 15 características realmente úteis
    n_redundant=5,             # 5 características redundantes
    random_state=42
)

# Dividindo em treino e teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# DICA CRUCIAL: sempre normalize os dados para SGD
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Criando nosso detector de spam
spam_detector = SGDClassifier(
    loss='log',                # Regressão logística - ótima para probabilidades
    penalty='l2',              # Regularização para evitar overfitting
    alpha=0.0001,              # Força da regularização
    max_iter=1000,             # Máximo de iterações
    tol=1e-3,                  # Tolerância para parada
    learning_rate='optimal',   # Taxa de aprendizado adaptativa
    random_state=42            # Para resultados reproduzíveis
)

# Treinamento - rápido mesmo com 10,000 exemplos!
print("Treinando o detector de spam...")
spam_detector.fit(X_train_scaled, y_train)

# Fazendo previsões
y_pred = spam_detector.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)

print(f"\nResultados:")
print(f"Acurácia: {accuracy:.1%}")
print(f"Número de iterações: {spam_detector.n_iter_}")
print(f"Número de coeficientes não-zero: {np.sum(spam_detector.coef_ != 0)}")

# Relatório detalhado
print(f"\nRelatório de classificação:")
print(classification_report(y_test, y_pred, target_names=['Não spam', 'Spam']))

from sklearn.linear_model import SGDClassifier

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score, classification_report

import numpy as np

# Simulando dados de emails: características como comprimento, palavras-chave, etc.

# Na prática, isso seria extraído de emails reais

X, y = make_classification(

n_samples=10000, # 10,000 emails

n_features=20, # 20 características por email

n_classes=2, # spam ou não spam

n_informative=15, # 15 características realmente úteis

n_redundant=5, # 5 características redundantes

random_state=42

)

# Dividindo em treino e teste

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.3, random_state=42

)

# DICA CRUCIAL: sempre normalize os dados para SGD

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Criando nosso detector de spam

spam_detector = SGDClassifier(

loss='log', # Regressão logística - ótima para probabilidades

penalty='l2', # Regularização para evitar overfitting

alpha=0.0001, # Força da regularização

max_iter=1000, # Máximo de iterações

tol=1e-3, # Tolerância para parada

learning_rate='optimal', # Taxa de aprendizado adaptativa

random_state=42 # Para resultados reproduzíveis

)

# Treinamento - rápido mesmo com 10,000 exemplos!

print("Treinando o detector de spam...")

spam_detector.fit(X_train_scaled, y_train)

# Fazendo previsões

y_pred = spam_detector.predict(X_test_scaled)

accuracy = accuracy_score(y_test, y_pred)

print(f"\nResultados:")

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

print(f"Número de iterações: {spam_detector.n_iter_}")

print(f"Número de coeficientes não-zero: {np.sum(spam_detector.coef_ != 0)}")

# Relatório detalhado

print(f"\nRelatório de classificação:")

print(classification_report(y_test, y_pred, target_names=['Não spam', 'Spam']))

Por que o SGD é tão eficiente?

O segredo da eficiência do SGD está em suas características únicas:

Processamento incremental: não precisa carregar todos os dados na memória de uma vez
Convergência rápida inicial: faz progresso significativo nas primeiras iterações
Escapando de mínimos locais: a natureza estocástica ajuda a evitar ficar preso em soluções ruins
Eficiência com dados esparsos: ideal para texto e sistemas de recomendação

Comparando SGD com métodos tradicionais

Vamos ver na prática as diferenças de performance:

import time
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC

# Dataset maior para comparação justa
X_large, y_large = make_classification(
    n_samples=50000, n_features=30, random_state=42
)

X_train_large, X_test_large, y_train_large, y_test_large = train_test_split(
    X_large, y_large, test_size=0.2, random_state=42
)

# Normalizando
scaler_large = StandardScaler()
X_train_large_scaled = scaler_large.fit_transform(X_train_large)
X_test_large_scaled = scaler_large.transform(X_test_large)

models = {
    'SGDClassifier': SGDClassifier(max_iter=1000, random_state=42),
    'LogisticRegression': LogisticRegression(max_iter=1000, random_state=42),
    'LinearSVC': LinearSVC(max_iter=1000, random_state=42)
}

results = []

for name, model in models.items():
    print(f"Treinando {name}...")
    start_time = time.time()
    
    model.fit(X_train_large_scaled, y_train_large)
    training_time = time.time() - start_time
    
    accuracy = model.score(X_test_large_scaled, y_test_large)
    
    results.append({
        'model': name,
        'training_time': training_time,
        'accuracy': accuracy
    })
    
    print(f"  Tempo: {training_time:.2f}s")
    print(f"  Acurácia: {accuracy:.3f}")

# Mostrando comparação
print(f"\nComparação final:")
for result in results:
    print(f"{result['model']:20} | {result['training_time']:6.2f}s | {result['accuracy']:.3f}")

# Encontrando o mais rápido com boa acurácia
fast_accurate = min(results, key=lambda x: x['training_time'] if x['accuracy'] > 0.85 else float('inf'))
print(f"\nMais rápido com boa acurácia: {fast_accurate['model']}")

import time

from sklearn.linear_model import LogisticRegression

from sklearn.svm import LinearSVC

# Dataset maior para comparação justa

X_large, y_large = make_classification(

n_samples=50000, n_features=30, random_state=42

)

X_train_large, X_test_large, y_train_large, y_test_large = train_test_split(

X_large, y_large, test_size=0.2, random_state=42

)

# Normalizando

scaler_large = StandardScaler()

X_train_large_scaled = scaler_large.fit_transform(X_train_large)

X_test_large_scaled = scaler_large.transform(X_test_large)

models = {

'SGDClassifier': SGDClassifier(max_iter=1000, random_state=42),

'LogisticRegression': LogisticRegression(max_iter=1000, random_state=42),

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

}

results = []

for name, model in models.items():

print(f"Treinando {name}...")

start_time = time.time()

model.fit(X_train_large_scaled, y_train_large)

training_time = time.time() - start_time

accuracy = model.score(X_test_large_scaled, y_test_large)

results.append({

'model': name,

'training_time': training_time,

'accuracy': accuracy

})

print(f" Tempo: {training_time:.2f}s")

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

# Mostrando comparação

print(f"\nComparação final:")

for result in results:

print(f"{result['model']:20} | {result['training_time']:6.2f}s | {result['accuracy']:.3f}")

# Encontrando o mais rápido com boa acurácia

fast_accurate = min(results, key=lambda x: x['training_time'] if x['accuracy'] > 0.85 else float('inf'))

print(f"\nMais rápido com boa acurácia: {fast_accurate['model']}")

Configurações que fazem toda a diferença

Depois de implementar muitos modelos com SGD, aprendi que estas configurações são cruciais:

loss=’hinge’: para SVM linear – cria margens largas entre classes
loss=’log’: para regressão logística – ótima para probabilidades
penalty=’l1′: para seleção de features – cria coeficientes esparsos
penalty=’l2′: padrão – funciona bem na maioria dos casos
learning_rate=’optimal’: adapta automaticamente – melhor para iniciantes
alpha=0.0001: bom valor inicial para regularização

Escolhendo a função de perda certa

Cada função de perda tem um propósito específico. Vamos explorar as opções:

from sklearn.linear_model import SGDClassifier
import matplotlib.pyplot as plt

# Dados de exemplo com diferentes características
X_simple, y_simple = make_classification(
    n_samples=1000, n_features=2, n_classes=2, 
    n_redundant=0, n_clusters_per_class=1, random_state=42
)

loss_functions = ['hinge', 'log', 'modified_huber', 'perceptron']
results_loss = []

for loss in loss_functions:
    classifier = SGDClassifier(
        loss=loss,
        max_iter=1000,
        random_state=42
    )
    
    classifier.fit(X_simple, y_simple)
    accuracy = classifier.score(X_simple, y_simple)
    
    results_loss.append({
        'loss': loss,
        'accuracy': accuracy,
        'n_iter': classifier.n_iter_,
        'coef_norm': np.linalg.norm(classifier.coef_)
    })

# Mostrando resultados
print("Comparação de funções de perda:")
for result in results_loss:
    print(f"{result['loss']:15} | Acurácia: {result['accuracy']:.3f} | "
          f"Iterações: {result['n_iter']} | Norma: {result['coef_norm']:.3f}")

# Visualizando as fronteiras de decisão
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
axes = axes.ravel()

for idx, loss in enumerate(loss_functions):
    classifier = SGDClassifier(loss=loss, max_iter=1000, random_state=42)
    classifier.fit(X_simple, y_simple)
    
    # Plotando pontos
    axes[idx].scatter(X_simple[:, 0], X_simple[:, 1], c=y_simple, cmap='bwr', alpha=0.6)
    
    # Criando grid para fronteira de decisão
    xx, yy = np.meshgrid(
        np.linspace(X_simple[:, 0].min()-0.5, X_simple[:, 0].max()+0.5, 50),
        np.linspace(X_simple[:, 1].min()-0.5, X_simple[:, 1].max()+0.5, 50)
    )
    Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    axes[idx].contour(xx, yy, Z, colors='black', alpha=0.8, linewidths=1)
    axes[idx].set_title(f'Loss: {loss}\nAcurácia: {results_loss[idx]["accuracy"]:.3f}')
    axes[idx].set_xlabel('Feature 1')
    axes[idx].set_ylabel('Feature 2')

plt.tight_layout()
plt.show()

from sklearn.linear_model import SGDClassifier

import matplotlib.pyplot as plt

# Dados de exemplo com diferentes características

X_simple, y_simple = make_classification(

n_samples=1000, n_features=2, n_classes=2,

n_redundant=0, n_clusters_per_class=1, random_state=42

)

loss_functions = ['hinge', 'log', 'modified_huber', 'perceptron']

results_loss = []

for loss in loss_functions:

classifier = SGDClassifier(

loss=loss,

max_iter=1000,

random_state=42

)

classifier.fit(X_simple, y_simple)

accuracy = classifier.score(X_simple, y_simple)

results_loss.append({

'loss': loss,

'accuracy': accuracy,

'n_iter': classifier.n_iter_,

'coef_norm': np.linalg.norm(classifier.coef_)

})

# Mostrando resultados

print("Comparação de funções de perda:")

for result in results_loss:

print(f"{result['loss']:15} | Acurácia: {result['accuracy']:.3f} | "

f"Iterações: {result['n_iter']} | Norma: {result['coef_norm']:.3f}")

# Visualizando as fronteiras de decisão

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

axes = axes.ravel()

for idx, loss in enumerate(loss_functions):

classifier = SGDClassifier(loss=loss, max_iter=1000, random_state=42)

classifier.fit(X_simple, y_simple)

# Plotando pontos

axes[idx].scatter(X_simple[:, 0], X_simple[:, 1], c=y_simple, cmap='bwr', alpha=0.6)

# Criando grid para fronteira de decisão

xx, yy = np.meshgrid(

np.linspace(X_simple[:, 0].min()-0.5, X_simple[:, 0].max()+0.5, 50),

np.linspace(X_simple[:, 1].min()-0.5, X_simple[:, 1].max()+0.5, 50)

)

Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

axes[idx].contour(xx, yy, Z, colors='black', alpha=0.8, linewidths=1)

axes[idx].set_title(f'Loss: {loss}\nAcurácia: {results_loss[idx]["accuracy"]:.3f}')

axes[idx].set_xlabel('Feature 1')

axes[idx].set_ylabel('Feature 2')

plt.tight_layout()

plt.show()

Perguntas que todo iniciante faz sobre SGD

“Por que meu modelo SGD tem performance instável?”
Isso é normal! O SGD é inerentemente aleatório. Use random_state para reproducibilidade ou execute múltiplas vezes e tire a média.

“Quando devo usar SGD em vez de LogisticRegression?”
Use SGD para datasets grandes (>10,000 amostras) ou quando precisar de atualizações online. Use LogisticRegression para datasets menores onde estabilidade é importante.

“Como escolher a taxa de aprendizado certa?”
Comece com learning_rate='optimal'. Se precisar ajustar manualmente, valores entre 0.01 e 0.1 geralmente funcionam bem.

“Meu modelo não converge – o que fazer?”
Aumente max_iter, diminua tol, ou verifique se os dados estão normalizados. Às vezes, aumentar a taxa de aprendizado ajuda.

Trabalhando com dados em tempo real

Uma das maiores vantagens do SGD é lidar com dados que chegam continuamente:

from sklearn.linear_model import SGDClassifier
import numpy as np

# Simulando dados chegando em tempo real (como transações de cartão)
online_classifier = SGDClassifier(loss='log', random_state=42)

# Número total de amostras que chegarão
total_samples = 5000
batch_size = 100

print("Simulando aprendizado online...")
print("Batch | Acurácia acumulada")

for batch_num in range(total_samples // batch_size):
    # Novos dados chegando
    X_batch, y_batch = make_classification(
        n_samples=batch_size, 
        n_features=20,
        random_state=batch_num  # Diferente a cada batch
    )
    
    # Atualizando o modelo com os novos dados
    online_classifier.partial_fit(X_batch, y_batch, classes=[0, 1])
    
    # Avaliando a performance atual
    current_accuracy = online_classifier.score(X_batch, y_batch)
    
    if batch_num % 5 == 0:  # Mostrar a cada 5 batches
        samples_processed = (batch_num + 1) * batch_size
        print(f"{batch_num:5} | {samples_processed:5} amostras | {current_accuracy:.3f}")

print(f"\nModelo final treinado com {total_samples} amostras")
print(f"Coeficientes aprendidos: {online_classifier.coef_.shape}")

# Isso é incrivelmente útil para:
# - Sistemas de recomendação que aprendem com novo comportamento
# - Detectores de fraude que se adaptam a novos padrões
# - Classificadores de texto que aprendem com novos documentos

from sklearn.linear_model import SGDClassifier

import numpy as np

# Simulando dados chegando em tempo real (como transações de cartão)

online_classifier = SGDClassifier(loss='log', random_state=42)

# Número total de amostras que chegarão

total_samples = 5000

batch_size = 100

print("Simulando aprendizado online...")

print("Batch | Acurácia acumulada")

for batch_num in range(total_samples // batch_size):

# Novos dados chegando

X_batch, y_batch = make_classification(

n_samples=batch_size,

n_features=20,

random_state=batch_num # Diferente a cada batch

)

# Atualizando o modelo com os novos dados

online_classifier.partial_fit(X_batch, y_batch, classes=[0, 1])

# Avaliando a performance atual

current_accuracy = online_classifier.score(X_batch, y_batch)

if batch_num % 5 == 0: # Mostrar a cada 5 batches

samples_processed = (batch_num + 1) * batch_size

print(f"{batch_num:5} | {samples_processed:5} amostras | {current_accuracy:.3f}")

print(f"\nModelo final treinado com {total_samples} amostras")

print(f"Coeficientes aprendidos: {online_classifier.coef_.shape}")

# Isso é incrivelmente útil para:

# - Sistemas de recomendação que aprendem com novo comportamento

# - Detectores de fraude que se adaptam a novos padrões

# - Classificadores de texto que aprendem com novos documentos

Próximos passos para dominar o SGD

Agora que você entende o básico, aqui estão as direções para se aprofundar:

Experimente SGDRegressor para problemas de regressão
Teste regularização ElasticNet que combina L1 e L2
Explore parâmetros avançados como epsilon para Huber loss
Implemente early stopping customizado para melhor controle
Use com pipelines para fluxos de trabalho reprodutíveis

Assuntos relacionados para aprofundar

Para entender completamente o SGD, estes conceitos matemáticos são fundamentais:

Otimização convexa: gradientes, convexidade, condições de otimalidade
Probabilidade e estatística: processos estocásticos, convergência
Álgebra linear: produtos escalares, normas, espaços vetoriais
Cálculo: derivadas, regra da cadeia, aproximações lineares
Teoria da aprendizagem: viés-variância, generalização
Análise numérica: estabilidade, precisão, condicionamento

Referências que valem a pena

Lembre-se: o SGD é como uma ferramenta poderosa que se torna ainda mais útil quando você entende como ela funciona. Comece com problemas simples, experimente diferentes configurações, e gradualmente você desenvolverá a intuição para aplicar o SGD eficazmente em projetos reais. A prática constante é o segredo para dominar essa técnica incrivelmente versátil!

Formulação matemática: entendendo a magia por trás do SGD

19/12/202528/10/2025 Por antonino

Quando a matemática encontra a prática: a beleza escondida nos algoritmos

Imagine que você está aprendendo a andar de bicicleta. Você não precisa entender física avançada para pedalar, mas saber sobre equilíbrio, força e atrito ajuda muito quando algo dá errado. Com o SGD é a mesma coisa – você pode usar a ferramenta sem entender a matemática, mas quando compreende os princípios por trás, consegue resolver problemas muito mais eficientemente. A formulação matemática é o “porquê” que explica o “como” do algoritmo funcionar.

O que realmente acontece quando o SGD aprende?

Você deve estar se perguntando: “se eu posso usar o SGD sem entender a matemática, por que me preocupar com ela?” A resposta é que entender a formulação matemática é como ter um mapa quando você está perdido. Quando o modelo não converge, quando a performance é ruim, ou quando você precisa adaptar o algoritmo para um problema específico, o entendimento matemático se torna sua bússola.

No coração do SGD está uma ideia elegante: em vez de calcular o gradiente usando todos os dados (o que é computacionalmente caro), usamos apenas uma amostra por vez. A atualização básica segue esta fórmula:

\(w_{t+1} = w_t – \eta_t \nabla Q_i(w_t)\)

onde \(w_t\) são os pesos no tempo \(t\), \(η_t\) é a taxa de aprendizado, e \(∇Q_i(w_t)\) é o gradiente da função custo para a amostra \(i\).

Mãos na massa: implementando o SGD do zero

Vamos criar uma implementação simplificada do SGD para ver a matemática em ação:

import numpy as np
import matplotlib.pyplot as plt

class SimpleSGD:
    def __init__(self, learning_rate=0.01, max_iters=1000, tol=1e-3):
        self.learning_rate = learning_rate
        self.max_iters = max_iters
        self.tol = tol
        self.loss_history = []
    
    def compute_gradient(self, X_batch, y_batch, weights):
        """Calcula o gradiente para regressão linear"""
        predictions = X_batch.dot(weights)
        errors = predictions - y_batch
        gradient = 2 * X_batch.T.dot(errors) / len(X_batch)
        return gradient
    
    def compute_loss(self, X, y, weights):
        """Calcula a loss (erro quadrático médio)"""
        predictions = X.dot(weights)
        return np.mean((predictions - y) ** 2)
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.random.randn(n_features)
        
        for iteration in range(self.max_iters):
            # SGD: seleciona uma amostra aleatória
            random_idx = np.random.randint(n_samples)
            X_batch = X[random_idx:random_idx+1]  # Apenas uma amostra
            y_batch = y[random_idx:random_idx+1]
            
            # Calcula o gradiente para esta amostra
            gradient = self.compute_gradient(X_batch, y_batch, self.weights)
            
            # Atualiza os pesos
            self.weights -= self.learning_rate * gradient
            
            # Calcula a loss completa para monitoramento
            current_loss = self.compute_loss(X, y, self.weights)
            self.loss_history.append(current_loss)
            
            # Critério de parada
            if iteration > 0 and abs(self.loss_history[-2] - current_loss) < self.tol:
                break
        
        return self
    
    def predict(self, X):
        return X.dot(self.weights)

# Testando nossa implementação
np.random.seed(42)
X_simple = 2 * np.random.randn(100, 1)
y_simple = 4 + 3 * X_simple + np.random.randn(100, 1)

# Adicionando bias term
X_with_bias = np.c_[np.ones((100, 1)), X_simple]

# Treinando nosso SGD personalizado
sgd_custom = SimpleSGD(learning_rate=0.1, max_iters=1000)
sgd_custom.fit(X_with_bias, y_simple.ravel())

print(f"Peso encontrados: {sgd_custom.weights}")
print(f"Loss final: {sgd_custom.loss_history[-1]:.4f}")
print(f"Coeficientes reais: bias=4, peso=3")
print(f"Coeficientes aprendidos: bias={sgd_custom.weights[0]:.2f}, peso={sgd_custom.weights[1]:.2f}")

# Visualizando a convergência
plt.figure(figsize=(10, 6))
plt.plot(sgd_custom.loss_history)
plt.title('Convergência do SGD personalizado')
plt.xlabel('Iteração')
plt.ylabel('Loss')
plt.grid(True, alpha=0.3)
plt.show()

import numpy as np

import matplotlib.pyplot as plt

class SimpleSGD:

def __init__(self, learning_rate=0.01, max_iters=1000, tol=1e-3):

self.learning_rate = learning_rate

self.max_iters = max_iters

self.tol = tol

self.loss_history = []

def compute_gradient(self, X_batch, y_batch, weights):

"""Calcula o gradiente para regressão linear"""

predictions = X_batch.dot(weights)

errors = predictions - y_batch

gradient = 2 * X_batch.T.dot(errors) / len(X_batch)

return gradient

def compute_loss(self, X, y, weights):

"""Calcula a loss (erro quadrático médio)"""

predictions = X.dot(weights)

return np.mean((predictions - y) ** 2)

def fit(self, X, y):

n_samples, n_features = X.shape

self.weights = np.random.randn(n_features)

for iteration in range(self.max_iters):

# SGD: seleciona uma amostra aleatória

random_idx = np.random.randint(n_samples)

X_batch = X[random_idx:random_idx+1] # Apenas uma amostra

y_batch = y[random_idx:random_idx+1]

# Calcula o gradiente para esta amostra

gradient = self.compute_gradient(X_batch, y_batch, self.weights)

# Atualiza os pesos

self.weights -= self.learning_rate * gradient

# Calcula a loss completa para monitoramento

current_loss = self.compute_loss(X, y, self.weights)

self.loss_history.append(current_loss)

# Critério de parada

if iteration > 0 and abs(self.loss_history[-2] - current_loss) < self.tol:

break

return self

def predict(self, X):

return X.dot(self.weights)

# Testando nossa implementação

np.random.seed(42)

X_simple = 2 * np.random.randn(100, 1)

y_simple = 4 + 3 * X_simple + np.random.randn(100, 1)

# Adicionando bias term

X_with_bias = np.c_[np.ones((100, 1)), X_simple]

# Treinando nosso SGD personalizado

sgd_custom = SimpleSGD(learning_rate=0.1, max_iters=1000)

sgd_custom.fit(X_with_bias, y_simple.ravel())

print(f"Peso encontrados: {sgd_custom.weights}")

print(f"Loss final: {sgd_custom.loss_history[-1]:.4f}")

print(f"Coeficientes reais: bias=4, peso=3")

print(f"Coeficientes aprendidos: bias={sgd_custom.weights[0]:.2f}, peso={sgd_custom.weights[1]:.2f}")

# Visualizando a convergência

plt.figure(figsize=(10, 6))

plt.plot(sgd_custom.loss_history)

plt.title('Convergência do SGD personalizado')

plt.xlabel('Iteração')

plt.ylabel('Loss')

plt.grid(True, alpha=0.3)

plt.show()

Os componentes matemáticos essenciais do SGD

Para realmente entender o SGD, precisamos decompor sua formulação matemática em partes gerenciáveis:

Função objetivo: o que estamos tentando minimizar
Gradiente: a direção de maior aumento da função
Taxa de aprendizado: o tamanho do passo que damos
Regularização: controlando a complexidade do modelo

Decompondo a função objetivo completa

Vamos examinar cada componente da formulação matemática completa do SGD:

import numpy as np

def sgd_objective_function(weights, X, y, alpha, loss_type='squared'):
    """
    Calcula a função objetivo completa do SGD com regularização
    """
    n_samples = len(y)
    
    # Termo de loss (erro)
    if loss_type == 'squared':
        predictions = X.dot(weights)
        loss = np.sum((predictions - y) ** 2) / (2 * n_samples)
    elif loss_type == 'logistic':
        predictions = 1 / (1 + np.exp(-X.dot(weights)))
        loss = -np.sum(y * np.log(predictions) + (1 - y) * np.log(1 - predictions)) / n_samples
    else:
        raise ValueError("Tipo de loss não suportado")
    
    # Termo de regularização L2
    regularization = (alpha / 2) * np.sum(weights[1:] ** 2)  # Não regulariza o bias
    
    return loss + regularization

def sgd_gradient(weights, X_batch, y_batch, alpha, loss_type='squared'):
    """
    Calcula o gradiente estocástico
    """
    n_batch = len(y_batch)
    
    if loss_type == 'squared':
        predictions = X_batch.dot(weights)
        errors = predictions - y_batch
        gradient_loss = X_batch.T.dot(errors) / n_batch
    elif loss_type == 'logistic':
        predictions = 1 / (1 + np.exp(-X_batch.dot(weights)))
        errors = predictions - y_batch
        gradient_loss = X_batch.T.dot(errors) / n_batch
    else:
        raise ValueError("Tipo de loss não suportado")
    
    # Gradiente da regularização (não aplica ao bias)
    gradient_reg = np.zeros_like(weights)
    gradient_reg[1:] = alpha * weights[1:]  # Apenas para pesos, não bias
    
    return gradient_loss + gradient_reg

# Exemplo de uso
np.random.seed(42)
X_demo = np.random.randn(50, 3)
weights_true = np.array([1.0, 2.0, -1.0])
y_demo = X_demo.dot(weights_true) + 0.1 * np.random.randn(50)

# Adicionando coluna de bias
X_with_bias = np.c_[np.ones((50, 1)), X_demo]
weights_initial = np.random.randn(4)

# Calculando função objetivo e gradiente
objective_value = sgd_objective_function(weights_initial, X_with_bias, y_demo, alpha=0.1)
gradient_value = sgd_gradient(weights_initial, X_with_bias[:5], y_demo[:5], alpha=0.1)

print(f"Valor da função objetivo: {objective_value:.4f}")
print(f"Norma do gradiente: {np.linalg.norm(gradient_value):.4f}")
print(f"Gradiente: {gradient_value}")

# Mostrando que o gradiente aponta na direção de descida
weights_new = weights_initial - 0.1 * gradient_value
new_objective = sgd_objective_function(weights_new, X_with_bias, y_demo, alpha=0.1)
print(f"Novo valor da função objetivo: {new_objective:.4f}")
print(f"Melhoria: {objective_value - new_objective:.4f}")

import numpy as np

def sgd_objective_function(weights, X, y, alpha, loss_type='squared'):

"""

Calcula a função objetivo completa do SGD com regularização

"""

n_samples = len(y)

# Termo de loss (erro)

if loss_type == 'squared':

predictions = X.dot(weights)

loss = np.sum((predictions - y) ** 2) / (2 * n_samples)

elif loss_type == 'logistic':

predictions = 1 / (1 + np.exp(-X.dot(weights)))

loss = -np.sum(y * np.log(predictions) + (1 - y) * np.log(1 - predictions)) / n_samples

else:

raise ValueError("Tipo de loss não suportado")

# Termo de regularização L2

regularization = (alpha / 2) * np.sum(weights[1:] ** 2) # Não regulariza o bias

return loss + regularization

def sgd_gradient(weights, X_batch, y_batch, alpha, loss_type='squared'):

"""

Calcula o gradiente estocástico

"""

n_batch = len(y_batch)

if loss_type == 'squared':

predictions = X_batch.dot(weights)

errors = predictions - y_batch

gradient_loss = X_batch.T.dot(errors) / n_batch

elif loss_type == 'logistic':

predictions = 1 / (1 + np.exp(-X_batch.dot(weights)))

errors = predictions - y_batch

gradient_loss = X_batch.T.dot(errors) / n_batch

else:

raise ValueError("Tipo de loss não suportado")

# Gradiente da regularização (não aplica ao bias)

gradient_reg = np.zeros_like(weights)

gradient_reg[1:] = alpha * weights[1:] # Apenas para pesos, não bias

return gradient_loss + gradient_reg

# Exemplo de uso

np.random.seed(42)

X_demo = np.random.randn(50, 3)

weights_true = np.array([1.0, 2.0, -1.0])

y_demo = X_demo.dot(weights_true) + 0.1 * np.random.randn(50)

# Adicionando coluna de bias

X_with_bias = np.c_[np.ones((50, 1)), X_demo]

weights_initial = np.random.randn(4)

# Calculando função objetivo e gradiente

objective_value = sgd_objective_function(weights_initial, X_with_bias, y_demo, alpha=0.1)

gradient_value = sgd_gradient(weights_initial, X_with_bias[:5], y_demo[:5], alpha=0.1)

print(f"Valor da função objetivo: {objective_value:.4f}")

print(f"Norma do gradiente: {np.linalg.norm(gradient_value):.4f}")

print(f"Gradiente: {gradient_value}")

# Mostrando que o gradiente aponta na direção de descida

weights_new = weights_initial - 0.1 * gradient_value

new_objective = sgd_objective_function(weights_new, X_with_bias, y_demo, alpha=0.1)

print(f"Novo valor da função objetivo: {new_objective:.4f}")

print(f"Melhoria: {objective_value - new_objective:.4f}")

Por que a formulação matemática importa na prática?

Entender a matemática não é apenas um exercício acadêmico – tem implicações práticas diretas no seu trabalho:

Debugging de modelos: quando o modelo não converge, você pode investigar se o gradiente está sendo calculado corretamente
Seleção de hiperparâmetros: entender como a taxa de aprendizado afeta a convergência ajuda a escolher valores melhores
Adaptação para problemas específicos: você pode modificar a função custo para necessidades específicas do seu domínio
Interpretação de resultados: compreender o que os coeficientes representam ajuda na explicação do modelo

Comparando diferentes funções de perda

Cada função de perda tem propriedades matemáticas diferentes que afetam o comportamento do SGD:

import matplotlib.pyplot as plt

# Visualizando diferentes funções de perda
def squared_loss(prediction, true_value):
    return 0.5 * (prediction - true_value) ** 2

def huber_loss(prediction, true_value, delta=1.0):
    error = abs(prediction - true_value)
    if error <= delta:
        return 0.5 * error ** 2
    else:
        return delta * (error - 0.5 * delta)

def epsilon_insensitive_loss(prediction, true_value, epsilon=0.1):
    error = abs(prediction - true_value)
    return max(0, error - epsilon)

# Gerando dados para plotagem
errors = np.linspace(-2, 2, 100)
true_value = 0

squared_losses = [squared_loss(err, true_value) for err in errors]
huber_losses = [huber_loss(err, true_value) for err in errors]
epsilon_losses = [epsilon_insensitive_loss(err, true_value) for err in errors]

plt.figure(figsize=(12, 8))
plt.plot(errors, squared_losses, label='Squared Loss', linewidth=2)
plt.plot(errors, huber_losses, label='Huber Loss', linewidth=2)
plt.plot(errors, epsilon_losses, label='Epsilon-Insensitive Loss', linewidth=2)
plt.xlabel('Erro (predição - valor real)')
plt.ylabel('Loss')
plt.title('Comparação de Funções de Perda')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

print("Insights das funções de perda:")
print("- Squared Loss: penaliza muito outliers, gradiente linear")
print("- Huber Loss: robusta a outliers, combina squared e linear")
print("- Epsilon-Insensitive: ignora erros pequenos, útil para SVR")

import matplotlib.pyplot as plt

# Visualizando diferentes funções de perda

def squared_loss(prediction, true_value):

return 0.5 * (prediction - true_value) ** 2

def huber_loss(prediction, true_value, delta=1.0):

error = abs(prediction - true_value)

if error <= delta:

return 0.5 * error ** 2

else:

return delta * (error - 0.5 * delta)

def epsilon_insensitive_loss(prediction, true_value, epsilon=0.1):

error = abs(prediction - true_value)

return max(0, error - epsilon)

# Gerando dados para plotagem

errors = np.linspace(-2, 2, 100)

true_value = 0

squared_losses = [squared_loss(err, true_value) for err in errors]

huber_losses = [huber_loss(err, true_value) for err in errors]

epsilon_losses = [epsilon_insensitive_loss(err, true_value) for err in errors]

plt.figure(figsize=(12, 8))

plt.plot(errors, squared_losses, label='Squared Loss', linewidth=2)

plt.plot(errors, huber_losses, label='Huber Loss', linewidth=2)

plt.plot(errors, epsilon_losses, label='Epsilon-Insensitive Loss', linewidth=2)

plt.xlabel('Erro (predição - valor real)')

plt.ylabel('Loss')

plt.title('Comparação de Funções de Perda')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

print("Insights das funções de perda:")

print("- Squared Loss: penaliza muito outliers, gradiente linear")

print("- Huber Loss: robusta a outliers, combina squared e linear")

print("- Epsilon-Insensitive: ignora erros pequenos, útil para SVR")

Perguntas comuns sobre a matemática do SGD

“Por que o SGD usa apenas uma amostra por vez?”
Por eficiência computacional. Calcular o gradiente completo é O(n), enquanto o gradiente estocástico é O(1) por iteração. Além disso, a natureza ruidosa ajuda a escapar de mínimos locais.

“Como a taxa de aprendizado afeta a convergência?”
Muito alta: o algoritmo pode divergir ou oscilar. Muito baixa: converge muito devagar. A taxa ideal balanceia velocidade e estabilidade.

“Por que precisamos de regularização?”
Para prevenir overfitting penalizando coeficientes muito grandes. L1 cria esparsidade, L2 distribui os pesos.

“O SGD sempre converge para o mínimo global?”
Para funções convexas, sim. Para funções não-convexas, pode convergir para mínimos locais, mas a natureza estocástica ajuda a explorar melhor o espaço.

Entendendo a convergência matematicamente

Vamos analisar as condições matemáticas para convergência do SGD:

import numpy as np
import matplotlib.pyplot as plt

def analyze_convergence_conditions():
    """
    Analisa as condições matemáticas para convergência do SGD
    """
    print("Condições para convergência do SGD:")
    print("1. Função objetivo convexa")
    print("2. Gradiente Lipschitz contínuo")
    print("3. Taxa de aprendizado decrescente")
    print("4. ∑η_t = ∞ (exploração suficiente)")
    print("5. ∑η_t² < ∞ (ruído decrescente)")
    
    # Exemplo de taxas de aprendizado que satisfazem as condições
    t_values = np.arange(1, 101)
    learning_rates = {
        'ideal': 1.0 / t_values,
        'muito_devagar': 0.1 / np.sqrt(t_values),
        'muito_rapido': 1.0 / np.sqrt(t_values)
    }
    
    plt.figure(figsize=(10, 6))
    for label, rates in learning_rates.items():
        plt.plot(t_values, rates, label=label, linewidth=2)
    
    plt.xlabel('Iteração (t)')
    plt.ylabel('Taxa de Aprendizado (η_t)')
    plt.title('Evolução da Taxa de Aprendizado')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.yscale('log')
    plt.show()
    
    # Verificando as condições de convergência
    ideal_rates = 1.0 / t_values
    condition_4 = np.sum(ideal_rates)  # Deve ser infinito (na prática, muito grande)
    condition_5 = np.sum(ideal_rates ** 2)  # Deve ser finito
    
    print(f"\nCondição 4 (∑η_t): {condition_4:.2f} (grande = bom)")
    print(f"Condição 5 (∑η_t²): {condition_5:.2f} (finita = bom)")

analyze_convergence_conditions()

import numpy as np

import matplotlib.pyplot as plt

def analyze_convergence_conditions():

"""

Analisa as condições matemáticas para convergência do SGD

"""

print("Condições para convergência do SGD:")

print("1. Função objetivo convexa")

print("2. Gradiente Lipschitz contínuo")

print("3. Taxa de aprendizado decrescente")

print("4. ∑η_t = ∞ (exploração suficiente)")

print("5. ∑η_t² < ∞ (ruído decrescente)")

# Exemplo de taxas de aprendizado que satisfazem as condições

t_values = np.arange(1, 101)

learning_rates = {

'ideal': 1.0 / t_values,

'muito_devagar': 0.1 / np.sqrt(t_values),

'muito_rapido': 1.0 / np.sqrt(t_values)

}

plt.figure(figsize=(10, 6))

for label, rates in learning_rates.items():

plt.plot(t_values, rates, label=label, linewidth=2)

plt.xlabel('Iteração (t)')

plt.ylabel('Taxa de Aprendizado (η_t)')

plt.title('Evolução da Taxa de Aprendizado')

plt.legend()

plt.grid(True, alpha=0.3)

plt.yscale('log')

plt.show()

# Verificando as condições de convergência

ideal_rates = 1.0 / t_values

condition_4 = np.sum(ideal_rates) # Deve ser infinito (na prática, muito grande)

condition_5 = np.sum(ideal_rates ** 2) # Deve ser finito

print(f"\nCondição 4 (∑η_t): {condition_4:.2f} (grande = bom)")

print(f"Condição 5 (∑η_t²): {condition_5:.2f} (finita = bom)")

analyze_convergence_conditions()

Próximos passos no entendimento matemático

Para aprofundar seu conhecimento matemático do SGD, explore estas direções:

Estude otimização convexa: understand condições de otimalidade e garantias de convergência
Aprenda sobre teoria de probabilidade: processos estocásticos e convergência quase certa
Explore variantes do SGD: momentum, Nesterov, AdaGrad, Adam
Pratique implementações do zero: recrie diferentes algoritmos de otimização
Estude análise de convergência: taxas de convergência e complexidade

Assuntos relacionados para aprofundar

Para dominar completamente a formulação matemática do SGD, estes tópicos são essenciais:

Cálculo multivariado: gradientes, derivadas parciais, matriz Hessiana
Álgebra linear: produtos internos, normas, autovalores/autovetores
Otimização convexa: convexidade, condições KKT, dualidade
Teoria da probabilidade: esperança, variância, leis dos grandes números
Análise numérica: estabilidade, condicionamento, precisão
Estatística matemática: estimação, propriedades assintóticas
Teoria da aprendizagem: generalização, complexidade, limites

Referências que valem a pena

Lembre-se: a matemática por trás do SGD não é apenas bonita – é incrivelmente prática. Cada vez que você ajusta um hiperparâmetro ou debuga um modelo que não converge, está aplicando esses conceitos matemáticos. Quanto mais você entender o “porquê”, mais eficaz será no “como” de construir modelos de machine learning!