Arquivo de regressao-linear

SGDRegressor: Quando Você Precisa Prever Números

19/12/202528/10/2025 Por antonino

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!

Análise Discriminante: Algoritmos de Estimativa

19/12/202518/10/2025 Por antonino

Continuando nossa exploração detalhada da Análise Discriminante, chegamos aos algoritmos de estimativa que fundamentam a implementação prática do LDA e QDA no scikit-learn. Conforme discutimos anteriormente sobre encolhimento e formulações matemáticas, a escolha do algoritmo de estimação impacta significativamente o desempenho e a estabilidade numérica destes classificadores.

O Desafio da Estimação em LDA e QDA

Analogamente aos problemas que identificamos nas seções anteriores sobre encolhimento, a estimação precisa das matrizes de covariância é crucial para o bom desempenho dos classificadores LDA e QDA. Primordialmente, os desafios incluem:

Inversão de matrizes potencialmente singulares
Estimação estável com dados de alta dimensionalidade
Balanceamento entre precisão e eficiência computacional
Tratamento de casos degenerados

Solvers Disponíveis no scikit-learn

O scikit-learn oferece diferentes algoritmos de estimação através do parâmetro solver, cada um com características específicas:

svd – Decomposição por Valores Singulares

Este solver evita explicitamente o cálculo da matriz de covariância, trabalhando diretamente com a decomposição SVD:

$X = U \Sigma V^T$

Vantagens:

Não calcula explicitamente a matriz de covariância
Mais estável numericamente
Funciona bem com dados de alta dimensionalidade
Não suporta shrinkage

lsqr – Mínimos Quadrados

Utiliza métodos iterativos de mínimos quadrados para estimação:

$\min_w \|X w – y\|^2_2$

Vantagens:

Suporta shrinkage
Eficiente para problemas de grande escala
Estável numericamente

eigen – Decomposição Espectral

Baseia-se na decomposição de autovalores da matriz de covariância:

$\Sigma = Q \Lambda Q^T$

Vantagens:

Suporta shrinkage
Computacionalmente eficiente para datasets menores
Interpretação geométrica clara

Seleção Automática do Solver

Quando o parâmetro solver não é especificado, o scikit-learn aplica regras heurísticas para seleção automática:

Se shrinkage não é usado: seleciona ‘svd’
Se shrinkage é usado: seleciona ‘lsqr’ ou ‘eigen’
Considera o número de features e amostras
Avalia a relação entre dimensionalidade e tamanho do dataset

Considerações de Performance

Complexidade Computacional

Cada solver possui características de complexidade distintas:

svd: O(min(n²p, np²)) para n amostras e p features
lsqr: O(n_iter × p²) dependendo da convergência
eigen: O(p³) para a decomposição espectral

Estabilidade Numérica

Conforme observamos nos experimentos com encolhimento, a estabilidade numérica varia entre os solvers:

svd: Mais estável, especialmente para matrizes de baixo rank
lsqr: Boa estabilidade com regularização apropriada
eigen: Pode ser sensível a matrizes mal-condicionadas

Conexões com Tópicos Anteriores

Similarmente aos conceitos de encolhimento que exploramos, a escolha do algoritmo de estimação:

Influencia diretamente a necessidade de técnicas de regularização
Determina a robustez em cenários de alta dimensionalidade
Afeta a capacidade de lidar com matrizes singulares
Impacta o trade-off entre precisão e eficiência computacional

Exemplo Prático em Python

Para ilustrar as diferenças entre os algoritmos de estimação, implementemos um estudo comparativo detalhado:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.datasets import make_classification, load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
import time
import warnings
warnings.filterwarnings('ignore')

'''
Estudo comparativo dos diferentes algoritmos de estimação (solvers)
disponíveis no LDA do scikit-learn
'''

print("=== COMPARAÇÃO DE ALGORITMOS DE ESTIMAÇÃO EM LDA ===")

# Criando diferentes cenários de dados
print("\n1. CONFIGURAÇÃO DOS CENÁRIOS DE TESTE")

# Cenário 1: Dataset balanceado com dimensionalidade moderada
X1, y1 = make_classification(
    n_samples=1000, n_features=20, n_informative=10,
    n_redundant=5, n_classes=3, random_state=42
)

# Cenário 2: Alta dimensionalidade com poucas amostras
X2, y2 = make_classification(
    n_samples=100, n_features=50, n_informative=10,
    n_redundant=30, n_classes=2, random_state=42
)

# Cenário 3: Dataset real (Iris) para referência
iris = load_iris()
X3, y3 = iris.data, iris.target

cenarios = [
    ('Moderado (1000x20)', X1, y1),
    ('Alta Dim (100x50)', X2, y2),
    ('Real (Iris)', X3, y3)
]

# Solvers a serem testados
solvers = ['svd', 'lsqr', 'eigen']
shrinkage_values = [None, 'auto', 0.5]

'''
Avaliação sistemática dos solvers em diferentes cenários
'''
print("\n2. AVALIAÇÃO DOS SOLVERS")

resultados_completos = {}

for cenario_nome, X, y in cenarios:
    print(f"\n--- {cenario_nome} ---")
    print(f"Dimensões: {X.shape}, Classes: {len(np.unique(y))}")
    
    # Padronizando os dados
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # Dividindo em treino e teste
    X_train, X_test, y_train, y_test = train_test_split(
        X_scaled, y, test_size=0.3, random_state=42
    )
    
    cenario_resultados = {}
    
    for solver in solvers:
        for shrinkage in shrinkage_values:
            # Configuração específica para cada combinação
            if solver == 'svd' and shrinkage is not None:
                continue  # SVD não suporta shrinkage
            
            try:
                # Medindo tempo de treinamento
                start_time = time.time()
                
                if shrinkage is not None:
                    lda = LinearDiscriminantAnalysis(solver=solver, shrinkage=shrinkage)
                else:
                    lda = LinearDiscriminantAnalysis(solver=solver)
                
                # Treinamento
                lda.fit(X_train, y_train)
                train_time = time.time() - start_time
                
                # Previsões e acurácia
                y_pred = lda.predict(X_test)
                accuracy = accuracy_score(y_test, y_pred)
                
                # Validação cruzada para avaliação robusta
                cv_scores = cross_val_score(lda, X_scaled, y, cv=5)
                cv_mean = np.mean(cv_scores)
                cv_std = np.std(cv_scores)
                
                # Armazenando resultados
                config_key = f"{solver}_shrink{shrinkage}"
                cenario_resultados[config_key] = {
                    'solver': solver,
                    'shrinkage': shrinkage,
                    'accuracy': accuracy,
                    'cv_mean': cv_mean,
                    'cv_std': cv_std,
                    'train_time': train_time,
                    'model': lda
                }
                
                print(f"  {config_key}:")
                print(f"    Acurácia: {accuracy:.3f}, CV: {cv_mean:.3f} ± {cv_std:.3f}")
                print(f"    Tempo: {train_time:.4f}s")
                
            except Exception as e:
                print(f"  {config_key}: ERRO - {e}")
    
    resultados_completos[cenario_nome] = cenario_resultados

'''
Análise de performance computacional
'''
print("\n3. ANÁLISE DE PERFORMANCE COMPUTACIONAL")

# Coletando dados de tempo para comparação
fig, axes = plt.subplots(2, 2, figsize=(15, 12))

# Gráfico 1: Tempo de treinamento por cenário
for idx, (cenario_nome, resultados) in enumerate(resultados_completos.items()):
    ax = axes[0, 0] if idx == 0 else axes[0, 1] if idx == 1 else axes[1, 0]
    
    configs = []
    tempos = []
    
    for config_key, dados in resultados.items():
        configs.append(config_key)
        tempos.append(dados['train_time'])
    
    bars = ax.bar(configs, tempos, color=['blue', 'orange', 'green'][:len(configs)])
    ax.set_title(f'Tempo de Treinamento - {cenario_nome}')
    ax.set_ylabel('Tempo (segundos)')
    ax.tick_params(axis='x', rotation=45)
    
    # Adicionando valores nas barras
    for bar, tempo in zip(bars, tempos):
        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.001,
                f'{tempo:.4f}s', ha='center', va='bottom', fontsize=8)

# Gráfico 2: Comparação de acurácia entre solvers
ax_acc = axes[1, 1]
solver_accuracies = {solver: [] for solver in solvers}

for cenario_nome, resultados in resultados_completos.items():
    for solver in solvers:
        # Buscando a melhor configuração para cada solver
        solver_configs = [k for k in resultados.keys() if k.startswith(solver)]
        if solver_configs:
            best_config = max(solver_configs, key=lambda k: resultados[k]['cv_mean'])
            solver_accuracies[solver].append(resultados[best_config]['cv_mean'])

# Plotando acurácias médias
cenario_nomes = [nome for nome, _ in cenarios]
x_pos = np.arange(len(cenario_nomes))
width = 0.25

for idx, solver in enumerate(solvers):
    if solver_accuracies[solver]:  # Verifica se há dados
        ax_acc.bar(x_pos + idx*width, solver_accuracies[solver], width, label=solver)

ax_acc.set_xlabel('Cenários')
ax_acc.set_ylabel('Acurácia (CV)')
ax_acc.set_title('Acurácia por Solver e Cenário')
ax_acc.set_xticks(x_pos + width)
ax_acc.set_xticklabels(cenario_nomes)
ax_acc.legend()
ax_acc.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

'''
Análise de estabilidade numérica
'''
print("\n4. ANÁLISE DE ESTABILIDADE NUMÉRICA")

# Testando casos extremos
print("\nCenários Extremos:")

# Caso 1: Mais features que amostras
X_extremo1, y_extremo1 = make_classification(
    n_samples=50, n_features=100, n_informative=10,
    n_classes=2, random_state=42
)

# Caso 2: Matriz quase singular
X_extremo2 = np.random.randn(200, 10)
# Criando correlações fortes para tornar a matriz quase singular
X_extremo2[:, 5] = X_extremo2[:, 4] + 0.01 * np.random.randn(200)
X_extremo2[:, 6] = X_extremo2[:, 4] + 0.01 * np.random.randn(200)
y_extremo2 = np.random.randint(0, 2, 200)

cenarios_extremos = [
    ('Mais Features (50x100)', X_extremo1, y_extremo1),
    ('Quase Singular (200x10)', X_extremo2, y_extremo2)
]

for cenario_nome, X, y in cenarios_extremos:
    print(f"\n{cenario_nome}:")
    X_scaled = StandardScaler().fit_transform(X)
    
    for solver in solvers:
        try:
            if solver == 'svd':
                lda = LinearDiscriminantAnalysis(solver=solver)
            else:
                lda = LinearDiscriminantAnalysis(solver=solver, shrinkage='auto')
            
            lda.fit(X_scaled, y)
            score = lda.score(X_scaled, y)
            print(f"  {solver}: OK (score: {score:.3f})")
            
        except Exception as e:
            print(f"  {solver}: FALHOU - {e}")

'''
Recomendações práticas baseadas nos resultados
'''
print("\n5. RECOMENDAÇÕES PRÁTICAS")

print("\nBaseado na análise experimental, recomenda-se:")

print("\nPara datasets gerais:")
print("  - Usar 'svd' como primeira opção (mais estável)")
print("  - Especificar solver apenas se necessário")
print("  - Deixar a seleção automática quando possível")

print("\nQuando usar shrinkage:")
print("  - Preferir 'lsqr' ou 'eigen'")
print("  - 'lsqr' geralmente mais robusto para alta dimensionalidade")
print("  - 'eigen' mais eficiente para datasets menores")

print("\nPara casos específicos:")
print("  - Alta dimensionalidade: 'svd' ou 'lsqr' com shrinkage")
print("  - Poucas amostras: 'svd' (evita problemas de singularidade)")
print("  - Datasets grandes: 'lsqr' (escalabilidade)")
print("  - Precisão máxima: testar múltiplos solvers com validação cruzada")

'''
Análise das propriedades dos solvers
'''
print("\n6. PROPRIEDADES DOS SOLVERS")

propriedades = {
    'svd': {
        'shrinkage': 'Não suportado',
        'estabilidade': 'Alta',
        'dimensionalidade': 'Alta compatibilidade',
        'casos_especiais': 'Excelente para matrizes singulares'
    },
    'lsqr': {
        'shrinkage': 'Suportado',
        'estabilidade': 'Média-Alta',
        'dimensionalidade': 'Boa escalabilidade',
        'casos_especiais': 'Bom com regularização'
    },
    'eigen': {
        'shrinkage': 'Suportado',
        'estabilidade': 'Média',
        'dimensionalidade': 'Limitada por p³',
        'casos_especiais': 'Sensível a mal-condicionamento'
    }
}

for solver, props in propriedades.items():
    print(f"\n{solver.upper()}:")
    for prop, valor in props.items():
        print(f"  {prop}: {valor}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

import numpy as np

import matplotlib.pyplot as plt

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

from sklearn.datasets import make_classification, load_iris

from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.metrics import accuracy_score

from sklearn.preprocessing import StandardScaler

import time

import warnings

warnings.filterwarnings('ignore')

'''

Estudo comparativo dos diferentes algoritmos de estimação (solvers)

disponíveis no LDA do scikit-learn

'''

print("=== COMPARAÇÃO DE ALGORITMOS DE ESTIMAÇÃO EM LDA ===")

# Criando diferentes cenários de dados

print("\n1. CONFIGURAÇÃO DOS CENÁRIOS DE TESTE")

# Cenário 1: Dataset balanceado com dimensionalidade moderada

X1, y1 = make_classification(

n_samples=1000, n_features=20, n_informative=10,

n_redundant=5, n_classes=3, random_state=42

)

# Cenário 2: Alta dimensionalidade com poucas amostras

X2, y2 = make_classification(

n_samples=100, n_features=50, n_informative=10,

n_redundant=30, n_classes=2, random_state=42

)

# Cenário 3: Dataset real (Iris) para referência

iris = load_iris()

X3, y3 = iris.data, iris.target

cenarios = [

('Moderado (1000x20)', X1, y1),

('Alta Dim (100x50)', X2, y2),

('Real (Iris)', X3, y3)

]

# Solvers a serem testados

solvers = ['svd', 'lsqr', 'eigen']

shrinkage_values = [None, 'auto', 0.5]

'''

Avaliação sistemática dos solvers em diferentes cenários

'''

print("\n2. AVALIAÇÃO DOS SOLVERS")

resultados_completos = {}

for cenario_nome, X, y in cenarios:

print(f"\n--- {cenario_nome} ---")

print(f"Dimensões: {X.shape}, Classes: {len(np.unique(y))}")

# Padronizando os dados

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Dividindo em treino e teste

X_train, X_test, y_train, y_test = train_test_split(

X_scaled, y, test_size=0.3, random_state=42

)

cenario_resultados = {}

for solver in solvers:

for shrinkage in shrinkage_values:

# Configuração específica para cada combinação

if solver == 'svd' and shrinkage is not None:

continue # SVD não suporta shrinkage

try:

# Medindo tempo de treinamento

start_time = time.time()

if shrinkage is not None:

lda = LinearDiscriminantAnalysis(solver=solver, shrinkage=shrinkage)

else:

lda = LinearDiscriminantAnalysis(solver=solver)

# Treinamento

lda.fit(X_train, y_train)

train_time = time.time() - start_time

# Previsões e acurácia

y_pred = lda.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

# Validação cruzada para avaliação robusta

cv_scores = cross_val_score(lda, X_scaled, y, cv=5)

cv_mean = np.mean(cv_scores)

cv_std = np.std(cv_scores)

# Armazenando resultados

config_key = f"{solver}_shrink{shrinkage}"

cenario_resultados[config_key] = {

'solver': solver,

'shrinkage': shrinkage,

'accuracy': accuracy,

'cv_mean': cv_mean,

'cv_std': cv_std,

'train_time': train_time,

'model': lda

}

print(f" {config_key}:")

print(f" Acurácia: {accuracy:.3f}, CV: {cv_mean:.3f} ± {cv_std:.3f}")

print(f" Tempo: {train_time:.4f}s")

except Exception as e:

print(f" {config_key}: ERRO - {e}")

resultados_completos[cenario_nome] = cenario_resultados

'''

Análise de performance computacional

'''

print("\n3. ANÁLISE DE PERFORMANCE COMPUTACIONAL")

# Coletando dados de tempo para comparação

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

# Gráfico 1: Tempo de treinamento por cenário

for idx, (cenario_nome, resultados) in enumerate(resultados_completos.items()):

ax = axes[0, 0] if idx == 0 else axes[0, 1] if idx == 1 else axes[1, 0]

configs = []

tempos = []

for config_key, dados in resultados.items():

configs.append(config_key)

tempos.append(dados['train_time'])

bars = ax.bar(configs, tempos, color=['blue', 'orange', 'green'][:len(configs)])

ax.set_title(f'Tempo de Treinamento - {cenario_nome}')

ax.set_ylabel('Tempo (segundos)')

ax.tick_params(axis='x', rotation=45)

# Adicionando valores nas barras

for bar, tempo in zip(bars, tempos):

ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.001,

f'{tempo:.4f}s', ha='center', va='bottom', fontsize=8)

# Gráfico 2: Comparação de acurácia entre solvers

ax_acc = axes[1, 1]

solver_accuracies = {solver: [] for solver in solvers}

for cenario_nome, resultados in resultados_completos.items():

for solver in solvers:

# Buscando a melhor configuração para cada solver

solver_configs = [k for k in resultados.keys() if k.startswith(solver)]

if solver_configs:

best_config = max(solver_configs, key=lambda k: resultados[k]['cv_mean'])

solver_accuracies[solver].append(resultados[best_config]['cv_mean'])

# Plotando acurácias médias

cenario_nomes = [nome for nome, _ in cenarios]

x_pos = np.arange(len(cenario_nomes))

width = 0.25

for idx, solver in enumerate(solvers):

if solver_accuracies[solver]: # Verifica se há dados

ax_acc.bar(x_pos + idx*width, solver_accuracies[solver], width, label=solver)

ax_acc.set_xlabel('Cenários')

ax_acc.set_ylabel('Acurácia (CV)')

ax_acc.set_title('Acurácia por Solver e Cenário')

ax_acc.set_xticks(x_pos + width)

ax_acc.set_xticklabels(cenario_nomes)

ax_acc.legend()

ax_acc.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

'''

Análise de estabilidade numérica

'''

print("\n4. ANÁLISE DE ESTABILIDADE NUMÉRICA")

# Testando casos extremos

print("\nCenários Extremos:")

# Caso 1: Mais features que amostras

X_extremo1, y_extremo1 = make_classification(

n_samples=50, n_features=100, n_informative=10,

n_classes=2, random_state=42

)

# Caso 2: Matriz quase singular

X_extremo2 = np.random.randn(200, 10)

# Criando correlações fortes para tornar a matriz quase singular

X_extremo2[:, 5] = X_extremo2[:, 4] + 0.01 * np.random.randn(200)

X_extremo2[:, 6] = X_extremo2[:, 4] + 0.01 * np.random.randn(200)

y_extremo2 = np.random.randint(0, 2, 200)

cenarios_extremos = [

('Mais Features (50x100)', X_extremo1, y_extremo1),

('Quase Singular (200x10)', X_extremo2, y_extremo2)

]

for cenario_nome, X, y in cenarios_extremos:

print(f"\n{cenario_nome}:")

X_scaled = StandardScaler().fit_transform(X)

for solver in solvers:

try:

if solver == 'svd':

lda = LinearDiscriminantAnalysis(solver=solver)

else:

lda = LinearDiscriminantAnalysis(solver=solver, shrinkage='auto')

lda.fit(X_scaled, y)

score = lda.score(X_scaled, y)

print(f" {solver}: OK (score: {score:.3f})")

except Exception as e:

print(f" {solver}: FALHOU - {e}")

'''

Recomendações práticas baseadas nos resultados

'''

print("\n5. RECOMENDAÇÕES PRÁTICAS")

print("\nBaseado na análise experimental, recomenda-se:")

print("\nPara datasets gerais:")

print(" - Usar 'svd' como primeira opção (mais estável)")

print(" - Especificar solver apenas se necessário")

print(" - Deixar a seleção automática quando possível")

print("\nQuando usar shrinkage:")

print(" - Preferir 'lsqr' ou 'eigen'")

print(" - 'lsqr' geralmente mais robusto para alta dimensionalidade")

print(" - 'eigen' mais eficiente para datasets menores")

print("\nPara casos específicos:")

print(" - Alta dimensionalidade: 'svd' ou 'lsqr' com shrinkage")

print(" - Poucas amostras: 'svd' (evita problemas de singularidade)")

print(" - Datasets grandes: 'lsqr' (escalabilidade)")

print(" - Precisão máxima: testar múltiplos solvers com validação cruzada")

'''

Análise das propriedades dos solvers

'''

print("\n6. PROPRIEDADES DOS SOLVERS")

propriedades = {

'svd': {

'shrinkage': 'Não suportado',

'estabilidade': 'Alta',

'dimensionalidade': 'Alta compatibilidade',

'casos_especiais': 'Excelente para matrizes singulares'

'lsqr': {

'shrinkage': 'Suportado',

'estabilidade': 'Média-Alta',

'dimensionalidade': 'Boa escalabilidade',

'casos_especiais': 'Bom com regularização'

'eigen': {

'shrinkage': 'Suportado',

'estabilidade': 'Média',

'dimensionalidade': 'Limitada por p³',

'casos_especiais': 'Sensível a mal-condicionamento'

}

for solver, props in propriedades.items():

print(f"\n{solver.upper()}:")

for prop, valor in props.items():

print(f" {prop}: {valor}")

Interpretação dos Resultados

Analisando os experimentos comparativos, podemos observar padrões importantes:

O solver svd demonstra maior estabilidade em cenários desafiadores
Os solvers lsqr e eigen são essenciais quando shrinkage é necessário
A seleção automática geralmente faz escolhas adequadas
Cada solver possui trade-offs específicos entre precisão, velocidade e estabilidade

Implicações Práticas

Escolha do Solver

Inegavelmente, a escolha do algoritmo de estimação deve considerar:

Características dos dados: dimensionalidade, tamanho da amostra, correlações
Requisitos de performance: tempo de treinamento vs precisão
Necessidade de regularização: uso de shrinkage ou outras técnicas
Robustez necessária: estabilidade em cenários variados

Boas Práticas

Conforme demonstrado nos experimentos, recomenda-se:

Começar com a configuração padrão (seleção automática)
Especificar o solver apenas quando necessário para casos específicos
Usar validação cruzada para comparar diferentes abordagens
Considerar o trade-off entre complexidade e benefícios

Conclusão

Os algoritmos de estimação representam a ponte entre as fundamentações matemáticas do LDA/QDA e sua aplicação prática eficiente. Embora as diferenças entre os solvers possam parecer técnicas, seu impacto no desempenho e robustez dos classificadores é significativo.

Portanto, compreender estas opções e saber quando utilizá-las permite extrair o máximo potencial dos classificadores discriminantes, adaptando-se adequadamente às características específicas de cada problema e conjunto de dados.

Referência

Este post explora o item 1.2.5. Algoritmos de estimativa da documentação do scikit-learn:

https://scikit-learn.org/0.21/modules/lda_qda.html