1

??
 Université Abdelmalek Essaadi

Faculté des Sciences et Techniques de Tanger

Département de Mathématiques

LST Mathématiques et Informatique Décisionnelles (LMID)

LST Statistique et Science de Données (LSSD)

Mon PFE

Préparé par :
Ghizlane Malki
Fatima Zohra El Gharbaoui
 15 juin 2025

3
4
Table des matières

1 Optimisation Numérique des Fonctions de Coût dans les Réseaux

Neuronaux 7

Optimisation Numérique des Fonctions de Coût dans les Réseaux Neuro-

naux 7
1.1 Introduion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Descente de gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.1 . Descente de gradient classique . . . . . . . . . . . . . . . . . . . 8
1.2.2 Condition d’optimalité . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.3 Condition d’Optimalité . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.4 Descente de Gradient (DG) . . . . . . . . . . . . . . . . . . . . . 10
1.2.5 Lien entre DG et les Points Critiques . . . . . . . . . . . . . . . . 10
1.2.6 Illustrations Graphiques . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.7 Alghorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Méthodes de gradient stochastique . . . . . . . . . . . . . . . . . . . . . 12
1.3.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.2 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.3 Remarque technique . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.4 Exemple d’application de la descente de gradient stochastique en
Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4 Descente de Gradient Stochastique avec Momentum . . . . . . . . . . . . 19
1.4.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.4.2 Formulation mathématique . . . . . . . . . . . . . . . . . . . . . . 19
1.4.3 Avantages du momentum . . . . . . . . . . . . . . . . . . . . . . . 20
1.4.4 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4.5 Formules utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.4.6 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5
2 Intégration des probabilités dans les architectures neuronales 25
2.1 Modélisation des données par des lois de probabilité . . . . . . . . . . . . 25
2.1.1 Loi Normale (ou Gaussienne) . . . . . . . . . . . . . . . . . . . . 25
2.1.2 Loi Catégorielle et Multinomiale . . . . . . . . . . . . . . . . . . . 26
2.1.3 Loi de Bernoulli . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.1.4 Fonctions d’Activation . . . . . . . . . . . . . . . . . . . . . . . . 27

3 optimisation dans l’apprentissage automatique 29

3.1 AdaGrad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.1.1 Méthode de Gradient Adaptatif (AdaGrad) . . . . . . . . . . . . . 29
3.1.2 Applications numerique en python d’AdaGrad . . . . . . . . . . . 30
3.2 RMSprop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2.1 application numerique en python d’RMsprop . . . . . . . . . . . . 34
3.3 Adam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.1 Adagrad vs RMSprop vs Adam . . . . . . . . . . . . . . . . . . . 40

6
Chapitre 1
Optimisation Numérique des Fonctions de
Coût dans les Réseaux Neuronaux

1.1 Introduion

Qu’est-ce que la descente de gradient ?

La science des données vise à identifier des motifs complexes dans les grands volumes
de données, appelés patterns. Grâce à l’apprentissage automatique, les algorithmes sont
entraînés à reconnaître ces schémas pour automatiser des tâches ou faire des prédictions.

L’apprentissage se fait par exposition répétée aux données, permettant aux algo-
rithmes d’améliorer leur performance avec l’expérience, sans instructions explicites. Parmi
les techniques utilisées, la descente de gradient est l’un des algorithmes d’optimisation les
plus importants.

Cet algorithme cherche à minimiser une fonction, en ajustant progressivement ses

paramètres. Il est particulièrement efficace pour les fonctions convexes (qui ont un seul
minimum global), mais peut échouer sur les fonctions non convexes à cause de la présence
de minima locaux.

Illustration de la descente de gradient sur une fonction convexe La descente de gradient

est également appelée « l’algorithme de pente descendante la plus profonde ». Elle est
essentielle en apprentissage automatique, où elle est utilisée pour minimiser une fonction
de coût. Cette dernière permet de déterminer le meilleur modèle de prédiction en analyse
de données. Plus le coût est minimisé, plus la machine sera capable de faire de bonnes
prédictions.

7
1.2 Descente de gradient

1.2.1 . Descente de gradient classique

Imaginez que vous vous trouvez dans une pièce totalement obscure et que votre objectif
est de trouver l’endroit le plus bas du sol, comme un creux ou un trou. Vous disposez
seulement d’une lampe torche qui éclaire le sol autour de vos pieds. À chaque instant, vous
observez la pente sous vos pieds et vous faites un pas dans la direction où le sol descend
le plus. Puis, vous répétez cette opération : observer, descendre, observer à nouveau. Ce
processus se poursuit jusqu’à ce que vous ne puissiez plus descendre davantage. C’est
exactement le principe de la descente de gradient : à partir d’un point initial, on utilise
le gradient pour déterminer la direction de la plus forte pente et on progresse étape par
étape jusqu’à atteindre un point bas, un minimum local.

Figure 1.1 – Illustration d’une fonction de coût présentant plusieurs minima locaux. La
descente de gradient suit la pente la plus forte et peut se stabiliser sur un minimum local
sans atteindre le minimum global.

Dans cette partie, nous intéressons à des problèmes fondamentalement non linéaires

8
LES RÉSEAUX NEURONAUX PFE
de la forme :

min f (w).
w∈Rd

Le but sera de se ramener à l’étude de fonctions quadratiques construites à partir de

f (et de ses dérivées). On travaillera dans la suite sous l’hypothèse suivante :

Hypothèse

La fonction objectif f du problème

min f (w)
w∈Rd

est de classe CL1,1 (Rd ) pour une certaine constante L > 0, c’est-à-dire que f est
continûment différentiable et que son gradient est L-Lipschitzien. De plus, f est minorée
sur Rd par une constante flow ∈ R, c’est-à-dire :

f (x) ≥ flow , ∀x ∈ Rd .

Notre but est donc de construire et d’analyser des algorithmes basés sur l’information
fournie par le gradient.
L’algorithme de descente de gradient est la méthode la plus classique en optimisation
différentiable. Elle repose sur le principe élémentaire suivant, tiré de la condition
d’optimalité
[w∗ minimum local de f ] =⇒ ∇f (w∗ ) = 0

Soit w ∈ Rd tel que ∇f (w) = 0. Dans ce cas, w est un point critique de la fonction f ,
c’est-à-dire un point où le gradient s’annule.

1.2.2 Condition d’optimalité

Soit w ∈ Rd tel que ∇f (w) = 0. Alors w est un point critique de la fonction f . On

distingue trois cas :
— Si f est convexe, alors w est un minimum local.
— Si la dérivée seconde est strictement négative, alors w est un maximum local.
— Si la dérivée seconde change de signe autour de w, alors c’est un point selle.

9
1.2.3 Condition d’Optimalité
Soit une fonction différentiable f : Rd → R. Un point w∗ est un minimum local si :

∇f (w∗ ) = 0 et ∇2 f (w∗ ) est définie positive.

Dans le cas convexe, cela implique que le minimum est global.

1.2.4 Descente de Gradient (DG)

La descente de gradient est une méthode itérative qui consiste à mettre à jour un
point w selon la direction du gradient :

wk+1 = wk − αk ∇f (wk )

Interprétation : ∇f (w) indique la direction de la plus forte croissance de f , donc

−∇f (w) est une direction de décroissance.

1.2.5 Lien entre DG et les Points Critiques

Lorsqu’on atteint un point w∗ tel que ∇f (w∗ ) = 0, la mise à jour devient :

wk+1 = wk ⇒ convergence.

On distingue alors trois types de points critiques selon ∇2 f (w∗ ) :

— Minimum local : matrice Hessienne > 0
— Maximum local : matrice Hessienne < 0
— Point selle : matrice Hessienne a des valeurs propres de signes opposés

1.2.6 Illustrations Graphiques

Minimum global Maximum local
Point selle
f (w) = (w − 2)2 + 1 f (w) = −w2
f (w) = w3
f (w) w
f (w)
f (w)
w

w
2

Interprétations :

10
LES RÉSEAUX NEURONAUX PFE
— Minimum global : Le point w = 2 est le minimum global. La descente de
gradient converge naturellement vers ce point, car la fonction est convexe et le
gradient s’annule ici.
— Maximum local : Le point w = 0 est un maximum local. La descente de gradient
ne converge pas vers ce point car la direction du gradient est montante, ce qui ne
favorise pas la minimisation.
— Point selle : Le point w = 0 est un point selle. Le gradient s’annule mais ce n’est
ni un minimum ni un maximum. La descente de gradient peut s’y bloquer ou le
contourner selon l’initialisation.

Conclusion
La descente de gradient permet de converger vers un point critique w∗ . Selon la
nature de ∇2 f (w∗ ), ce point est un minimum, un maximum ou un point selle. Pour
l’apprentissage automatique, l’objectif est souvent de minimiser une fonction de perte
convexe ou quasi-convexe.

1.2.7 Alghorithme
L’algorithme de descente de gradient est un processus itératif qui se base sur l’itération
suivante :
w ← w − α∇f (w), (2)

où α > 0 est un paramètre appelé taille de pas ou longueur de pas.

Lorsque ∇f (w) = 0, on remarque que le vecteur w ne change pas lors de la mise
à jour : cette propriété est logique puisque dans une telle situation, il est impossible
d’utiliser le gradient pour déterminer un meilleur point.
En revanche, dès lors que ∇f (w) ̸= 0, on s’attend à ce qu’il existe des valeurs de α
pour lesquelles une telle mise à jour permette d’obtenir un meilleur point, c’est-à-dire un
point avec une valeur de la fonction objectif plus faible.
En utilisant la règle (2) au sein d’un processus itératif, on peut construire un
algorithme dont le but consiste à minimiser la fonction objectif f . Il s’agit de l’algorithme
de descente de gradient, parfois également appelée méthode de la plus forte pente, dont
l’énoncé complet est donné par l’algorithme 1.

Code Python correspondant

11
 Algorithm 1 Descente de gradient pour la minimisation d’une fonction f
Entrée : fonction f : Rd → R, gradient ∇f , point initial w0 ∈ Rd , règle de pas
αk > 0 Initialisation : w ← w0 k = 0, 1, 2, . . . Calculer le gradient : gk ← ∇f (w)
∥gk ∥ < ε Arrêter (convergence atteinte) Choisir αk > 0 Mise à jour : w ← w − αk · gk

1 import numpy as np
2

3 def gradient_descent (f , grad_f , w0 , alpha_func , tol =1 e -6 , max_iter

=1000) :
4

5 w = w0 . copy ()
6 history = [ w . copy () ]
7

8 for k in range ( max_iter ) :

9 grad = grad_f ( w )
10 if np . linalg . norm ( grad ) < tol :
11 print ( f " Convergence atteinte en { k } i t r a t i o n s . " )
12 break
13 alpha_k = alpha_func ( k )
14 w = w - alpha_k * grad
15 history . append ( w . copy () )
16

17 return w , history

Listing 1.1 – Implémentation de la descente de gradient en Python

1.3 Méthodes de gradient stochastique

1.3.1 Définition
Le gradient stochastique est une variante de l’algorithme de descente de gradient
classique, utilisée pour minimiser une fonction objectif exprimée comme une somme de
fonctions individuelles. Ce cas est fréquent en apprentissage automatique, notamment
dans les problèmes de régression ou de classification. La fonction à minimiser est
généralement de la forme :
n
1X
f (w) = fi (w),
n i=1

où chaque fi (w) correspond à la perte associée à l’exemple d’entraînement i, et w ∈ Rd

désigne les paramètres du modèle.
Plutôt que de calculer le gradient complet ∇f (w) à chaque itération — ce qui est

12
LES RÉSEAUX NEURONAUX PFE
coûteux pour de grands ensembles de données — l’algorithme de descente de gradient
stochastique (SGD) effectue une mise à jour à partir du gradient d’un seul terme fik ,
choisi au hasard ou par permutation. La mise à jour des paramètres à l’itération k est
donnée par :
wk+1 = wk − αk ∇fik (wk ),

où αk > 0 est le taux d’apprentissage à l’itération k, et ik ∈ {1, . . . , n} est un indice

tiré aléatoirement. Même si cette estimation du gradient est bruitée, l’algorithme peut
converger vers un minimum de f (w) sous certaines hypothèses sur la suite (αk ), telles
que :
∞
X ∞
X
αk = ∞ et αk2 < ∞.
k=0 k=0

1.3.2 Algorithme

Algorithm 2 Descente de Gradient Stochastique (SGD) pour minimiser f (w) =

1
Pn
n i=1 fi (w)
Entrée : Fonctions fi , gradient ∇fi , point initial w0 ∈ Rd , règle de pas αk > 0
Initialisation : w ← w0 k = 0, 1, 2, . . . , max_iter Choisir un indice aléatoire
ik ∈ {1, . . . , n} Calculer le gradient stochastique : gk ← ∇fik (w) ∥gk ∥ < ε Arrêter
(convergence atteinte) Mise à jour : w ← w − αk · gk Retourner w

Exemple : ajustement parabolique

On considère les quatre points suivants :

A1 = (2, 0), A2 = (0, 2), A3 = (4, 6), A4 = (1, 0)

Comme ces points ne sont clairement pas alignés, on cherche un modèle pour les
ajuster par une parabole de la forme :

y = x2 + ax + b

En effectuant une régression quadratique (polynôme de degré 2), on obtient la parabole

qui minimise l’erreur quadratique entre les points et la courbe.
On cherche ici des coefficients a et b tels que les points soient proches de la parabole
d’équation :
y = x2 + ax + b

13
 Figure 1.2 – Enter Caption

On note donc F (x) = x2 + ax + b, et on souhaite que F (xi ) ≈ yi pour les points

Ai = (xi , yi ), avec i = 1, . . . , 4.

Les fonctions d’erreur locales sont définies pour chaque point comme :


2
Ei (a, b) = yi − x2i + axi + b

La fonction d’erreur globale est la somme des erreurs locales :

E(a, b) = E1 (a, b) + E2 (a, b) + E3 (a, b) + E4 (a, b)

Nous cherchons à minimiser cette fonction d’erreur globale en utilisant des méthodes
d’optimisation. Voici les premières itérations pour deux méthodes d’optimisation à partir
de l’initialisation (a0 , b0 ) = (1, 1) avec un pas d’apprentissage δ = 0,01 :
— Descente de gradient classique : on calcule le gradient sur l’ensemble des points
à chaque itération.
— Descente de gradient stochastique (SGD) : on met à jour (a, b) en utilisant
un seul point aléatoire à chaque itération.

[Link] de gradient classique

Ces deux méthodes peuvent conduire à une convergence vers un minimum local, mais
la SGD peut être plus rapide dans les grands ensembles de données en raison de ses mises
à jour fréquentes et légères.

14
LES RÉSEAUX NEURONAUX PFE

k (ak , bk ) E(ak , bk )

0 (1, 1) 284
1 (−0.54, 0.52) 84.87
2 (−1.36, 0.29) 28.68

Table 1.1 – Premières itérations de la descente de gradient classique

[Link] de gradient stochastique

k (a′k , b′k ) E(a′k , b′k )

0 (1, 1) 284
1 (0.72, 0.86) 236.43
2 (0.72, 0.88) 237.41
3 (−0.38, 0.60) 100.74
4 (−0.40, 0.58) 97.92
5 (−0.55, 0.50) 83.25
6 (−0.55, 0.53) 83.91
7 (−1.22, 0.37) 36.48
8 (−1.22, 0.36) 36.29

Table 1.2 – Premières itérations de la descente de gradient stochastique

Au bout de 200 itérations, la descente de gradient classique conduit à :

(a200 , b200 ) ≈ (−2.9981, 1.9948)

Chaque donnée a été utilisée 200 fois.

La méthode de descente de gradient stochastique a effectué 800 itérations, ce qui
correspond à l’utilisation de chacune des 4 données 200 fois. Elle aboutit à une solution
approchée :
(a′800 , b′800 ) ≈ (−2.9984, 1.9954)

La limite théorique attendue est :

(a, b) = (−3, 2) avec E(a, b) = 0

Ainsi, les deux méthodes — la descente de gradient classique et la descente de

gradient stochastique — convergent vers la même solution, avec une précision comparable.
Toutefois, elles diffèrent sur le plan computationnel :

15
Figure 1.3 – Comparaison entre la descente de gradient classique (à gauche) et la
descente de gradient stochastique (à droite)

— La descente de gradient classique réalise des mises à jour à partir du gradient global
(calculé sur toutes les données).
— La descente de gradient stochastique effectue des mises à jour plus fréquentes avec
un gradient local, ce qui rend chaque itération plus rapide, mais nécessite davantage
d’itérations.

Voici un rappel des points obtenus lors des premières itérations (voir tableaux
précédents) :
— Descente de gradient : (a0 , b0 ) = (1, 1) → (a1 , b1 ) = (−0.54, 0.52) → (a2 , b2 ) =
(−1.36, 0.29)
— Descente stochastique :

(a′0 , b′0 ) = (1, 1), (a′1 , b′1 ) = (0.72, 0.86), (a′2 , b′2 ) = (0.72, 0.88),
(a′3 , b′3 ) = (−0.38, 0.60), (a′4 , b′4 ) = (−0.40, 0.58), (a′5 , b′5 ) = (−0.55, 0.50)

On observe que, malgré une évolution plus "bruyante", la descente stochastique

progresse vers le minimum global. Son efficacité augmente avec les jeux de données de
grande taille, car le coût d’une seule mise à jour est bien plus faible qu’un calcul complet
du gradient.
Voici les points des premières itérations correspondant au tableau ci-dessus

16
LES RÉSEAUX NEURONAUX PFE

Interpretaion
Cette image illustre la différence entre la descente de gradient classique, qui suit
un chemin régulier vers le minimum en utilisant toutes les données, et la descente
stochastique, dont le trajet est plus irrégulier car elle utilise une seule donnée à la fois.
Malgré les zigzags, les deux méthodes convergent vers le même minimum.

Conclusion
Sur cet exemple, les points sont exactement situés sur la parabole d’équation :

y = x2 + ax + b avec a = −3, b = 2.

Bien sûr cette méthode est encore plus intéressante lorsqu’il s’agit de trouver une
parabole qui ne contient pas l’ensemble des points donnés.

1.3.3 Remarque technique

Terminons par des remarques plus techniques. Tout d’abord, la formule précise de la
descente de gradient stochastique est :

Pk+1 = Pk − δ · ∇E(k mod N )+1 (Pk )

où k mod N désigne « k modulo N », c’est-à-dire l’indice cyclique de la donnée utilisée

à l’itération k (dans un ensemble de N données).

La descente de gradient stochastique est une méthode qui peut être plus efficace que
la version classique dans certains contextes, notamment :

17
 — Elle n’utilise qu’une seule donnée à la fois pour mettre à jour les paramètres, ce
qui réduit considérablement l’utilisation de la mémoire.
— Elle évite les coûts liés au calcul du gradient global, requis par la descente de
gradient classique.
— Elle permet des mises à jour fréquentes et rapides, ce qui est particulièrement utile
pour les grands ensembles de données.
Ainsi, bien qu’elle puisse présenter plus de bruit dans la trajectoire d’optimisation,
elle s’avère souvent plus adaptée dans un cadre de traitement de données massives ou en
apprentissage automatique en ligne.

1.3.4 Exemple d’application de la descente de gradient stochas-

tique en Python
Voici un exemple simple en Python de descente de gradient stochastique (SGD) pour
ajuster une parabole y = x2 + ax + b aux points A1 = (2, 0), A2 = (0, 2), A3 = (4, 6), A4 =
(1, 0).
1 import numpy as np
2

3 # D o n n e s : ( x_i , y_i )
4 data = np . array ([
5 [2 , 0] ,
6 [0 , 2] ,
7 [4 , 6] ,
8 [1 , 0]
9 ])
10

11 # Initialisation
12 a , b = 1.0 , 1.0
13 lr = 0.01 # Taux d ’ apprentissage
14 iterations = 200
15 N = len ( data )
16

17 # Fonction d ’ erreur partielle et son gradient

18 def gradient ( xi , yi , a , b ) :
19 pred = xi **2 + a * xi + b
20 error = pred - yi
21 dE_da = 2 * error * xi
22 dE_db = 2 * error
23 return dE_da , dE_db
24

25 # Descente de gradient stochastique

26 for k in range ( iterations ) :

18
 LES RÉSEAUX NEURONAUX PFE
27 i = k % N
28 xi , yi = data [ i ]
29 da , db = gradient ( xi , yi , a , b )
30 a -= lr * da
31 b -= lr * db
32 if k % 50 == 0:
33 print ( f " Iter { k :3 d } : a = { a :.4 f } , b = { b :.4 f } " )
34

35 print ( f " R s u l t a t final : a = { a :.4 f } , b = { b :.4 f } " )

Listing 1.2 – SGD pour ajustement de parabole à 4 points

Résultat attendu :
Après 200 itérations, on obtient typiquement :

a ≈ −2.9984, b ≈ 1.9954

Ce qui est très proche de la solution théorique a = −3, b = 2 pour laquelle la fonction
d’erreur globale est nulle.

1.4 Descente de Gradient Stochastique avec Momen-

tum

1.4.1 Définition
La descente de gradient stochastique avec momentum est une amélioration de la
descente stochastique classique. Elle vise à accélérer la convergence tout en réduisant les
oscillations, notamment dans des vallées étroites du paysage de la fonction à optimiser.

1.4.2 Formulation mathématique

Soit une fonction d’erreur E(a, b) que l’on souhaite minimiser. La mise à jour classique
de la descente de gradient stochastique (SGD) est :

Pk+1 = Pk − δ · ∇Ei (Pk )

où :
— δ est le taux d’apprentissage,
— ∇Ei est le gradient calculé sur un seul échantillon i,
— i = k mod N avec N le nombre total d’échantillons.

19
 Avec le momentum, on introduit un vecteur de vitesse accumulée :

vk+1 = µvk + δ · ∇Ei (Pk )

Pk+1 = Pk − vk+1

où :
— µ ∈ [0, 1) est le coefficient de momentum (typiquement 0.9),
— vk agit comme une mémoire des gradients précédents.

1.4.3 Avantages du momentum

— Réduit les oscillations dans les directions instables.
— Accélère la descente dans les directions constantes.
— Permet d’atteindre le minimum plus rapidement.

1.4.4 Exemple

Considérons la fonction simple :

E(a, b) = (a + 3)2 + (b − 2)2

Cette fonction admet un minimum global en (a∗ , b∗ ) = (−3, 2). On applique la descente
stochastique avec momentum en partant du point (1, 1).

Application numérique : SGD avec Momentum

Considérons la fonction convexe :

E(a, b) = (a + 3)2 + (b − 2)2

Elle admet un minimum global en (a∗ , b∗ ) = (−3, 2).

Nous appliquons la descente de gradient stochastique avec momentum pour trouver
ce minimum, avec les paramètres suivants :
— Point initial : a0 = 1.0, b0 = 1.0
— Taux d’apprentissage : δ = 0.1
— Momentum : µ = 0.9
— Vitesse initiale : va0 = 0, vb0 = 0

20
LES RÉSEAUX NEURONAUX PFE
1.4.5 Formules utilisées

∇E(a, b) = (2(a + 3), 2(b − 2))


(k+1) (k)


 va = µva + δ · 2(ak + 3)


v (k+1) = µv (k) + δ · 2(bk − 2)

b b

ak+1 = ak − va(k+1)




 (k+1)
bk+1 = bk − vb


Calculs itératifs
— Itération 0 :

∇E(1, 1) = (8, −2) ⇒ va = 0.8, vb = −0.2

a1 = 1.0 − 0.8 = 0.2, b1 = 1.0 − (−0.2) = 1.2

— Itération 1 :
∇E(0.2, 1.2) = (6.4, −1.6)

va = 0.9 · 0.8 + 0.1 · 6.4 = 1.36, vb = 0.9 · (−0.2) + 0.1 · (−1.6) = −0.34

a2 = 0.2 − 1.36 = −1.16, b2 = 1.2 − (−0.34) = 1.54

— Itération 2 :
∇E(−1.16, 1.54) = (3.68, −0.92)

va = 0.9 · 1.36 + 0.1 · 3.68 = 1.592, vb = 0.9 · (−0.34) + 0.1 · (−0.92) = −0.398

a3 = −1.16 − 1.592 = −2.752, b3 = 1.54 − (−0.398) = 1.938

Tableau récapitulatif
Itération k ak bk va vb
0 1.000 1.000 0.800 -0.200
1 0.200 1.200 1.360 -0.340
2 -1.160 1.540 1.592 -0.398
3 -2.752 1.938 - -

21
 Figure 1.4 – Convergence de (ak , bk ) vers le minimum global avec momentum

Observation

On observe une convergence rapide de (ak , bk ) vers (−3, 2) en seulement quelques

itérations. Le momentum permet de lisser les gradients et d’accélérer la descente dans la
bonne direction.

Résultat

Après 50 itérations, le point (ak , bk ) converge rapidement vers le minimum (−3, 2),
démontrant l’efficacité du momentum pour accélérer la descente dans des directions
stables.

22
 LES RÉSEAUX NEURONAUX PFE
1.4.6 Code Python
Voici une implémentation Python simple de la descente de gradient stochastique avec
momentum, appliquée à la fonction :

E(a, b) = (a + 3)2 + (b − 2)2

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

4 # Fonction d ’ erreur
5 def E (a , b ) :
6 return ( a + 3) **2 + ( b - 2) **2
7

8 # Gradient de la fonction
9 def gradient (a , b ) :
10 dE_da = 2 * ( a + 3)
11 dE_db = 2 * ( b - 2)
12 return dE_da , dE_db
13

14 # Initialisation
15 a , b = 1.0 , 1.0
16 va , vb = 0.0 , 0.0
17 lr = 0.1
18 momentum = 0.9
19 iterations = 50
20

21 history = [( a , b ) ]
22

23 # Descente de gradient avec momentum

24 for k in range ( iterations ) :
25 dE_da , dE_db = gradient (a , b )
26 va = momentum * va + lr * dE_da
27 vb = momentum * vb + lr * dE_db
28 a -= va
29 b -= vb
30 history . append (( a , b ) )
31 if k % 10 == 0 or k == iterations - 1:
32 print ( f " Iter { k :2 d } : a = { a :.4 f } , b = { b :.4 f } , E = { E (a , b ) :.4
f}")
33

34 # Trajectoire de convergence
35 history = np . array ( history )
36 plt . plot ( history [: , 0] , history [: , 1] , ’o - ’ , label = ’ SGD + momentum ’)
37 plt . plot ( -3 , 2 , ’r * ’ , markersize =12 , label = ’ Minimum attendu ’)

23
38 plt . xlabel ( " a " )
39 plt . ylabel ( " b " )
40 plt . title ( " Convergence avec SGD + momentum " )
41 plt . grid ( True )
42 plt . legend ()
43 plt . show ()

Listing 1.3 – SGD avec momentum pour minimisation de E(a, b)

Resultat
Ce programme illustre bien comment les paramètres a et b convergent rapidement
vers leur minimum théorique (−3, 2), grâce à l’effet d’accélération du momentum.

Itération a b E(a,b)
0 1.6000 1.2000 29.9600
10 -1.3260 1.7686 3.8451
20 -2.5307 1.9422 0.3080
30 -2.8553 1.9853 0.0241
40 -2.9606 1.9965 0.0019
49 -2.9895 1.9989 0.0002

Table 1.3 – Convergence de la descente de gradient avec momentum vers le minimum

global

24
Chapitre 2
Intégration des probabilités dans les
architectures neuronales

2.1 Modélisation des données par des lois de probabi-

lité

2.1.1 Loi Normale (ou Gaussienne)

Définition : Une variable aléatoire continue X suit une loi normale de moyenne µ et
de variance σ 2 si :
X ∼ N (µ, σ 2 )

Densité de probabilité :

(x − µ)2
 
1
fX (x) = √ exp −
2πσ 2 2σ 2

Propriétés :
— Espérance : E[X] = µ
— Variance : Var(X) = σ 2
Cas particulier : Loi normale centrée réduite
Lorsque la moyenne est nulle (µ = 0) et la variance est égale à un (σ 2 = 1), on parle
de loi normale centrée réduite. On la note :

X ∼ N (0, 1)

Sa densité de probabilité devient alors :

 2
1 x
fX (x) = √ exp −
2π 2

25
 Cette forme particulière est très utilisée en statistiques pour la standardisation des
données et sert de base pour de nombreuses approximations théoriques (ex. : théorème
central limite).
Cette loi est souvent utilisée comme prior sur les poids : on suppose que chaque
poids suit une distribution normale wi ∼ N (0, σ 2 ). Elle intervient également dans la
modélisation de la vraisemblance dans les tâches de régression bayésienne.

2.1.2 Loi Catégorielle et Multinomiale

Loi catégorielle : Modélise une seule épreuve où l’on choisit une catégorie parmi K
possibles :
K
X
X ∼ Cat(p1 , ..., pK ), pi = 1
i=1

Loi multinomiale : Généralise la loi catégorielle à n tirages indépendants :

(X1 , ..., XK ) ∼ Mult(n; p1 , ..., pK )

Propriétés :
— E[Xi ] = npi
— Var(Xi ) = npi (1 − pi )
— Cov(Xi , Xj ) = −npi pj , pour i ̸= j
Ces lois sont utilisées pour modéliser la vraisemblance en classification. La sortie du
réseau représente un vecteur de probabilités sur les classes. L’utilisation de l’entropie
croisée (cross-entropy) comme fonction de perte revient à maximiser la log-vraisemblance
de la loi catégorielle.

2.1.3 Loi de Bernoulli

Définition : La loi de Bernoulli est une distribution discrète à deux issues {0, 1},
paramétrée par p ∈ [0, 1], représentant la probabilité de succès (issue 1).
Notation :
X ∼ Bern(p)

Fonction de masse de probabilité :

P (X = x) = px (1 − p)1−x , x ∈ {0, 1}

Propriétés :
— Espérance : E[X] = p
— Variance : Var(X) = p(1 − p)

26
 La loi de Bernoulli intervient dans la technique du drop-out, où chaque neurone est
conservé avec une probabilité p et supprimé avec une probabilité 1−p. Le masque de drop-
out est ainsi un vecteur de variables aléatoires suivant des lois de Bernoulli indépendantes.
Cela permet :
— D’introduire un bruit stochastique, interprété comme une régularisation bayé-
sienne,
— De modéliser l’incertitude sur l’activation des neurones,
— De réduire le sur-apprentissage (overfitting) et améliorer la généralisation du
réseau.

2.1.4 Fonctions d’Activation

Les fonctions d’activation introduisent de la non-linéarité dans les réseaux de neurones,
ce qui est essentiel pour modéliser des relations complexes. Elles transforment la somme
pondérée des entrées d’un neurone avant de produire la sortie.

Formule générale de sortie d’un neurone

n
!
X
y=ϕ w i xi + b
i=1

où ϕ est la fonction d’activation, wi les poids, xi les entrées, et b le biais.

Fonctions courantes :

— Fonction sigmoïde :
1
σ(z) =
1 + e−z
Utilité : Modélise des probabilités dans les tâches de classification binaire.
Inconvénient : gradients faibles pour |z| grand.
— Fonction tanh :
ez − e−z
tanh(z) =
ez + e−z
Utilité : Fournit des sorties centrées sur 0, ce qui peut améliorer la convergence
pendant l’apprentissage.
— Fonction ReLU :
ReLU(z) = max(0, z)

Utilité : Favorise un apprentissage rapide dans les réseaux profonds. Elle évite le
problème de vanishing gradients et est très utilisée dans la pratique.

27
28
Chapitre 3
optimisation dans l’apprentissage
automatique

3.1 AdaGrad

3.1.1 Méthode de Gradient Adaptatif (AdaGrad)

La méthode de gradient adaptatif, ou AdaGrad, a été proposée en 2011 pour
répondre à la difficulté du choix du taux d’apprentissage α dans l’algorithme de gradient
stochastique, tout en évitant d’avoir recours à des procédures adaptatives coûteuses telles
que la recherche linéaire.
L’approche d’AdaGrad consiste à normaliser chaque composante du gradient stochas-
tique en tenant compte de l’historique de ses valeurs. Plus précisément, AdaGrad accu-
mule les carrés des gradients pour chaque composante au fil des itérations, ce qui permet
d’ajuster automatiquement le taux d’apprentissage pour chaque paramètre du modèle :

rt [i] = rt−1 [i] + (gt [i])2

η
θt+1 = θt − √ · gt
rt + ϵ
où :
— rt [i] est la somme cumulative des carrés des gradients de la i-ème composante
jusqu’à l’itération t,
— gt [i] est le gradient stochastique de la i-ème composante à l’itération t,
— ϵ est un terme de régularisation (typiquement très petit) pour éviter la division
par zéro,
— η est le taux d’apprentissage global.

29
 Cette méthode permet à AdaGrad de mieux gérer les situations où les données
sont clairsemées (sparse data), en attribuant un taux d’apprentissage plus élevé aux
paramètres moins fréquemment mis à jour.

Algorithme d’AdaGrad

Algorithm 3 Adagrad, algorithme d’optimisation adaptatif

Require: η : Taux d’apprentissage
Require: ε : Terme de lissage
Require: f (θ) : Fonction objectif à optimiser
Require: θ0 : Paramètre initial
1: r0 ← 0 {Initialisation de l’accumulation des gradients au carré}
2: t←0
3: while non convergé do
4: t←t+1
5: gt ← ∇θ f (θt−1 ) {Gradient}
6: rt ← rt−1 + gt2 {Accumulation du gradient au carré}
η
7: θt ← θt−1 − √
rt +ε
· gt {Mise à jour des paramètres}
8: end while
9: return θt

3.1.2 Applications numerique en python d’AdaGrad

Description
Dans cet exemple, nous appliquons l’algorithme de descente de gradient AdaGrad à une
fonction simple définie par :
J(θ) = θ2

L’objectif est de minimiser cette fonction convexe à l’aide d’AdaGrad, qui adapte
dynamiquement le taux d’apprentissage pour chaque paramètre en fonction de l’historique
des gradients.
1 import numpy as np
2 import matplotlib . pyplot as plt
3

4 def cost ( theta ) :

5 return theta **2
6

7 def gradient ( theta ) :

30
8 return 2 * theta
9

10 theta = 10
11 eta = 0.1
12 epsilon = 1e -8
13 r = 0
14 iterations = 100
15

16 loss_history = []
17 lr_history = []
18

19 for t in range (1 , iterations + 1) :

20 g = gradient ( theta )
21 r += g **2
22 adjusted_lr = eta / ( np . sqrt ( r ) + epsilon )
23 theta = theta - adjusted_lr * g
24

25 loss_history . append ( cost ( theta ) )

26 lr_history . append ( adjusted_lr )
27

28 plt . figure ( figsize =(8 , 5) )

29 plt . plot ( loss_history , label = ’J (\ theta ) ’ , color = ’ #457 b9d ’ , marker = ’o ’)
30 plt . title ( " volution de la perte J ( theta ) " )
31 plt . ylabel ( " Perte " )
32 plt . xlabel ( " I t r a t i o n s " )
33 plt . grid ( True )
34 plt . legend ()
35 plt . tight_layout ()
36 plt . show ()
37

38 plt . figure ( figsize =(8 , 5) )

39 plt . plot ( lr_history , label = ’ eta_t ( learning rate ) ’ , color = ’ #264653 ’ ,
marker = ’. ’)
40 plt . title ( " volution du taux d ’ apprentissage effectif eta_t " )
41 plt . ylabel ( " Taux d ’ apprentissage " )
42 plt . xlabel ( " I t r a t i o n s " )
43 plt . grid ( True )
44 plt . legend ()
45 plt . tight_layout ()
46 plt . show ()

Listing 3.1 – Évolution de la perte J(θ) et du taux d’apprentissage effectif ηt avec AdaGrad

31
Résultats du code

Iteration 1 : J(θ) = 98.010000, ηt = 0.005000

Iteration 5 : J(θ) = 93.677983, ηt = 0.002271
..
.
Iteration 15 : J(θ) = 87.735400, ηt = 0.001340
..
.
Iteration 25 : J(θ) = 83.737041, ηt = 0.001054
Iteration 30 : J(θ) = 82.076028, ηt = 0.000968

Figure 3.1 – Évolution de J(θ) avec Figure 3.2 – Évolution du taux d’appren-
l’algorithme AdaGrad tissage avec l’algorithme AdaGrad

Interprétation de la figure 3.1 : La fonction de coût J(θ) décroît progressivement,

indiquant que l’algorithme AdaGrad optimise efficacement les paramètres. La courbe tend
vers un plateau, signe de convergence vers un minimum local.

Interprétation de la figure 3.2 : Le taux d’apprentissage diminue au fil des

itérations, ce qui reflète l’adaptation dynamique d’AdaGrad pour stabiliser et améliorer
la convergence du modèle.

Limites d’AdaGrad

Limites d’Adagrad
Adagrad adapte le taux d’apprentissage ηt pour chaque paramètre en fonction de la
somme cumulée des carrés des gradients jusqu’à l’itération t :

32
 t
η X
ηt = √ avec rt = gi2
rt + ε i=1

Comme rt est une somme croissante, le taux d’apprentissage ηt diminue rapidement

avec le temps.
Par conséquent, la mise à jour des paramètres s’écrit :

θt+1 = θt − ηt · gt

qui devient de plus en plus petite, même lorsque θt n’a pas encore atteint le minimum
de la fonction de perte f (θ).
Cela limite la capacité de l’algorithme à faire des ajustements significatifs, ce qui peut
entraîner une stagnation prématurée et une optimisation inefficace de la fonction de perte.

3.2 RMSprop
La méthode RMSProp (Root Mean Square Propagation) a été proposée pour
surmonter une limite majeure d’AdaGrad : la décroissance rapide du taux d’apprentissage
due à l’accumulation des gradients au cours du temps.
RMSProp introduit une approche fondée sur une moyenne glissante exponentielle
du carré des gradients, permettant ainsi de conserver une mémoire limitée des gradients
récents. Cette méthode ajuste dynamiquement le taux d’apprentissage tout en évitant
qu’il ne diminue trop rapidement.
La formule clé utilisée est la suivante :

E[g 2 ]t = γE[g 2 ]t−1 + (1 − γ)gt2

où :
— E[g 2 ]t est la moyenne glissante exponentielle des carrés des gradients à l’itération
t,
— gt est le gradient au temps t,
— γ ∈ [0, 1) est le taux de décroissance, souvent fixé à γ = 0,9,
— η est le taux d’apprentissage initial,
— ε est une petite constante pour la stabilité numérique.
La mise à jour des paramètres est ensuite donnée par :

η
θt+1 = θt − p · gt
E[g 2 ]t + ε

33
 Algorithme RMSProp

Algorithm 4 RMSProp, algorithme d’optimisation avec moyenne mobile

Require: η : Taux d’apprentissage
Require: γ : Taux de décroissance (decay)
Require: ε : Terme de lissage
Require: f (θ) : Fonction objectif à optimiser
Require: θ0 : Paramètre initial
1: E[g 2 ]0 ← 0 {Initialisation de la moyenne mobile}
2: t←0
3: while non convergé do
4: t←t+1
5: gt ← ∇θ f (θt−1 ) {Gradient}
6: E[g 2 ]t ← γ · E[g 2 ]t−1 + (1 − γ) · gt2 {Moyenne mobile des gradients au carré}
7: θt ← θt−1 − √ η2 · gt {Mise à jour des paramètres}
E[g ]t +ε
8: end while
9: return θt

3.2.1 application numerique en python d’RMsprop

Description
Dans ce programme, nous appliquons l’algorithme de descente de gradient RMSProp
à la même fonction que celle utilisée pour AdaGrad, afin de visualiser les différences entre
ces deux algorithmes.

Code Python
1 import numpy as np
2 import matplotlib . pyplot as plt
3

4 # Fonction de c o t : J ( ) = theta ^2
5 def cost ( theta ) :
6 return theta **2
7

8 # Gradient de J ( )
9 def gradient ( theta ) :
10 return 2 * theta
11

34
12 # Initialisation
13 theta = 10
14 eta = 0.1
15 epsilon = 1e -8
16 r = 0
17 rho = 0.9 # Coefficient de lissage RMSProp
18 iterations = 30
19

20 # Historique des valeurs

21 loss_history = []
22 lr_history = []
23

24 # Descente de gradient avec RMSProp

25 for t in range (1 , iterations + 1) :
26 g = gradient ( theta )
27 r = rho * r + (1 - rho ) * g **2
28 adjusted_lr = eta / ( np . sqrt ( r ) + epsilon )
29 theta = theta - adjusted_lr * g
30

31 loss_history . append ( cost ( theta ) )

32 lr_history . append ( adjusted_lr )
33

34 print ( f " Iteration { t :2 d }: J ( ) = { cost ( theta ) :.6 f } , = {

adjusted_lr :.6 f } " )
35

36 plt . figure ( figsize =(8 , 5) )

37 plt . plot ( loss_history , label = ’J ( ) ’ , color = ’ #457 b9d ’ , marker = ’o ’)
38 plt . title ( " volution de la perte J ( )")
39 plt . ylabel ( " Perte " )
40 plt . xlabel ( " I t r a t i o n s " )
41 plt . grid ( True )
42 plt . legend ()
43 plt . tight_layout ()
44 plt . show ()
45

46 plt . figure ( figsize =(8 , 5) )

47 plt . plot ( lr_history , label =... ( learning rate ) ’ , color = ’# 264653 ’ ,
marker = ’. ’)
48 plt . title ( " volution du taux d ’ apprentissage effectif .. " )
49 plt . ylabel ( " Taux d ’ apprentissage " )
50 plt . xlabel ( " I t r a t i o n s " )
51 plt . grid ( True )
52 plt . legend ()
53 plt . tight_layout ()
54 plt . show ()

35
 Listing 3.2 – Descente de gradient avec RMSProp

Résultat du code

Itération 1 : J(θ) = 93.775445, ηt = 0.015811

Itération 2 : J(θ) = 89.451499, ηt = 0.011663
..
.
Itération 22 : J(θ) = 50.261954, ηt = 0.006654
Itération 23 : J(θ) = 48.925778, ηt = 0.006691
..
.
Itération 29 : J(θ) = 41.448733, ηt = 0.007006
Itération 30 : J(θ) = 40.284464, ηt = 0.007072

Figure 3.3 – Évolution de J(θ) avec Figure 3.4 – Évolution du taux d’appren-
l’algorithme RMSprop tissage avec l’algorithme RMSProp

Interprétation de la figure 3.3 :On observe une diminution progressive de la

valeur de J(θ) au fur et à mesure que le nombre d’itérations augmente. Cela signifie
que l’algorithme ajuste correctement le paramètre θ afin de minimiser la fonction de
coût.

Interprétation de la figure 3.4 : Le taux d’apprentissage ηt diminue rapidement

au début car les gradients sont plus importants (valeurs initiales élevées de θ), ce qui fait
augmenter la moyenne mobile des carrés des gradients r, et donc diminuer
η
ηt = √ .
r+ϵ

36
Ensuite, ηt se stabilise autour d’une petite valeur, ce qui permet d’avoir des pas plus
petits et plus stables dans la descente, évitant ainsi les oscillations ou divergences. .

3.3 Adam

1. Qu’est-ce que Adam ?

Adam (Adaptive Moment Estimation) est un algorithme d’optimisation avancé,
largement utilisé en apprentissage automatique pour sa robustesse et sa rapidité de
convergence.
Il combine intelligemment deux méthodes :
— Momentum : permet d’accélérer la descente du gradient en accumulant une
moyenne des gradients passés, ce qui favorise les directions stables et rapides de
convergence tout en limitant les oscillations.
— RMSProp : adapte dynamiquement le taux d’apprentissage en fonction de la
moyenne des gradients au carré, ce qui stabilise les descentes.
Grâce à cette combinaison, Adam ajuste automatiquement les taux d’apprentissage
pour chaque paramètre, ce qui le rend particulièrement efficace dans des environnements
complexes (gradients bruités, fonctions non convexes, etc.).

2. Formules de l’algorithme Adam

À chaque itération t, Adam met à jour les paramètres θ à l’aide des formules suivantes :

gt = ∇θ f (θt ) (gradient)
mt = β1 · mt−1 + (1 − β1 ) · gt (moyenne mobile des gradients)
vt = β2 · vt−1 + (1 − β2 ) · gt2 (moyenne mobile des carrés des gradients)
mt
m̂t = (correction du biais)
1 − β1t
vt
v̂t =
1 − β2t
m̂t
θt+1 = θt − α · √
v̂t + ε
Où :
— θt : paramètre à l’itération t
— gt : gradient de la fonction de coût
— mt : moyenne mobile des gradients (Momentum)
— vt : moyenne mobile des carrés des gradients (RMSProp)
— m̂t , v̂t : versions corrigées du biais

37
 — α : taux d’apprentissage
— β1 , β2 : coefficients de pondération
— ε : petit terme pour éviter la division par zéro

3. Exemple numérique

Objectif : Minimiser la fonction f (θ) = θ2 dont le minimum est atteint en θ = 0.

Paramètres de l’algorithme :

Paramètre Valeur

θ0 0.5
α 0.1
β1 0.9
β2 0.999
ε 10−8
Itérations 3

Étapes du calcul :
— gt = 2θt
— mt = β1 mt−1 + (1 − β1 )gt
— vt = β2 vt−1 + (1 − β2 )gt2
— m̂t = mt /(1 − β1t )
— v̂t = vt /(1 − β2t )
— θt+1 = θt − α · √m̂t
v̂t +ε

Itération 1

g1 = 1.0, m1 = 0.1, v1 = 0.001

m̂1 = 1.0, v̂1 = 1.0
1.0
θ1 = 0.5 − 0.1 · √ ≈ 0.4
1.0 + 10−8

38
Itération 2

g2 = 0.8, m2 = 0.17, v2 = 0.001639

m̂2 ≈ 0.8947, v̂2 ≈ 0.8199
θ2 ≈ 0.3011

Itération 3

g3 = 0.6022, m3 = 0.2132, v3 ≈ 0.0019991

m̂3 ≈ 0.7864, v̂3 ≈ 0.6671
θ3 ≈ 0.2048

Résumé :

Itération θt f (θt )

0 0.5000 0.2500
1 0.4000 0.1600
2 0.3011 0.0907
3 0.2048 0.0419

4. Algorithme Adam (pseudocode)

Algorithm 5 Algorithme Adam

Require: α, β1 , β2 , ε, θ0
1: m0 ← 0, v0 ← 0, t ← 0
2: while non convergé do
3: t←t+1
4: gt ← ∇f (θt−1 )
5: mt ← β1 mt−1 + (1 − β1 )gt
6: vt ← β2 vt−1 + (1 − β2 )gt2
7: m̂t ← mt /(1 − β1t )
8: v̂t ← vt /(1 − β2t )
√
9: θt ← θt−1 − α · m̂t /( v̂t + ε)
10: end while
11: return θt

39
3.3.1 Adagrad vs RMSprop vs Adam

Description

Dans cette partie, nous avons appliqué les trois algorithmes d’optimisation à la même
fonction et avec le même nombre d’itérations, afin de comparer leurs comportements
respectifs et identifier celui qui converge le plus efficacement vers le minimum.

(a) Taux d’apprentissage ef- (b) Fonction de perte J(θ) (c) Évolution du paramètre
fectif θ

Figure 3.5 – Comparaison des optimisateurs Adagrad, RMSprop et Adam

Interprétation des résultats

Les figures comparent les algorithmes Adagrad, RMSprop et Adam sur la fonction
J(θ) = θ2 .
— Taux d’apprentissage : Adagrad décroit rapidement, provoquant un arrêt
prématuré. RMSprop et Adam maintiennent un taux plus stable grâce aux
moyennes mobiles, Adam ajoutant une correction de moment pour une meilleure
dynamique.
— Fonction de perte : Adam converge le plus vite, RMSprop suit bien, Adagrad
ralentit à cause de la baisse agressive du taux d’apprentissage.
— Paramètre θ : Adam atteint le minimum rapidement et en douceur, RMSprop
descend progressivement, Adagrad ralentit après les premières itérations, limitant
son exploration.
En résumé, Adam combine efficacité et stabilité, RMSprop est performant, tandis
qu’Adagrad reste limité pour des optimisations longues.

40