Régularisation L1 (Lasso)

En apprentissage automatique, pour lutter contre le surapprentissage et améliorer la généralisation d’un modèle, la régularisation L1, appelée aussi Lasso (Least Absolute Shrinkage and Selection Operator), est une technique très utilisée.

Principe de la régularisation L1

La régularisation L1 ajoute à la fonction de perte classique une pénalité proportionnelle à la somme des valeurs absolues des coefficients du modèle :

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

$\theta_j$ : coefficient du modèle pour la variable $j$
$\lambda$ (lambda) : hyperparamètre qui contrôle la force de la pénalité

Cette pénalité pousse certains coefficients exactement à zéro, ce qui réalise une sélection automatique des variables.

Pourquoi utiliser Lasso ?

Réduction du surapprentissage par simplification du modèle.
Sélection de variables en éliminant automatiquement les moins importantes.
Favorise des modèles sparse (avec peu de variables non nulles), facilitant l’interprétation.

Fonctions :

Lasso()

La fonction Lasso() implémente la régression Lasso (Least Absolute Shrinkage and Selection Operator), qui est une technique de régularisation utilisée dans les modèles de régression linéaire. Lasso ajoute une pénalité (ou régularisation) L1 à la fonction de coût de la régression linéaire. Cette pénalité pousse certains coefficients de régression à être exactement nuls, ce qui permet de réaliser une sélection de variables et de réduire ainsi la complexité du modèle. Cela est particulièrement utile pour éviter le sur-apprentissage (overfitting) et pour identifier les variables les plus importantes dans un modèle. Lasso peut être considéré comme une méthode de régularisation qui effectue à la fois de la sélection de variables et de la régression.

Importation :

from sklearn.linear_model import Lasso

Attributs :

Paramètre	Type	Valeur par défaut	Description
alpha	float, optionnel	1.0	La constante de régularisation qui contrôle la force de la pénalité L1. Plus alpha est grand, plus la régularisation est forte, ce qui réduit la taille des coefficients.
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. Cela est recommandé si les variables d'entrée sont sur des échelles différentes.
max_iter	int, optionnel	1000	Le nombre maximal d'itérations pour l'optimisation.
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 utilisée pour la sélection des caractéristiques. Peut être 'cyclic' (par défaut) ou 'random'.

Exemple de code :

from sklearn.linear_model import Lasso
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 Lasso
lasso = Lasso(alpha=0.1)
lasso.fit(X_train, y_train)

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

# Prédiction sur l'ensemble de test
y_pred = lasso.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 de données : Nous utilisons make_regression() pour générer des données de régression simulées. X est une matrice de caractéristiques (features) de taille (100, 5), et y est le vecteur de la variable cible de taille (100,).
Séparation des données : Nous utilisons train_test_split() pour diviser les données en un ensemble d'entraînement (X_train, y_train) et un ensemble de test (X_test, y_test), avec 20% des données utilisées pour le test.
Création du modèle Lasso : Un modèle Lasso est créé en utilisant la classe Lasso() avec une valeur de alpha de 0.1. L'alpha détermine la force de la régularisation L1. Une valeur plus élevée de alpha impose une régularisation plus forte, ce qui peut entraîner une réduction des coefficients du modèle.
Ajustement du modèle : Le modèle Lasso est ajusté aux données d'entraînement avec la méthode fit(). Cette méthode ajuste les coefficients du modèle pour minimiser l'erreur tout en imposant la régularisation L1.
Affichage des coefficients : Après l'ajustement, nous affichons les coefficients du modèle Lasso à l'aide de lasso.coef_. Certains coefficients seront exactement nuls en raison de la régularisation L1, ce qui signifie que les variables correspondantes ont été sélectionnées comme moins importantes.
Prédiction et évaluation : Nous utilisons lasso.predict() pour prédire les valeurs cibles sur les données de test et calculer l'erreur quadratique moyenne (RMSE) pour évaluer la performance du modèle.

Sortie attendue :

Les coefficients du modèle Lasso, qui peuvent être partiellement ou totalement nuls pour certaines variables.
L'erreur quadratique moyenne (RMSE), qui mesure la qualité des prédictions du modèle.

Applications :

Sélection de variables : Lasso est particulièrement utile pour les modèles avec de nombreuses variables, car il effectue une sélection de variables en poussant les coefficients de certaines caractéristiques à zéro.
Régression avec régularisation : Lasso est utilisé pour éviter le sur-apprentissage en ajoutant une régularisation L1 qui contraint la taille des coefficients.
Modèles simples et interprétables : Comme Lasso effectue une sélection de variables, il peut être utilisé pour construire des modèles simples et interprétables, en mettant l'accent sur les variables les plus influentes.