SGDRegressor: Quando Você Precisa Prever Números

Do Preço de Casas à Demanda de Produtos: Prevendo o Futuro com Dados

Imagine que você trabalha numa imobiliária e precisa estimar o preço de venda de um apartamento. Ou talvez você seja responsável por prever a demanda de um produto para evitar estoques cheios ou prateleiras vazias. Em ambos os casos, você não está classificando coisas em categorias, mas sim tentando prever um número – e é exatamente aqui que o SGDRegressor entra em cena. Ele é como um corretor de imóveis super eficiente que aprende rapidamente os padrões de preços, mesmo com milhares de transações para analisar.

Da Classificação para a Regressão: A Mesma Ideia, Objetivo Diferente

Você já conhece o SGDClassifier para classificação, certo? O SGDRegressor é seu primo que resolve problemas diferentes. Enquanto o classificador diz “isso é spam” ou “isso não é spam”, o regressor responde perguntas como “quanto custa?” ou “quantas unidades venderemos?”.

A ideia fundamental permanece a mesma: aprender de forma eficiente, processando os dados em pequenos lotes. Contudo, em vez de minimizar erros de classificação, o regressor minimiza o erro entre previsões e valores reais. A função objetivo se parece com:

$\min_{w} \frac{1}{2} w^T w + C \sum_{i=1}^n L(y_i, w^T x_i)$

onde L é a função de perda que mede quão errada está nossa previsão.

Mãos na Massa: Prevendo Preços de Imóveis

Vamos criar um sistema para estimar preços de casas baseado em características como tamanho, número de quartos e localização:

from sklearn.linear_model import SGDRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Simulando dados de imóveis: preços baseados em características
# tamanho (m²), quartos, banheiros, idade do imóvel, distância do centro
X, y = make_regression(n_samples=10000, n_features=5, noise=10.0, 
                       random_state=42, bias=200000)

# Ajustando a escala dos preços para algo realista (em milhares de reais)
y = y * 100 + 300  # Preços entre ~200k e 400k

# Dividindo nossos dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
                                                   random_state=42)

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

# Criando nosso estimador de preços
price_predictor = SGDRegressor(
    loss='squared_loss',  # Erro quadrático - clássico para regressão
    penalty='l2',         # Regularização para evitar overfitting
    alpha=0.0001,         # Força da regularização
    max_iter=1000,
    learning_rate='invscaling',  # Aprendizado que diminui com o tempo
    eta0=0.01,           # Taxa de aprendizado inicial
    power_t=0.25,        # Como a taxa diminui
    random_state=42
)

# Treinando o modelo
price_predictor.fit(X_train_scaled, y_train)

# Fazendo previsões e avaliando
y_pred = price_predictor.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(f"Erro médio: R$ {rmse:.2f}")
print(f"R² Score: {r2:.4f}")  # Quanto mais perto de 1, melhor
print(f"O modelo explica {r2:.1%} da variação nos preços!")

from sklearn.linear_model import SGDRegressor

from sklearn.datasets import make_regression

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

import numpy as np

# Simulando dados de imóveis: preços baseados em características

# tamanho (m²), quartos, banheiros, idade do imóvel, distância do centro

X, y = make_regression(n_samples=10000, n_features=5, noise=10.0,

random_state=42, bias=200000)

# Ajustando a escala dos preços para algo realista (em milhares de reais)

y = y * 100 + 300 # Preços entre ~200k e 400k

# Dividindo nossos dados

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

random_state=42)

# CRUCIAL: Normalizar os dados para SGD

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Criando nosso estimador de preços

price_predictor = SGDRegressor(

loss='squared_loss', # Erro quadrático - clássico para regressão

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

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

max_iter=1000,

learning_rate='invscaling', # Aprendizado que diminui com o tempo

eta0=0.01, # Taxa de aprendizado inicial

power_t=0.25, # Como a taxa diminui

random_state=42

)

# Treinando o modelo

price_predictor.fit(X_train_scaled, y_train)

# Fazendo previsões e avaliando

y_pred = price_predictor.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

rmse = np.sqrt(mse)

r2 = r2_score(y_test, y_pred)

print(f"Erro médio: R$ {rmse:.2f}")

print(f"R² Score: {r2:.4f}") # Quanto mais perto de 1, melhor

print(f"O modelo explica {r2:.1%} da variação nos preços!")

Escolhendo a Função de Perda Certa para Seu Problema

Uma das decisões mais importantes ao usar SGDRegressor é escolher a função de perda adequada. Cada uma tem suas vantagens e desvantagens:

squared_loss: O clássico erro quadrático. Penaliza muito os erros grandes, então é ótimo quando outliers são raros.
huber: Mais robusta a outliers. Funciona como erro quadrático para erros pequenos e linear para erros grandes.
epsilon_insensitive: Ignora erros menores que ε. Perfeita para problemas onde pequenas diferenças não importam.
squared_epsilon_insensitive: Similar à anterior, mas penaliza erros quadráticos acima do limiar.

Comparando Diferentes Funções de Perda

Vamos ver como cada função se comporta com dados do mundo real:

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

# Dados com alguns outliers (preços anormalmente altos/baixos)
X_outlier, y_outlier = make_regression(n_samples=1000, n_features=4, 
                                      noise=15.0, random_state=42)
# Adicionando alguns outliers
y_outlier[::100] += 200  # A cada 100 amostras, adiciona um outlier

loss_functions = ['squared_loss', 'huber', 'epsilon_insensitive']
results = {}

scaler_outlier = StandardScaler()
X_outlier_scaled = scaler_outlier.fit_transform(X_outlier)

for loss in loss_functions:
    if loss == 'huber':
        regressor = SGDRegressor(loss=loss, epsilon=1.0, random_state=42)
    elif 'epsilon' in loss:
        regressor = SGDRegressor(loss=loss, epsilon=0.5, random_state=42)
    else:
        regressor = SGDRegressor(loss=loss, random_state=42)
    
    regressor.fit(X_outlier_scaled, y_outlier)
    y_pred_loss = regressor.predict(X_outlier_scaled)
    
    mse_loss = mean_squared_error(y_outlier, y_pred_loss)
    results[loss] = {
        'mse': mse_loss,
        'coef': regressor.coef_
    }
    print(f"{loss}: MSE = {mse_loss:.2f}")

print("\nLição: 'huber' geralmente performa melhor com dados ruidosos!")

from sklearn.linear_model import SGDRegressor

import matplotlib.pyplot as plt

# Dados com alguns outliers (preços anormalmente altos/baixos)

X_outlier, y_outlier = make_regression(n_samples=1000, n_features=4,

noise=15.0, random_state=42)

# Adicionando alguns outliers

y_outlier[::100] += 200 # A cada 100 amostras, adiciona um outlier

loss_functions = ['squared_loss', 'huber', 'epsilon_insensitive']

results = {}

scaler_outlier = StandardScaler()

X_outlier_scaled = scaler_outlier.fit_transform(X_outlier)

for loss in loss_functions:

if loss == 'huber':

regressor = SGDRegressor(loss=loss, epsilon=1.0, random_state=42)

elif 'epsilon' in loss:

regressor = SGDRegressor(loss=loss, epsilon=0.5, random_state=42)

else:

regressor = SGDRegressor(loss=loss, random_state=42)

regressor.fit(X_outlier_scaled, y_outlier)

y_pred_loss = regressor.predict(X_outlier_scaled)

mse_loss = mean_squared_error(y_outlier, y_pred_loss)

results[loss] = {

'mse': mse_loss,

'coef': regressor.coef_

}

print(f"{loss}: MSE = {mse_loss:.2f}")

print("\nLição: 'huber' geralmente performa melhor com dados ruidosos!")

Os Segredos que Fazem a Diferença na Regressão com SGD

Quando comecei com SGDRegressor, cometi erros que poderiam ter sido evitados. Aqui estão minhas lições aprendidas:

A normalização é ainda mais crítica na regressão porque os coeficientes diretamente afetam a escala da previsão.
Teste diferentes taxas de aprendizado – ‘invscaling’ com power_t=0.25 geralmente funciona bem.
Monitore a convergência com verbose=1 nas primeiras execuções para entender o comportamento.
Considere o epsilon nas funções Huber e epsilon-insensitive – valores entre 0.1 e 1.0 costumam funcionar bem.

Quando o SGDRegressor Brilha (e Quando Não)

O SGDRegressor é fantástico para:

# Cenário 1: Dados em streaming - preços de ações em tempo real
stock_predictor = SGDRegressor(loss='huber', random_state=42)

# Simulando dados chegando em tempo real (minuto a minuto)
for hour in range(24):  # 24 horas de dados
    # Novos dados da hora atual
    X_hour, y_hour = make_regression(n_samples=60, n_features=4, 
                                    random_state=hour)
    
    stock_predictor.partial_fit(X_hour, y_hour)
    
    if hour % 6 == 0:  # A cada 6 horas
        current_r2 = stock_predictor.score(X_test_scaled, y_test)
        print(f"Após {hour} horas: R² = {current_r2:.4f}")

# Cenário 1: Dados em streaming - preços de ações em tempo real

stock_predictor = SGDRegressor(loss='huber', random_state=42)

# Simulando dados chegando em tempo real (minuto a minuto)

for hour in range(24): # 24 horas de dados

# Novos dados da hora atual

X_hour, y_hour = make_regression(n_samples=60, n_features=4,

random_state=hour)

stock_predictor.partial_fit(X_hour, y_hour)

if hour % 6 == 0: # A cada 6 horas

current_r2 = stock_predictor.score(X_test_scaled, y_test)

print(f"Após {hour} horas: R² = {current_r2:.4f}")

Mas considere outras abordagens quando:

Seu dataset é pequeno (< 1.000 exemplos) - LinearRegression ou Ridge podem ser melhores
Você precisa de intervalos de confiança – métodos Bayesianos são mais adequados
Os relacionamentos são altamente não-lineares – experimente RandomForestRegressor ou GradientBoostingRegressor

Perguntas que Todo Mundo Faz (Com Respostas Sinceras)

“Qual função de perda devo usar?”
Comece com ‘squared_loss’. Se tiver muitos outliers, experimente ‘huber’. Para problemas onde pequenos erros são aceitáveis, ‘epsilon_insensitive’.

“Como escolher o alpha certo?”
Comece com valores pequenos (0.0001) e aumente se o modelo estiver sobreajustando. Use validação cruzada para encontrar o ideal.

“Meu modelo não converge – o que fazer?”
Diminua a taxa de aprendizado (eta0), aumente max_iter, ou tente learning_rate='constant' com um eta0 bem pequeno.

“Quando usar SGDRegressor vs LinearRegression?”
SGD para datasets grandes (>10.000 exemplos) ou streaming. LinearRegression para datasets menores onde precisão máxima é crucial.

O Poder do Aprendizado Online em Regressão

A capacidade de aprendizado incremental é uma das features mais poderosas do SGDRegressor:

# Digamos que novos dados de mercado imobiliário chegaram
novos_imoveis, novos_precos = make_regression(n_samples=500, n_features=5, 
                                             random_state=123)

# Aplicando a mesma transformação
novos_imoveis_scaled = scaler.transform(novos_imoveis)

# Atualizando nosso modelo sem retreinar do zero
price_predictor.partial_fit(novos_imoveis_scaled, novos_precos)

# Verificando a melhoria
novo_r2 = price_predictor.score(X_test_scaled, y_test)
print(f"Modelo atualizado! Novo R²: {novo_r2:.4f}")

# Isso é incrivelmente útil para:
# - Dados que chegam continuamente
# - Ajustes sazonais (verão vs inverno)
# - Mudanças no mercado ao longo do tempo

# Digamos que novos dados de mercado imobiliário chegaram

novos_imoveis, novos_precos = make_regression(n_samples=500, n_features=5,

random_state=123)

# Aplicando a mesma transformação

novos_imoveis_scaled = scaler.transform(novos_imoveis)

# Atualizando nosso modelo sem retreinar do zero

price_predictor.partial_fit(novos_imoveis_scaled, novos_precos)

# Verificando a melhoria

novo_r2 = price_predictor.score(X_test_scaled, y_test)

print(f"Modelo atualizado! Novo R²: {novo_r2:.4f}")

# Isso é incrivelmente útil para:

# - Dados que chegam continuamente

# - Ajustes sazonais (verão vs inverno)

# - Mudanças no mercado ao longo do tempo

Próximos Passos na Sua Jornada com Regressão

Agora que você domina o básico do SGDRegressor, aqui estão alguns caminhos para explorar:

Experimente regularização L1 (penalty='l1') para criar modelos esparsos que usam menos features
Teste ElasticNet (penalty='elasticnet') que combina L1 e L2
Explore early_stopping para parar o treinamento automaticamente quando a performance para de melhorar
Implemente validação cruzada para tuning robusto de hiperparâmetros

Assuntos Relacionados para Aprofundar

Para realmente dominar o SGDRegressor, esses conceitos matemáticos e estatísticos vão ajudar muito:

Álgebra Linear: Entender produtos escalares, normas vetoriais e espaços vetoriais
Cálculo Diferencial: Gradientes, derivadas parciais e otimização
Estatística Descritiva: Média, variância, desvio padrão e correlação
Teoria da Regressão: Mínimos quadrados, coeficientes de determinação (R²)
Otimização Convexa: Funções convexas, condições de otimalidade
Probabilidade: Distribuições normais, teorema do limite central
Análise Numérica: Estabilidade numérica, convergência de algoritmos

Referências que Realmente Ajudam

Documentação Oficial do SGDRegressor – Sempre atualizada e completa
Guia de Regressão do Scikit-Learn – Excelente visão geral
Exemplos de Funções de Perda – Visualizações úteis
Guia de Regressão Linear – Fundamentos teóricos

E não se esqueça: a comunidade está sempre disposta a ajudar. Quando encontrar dificuldades, o Stack Overflow e fóruns especializados são seus melhores amigos!

Indice