Arquivo de Inteligência Artificial - Página 156 de 165

Regressão Lasso – Teoria e Implementação Prática

25/04/202617/10/2025 Por antonino

Analogamente a um conjunto de ferramentas especializadas, a Regressão Lasso oferece diversas implementações para diferentes cenários. Ademais, conforme documentado no scikit-learn, estas variações atendem a necessidades específicas de seleção de parâmetros e validação.

1.1.3. Lasso

Primordialmente, o Lasso implementa a regressão linear com regularização L1. Certamente, sua formulação matemática busca minimizar a função objetivo:

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

Similarmente a um filtro de precisão, o Lasso é capaz de produzir modelos esparsos através da eliminação seletiva de coeficientes.

1.1.3.1. Definindo o parâmetro de regularização

O parâmetro alpha controla o grau de esparsidade dos coeficientes estimados. Contudo, a seleção adequada deste parâmetro é crucial para o desempenho do modelo.

1.1.3.1.1. Uso de validação cruzada

O scikit-learn fornece LassoCV, que automaticamente seleciona o melhor alpha através de validação cruzada. Decerto, esta abordagem é preferível na prática, pois evita a seleção manual e potencialmente subótima do parâmetro.

1.1.3.1.2. Critérios de informação

Alternativamente, LassoLarsIC utiliza critérios de informação como Akaike (AIC) ou Bayesiano (BIC) para selecionar o modelo ótimo. Embora computacionalmente mais eficiente, esta abordagem requer cuidados adicionais.

1.1.3.1.3. Comparação com o modelo de mínimos quadrados

Comparado aos Mínimos Quadrados Ordinários, o Lasso oferece melhor generalização em troca de um viés introduzido. Todavia, este trade-off é frequentemente vantajoso em datasets com muitas features.

Exemplo Prático com Diferentes Abordagens

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso, LassoCV, LassoLarsIC
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

print("=" * 60)
print("COMPARAÇÃO: DIFERENTES ABORDAGENS LASSO")
print("=" * 60)

# Gerar dados com features redundantes
X, y = make_regression(n_samples=200, n_features=15, n_informative=5,
                       noise=0.5, random_state=42, coef=True)

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

print(f"Dataset: {X.shape[0]} amostras, {X.shape[1]} features")
print(f"Features informativas verdadeiras: 5")
print(f"Treino: {X_train.shape[0]} amostras | Teste: {X_test.shape[0]} amostras")

# 1. LASSO com alpha fixo
print("\n" + "=" * 50)
print("1. LASSO COM ALPHA FIXO")
print("=" * 50)

lasso_fixo = Lasso(alpha=0.1, max_iter=10000, random_state=42)
lasso_fixo.fit(X_train, y_train)

y_pred_fixo = lasso_fixo.predict(X_test)
mse_fixo = mean_squared_error(y_test, y_pred_fixo)
r2_fixo = r2_score(y_test, y_pred_fixo)

print(f"Alpha: 0.1")
print(f"Features selecionadas: {np.sum(lasso_fixo.coef_ != 0)}/15")
print(f"MSE teste: {mse_fixo:.4f}")
print(f"R² teste: {r2_fixo:.4f}")

# 2. LASSO com validação cruzada (LassoCV)
print("\n" + "=" * 50)
print("2. LASSO COM VALIDAÇÃO CRUZADA (LassoCV)")
print("=" * 50)

# Definir range de alphas para busca
alphas = np.logspace(-4, 0, 50)
lasso_cv = LassoCV(alphas=alphas, cv=5, max_iter=10000, random_state=42)
lasso_cv.fit(X_train, y_train)

y_pred_cv = lasso_cv.predict(X_test)
mse_cv = mean_squared_error(y_test, y_pred_cv)
r2_cv = r2_score(y_test, y_pred_cv)

print(f"Melhor alpha (CV): {lasso_cv.alpha_:.6f}")
print(f"Features selecionadas: {np.sum(lasso_cv.coef_ != 0)}/15")
print(f"MSE teste: {mse_cv:.4f}")
print(f"R² teste: {r2_cv:.4f}")

# 3. LASSO com critério de informação (LassoLarsIC)
print("\n" + "=" * 50)
print("3. LASSO COM CRITÉRIO DE INFORMAÇÃO (LassoLarsIC)")
print("=" * 50)

# AIC (Akaike Information Criterion)
lasso_aic = LassoLarsIC(criterion='aic')
lasso_aic.fit(X_train, y_train)

y_pred_aic = lasso_aic.predict(X_test)
mse_aic = mean_squared_error(y_test, y_pred_aic)
r2_aic = r2_score(y_test, y_pred_aic)

print(f"Alpha (AIC): {lasso_aic.alpha_:.6f}")
print(f"Features selecionadas: {np.sum(lasso_aic.coef_ != 0)}/15")
print(f"MSE teste: {mse_aic:.4f}")
print(f"R² teste: {r2_aic:.4f}")

# BIC (Bayesian Information Criterion)
lasso_bic = LassoLarsIC(criterion='bic')
lasso_bic.fit(X_train, y_train)

y_pred_bic = lasso_bic.predict(X_test)
mse_bic = mean_squared_error(y_test, y_pred_bic)
r2_bic = r2_score(y_test, y_pred_bic)

print(f"\nAlpha (BIC): {lasso_bic.alpha_:.6f}")
print(f"Features selecionadas: {np.sum(lasso_bic.coef_ != 0)}/15")
print(f"MSE teste: {mse_bic:.4f}")
print(f"R² teste: {r2_bic:.4f}")

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

# Gráfico 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
modelos = [lasso_fixo, lasso_cv, lasso_aic, lasso_bic]
nomes = ['Alpha Fixo', 'CV', 'AIC', 'BIC']
cores = ['red', 'blue', 'green', 'orange']

for i, modelo in enumerate(modelos):
    plt.bar(np.arange(15) + i*0.2, modelo.coef_, width=0.2, 
            label=nomes[i], alpha=0.7, color=cores[i])

plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes entre Abordagens')
plt.xticks(np.arange(15) + 0.3, [f'F{i+1}' for i in range(15)])
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 2: Número de features selecionadas
plt.subplot(2, 2, 2)
features_selecionadas = [np.sum(m.coef_ != 0) for m in modelos]
plt.bar(nomes, features_selecionadas, color=cores, alpha=0.7)
plt.ylabel('Número de Features Selecionadas')
plt.title('Esparsidade: Features Não Nulas')
for i, v in enumerate(features_selecionadas):
    plt.text(i, v + 0.1, str(v), ha='center', va='bottom')
plt.grid(True, alpha=0.3)

# Gráfico 3: Performance (MSE)
plt.subplot(2, 2, 3)
mse_valores = [mse_fixo, mse_cv, mse_aic, mse_bic]
plt.bar(nomes, mse_valores, color=cores, alpha=0.7)
plt.ylabel('Mean Squared Error (Teste)')
plt.title('Comparação de Performance - MSE')
for i, v in enumerate(mse_valores):
    plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')
plt.grid(True, alpha=0.3)

# Gráfico 4: Performance (R²)
plt.subplot(2, 2, 4)
r2_valores = [r2_fixo, r2_cv, r2_aic, r2_bic]
plt.bar(nomes, r2_valores, color=cores, alpha=0.7)
plt.ylabel('R² Score (Teste)')
plt.title('Comparação de Performance - R²')
for i, v in enumerate(r2_valores):
    plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# 💡 ANÁLISE COMPARATIVA DETALHADA
print("\n" + "=" * 50)
print("ANÁLISE COMPARATIVA DAS ABORDAGENS")
print("=" * 50)

print(f"\nRESUMO DE PERFORMANCE:")
print(f"{'Método':<12} {'Alpha':<10} {'Features':<10} {'MSE':<8} {'R²':<6}")
print("-" * 50)
for i, (nome, modelo, mse, r2) in enumerate(zip(nomes, modelos, mse_valores, r2_valores)):
    features = np.sum(modelo.coef_ != 0)
    alpha = getattr(modelo, 'alpha_', 0.1)  # Para Lasso com alpha fixo
    print(f"{nome:<12} {alpha:<10.6f} {features:<10} {mse:<8.4f} {r2:<6.4f}")

print(f"\n💡 RECOMENDAÇÕES PRÁTICAS:")
print("1. LassoCV: Ideal para maioria dos casos - seleção automática robusta")
print("2. LassoLarsIC: Mais rápido, útil para datasets muito grandes")
print("3. Alpha fixo: Apenas quando há conhecimento prévio do domínio")
print("4. BIC tende a selecionar modelos mais esparsos que AIC")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import Lasso, LassoCV, LassoLarsIC

from sklearn.datasets import make_regression

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error, r2_score

print("=" * 60)

print("COMPARAÇÃO: DIFERENTES ABORDAGENS LASSO")

print("=" * 60)

# Gerar dados com features redundantes

X, y = make_regression(n_samples=200, n_features=15, n_informative=5,

noise=0.5, random_state=42, coef=True)

# 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

)

print(f"Dataset: {X.shape[0]} amostras, {X.shape[1]} features")

print(f"Features informativas verdadeiras: 5")

print(f"Treino: {X_train.shape[0]} amostras | Teste: {X_test.shape[0]} amostras")

# 1. LASSO com alpha fixo

print("\n" + "=" * 50)

print("1. LASSO COM ALPHA FIXO")

print("=" * 50)

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

lasso_fixo.fit(X_train, y_train)

y_pred_fixo = lasso_fixo.predict(X_test)

mse_fixo = mean_squared_error(y_test, y_pred_fixo)

r2_fixo = r2_score(y_test, y_pred_fixo)

print(f"Alpha: 0.1")

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

print(f"MSE teste: {mse_fixo:.4f}")

print(f"R² teste: {r2_fixo:.4f}")

# 2. LASSO com validação cruzada (LassoCV)

print("\n" + "=" * 50)

print("2. LASSO COM VALIDAÇÃO CRUZADA (LassoCV)")

print("=" * 50)

# Definir range de alphas para busca

alphas = np.logspace(-4, 0, 50)

lasso_cv = LassoCV(alphas=alphas, cv=5, max_iter=10000, random_state=42)

lasso_cv.fit(X_train, y_train)

y_pred_cv = lasso_cv.predict(X_test)

mse_cv = mean_squared_error(y_test, y_pred_cv)

r2_cv = r2_score(y_test, y_pred_cv)

print(f"Melhor alpha (CV): {lasso_cv.alpha_:.6f}")

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

print(f"MSE teste: {mse_cv:.4f}")

print(f"R² teste: {r2_cv:.4f}")

# 3. LASSO com critério de informação (LassoLarsIC)

print("\n" + "=" * 50)

print("3. LASSO COM CRITÉRIO DE INFORMAÇÃO (LassoLarsIC)")

print("=" * 50)

# AIC (Akaike Information Criterion)

lasso_aic = LassoLarsIC(criterion='aic')

lasso_aic.fit(X_train, y_train)

y_pred_aic = lasso_aic.predict(X_test)

mse_aic = mean_squared_error(y_test, y_pred_aic)

r2_aic = r2_score(y_test, y_pred_aic)

print(f"Alpha (AIC): {lasso_aic.alpha_:.6f}")

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

print(f"MSE teste: {mse_aic:.4f}")

print(f"R² teste: {r2_aic:.4f}")

# BIC (Bayesian Information Criterion)

lasso_bic = LassoLarsIC(criterion='bic')

lasso_bic.fit(X_train, y_train)

y_pred_bic = lasso_bic.predict(X_test)

mse_bic = mean_squared_error(y_test, y_pred_bic)

r2_bic = r2_score(y_test, y_pred_bic)

print(f"\nAlpha (BIC): {lasso_bic.alpha_:.6f}")

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

print(f"MSE teste: {mse_bic:.4f}")

print(f"R² teste: {r2_bic:.4f}")

# Visualização comparativa

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

# Gráfico 1: Comparação de coeficientes

plt.subplot(2, 2, 1)

modelos = [lasso_fixo, lasso_cv, lasso_aic, lasso_bic]

nomes = ['Alpha Fixo', 'CV', 'AIC', 'BIC']

cores = ['red', 'blue', 'green', 'orange']

for i, modelo in enumerate(modelos):

plt.bar(np.arange(15) + i*0.2, modelo.coef_, width=0.2,

label=nomes[i], alpha=0.7, color=cores[i])

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

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

plt.xticks(np.arange(15) + 0.3, [f'F{i+1}' for i in range(15)])

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 2: Número de features selecionadas

plt.subplot(2, 2, 2)

features_selecionadas = [np.sum(m.coef_ != 0) for m in modelos]

plt.bar(nomes, features_selecionadas, color=cores, alpha=0.7)

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

plt.title('Esparsidade: Features Não Nulas')

for i, v in enumerate(features_selecionadas):

plt.text(i, v + 0.1, str(v), ha='center', va='bottom')

plt.grid(True, alpha=0.3)

# Gráfico 3: Performance (MSE)

plt.subplot(2, 2, 3)

mse_valores = [mse_fixo, mse_cv, mse_aic, mse_bic]

plt.bar(nomes, mse_valores, color=cores, alpha=0.7)

plt.ylabel('Mean Squared Error (Teste)')

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

for i, v in enumerate(mse_valores):

plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')

plt.grid(True, alpha=0.3)

# Gráfico 4: Performance (R²)

plt.subplot(2, 2, 4)

r2_valores = [r2_fixo, r2_cv, r2_aic, r2_bic]

plt.bar(nomes, r2_valores, color=cores, alpha=0.7)

plt.ylabel('R² Score (Teste)')

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

for i, v in enumerate(r2_valores):

plt.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# 💡 ANÁLISE COMPARATIVA DETALHADA

print("\n" + "=" * 50)

print("ANÁLISE COMPARATIVA DAS ABORDAGENS")

print("=" * 50)

print(f"\nRESUMO DE PERFORMANCE:")

print(f"{'Método':<12} {'Alpha':<10} {'Features':<10} {'MSE':<8} {'R²':<6}")

print("-" * 50)

for i, (nome, modelo, mse, r2) in enumerate(zip(nomes, modelos, mse_valores, r2_valores)):

features = np.sum(modelo.coef_ != 0)

alpha = getattr(modelo, 'alpha_', 0.1) # Para Lasso com alpha fixo

print(f"{nome:<12} {alpha:<10.6f} {features:<10} {mse:<8.4f} {r2:<6.4f}")

print(f"\n💡 RECOMENDAÇÕES PRÁTICAS:")

print("1. LassoCV: Ideal para maioria dos casos - seleção automática robusta")

print("2. LassoLarsIC: Mais rápido, útil para datasets muito grandes")

print("3. Alpha fixo: Apenas quando há conhecimento prévio do domínio")

print("4. BIC tende a selecionar modelos mais esparsos que AIC")

Interpretação dos Resultados

Inegavelmente, as diferentes abordagens produzem resultados distintos em termos de seleção de features e performance preditiva. Afinal, cada método possui suas próprias suposições e critérios de otimização.

Vantagens de Cada Abordagem

LassoCV: Seleção robusta através de validação cruzada
LassoLarsIC: Eficiência computacional e fundamentação estatística
Lasso com alpha fixo: Controle direto sobre a esparsidade

Considerações de Implementação

Embora todas as abordagens implementem a mesma formulação matemática básica, suas estratégias de seleção de parâmetros diferem significativamente. Ocasionalmente, pode ser necessário testar múltiplas abordagens para encontrar a mais adequada ao problema específico.

Contudo, na prática, LassoCV é frequentemente a escolha mais segura e recomendada, pois combina robustez estatística com performance prática.

Conclusão

Portanto, o scikit-learn oferece um conjunto abrangente de implementações Lasso para diferentes necessidades. Analogamente a um kit de ferramentas especializadas, cada variação atende a cenários específicos de aplicação.

Enfim, a compreensão das diferenças entre estas implementações permite selecionar a abordagem mais adequada para cada problema, otimizando tanto a performance preditiva quanto a interpretabilidade do modelo.

Modelos Lineares Generalizados: Regressão Laço (Lasso)

25/04/202617/10/2025 Por antonino

Regularização L1 e Seleção de Features

Analogamente à Regressão de Ridge, o Laço (Lasso) constitui outra técnica fundamental de regularização em modelos lineares. Ademais, enquanto a Ridge utiliza penalização L2, o Lasso emprega penalização L1, o que confere propriedades únicas e particularmente úteis para seleção de features.

Fundamentação Matemática do Lasso

Conforme especificado na documentação do scikit-learn, o Lasso resolve o seguinte problema de otimização:

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

Primordialmente, a diferença crucial reside no termo de penalização \(\alpha ||w||_1\), que utiliza a norma L1 em vez da norma L2. Certamente, esta mudança aparentemente sutil produz comportamentos radicalmente diferentes.

Características Distintivas do Lasso

Seleção de features: Capaz de definir coeficientes exatamente para zero
Esparsidade: Produz vetores de coeficientes esparsos
Interpretabilidade: Modelos mais simples e interpretáveis
Regularização L1: Penalização baseada na soma dos valores absolutos

Comparação: Lasso vs Ridge

Enquanto a Ridge regression apenas reduz a magnitude dos coeficientes, o Lasso pode eliminá-los completamente. Similarmente a um processo de seleção natural, apenas as features mais importantes sobrevivem no modelo final.

Exemplo Prático com Lasso

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso, Ridge
from sklearn.datasets import make_regression
 
print("=" * 60)
print("DEMONSTRAÇÃO PRÁTICA - REGRESSÃO LASSO COM LEGENDAS")
print("=" * 60)
 
# Gerar dados com features redundantes
X, y = make_regression(n_samples=100, n_features=6, n_informative=3, 
                       noise=0.5, random_state=42)
 
print(f"Dimensões: X {X.shape}, y {y.shape}")
print(f"Features informativas geradas: 3 de 6")
 
# Configurar parâmetros de regularização
n_alphas = 200
alphas = np.logspace(-3, 1, n_alphas)
 
# Armazenar resultados
lasso_coefs = []
ridge_coefs = []
 
for alpha in alphas:
    # Lasso regression
    lasso = Lasso(alpha=alpha, max_iter=10000)
    lasso.fit(X, y)
    lasso_coefs.append(lasso.coef_)
    
    # Ridge regression para comparação
    ridge = Ridge(alpha=alpha)
    ridge.fit(X, y)
    ridge_coefs.append(ridge.coef_)
 
lasso_coefs = np.array(lasso_coefs)
ridge_coefs = np.array(ridge_coefs)
 
# Visualização comparativa com legendas
plt.figure(figsize=(16, 8))
 
# Gráfico Lasso com legendas
plt.subplot(1, 2, 1)
cores = ['red', 'blue', 'green', 'orange', 'purple', 'brown']
for i in range(lasso_coefs.shape[1]):
    plt.plot(alphas, lasso_coefs[:, i], 
             color=cores[i], linewidth=2, 
             label=f'Feature {i+1}')
 
plt.xscale('log')
plt.xlabel('Alpha (escala logarítmica)', fontsize=12)
plt.ylabel('Valor do Coeficiente', fontsize=12)
plt.title('LASSO: Regularização L1\n(Convergência para Zero Exato)', 
          fontsize=14, fontweight='bold')
plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.grid(True, alpha=0.3)
 
# Adicionar legenda fora do gráfico para melhor visualização
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', 
           borderaxespad=0., fontsize=10)
 
# Gráfico Ridge com legendas
plt.subplot(1, 2, 2)
for i in range(ridge_coefs.shape[1]):
    plt.plot(alphas, ridge_coefs[:, i], 
             color=cores[i], linewidth=2, 
             label=f'Feature {i+1}')
 
plt.xscale('log')
plt.xlabel('Alpha (escala logarítmica)', fontsize=12)
plt.ylabel('Valor do Coeficiente', fontsize=12)
plt.title('RIDGE: Regularização L2\n(Convergência Suave para Zero)', 
          fontsize=14, fontweight='bold')
plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.grid(True, alpha=0.3)
 
# Adicionar legenda fora do gráfico
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', 
           borderaxespad=0., fontsize=10)
 
plt.tight_layout()
plt.show()
 
# 💡 ANÁLISE DETALHADA COM DESTAQUE PARA FEATURES SELECIONADAS
print("\n" + "=" * 50)
print("ANÁLISE DE SELEÇÃO DE FEATURES")
print("=" * 50)
 
# Testar diferentes valores de alpha
alpha_valores = [0.001, 0.01, 0.1, 0.5, 1.0]
 
for alpha in alpha_valores:
    lasso_model = Lasso(alpha=alpha, max_iter=10000)
    lasso_model.fit(X, y)
    
    features_nao_nulas = np.where(lasso_model.coef_ != 0)[0]
    features_nulas = np.where(lasso_model.coef_ == 0)[0]
    
    print(f"\nAlpha = {alpha:.3f}:")
    print(f"  Features selecionadas: {features_nao_nulas + 1}")
    print(f"  Features eliminadas: {features_nulas + 1}")
    print(f"  Coeficientes: {lasso_model.coef_}")
 
# 🎯 VISUALIZAÇÃO ALTERNATIVA: GRÁFICO DE BARRAS PARA COEFICIENTES
plt.figure(figsize=(14, 6))
 
# Selecionar um alpha específico para demonstração
alpha_demo = 0.1
lasso_demo = Lasso(alpha=alpha_demo, max_iter=10000)
lasso_demo.fit(X, y)
ridge_demo = Ridge(alpha=alpha_demo)
ridge_demo.fit(X, y)
 
# Gráfico de barras comparativo
plt.subplot(1, 2, 1)
indices = np.arange(len(lasso_demo.coef_))
largura = 0.35
 
plt.bar(indices - largura/2, lasso_demo.coef_, largura, 
        label='Lasso', alpha=0.7, color='red')
plt.bar(indices + largura/2, ridge_demo.coef_, largura, 
        label='Ridge', alpha=0.7, color='blue')
 
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title(f'Comparação Lasso vs Ridge (alpha={alpha_demo})')
plt.xticks(indices, [f'F{i+1}' for i in range(len(lasso_demo.coef_))])
plt.legend()
plt.grid(True, alpha=0.3)
 
# Gráfico de sparsidade
plt.subplot(1, 2, 2)
coeficientes_nao_nulos = (lasso_demo.coef_ != 0).astype(int)
plt.bar(range(len(coeficientes_nao_nulos)), coeficientes_nao_nulos, 
        color=['red' if x == 0 else 'green' for x in coeficientes_nao_nulos])
plt.xlabel('Features')
plt.ylabel('Selecionada (1) / Eliminada (0)')
plt.title('Sparsidade do Lasso: Features Selecionadas')
plt.xticks(range(len(coeficientes_nao_nulos)), 
           [f'F{i+1}' for i in range(len(coeficientes_nao_nulos))])
 
plt.tight_layout()
plt.show()
 
print("\n" + "=" * 50)
print("INTERPRETAÇÃO DOS RESULTADOS")
print("=" * 50)
 
print("""
🔍 OBSERVAÇÕES:
 
1. LASSO (L1):
   • Coeficientes podem se tornar EXATAMENTE zero
   • Efeito de seleção de features
   • Modelos esparsos e interpretáveis
 
2. RIDGE (L2):
   • Coeficientes apenas se aproximam de zero
   • Sem eliminação completa de features
   • Convergência mais suave
 
3. LEGENDAS:
   • Agora cada feature é claramente identificada
   • Cores consistentes facilitam a comparação
   • Posicionamento evita sobreposição
""")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import Lasso, Ridge

from sklearn.datasets import make_regression

print("=" * 60)

print("DEMONSTRAÇÃO PRÁTICA - REGRESSÃO LASSO COM LEGENDAS")

print("=" * 60)

# Gerar dados com features redundantes

X, y = make_regression(n_samples=100, n_features=6, n_informative=3,

noise=0.5, random_state=42)

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

print(f"Features informativas geradas: 3 de 6")

# Configurar parâmetros de regularização

n_alphas = 200

alphas = np.logspace(-3, 1, n_alphas)

# Armazenar resultados

lasso_coefs = []

ridge_coefs = []

for alpha in alphas:

# Lasso regression

lasso = Lasso(alpha=alpha, max_iter=10000)

lasso.fit(X, y)

lasso_coefs.append(lasso.coef_)

# Ridge regression para comparação

ridge = Ridge(alpha=alpha)

ridge.fit(X, y)

ridge_coefs.append(ridge.coef_)

lasso_coefs = np.array(lasso_coefs)

ridge_coefs = np.array(ridge_coefs)

# Visualização comparativa com legendas

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

# Gráfico Lasso com legendas

plt.subplot(1, 2, 1)

cores = ['red', 'blue', 'green', 'orange', 'purple', 'brown']

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

plt.plot(alphas, lasso_coefs[:, i],

color=cores[i], linewidth=2,

label=f'Feature {i+1}')

plt.xscale('log')

plt.xlabel('Alpha (escala logarítmica)', fontsize=12)

plt.ylabel('Valor do Coeficiente', fontsize=12)

plt.title('LASSO: Regularização L1\n(Convergência para Zero Exato)',

fontsize=14, fontweight='bold')

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

plt.grid(True, alpha=0.3)

# Adicionar legenda fora do gráfico para melhor visualização

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

borderaxespad=0., fontsize=10)

# Gráfico Ridge com legendas

plt.subplot(1, 2, 2)

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

plt.plot(alphas, ridge_coefs[:, i],

color=cores[i], linewidth=2,

label=f'Feature {i+1}')

plt.xscale('log')

plt.xlabel('Alpha (escala logarítmica)', fontsize=12)

plt.ylabel('Valor do Coeficiente', fontsize=12)

plt.title('RIDGE: Regularização L2\n(Convergência Suave para Zero)',

fontsize=14, fontweight='bold')

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

plt.grid(True, alpha=0.3)

# Adicionar legenda fora do gráfico

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

borderaxespad=0., fontsize=10)

plt.tight_layout()

plt.show()

# 💡 ANÁLISE DETALHADA COM DESTAQUE PARA FEATURES SELECIONADAS

print("\n" + "=" * 50)

print("ANÁLISE DE SELEÇÃO DE FEATURES")

print("=" * 50)

# Testar diferentes valores de alpha

alpha_valores = [0.001, 0.01, 0.1, 0.5, 1.0]

for alpha in alpha_valores:

lasso_model = Lasso(alpha=alpha, max_iter=10000)

lasso_model.fit(X, y)

features_nao_nulas = np.where(lasso_model.coef_ != 0)[0]

features_nulas = np.where(lasso_model.coef_ == 0)[0]

print(f"\nAlpha = {alpha:.3f}:")

print(f" Features selecionadas: {features_nao_nulas + 1}")

print(f" Features eliminadas: {features_nulas + 1}")

print(f" Coeficientes: {lasso_model.coef_}")

# 🎯 VISUALIZAÇÃO ALTERNATIVA: GRÁFICO DE BARRAS PARA COEFICIENTES

plt.figure(figsize=(14, 6))

# Selecionar um alpha específico para demonstração

alpha_demo = 0.1

lasso_demo = Lasso(alpha=alpha_demo, max_iter=10000)

lasso_demo.fit(X, y)

ridge_demo = Ridge(alpha=alpha_demo)

ridge_demo.fit(X, y)

# Gráfico de barras comparativo

plt.subplot(1, 2, 1)

indices = np.arange(len(lasso_demo.coef_))

largura = 0.35

plt.bar(indices - largura/2, lasso_demo.coef_, largura,

label='Lasso', alpha=0.7, color='red')

plt.bar(indices + largura/2, ridge_demo.coef_, largura,

label='Ridge', alpha=0.7, color='blue')

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

plt.title(f'Comparação Lasso vs Ridge (alpha={alpha_demo})')

plt.xticks(indices, [f'F{i+1}' for i in range(len(lasso_demo.coef_))])

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico de sparsidade

plt.subplot(1, 2, 2)

coeficientes_nao_nulos = (lasso_demo.coef_ != 0).astype(int)

plt.bar(range(len(coeficientes_nao_nulos)), coeficientes_nao_nulos,

color=['red' if x == 0 else 'green' for x in coeficientes_nao_nulos])

plt.xlabel('Features')

plt.ylabel('Selecionada (1) / Eliminada (0)')

plt.title('Sparsidade do Lasso: Features Selecionadas')

plt.xticks(range(len(coeficientes_nao_nulos)),

[f'F{i+1}' for i in range(len(coeficientes_nao_nulos))])

plt.tight_layout()

plt.show()

print("\n" + "=" * 50)

print("INTERPRETAÇÃO DOS RESULTADOS")

print("=" * 50)

print("""

🔍 OBSERVAÇÕES:

1. LASSO (L1):

• Coeficientes podem se tornar EXATAMENTE zero

• Efeito de seleção de features

• Modelos esparsos e interpretáveis

2. RIDGE (L2):

• Coeficientes apenas se aproximam de zero

• Sem eliminação completa de features

• Convergência mais suave

3. LEGENDAS:

• Agora cada feature é claramente identificada

• Cores consistentes facilitam a comparação

• Posicionamento evita sobreposição

""")

Vantagens Práticas do Lasso

Inegavelmente, a capacidade de produzir modelos esparsos confere ao Lasso vantagens significativas em cenários específicos. Afinal, em problemas com muitas features, a seleção automática simplifica consideravelmente a interpretação do modelo.

Aplicações Típicas do Lasso

Seleção de variáveis: Identificar features mais relevantes
Modelos interpretáveis: Construir modelos com poucas variáveis
Redução de dimensionalidade: Eliminar features redundantes
Regularização agressiva: Controle rigoroso de overfitting

Considerações de Implementação

Embora poderoso, o Lasso requer alguns cuidados na implementação. Ocasionalmente, pode ser necessário aumentar o número máximo de iterações (max_iter) para garantir convergência, especialmente com muitos dados.

Contudo, o scikit-learn oferece implementações otimizadas como LassoCV que automatizam a seleção do melhor parâmetro alpha através de validação cruzada.

Geometria da Penalização L1

A propriedade de sparsidade do Lasso decorre da geometria da norma L1. Similarmente a um contorno com “cantos”, a interseção entre a função de erro e a restrição L1 tende a ocorrer nos eixos, onde alguns coeficientes são exatamente zero.

Conclusão

Portanto, o Lasso representa uma ferramenta valiosa no arsenal do cientista de dados. Analogamente a um filtro de precisão, ele é capaz de separar sinais importantes de ruído estatístico.

Enfim, a compreensão das diferenças entre Lasso e Ridge é essencial para selecionar a técnica apropriada para cada problema. Inclusive, em muitos casos práticos, uma combinação de ambas através do Elastic Net pode oferecer o melhor dos dois mundos.