Régularisation ElasticNet

La régularisation ElasticNet combine les avantages des régularisations L1 (Lasso) et L2 (Ridge) pour construire des modèles robustes, capables à la fois de sélectionner les variables importantes et de réduire le surapprentissage.

📐 Principe de la régularisation ElasticNet

ElasticNet ajoute à la fonction de perte classique une pénalité mixte, qui est une combinaison pondérée de la somme des valeurs absolues (L1) et des carrés (L2) des coefficients :

$J(\theta) = \text{Erreur classique} + \lambda \left( \alpha \sum_{j=1}^{n} |\theta_j| + (1 – \alpha) \sum_{j=1}^{n} \theta_j^2 \right)$

$\lambda$ : hyperparamètre global de régularisation qui contrôle la force de la pénalité.
$\alpha \in [0,1]$ : paramètre qui équilibre la contribution entre L1 (sélection de variables) et L2 (stabilisation).

🧠 Pourquoi utiliser ElasticNet ?

Combine la sélection automatique des variables de Lasso avec la stabilité et la gestion de la multicolinéarité de Ridge.
Particulièrement utile lorsque les variables sont corrélées entre elles.
Permet d’obtenir un compromis flexible entre sparsité et régularisation douce.

Fonctions :

ElasticNet()

La fonction ElasticNet() implémente la régression ElasticNet, une combinaison des régularisations Lasso (L1) et Ridge (L2). ElasticNet est particulièrement utile lorsqu'il y a de nombreuses variables corrélées, car elle combine les avantages de Lasso et Ridge en ajoutant une pénalité L1 (pour la sélection de variables) et une pénalité L2 (pour la réduction de la taille des coefficients). Cela permet au modèle de bénéficier de la régularisation des deux techniques tout en atténuant leurs limites individuelles.

Importation :

from sklearn.linear_model import ElasticNet

Attributs :

Paramètre	Type	Valeur par défaut	Description
alpha	float, optionnel	1.0	Le paramètre de régularisation qui contrôle la force de la pénalité. Plus alpha est grand, plus la régularisation est forte. Il détermine la combinaison de L1 et L2.
l1_ratio	float, optionnel	0.5	Le ratio de la pénalité L1 par rapport à L2. Une valeur de 1.0 signifie une régularisation purement Lasso (L1), une valeur de 0 signifie une régularisation purement Ridge (L2). Une valeur de 0.5 combine L1 et L2 de manière égale.
fit_intercept	bool, optionnel	True	Indique si un terme d'interception (biais) doit être ajusté dans le modèle.
normalize	bool, optionnel	False	Si True, les données d'entrée sont normalisées avant l'ajustement du modèle.
max_iter	int, optionnel	1000	Le nombre maximal d'itérations pour l'optimisation du modèle.
tol	float, optionnel	1e-4	Le critère de tolérance pour l'optimisation. Si la modification entre deux itérations consécutives est inférieure à ce seuil, l'optimisation s'arrête.
selection	str, optionnel	'cyclic'	La méthode d'optimisation utilisée. 'cyclic' met à jour les coefficients à chaque itération, tandis que 'random' sélectionne de manière aléatoire les coefficients à chaque itération.

Exemple de code :

from sklearn.linear_model import ElasticNet
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np

# Génération de données de régression
X, y = make_regression(n_samples=100, n_features=5, noise=0.1, random_state=42)

# Séparation des données en ensemble d'entraînement et test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Création et ajustement du modèle ElasticNet
elastic_net = ElasticNet(alpha=1.0, l1_ratio=0.5)
elastic_net.fit(X_train, y_train)

# Affichage des coefficients du modèle
print("Coefficients du modèle ElasticNet : ", elastic_net.coef_)

# Prédiction sur l'ensemble de test
y_pred = elastic_net.predict(X_test)

# Calcul de l'erreur quadratique moyenne (RMSE)
rmse = np.sqrt(np.mean((y_pred - y_test)**2))
print("Erreur quadratique moyenne (RMSE) : ", rmse)

Explication du code :

Génération des données : Comme pour les autres exemples, nous générons un jeu de données de régression simulées à l'aide de make_regression(). Ce jeu de données inclut des caractéristiques X et une variable cible y.
Séparation des données : À l'aide de train_test_split(), nous divisons les données en un ensemble d'entraînement (80%) et un ensemble de test (20%).
Création du modèle ElasticNet : Le modèle ElasticNet() est créé avec un paramètre de régularisation alpha de 1.0, ce qui signifie une pénalité modérée. Le l1_ratio est réglé à 0.5, ce qui donne une combinaison égale de régularisation L1 (Lasso) et L2 (Ridge).
Ajustement du modèle : Le modèle est ajusté sur les données d'entraînement avec la méthode fit(). ElasticNet cherche à minimiser l'erreur tout en régularisant les coefficients à l'aide de la combinaison L1 et L2.
Affichage des coefficients : Les coefficients du modèle ajusté sont affichés avec elastic_net.coef_. Comme dans la régression Lasso et Ridge, ces coefficients peuvent être plus petits ou égaux à zéro en fonction du degré de régularisation.
Prédiction et évaluation : Le modèle prédit les valeurs pour l'ensemble de test à l'aide de la méthode predict(). Ensuite, nous calculons l'erreur quadratique moyenne (RMSE) pour évaluer la qualité des prédictions.

Sortie attendue :

Les coefficients du modèle ElasticNet, qui seront régularisés par une combinaison des pénalités L1 et L2.
L'erreur quadratique moyenne (RMSE), indiquant la précision du modèle sur l'ensemble de test.

Applications :

Modèle hybride de régression : ElasticNet est particulièrement utile lorsque les données ont de nombreuses variables corrélées. Il combine les avantages de Lasso et Ridge en appliquant une régularisation à la fois L1 et L2.
Réduction de la multicolinéarité : ElasticNet est très performant lorsqu'il y a une forte multicolinéarité entre les variables d'entrée.
Sélection de variables avec régularisation : Grâce à la régularisation L1, ElasticNet peut aussi effectuer une sélection de variables tout en réduisant la complexité du modèle grâce à la régularisation L2.