Arquivo de Python - Página 45 de 93

Modelos Lineares Generalizados: Laço Multitarefa (MultiTaskLasso)

28/10/202518/10/2025 Por antonino

Anteriormente exploramos o Lasso tradicional para problemas de regressão com uma única variável target. Analogamente, o MultiTaskLasso estende essa abordagem para problemas com múltiplos targets, permitindo que o modelo aprenda tarefas relacionadas de forma conjunta.

Conceito Fundamental do MultiTaskLasso

Primordialmente, o MultiTaskLasso é uma generalização do Lasso para problemas de regressão multivariada. Decerto, ele assume que as diferentes tarefas de regressão compartilham a mesma estrutura esparsa nas features relevantes.

Conforme a documentação do scikit-learn, o MultiTaskLasso impõe que as mesmas features sejam selecionadas para todas as tarefas. Similarmente ao Lasso tradicional, ele promove esparsidade, mas de forma coerente através de todas as tarefas.

Formulação Matemática

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

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

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
||W||₂₁ é a norma mista L₂₁ (soma das normas L₂ das linhas)

Características Principais

Inegavelmente, o MultiTaskLasso possui propriedades únicas para problemas multivariados:

Seleção coerente de features: Mesmas features selecionadas para todos os targets
Norma mista L₂₁: Penaliza linhas inteiras da matriz de coeficientes
Aprendizado multitarefa: Aprende tarefas relacionadas conjuntamente
Transferência de conhecimento: Informação compartilhada entre tarefas

Comparação: Lasso vs MultiTaskLasso

Embora relacionados, existem diferenças fundamentais:

Lasso: Um target, seleção independente de features
MultiTaskLasso: Múltiplos targets, seleção conjunta de features
MultiTaskLasso: Assume estrutura comum entre tarefas

Aplicações Práticas

Atualmente, o MultiTaskLasso é aplicado em diversos cenários:

Problemas de recomendação: Múltiplos ratings para prever
Análise de sensores: Múltiplos sinais correlacionados
Bioinformática: Expressão gênica múltipla
Visão computacional: Múltiplos atributos de imagem

Exemplo Prático: MultiTaskLasso em Ação

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

'''
Aplicação do MultiTaskLasso para Regressão Multivariada
Este exemplo demonstra como o MultiTaskLasso pode ser usado
para prever múltiplos targets simultaneamente com seleção conjunta de features
'''

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

# Gerar dataset com múltiplos targets correlacionados
n_samples = 1000
n_features = 20
n_tasks = 3  # Número de targets
n_informative = 8  # 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=15, random_state=42)

# Adicionar correlação entre os targets
correlation_matrix = np.array([[1.0, 0.7, 0.5],
                              [0.7, 1.0, 0.6],
                              [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: MultiTaskLasso vs Lasso Individual ---")

# MultiTaskLasso (abordagem conjunta)
multi_lasso = MultiTaskLasso(alpha=0.1, max_iter=10000, random_state=42)
multi_lasso.fit(X_train_scaled, Y_train_scaled)

Y_pred_multi = multi_lasso.predict(X_test_scaled)
mse_multi = mean_squared_error(Y_test_scaled, Y_pred_multi)
r2_multi = r2_score(Y_test_scaled, Y_pred_multi)

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

# Lasso individual para cada tarefa (abordagem independente)
individual_results = []
individual_coefs = []

for task in range(n_tasks):
    lasso = Lasso(alpha=0.1, max_iter=10000, random_state=42)
    lasso.fit(X_train_scaled, Y_train_scaled[:, task])
    
    y_pred = lasso.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(lasso.coef_)

# Calcular médias para Lasso 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"\nLasso Individual (média entre tarefas):")
print(f"MSE médio: {avg_mse_individual:.4f}")
print(f"R² médio: {avg_r2_individual:.4f}")

# Análise da matriz de coeficientes
print(f"\n--- Análise da Matriz de Coeficientes ---")

# Coeficientes do MultiTaskLasso
multi_coef = multi_lasso.coef_
print(f"\nMultiTaskLasso - Estrutura de coeficientes:")
print(f"Dimensões da matriz W: {multi_coef.shape}")
print(f"Features com coeficientes não-zero em todas tarefas: {np.sum(np.all(multi_coef != 0, axis=1))}")
print(f"Features com coeficientes não-zero em alguma tarefa: {np.sum(np.any(multi_coef != 0, axis=1))}")
print(f"Features com coeficientes zero em todas tarefas: {np.sum(np.all(multi_coef == 0, axis=1))}")

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

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

# Plot 2: Comparação de coeficientes por feature
plt.subplot(2, 3, 2)
for task in range(n_tasks):
    plt.plot(multi_coef[:, task], 'o-', label=f'Tarefa {task+1}', alpha=0.7)
plt.xlabel('Feature')
plt.ylabel('Valor do Coeficiente')
plt.title('Coeficientes por Tarefa')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot 3: Features selecionadas
plt.subplot(2, 3, 3)
features_selected = np.any(multi_coef != 0, axis=1)
plt.bar(['Selecionadas', 'Não Selecionadas'], 
        [np.sum(features_selected), np.sum(~features_selected)],
        color=['lightcoral', 'lightblue'])
plt.title('Seleção de Features')
plt.ylabel('Número de Features')

# Plot 4: Comparação de performance
plt.subplot(2, 3, 4)
models = ['MultiTaskLasso', 'Lasso Individual']
mses = [mse_multi, avg_mse_individual]

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

# Plot 5: Correlação entre targets verdadeiros
plt.subplot(2, 3, 5)
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 6: Correlação entre previsões
plt.subplot(2, 3, 6)
corr_pred = np.corrcoef(Y_pred_multi.T)
im = plt.imshow(corr_pred, cmap='coolwarm', vmin=-1, vmax=1)
plt.colorbar(im)
plt.title('Correlação - Previsões MultiTaskLasso')
plt.xlabel('Tarefa')
plt.ylabel('Tarefa')

plt.tight_layout()
plt.show()

# Análise de variação do parâmetro alpha
print(f"\n--- Análise de Sensibilidade ao Parâmetro Alpha ---")

alphas = [0.001, 0.01, 0.1, 1, 10]
n_features_selected = []
mse_scores = []

for alpha in alphas:
    model = MultiTaskLasso(alpha=alpha, 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)
    n_selected = np.sum(np.any(model.coef_ != 0, axis=1))
    
    n_features_selected.append(n_selected)
    mse_scores.append(mse)
    
    print(f"Alpha: {alpha:6.3f} | Features: {n_selected:2d} | MSE: {mse:.4f}")

# Visualização da seleção de features vs alpha
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.semilogx(alphas, n_features_selected, 'o-', linewidth=2)
plt.xlabel('Alpha')
plt.ylabel('Número de Features Selecionadas')
plt.title('Seleção de Features vs Alpha')
plt.grid(True, alpha=0.3)

plt.subplot(1, 2, 2)
plt.semilogx(alphas, mse_scores, 'o-', linewidth=2)
plt.xlabel('Alpha')
plt.ylabel('MSE')
plt.title('Performance vs Alpha')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Resumo final
print(f"\n--- Resumo Final ---")
print(f"Vantagem do MultiTaskLasso em MSE: {(avg_mse_individual - mse_multi)/avg_mse_individual*100:.1f}%")
print(f"Features compartilhadas selecionadas: {np.sum(np.all(multi_coef != 0, axis=1))}")
print(f"Consistência na seleção: {np.sum(np.all(multi_coef != 0, axis=1)) / np.sum(np.any(multi_coef != 0, axis=1)):.1%}")

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

'''

Aplicação do MultiTaskLasso para Regressão Multivariada

Este exemplo demonstra como o MultiTaskLasso pode ser usado

para prever múltiplos targets simultaneamente com seleção conjunta de features

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import MultiTaskLasso, Lasso

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com múltiplos targets correlacionados

n_samples = 1000

n_features = 20

n_tasks = 3 # Número de targets

n_informative = 8 # 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=15, random_state=42)

# Adicionar correlação entre os targets

correlation_matrix = np.array([[1.0, 0.7, 0.5],

[0.7, 1.0, 0.6],

[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: MultiTaskLasso vs Lasso Individual ---")

# MultiTaskLasso (abordagem conjunta)

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

multi_lasso.fit(X_train_scaled, Y_train_scaled)

Y_pred_multi = multi_lasso.predict(X_test_scaled)

mse_multi = mean_squared_error(Y_test_scaled, Y_pred_multi)

r2_multi = r2_score(Y_test_scaled, Y_pred_multi)

print(f"\nMultiTaskLasso:")

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

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

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

# Lasso individual para cada tarefa (abordagem independente)

individual_results = []

individual_coefs = []

for task in range(n_tasks):

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

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

y_pred = lasso.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(lasso.coef_)

# Calcular médias para Lasso 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"\nLasso Individual (média entre tarefas):")

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

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

# Análise da matriz de coeficientes

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

# Coeficientes do MultiTaskLasso

multi_coef = multi_lasso.coef_

print(f"\nMultiTaskLasso - Estrutura de coeficientes:")

print(f"Dimensões da matriz W: {multi_coef.shape}")

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

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

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

# Visualização dos resultados

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

# Plot 1: Matriz de coeficientes do MultiTaskLasso

plt.subplot(2, 3, 1)

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

plt.colorbar(im)

plt.xlabel('Tarefa')

plt.ylabel('Feature')

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

# Plot 2: Comparação de coeficientes por feature

plt.subplot(2, 3, 2)

for task in range(n_tasks):

plt.plot(multi_coef[:, task], 'o-', label=f'Tarefa {task+1}', alpha=0.7)

plt.xlabel('Feature')

plt.ylabel('Valor do Coeficiente')

plt.title('Coeficientes por Tarefa')

plt.legend()

plt.grid(True, alpha=0.3)

# Plot 3: Features selecionadas

plt.subplot(2, 3, 3)

features_selected = np.any(multi_coef != 0, axis=1)

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

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

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

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

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

# Plot 4: Comparação de performance

plt.subplot(2, 3, 4)

models = ['MultiTaskLasso', 'Lasso Individual']

mses = [mse_multi, avg_mse_individual]

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

plt.ylabel('MSE')

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

plt.xticks(rotation=45)

# Plot 5: Correlação entre targets verdadeiros

plt.subplot(2, 3, 5)

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 6: Correlação entre previsões

plt.subplot(2, 3, 6)

corr_pred = np.corrcoef(Y_pred_multi.T)

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

plt.colorbar(im)

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

plt.xlabel('Tarefa')

plt.ylabel('Tarefa')

plt.tight_layout()

plt.show()

# Análise de variação do parâmetro alpha

print(f"\n--- Análise de Sensibilidade ao Parâmetro Alpha ---")

alphas = [0.001, 0.01, 0.1, 1, 10]

n_features_selected = []

mse_scores = []

for alpha in alphas:

model = MultiTaskLasso(alpha=alpha, 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)

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

n_features_selected.append(n_selected)

mse_scores.append(mse)

print(f"Alpha: {alpha:6.3f} | Features: {n_selected:2d} | MSE: {mse:.4f}")

# Visualização da seleção de features vs alpha

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

plt.subplot(1, 2, 1)

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

plt.xlabel('Alpha')

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

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

plt.grid(True, alpha=0.3)

plt.subplot(1, 2, 2)

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

plt.xlabel('Alpha')

plt.ylabel('MSE')

plt.title('Performance vs Alpha')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Resumo final

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

print(f"Vantagem do MultiTaskLasso em MSE: {(avg_mse_individual - mse_multi)/avg_mse_individual*100:.1f}%")

print(f"Features compartilhadas selecionadas: {np.sum(np.all(multi_coef != 0, axis=1))}")

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

Vantagens do MultiTaskLasso

Embora mais complexo, o MultiTaskLasso oferece benefícios significativos:

Vantagens Principais

Seleção coerente: Mesmo conjunto de features para todas tarefas
Transferência de aprendizado: Tarefas se beneficiam mutuamente
Modelos mais robustos: Menor variância através de tarefas
Interpretabilidade: Estrutura comum facilita análise

Quando Usar MultiTaskLasso

O MultiTaskLasso é particularmente adequado quando:

As tarefas estão correlacionadas ou relacionadas
Há estrutura comum nas features relevantes
Deseja-se consistência na seleção de features
Os dados são escassos para tarefas individuais

Considerações Práticas

Algumas considerações importantes para uso eficaz:

Normalize os dados antes de aplicar o modelo
Use validação cruzada para selecionar o parâmetro alpha
Considere MultiTaskElasticNet para combinar L1 e L2
Verifique a correlação entre targets antes de usar

Enfim, o MultiTaskLasso representa uma ferramenta poderosa para problemas de regressão multivariada onde as tarefas compartilham estrutura subjacente, permitindo aprendizado mais eficiente e modelos mais interpretáveis.

Referência: https://scikit-learn.org/0.21/modules/linear_model.html#multi-task-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