Arquivo de lasso - Área de Trampo

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

Regressão Lasso com Regularização L1 e Seleção de Features

19/12/202517/10/2025 Por antonino

Introdução ao Método Lasso

O Lasso, acrônimo para Least Absolute Shrinkage and Selection Operator, constitui uma técnica de regressão linear que combina regularização com seleção de features. Primordialmente, diferencia-se da regressão Ridge por empregar penalidade L1, o que promove esparsidade nos coeficientes estimados.

Formulação Matemática

A função objetivo do Lasso minimiza a soma dos quadrados dos resíduos com uma penalidade baseada na norma L1 dos coeficientes:

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

Onde:

\(X\) representa a matriz de features
\(y\) denota o vetor target
\(w\) simboliza os coeficientes a serem estimados
\(\alpha\) corresponde ao parâmetro de regularização
\(||w||_1\) indica a norma L1 (soma dos valores absolutos)

Característica da Penalidade L1

Surpreendentemente, a penalidade L1 possui a propriedade de produzir coeficientes exatamente iguais a zero para valores suficientemente altos de \(\alpha\). Esta característica permite que o Lasso execute seleção automática de features, eliminando variáveis irrelevantes do modelo.

Vantagens da Abordagem Lasso

Seleção automática de features através de coeficientes nulos
Redução da complexidade do modelo
Melhor interpretabilidade devido à eliminação de variáveis
Eficácia em problemas de alta dimensionalidade

Implementação no scikit-learn

No scikit-learn, a classe Lasso implementa esta técnica. Ademais, estão disponíveis variações como LassoCV para seleção automática do parâmetro alpha via validação cruzada.

Parâmetros Principais

alpha: Parâmetro de regularização (controle da força da penalidade)
max_iter: Número máximo de iterações para convergência
tol: Tolerância para critério de parada
selection: Estratégia de seleção de variáveis

Exemplo Prático de Aplicação

O exemplo a seguir demonstra o uso do Lasso em um problema de regressão com features redundantes:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso, LassoCV
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("EXEMPLO PRÁTICO: REGRESSÃO LASSO")
print("=" * 60)

# Gerar dados com apenas 5 features informativas dentre 15
X, y = make_regression(n_samples=200, n_features=15, n_informative=5, 
                       noise=0.5, random_state=42)

# Dividir em conjuntos de 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"Dimensões do dataset: {X.shape}")
print(f"Features verdadeiramente informativas: 5")

# 1. Lasso com alpha fixo
print("\n1. LASSO COM ALPHA FIXO (0.1)")
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)
coef_nao_nulos = np.sum(lasso_fixo.coef_ != 0)

print(f"Coeficientes não nulos: {coef_nao_nulos}/15")
print(f"MSE: {mean_squared_error(y_test, y_pred_fixo):.4f}")
print(f"R²: {r2_score(y_test, y_pred_fixo):.4f}")

# 2. Lasso com validação cruzada para seleção de alpha
print("\n2. LASSO COM VALIDAÇÃO CRUZADA (LassoCV)")
lasso_cv = LassoCV(cv=5, max_iter=10000, random_state=42)
lasso_cv.fit(X_train, y_train)

y_pred_cv = lasso_cv.predict(X_test)
coef_nao_nulos_cv = np.sum(lasso_cv.coef_ != 0)

print(f"Melhor alpha: {lasso_cv.alpha_:.6f}")
print(f"Coeficientes não nulos: {coef_nao_nulos_cv}/15")
print(f"MSE: {mean_squared_error(y_test, y_pred_cv):.4f}")
print(f"R²: {r2_score(y_test, y_pred_cv):.4f}")

# Visualização dos coeficientes
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.bar(range(15), lasso_fixo.coef_, color='red', alpha=0.7)
plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title(f'Lasso Alpha Fixo - {coef_nao_nulos} features selecionadas')
plt.grid(True, alpha=0.3)

plt.subplot(1, 2, 2)
plt.bar(range(15), lasso_cv.coef_, color='blue', alpha=0.7)
plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title(f'Lasso CV - {coef_nao_nulos_cv} features selecionadas')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise dos coeficientes zerados
print("\n3. ANÁLISE DE ESPARSIDADE")
coeficientes_zerados = lasso_cv.coef_ == 0
print(f"Features eliminadas (coeficiente zero): {np.sum(coeficientes_zerados)}")
print(f"Features mantidas no modelo: {np.sum(~coeficientes_zerados)}")

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import Lasso, LassoCV

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("EXEMPLO PRÁTICO: REGRESSÃO LASSO")

print("=" * 60)

# Gerar dados com apenas 5 features informativas dentre 15

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

noise=0.5, random_state=42)

# Dividir em conjuntos de 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"Dimensões do dataset: {X.shape}")

print(f"Features verdadeiramente informativas: 5")

# 1. Lasso com alpha fixo

print("\n1. LASSO COM ALPHA FIXO (0.1)")

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)

coef_nao_nulos = np.sum(lasso_fixo.coef_ != 0)

print(f"Coeficientes não nulos: {coef_nao_nulos}/15")

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

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

# 2. Lasso com validação cruzada para seleção de alpha

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

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

lasso_cv.fit(X_train, y_train)

y_pred_cv = lasso_cv.predict(X_test)

coef_nao_nulos_cv = np.sum(lasso_cv.coef_ != 0)

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

print(f"Coeficientes não nulos: {coef_nao_nulos_cv}/15")

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

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

# Visualização dos coeficientes

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

plt.subplot(1, 2, 1)

plt.bar(range(15), lasso_fixo.coef_, color='red', alpha=0.7)

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

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

plt.title(f'Lasso Alpha Fixo - {coef_nao_nulos} features selecionadas')

plt.grid(True, alpha=0.3)

plt.subplot(1, 2, 2)

plt.bar(range(15), lasso_cv.coef_, color='blue', alpha=0.7)

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

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

plt.title(f'Lasso CV - {coef_nao_nulos_cv} features selecionadas')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise dos coeficientes zerados

print("\n3. ANÁLISE DE ESPARSIDADE")

coeficientes_zerados = lasso_cv.coef_ == 0

print(f"Features eliminadas (coeficiente zero): {np.sum(coeficientes_zerados)}")

print(f"Features mantidas no modelo: {np.sum(~coeficientes_zerados)}")

Considerações sobre Convergência

Embora o Lasso seja uma ferramenta poderosa, ocasionalmente pode apresentar desafios de convergência. Principalmente em problemas com alta correlação entre features, o algoritmo pode necessitar de mais iterações para convergir. Portanto, é recomendável ajustar os parâmetros max_iter e tol conforme necessário.

Estratégias de Seleção

O scikit-learn oferece duas estratégias através do parâmetro selection:

cyclic: Atualização cíclica de coeficientes (padrão)
random: Atualização aleatória, podendo ser mais eficiente em alguns casos

Cenários de Aplicação Recomendados

Problemas com muitas features potencialmente irrelevantes
Seleção de variáveis para interpretabilidade do modelo
Datasets onde a esparsidade é uma propriedade desejável
Prevenção de overfitting em alta dimensionalidade

Considerações Finais

Inegavelmente, o Lasso representa uma evolução significativa na regressão linear, combinando estimação com seleção de features. Entretanto, a escolha do parâmetro alpha é crucial e tipicamente requer validação cruzada. Analogamente, em problemas onde se deseja manter features correlacionadas, a regressão Ridge ou Elastic Net podem ser mais apropriadas.

Decerto, o domínio desta técnica expande consideravelmente o arsenal do cientista de dados, permitindo a construção de modelos mais parcimoniosos e interpretáveis. Ademais, serve como fundamento para métodos mais avançados de aprendizado estatístico.