Arquivo de Python - Página 179 de 218

Continuando nossa análise do guia do scikit-learn, chegamos a um conceito fundamental para expandir a flexibilidade dos modelos lineares: a regressão polinomial. Primordialmente, esta técnica permite capturar relações não-lineares entre variáveis enquanto mantém a estrutura linear do modelo.

O Conceito Fundamental

Conforme observamos anteriormente com os modelos de regressão linear, frequentemente nos deparamos com situações onde a relação entre as variáveis não é estritamente linear. Analogamente, a regressão polinomial surge como uma extensão natural que preserva a linearidade nos parâmetros, mas introduz não-linearidade nas features.

Base Matemática

Enquanto um modelo linear simples segue a forma:

\(y = \beta_0 + \beta_1x + \epsilon\)

A regressão polinomial de grau d expande esta representação para:

\(y = \beta_0 + \beta_1x + \beta_2x^2 + \beta_3x^3 + \cdots + \beta_dx^d + \epsilon\)

Implementação no scikit-learn

No scikit-learn, a regressão polinomial é implementada através de dois componentes principais:

PolynomialFeatures: Transforma features originais em features polinomiais
Um estimador linear (como LinearRegression, Ridge, ou Lasso)

PolynomialFeatures

Esta classe gera novas features criando todas as combinações polinomiais até o grau especificado. Por exemplo, para duas features [a, b] e grau 2, obtemos:

[1, a, b, a², ab, b²]

Inegavelmente, esta abordagem mantém a linearidade nos parâmetros enquanto expande significativamente a capacidade de representação do modelo.

Vantagens e Considerações

Benefícios Principais

Capacidade de capturar relações não-lineares complexas
Mantém as propriedades de estimação dos modelos lineares
Interpretabilidade relativa dos coeficientes
Computacionalmente eficiente comparado a outros métodos não-lineares

Desafios e Cuidados

Embora poderosa, a regressão polinomial requer atenção a alguns aspectos:

Risco de overfitting com graus muito altos
Problemas de condicionamento numérico
Crescimento combinatório do número de features
Necessidade de regularização em muitos casos

Escolha do Grau Polinomial

A seleção do grau apropriado é crucial. Certamente, graus muito baixos podem underfitting, enquanto graus muito altos levam a overfitting. Estratégias comuns incluem:

Validação cruzada para seleção do grau ótimo
Análise de curvas de aprendizado
Uso de regularização (Ridge, Lasso) para controlar complexidade

Exemplo Prático em Python

Para ilustrar a aplicação da regressão polinomial, vejamos um exemplo completo:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

'''
Demonstração de regressão polinomial com diferentes graus
e comparação entre modelos regularizados e não-regularizados
'''

# Gerando dados com relação não-linear verdadeira
np.random.seed(42)
n_samples = 100
X = np.random.uniform(-3, 3, n_samples).reshape(-1, 1)
y_true = np.sin(X.ravel()) + 0.1 * X.ravel()**2
y = y_true + 0.2 * np.random.randn(n_samples)  # Adicionando ruído

# 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)

'''
Configurando pipelines para diferentes graus polinomiais
e tipos de regularização
'''
degrees = [1, 3, 5, 10]
models = {}

for degree in degrees:
    # Modelo sem regularização
    poly_reg = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('linear', LinearRegression())
    ])
    
    # Modelo com regularização Ridge
    poly_ridge = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('ridge', Ridge(alpha=1.0))
    ])
    
    # Treinando os modelos
    poly_reg.fit(X_train, y_train)
    poly_ridge.fit(X_train, y_train)
    
    # Fazendo previsões
    y_pred_reg = poly_reg.predict(X_test)
    y_pred_ridge = poly_ridge.predict(X_test)
    
    # Calculando métricas
    mse_reg = mean_squared_error(y_test, y_pred_reg)
    mse_ridge = mean_squared_error(y_test, y_pred_ridge)
    
    models[degree] = {
        'linear': {'model': poly_reg, 'mse': mse_reg, 'predictions': y_pred_reg},
        'ridge': {'model': poly_ridge, 'mse': mse_ridge, 'predictions': y_pred_ridge}
    }

'''
Visualizando os resultados para diferentes graus
'''
plt.figure(figsize=(15, 10))

# Ordenando pontos para visualização suave
X_plot = np.linspace(-3, 3, 300).reshape(-1, 1)
y_plot_true = np.sin(X_plot.ravel()) + 0.1 * X_plot.ravel()**2

for i, degree in enumerate(degrees, 1):
    plt.subplot(2, 2, i)
    
    # Pontos de treino
    plt.scatter(X_train, y_train, alpha=0.6, label='Dados treino', color='blue')
    plt.scatter(X_test, y_test, alpha=0.6, label='Dados teste', color='green')
    
    # Curva verdadeira
    plt.plot(X_plot, y_plot_true, 'k-', linewidth=2, label='Relação verdadeira')
    
    # Previsões dos modelos
    y_plot_reg = models[degree]['linear']['model'].predict(X_plot)
    y_plot_ridge = models[degree]['ridge']['model'].predict(X_plot)
    
    plt.plot(X_plot, y_plot_reg, 'r-', linewidth=2, 
             label=f'Poly (MSE: {models[degree]["linear"]["mse"]:.3f})')
    plt.plot(X_plot, y_plot_ridge, 'g--', linewidth=2, 
             label=f'Poly+Ridge (MSE: {models[degree]["ridge"]["mse"]:.3f})')
    
    plt.title(f'Grau {degree}')
    plt.legend()
    plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

'''
Análise dos coeficientes para entender o efeito da regularização
'''
print("Análise dos coeficientes para grau 5:")
degree_5_model = models[5]['linear']['model']
degree_5_ridge = models[5]['ridge']['model']

coef_linear = degree_5_model.named_steps['linear'].coef_
coef_ridge = degree_5_ridge.named_steps['ridge'].coef_

print(f"Número de coeficientes: {len(coef_linear)}")
print(f"Norma L2 dos coeficientes (Linear): {np.linalg.norm(coef_linear):.4f}")
print(f"Norma L2 dos coeficientes (Ridge): {np.linalg.norm(coef_ridge):.4f}")

100

101

102

103

104

105

106

107

108

import numpy as np

import matplotlib.pyplot as plt

from sklearn.preprocessing import PolynomialFeatures

from sklearn.linear_model import LinearRegression, Ridge

from sklearn.pipeline import Pipeline

from sklearn.metrics import mean_squared_error

from sklearn.model_selection import train_test_split

'''

Demonstração de regressão polinomial com diferentes graus

e comparação entre modelos regularizados e não-regularizados

'''

# Gerando dados com relação não-linear verdadeira

np.random.seed(42)

n_samples = 100

X = np.random.uniform(-3, 3, n_samples).reshape(-1, 1)

y_true = np.sin(X.ravel()) + 0.1 * X.ravel()**2

y = y_true + 0.2 * np.random.randn(n_samples) # Adicionando ruído

# 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)

'''

Configurando pipelines para diferentes graus polinomiais

e tipos de regularização

'''

degrees = [1, 3, 5, 10]

models = {}

for degree in degrees:

# Modelo sem regularização

poly_reg = Pipeline([

('poly', PolynomialFeatures(degree=degree)),

('linear', LinearRegression())

])

# Modelo com regularização Ridge

poly_ridge = Pipeline([

('poly', PolynomialFeatures(degree=degree)),

('ridge', Ridge(alpha=1.0))

])

# Treinando os modelos

poly_reg.fit(X_train, y_train)

poly_ridge.fit(X_train, y_train)

# Fazendo previsões

y_pred_reg = poly_reg.predict(X_test)

y_pred_ridge = poly_ridge.predict(X_test)

# Calculando métricas

mse_reg = mean_squared_error(y_test, y_pred_reg)

mse_ridge = mean_squared_error(y_test, y_pred_ridge)

models[degree] = {

'linear': {'model': poly_reg, 'mse': mse_reg, 'predictions': y_pred_reg},

'ridge': {'model': poly_ridge, 'mse': mse_ridge, 'predictions': y_pred_ridge}

}

'''

Visualizando os resultados para diferentes graus

'''

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

# Ordenando pontos para visualização suave

X_plot = np.linspace(-3, 3, 300).reshape(-1, 1)

y_plot_true = np.sin(X_plot.ravel()) + 0.1 * X_plot.ravel()**2

for i, degree in enumerate(degrees, 1):

plt.subplot(2, 2, i)

# Pontos de treino

plt.scatter(X_train, y_train, alpha=0.6, label='Dados treino', color='blue')

plt.scatter(X_test, y_test, alpha=0.6, label='Dados teste', color='green')

# Curva verdadeira

plt.plot(X_plot, y_plot_true, 'k-', linewidth=2, label='Relação verdadeira')

# Previsões dos modelos

y_plot_reg = models[degree]['linear']['model'].predict(X_plot)

y_plot_ridge = models[degree]['ridge']['model'].predict(X_plot)

plt.plot(X_plot, y_plot_reg, 'r-', linewidth=2,

label=f'Poly (MSE: {models[degree]["linear"]["mse"]:.3f})')

plt.plot(X_plot, y_plot_ridge, 'g--', linewidth=2,

label=f'Poly+Ridge (MSE: {models[degree]["ridge"]["mse"]:.3f})')

plt.title(f'Grau {degree}')

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

'''

Análise dos coeficientes para entender o efeito da regularização

'''

print("Análise dos coeficientes para grau 5:")

degree_5_model = models[5]['linear']['model']

degree_5_ridge = models[5]['ridge']['model']

coef_linear = degree_5_model.named_steps['linear'].coef_

coef_ridge = degree_5_ridge.named_steps['ridge'].coef_

print(f"Número de coeficientes: {len(coef_linear)}")

print(f"Norma L2 dos coeficientes (Linear): {np.linalg.norm(coef_linear):.4f}")

print(f"Norma L2 dos coeficientes (Ridge): {np.linalg.norm(coef_ridge):.4f}")

Interpretação dos Resultados

Analisando o exemplo, podemos observar que:

Graus muito baixos (1) mostram underfitting evidente
Graus intermediários (3-5) capturam bem a relação não-linear
Graus muito altos (10) podem mostrar overfitting, especialmente sem regularização
A regularização Ridge ajuda a suavizar as previsões e melhorar generalização

Considerações Finais

A regressão polinomial representa uma ponte elegante entre modelos lineares simples e abordagens não-lineares complexas. Embora expanda significativamente a capacidade de modelagem, requer cuidado na seleção do grau polinomial e, frequentemente, beneficia-se de técnicas de regularização.

Portanto, ao aplicar esta técnica na prática, recomenda-se sempre usar validação cruzada para seleção de hiperparâmetros e considerar a combinação com métodos de regularização para obter modelos robustos e generalizáveis.

Analisando a documentação do scikit-learn versão 0.21, chegamos a uma seção crucial para aplicações práticas: a regressão robusta. Primordialmente, esta técnica aborda um problema comum em modelos lineares – a sensibilidade a valores atípicos.

O Desafio dos Outliers

Conforme observamos anteriormente, os modelos de Ordinary Least Squares (OLS) convencionais assumem que os resíduos seguem uma distribuição normal. Contudo, na prática, frequentemente nos deparamos com situações onde:

Existem observações extremas que distorcem as estimativas
Os erros não seguem perfeitamente uma distribuição normal
Há violação dos pressupostos de homocedasticidade

Fundamentos Matemáticos

Enquanto o OLS tradicional minimiza a soma dos quadrados dos resíduos:

\(\min_{w} ||Xw – y||_2^2\)

As abordagens robustas utilizam funções de perda diferentes que são menos sensíveis a outliers. Analogamente, podemos pensar em funções como:

Huber loss
RANSAC (RANdom SAmple Consensus)
Theil-Sen estimator

Abordagens Implementadas no scikit-learn

Huber Regressor

Esta técnica utiliza uma função de perda que se comporta quadraticamente para pequenos resíduos e linearmente para resíduos grandes. Afinal, isso permite que o modelo seja robusto a outliers enquanto mantém eficiência para dados normais.

RANSAC Regressor

O RANSAC opera através de um processo iterativo que:

Seleciona aleatoriamente subconjuntos dos dados
Ajusta modelos a esses subconjuntos
Classifica pontos como inliers ou outliers baseado em um threshold
Seleciona o modelo com maior consenso

Theil-Sen Regressor

Similarmente, o estimador de Theil-Sen calcula slopes entre todos os pares de pontos e utiliza a mediana desses slopes. Inegavelmente, este método é particularmente robusto contra outliers nos dados de entrada.

Quando Utilizar Regressão Robusta?

Certamente, você deve considerar estas abordagens quando:

Suspeita da presença de outliers significativos
Os resíduos do modelo apresentam caudas pesadas
Precisa de estimativas mais confiáveis em dados ruidosos
Trabalha com medições sujeitas a erros grosseiros

Ademais, é importante notar que estas técnicas geralmente são computacionalmente mais custosas que o OLS tradicional.

Exemplo Prático em Python

Para ilustrar a aplicação destes conceitos, vejamos um exemplo comparativo:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, HuberRegressor, RANSACRegressor
from sklearn.metrics import mean_squared_error

'''
Exemplo demonstrando a robustez de diferentes regressores
contra outliers nos dados
'''

# Gerando dados sintéticos com relação linear
np.random.seed(42)
X = np.random.normal(0, 1, 100).reshape(-1, 1)
y_true = 2 * X.ravel() + 1

''' 
Adicionando outliers para simular um cenário real
onde algumas medições estão corrompidas
'''
y_outliers = y_true.copy()
outlier_indices = np.random.choice(100, 10, replace=False)
y_outliers[outlier_indices] += 10 * np.random.randn(10)

# Inicializando os modelos
models = {
    'OLS': LinearRegression(),
    'Huber': HuberRegressor(),
    'RANSAC': RANSACRegressor()
}

# Treinando e avaliando cada modelo
results = {}
for name, model in models.items():
    if name == 'Huber':
        model.fit(X, y_outliers)
    else:
        model.fit(X, y_outliers)
    
    y_pred = model.predict(X)
    mse = mean_squared_error(y_true, y_pred)
    results[name] = {'model': model, 'mse': mse, 'predictions': y_pred}

'''
Comparando os resultados: o RANSAC e Huber devem apresentar
melhor performance em termos de MSE quando comparados ao OLS,
pois são menos sensíveis aos outliers
'''
print("Comparação de MSE entre modelos:")
for name, result in results.items():
    print(f"{name}: {result['mse']:.4f}")

# Visualização dos resultados
plt.figure(figsize=(12, 4))

for i, (name, result) in enumerate(results.items(), 1):
    plt.subplot(1, 3, i)
    plt.scatter(X, y_outliers, alpha=0.6, label='Dados com outliers')
    plt.scatter(X[outlier_indices], y_outliers[outlier_indices], 
                color='red', label='Outliers', alpha=0.8)
    plt.plot(X, result['predictions'], color='black', 
             linewidth=2, label=f'Regressão {name}')
    plt.title(f'{name} (MSE: {result["mse"]:.2f})')
    plt.legend()

plt.tight_layout()
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LinearRegression, HuberRegressor, RANSACRegressor

from sklearn.metrics import mean_squared_error

'''

Exemplo demonstrando a robustez de diferentes regressores

contra outliers nos dados

'''

# Gerando dados sintéticos com relação linear

np.random.seed(42)

X = np.random.normal(0, 1, 100).reshape(-1, 1)

y_true = 2 * X.ravel() + 1

'''

Adicionando outliers para simular um cenário real

onde algumas medições estão corrompidas

'''

y_outliers = y_true.copy()

outlier_indices = np.random.choice(100, 10, replace=False)

y_outliers[outlier_indices] += 10 * np.random.randn(10)

# Inicializando os modelos

models = {

'OLS': LinearRegression(),

'Huber': HuberRegressor(),

'RANSAC': RANSACRegressor()

}

# Treinando e avaliando cada modelo

results = {}

for name, model in models.items():

if name == 'Huber':

model.fit(X, y_outliers)

else:

model.fit(X, y_outliers)

y_pred = model.predict(X)

mse = mean_squared_error(y_true, y_pred)

results[name] = {'model': model, 'mse': mse, 'predictions': y_pred}

'''

Comparando os resultados: o RANSAC e Huber devem apresentar

melhor performance em termos de MSE quando comparados ao OLS,

pois são menos sensíveis aos outliers

'''

print("Comparação de MSE entre modelos:")

for name, result in results.items():

print(f"{name}: {result['mse']:.4f}")

# Visualização dos resultados

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

for i, (name, result) in enumerate(results.items(), 1):

plt.subplot(1, 3, i)

plt.scatter(X, y_outliers, alpha=0.6, label='Dados com outliers')

plt.scatter(X[outlier_indices], y_outliers[outlier_indices],

color='red', label='Outliers', alpha=0.8)

plt.plot(X, result['predictions'], color='black',

linewidth=2, label=f'Regressão {name}')

plt.title(f'{name} (MSE: {result["mse"]:.2f})')

plt.legend()

plt.tight_layout()

plt.show()

Eventualmente, ao executar este código, você observará que os regressores robustos (Huber e RANSAC) produzem estimativas mais próximas da relação linear verdadeira, mesmo na presença de outliers significativos.

Considerações Finais

Embora a regressão robusta ofereça vantagens significativas em cenários com outliers, é importante considerar que:

O aumento da robustez pode vir acompanhado de maior custo computacional
Parâmetros como epsilon no Huber Regressor requerem ajuste cuidadoso
Em dados limpos, o OLS tradicional pode ser mais eficiente

Portanto, a escolha entre abordagens tradicionais e robustas deve considerar as características específicas dos dados e os objetivos do modelo. Inclusive, em muitos casos práticos, uma análise exploratória preliminar pode indicar qual abordagem será mais adequada.

Regressão Polinomial: Estendendo Modelos Lineares com Funções de Base

O Conceito Fundamental

Base Matemática

Implementação no scikit-learn

PolynomialFeatures

Vantagens e Considerações

Benefícios Principais

Desafios e Cuidados

Escolha do Grau Polinomial

Exemplo Prático em Python

Interpretação dos Resultados

Considerações Finais

Modelos Lineares Generalizados: Regressão Robusta com Outliers e Erros de Modelagem

O Desafio dos Outliers

Fundamentos Matemáticos

Abordagens Implementadas no scikit-learn

Huber Regressor

RANSAC Regressor

Theil-Sen Regressor

Quando Utilizar Regressão Robusta?

Exemplo Prático em Python

Considerações Finais