Régularisation L2 (Ridge)

En apprentissage automatique, lorsque votre modèle est trop complexe ou que vous avez peu de données, il risque de faire du surapprentissage (overfitting), c’est-à-dire apprendre le bruit plutôt que les tendances réelles.

La régularisation L2, aussi appelée Ridge Regression, est une technique courante pour réduire ce risque en ajoutant une pénalité aux coefficients du modèle afin de les contraindre à rester petits.

Principe de la régularisation L2

La régularisation L2 ajoute à la fonction de perte classique (exemple : erreur quadratique moyenne) un terme proportionnel à la somme des carrés des coefficients :

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

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

En augmentant $\lambda$ , on force les coefficients à être plus petits, ce qui rend le modèle plus simple et moins sujet au surapprentissage.

Pourquoi utiliser Ridge ?

Prévenir le surapprentissage en limitant la complexité du modèle.
Gérer les problèmes de multicolinéarité (variables fortement corrélées).
Obtenir un modèle plus stable et généralisant mieux sur de nouvelles données.

Fonctions :

Ridge()

La fonction Ridge() implémente la régression Ridge, qui est une méthode de régularisation utilisée dans les modèles de régression linéaire. Contrairement à la régression Lasso, qui utilise une pénalité L1, la régression Ridge ajoute une pénalité L2 (norme euclidienne) aux coefficients du modèle. Cela réduit la taille des coefficients tout en permettant à tous les coefficients d'être non nuls. Ridge est particulièrement utile pour les modèles de régression lorsque les données sont multicolinéaires ou lorsque le modèle souffre de sur-apprentissage.

Importation :

from sklearn.linear_model import Ridge

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é L2. 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	None	Le nombre maximal d'itérations pour l'optimisation. Si None, l'optimisation continue jusqu'à la convergence.
tol	float, optionnel	1e-3	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.
solver	str, optionnel	'auto'	Le solver à utiliser pour résoudre l'optimisation. Peut être 'auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', etc.

Exemple de code :

from sklearn.linear_model import Ridge
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 Ridge
ridge = Ridge(alpha=1.0)
ridge.fit(X_train, y_train)

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

# Prédiction sur l'ensemble de test
y_pred = ridge.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 représente les caractéristiques (features) du modèle, et y est la variable cible.
Séparation des données : Avec train_test_split(), nous divisons les données en un ensemble d'entraînement et un ensemble de test. 80% des données sont utilisées pour l'entraînement, et 20% pour les tests.
Création du modèle Ridge : Le modèle Ridge est créé avec une valeur de régularisation alpha de 1.0. L'alpha contrôle la force de la régularisation L2, et une valeur plus grande de alpha augmentera la pénalité sur les coefficients, les rendant plus petits.
Ajustement du modèle : Le modèle est ajusté aux données d'entraînement à l'aide de la méthode fit(), où il cherche à minimiser l'erreur tout en appliquant la régularisation L2 sur les coefficients.
Affichage des coefficients : Nous affichons les coefficients du modèle avec ridge.coef_. Comme avec Lasso, la régularisation réduit les coefficients, mais contrairement à Lasso, tous les coefficients resteront non nuls, mais plus petits.
Prédiction et évaluation : Le modèle prédit les valeurs cibles pour l'ensemble de test avec 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 Ridge, qui seront réduits en taille en raison de la régularisation.
L'erreur quadratique moyenne (RMSE), qui mesure la précision du modèle sur l'ensemble de test.

Applications :

Régression avec régularisation : Ridge est souvent utilisé dans les cas où les données présentent une multicolinéarité ou lorsque le modèle pourrait souffrir de sur-apprentissage.
Amélioration des modèles de régression linéaire : Ridge peut être appliqué lorsqu'un modèle de régression linéaire simple présente des problèmes de sur-apprentissage, surtout lorsque les variables d'entrée sont fortement corrélées.
Stabilisation de la solution : Ridge est utile dans des scénarios où un modèle linéaire peut avoir des coefficients instables ou très sensibles aux petites variations des données.