Régularisation

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.

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.

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.