Arquivo de regularizacao-lasso

Modelos Lineares Generalizados: Laço (Lasso)

19/12/202518/10/2025 Por antonino

Anteriormente discutimos a Regressão Linear tradicional e Ridge. Analogamente, o Lasso (Least Absolute Shrinkage and Selection Operator) é outra técnica de regularização que adiciona uma penalidade L1 à função objetivo, promovendo esparsidade nos coeficientes do modelo.

Conceito Fundamental do Lasso

Primordialmente, o Lasso realiza não apenas a regularização dos coeficientes, mas também seleção de features. Decerto, ao adicionar uma penalidade baseada no valor absoluto dos coeficientes, ele tende a zerar os coeficientes de features menos importantes.

Conforme a documentação do scikit-learn, o Lasso é particularmente útil quando acreditamos que apenas um subconjunto das features é realmente relevante para a previsão. Similarmente ao Ridge, ele ajuda a prevenir overfitting, mas com características distintas.

Formulação Matemática

O objetivo do Lasso é minimizar a seguinte função:

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

Onde:

X é a matriz de features
y é o vetor target
w são os coeficientes do modelo
α é o parâmetro de regularização
||w||₁ é a norma L1 dos coeficientes

Características Principais do Lasso

Inegavelmente, o Lasso possui propriedades únicas que o distinguem de outras técnicas de regularização:

Seleção de features: Zera coeficientes de features irrelevantes
Esparsidade: Produz modelos com poucas features não-zero
Interpretabilidade: Modelos mais simples e interpretáveis
Regularização L1: Penalidade baseada no valor absoluto

Comparação: Lasso vs Ridge

Embora ambos sejam técnicas de regularização, existem diferenças fundamentais:

Lasso (L1): Promove esparsidade, zera coeficientes
Ridge (L2): Reduz coeficientes, mas não zera
ElasticNet: Combina L1 e L2

Parâmetros do Lasso

Os principais parâmetros para ajuste no Lasso são:

alpha: Parâmetro de regularização (α)
max_iter: Número máximo de iterações
tol: Tolerância para critério de parada
selection: Estratégia de seleção de coeficientes

Exemplo Prático: Aplicação do Lasso

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

'''
Aplicação do Lasso para Regressão com Seleção de Features
Este exemplo demonstra como o Lasso pode ser usado
para selecionar features relevantes e evitar overfitting
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import Lasso, Ridge, LinearRegression
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 algumas features irrelevantes
X, y, true_coef = make_regression(n_samples=1000, n_features=20, 
                                 n_informative=8, noise=10, 
                                 coef=True, random_state=42)

print("Informações do Dataset:")
print(f"Número de amostras: {X.shape[0]}")
print(f"Número de features: {X.shape[1]}")
print(f"Features informativas: 8")
print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

# 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 (importante para regularização)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''
Comparação entre Regressão Linear, Ridge e Lasso
Cada método tem características diferentes de regularização
'''

models = {
    'Linear': LinearRegression(),
    'Ridge': Ridge(alpha=1.0),
    'Lasso': Lasso(alpha=1.0)
}

results = {}

print("\n--- Comparação de Modelos ---")
for name, model in models.items():
    # Treinar modelo
    model.fit(X_train_scaled, y_train)
    
    # Fazer previsões
    y_pred = model.predict(X_test_scaled)
    
    # Calcular métricas
    mse = mean_squared_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    
    # Armazenar resultados
    if hasattr(model, 'coef_'):
        n_nonzero = np.sum(model.coef_ != 0)
        results[name] = {
            'model': model,
            'mse': mse,
            'r2': r2,
            'n_nonzero': n_nonzero,
            'coef': model.coef_
        }
    else:
        results[name] = {
            'model': model,
            'mse': mse,
            'r2': r2,
            'n_nonzero': X.shape[1],
            'coef': None
        }
    
    print(f"{name:8} - MSE: {mse:.2f}, R²: {r2:.3f}, Features não-zero: {results[name]['n_nonzero']}")

# Otimização do parâmetro alpha para Lasso
print("\n--- Otimização do Parâmetro Alpha para Lasso ---")

param_grid = {
    'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]
}

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

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

# Modelo Lasso otimizado
best_lasso = grid_search.best_estimator_
y_pred_best = best_lasso.predict(X_test_scaled)
final_mse = mean_squared_error(y_test, y_pred_best)
final_r2 = r2_score(y_test, y_pred_best)
n_nonzero_best = np.sum(best_lasso.coef_ != 0)

print(f"\nLasso Otimizado - MSE: {final_mse:.2f}, R²: {final_r2:.3f}")
print(f"Features selecionadas: {n_nonzero_best} de {X.shape[1]}")

# Análise dos coeficientes
print("\n--- Análise dos Coeficientes ---")
print("Comparação entre coeficientes verdadeiros e estimados:")

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

# Plot 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
features = range(len(true_coef))
plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=8)
plt.plot(features, results['Linear']['coef'], 's-', label='Linear', alpha=0.7)
plt.plot(features, results['Ridge']['coef'], '^-', label='Ridge', alpha=0.7)
plt.plot(features, best_lasso.coef_, 'd-', label='Lasso (Otimizado)', alpha=0.7)
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 pelo Lasso
plt.subplot(2, 2, 2)
lasso_coef_nonzero = best_lasso.coef_ != 0
true_coef_nonzero = true_coef != 0

# Calcular acurácia na seleção de features
correct_selection = np.sum(lasso_coef_nonzero == true_coef_nonzero)
selection_accuracy = correct_selection / len(true_coef)

plt.bar(['Selecionadas', 'Não Selecionadas'], 
        [np.sum(lasso_coef_nonzero), np.sum(~lasso_coef_nonzero)],
        color=['lightcoral', 'lightblue'])
plt.title(f'Seleção de Features pelo Lasso\nAcurácia: {selection_accuracy:.1%}')
plt.ylabel('Número de Features')

# Plot 3: Performance vs Alpha
plt.subplot(2, 2, 3)
alphas = param_grid['alpha']
cv_scores = -grid_search.cv_results_['mean_test_score']

plt.semilogx(alphas, cv_scores, 'o-', linewidth=2)
plt.xlabel('Alpha')
plt.ylabel('MSE')
plt.title('Performance vs Parâmetro Alpha')
plt.grid(True, alpha=0.3)

# Plot 4: Comparação de MSE
plt.subplot(2, 2, 4)
model_names = list(results.keys()) + ['Lasso Otimizado']
mses = [results[name]['mse'] for name in results.keys()] + [final_mse]

plt.bar(model_names, mses, color=['skyblue', 'lightgreen', 'gold', 'lightcoral'])
plt.ylabel('MSE')
plt.title('Comparação de Erro Quadrático Médio')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# Análise detalhada da seleção de features
print(f"\n--- Análise Detalhada da Seleção de Features ---")
print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")
print(f"Coeficientes Lasso não-zero: {np.sum(best_lasso.coef_ != 0)}")
print(f"Features corretamente selecionadas: {np.sum((best_lasso.coef_ != 0) & (true_coef != 0))}")
print(f"Features corretamente excluídas: {np.sum((best_lasso.coef_ == 0) & (true_coef == 0))}")
print(f"Acurácia total na seleção: {selection_accuracy:.1%}")

# Exemplo de interpretação do modelo
print(f"\n--- Interpretação do Modelo Lasso ---")
print("Features mais importantes (maiores coeficientes em valor absoluto):")

important_features = np.argsort(np.abs(best_lasso.coef_))[::-1][:5]
for i, feat_idx in enumerate(important_features):
    if best_lasso.coef_[feat_idx] != 0:
        print(f"Feature {feat_idx:2d}: coeficiente = {best_lasso.coef_[feat_idx]:.3f}")

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

'''

Aplicação do Lasso para Regressão com Seleção de Features

Este exemplo demonstra como o Lasso pode ser usado

para selecionar features relevantes e evitar overfitting

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import Lasso, Ridge, LinearRegression

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 algumas features irrelevantes

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

n_informative=8, noise=10,

coef=True, random_state=42)

print("Informações do Dataset:")

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

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

print(f"Features informativas: 8")

print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

# 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 (importante para regularização)

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''

Comparação entre Regressão Linear, Ridge e Lasso

Cada método tem características diferentes de regularização

'''

models = {

'Linear': LinearRegression(),

'Ridge': Ridge(alpha=1.0),

'Lasso': Lasso(alpha=1.0)

}

results = {}

print("\n--- Comparação de Modelos ---")

for name, model in models.items():

# Treinar modelo

model.fit(X_train_scaled, y_train)

# Fazer previsões

y_pred = model.predict(X_test_scaled)

# Calcular métricas

mse = mean_squared_error(y_test, y_pred)

r2 = r2_score(y_test, y_pred)

# Armazenar resultados

if hasattr(model, 'coef_'):

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

results[name] = {

'model': model,

'mse': mse,

'r2': r2,

'n_nonzero': n_nonzero,

'coef': model.coef_

}

else:

results[name] = {

'model': model,

'mse': mse,

'r2': r2,

'n_nonzero': X.shape[1],

'coef': None

}

print(f"{name:8} - MSE: {mse:.2f}, R²: {r2:.3f}, Features não-zero: {results[name]['n_nonzero']}")

# Otimização do parâmetro alpha para Lasso

print("\n--- Otimização do Parâmetro Alpha para Lasso ---")

param_grid = {

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

}

grid_search = GridSearchCV(Lasso(max_iter=10000), param_grid, cv=5,

scoring='neg_mean_squared_error', n_jobs=-1)

grid_search.fit(X_train_scaled, y_train)

print(f"Melhor alpha: {grid_search.best_params_['alpha']}")

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

# Modelo Lasso otimizado

best_lasso = grid_search.best_estimator_

y_pred_best = best_lasso.predict(X_test_scaled)

final_mse = mean_squared_error(y_test, y_pred_best)

final_r2 = r2_score(y_test, y_pred_best)

n_nonzero_best = np.sum(best_lasso.coef_ != 0)

print(f"\nLasso Otimizado - MSE: {final_mse:.2f}, R²: {final_r2:.3f}")

print(f"Features selecionadas: {n_nonzero_best} de {X.shape[1]}")

# Análise dos coeficientes

print("\n--- Análise dos Coeficientes ---")

print("Comparação entre coeficientes verdadeiros e estimados:")

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

# Plot 1: Comparação de coeficientes

plt.subplot(2, 2, 1)

features = range(len(true_coef))

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

plt.plot(features, results['Linear']['coef'], 's-', label='Linear', alpha=0.7)

plt.plot(features, results['Ridge']['coef'], '^-', label='Ridge', alpha=0.7)

plt.plot(features, best_lasso.coef_, 'd-', label='Lasso (Otimizado)', alpha=0.7)

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 pelo Lasso

plt.subplot(2, 2, 2)

lasso_coef_nonzero = best_lasso.coef_ != 0

true_coef_nonzero = true_coef != 0

# Calcular acurácia na seleção de features

correct_selection = np.sum(lasso_coef_nonzero == true_coef_nonzero)

selection_accuracy = correct_selection / len(true_coef)

plt.bar(['Selecionadas', 'Não Selecionadas'],

[np.sum(lasso_coef_nonzero), np.sum(~lasso_coef_nonzero)],

color=['lightcoral', 'lightblue'])

plt.title(f'Seleção de Features pelo Lasso\nAcurácia: {selection_accuracy:.1%}')

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

# Plot 3: Performance vs Alpha

plt.subplot(2, 2, 3)

alphas = param_grid['alpha']

cv_scores = -grid_search.cv_results_['mean_test_score']

plt.semilogx(alphas, cv_scores, 'o-', linewidth=2)

plt.xlabel('Alpha')

plt.ylabel('MSE')

plt.title('Performance vs Parâmetro Alpha')

plt.grid(True, alpha=0.3)

# Plot 4: Comparação de MSE

plt.subplot(2, 2, 4)

model_names = list(results.keys()) + ['Lasso Otimizado']

mses = [results[name]['mse'] for name in results.keys()] + [final_mse]

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

plt.ylabel('MSE')

plt.title('Comparação de Erro Quadrático Médio')

plt.xticks(rotation=45)

plt.tight_layout()

plt.show()

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

print(f"\n--- Análise Detalhada da Seleção de Features ---")

print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

print(f"Coeficientes Lasso não-zero: {np.sum(best_lasso.coef_ != 0)}")

print(f"Features corretamente selecionadas: {np.sum((best_lasso.coef_ != 0) & (true_coef != 0))}")

print(f"Features corretamente excluídas: {np.sum((best_lasso.coef_ == 0) & (true_coef == 0))}")

print(f"Acurácia total na seleção: {selection_accuracy:.1%}")

# Exemplo de interpretação do modelo

print(f"\n--- Interpretação do Modelo Lasso ---")

print("Features mais importantes (maiores coeficientes em valor absoluto):")

important_features = np.argsort(np.abs(best_lasso.coef_))[::-1][:5]

for i, feat_idx in enumerate(important_features):

if best_lasso.coef_[feat_idx] != 0:

print(f"Feature {feat_idx:2d}: coeficiente = {best_lasso.coef_[feat_idx]:.3f}")

Vantagens e Limitações do Lasso

Embora o Lasso seja poderoso, é importante compreender suas características:

Vantagens

Seleção automática de features
Modelos mais interpretáveis
Bom para high-dimensional data
Prevenção de overfitting

Limitações

Pode selecionar apenas uma feature de grupo correlacionado
Sensível à escala dos dados
Pode não performar bem quando todas features são relevantes
Requer ajuste cuidadoso do parâmetro alpha

Casos de Uso Recomendados

O Lasso é particularmente útil em:

Problemas com muitas features e amostras limitadas
Quando se deseja interpretabilidade do modelo
Para seleção de features automática
Em datasets onde muitas features são irrelevantes

Enfim, o Lasso representa uma ferramenta valiosa no arsenal de machine learning, combinando regularização com seleção de features de maneira eficiente e interpretável.

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

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.