TP1 : apprentissage automatique,

Ndeye Fatou NGOM (DIC1 2018-2019)

Exercice 1 Equation Normale

La régression linéaire est un algorithme d’apprentissage supervisé de type
régression. Les algorithmes de régression permettent de prédire des valeurs
continues à partir des variables prédictives. Le principe est de trouver une
droite qui se rapproche le plus possible d’un ensemble de points (points d’en-
traînement). . Considérons l’équation de prédiction d’un modèle de régression
linéaire suivante

ŷ = hθ (x) = θT .x = θ0 + θ1 x1 + ... + θn xn

où θ est le vecteur des paramètres du modèle, θT transposé de θ, x vecteur

des valeurs d’une observation, θT .x est le produit scalaire de θT et x et hθ
est la fonction hypothèse utilisant les paramètres θ.
1. Pour tester le modèle de régression univariée (avec une va-
riable), générer les données à l’allure linéaire suivante

y = 4 + 3x + bruit gaussien

où x est un jeu de données aléatoires

2. Nous souhaitons entraîner le modèle en utilisant la librairie Numpy
et la fonction coût suivante
m
1 X T i
2
M SE (x, hθ ) = θ .x − y i
m
i=1

(a) Péréliminaires
i. Tester le segment de code qui suit
x=2
z= np.c_[1,x]
#z-> ?
x=np.rand(3,1)
X=np.c_[np.ones((3,1)),x]
#X-> ?
ii. Quelle est la valeur de z,
iii. En déduire le rôle de la fonction c_ de Numpy,
iv. Générez deux vecteurs aléatoires et faite la concaténation à
l’aide de la fonction c_.
v. L’équation de régression lorsque les entrées sont composées
d’une seule valeur x est donnée par
(
θ0
ŷ = θ0 + θ1 x = [1, x] = [1, x] θT
θ1
 DIC1-2022-GIT-ML- NFN

Ainsi, pour faire le calcul de la solution analytique de theta,

il faut ajouter une colonne de 1 aux entrées pour introduire
θ0 . A l’aide de l’opérateur c_ ajouter une colonne de 1 à un
vecteur de données aléatoires de taille 5 × 1.
(b) Sachant que la solution analytique de la valeur θ̂ qui minimise la
fonction coût est donnée par l’équation normale suivante

−1
θ̂ = X T .X .X T .y

avec y le vecteur des valeurs cibles y 1 à y m , X. Calculer θ à l’aide

de l’équation normale.
(c) En déduire le temps de calcule et les paramètres θ de ce modèle.
(d) Interpréter les résultats obtenus.
(e) Réaliser des prédictions du modèles.
(f ) Représenter graphiquement les prédicitions du modèle.
(g) Maintenant générer des données non linéaires.
i. Faite une régression linéaire,
ii. Afficher le résultat sur un graphe.
iii. Interpréter le résultat obtenu.
3. On considère pour la suite la libraire Scikit-Learn.
(a) Donner le code équivalent de la régression linéaire pour le modèle
précédent.
(b) Générer un jeu de données non linéaire avec l’équation qui suit

y = 0.5x21 + 1.0x1 + 2.0 + bruit gaussien

(c) Implementer et tester sur des données aléatoires la régression poly-

nomiale : faire une polynomialisation (tranformation des données
d’apprentissage : ajout des puissances de chacune des variables
comme nouvelles variables) avec PolynomialFeatures, puis entraî-
ner un modèle linéaire sur ce nouvel ensemble de données.
4. Régression avec plusieurs variables
5. Les courbes d’apprentissage sont des diagrammes représentant les ré-
sultats obtenus par le modèle sur le jeu d’entraînement et le jeu de
validation en fonction de la taille du jeu d’entraînement. Pour géné-
rer ces graphiques, il suffit d’entraîner le modèle plusieurs fois sur des
sous-ensembles de différentes tailles du jeu d’entraînement.
(a) Définir une fonction qui trace les courbes d’apprentissage,
(b) Générer les courbes d’apprentissage pour un modèle de régression
linéaire simple et pour un modèle polynomial.
 DIC1-2022-GIT-ML- NFN

6. Trouver la polynomialisation qui permet d’éviter le sur-apprentissage

tout en garantissant un apprentissage s’appelle la régularisation d’un
modèle. Parmi les modèles de régularisation figure la régression Ridge
ou régularisation de Tikhonov, la régression LASSO (least absolute
Shrinkage and Selection Operator Regression), l’Elastic Net ou le Early
Stopping. Pour chacune de ces méthodes
(a) rappeler l’idée générale,
(b) rappeler la fonction coût,
(c) implémenter et tester le modèle.

Exercice 2 Descente de gradient ordinaire

Nous allons dans cette exercice rechercher les minima globaux pour une fonc-
tion parabolique et implémenter la descente de gradient pour trouver les pa-
ramètres optimaux pour l’équation de régression linéaire.
1. Pour implémenter un algorithme de descente de gradient, à quoi sert
(a) Fonction coût,
(b) de fixer le nombre d’itérations,
(c) Taux d’apprentissage pour déterminer,
(d) les dérivées partielles,
(e) Fonction de prédiction
(f ) le biais.
2. Considérons maintenant l’équation parabolique suivante

y = 4x2

(a) Sans utiliser la descente de gradient, calculer le minimum global

(xmin , ymin ).
(b) Nous allons maintenant utiliser la descente de gradient pour cal-
culer le minimum.
i. Rappeler l’algortihme de descente de gradient,
ii. Initialiser tous les paramètres nécessaires après avoir défini
une fonction de prédiction, une fonction coût et calculer le
gradient,
iii. Effectuer trois itérations de descente de gradient et visulisez
les résultats.
iv. Définir un critère d’arrêt optimal permettant de se rapprocher
du minimum ;
v. Afficher le minimum trouvé.

Exercice 3 Descente de gradient

 DIC1-2022-GIT-ML- NFN

1. Rappeler la fonction coût du modèle de régression linéaire h (x).

2. Pour la suite, nous souhaitons implémenter la descente de gradient
ordinaire
(a) Ecrire une fonction permettant de caculer h (x) en fonction de θ0
et θ1 en vous inspirant du script qui suit
from numpy import *
import pandas as pd
import matplotlib . pyplot as plt

import matplotlib . animation as animation

def cost_function ( theta0 , theta1 ):

global_cost = 0
for i in range ( len ( X )):
cost_i = (( theta0 + ( theta1 * X [ i ])) - Y [ i ]) * (( theta0
+ ( theta1 * X [ i ])) - Y [ i ])
global_cost += cost_i
return (1/ (2 * len ( X ))) * global_cost

(b) Ecrire une fonction qui permet de calculer la dérivée partielle des
paramètres theta0 et theta1 .
def de r i ve e s_ p a rt i el l es ( ancien_theta0 , ancien_theta1 ):
derivee_theta0 = float (0)
derivee_theta1 = float (0)
for i in range (0 , len ( X )):
derivee_theta0 += float ((( ancien_theta0 +
( ancien_theta1 * X [ i ]))
- float ( Y [ i ])))
derivee_theta1 += ((( ancien_theta0 +
( ancien_theta1 * X [ i ])))
- float ( Y [ i ])) * float ( X [ i ])
derivee_theta0 = (1/ M ) * derivee_theta0
derivee_theta1 = (1/ M ) * derivee_theta1
return [ derivee_theta0 , derivee_theta1 ]

(c) Ecrire une fonction qui permet de calculer itérativement θ en fonc-

tion du learning rate.
def nouvelles_theta ( ancien_theta0 , ancien_theta1 ):
[ derivee_theta0 , derivee_theta1 ] = d e ri v e es _ pa r t ie l le s (
ancien_theta0 , ancien_theta1 )
nouvelle_theta0 = ancien_theta0 - (
l ea r n in g _r a t e_ A LP H A * derivee_theta0 )
nouvelle_theta1 = ancien_theta1 - (
l ea r n in g _r a t e_ A LP H A * derivee_theta1 )
COST_RECORDER . append ( cost_function (
nouvelle_theta0 , nouvelle_theta1 ))
return [ nouvelle_theta0 , nouvelle_theta1 ]
 DIC1-2022-GIT-ML- NFN

(d) En s’appuyant sur ces dernières fonctions, implémenter la des-

cente de gradient.
def gradient_descent ():
tmp_theta0 = initial_theta0
tmp_theta1 = initial_theta1
for i in range ( n ombre_it erations ):
[ nouvelle_theta0 , nouvelle_theta1 ] = nouvelles_theta (
tmp_theta0 , tmp_theta1 )
tmp_theta0 = nouvelle_theta0
tmp_theta1 = nouvelle_theta1
return [ tmp_theta0 , tmp_theta1 ]

[ final_theta0 , final_theta1 ] = gradient_descent ()

print ( " After {0} iterations theta0 = {1} , theta1 = {2} " . format (
nombre_iterations , final_theta0 , final_theta1 ))

3. Tester sur des données de votre choix l’algorithme.

4. Afficher l’évolution du coût d’ereur global en fonction du nombre d’ité-
rations.
xx = []; yy =[]

# dessiner l ’ avancer des differents de J ( theta0 , theta1 )

for i in range ( len ( COST_RECORDER )):
xx . append ( i )
yy . append ( COST_RECORDER [ i ])

axes = plt . axes ()

axes . grid ()
plt . xlabel ( ’ Nombre d \ ’ iterations ’)
plt . ylabel ( ’ Cout d \ ’ erreur global ’)
plt . scatter ( xx , yy )
plt . show ()

Exercice 4 Descente de gradient

La recherche d’optimum avec des solutions directes comme l’équation nor-
male est souvent une tâche très fastidieuse. Une solution le plus souvent plus
efficace est la Descente de Gradient (DG). La descente de gradient est un
algorithme d’optimisation qui permet de trouver des solutions optimales en
corrigeant petit à petit les paramètres dans le but de minimiser une fonction
coût.
1. Discuter sur l’impact de la dimension des pas (taux d’apprentissage) et
de la normalisation des données pour la DG.
2. Générer des données aléatoires X.
3. Normaliser les données en vous inspirant du script suivant
 DIC1-2022-GIT-ML- NFN

# Numpy
X_norm =( X - X . mean ( axis =0))/ X . std ( axis =0)
# StandardScaler de ScikitLearn
from sklearn . preprocessing import StandardScaler
scaler = StandardScaler ()
X_norm = scaler . fit_transform ( X )

4. Nous considérons la descente de gradient ordinaire avec la fonction

coût d’un modèle de régression linéaire. Nous supposons que le vecteur
gradient de la fonction coût est donnée par le vecteur qui suit
 
∂
∂θ0 M SE (θ)
 ∂ M SE (θ) 
 ∂θ1  2
∇θ M SE (θ) =  .  = X T . (X.θ − y)
 
 m
.

 
∂
∂θn M SE (θ)

où
m
∂ 2 X T i
θ .x − y i xij


M SE (θ) =
∂θj m
i=1

Une fois que l’on a le vecteur de gradient, il suffit d’aller dans la direc-
tion opposée pour descendre. Ainsi le pas de descente de gradient est
donnée par
θEtapeSuivante = θ − η∇θ M SE (θ)
où η est le taux d’apprentissage.
(a) Implémenter l’algorithme de descente de gradient ordinaire avec
un nombre d’itération de l’algorithme fixé à 1000.
(b) En vous basant sur les graphes et les temps de calcul, interpréter
les résultats obtenus avec les taux d’apprentissage suivantes : η =
0.02, η = 0.1 et η = 0.5.
(c) En testant plusieurs nombre d’itération différentes, interpréter
l’impact du nombre d’itération sur le résultat obtenu.
(d) Modifier l’algorithme de manière à choisir un très grand nombre
d’itérations, et interrompre l’algorithme lorsque le vecteur de gra-
dient devient très petit ie quand sa norme devient inférieure à
une tolérance epsilon ; ce qui signifie que la descente de gradient
atteint presque son minimum.
(e) Rappeler les avantages et inconvénient, puis implémenter et tester
les méthodes de descente de gradient suivantes
i. Descente de gradient stochastique,
ii. Descente de gradient par mini-lots.