antonino, Autor em Á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

Modelos Lineares Generalizados: Rede Elástica Multitarefa

19/12/202518/10/2025 Por antonino

Anteriormente exploramos a Elastic Net para problemas de regressão com um único target. Analogamente, o MultiTaskElasticNet estende essa abordagem para problemas com múltiplos targets, combinando as vantagens da Elastic Net com o aprendizado multitarefa.

Conceito Fundamental do MultiTaskElasticNet

Primordialmente, o MultiTaskElasticNet é uma generalização da Elastic Net para problemas de regressão multivariada. Decerto, ele assume que as diferentes tarefas de regressão compartilham a mesma estrutura esparsa nas features relevantes, enquanto combina as penalidades L1 e L2.

Conforme a documentação do scikit-learn, o MultiTaskElasticNet é particularmente útil quando temos múltiplos targets correlacionados e desejamos realizar seleção de features de forma coerente através de todas as tarefas. Similarmente ao MultiTaskLasso, ele promove que as mesmas features sejam selecionadas para todos os targets.

Formulação Matemática

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

\(\min_{W} \frac{1}{2n}||XW – Y||_F^2 + \alpha\rho||W||_{21} + \frac{\alpha(1-\rho)}{2}||W||_F^2\)

Onde:

X é a matriz de features \((n \times p)\)
Y é a matriz de targets \((n \times k)\)
W é a matriz de coeficientes \((p \times k)\)
α é o parâmetro de regularização principal
ρ é a razão de mistura L1 (l1_ratio)
||W||₂₁ é a norma mista L₂₁ (soma das normas L₂ das linhas)
||W||_F² é a norma de Frobenius ao quadrado

Características Principais

Inegavelmente, o MultiTaskElasticNet combina as melhores propriedades de várias técnicas:

Seleção coerente de features: Mesmas features selecionadas para todos os targets
Regularização mista: Combina penalidades L1 e L2 como a Elastic Net

Estabilidade com correlação: Robustez com features correlacionadas

Aprendizado multitarefa: Transferência de conhecimento entre tarefas relacionadas

Vantagens sobre Abordagens Individuais

Embora treinar Elastic Nets separadas para cada target seja possível, o MultiTaskElasticNet oferece benefícios significativos:

Consistência: Mesmo conjunto de features selecionado para todas as tarefas
Eficiência estatística: Melhor uso dos dados através do compartilhamento de informação
Robustez: Mais estável com alta dimensionalidade
Interpretabilidade: Modelo único e coerente para todas as tarefas

Exemplo Prático: MultiTaskElasticNet em Ação

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

'''
Aplicação do MultiTaskElasticNet para Regressão Multivariada
Este exemplo demonstra como o MultiTaskElasticNet combina
seleção coerente de features com regularização mista L1/L2
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import MultiTaskElasticNet, MultiTaskLasso, ElasticNet
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 múltiplos targets correlacionados
n_samples = 800
n_features = 25
n_tasks = 4  # Número de targets
n_informative = 10  # Features realmente informativas

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

# Gerar dados com estrutura comum entre tarefas
X, Y = make_regression(n_samples=n_samples, n_features=n_features, 
                      n_targets=n_tasks, n_informative=n_informative,
                      noise=20, random_state=42)

# Adicionar correlação entre os targets
correlation_matrix = np.array([[1.0, 0.8, 0.6, 0.4],
                              [0.8, 1.0, 0.7, 0.5],
                              [0.6, 0.7, 1.0, 0.6],
                              [0.4, 0.5, 0.6, 1.0]])

L = np.linalg.cholesky(correlation_matrix)
Y = Y @ L.T

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

# Dividir em treino e teste
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, 
                                                    random_state=42)

# Normalizar os dados
scaler_X = StandardScaler()
scaler_Y = StandardScaler()

X_train_scaled = scaler_X.fit_transform(X_train)
X_test_scaled = scaler_X.transform(X_test)
Y_train_scaled = scaler_Y.fit_transform(Y_train)
Y_test_scaled = scaler_Y.transform(Y_test)

print(f"\n--- Comparação: MultiTaskElasticNet vs Abordagens Alternativas ---")

# MultiTaskElasticNet
multi_en = MultiTaskElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)
multi_en.fit(X_train_scaled, Y_train_scaled)
Y_pred_multi_en = multi_en.predict(X_test_scaled)
mse_multi_en = mean_squared_error(Y_test_scaled, Y_pred_multi_en)
r2_multi_en = r2_score(Y_test_scaled, Y_pred_multi_en)

# MultiTaskLasso (para comparação)
multi_lasso = MultiTaskLasso(alpha=0.1, max_iter=10000, random_state=42)
multi_lasso.fit(X_train_scaled, Y_train_scaled)
Y_pred_multi_lasso = multi_lasso.predict(X_test_scaled)
mse_multi_lasso = mean_squared_error(Y_test_scaled, Y_pred_multi_lasso)
r2_multi_lasso = r2_score(Y_test_scaled, Y_pred_multi_lasso)

# Elastic Net individual para cada tarefa
individual_results = []
individual_coefs = []

for task in range(n_tasks):
    en = ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)
    en.fit(X_train_scaled, Y_train_scaled[:, task])
    
    y_pred = en.predict(X_test_scaled)
    mse = mean_squared_error(Y_test_scaled[:, task], y_pred)
    r2 = r2_score(Y_test_scaled[:, task], y_pred)
    
    individual_results.append({'mse': mse, 'r2': r2})
    individual_coefs.append(en.coef_)

# Calcular médias para abordagem individual
avg_mse_individual = np.mean([r['mse'] for r in individual_results])
avg_r2_individual = np.mean([r['r2'] for r in individual_results])

print(f"\nMultiTaskElasticNet:")
print(f"MSE total: {mse_multi_en:.4f}")
print(f"R² total: {r2_multi_en:.4f}")
print(f"Features selecionadas: {np.sum(np.any(multi_en.coef_ != 0, axis=1))}")

print(f"\nMultiTaskLasso:")
print(f"MSE total: {mse_multi_lasso:.4f}")
print(f"R² total: {r2_multi_lasso:.4f}")
print(f"Features selecionadas: {np.sum(np.any(multi_lasso.coef_ != 0, axis=1))}")

print(f"\nElastic Net Individual (média):")
print(f"MSE médio: {avg_mse_individual:.4f}")
print(f"R² médio: {avg_r2_individual:.4f}")

# Otimização dos hiperparâmetros do MultiTaskElasticNet
print(f"\n--- Otimização dos Hiperparâmetros do MultiTaskElasticNet ---")

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

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

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

# Modelo MultiTaskElasticNet otimizado
best_multi_en = grid_search.best_estimator_
Y_pred_best = best_multi_en.predict(X_test_scaled)
final_mse = mean_squared_error(Y_test_scaled, Y_pred_best)
final_r2 = r2_score(Y_test_scaled, Y_pred_best)

print(f"\nMultiTaskElasticNet Otimizado:")
print(f"MSE: {final_mse:.4f}")
print(f"R²: {final_r2:.4f}")
print(f"Features selecionadas: {np.sum(np.any(best_multi_en.coef_ != 0, axis=1))}")

# Visualização dos resultados
plt.figure(figsize=(16, 12))

# Plot 1: Matriz de coeficientes do MultiTaskElasticNet
plt.subplot(3, 3, 1)
coef_matrix = best_multi_en.coef_
im = plt.imshow(coef_matrix, aspect='auto', cmap='RdBu_r', vmin=-1, vmax=1)
plt.colorbar(im)
plt.xlabel('Tarefa')
plt.ylabel('Feature')
plt.title('Matriz de Coeficientes - MultiTaskElasticNet')

# Plot 2: Comparação de performance
plt.subplot(3, 3, 2)
methods = ['MultiTaskElasticNet', 'MultiTaskLasso', 'ElasticNet Individual']
mses = [mse_multi_en, mse_multi_lasso, avg_mse_individual]

plt.bar(methods, mses, color=['lightcoral', 'lightgreen', 'skyblue'])
plt.ylabel('MSE')
plt.title('Comparação de Performance')
plt.xticks(rotation=45)

# Plot 3: Features selecionadas
plt.subplot(3, 3, 3)
n_selected = [np.sum(np.any(best_multi_en.coef_ != 0, axis=1)),
              np.sum(np.any(multi_lasso.coef_ != 0, axis=1)),
              n_features]  # Individual sempre seleciona todas (com valores pequenos)

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

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

for l1_ratio in l1_ratios:
    model = MultiTaskElasticNet(alpha=0.1, l1_ratio=l1_ratio, max_iter=10000, random_state=42)
    model.fit(X_train_scaled, Y_train_scaled)
    Y_pred = model.predict(X_test_scaled)
    mse = mean_squared_error(Y_test_scaled, Y_pred)
    sparsity = np.sum(np.any(model.coef_ != 0, axis=1))
    
    cv_scores.append(mse)
    sparsity_levels.append(sparsity)

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

# Plot 5: Esparsidade vs l1_ratio
plt.subplot(3, 3, 5)
plt.plot(l1_ratios, sparsity_levels, 's-', linewidth=2, color='red')
plt.xlabel('l1_ratio')
plt.ylabel('Features Não-Zero')
plt.title('Esparsidade vs l1_ratio')
plt.grid(True, alpha=0.3)

# Plot 6: Correlação entre targets verdadeiros
plt.subplot(3, 3, 6)
corr_true = np.corrcoef(Y_test_scaled.T)
im = plt.imshow(corr_true, cmap='coolwarm', vmin=-1, vmax=1)
plt.colorbar(im)
plt.title('Correlação - Targets Verdadeiros')
plt.xlabel('Tarefa')
plt.ylabel('Tarefa')

# Plot 7: Correlação entre previsões
plt.subplot(3, 3, 7)
corr_pred = np.corrcoef(Y_pred_best.T)
im = plt.imshow(corr_pred, cmap='coolwarm', vmin=-1, vmax=1)
plt.colorbar(im)
plt.title('Correlação - Previsões')
plt.xlabel('Tarefa')
plt.ylabel('Tarefa')

# Plot 8: Performance por tarefa individual
plt.subplot(3, 3, 8)
task_mses_multi = [mean_squared_error(Y_test_scaled[:, i], Y_pred_best[:, i]) 
                   for i in range(n_tasks)]
task_mses_individual = [r['mse'] for r in individual_results]

x_pos = np.arange(n_tasks)
width = 0.35

plt.bar(x_pos - width/2, task_mses_multi, width, label='MultiTaskElasticNet', alpha=0.8)
plt.bar(x_pos + width/2, task_mses_individual, width, label='ElasticNet Individual', alpha=0.8)
plt.xlabel('Tarefa')
plt.ylabel('MSE')
plt.title('Performance por Tarefa')
plt.legend()
plt.xticks(x_pos, [f'Tarefa {i+1}' for i in range(n_tasks)])

# Plot 9: Consistência na seleção de features
plt.subplot(3, 3, 9)
# Calcular consistência (quantas features são usadas em todas as tarefas)
consistency_multi = np.sum(np.all(best_multi_en.coef_ != 0, axis=1))
consistency_individual = 0  # Abordagem individual não garante consistência

plt.bar(['MultiTaskElasticNet', 'ElasticNet Individual'], 
        [consistency_multi, consistency_individual],
        color=['lightcoral', 'skyblue'])
plt.ylabel('Features em Todas as Tarefas')
plt.title('Consistência na Seleção')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# Análise detalhada da estrutura de coeficientes
print(f"\n--- Análise Detalhada da Estrutura de Coeficientes ---")

coef_matrix_best = best_multi_en.coef_
print(f"\nEstrutura da matriz de coeficientes:")
print(f"Dimensões: {coef_matrix_best.shape}")
print(f"Features com coeficientes não-zero em todas tarefas: {np.sum(np.all(coef_matrix_best != 0, axis=1))}")
print(f"Features com coeficientes não-zero em alguma tarefa: {np.sum(np.any(coef_matrix_best != 0, axis=1))}")
print(f"Features com coeficientes zero em todas tarefas: {np.sum(np.all(coef_matrix_best == 0, axis=1))}")

# Análise de grupos de features
print(f"\nDistribuição de importância das features:")
feature_importance = np.linalg.norm(coef_matrix_best, axis=1)  # Norma L2 por feature
top_features = np.argsort(feature_importance)[::-1][:5]

print("Top 5 features mais importantes:")
for i, feat_idx in enumerate(top_features):
    print(f"  Feature {feat_idx:2d}: importância = {feature_importance[feat_idx]:.3f}")

# Resumo final
print(f"\n--- Resumo Final ---")
print(f"Vantagem do MultiTaskElasticNet sobre abordagem individual: {(avg_mse_individual - final_mse)/avg_mse_individual*100:.1f}%")
print(f"Consistência na seleção: {np.sum(np.all(coef_matrix_best != 0, axis=1)) / np.sum(np.any(coef_matrix_best != 0, axis=1)):.1%}")
print(f"Parâmetros otimizados: alpha={grid_search.best_params_['alpha']}, l1_ratio={grid_search.best_params_['l1_ratio']}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

'''

Aplicação do MultiTaskElasticNet para Regressão Multivariada

Este exemplo demonstra como o MultiTaskElasticNet combina

seleção coerente de features com regularização mista L1/L2

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import MultiTaskElasticNet, MultiTaskLasso, ElasticNet

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 múltiplos targets correlacionados

n_samples = 800

n_features = 25

n_tasks = 4 # Número de targets

n_informative = 10 # Features realmente informativas

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

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

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

print(f"Número de targets (tarefas): {n_tasks}")

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

# Gerar dados com estrutura comum entre tarefas

X, Y = make_regression(n_samples=n_samples, n_features=n_features,

n_targets=n_tasks, n_informative=n_informative,

noise=20, random_state=42)

# Adicionar correlação entre os targets

correlation_matrix = np.array([[1.0, 0.8, 0.6, 0.4],

[0.8, 1.0, 0.7, 0.5],

[0.6, 0.7, 1.0, 0.6],

[0.4, 0.5, 0.6, 1.0]])

L = np.linalg.cholesky(correlation_matrix)

Y = Y @ L.T

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

# Dividir em treino e teste

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3,

random_state=42)

# Normalizar os dados

scaler_X = StandardScaler()

scaler_Y = StandardScaler()

X_train_scaled = scaler_X.fit_transform(X_train)

X_test_scaled = scaler_X.transform(X_test)

Y_train_scaled = scaler_Y.fit_transform(Y_train)

Y_test_scaled = scaler_Y.transform(Y_test)

print(f"\n--- Comparação: MultiTaskElasticNet vs Abordagens Alternativas ---")

# MultiTaskElasticNet

multi_en = MultiTaskElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=10000, random_state=42)

multi_en.fit(X_train_scaled, Y_train_scaled)

Y_pred_multi_en = multi_en.predict(X_test_scaled)

mse_multi_en = mean_squared_error(Y_test_scaled, Y_pred_multi_en)

r2_multi_en = r2_score(Y_test_scaled, Y_pred_multi_en)

# MultiTaskLasso (para comparação)

multi_lasso = MultiTaskLasso(alpha=0.1, max_iter=10000, random_state=42)

multi_lasso.fit(X_train_scaled, Y_train_scaled)

Y_pred_multi_lasso = multi_lasso.predict(X_test_scaled)

mse_multi_lasso = mean_squared_error(Y_test_scaled, Y_pred_multi_lasso)

r2_multi_lasso = r2_score(Y_test_scaled, Y_pred_multi_lasso)

# Elastic Net individual para cada tarefa

individual_results = []

individual_coefs = []

for task in range(n_tasks):

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

en.fit(X_train_scaled, Y_train_scaled[:, task])

y_pred = en.predict(X_test_scaled)

mse = mean_squared_error(Y_test_scaled[:, task], y_pred)

r2 = r2_score(Y_test_scaled[:, task], y_pred)

individual_results.append({'mse': mse, 'r2': r2})

individual_coefs.append(en.coef_)

# Calcular médias para abordagem individual

avg_mse_individual = np.mean([r['mse'] for r in individual_results])

avg_r2_individual = np.mean([r['r2'] for r in individual_results])

print(f"\nMultiTaskElasticNet:")

print(f"MSE total: {mse_multi_en:.4f}")

print(f"R² total: {r2_multi_en:.4f}")

print(f"Features selecionadas: {np.sum(np.any(multi_en.coef_ != 0, axis=1))}")

print(f"\nMultiTaskLasso:")

print(f"MSE total: {mse_multi_lasso:.4f}")

print(f"R² total: {r2_multi_lasso:.4f}")

print(f"Features selecionadas: {np.sum(np.any(multi_lasso.coef_ != 0, axis=1))}")

print(f"\nElastic Net Individual (média):")

print(f"MSE médio: {avg_mse_individual:.4f}")

print(f"R² médio: {avg_r2_individual:.4f}")

# Otimização dos hiperparâmetros do MultiTaskElasticNet

print(f"\n--- Otimização dos Hiperparâmetros do MultiTaskElasticNet ---")

param_grid = {

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

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

}

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

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

n_jobs=-1)

grid_search.fit(X_train_scaled, Y_train_scaled)

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

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

# Modelo MultiTaskElasticNet otimizado

best_multi_en = grid_search.best_estimator_

Y_pred_best = best_multi_en.predict(X_test_scaled)

final_mse = mean_squared_error(Y_test_scaled, Y_pred_best)

final_r2 = r2_score(Y_test_scaled, Y_pred_best)

print(f"\nMultiTaskElasticNet Otimizado:")

print(f"MSE: {final_mse:.4f}")

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

print(f"Features selecionadas: {np.sum(np.any(best_multi_en.coef_ != 0, axis=1))}")

# Visualização dos resultados

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

# Plot 1: Matriz de coeficientes do MultiTaskElasticNet

plt.subplot(3, 3, 1)

coef_matrix = best_multi_en.coef_

im = plt.imshow(coef_matrix, aspect='auto', cmap='RdBu_r', vmin=-1, vmax=1)

plt.colorbar(im)

plt.xlabel('Tarefa')

plt.ylabel('Feature')

plt.title('Matriz de Coeficientes - MultiTaskElasticNet')

# Plot 2: Comparação de performance

plt.subplot(3, 3, 2)

methods = ['MultiTaskElasticNet', 'MultiTaskLasso', 'ElasticNet Individual']

mses = [mse_multi_en, mse_multi_lasso, avg_mse_individual]

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

plt.ylabel('MSE')

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

plt.xticks(rotation=45)

# Plot 3: Features selecionadas

plt.subplot(3, 3, 3)

n_selected = [np.sum(np.any(best_multi_en.coef_ != 0, axis=1)),

np.sum(np.any(multi_lasso.coef_ != 0, axis=1)),

n_features] # Individual sempre seleciona todas (com valores pequenos)

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

plt.ylabel('Features Selecionadas')

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

plt.xticks(rotation=45)

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

plt.subplot(3, 3, 4)

l1_ratios = param_grid['l1_ratio']

cv_scores = []

sparsity_levels = []

for l1_ratio in l1_ratios:

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

model.fit(X_train_scaled, Y_train_scaled)

Y_pred = model.predict(X_test_scaled)

mse = mean_squared_error(Y_test_scaled, Y_pred)

sparsity = np.sum(np.any(model.coef_ != 0, axis=1))

cv_scores.append(mse)

sparsity_levels.append(sparsity)

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

plt.xlabel('l1_ratio')

plt.ylabel('MSE')

plt.title('Performance vs l1_ratio')

plt.grid(True, alpha=0.3)

plt.legend()

# Plot 5: Esparsidade vs l1_ratio

plt.subplot(3, 3, 5)

plt.plot(l1_ratios, sparsity_levels, 's-', linewidth=2, color='red')

plt.xlabel('l1_ratio')

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

plt.title('Esparsidade vs l1_ratio')

plt.grid(True, alpha=0.3)

# Plot 6: Correlação entre targets verdadeiros

plt.subplot(3, 3, 6)

corr_true = np.corrcoef(Y_test_scaled.T)

im = plt.imshow(corr_true, cmap='coolwarm', vmin=-1, vmax=1)

plt.colorbar(im)

plt.title('Correlação - Targets Verdadeiros')

plt.xlabel('Tarefa')

plt.ylabel('Tarefa')

# Plot 7: Correlação entre previsões

plt.subplot(3, 3, 7)

corr_pred = np.corrcoef(Y_pred_best.T)

im = plt.imshow(corr_pred, cmap='coolwarm', vmin=-1, vmax=1)

plt.colorbar(im)

plt.title('Correlação - Previsões')

plt.xlabel('Tarefa')

plt.ylabel('Tarefa')

# Plot 8: Performance por tarefa individual

plt.subplot(3, 3, 8)

task_mses_multi = [mean_squared_error(Y_test_scaled[:, i], Y_pred_best[:, i])

for i in range(n_tasks)]

task_mses_individual = [r['mse'] for r in individual_results]

x_pos = np.arange(n_tasks)

width = 0.35

plt.bar(x_pos - width/2, task_mses_multi, width, label='MultiTaskElasticNet', alpha=0.8)

plt.bar(x_pos + width/2, task_mses_individual, width, label='ElasticNet Individual', alpha=0.8)

plt.xlabel('Tarefa')

plt.ylabel('MSE')

plt.title('Performance por Tarefa')

plt.legend()

plt.xticks(x_pos, [f'Tarefa {i+1}' for i in range(n_tasks)])

# Plot 9: Consistência na seleção de features

plt.subplot(3, 3, 9)

# Calcular consistência (quantas features são usadas em todas as tarefas)

consistency_multi = np.sum(np.all(best_multi_en.coef_ != 0, axis=1))

consistency_individual = 0 # Abordagem individual não garante consistência

plt.bar(['MultiTaskElasticNet', 'ElasticNet Individual'],

[consistency_multi, consistency_individual],

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

plt.ylabel('Features em Todas as Tarefas')

plt.title('Consistência na Seleção')

plt.xticks(rotation=45)

plt.tight_layout()

plt.show()

# Análise detalhada da estrutura de coeficientes

print(f"\n--- Análise Detalhada da Estrutura de Coeficientes ---")

coef_matrix_best = best_multi_en.coef_

print(f"\nEstrutura da matriz de coeficientes:")

print(f"Dimensões: {coef_matrix_best.shape}")

print(f"Features com coeficientes não-zero em todas tarefas: {np.sum(np.all(coef_matrix_best != 0, axis=1))}")

print(f"Features com coeficientes não-zero em alguma tarefa: {np.sum(np.any(coef_matrix_best != 0, axis=1))}")

print(f"Features com coeficientes zero em todas tarefas: {np.sum(np.all(coef_matrix_best == 0, axis=1))}")

# Análise de grupos de features

print(f"\nDistribuição de importância das features:")

feature_importance = np.linalg.norm(coef_matrix_best, axis=1) # Norma L2 por feature

top_features = np.argsort(feature_importance)[::-1][:5]

print("Top 5 features mais importantes:")

for i, feat_idx in enumerate(top_features):

print(f" Feature {feat_idx:2d}: importância = {feature_importance[feat_idx]:.3f}")

# Resumo final

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

print(f"Vantagem do MultiTaskElasticNet sobre abordagem individual: {(avg_mse_individual - final_mse)/avg_mse_individual*100:.1f}%")

print(f"Consistência na seleção: {np.sum(np.all(coef_matrix_best != 0, axis=1)) / np.sum(np.any(coef_matrix_best != 0, axis=1)):.1%}")

print(f"Parâmetros otimizados: alpha={grid_search.best_params_['alpha']}, l1_ratio={grid_search.best_params_['l1_ratio']}")

Casos de Uso Recomendados

O MultiTaskElasticNet é particularmente eficaz em:

Sistemas de recomendação: Múltiplos ratings ou preferências para prever
Análise de sensores: Múltiplos sinais correlacionados de diferentes sensores
Bioinformática: Expressão de múltiplos genes ou proteínas
Problemas com targets correlacionados: Quando há estrutura comum nas relações

Considerações Práticas

Algumas recomendações importantes para uso eficaz:

Verifique a correlação entre os targets antes de usar abordagem multitarefa
Use StandardScaler para normalizar tanto features quanto targets
Considere MultiTaskElasticNetCV para seleção automática de parâmetros
Avalie se a suposição de estrutura comum entre tarefas é válida

Quando Escolher MultiTaskElasticNet

Prefira MultiTaskElasticNet quando:

Os targets estão correlacionados e compartilham features relevantes
Deseja-se consistência na seleção de features através das tarefas
Há alta dimensionalidade (muitas features) e dados limitados
Features correlacionadas estão presentes no dataset

Enfim, o MultiTaskElasticNet representa uma ferramenta poderosa para problemas de regressão multivariada, combinando a flexibilidade da Elastic Net com os benefícios do aprendizado multitarefa para produzir modelos robustos, interpretáveis e de alta performance.

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