Arquivo de Aprendizado de Máquina - Página 9 de 12

Lasso LARS e a fusão entre Regularização L1 e Abordagem Geométric

19/12/202517/10/2025 Por antonino

Introdução ao Lasso LARS

O Lasso LARS constitui uma implementação eficiente que combina as vantagens da regressão Lasso com o algoritmo Least Angle Regression. Primordialmente, esta abordagem permite computar a solução completa do caminho Lasso de forma computacionalmente eficiente, sem a necessidade de otimização convexa iterativa.

Princípio de Funcionamento

O Lasso LARS opera através de um processo sequencial similar ao LARS tradicional, mas com uma modificação crucial: quando um coeficiente atinge zero, a feature correspondente é removida do conjunto ativo. Esta simples alteração garante que as soluções produzidas sejam idênticas às do Lasso convencional.

Diferenciação do LARS Clássico

Enquanto o LARS tradicional sempre mantém as features no modelo uma vez selecionadas, o Lasso LARS permite a remoção de features quando seus coeficientes se tornam zero. Isto produz modelos mais esparsos e alinhados com a filosofia de seleção de features do Lasso.

Vantagens Computacionais

Computação eficiente de todo o caminho de regularização
Menor custo computacional para problemas com muitas features
Estabilidade numérica superior em comparação com métodos baseados em descida de gradiente
Capacidade de lidar com situações onde número de features excede número de amostras

Formulação Matemática

O Lasso LARS resolve o mesmo problema de otimização do Lasso tradicional:

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

Contudo, a estratégia de solução é fundamentalmente diferente. Ao invés de otimização convexa, utiliza-se uma abordagem geométrica baseada em direções equiangulares.

Algoritmo Lasso LARS

Iniciar com coeficientes zero e resíduo igual ao target
Encontrar a feature mais correlacionada com o resíduo
Mover na direção desta feature até que outra feature tenha correlação igual
Continuar na direção equiangular entre features ativas
Se algum coeficiente atingir zero, remover a feature do conjunto ativo
Repetir até inclusão de todas as features relevantes

Cenários de Aplicação Ideal

O Lasso LARS é particularmente adequado para:

Problemas com número de features maior que número de amostras (p > n)
Análise exploratória onde se deseja examinar todo o caminho de regularização
Situações que requerem seleção eficiente de features
Aplicações onde a estabilidade numérica é crítica

Implementação no scikit-learn

No scikit-learn, a classe LassoLars implementa esta técnica. Ademais, LassoLarsCV fornece seleção automática do parâmetro alpha através de validação cruzada.

Parâmetros Principais

alpha: Parâmetro de regularização (constante ou array)
fit_intercept: Cálculo do termo intercepto
verbose: Nível de detalhe durante execução
normalize: Normalização prévia dos dados
max_iter: Número máximo de iterações

Exemplo Prático: Comparação com Outras Abordagens

O exemplo a seguir demonstra o uso do Lasso LARS e sua comparação com implementações alternativas do Lasso:

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

print("=" * 60)
print("COMPARAÇÃO: LASSO LARS VS LASSO TRADICIONAL")
print("=" * 60)

# Gerar dados com alta dimensionalidade (p > n scenario)
X, y = make_regression(n_samples=80, n_features=50, n_informative=10, 
                       noise=0.3, random_state=42)

# Normalizar os dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
y_centered = y - np.mean(y)

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

print(f"Cenário p > n: {X.shape[1]} features, {X.shape[0]} amostras")
print(f"Features informativas verdadeiras: 10")

# 1. Lasso LARS com alpha fixo
print("\n1. LASSO LARS (ALPHA=0.1)")
start_time = time.time()
lasso_lars = LassoLars(alpha=0.1)
lasso_lars.fit(X_train, y_train)
lars_time = time.time() - start_time

y_pred_lars = lasso_lars.predict(X_test)
coef_nao_nulos_lars = np.sum(lasso_lars.coef_ != 0)

print(f"Tempo de execução: {lars_time:.4f} segundos")
print(f"Coeficientes não nulos: {coef_nao_nulos_lars}/50")
print(f"MSE: {mean_squared_error(y_test, y_pred_lars):.4f}")
print(f"R²: {r2_score(y_test, y_pred_lars):.4f}")

# 2. Lasso tradicional
print("\n2. LASSO TRADICIONAL (ALPHA=0.1)")
start_time = time.time()
lasso_trad = Lasso(alpha=0.1, max_iter=10000, random_state=42)
lasso_trad.fit(X_train, y_train)
lasso_time = time.time() - start_time

y_pred_trad = lasso_trad.predict(X_test)
coef_nao_nulos_trad = np.sum(lasso_trad.coef_ != 0)

print(f"Tempo de execução: {lasso_time:.4f} segundos")
print(f"Coeficientes não nulos: {coef_nao_nulos_trad}/50")
print(f"MSE: {mean_squared_error(y_test, y_pred_trad):.4f}")
print(f"R²: {r2_score(y_test, y_pred_trad):.4f}")

# 3. Lasso LARS com critério de informação
print("\n3. LASSO LARS COM CRITÉRIO AIC")
lasso_lars_aic = LassoLarsIC(criterion='aic')
lasso_lars_aic.fit(X_train, y_train)
y_pred_aic = lasso_lars_aic.predict(X_test)

print(f"Alpha selecionado (AIC): {lasso_lars_aic.alpha_:.6f}")
print(f"Coeficientes não nulos: {np.sum(lasso_lars_aic.coef_ != 0)}/50")
print(f"MSE: {mean_squared_error(y_test, y_pred_aic):.4f}")

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

# Gráfico 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
coeficientes = [lasso_lars.coef_, lasso_trad.coef_, lasso_lars_aic.coef_]
nomes = ['LassoLars', 'Lasso Trad', 'LassoLars AIC']
cores = ['blue', 'red', 'green']

for i, (coef, nome) in enumerate(zip(coeficientes, nomes)):
    plt.bar(np.arange(50) + i*0.25, coef, width=0.23, 
            label=nome, alpha=0.7, color=cores[i])

plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes - Cenário p > n')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 2: Caminho de regularização LassoLars
plt.subplot(2, 2, 2)
# Calcular caminho completo com alpha zero
lars_path = LassoLars(alpha=0)
lars_path.fit(X_train, y_train)

# Extrair alphas ao longo do caminho
alphas = lars_path.alphas_
coef_path = lars_path.coef_path_

# Plotar caminho para primeiras 15 features
for i in range(min(15, coef_path.shape[0])):
    plt.plot(alphas, coef_path[i], label=f'F{i+1}', linewidth=1.5)

plt.xlabel('Alpha')
plt.ylabel('Valor do Coeficiente')
plt.title('Caminho LassoLars - Evolução com Alpha')
plt.xscale('log')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)

# Gráfico 3: Comparação de esparsidade
plt.subplot(2, 2, 3)
features_nao_nulas = [np.sum(coef != 0) for coef in coeficientes]
plt.bar(nomes, features_nao_nulas, color=cores, alpha=0.7)
plt.ylabel('Número de Features Selecionadas')
plt.title('Comparação de Esparsidade')
for i, v in enumerate(features_nao_nulas):
    plt.text(i, v + 0.5, str(v), ha='center', va='bottom')
plt.grid(True, alpha=0.3)

# Gráfico 4: Comparação de performance
plt.subplot(2, 2, 4)
mse_valores = [
    mean_squared_error(y_test, y_pred_lars),
    mean_squared_error(y_test, y_pred_trad),
    mean_squared_error(y_test, y_pred_aic)
]
tempos = [lars_time, lasso_time, 0]  # AIC não tem tempo separado

x_pos = np.arange(len(nomes))
width = 0.35

plt.bar(x_pos - width/2, mse_valores, width, label='MSE', alpha=0.7, color='blue')
plt.bar(x_pos + width/2, tempos, width, label='Tempo (s)', alpha=0.7, color='orange')
plt.xlabel('Método')
plt.ylabel('MSE / Tempo (s)')
plt.title('Performance e Eficiência Computacional')
plt.xticks(x_pos, nomes)
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise de concordância na seleção de features
print("\n4. ANÁLISE DE CONCORDÂNCIA NA SELEÇÃO")
print("Feature | LassoLars | LassoTrad | Concordância")
print("-" * 50)
concordancia_total = 0
for i in range(50):
    selecionada_lars = lasso_lars.coef_[i] != 0
    selecionada_trad = lasso_trad.coef_[i] != 0
    concordancia = "SIM" if selecionada_lars == selecionada_trad else "NÃO"
    if selecionada_lars == selecionada_trad:
        concordancia_total += 1
    
    status_lars = "SEL" if selecionada_lars else "---"
    status_trad = "SEL" if selecionada_trad else "---"
    print(f"F{i+1:2d}     |    {status_lars}    |    {status_trad}    |     {concordancia}")

print(f"\nTaxa de concordância: {concordancia_total/50*100:.1f}%")

# Análise adicional do caminho LassoLars
print("\n5. INFORMAÇÕES DO CAMINHO LASSO LARS")
print(f"Número de iterações: {len(lars_path.alphas_)}")
print(f"Alpha máximo: {lars_path.alphas_[0]:.6f}")
print(f"Alpha mínimo: {lars_path.alphas_[-1]:.6f}")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LassoLars, Lasso, LassoLarsIC

from sklearn.datasets import make_regression

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.preprocessing import StandardScaler

import time

print("=" * 60)

print("COMPARAÇÃO: LASSO LARS VS LASSO TRADICIONAL")

print("=" * 60)

# Gerar dados com alta dimensionalidade (p > n scenario)

X, y = make_regression(n_samples=80, n_features=50, n_informative=10,

noise=0.3, random_state=42)

# Normalizar os dados

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

y_centered = y - np.mean(y)

# Dividir em treino e teste

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_centered,

test_size=0.3, random_state=42)

print(f"Cenário p > n: {X.shape[1]} features, {X.shape[0]} amostras")

print(f"Features informativas verdadeiras: 10")

# 1. Lasso LARS com alpha fixo

print("\n1. LASSO LARS (ALPHA=0.1)")

start_time = time.time()

lasso_lars = LassoLars(alpha=0.1)

lasso_lars.fit(X_train, y_train)

lars_time = time.time() - start_time

y_pred_lars = lasso_lars.predict(X_test)

coef_nao_nulos_lars = np.sum(lasso_lars.coef_ != 0)

print(f"Tempo de execução: {lars_time:.4f} segundos")

print(f"Coeficientes não nulos: {coef_nao_nulos_lars}/50")

print(f"MSE: {mean_squared_error(y_test, y_pred_lars):.4f}")

print(f"R²: {r2_score(y_test, y_pred_lars):.4f}")

# 2. Lasso tradicional

print("\n2. LASSO TRADICIONAL (ALPHA=0.1)")

start_time = time.time()

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

lasso_trad.fit(X_train, y_train)

lasso_time = time.time() - start_time

y_pred_trad = lasso_trad.predict(X_test)

coef_nao_nulos_trad = np.sum(lasso_trad.coef_ != 0)

print(f"Tempo de execução: {lasso_time:.4f} segundos")

print(f"Coeficientes não nulos: {coef_nao_nulos_trad}/50")

print(f"MSE: {mean_squared_error(y_test, y_pred_trad):.4f}")

print(f"R²: {r2_score(y_test, y_pred_trad):.4f}")

# 3. Lasso LARS com critério de informação

print("\n3. LASSO LARS COM CRITÉRIO AIC")

lasso_lars_aic = LassoLarsIC(criterion='aic')

lasso_lars_aic.fit(X_train, y_train)

y_pred_aic = lasso_lars_aic.predict(X_test)

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

print(f"Coeficientes não nulos: {np.sum(lasso_lars_aic.coef_ != 0)}/50")

print(f"MSE: {mean_squared_error(y_test, y_pred_aic):.4f}")

# Visualização comparativa

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

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

plt.subplot(2, 2, 1)

coeficientes = [lasso_lars.coef_, lasso_trad.coef_, lasso_lars_aic.coef_]

nomes = ['LassoLars', 'Lasso Trad', 'LassoLars AIC']

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

for i, (coef, nome) in enumerate(zip(coeficientes, nomes)):

plt.bar(np.arange(50) + i*0.25, coef, width=0.23,

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

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

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

plt.title('Comparação dos Coeficientes - Cenário p > n')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 2: Caminho de regularização LassoLars

plt.subplot(2, 2, 2)

# Calcular caminho completo com alpha zero

lars_path = LassoLars(alpha=0)

lars_path.fit(X_train, y_train)

# Extrair alphas ao longo do caminho

alphas = lars_path.alphas_

coef_path = lars_path.coef_path_

# Plotar caminho para primeiras 15 features

for i in range(min(15, coef_path.shape[0])):

plt.plot(alphas, coef_path[i], label=f'F{i+1}', linewidth=1.5)

plt.xlabel('Alpha')

plt.ylabel('Valor do Coeficiente')

plt.title('Caminho LassoLars - Evolução com Alpha')

plt.xscale('log')

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

plt.grid(True, alpha=0.3)

# Gráfico 3: Comparação de esparsidade

plt.subplot(2, 2, 3)

features_nao_nulas = [np.sum(coef != 0) for coef in coeficientes]

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

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

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

for i, v in enumerate(features_nao_nulas):

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

plt.grid(True, alpha=0.3)

# Gráfico 4: Comparação de performance

plt.subplot(2, 2, 4)

mse_valores = [

mean_squared_error(y_test, y_pred_lars),

mean_squared_error(y_test, y_pred_trad),

mean_squared_error(y_test, y_pred_aic)

]

tempos = [lars_time, lasso_time, 0] # AIC não tem tempo separado

x_pos = np.arange(len(nomes))

width = 0.35

plt.bar(x_pos - width/2, mse_valores, width, label='MSE', alpha=0.7, color='blue')

plt.bar(x_pos + width/2, tempos, width, label='Tempo (s)', alpha=0.7, color='orange')

plt.xlabel('Método')

plt.ylabel('MSE / Tempo (s)')

plt.title('Performance e Eficiência Computacional')

plt.xticks(x_pos, nomes)

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise de concordância na seleção de features

print("\n4. ANÁLISE DE CONCORDÂNCIA NA SELEÇÃO")

print("Feature | LassoLars | LassoTrad | Concordância")

print("-" * 50)

concordancia_total = 0

for i in range(50):

selecionada_lars = lasso_lars.coef_[i] != 0

selecionada_trad = lasso_trad.coef_[i] != 0

concordancia = "SIM" if selecionada_lars == selecionada_trad else "NÃO"

if selecionada_lars == selecionada_trad:

concordancia_total += 1

status_lars = "SEL" if selecionada_lars else "---"

status_trad = "SEL" if selecionada_trad else "---"

print(f"F{i+1:2d} | {status_lars} | {status_trad} | {concordancia}")

print(f"\nTaxa de concordância: {concordancia_total/50*100:.1f}%")

# Análise adicional do caminho LassoLars

print("\n5. INFORMAÇÕES DO CAMINHO LASSO LARS")

print(f"Número de iterações: {len(lars_path.alphas_)}")

print(f"Alpha máximo: {lars_path.alphas_[0]:.6f}")

print(f"Alpha mínimo: {lars_path.alphas_[-1]:.6f}")

Considerações sobre Estabilidade Numérica

O Lasso LARS demonstra particular robustez em situações numericamente desafiadoras. Por utilizar decomposições matriciais estáveis e evitar problemas de convergência associados a métodos iterativos, frequentemente produz resultados mais confiáveis em problemas mal condicionados.

Limitações e Considerações

Embora poderoso, o Lasso LARS apresenta algumas limitações:

Pode ser menos eficiente quando número de amostras é muito grande
Implementação atual não suporta sparse matrices de forma nativa
Menos flexível para personalização em comparação com abordagens baseadas em otimização

Considerações Finais

Inegavelmente, o Lasso LARS representa uma fusão elegante entre a intuitividade geométrica do LARS e o poder de seleção de features do Lasso. Sua capacidade de computar eficientemente todo o caminho de regularização o torna invaluable para análise exploratória e seleção de modelos.

Decerto, em cenários de alta dimensionalidade (p > n), o Lasso LARS frequentemente supera implementações tradicionais do Lasso tanto em termos de eficiência computacional quanto de estabilidade numérica. Ademais, fornece insights valiosos sobre a ordem de importância das features através do exame do caminho de regularização.

Analogamente a outras técnicas de regularização, a escolha do parâmetro alpha permanece crucial. Portanto, a combinação do Lasso LARS com métodos de validação cruzada ou critérios de informação constitui uma abordagem robusta para problemas práticos de machine learning.

Modelos Lineares Generalizados: Regressão do menor ângulo

19/12/202517/10/2025 Por antonino

Regressão do Menor Ângulo (LARS): Uma Abordagem Geométrica

Introdução ao Método LARS

A Regressão do Menor Ângulo, conhecida como Least Angle Regression (LARS), constitui um algoritmo elegante para regressão linear com seleção de features. Primordialmente, diferencia-se de métodos tradicionais por sua abordagem geométrica incremental, adicionando variáveis ao modelo de forma sequencial.

Princípio Fundamental

O LARS opera através de um processo iterativo onde, a cada passo, o algoritmo seleciona a feature que forma o menor ângulo com o resíduo atual. Surpreendentemente, esta abordagem permite calcular soluções para todos os valores de regularização de forma computacionalmente eficiente.

Intuição Geométrica

Imagine cada feature como um vetor no espaço multidimensional. O LARS inicia com predições nulas e, a cada iteração, move-se na direção que forma o menor ângulo com o vetor residual atual, até que outra feature se torne igualmente correlacionada.

Algoritmo LARS Passo a Passo

Inicializar todos os coeficientes como zero
Encontrar a feature mais correlacionada com o resíduo
Mover o coeficiente na direção desta feature até que outra feature tenha correlação igual
Continuar na direção equiangular entre as features ativas
Repetir até que todas as features relevantes sejam incluídas

Vantagens do Método LARS

Eficiência computacional para problemas de alta dimensionalidade
Cálculo de todo o caminho de regularização em uma única execução
Seleção natural de features de forma sequencial
Estabilidade numérica superior em comparação com métodos diretos

Relação com Lasso

Inegavelmente, uma das características mais notáveis do LARS é sua conexão profunda com a regressão Lasso. Com uma modificação simples, o algoritmo LARS pode computar exatamente a solução do Lasso para todos os valores do parâmetro de regularização.

Modificação LARS-Lasso

Quando uma feature ativa torna-se não-ativa (coeficiente atinge zero), o algoritmo LARS-Lasso remove esta feature do conjunto ativo antes de continuar. Esta simples modificação produz soluções idênticas ao Lasso tradicional.

Implementação no scikit-learn

No scikit-learn, a classe Lars implementa o algoritmo básico, enquanto LassoLars combina LARS com a penalidade Lasso. Ademais, LarsCV fornece seleção automática do parâmetro via validação cruzada.

Parâmetros Principais

n_nonzero_coefs: Número máximo de coeficientes não nulos
alpha: Parâmetro de regularização (para LassoLars)
fit_intercept: Se deve calcular o intercepto
normalize: Normalização dos dados de entrada

Exemplo Prático Comparativo

O exemplo a seguir demonstra o uso do LARS e sua comparação com outros métodos de regressão:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lars, LassoLars, Lasso, LinearRegression
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler

print("=" * 60)
print("COMPARAÇÃO: LARS VS OUTROS MÉTODOS DE REGRESSÃO")
print("=" * 60)

# Gerar dados com features correlacionadas
X, y = make_regression(n_samples=150, n_features=10, n_informative=5, 
                       noise=0.2, random_state=42, effective_rank=3)

# Adicionar correlação entre features
X[:, 3] = X[:, 0] * 0.7 + X[:, 3] * 0.3
X[:, 7] = X[:, 1] * 0.6 + X[:, 7] * 0.4

# Normalizar os dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
y_centered = y - np.mean(y)

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

print(f"Dimensões: {X.shape[0]} amostras, {X.shape[1]} features")
print(f"Features informativas: 5")

# 1. Regressão Linear Ordinária
print("\n1. REGRESSÃO LINEAR ORDINÁRIA")
ols = LinearRegression()
ols.fit(X_train, y_train)
y_pred_ols = ols.predict(X_test)
print(f"Coeficientes não nulos: {np.sum(ols.coef_ != 0)}/10")
print(f"MSE: {mean_squared_error(y_test, y_pred_ols):.4f}")

# 2. LARS Básico
print("\n2. LARS (5 COEFICIENTES NÃO NULOS)")
lars = Lars(n_nonzero_coefs=5)
lars.fit(X_train, y_train)
y_pred_lars = lars.predict(X_test)
print(f"Coeficientes não nulos: {np.sum(lars.coef_ != 0)}/10")
print(f"MSE: {mean_squared_error(y_test, y_pred_lars):.4f}")

# 3. LassoLars
print("\n3. LASSO LARS (ALPHA=0.1)")
lasso_lars = LassoLars(alpha=0.1)
lasso_lars.fit(X_train, y_train)
y_pred_ll = lasso_lars.predict(X_test)
print(f"Coeficientes não nulos: {np.sum(lasso_lars.coef_ != 0)}/10")
print(f"MSE: {mean_squared_error(y_test, y_pred_ll):.4f}")

# 4. Lasso Tradicional
print("\n4. LASSO TRADICIONAL (ALPHA=0.1)")
lasso = Lasso(alpha=0.1, max_iter=10000)
lasso.fit(X_train, y_train)
y_pred_lasso = lasso.predict(X_test)
print(f"Coeficientes não nulos: {np.sum(lasso.coef_ != 0)}/10")
print(f"MSE: {mean_squared_error(y_test, y_pred_lasso):.4f}")

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

# Gráfico 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
modelos = [ols, lars, lasso_lars, lasso]
nomes = ['OLS', 'LARS', 'LassoLars', 'Lasso']
cores = ['blue', 'green', 'red', 'orange']

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

plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes')
plt.xticks(np.arange(10) + 0.3, [f'F{i+1}' for i in range(10)])
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 2: Caminho LARS
plt.subplot(2, 2, 2)
# Calcular caminho LARS completo
lars_path = Lars()
lars_path.fit(X_train, y_train)

# Extrair coeficientes ao longo do caminho
coef_path = lars_path.coef_path_

for i in range(coef_path.shape[0]):
    plt.plot(np.sum(np.abs(coef_path[:i+1]), axis=0), coef_path[i], 
             label=f'F{i+1}', linewidth=2)

plt.xlabel('Norma L1 dos Coeficientes')
plt.ylabel('Valor do Coeficiente')
plt.title('Caminho LARS - Evolução dos Coeficientes')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)

# Gráfico 3: Features selecionadas
plt.subplot(2, 2, 3)
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('Comparação de Esparsidade')
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 4: Performance
plt.subplot(2, 2, 4)
mse_valores = [mean_squared_error(y_test, m.predict(X_test)) for m in modelos]
plt.bar(nomes, mse_valores, color=cores, alpha=0.7)
plt.ylabel('Mean Squared Error')
plt.title('Comparação de Performance')
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)

plt.tight_layout()
plt.show()

# Análise detalhada da seleção de features
print("\n5. ANÁLISE DETALHADA DA SELEÇÃO")
print("Feature |     OLS     |    LARS     | LassoLars  |   Lasso    ")
print("-" * 60)
for i in range(10):
    coef_ols = ols.coef_[i]
    coef_lars = lars.coef_[i]
    coef_ll = lasso_lars.coef_[i]
    coef_lasso = lasso.coef_[i]
    
    print(f"F{i+1:2d}    | {coef_ols:10.4f} | {coef_lars:10.4f} | {coef_ll:10.4f} | {coef_lasso:10.4f}")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import Lars, LassoLars, Lasso, LinearRegression

from sklearn.datasets import make_regression

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.preprocessing import StandardScaler

print("=" * 60)

print("COMPARAÇÃO: LARS VS OUTROS MÉTODOS DE REGRESSÃO")

print("=" * 60)

# Gerar dados com features correlacionadas

X, y = make_regression(n_samples=150, n_features=10, n_informative=5,

noise=0.2, random_state=42, effective_rank=3)

# Adicionar correlação entre features

X[:, 3] = X[:, 0] * 0.7 + X[:, 3] * 0.3

X[:, 7] = X[:, 1] * 0.6 + X[:, 7] * 0.4

# Normalizar os dados

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

y_centered = y - np.mean(y)

# Dividir em treino e teste

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_centered,

test_size=0.3, random_state=42)

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

print(f"Features informativas: 5")

# 1. Regressão Linear Ordinária

print("\n1. REGRESSÃO LINEAR ORDINÁRIA")

ols = LinearRegression()

ols.fit(X_train, y_train)

y_pred_ols = ols.predict(X_test)

print(f"Coeficientes não nulos: {np.sum(ols.coef_ != 0)}/10")

print(f"MSE: {mean_squared_error(y_test, y_pred_ols):.4f}")

# 2. LARS Básico

print("\n2. LARS (5 COEFICIENTES NÃO NULOS)")

lars = Lars(n_nonzero_coefs=5)

lars.fit(X_train, y_train)

y_pred_lars = lars.predict(X_test)

print(f"Coeficientes não nulos: {np.sum(lars.coef_ != 0)}/10")

print(f"MSE: {mean_squared_error(y_test, y_pred_lars):.4f}")

# 3. LassoLars

print("\n3. LASSO LARS (ALPHA=0.1)")

lasso_lars = LassoLars(alpha=0.1)

lasso_lars.fit(X_train, y_train)

y_pred_ll = lasso_lars.predict(X_test)

print(f"Coeficientes não nulos: {np.sum(lasso_lars.coef_ != 0)}/10")

print(f"MSE: {mean_squared_error(y_test, y_pred_ll):.4f}")

# 4. Lasso Tradicional

print("\n4. LASSO TRADICIONAL (ALPHA=0.1)")

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

lasso.fit(X_train, y_train)

y_pred_lasso = lasso.predict(X_test)

print(f"Coeficientes não nulos: {np.sum(lasso.coef_ != 0)}/10")

print(f"MSE: {mean_squared_error(y_test, y_pred_lasso):.4f}")

# Visualização comparativa

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

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

plt.subplot(2, 2, 1)

modelos = [ols, lars, lasso_lars, lasso]

nomes = ['OLS', 'LARS', 'LassoLars', 'Lasso']

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

for i, (modelo, nome) in enumerate(zip(modelos, nomes)):

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

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

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

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

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

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

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 2: Caminho LARS

plt.subplot(2, 2, 2)

# Calcular caminho LARS completo

lars_path = Lars()

lars_path.fit(X_train, y_train)

# Extrair coeficientes ao longo do caminho

coef_path = lars_path.coef_path_

for i in range(coef_path.shape[0]):

plt.plot(np.sum(np.abs(coef_path[:i+1]), axis=0), coef_path[i],

label=f'F{i+1}', linewidth=2)

plt.xlabel('Norma L1 dos Coeficientes')

plt.ylabel('Valor do Coeficiente')

plt.title('Caminho LARS - Evolução dos Coeficientes')

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

plt.grid(True, alpha=0.3)

# Gráfico 3: Features selecionadas

plt.subplot(2, 2, 3)

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('Comparação de Esparsidade')

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 4: Performance

plt.subplot(2, 2, 4)

mse_valores = [mean_squared_error(y_test, m.predict(X_test)) for m in modelos]

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

plt.ylabel('Mean Squared Error')

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

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)

plt.tight_layout()

plt.show()

# Análise detalhada da seleção de features

print("\n5. ANÁLISE DETALHADA DA SELEÇÃO")

print("Feature | OLS | LARS | LassoLars | Lasso ")

print("-" * 60)

for i in range(10):

coef_ols = ols.coef_[i]

coef_lars = lars.coef_[i]

coef_ll = lasso_lars.coef_[i]

coef_lasso = lasso.coef_[i]

print(f"F{i+1:2d} | {coef_ols:10.4f} | {coef_lars:10.4f} | {coef_ll:10.4f} | {coef_lasso:10.4f}")

Aplicações Práticas do LARS

O método LARS é particularmente útil em cenários específicos:

Análise exploratória de dados com muitas features
Seleção de variáveis em problemas de alta dimensionalidade
Computação eficiente do caminho de regularização completo
Problemas onde a ordem de importância das features é relevante

Considerações sobre Performance

Embora o LARS seja computacionalmente eficiente para problemas com muitas features, pode tornar-se lento quando o número de amostras é muito grande. Nesses casos, métodos baseados em descida de gradiente podem ser mais apropriados.

Considerações Finais

Inegavelmente, a Regressão do Menor Ângulo representa uma contribuição significativa para o arsenal de métodos de regressão. Sua abordagem geométrica proporciona intuição valiosa sobre o processo de seleção de features.

Decerto, a conexão entre LARS e Lasso torna o método particularmente atraente para aplicações práticas. Ademais, a capacidade de computar todo o caminho de regularização em uma única execução oferece vantagens computacionais importantes.

Analogamente a outros métodos de regularização, a interpretação dos resultados requer atenção à ordem de entrada das features no modelo. Portanto, a análise do caminho LARS pode revelar insights valiosos sobre a estrutura subjacente dos dados.