Arquivo de glm - Página 2 de 3

Modelos Lineares Generalizados: Laço LARS

19/12/202518/10/2025 Por antonino

Anteriormente exploramos diversas implementações do Lasso. Analogamente, o LassoLars oferece uma abordagem computacionalmente eficiente para resolver problemas Lasso usando o algoritmo LARS (Least Angle Regression).

Conceito Fundamental do LassoLars

Primordialmente, o LassoLars combina o algoritmo LARS com a penalidade L1 do Lasso. Decerto, ao contrário de métodos baseados em otimização convexa, o LARS constrói a solução de forma incremental, adicionando uma feature por vez ao modelo.

Conforme a documentação do scikit-learn, o LassoLars é computacionalmente eficiente quando o número de features é muito maior que o número de amostras. Similarmente ao Lasso tradicional, ele produz soluções esparsas, mas com uma abordagem algorítmica diferente.

O Algoritmo LARS

O algoritmo LARS opera através dos seguintes passos:

Começa com todos coeficientes iguais a zero
Encontra a feature mais correlacionada com o resíduo
Move o coeficiente na direção do sinal da correlação
Para quando outra feature tem correlação igual com o resíduo
Adiciona essa feature ao conjunto ativo e continua

Características Principais

Inegavelmente, o LassoLars possui propriedades únicas que o distinguem de outras implementações:

Caminho de solução completo: Computa todo o caminho de regularização de uma vez
Eficiência numérica: Mais rápido que métodos baseados em otimização para p >> n
Solução exata: Fornece solução exata em cada passo, não aproximada
Seleção de variáveis: Mantém a capacidade de zerar coeficientes do Lasso

Vantagens sobre Lasso Tradicional

Embora ambos resolvam o mesmo problema, o LassoLars oferece benefícios específicos:

Eficiência: Mais rápido quando número de features é grande
Caminho completo: Obtém soluções para todos valores de regularização
Estabilidade numérica: Menos sensível a problemas numéricos
Interpretabilidade: Ordem de entrada das features é informativa

Exemplo Prático: LassoLars em Ação

Ademais, vejamos um exemplo completo demonstrando o uso do LassoLars:

print(__doc__)

# Autor: Fabian Pedregosa <fabian.pedregosa@inria.fr> 
# Alexandre Gramfort <alexandre.gramfort@inria.fr> 
# Licença: cláusula BSD 3

import numpy as np
import matplotlib.pyplot as plt

from sklearn import linear_model
from sklearn import datasets

diabetes = datasets.load_diabetes()
X = diabetes.data
y = diabetes.target

print("Calculando caminho de regularização usando o LARS...")
_, _, coefs = linear_model.lars_path(X, y, method='lasso', verbose=True)

xx = np.sum(np.abs(coefs.T), axis=1)
xx /= xx[-1]

plt.figure(figsize=(12, 8))
plt.plot(xx, coefs.T)
ymin, ymax = plt.ylim()
plt.vlines(xx, ymin, ymax, linestyle='dashed', alpha=0.3)
plt.xlabel('|coef| / max|coef|')
plt.ylabel('Coeficientes')
plt.title('Caminho LASSO - Dataset Diabetes')
plt.axis('tight')
plt.grid(True, alpha=0.3)
plt.show()

# Adicionando análise adicional
print(f"\n--- Informações do Dataset Diabetes ---")
print(f"Número de amostras: {X.shape[0]}")
print(f"Número de features: {X.shape[1]}")
print(f"Features: {diabetes.feature_names}")

# Criar gráficos adicionais para melhor compreensão
plt.figure(figsize=(15, 5))

# Gráfico 1: Caminho LASSO com cores diferentes para cada feature
plt.subplot(1, 3, 1)
colors = plt.cm.Set1(np.linspace(0, 1, coefs.shape[0]))
for i, color in enumerate(colors):
    plt.plot(xx, coefs[i], color=color, label=diabetes.feature_names[i] if i < len(diabetes.feature_names) else f'Feature {i}')
plt.xlabel('|coef| / max|coef|')
plt.ylabel('Coeficientes')
plt.title('Caminho LASSO - Features Coloridas')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)

# Gráfico 2: Ordem de entrada das features no caminho LARS
plt.subplot(1, 3, 2)
# Calcular quando cada feature entra no modelo
active_features = []
for i in range(coefs.shape[1]):
    active = np.where(coefs[:, i] != 0)[0]
    for feat in active:
        if feat not in active_features:
            active_features.append(feat)

plt.bar(range(len(active_features)), [i+1 for i in range(len(active_features))])
plt.xticks(range(len(active_features)), [diabetes.feature_names[i] for i in active_features], rotation=45)
plt.ylabel('Ordem de Entrada')
plt.title('Ordem de Seleção das Features')

# Gráfico 3: Valores finais dos coeficientes
plt.subplot(1, 3, 3)
final_coefs = coefs[:, -1]
colors = ['red' if coef != 0 else 'blue' for coef in final_coefs]
bars = plt.bar(diabetes.feature_names, final_coefs, color=colors, alpha=0.7)
plt.axhline(y=0, color='black', linestyle='-', alpha=0.5)
plt.ylabel('Valor Final do Coeficiente')
plt.title('Coeficientes Finais no Caminho LASSO')
plt.xticks(rotation=45)
for bar, coef in zip(bars, final_coefs):
    if coef != 0:
        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + (0.1 if bar.get_height() > 0 else -0.3), 
                f'{coef:.2f}', ha='center', va='bottom' if bar.get_height() > 0 else 'top', fontsize=8)

plt.tight_layout()
plt.show()

# Análise estatística
print(f"\n--- Análise do Caminho LASSO ---")
print(f"Número total de passos no caminho: {coefs.shape[1]}")
print(f"Features selecionadas no final: {np.sum(final_coefs != 0)} de {len(final_coefs)}")
print(f"Features zeradas: {np.sum(final_coefs == 0)}")

# Mostrar a ordem de entrada das features
print(f"\nOrdem de entrada das features no modelo:")
for i, feat_idx in enumerate(active_features):
    print(f"{i+1}º: {diabetes.feature_names[feat_idx]}")

# Valores dos coeficientes em diferentes pontos do caminho
print(f"\n--- Valores dos Coeficientes em Diferentes Pontos ---")
checkpoints = [0, coefs.shape[1]//4, coefs.shape[1]//2, coefs.shape[1]-1]
for checkpoint in checkpoints:
    print(f"\nPonto {checkpoint+1}/{coefs.shape[1]} (|coef|/max|coef| = {xx[checkpoint]:.3f}):")
    for i, name in enumerate(diabetes.feature_names):
        if coefs[i, checkpoint] != 0:
            print(f"  {name}: {coefs[i, checkpoint]:.4f}")

100

101

102

103

104

print(__doc__)

# Autor: Fabian Pedregosa <fabian.pedregosa@inria.fr>

# Alexandre Gramfort <alexandre.gramfort@inria.fr>

# Licença: cláusula BSD 3

import numpy as np

import matplotlib.pyplot as plt

from sklearn import linear_model

from sklearn import datasets

diabetes = datasets.load_diabetes()

X = diabetes.data

y = diabetes.target

print("Calculando caminho de regularização usando o LARS...")

_, _, coefs = linear_model.lars_path(X, y, method='lasso', verbose=True)

xx = np.sum(np.abs(coefs.T), axis=1)

xx /= xx[-1]

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

plt.plot(xx, coefs.T)

ymin, ymax = plt.ylim()

plt.vlines(xx, ymin, ymax, linestyle='dashed', alpha=0.3)

plt.xlabel('|coef| / max|coef|')

plt.ylabel('Coeficientes')

plt.title('Caminho LASSO - Dataset Diabetes')

plt.axis('tight')

plt.grid(True, alpha=0.3)

plt.show()

# Adicionando análise adicional

print(f"\n--- Informações do Dataset Diabetes ---")

print(f"Número de amostras: {X.shape[0]}")

print(f"Número de features: {X.shape[1]}")

print(f"Features: {diabetes.feature_names}")

# Criar gráficos adicionais para melhor compreensão

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

# Gráfico 1: Caminho LASSO com cores diferentes para cada feature

plt.subplot(1, 3, 1)

colors = plt.cm.Set1(np.linspace(0, 1, coefs.shape[0]))

for i, color in enumerate(colors):

plt.plot(xx, coefs[i], color=color, label=diabetes.feature_names[i] if i < len(diabetes.feature_names) else f'Feature {i}')

plt.xlabel('|coef| / max|coef|')

plt.ylabel('Coeficientes')

plt.title('Caminho LASSO - Features Coloridas')

plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')

plt.grid(True, alpha=0.3)

# Gráfico 2: Ordem de entrada das features no caminho LARS

plt.subplot(1, 3, 2)

# Calcular quando cada feature entra no modelo

active_features = []

for i in range(coefs.shape[1]):

active = np.where(coefs[:, i] != 0)[0]

for feat in active:

if feat not in active_features:

active_features.append(feat)

plt.bar(range(len(active_features)), [i+1 for i in range(len(active_features))])

plt.xticks(range(len(active_features)), [diabetes.feature_names[i] for i in active_features], rotation=45)

plt.ylabel('Ordem de Entrada')

plt.title('Ordem de Seleção das Features')

# Gráfico 3: Valores finais dos coeficientes

plt.subplot(1, 3, 3)

final_coefs = coefs[:, -1]

colors = ['red' if coef != 0 else 'blue' for coef in final_coefs]

bars = plt.bar(diabetes.feature_names, final_coefs, color=colors, alpha=0.7)

plt.axhline(y=0, color='black', linestyle='-', alpha=0.5)

plt.ylabel('Valor Final do Coeficiente')

plt.title('Coeficientes Finais no Caminho LASSO')

plt.xticks(rotation=45)

for bar, coef in zip(bars, final_coefs):

if coef != 0:

plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + (0.1 if bar.get_height() > 0 else -0.3),

f'{coef:.2f}', ha='center', va='bottom' if bar.get_height() > 0 else 'top', fontsize=8)

plt.tight_layout()

plt.show()

# Análise estatística

print(f"\n--- Análise do Caminho LASSO ---")

print(f"Número total de passos no caminho: {coefs.shape[1]}")

print(f"Features selecionadas no final: {np.sum(final_coefs != 0)} de {len(final_coefs)}")

print(f"Features zeradas: {np.sum(final_coefs == 0)}")

# Mostrar a ordem de entrada das features

print(f"\nOrdem de entrada das features no modelo:")

for i, feat_idx in enumerate(active_features):

print(f"{i+1}º: {diabetes.feature_names[feat_idx]}")

# Valores dos coeficientes em diferentes pontos do caminho

print(f"\n--- Valores dos Coeficientes em Diferentes Pontos ---")

checkpoints = [0, coefs.shape[1]//4, coefs.shape[1]//2, coefs.shape[1]-1]

for checkpoint in checkpoints:

print(f"\nPonto {checkpoint+1}/{coefs.shape[1]} (|coef|/max|coef| = {xx[checkpoint]:.3f}):")

for i, name in enumerate(diabetes.feature_names):

if coefs[i, checkpoint] != 0:

print(f" {name}: {coefs[i, checkpoint]:.4f}")

Casos de Uso Recomendados

O LassoLars é particularmente eficaz em:

Alta dimensionalidade: Quando número de features é muito maior que número de amostras (p >> n)
Seleção de variáveis: Quando a ordem de importância das features é relevante
Análise exploratória: Para entender o caminho de solução completo
Problemas computacionalmente intensivos: Onde eficiência é crucial

Considerações Práticas

Algumas recomendações importantes para uso eficaz:

Use LassoLars quando p >> n para melhor eficiência
Considere LassoLarsIC para seleção automática do parâmetro alpha
O parâmetro max_iter controla o número máximo de iterações/features
Para problemas com p < n, o Lasso tradicional pode ser suficiente

Variantes do LARS

O scikit-learn oferece várias variantes do algoritmo:

Lars: Versão sem penalidade L1 (regressão por ângulos mínimos)
LassoLars: Combinação de LARS com penalidade L1
LassoLarsIC: Com critério de informação para seleção de modelo

Enfim, o LassoLars representa uma abordagem algorítmica elegante e eficiente para problemas Lasso, especialmente em cenários de alta dimensionalidade onde a eficiência computacional e a interpretabilidade do caminho de solução são importantes.

Referência: https://scikit-learn.org/0.21/modules/linear_model.html#lars-lasso

Modelos Lineares Generalizados: Rede Elástica

19/12/202518/10/2025 Por antonino

Anteriormente exploramos o Lasso e Ridge como técnicas de regularização separadas. Analogamente, a Rede Elástica (Elastic Net) combina as penalidades L1 e L2, oferecendo os benefícios de ambas as abordagens em um único modelo.

Conceito Fundamental da Elastic Net

Primordialmente, a Elastic Net aborda algumas limitações do Lasso, especialmente quando lidamos com features altamente correlacionadas. Decerto, enquanto o Lasso tende a selecionar apenas uma feature de um grupo correlacionado, a Elastic Net pode selecionar todo o grupo.

Conforme a documentação do scikit-learn, a Elastic Net é particularmente útil quando o número de features é maior que o número de amostras, ou quando há alta correlação entre as features. Similarmente às outras técnicas de regularização, ela ajuda a prevenir overfitting.

Formulação Matemática

O objetivo da Elastic Net é minimizar a seguinte função:

\(\min_{w} \frac{1}{2n}||Xw – y||_2^2 + \alpha\rho||w||_1 + \frac{\alpha(1-\rho)}{2}||w||_2^2\)

Onde:

X é a matriz de features
y é o vetor target
w são os coeficientes do modelo
α é o parâmetro de regularização principal
ρ é a razão de mistura L1 (l1_ratio)
||w||₁ é a norma L1 (penalidade Lasso)
||w||₂² é a norma L2 ao quadrado (penalidade Ridge)

Características Principais

Inegavelmente, a Elastic Net combina as melhores propriedades do Lasso e Ridge:

Seleção de features: Herda a capacidade de zerar coeficientes do Lasso
Estabilidade com correlação: Herda a robustez do Ridge com features correlacionadas
Controle flexível: Parâmetro l1_ratio controla o balanceamento entre L1 e L2
Performance em high-dimension: Funciona bem quando p > n

Interpretação do Parâmetro l1_ratio

O parâmetro l1_ratio controla a mistura entre Lasso e Ridge:

l1_ratio = 1: Elastic Net se torna Lasso puro
l1_ratio = 0: Elastic Net se torna Ridge puro
0 < l1_ratio < 1: Combinação balanceada entre L1 e L2

Vantagens sobre Lasso e Ridge

Embora Lasso e Ridge sejam úteis, a Elastic Net oferece vantagens em cenários específicos:

Features correlacionadas: Lasso seleciona aleatoriamente, Elastic Net seleciona grupo
Seleção de variáveis: Mantém a capacidade de seleção do Lasso
Estabilidade: Mais estável que Lasso com alta correlação
Performance preditiva: Frequentemente supera ambos em prática

Exemplo Prático: Elastic Net em Ação

Ademais, vejamos um exemplo completo demonstrando o uso da Elastic Net:

'''
Aplicação da Elastic Net para Regressão
Este exemplo demonstra como a Elastic Net combina
as vantagens do Lasso e Ridge em diferentes cenários
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import ElasticNet, Lasso, Ridge
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com features correlacionadas
n_samples = 500
n_features = 20
n_informative = 8

print("Configuração do Dataset:")
print(f"Número de amostras: {n_samples}")
print(f"Número de features: {n_features}")
print(f"Features informativas: {n_informative}")

# Gerar dados com grupos de features correlacionadas
X, y, true_coef = make_regression(n_samples=n_samples, n_features=n_features,
                                 n_informative=n_informative, noise=20,
                                 coef=True, random_state=42)

# Adicionar correlação entre algumas features
rng = np.random.RandomState(42)
for i in range(0, n_informative, 2):
    if i + 1 < n_informative:
        X[:, i+1] = X[:, i] * 0.7 + rng.normal(0, 0.1, n_samples)

print(f"\nDimensões: X {X.shape}, y {y.shape}")

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

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

print(f"\n--- Comparação: Elastic Net vs Lasso vs Ridge ---")

# Elastic Net
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)
elastic_net.fit(X_train_scaled, y_train)
y_pred_en = elastic_net.predict(X_test_scaled)
mse_en = mean_squared_error(y_test, y_pred_en)
r2_en = r2_score(y_test, y_pred_en)

# Lasso
lasso = Lasso(alpha=0.1, max_iter=10000, random_state=42)
lasso.fit(X_train_scaled, y_train)
y_pred_lasso = lasso.predict(X_test_scaled)
mse_lasso = mean_squared_error(y_test, y_pred_lasso)
r2_lasso = r2_score(y_test, y_pred_lasso)

# Ridge
ridge = Ridge(alpha=0.1, random_state=42)
ridge.fit(X_train_scaled, y_train)
y_pred_ridge = ridge.predict(X_test_scaled)
mse_ridge = mean_squared_error(y_test, y_pred_ridge)
r2_ridge = r2_score(y_test, y_pred_ridge)

print(f"\nElastic Net:")
print(f"MSE: {mse_en:.2f}, R²: {r2_en:.4f}")
print(f"Features selecionadas: {np.sum(elastic_net.coef_ != 0)}")

print(f"\nLasso:")
print(f"MSE: {mse_lasso:.2f}, R²: {r2_lasso:.4f}")
print(f"Features selecionadas: {np.sum(lasso.coef_ != 0)}")

print(f"\nRidge:")
print(f"MSE: {mse_ridge:.2f}, R²: {r2_ridge:.4f}")
print(f"Features selecionadas: {np.sum(ridge.coef_ != 0)}")

# Otimização dos hiperparâmetros da Elastic Net
print(f"\n--- Otimização dos Hiperparâmetros da Elastic Net ---")

param_grid = {
    'alpha': [0.001, 0.01, 0.1, 1, 10],
    'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]
}

grid_search = GridSearchCV(ElasticNet(max_iter=10000, random_state=42),
                          param_grid, cv=5, scoring='neg_mean_squared_error',
                          n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

print(f"Melhores parâmetros: {grid_search.best_params_}")
print(f"Melhor MSE na validação: {-grid_search.best_score_:.2f}")

# Modelo Elastic Net otimizado
best_en = grid_search.best_estimator_
y_pred_best = best_en.predict(X_test_scaled)
final_mse = mean_squared_error(y_test, y_pred_best)
final_r2 = r2_score(y_test, y_pred_best)

print(f"\nElastic Net Otimizado:")
print(f"MSE: {final_mse:.2f}, R²: {final_r2:.4f}")
print(f"Features selecionadas: {np.sum(best_en.coef_ != 0)}")

# Visualização dos resultados
plt.figure(figsize=(15, 10))

# Plot 1: Comparação de coeficientes
plt.subplot(2, 3, 1)
features = range(len(true_coef))
plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=6)
plt.plot(features, elastic_net.coef_, 's-', label='Elastic Net', alpha=0.8)
plt.plot(features, lasso.coef_, '^-', label='Lasso', alpha=0.8)
plt.plot(features, ridge.coef_, 'd-', label='Ridge', alpha=0.8)
plt.xlabel('Feature Index')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot 2: Features selecionadas
plt.subplot(2, 3, 2)
methods = ['Elastic Net', 'Lasso', 'Ridge']
n_selected = [np.sum(elastic_net.coef_ != 0),
              np.sum(lasso.coef_ != 0),
              np.sum(ridge.coef_ != 0)]

plt.bar(methods, n_selected, color=['lightcoral', 'lightgreen', 'skyblue'])
plt.ylabel('Número de Features Selecionadas')
plt.title('Seleção de Features')
plt.xticks(rotation=45)

# Plot 3: Comparação de performance
plt.subplot(2, 3, 3)
mses = [mse_en, mse_lasso, mse_ridge]
plt.bar(methods, mses, color=['lightcoral', 'lightgreen', 'skyblue'])
plt.ylabel('MSE')
plt.title('Comparação de Performance')
plt.xticks(rotation=45)

# Plot 4: Análise do parâmetro l1_ratio
plt.subplot(2, 3, 4)
l1_ratios = param_grid['l1_ratio']
cv_scores = []

for l1_ratio in l1_ratios:
    model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)
    model.fit(X_train_scaled, y_train)
    y_pred = model.predict(X_test_scaled)
    mse = mean_squared_error(y_test, y_pred)
    cv_scores.append(mse)

plt.plot(l1_ratios, cv_scores, 'o-', linewidth=2)
plt.xlabel('l1_ratio')
plt.ylabel('MSE')
plt.title('Performance vs l1_ratio (alpha=0.1)')
plt.grid(True, alpha=0.3)

# Plot 5: Esparsidade vs l1_ratio
plt.subplot(2, 3, 5)
sparsity_levels = []

for l1_ratio in l1_ratios:
    model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)
    model.fit(X_train_scaled, y_train)
    sparsity = np.sum(model.coef_ != 0)
    sparsity_levels.append(sparsity)

plt.plot(l1_ratios, sparsity_levels, 'o-', linewidth=2)
plt.xlabel('l1_ratio')
plt.ylabel('Features Não-Zero')
plt.title('Esparsidade vs l1_ratio')
plt.grid(True, alpha=0.3)

# Plot 6: Matriz de resultados do GridSearch
plt.subplot(2, 3, 6)
results = grid_search.cv_results_
scores = -results['mean_test_score']
alphas = results['param_alpha'].data
l1_ratios = results['param_l1_ratio'].data

# Encontrar melhor combinação
best_idx = np.argmin(scores)
best_alpha = alphas[best_idx]
best_l1_ratio = l1_ratios[best_idx]

plt.scatter(l1_ratios, scores, c=scores, cmap='viridis', s=100, alpha=0.7)
plt.colorbar(label='MSE')
plt.xlabel('l1_ratio')
plt.ylabel('MSE')
plt.title(f'GridSearch: Melhor alpha={best_alpha}, l1_ratio={best_l1_ratio}')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise de grupos correlacionados
print(f"\n--- Análise de Grupos Correlacionados ---")

# Identificar features correlacionadas
correlation_matrix = np.corrcoef(X_train_scaled.T)
high_correlation = np.sum(np.abs(correlation_matrix) > 0.6) - n_features

print(f"Pares de features com correlação > 0.6: {high_correlation//2}")

# Verificar como cada método lida com features correlacionadas
print(f"\nComportamento com Features Correlacionadas:")

# Encontrar pares correlacionados
correlated_pairs = []
for i in range(n_features):
    for j in range(i+1, n_features):
        if abs(correlation_matrix[i, j]) > 0.6:
            correlated_pairs.append((i, j))

for i, (idx1, idx2) in enumerate(correlated_pairs[:3]):  # Mostrar apenas os 3 primeiros
    print(f"\nPar {i+1}: Features {idx1} e {idx2}")
    print(f"  Elastic Net: {best_en.coef_[idx1]:.3f}, {best_en.coef_[idx2]:.3f}")
    print(f"  Lasso: {lasso.coef_[idx1]:.3f}, {lasso.coef_[idx2]:.3f}")
    print(f"  Ridge: {ridge.coef_[idx1]:.3f}, {ridge.coef_[idx2]:.3f}")

# Resumo final
print(f"\n--- Resumo Final ---")
print(f"Melhor modelo: Elastic Net com l1_ratio={grid_search.best_params_['l1_ratio']}")
print(f"Melhoria sobre Lasso: {(mse_lasso - final_mse)/mse_lasso*100:.1f}%")
print(f"Melhoria sobre Ridge: {(mse_ridge - final_mse)/mse_ridge*100:.1f}%")
print(f"Features corretamente identificadas: {np.sum((best_en.coef_ != 0) == (true_coef != 0))}/{n_features}")

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

'''

Aplicação da Elastic Net para Regressão

Este exemplo demonstra como a Elastic Net combina

as vantagens do Lasso e Ridge em diferentes cenários

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import ElasticNet, Lasso, Ridge

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com features correlacionadas

n_samples = 500

n_features = 20

n_informative = 8

print("Configuração do Dataset:")

print(f"Número de amostras: {n_samples}")

print(f"Número de features: {n_features}")

print(f"Features informativas: {n_informative}")

# Gerar dados com grupos de features correlacionadas

X, y, true_coef = make_regression(n_samples=n_samples, n_features=n_features,

n_informative=n_informative, noise=20,

coef=True, random_state=42)

# Adicionar correlação entre algumas features

rng = np.random.RandomState(42)

for i in range(0, n_informative, 2):

if i + 1 < n_informative:

X[:, i+1] = X[:, i] * 0.7 + rng.normal(0, 0.1, n_samples)

print(f"\nDimensões: X {X.shape}, y {y.shape}")

# Dividir em treino e teste

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

random_state=42)

# Normalizar os dados

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(f"\n--- Comparação: Elastic Net vs Lasso vs Ridge ---")

# Elastic Net

elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)

elastic_net.fit(X_train_scaled, y_train)

y_pred_en = elastic_net.predict(X_test_scaled)

mse_en = mean_squared_error(y_test, y_pred_en)

r2_en = r2_score(y_test, y_pred_en)

# Lasso

lasso = Lasso(alpha=0.1, max_iter=10000, random_state=42)

lasso.fit(X_train_scaled, y_train)

y_pred_lasso = lasso.predict(X_test_scaled)

mse_lasso = mean_squared_error(y_test, y_pred_lasso)

r2_lasso = r2_score(y_test, y_pred_lasso)

# Ridge

ridge = Ridge(alpha=0.1, random_state=42)

ridge.fit(X_train_scaled, y_train)

y_pred_ridge = ridge.predict(X_test_scaled)

mse_ridge = mean_squared_error(y_test, y_pred_ridge)

r2_ridge = r2_score(y_test, y_pred_ridge)

print(f"\nElastic Net:")

print(f"MSE: {mse_en:.2f}, R²: {r2_en:.4f}")

print(f"Features selecionadas: {np.sum(elastic_net.coef_ != 0)}")

print(f"\nLasso:")

print(f"MSE: {mse_lasso:.2f}, R²: {r2_lasso:.4f}")

print(f"Features selecionadas: {np.sum(lasso.coef_ != 0)}")

print(f"\nRidge:")

print(f"MSE: {mse_ridge:.2f}, R²: {r2_ridge:.4f}")

print(f"Features selecionadas: {np.sum(ridge.coef_ != 0)}")

# Otimização dos hiperparâmetros da Elastic Net

print(f"\n--- Otimização dos Hiperparâmetros da Elastic Net ---")

param_grid = {

'alpha': [0.001, 0.01, 0.1, 1, 10],

'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9, 1.0]

}

grid_search = GridSearchCV(ElasticNet(max_iter=10000, random_state=42),

param_grid, cv=5, scoring='neg_mean_squared_error',

n_jobs=-1)

grid_search.fit(X_train_scaled, y_train)

print(f"Melhores parâmetros: {grid_search.best_params_}")

print(f"Melhor MSE na validação: {-grid_search.best_score_:.2f}")

# Modelo Elastic Net otimizado

best_en = grid_search.best_estimator_

y_pred_best = best_en.predict(X_test_scaled)

final_mse = mean_squared_error(y_test, y_pred_best)

final_r2 = r2_score(y_test, y_pred_best)

print(f"\nElastic Net Otimizado:")

print(f"MSE: {final_mse:.2f}, R²: {final_r2:.4f}")

print(f"Features selecionadas: {np.sum(best_en.coef_ != 0)}")

# Visualização dos resultados

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

# Plot 1: Comparação de coeficientes

plt.subplot(2, 3, 1)

features = range(len(true_coef))

plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=6)

plt.plot(features, elastic_net.coef_, 's-', label='Elastic Net', alpha=0.8)

plt.plot(features, lasso.coef_, '^-', label='Lasso', alpha=0.8)

plt.plot(features, ridge.coef_, 'd-', label='Ridge', alpha=0.8)

plt.xlabel('Feature Index')

plt.ylabel('Valor do Coeficiente')

plt.title('Comparação dos Coeficientes')

plt.legend()

plt.grid(True, alpha=0.3)

# Plot 2: Features selecionadas

plt.subplot(2, 3, 2)

methods = ['Elastic Net', 'Lasso', 'Ridge']

n_selected = [np.sum(elastic_net.coef_ != 0),

np.sum(lasso.coef_ != 0),

np.sum(ridge.coef_ != 0)]

plt.bar(methods, n_selected, color=['lightcoral', 'lightgreen', 'skyblue'])

plt.ylabel('Número de Features Selecionadas')

plt.title('Seleção de Features')

plt.xticks(rotation=45)

# Plot 3: Comparação de performance

plt.subplot(2, 3, 3)

mses = [mse_en, mse_lasso, mse_ridge]

plt.bar(methods, mses, color=['lightcoral', 'lightgreen', 'skyblue'])

plt.ylabel('MSE')

plt.title('Comparação de Performance')

plt.xticks(rotation=45)

# Plot 4: Análise do parâmetro l1_ratio

plt.subplot(2, 3, 4)

l1_ratios = param_grid['l1_ratio']

cv_scores = []

for l1_ratio in l1_ratios:

model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)

model.fit(X_train_scaled, y_train)

y_pred = model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

cv_scores.append(mse)

plt.plot(l1_ratios, cv_scores, 'o-', linewidth=2)

plt.xlabel('l1_ratio')

plt.ylabel('MSE')

plt.title('Performance vs l1_ratio (alpha=0.1)')

plt.grid(True, alpha=0.3)

# Plot 5: Esparsidade vs l1_ratio

plt.subplot(2, 3, 5)

sparsity_levels = []

for l1_ratio in l1_ratios:

model = ElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)

model.fit(X_train_scaled, y_train)

sparsity = np.sum(model.coef_ != 0)

sparsity_levels.append(sparsity)

plt.plot(l1_ratios, sparsity_levels, 'o-', linewidth=2)

plt.xlabel('l1_ratio')

plt.ylabel('Features Não-Zero')

plt.title('Esparsidade vs l1_ratio')

plt.grid(True, alpha=0.3)

# Plot 6: Matriz de resultados do GridSearch

plt.subplot(2, 3, 6)

results = grid_search.cv_results_

scores = -results['mean_test_score']

alphas = results['param_alpha'].data

l1_ratios = results['param_l1_ratio'].data

# Encontrar melhor combinação

best_idx = np.argmin(scores)

best_alpha = alphas[best_idx]

best_l1_ratio = l1_ratios[best_idx]

plt.scatter(l1_ratios, scores, c=scores, cmap='viridis', s=100, alpha=0.7)

plt.colorbar(label='MSE')

plt.xlabel('l1_ratio')

plt.ylabel('MSE')

plt.title(f'GridSearch: Melhor alpha={best_alpha}, l1_ratio={best_l1_ratio}')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise de grupos correlacionados

print(f"\n--- Análise de Grupos Correlacionados ---")

# Identificar features correlacionadas

correlation_matrix = np.corrcoef(X_train_scaled.T)

high_correlation = np.sum(np.abs(correlation_matrix) > 0.6) - n_features

print(f"Pares de features com correlação > 0.6: {high_correlation//2}")

# Verificar como cada método lida com features correlacionadas

print(f"\nComportamento com Features Correlacionadas:")

# Encontrar pares correlacionados

correlated_pairs = []

for i in range(n_features):

for j in range(i+1, n_features):

if abs(correlation_matrix[i, j]) > 0.6:

correlated_pairs.append((i, j))

for i, (idx1, idx2) in enumerate(correlated_pairs[:3]): # Mostrar apenas os 3 primeiros

print(f"\nPar {i+1}: Features {idx1} e {idx2}")

print(f" Elastic Net: {best_en.coef_[idx1]:.3f}, {best_en.coef_[idx2]:.3f}")

print(f" Lasso: {lasso.coef_[idx1]:.3f}, {lasso.coef_[idx2]:.3f}")

print(f" Ridge: {ridge.coef_[idx1]:.3f}, {ridge.coef_[idx2]:.3f}")

# Resumo final

print(f"\n--- Resumo Final ---")

print(f"Melhor modelo: Elastic Net com l1_ratio={grid_search.best_params_['l1_ratio']}")

print(f"Melhoria sobre Lasso: {(mse_lasso - final_mse)/mse_lasso*100:.1f}%")

print(f"Melhoria sobre Ridge: {(mse_ridge - final_mse)/mse_ridge*100:.1f}%")

print(f"Features corretamente identificadas: {np.sum((best_en.coef_ != 0) == (true_coef != 0))}/{n_features}")

Casos de Uso Recomendados

A Elastic Net é particularmente eficaz em:

Features altamente correlacionadas: Quando o Lasso falha em selecionar grupos
Problemas de alta dimensionalidade: Quando p > n
Seleção de variáveis com estabilidade: Combinando sparsity e robustez
Quando não se sabe qual regularização usar: Elastic Net como abordagem padrão

Considerações Práticas

Algumas recomendações importantes para uso eficaz:

Sempre normalize os dados antes de usar Elastic Net
Use GridSearchCV ou RandomizedSearchCV para otimizar alpha e l1_ratio
Comece com l1_ratio=0.5 como ponto de partida
Considere a complexidade computacional para datasets muito grandes

Variantes da Elastic Net

O scikit-learn também oferece variantes especializadas:

ElasticNetCV: Com validação cruzada embutida para seleção de parâmetros
MultiTaskElasticNet: Para problemas com múltiplos targets

Enfim, a Elastic Net representa uma abordagem robusta e flexível que combina os pontos fortes do Lasso e Ridge, tornando-se frequentemente a escolha preferida para problemas de regressão regularizada na prática.

Referência: https://scikit-learn.org/0.21/modules/linear_model.html#elastic-net