APPRENTISSAGE AUTOMATIQUE : RÉGRESSION PÉNALISÉE (RIDGE &
LASSO)
===========================================================================
1. CHARGEMENT DE LA BIBLIOTHÈQUE
‘glmnet’ est le standard en R pour les modèles linéaires
pénalisés.
if(!require(glmnet)) install.packages("glmnet")
## Le chargement a nécessité le package : glmnet
## Le chargement a nécessité le package : Matrix
## Loaded glmnet 4.1-10
library(glmnet)
2. GÉNÉRATION DE DONNÉES DE TEST
Créons un scénario où nous avons 10 variables, mais seules 3 sont
utiles.
set.seed(42)
n <- 100 # Nombre d'observations (lignes)
p <- 10 # Nombre de variables (colonnes)
# Création d'une matrice de données aléatoires
X <- matrix(rnorm(n * p), n, p)
colnames(X) <- paste0("Var_", 1:p)
# Création d'une variable cible (Y) basée sur Var_1, Var_2 et Var_3 uniquement
# Les autres variables (4 à 10) sont du "bruit" inutile.
Y <- 5 * X[,1] - 3 * X[,2] + 2 * X[,3] + rnorm(n, sd = 0.5)
—————————————————————————
3. LA RÉGRESSION RIDGE (L2) - alpha = 0
—————————————————————————
La fonction ‘cv.glmnet’ effectue une validation croisée
automatique
pour tester différentes valeurs de Lambda (l’amende).
ridge_cv <- cv.glmnet(X, Y, alpha = 0)
# Affichage du meilleur Lambda (celui qui minimise l'erreur)
print(paste("Meilleur Lambda pour Ridge :", ridge_cv$lambda.min))
## [1] "Meilleur Lambda pour Ridge : 0.482166590332399"
# Extraction des coefficients finaux
# On remarque que tous les coefficients sont petits, mais AUCUN n'est nul.
coef_ridge <- coef(ridge_cv, s = "lambda.min")
print("--- Coefficients RIDGE ---")
## [1] "--- Coefficients RIDGE ---"
print(coef_ridge)
## 11 x 1 sparse Matrix of class "dgCMatrix"
## lambda.min
## (Intercept) -0.01424990
## Var_1 4.57743580
## Var_2 -2.71983644
## Var_3 1.71270917
## Var_4 0.04549088
## Var_5 0.05466748
## Var_6 0.11068945
## Var_7 -0.02760752
## Var_8 0.10243312
## Var_9 -0.04439875
## Var_10 0.08662842
############################################################################
# FICHIER : ANALYSE DES RÉSULTATS DE RÉGRESSION PÉNALISÉE (RIDGE)
# CONCEPT : COMPRENDRE L'AFFICHAGE DES COEFFICIENTS DANS R
############################################################################
# --- RAPPEL DU RÉSULTAT OBTENU (RIDGE) ---
# print(coef_ridge)
# 11 x 1 sparse Matrix of class "dgCMatrix"
# lambda.min
# (Intercept) -0.01424990 <-- L'ordonnée à l'origine (le biais)
# Var_1 4.57743580 <-- Variable forte (Poids élevé)
# Var_2 -2.71983644 <-- Variable forte (Poids négatif élevé)
# Var_3 1.71270917 <-- Variable moyenne
# Var_4 0.04549088 <-- Bruit (Réduit par Ridge)
# Var_5 0.05466748 <-- Bruit (Réduit par Ridge)
# ... [etc] ...
# ==========================================================================
# INTERPRÉTATION "TERRE À TERRE" DES CHIFFRES CI-DESSUS
# ==========================================================================
# 1. LA MATRICE SPARSE (dgCMatrix)
# R utilise ce format pour économiser de la mémoire. Dans un modèle
# pénalisé, beaucoup de chiffres peuvent devenir très petits ou nuls.
# Le format "sparse" (creux) ne stocke que les valeurs importantes.
# 2. LES VARIABLES DOMINANTES (Var_1, Var_2, Var_3)
# Ces variables ont des coefficients éloignés de zéro.
# Ridge a détecté qu'elles ont un impact réel sur la prédiction.
# Par exemple, si Var_1 augmente de 1 unité, Y augmente de ~4.57.
# 3. L'EFFET DE LA PÉNALITÉ L2 (SHRINKAGE)
# Regardez Var_4 (0.045) ou Var_7 (-0.027).
# Dans une régression classique, ces coefficients auraient pu être
# beaucoup plus grands à cause du bruit aléatoire.
# Ridge les a "écrasés" (shrinkage) pour qu'ils ne polluent pas le modèle.
# 4. POURQUOI CE N'EST PAS ZÉRO ?
# C'est la signature de Ridge : il réduit la taille des coefficients
# mais garde TOUTES les variables dans l'équation.
# Contrairement au Lasso, il ne fait pas de sélection radicale.
# ==========================================================================
# CODE R POUR COMPARER AVEC LE LASSO (SÉLECTION RADICALE)
# ==========================================================================
# Si vous exécutiez le Lasso sur les mêmes données :
# lasso_cv <- cv.glmnet(X, Y, alpha = 1)
# coef(lasso_cv, s = "lambda.min")
# VOUS VERRIEZ CECI DANS VOTRE CONSOLE :
# Var_1 4.423...
# Var_2 -2.601...
# Var_3 1.598...
# Var_4 . <-- Le point "." signifie EXACTEMENT ZÉRO
# Var_5 . <-- Le Lasso a supprimé cette variable
# Var_6 . <-- Le Lasso considère que c'est du bruit pur
# ==========================================================================
# CONCLUSION : QUAND UTILISER QUOI ?
# ==========================================================================
# - Utilisez RIDGE (votre résultat) si vous pensez que toutes vos variables
# ont une petite influence et que vous voulez stabiliser le modèle.
# - Utilisez LASSO si vous pensez que sur vos 10 variables, seulement 2 ou 3
# sont réellement importantes (modèle plus simple et lisible).
############################################################################
—————————————————————————
4. LA RÉGRESSION LASSO (L1) - alpha = 1
—————————————————————————
Le Lasso va tenter de supprimer les variables inutiles (Var_4 à
Var_10).
lasso_cv <- cv.glmnet(X, Y, alpha = 1)
# Affichage du meilleur Lambda
print(paste("Meilleur Lambda pour Lasso :", lasso_cv$lambda.min))
## [1] "Meilleur Lambda pour Lasso : 0.046025137465569"
# Extraction des coefficients finaux
# Notez les points "." : ce sont les variables que le Lasso a mises à ZÉRO.
coef_lasso <- coef(lasso_cv, s = "lambda.min")
print("--- Coefficients LASSO ---")
## [1] "--- Coefficients LASSO ---"
print(coef_lasso)
## 11 x 1 sparse Matrix of class "dgCMatrix"
## lambda.min
## (Intercept) -0.06175398
## Var_1 4.96111497
## Var_2 -2.97002272
## Var_3 1.90702793
## Var_4 .
## Var_5 .
## Var_6 0.03999008
## Var_7 .
## Var_8 .
## Var_9 .
## Var_10 .
############################################################################
# ANALYSE DES RÉSULTATS : RÉGRESSION LASSO (SÉLECTION DE VARIABLES)
############################################################################
# --- RÉSULTAT OBTENU (LASSO) ---
# print(coef_lasso)
# (Intercept) -0.06175398
# Var_1 4.96111497 <-- Gardée (Très importante)
# Var_2 -2.97002272 <-- Gardée (Très importante)
# Var_3 1.90702793 <-- Gardée (Importante)
# Var_4 . <-- ÉLIMINÉE (Zéro)
# Var_5 . <-- ÉLIMINÉE (Zéro)
# Var_6 0.03999008 <-- Gardée (Très faible influence)
# Var_7 . <-- ÉLIMINÉE (Zéro)
# Var_8 . <-- ÉLIMINÉE (Zéro)
# Var_9 . <-- ÉLIMINÉE (Zéro)
# Var_10 . <-- ÉLIMINÉE (Zéro)
# ==========================================================================
# CE QUE NOUS DISENT CES RÉSULTATS
# ==========================================================================
# 1. LE SYMBOLE DU POINT (.)
# C'est la magie du Lasso (Pénalité L1). Contrairement au Ridge qui
# garde tout, le Lasso a "éteint" les variables Var_4, 5, 7, 8, 9 et 10.
# Mathématiquement, le poids de ces variables est exactement égal à 0.
# 2. LA SÉLECTION AUTOMATIQUE
# Le Lasso a agi comme un filtre de qualité. Il a estimé que Var_1, Var_2
# et Var_3 expliquent l'essentiel de votre problème.
# En supprimant le reste, il simplifie le modèle et réduit le risque
# d'interpréter du "bruit" comme une information réelle.
# 3. LE CAS DE VAR_6 (0.0399)
# Pourquoi n'est-elle pas à zéro ? Parce que dans vos données, il existe
# probablement une légère corrélation accidentelle entre Var_6 et Y.
# Le Lasso a jugé qu'elle apportait un tout petit peu d'information,
# mais avec un Lambda plus fort, elle aurait fini par disparaître aussi.
# 4. COMPARAISON AVEC RIDGE
# - Ridge (précédent) : Un modèle avec 10 variables (complexe).
# - Lasso (actuel) : Un modèle avec 4 variables (simple et efficace).
# ==========================================================================
# COMMENTAIRE TECHNIQUE : L'ÉQUATION FINALE
# ==========================================================================
# Votre prédiction Y se résume désormais à :
# Y = -0.06 + (4.96 * Var_1) - (2.97 * Var_2) + (1.90 * Var_3) + (0.04 * Var_6)
# Toutes les autres variables sont ignorées car multipliées par zéro.
############################################################################
—————————————————————————
5. VISUALISATION DES RÉSULTATS
—————————————————————————
Ces graphiques montrent l’évolution de l’erreur en fonction de
Lambda.
Les lignes pointillées verticales indiquent le Lambda optimal.
par(mfrow=c(1,2)) # Divise la fenêtre graphique en 2
plot(ridge_cv, main = "Évolution de l'erreur (Ridge)")
plot(lasso_cv, main = "Évolution de l'erreur (Lasso)")
—————————————————————————
6. PRÉDICTION SUR DE NOUVELLES DONNÉES
—————————————————————————
Exemple : Prédire Y pour une nouvelle observation imaginaire
nouvelle_donnee <- matrix(rnorm(1 * p), 1, p)
prediction <- predict(lasso_cv, newx = nouvelle_donnee, s = "lambda.min")
print(paste("Prédiction Lasso :", prediction))
## [1] "Prédiction Lasso : -7.02314788977349"
===========================================================================
APPRENTISSAGE AUTOMATIQUE : MODÈLE ELASTIC NET (ALPHA = 0.5)
===========================================================================
1. CHARGEMENT DE LA BIBLIOTHÈQUE
‘glmnet’ gère Ridge, Lasso et Elastic Net via le paramètre
‘alpha’
library(glmnet)
# 2. GÉNÉRATION DES DONNÉES (RAPPEL DE L'EXEMPLE PREMIER)
set.seed(42) # Fixe le hasard pour avoir les mêmes résultats à chaque fois
n <- 100 # 100 individus/lignes
p <- 10 # 10 variables explicatives/colonnes
# Création d'une matrice X de nombres aléatoires (Loi Normale)
X <- matrix(rnorm(n * p), n, p)
colnames(X) <- paste0("Var_", 1:p)
# Création de la cible Y (On sait que Var_1, 2 et 3 sont les seules vraies causes)
# Les variables 4 à 10 sont du "bruit" (inutiles)
Y <- 5 * X[,1] - 3 * X[,2] + 2 * X[,3] + rnorm(n, sd = 0.5)
# 3. ENTRAÎNEMENT DU MODÈLE ELASTIC NET
# alpha = 0.5 : C'est le mélange (50% Ridge / 50% Lasso)
# nfolds = 10 : Divise les données en 10 pour tester la précision (Validation Croisée)
en_cv <- cv.glmnet(X, Y, alpha = 0.5, nfolds = 10)
# 4. EXTRACTION ET AFFICHAGE DU MEILLEUR LAMBDA
# 'lambda.min' est la valeur de pénalité qui donne l'erreur la plus faible
best_lambda <- en_cv$lambda.min
print(paste("La pénalité optimale (Lambda) est :", best_lambda))
## [1] "La pénalité optimale (Lambda) est : 0.0578102553868516"
# 5. AFFICHAGE DES COEFFICIENTS FINAUX
# On demande les coefficients pour le meilleur lambda trouvé précédemment
coef_final <- coef(en_cv, s = "lambda.min")
print("--- RÉSULTATS DES COEFFICIENTS (BÉTA) ---")
## [1] "--- RÉSULTATS DES COEFFICIENTS (BÉTA) ---"
print(coef_final)
## 11 x 1 sparse Matrix of class "dgCMatrix"
## lambda.min
## (Intercept) -0.0610132001
## Var_1 4.9514717750
## Var_2 -2.9687112371
## Var_3 1.9096961105
## Var_4 0.0097670485
## Var_5 .
## Var_6 0.0569869665
## Var_7 .
## Var_8 0.0110009124
## Var_9 -0.0008180291
## Var_10 0.0150339075
# INTERPRÉTATION DU RÉSULTAT :
# - Les variables importantes (1, 2, 3) ont des chiffres élevés.
# - Les variables inutiles (4 à 10) affichent un point '.' (Zéro grâce au Lasso).
# - Les poids restants sont stabilisés (Grâce au Ridge).
# 6. GRAPHIQUE DE PERFORMANCE
# Ce graphique montre l'erreur de prédiction qui descend puis remonte.
plot(en_cv, main = "Performance de l'Elastic Net (Erreur vs Lambda)")
