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

Formulação Matemática do SVM: Fundamentos teóricos e implementação

19/12/202528/10/2025 Por antonino

Compreendendo os Fundamentos Matemáticos dos Support Vector Machines

O tópico 1.4.7. Mathematical formulation descreve os princípios matemáticos que fundamentam os Support Vector Machines. Esta seção é crucial para entender como o SVM encontra o hiperplano ótimo que separa diferentes classes nos dados.

Formulação do Problema de Otimização

Primeiramente, o SVM resolve um problema de otimização convexa. Para dados linearmente separáveis, o objetivo é encontrar o hiperplano que maximiza a margem entre as classes. A formulação primal é expressa como:

\(\min_{w, b} \frac{1}{2} \|w\|^2\)

sujeito a:

\(y_i (w \cdot x_i + b) \geq 1 \quad \forall i\)

onde w é o vetor de pesos e b é o viés.

Problema Dual e Multiplicadores de Lagrange

Certamente, a formulação dual é mais eficiente computacionalmente. Através dos multiplicadores de Lagrange, transformamos o problema em:

\(\max_{\alpha} \sum_{i=1}^n \alpha_i – \frac{1}{2} \sum_{i=1}^n \sum_{j=1}^n \alpha_i \alpha_j y_i y_j x_i \cdot x_j\)

sujeito a:

\(\sum_{i=1}^n \alpha_i y_i = 0 \quad \text{e} \quad 0 \leq \alpha_i \leq C\)

import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import make_classification
import cvxopt

# Implementação manual do problema dual
def svm_dual_manual(X, y, C=1.0):
    n_samples, n_features = X.shape
    
    # Matriz do kernel linear
    K = np.dot(X, X.T)
    
    # Configuração do problema de otimização quadrática
    P = cvxopt.matrix(np.outer(y, y) * K)
    q = cvxopt.matrix(-np.ones(n_samples))
    
    # Restrições de desigualdade
    G = cvxopt.matrix(np.vstack((-np.eye(n_samples), np.eye(n_samples))))
    h = cvxopt.matrix(np.hstack((np.zeros(n_samples), np.ones(n_samples) * C)))
    
    # Restrição de igualdade
    A = cvxopt.matrix(y, (1, n_samples))
    b = cvxopt.matrix(0.0)
    
    # Resolvendo o problema
    solution = cvxopt.solvers.qp(P, q, G, h, A, b)
    alphas = np.array(solution['x']).flatten()
    
    return alphas

# Gerando dados de exemplo
X, y = make_classification(n_samples=100, n_features=2, n_classes=2, 
                          n_redundant=0, n_informative=2, random_state=42)
y = 2 * y - 1  # Convertendo para -1, 1

# Calculando alphas
alphas = svm_dual_manual(X, y, C=1.0)
print("Multiplicadores de Lagrange calculados:")
print(f"Número de vetores suporte: {np.sum(alphas > 1e-5)}")

import numpy as np

from sklearn.svm import SVC

from sklearn.datasets import make_classification

import cvxopt

# Implementação manual do problema dual

def svm_dual_manual(X, y, C=1.0):

n_samples, n_features = X.shape

# Matriz do kernel linear

K = np.dot(X, X.T)

# Configuração do problema de otimização quadrática

P = cvxopt.matrix(np.outer(y, y) * K)

q = cvxopt.matrix(-np.ones(n_samples))

# Restrições de desigualdade

G = cvxopt.matrix(np.vstack((-np.eye(n_samples), np.eye(n_samples))))

h = cvxopt.matrix(np.hstack((np.zeros(n_samples), np.ones(n_samples) * C)))

# Restrição de igualdade

A = cvxopt.matrix(y, (1, n_samples))

b = cvxopt.matrix(0.0)

# Resolvendo o problema

solution = cvxopt.solvers.qp(P, q, G, h, A, b)

alphas = np.array(solution['x']).flatten()

return alphas

# Gerando dados de exemplo

X, y = make_classification(n_samples=100, n_features=2, n_classes=2,

n_redundant=0, n_informative=2, random_state=42)

y = 2 * y - 1 # Convertendo para -1, 1

# Calculando alphas

alphas = svm_dual_manual(X, y, C=1.0)

print("Multiplicadores de Lagrange calculados:")

print(f"Número de vetores suporte: {np.sum(alphas > 1e-5)}")

Casos Não Linearmente Separáveis

Conquanto a formulação anterior assuma separabilidade linear, dados reais frequentemente exigem abordagens mais sofisticadas. Para lidar com sobreposição de classes, introduzimos variáveis de folga (slack variables):

\(\min_{w, b, \xi} \frac{1}{2} \|w\|^2 + C \sum_{i=1}^n \xi_i\)

sujeito a:

\(y_i (w \cdot x_i + b) \geq 1 – \xi_i \quad \text{e} \quad \xi_i \geq 0 \quad \forall i\)

O Parâmetro C e Controle de Complexidade

Embora a variável de folga permita violações da margem, decerto o parâmetro C controla o trade-off entre margem máxima e erro de classificação. Portanto, valores altos de C resultam em margens mais estreitas com menos violações.

from sklearn.svm import SVC
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

# Demonstrando o efeito do parâmetro C
X, y = make_blobs(n_samples=100, centers=2, cluster_std=2.0, random_state=42)

C_values = [0.1, 1, 10, 100]
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

for ax, C in zip(axes.ravel(), C_values):
    svm_model = SVC(kernel='linear', C=C)
    svm_model.fit(X, y)
    
    # Plotando decisão boundary
    ax.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.6)
    
    # Criando grid para decision boundary
    xx, yy = np.meshgrid(np.linspace(X[:, 0].min()-1, X[:, 0].max()+1, 50),
                         np.linspace(X[:, 1].min()-1, X[:, 1].max()+1, 50))
    Z = svm_model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    ax.contour(xx, yy, Z, colors='black', alpha=0.8)
    ax.set_title(f'SVM com C={C}')
    ax.set_xlabel('Feature 1')
    ax.set_ylabel('Feature 2')

plt.tight_layout()
plt.show()

from sklearn.svm import SVC

import matplotlib.pyplot as plt

from sklearn.datasets import make_blobs

# Demonstrando o efeito do parâmetro C

X, y = make_blobs(n_samples=100, centers=2, cluster_std=2.0, random_state=42)

C_values = [0.1, 1, 10, 100]

fig, axes = plt.subplots(2, 2, figsize=(12, 10))

for ax, C in zip(axes.ravel(), C_values):

svm_model = SVC(kernel='linear', C=C)

svm_model.fit(X, y)

# Plotando decisão boundary

ax.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.6)

# Criando grid para decision boundary

xx, yy = np.meshgrid(np.linspace(X[:, 0].min()-1, X[:, 0].max()+1, 50),

np.linspace(X[:, 1].min()-1, X[:, 1].max()+1, 50))

Z = svm_model.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

ax.contour(xx, yy, Z, colors='black', alpha=0.8)

ax.set_title(f'SVM com C={C}')

ax.set_xlabel('Feature 1')

ax.set_ylabel('Feature 2')

plt.tight_layout()

plt.show()

Kernel Trick e Espaços de Características

Atualmente, o kernel trick é uma das contribuições mais importantes dos SVMs. Aliás, esta técnica permite operar em espaços de alta dimensão sem computar explicitamente as coordenadas:

\(\max_{\alpha} \sum_{i=1}^n \alpha_i – \frac{1}{2} \sum_{i=1}^n \sum_{j=1}^n \alpha_i \alpha_j y_i y_j K(x_i, x_j)\)

onde K(x_i, x_j) é a função kernel.

Implementação com Diferentes Kernels

Enquanto o kernel linear é fundamental, igualmente importantes são os kernels não lineares:

from sklearn.svm import SVC
from sklearn.datasets import make_circles
from sklearn.model_selection import cross_val_score

# Comparando diferentes kernels
X, y = make_circles(n_samples=200, noise=0.1, factor=0.3, random_state=42)

kernels = ['linear', 'poly', 'rbf', 'sigmoid']
results = {}

for kernel in kernels:
    if kernel == 'poly':
        svm_model = SVC(kernel=kernel, degree=3)
    else:
        svm_model = SVC(kernel=kernel)
    
    scores = cross_val_score(svm_model, X, y, cv=5, scoring='accuracy')
    results[kernel] = scores.mean()
    print(f"Kernel {kernel}: Acurácia média = {scores.mean():.4f}")

print("\nMelhor kernel:", max(results, key=results.get))

from sklearn.svm import SVC

from sklearn.datasets import make_circles

from sklearn.model_selection import cross_val_score

# Comparando diferentes kernels

X, y = make_circles(n_samples=200, noise=0.1, factor=0.3, random_state=42)

kernels = ['linear', 'poly', 'rbf', 'sigmoid']

results = {}

for kernel in kernels:

if kernel == 'poly':

svm_model = SVC(kernel=kernel, degree=3)

else:

svm_model = SVC(kernel=kernel)

scores = cross_val_score(svm_model, X, y, cv=5, scoring='accuracy')

results[kernel] = scores.mean()

print(f"Kernel {kernel}: Acurácia média = {scores.mean():.4f}")

print("\nMelhor kernel:", max(results, key=results.get))

Vetores Suporte e Decisão

Surpreendentemente, apenas um subconjunto dos pontos de treinamento influencia a decisão final. Estes são os support vectors, que satisfazem:

\(y_i (w \cdot x_i + b) = 1\)

A função de decisão é então:

\(f(x) = \sum_{i \in SV} \alpha_i y_i K(x_i, x) + b\)

Extraindo Vetores Suporte

from sklearn.svm import SVC
import numpy as np

# Extraindo informações dos vetores suporte
X, y = make_classification(n_samples=100, n_features=4, random_state=42)

svm_model = SVC(kernel='linear', C=1.0)
svm_model.fit(X, y)

# Informações dos vetores suporte
support_vectors = svm_model.support_vectors_
support_indices = svm_model.support_
dual_coef = svm_model.dual_coef_

print(f"Número de vetores suporte: {len(support_vectors)}")
print(f"Shape dos coeficientes duais: {dual_coef.shape}")
print(f"Intercept (b): {svm_model.intercept_}")

# Função de decisão para novos pontos
X_new = np.random.randn(5, 4)
decision_function = svm_model.decision_function(X_new)
print(f"Valores da função de decisão: {decision_function}")

from sklearn.svm import SVC

import numpy as np

# Extraindo informações dos vetores suporte

X, y = make_classification(n_samples=100, n_features=4, random_state=42)

svm_model = SVC(kernel='linear', C=1.0)

svm_model.fit(X, y)

# Informações dos vetores suporte

support_vectors = svm_model.support_vectors_

support_indices = svm_model.support_

dual_coef = svm_model.dual_coef_

print(f"Número de vetores suporte: {len(support_vectors)}")

print(f"Shape dos coeficientes duais: {dual_coef.shape}")

print(f"Intercept (b): {svm_model.intercept_}")

# Função de decisão para novos pontos

X_new = np.random.randn(5, 4)

decision_function = svm_model.decision_function(X_new)

print(f"Valores da função de decisão: {decision_function}")

Implementação Numérica e Estabilidade

Contudo, a implementação prática requer cuidados numéricos. Assim, o Scikit-Learn emprega algoritmos especializados:

LIBSVM para problemas de classificação
LIBLINEAR para problemas lineares em grande escala
Otimização de cache para grandes conjuntos de dados

Comparação de Solvers

from sklearn.svm import SVC
import time
from sklearn.datasets import make_classification

# Gerando dataset grande
X_large, y_large = make_classification(n_samples=10000, n_features=20, random_state=42)

# Comparando tempos de treinamento
solvers = ['liblinear', 'saga']  # Para problemas lineares

for solver in solvers:
    start_time = time.time()
    
    svm_model = SVC(kernel='linear', max_iter=1000, random_state=42)
    svm_model.fit(X_large, y_large)
    
    training_time = time.time() - start_time
    print(f"Solver: {solver}, Tempo: {training_time:.2f} segundos")
    print(f"Número de iterações: {svm_model.n_iter_}")

from sklearn.svm import SVC

import time

from sklearn.datasets import make_classification

# Gerando dataset grande

X_large, y_large = make_classification(n_samples=10000, n_features=20, random_state=42)

# Comparando tempos de treinamento

solvers = ['liblinear', 'saga'] # Para problemas lineares

for solver in solvers:

start_time = time.time()

svm_model = SVC(kernel='linear', max_iter=1000, random_state=42)

svm_model.fit(X_large, y_large)

training_time = time.time() - start_time

print(f"Solver: {solver}, Tempo: {training_time:.2f} segundos")

print(f"Número de iterações: {svm_model.n_iter_}")

Extensões e Variações do SVM

Inegavelmente, a formulação básica do SVM inspirou diversas variações. Então, considere estas extensões importantes:

SVR (Support Vector Regression) para problemas de regressão
One-Class SVM para detecção de anomalias
Nu-SVM com controle direto do número de vetores suporte

Exemplo com Support Vector Regression

from sklearn.svm import SVR
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error, r2_score

# Problema de regressão com SVR
X_reg, y_reg = make_regression(n_samples=200, n_features=2, noise=0.1, random_state=42)

svr_model = SVR(kernel='rbf', C=1.0, epsilon=0.1)
svr_model.fit(X_reg, y_reg)

y_pred = svr_model.predict(X_reg)
mse = mean_squared_error(y_reg, y_pred)
r2 = r2_score(y_reg, y_pred)

print(f"Support Vector Regression - MSE: {mse:.4f}, R²: {r2:.4f}")
print(f"Número de vetores suporte: {len(svr_model.support_vectors_)}")

from sklearn.svm import SVR

from sklearn.datasets import make_regression

from sklearn.metrics import mean_squared_error, r2_score

# Problema de regressão com SVR

X_reg, y_reg = make_regression(n_samples=200, n_features=2, noise=0.1, random_state=42)

svr_model = SVR(kernel='rbf', C=1.0, epsilon=0.1)

svr_model.fit(X_reg, y_reg)

y_pred = svr_model.predict(X_reg)

mse = mean_squared_error(y_reg, y_pred)

r2 = r2_score(y_reg, y_pred)

print(f"Support Vector Regression - MSE: {mse:.4f}, R²: {r2:.4f}")

print(f"Número de vetores suporte: {len(svr_model.support_vectors_)}")

Conclusão e Perspectivas Futuras

Enfim, a formulação matemática do SVM representa um marco no machine learning. Inegavelmente, sua base teórica sólida combinada com implementações eficientes explica sua popularidade duradoura.

Afinal, compreender os fundamentos matemáticos permite não apenas usar efetivamente os SVMs, mas também adaptá-los para problemas específicos. Eventualmente, este conhecimento facilita a transição para métodos mais avançados.

Portanto, domine estes conceitos fundamentais. Inclusive para desenvolver intuição sobre quando e como aplicar Support Vector Machines em problemas do mundo real.

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