Arquivo de linear-discriminant-analysis

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.