TP : Méthodes Linéaires pour la Régression

avec Modèles Linéaire et Non Linéaire

25 avril 2025

Abstract
Ce TP explore des méthodes linéaires pour la régression sur un ensemble de données
synthétiques avec 4 variables d’entrée (x1 , x2 , x3 , x4 ) et une sortie (y), pour 300 échantillons.
Deux modèles sont étudiés : un modèle linéaire (y = β1 x1 + β2 x2 + β3 x3 + β4 x4 + β0 ) et un
modèle non linéaire (y = β1 x1 + β2 x2 + β3 x23 + β4 x4 + β0 ). Les méthodes incluent OLS avec
perte L2 , régularisation Ridge, Lasso, et Elastic Net, optimisées via Gradient Descent (GD)
manuel. Les fonctions objectifs et gradients sont exprimés en forme matricielle. Le TP
comprend la génération et la visualisation des données, l’optimisation des hyperparamètres,
et une comparaison des performances (MSE, R2 , erreur relative, robustesse, efficacité). Une
question bonus propose d’implémenter Ridge avec SGD et Adam. Un appendice détaille
GD avec un exemple.

Introduction
Ce TP enseigne l’application des méthodes linéaires pour la régression sur un dataset synthétique
de 300 échantillons avec 4 entrées et une sortie, incluant des corrélations et un terme non linéaire.
Les sections sont structurées comme des leçons, avec explications théoriques, tâches pratiques, et
questions. Toutes les optimisations utilisent Gradient Descent (GD) implémenté manuellement,
avec une question bonus pour SGD et Adam. Un appendice fournit des instructions pour GD.

Problème Principal

Problème 1 (Contexte et Objectifs). Ce TP analyse des méthodes linéaires pour la

régression sur un ensemble de données synthétiques (m = 300, n = 4 entrées, 1 sortie).
Les méthodes incluent OLS avec perte L2 , régularisation Ridge, Lasso, et Elastic Net,
optimisées via Gradient Descent (GD). Deux modèles sont à estimer :
• Modèle linéaire : yi = β1 xi1 + β2 xi2 + β3 xi3 + β4 xi4 + β0 .

• Modèle non linéaire : yi = β1 xi1 + β2 xi2 + β3 x2i3 + β4 xi4 + β0 .

L’objectif est d’évaluer la capacité des méthodes linéaires à approximer ces modèles, en
tenant compte des corrélations et du bruit.
Objectifs :
1. Générer un ensemble de données synthétiques avec 4 entrées et 1 sortie, incluant des
corrélations et un terme non linéaire.

2. Visualiser les données pour comprendre leur distribution et leurs relations.

3. Implémenter OLS, Ridge, Lasso, et Elastic Net avec perte L2 , en utilisant GD.

1
 4. Optimiser les hyperparamètres (λ, λ1 , λ2 , η, ϵ) via une recherche par grille.

5. Répondre à des questions mathématiques (gradients, convexité, robustesse).

6. Comparer les méthodes sur MSE, R2 , erreur relative, robustesse, et efficacité, avec
une question bonus pour SGD et Adam.

Spécifications des données :

• Taille : m = 300, n = 4, 1 sortie.

• Caractéristiques : X ∈ R300×4 , où xi1 , xi3 , xi4 ∼ N (0, 1), avec :

xi2 = 0.7xi1 + 0.3ϵi2 , ϵi2 ∼ N (0, 1).

• Cible : yi ∈ R, définie selon le modèle non linéaire :

yi = 3xi1 + 2xi2 + 0.5x2i3 + ϵi , ϵi ∼ N (0, 0.52 ).

• Prétraitement : Standardiser X ← (X − µ)/σ.

• Division : 80% entraı̂nement (240 échantillons), 20% test (60 échantillons).

• Bruit : Ajouter δ ∼ N (0, σδ2 ), σδ ∈ {0.01, 0.05, 0.1}.

Métriques :
m
(yi − ŷi )2
P
1 X ∥y − ŷ∥2
MSE = (yi − ŷi )2 , R2 = 1 − Pi 2
, Erreur Relative = .
m i=1 i (yi − ȳ) ∥y∥2

Génération et Visualisation des Données

Génération et Visualisation des Données
Concepts Clés
La génération des données crée un ensemble synthétique avec 300 échantillons et 4 entrées,
reflétant une corrélation entre x1 et x2 , un terme non linéaire 0.5x2i3 , et du bruit. La
visualisation explore la structure des données pour guider l’application des modèles.

Tâches à Accomplir
1. Générer les données :

• Créer X ∈ R300×4 avec xi1 , xi3 , xi4 ∼ N (0, 1).

• Générer xi2 = 0.7xi1 + 0.3ϵi2 , ϵi2 ∼ N (0, 1).
• Standardiser X.
• Générer la cible yi = 3xi1 + 2xi2 + 0.5x2i3 + ϵi , ϵi ∼ N (0, 0.52 ).
• Ajouter du bruit δ ∼ N (0, σδ2 ) pour σδ ∈ {0.01, 0.05, 0.1}.
• Diviser en 80% entraı̂nement (240 échantillons), 20% test (60 échantillons).

2
 2. Visualiser les données :

• Créer des histogrammes pour xi1 , xi2 , xi3 , xi4 , y.

• Tracer un nuage de points pour xi3 vs yi , avec la courbe 0.5x2i3 .
• Afficher la matrice de corrélation pour xi1 , xi2 , xi3 , xi4 .

Programme Python
1 import numpy as np
2 import matplotlib . pyplot as plt
3 import seaborn as sns
4 from sklearn . preprocessing import StandardScaler
5 from sklearn . model_selection import train_test_split
6

7 # Param tres
8 m = 300 # Nombre d ’ chantillons
9 n = 4 # Nombre de c a r a c t r i s t i q u e s
10 sigma_epsilon = 0.5
11 sigma_delt a_ va lu es = [0.01 , 0.05 , 0.1]
12

13 # G n r a t i o n des d o n n e s
14 np . random . seed (42)
15 X = np . zeros (( m , n ) )
16 X [: , 0] = np . random . normal (0 , 1 , m ) # x_1
17 X [: , 2] = np . random . normal (0 , 1 , m ) # x_3
18 X [: , 3] = np . random . normal (0 , 1 , m ) # x_4
19 X [: , 1] = 0.7 * X [: , 0] + 0.3 * np . random . normal (0 , 1 , m ) # x_2
20

21 # Standardisation
22 scaler = StandardScaler ()
23 X = scaler . fit_transform ( X )
24

25 # G n r a t i o n de la cible
26 y = 3 * X [: , 0] + 2 * X [: , 1] + 0.5 * X [: , 2]**2 + np . random .
normal (0 , sigma_epsilon , m )
27

28 # Ajout du bruit
29 sigma_delta = 0.05 # Exemple avec un sigma_delta
30 y += np . random . normal (0 , sigma_delta , m )
31

32 # Division des d o n n e s (80% train , 20% test )

33 X_train , X_test , y_train , y_test = train_test_split (X , y ,
test_size =0.2 , random_state =42)
34

35 # Visualisation
36 # 1. Histogrammes
37 plt . figure ( figsize =(15 , 10) )
38 for i in range ( n ) :
39 plt . subplot (2 , 3 , i +1)
40 plt . hist ( X [: , i ] , bins =30 , density = True , alpha =0.7)
41 plt . title ( f ’ Distribution de $x_ { i +1} $ ’)

3
42 plt . subplot (2 , 3 , 5)
43 plt . hist (y , bins =30 , density = True , alpha =0.7)
44 plt . title ( ’ Distribution de $y$ ’)
45 plt . tight_layout ()
46 plt . savefig ( ’ histograms . png ’)
47 plt . close ()
48

49 # 2. Nuage de points x_3 vs y

50 plt . figure ( figsize =(8 , 6) )
51 plt . scatter ( X [: , 2] , y , s =50 , alpha =0.5 , label = ’ D o n n e s ’)
52 x3_range = np . linspace ( min ( X [: , 2]) , max ( X [: , 2]) , 100)
53 plt . plot ( x3_range , 0.5 * x3_range **2 , ’r - ’ , label = ’ $0 .5 x_3 ^2 $ ’)
54 plt . xlabel ( ’ $x_3$ ’)
55 plt . ylabel ( ’ $y$ ’)
56 plt . title ( ’ Relation entre $x_3$ et $y$ ’)
57 plt . legend ()
58 plt . grid ( True )
59 plt . savefig ( ’ scatter_x3_y . png ’)
60 plt . close ()
61

62 # 3. Matrice de c o r r l a t i o n
63 corr_matrix = np . corrcoef ( X . T )
64 plt . figure ( figsize =(6 , 5) )
65 sns . heatmap ( corr_matrix , annot = True , cmap = ’ coolwarm ’ , xticklabels
=[ ’ $x_1$ ’ , ’ $x_2$ ’ , ’ $x_3$ ’ , ’ $x_4$ ’] , yticklabels =[ ’ $x_1$ ’ , ’
$x_2$ ’ , ’ $x_3$ ’ , ’ $x_4$ ’ ])
66 plt . title ( ’ Matrice de c o r r l a t i o n ’)
67 plt . savefig ( ’ co rr el at ion _m at ri x . png ’)
68 plt . close ()

Explications du Code
• Génération : Crée X ∈ R300×4 avec corrélation entre x1 et x2 . La cible y inclut
0.5x2i3 . La standardisation utilise StandardScaler. Le bruit δ est ajouté.

• Division : 240 échantillons pour l’entraı̂nement, 60 pour le test.

• Visualisation :

– Histogrammes : Montrent la distribution des 4 entrées et de y.

– Nuage de points : Illustre la relation quadratique x3 vs y.
– Matrice de corrélation : Montre la corrélation entre x1 , x2 , x3 , x4 .

• Sortie : Figures sauvegardées (histograms.png, scatterx 3y .png,

Approximation pour les Pertes L1 (Lasso et Elastic Net)

Pour Lasso et Elastic Net, une approximation lisse est utilisée pour la pénalité L1 dans GD :
4 q
X
∥β̃∥1 ≈ βj2 + ϵ, ϵ = 10−8 .
j=0

4
Testez ϵ ∈ {10−6 , 10−8 , 10−10 } dans la recherche par grille.

Partie 1 : OLS avec Perte L2

Méthode
Concepts Clés
La régression OLS avec perte L2 minimise la somme des erreurs quadratiques sans
régularisation. GD est implémenté manuellement, avec des formulations matricielles pour
la fonction objectif et le gradient.

Formulation Mathématique
• Modèle : ŷ = X̃β̃, où X̃ ∈ Rm×5 (avec colonne de 1), β̃ = [β0 , β1 , β2 , β3 , β4 ]T ∈ R5 .

• Objectif : Minimiser :
1 2 1
J(β̃) = y − X̃β̃ = (y − X̃β̃)T (y − X̃β̃).
m 2 m

• Gradient :
2 T
∇J(β̃) = X̃ (X̃β̃ − y).
m

Tâches à Accomplir
1. Préparer les données :

• Créer X̃train , X̃test en ajoutant une colonne de 1 à Xtrain , Xtest .

2. Implémenter GD :

• Initialiser β̃ ∈ R5 à zéro.
• Calculer ∇J et mettre à jour β̃ ← β̃ − η∇J.
• Itérer jusqu’à convergence (par exemple, 1000 itérations).

3. Recherche par grille :

• Tester η ∈ {10−4 , 10−3 , 10−2 }.

• Calculer MSE, R2 , et l’erreur relative sur X̃test .

4. Analyser les résultats :

• Visualiser les coefficients βj .

• Comparer les performances pour différents η.

5
 Questions
Questions Mathématiques
1. Dérivez le gradient de J en forme matricielle. Montrez que la fonc-
tion objectif est convexe.

2. Expliquez pourquoi OLS L2 est sensible aux outliers.

Questions Pratiques
1. Analysez l’impact de η sur la convergence.

2. Évaluez les coefficients estimés par rapport aux vrais (β1 = 3, β2 =

2, β3 = 0.5, β4 = 0).

Partie 2 : OLS avec Régularisation Ridge

Méthode
Concepts Clés
La régression Ridge ajoute une pénalité L2 sur tous les coefficients, normalisée par 1/m,
pour gérer la multicolinéarité (par exemple, entre x1 et x2 ). GD est utilisé avec une
formulation matricielle.

Formulation Mathématique
• Objectif : Minimiser :
1 2 λ 2
J(β̃) = y − X̃β̃ + β̃ .
m 2 m 2

• Gradient :
2 T 2λ
∇J(β̃) = X̃ (X̃β̃ − y) + β̃.
m m

Tâches à Accomplir
1. Préparer les données :

• Utiliser X̃train , X̃test .

2. Implémenter GD :

• Initialiser β̃ à zéro.
• Calculer ∇J et mettre à jour β̃.
• Itérer jusqu’à convergence.

3. Recherche par grille :

• Tester λ ∈ {10−6 , 10−4 , 10−2 }, η ∈ {10−4 , 10−3 , 10−2 }.

6
 • Calculer MSE, R2 , et l’erreur relative.

4. Analyser les résultats :

• Comparer les performances pour différents λ.

• Visualiser les coefficients βj .

Questions
Questions Mathématiques
1. Dérivez le gradient en forme matricielle. Montrez la convexité.

2. Expliquez pourquoi λ/m normalise la régularisation.

3. Analysez l’effet de λ sur les coefficients.

Questions Pratiques

1. Analysez l’impact de λ sur MSE et R2 .

2. Discutez de la régularisation de β0 .

Partie 3 : OLS avec Régularisation Lasso

Méthode
Concepts Clés
Lasso utilise une pénalité L1 pour encourager la parcimonie, avec une perte L2 . GD utilise
une approximation lisse pour la pénalité L1 .

Formulation Mathématique
• Objectif : Minimiser :
4
1 2 λ Xq 2
J(β̃) ≈ y − X̃β̃ + βj + ϵ.
m 2 m j=0

• Gradient :
√β02
 
β +ϵ
 β01 
√ 2 
 β1 +ϵ 
2 T λ  β2 
√ 2  .
∇J(β̃) ≈ X̃ (X̃β̃ − y) +  β2 +ϵ 
m m  √ β3 
 2 
 β3 +ϵ 
√β42
β4 +ϵ

Tâches à Accomplir
1. Préparer les données :

7
 • Utiliser X̃train , X̃test .

2. Implémenter GD :

• Initialiser β̃ à zéro.
• Calculer le gradient avec ϵ = 10−8 .
• Mettre à jour jusqu’à convergence.

3. Recherche par grille :

• Tester λ ∈ {10−6 , 5 × 10−5 , 10−4 }, η ∈ {10−4 , 10−3 , 10−2 }, ϵ ∈

{10−6 , 10−8 , 10−10 }.
• Calculer MSE, R2 , et l’erreur relative.

4. Analyser les résultats :

• Compter les coefficients nuls (|βj | < 10−6 ).

• Comparer les performances.

Questions
Questions Mathématiques
1. Montrez la convexité de J.

2. Expliquez pourquoi L1 favorise βj = 0.

3. Analysez l’effet de ϵ sur la parcimonie.

Questions Pratiques
1. Comparez la parcimonie avec Ridge.

2. Analysez la sensibilité à λ, η.

Partie 4 : OLS avec Régularisation Elastic Net

Méthode
Concepts Clés
Elastic Net combine les pénalités L1 et L2 , avec une perte L2 , pour allier parcimonie et
stabilité. GD utilise l’approximation lisse pour L1 .

Formulation Mathématique
• Objectif : Minimiser :
4
1 2 λ1 X q 2 λ2 2
J(β̃) ≈ y − X̃β̃ + βj + ϵ + β̃ .
m 2 m j=0 m 2

8
 • Gradient :
√β02
 
β +ϵ
 β01 
√ 2 
 β1 +ϵ 
2 T  √β22  + 2λ2 β̃.
λ1  
∇J(β̃) ≈ X̃ (X̃β̃ − y) + β +ϵ 
m m  √β23  m
 2 
 β3 +ϵ 
√β42
β4 +ϵ

Tâches à Accomplir
1. Préparer les données :

• Utiliser X̃train , X̃test .

2. Implémenter GD :

• Initialiser β̃ à zéro.
• Calculer le gradient.
• Mettre à jour jusqu’à convergence.

3. Recherche par grille :

• Tester λ1 ∈ {10−6 , 5 × 10−5 , 10−4 }, λ2 ∈ {10−6 , 10−4 , 10−2 }, η ∈

{10−4 , 10−3 , 10−2 }, ϵ ∈ {10−6 , 10−8 , 10−10 }.
• Calculer MSE, R2 , et l’erreur relative.

4. Analyser les résultats :

• Comparer parcimonie et stabilité.

• Analyser l’effet de λ1 , λ2 .

Questions
Questions Mathématiques
1. Dérivez le gradient et montrez la convexité.

2. Comparez les boules de pénalité L1 et L2 .

3. Analysez l’effet de λ1 , λ2 sur la parcimonie.

Questions Pratiques
1. Comparez avec Ridge et Lasso.

2. Évaluez la robustesse face aux corrélations.

3. Discutez de l’impact de ϵ.

9
Partie 5 : Comparaison des Méthodes
Méthode
Concepts Clés
Cette section compare OLS, Ridge, Lasso, et Elastic Net pour les modèles linéaire et non
linéaire, en évaluant MSE, R2 , erreur relative, robustesse, et efficacité. Les méthodes
linéaires peinent à capturer 0.5x2i3 . Une question bonus propose d’implémenter Ridge avec
SGD et Adam.

Tâches à Accomplir
1. Compiler les résultats :
• Créer un tableau avec MSE, R2 , erreur relative, temps d’exécution, et robustesse
pour σδ ∈ {0.01, 0.05, 0.1}.
2. Visualiser la convergence :
• Pour GD (OLS, Lasso, Elastic Net), tracer la perte vs itérations.
3. Analyser les limites :
• Expliquer l’échec à capturer 0.5x2i3 .
• Proposer d’ajouter x2i3 comme variable.
4. Recommander des hyperparamètres :
• Identifier les meilleures valeurs de λ, λ1 , λ2 , η, ϵ.

Tableau des Résultats

Méthode MSE R2 Erreur Relative Temps (s) Robustesse
OLS (GD)
Ridge (GD)
Lasso (GD)
Elastic Net (GD)

Questions
Questions Mathématiques

1. Comparez les fonctions d’influence de L1 et L2 pour Lasso et Ridge.

2. Montrez que la convergence de GD dépend de la constante de Lip-

schitz.

Questions Pratiques

1. Expliquez pourquoi les méthodes linéaires échouent pour 0.5x2i3 .

2. Analysez les compromis précision, robustesse, temps.

3. Recommandez des hyperparamètres optimaux.

10
 Question Bonus
1. Pour la question bonus, implémentez tout par SGD et Adam. Comparez les
performances par (MSE, R2 , temps).

Livrables
• Code : Implémentations de GD avec recherche par grille.
• Rapport : Tableau des résultats, courbes de convergence, réponses aux questions.
• Analyse : Discussion des performances et limites des méthodes linéaires.
• Bonus : Implémentation et comparaison de Ridge avec SGD et Adam.

Conseils
• Vérifiez les gradients pour GD (Lasso, Elastic Net).
• Testez avec m = 300 pour des résultats stables.
• Documentez la recherche par grille.
• Pour le bonus, utilisez SGDRegressor pour SGD et PyTorch pour Adam.

A Méthode d’Optimisation : Gradient Descent

Implémentation de GD

Gradient Descent (GD)

Concept : GD met à jour les paramètres en utilisant le gradient calculé sur l’ensemble
des données.
(t+1) (t) (t)
β̃ = β̃ − η∇J(β̃ ).
Algorithme :

Exemple d’Application : OLS avec Perte L2

Contexte
Nous appliquons GD à OLS avec perte L2 :
1 2
J(β̃) = y − X̃β̃ .
m 2

Gradient :
2 T
∇J(β̃) = X̃ (X̃β̃ − y).
m

Code Python

11
 1 import numpy as np
2 import matplotlib . pyplot as plt
3

4 # D o n n e s ( issues de la g n r a t i o n )
5 X_tilde = np . hstack ([ np . ones ((300 , 1) ) , X ]) # Ajouter colonne de
1
6 y = y_train [:240] # Utiliser l ’ ensemble d ’ e n t r a n e m e n t
7 m = len ( y )
8 eta = 0.01
9 T = 1000
10

11 # Gradient Descent
12 def gradient (X , y , beta ) :
13 return 2/ m * X . T @ ( X @ beta - y )
14

15 beta_gd = np . zeros (5)

16 loss_gd = []
17 for t in range ( T ) :
18 grad = gradient ( X_tilde [: m ] , y , beta_gd )
19 beta_gd -= eta * grad
20 loss = np . mean (( X_tilde [: m ] @ beta_gd - y ) **2)
21 loss_gd . append ( loss )
22

23 # Visualisation
24 plt . figure ( figsize =(10 , 6) )
25 plt . plot ( loss_gd , label = ’ GD ’)
26 plt . xlabel ( ’ I t r a t i o n s ’)
27 plt . ylabel ( ’ Perte $L ^2 $ ’)
28 plt . title ( ’ Convergence de GD pour OLS ’)
29 plt . legend ()
30 plt . grid ( True )
31 plt . savefig ( ’ convergence . png ’)
32 plt . close ()
33

34 # Afficher les coefficients

35 print ( " Coefficients GD : " , beta_gd )

Explications
• GD : Converge régulièrement, utilisant toutes les données d’entraı̂nement (m =
240).

• Sortie : La figure convergence.png montre la perte vs itérations pour GD.

12