Nom : Gleyze

Master 1 SD, SIME Prénom : Alexandre

Master 2 SIME
Apprentissage profond

Séance de TP 2
Perceptron multicouches et descente de gradient

1- Mettre en évidence l’influence des paramètres de l’algorithme SGD

Pour les paramètres SGD suivants: un batch de 64, un learning_rate de 1e-2 et 20
époques, nous obtenons:

Pour les paramètres SGD: un batch de 64, learning_rate de1e-2 et 60 époques, on a

:
Pour les paramètres SGD: un batch de 64, learning_rate de 1e-3 et 60 époques, on
a:

Pour les paramètres SGD: un batch de 16, learning_rate de 1e-2, 20 époques, on a :

En analysant les résultats fournis pour différentes configurations de paramètres du
Stochastic Gradient Descent (SGD), voici quelques observations et conclusions sur le
rôle et l'influence de ces paramètres :

Taux d'apprentissage (learning rate) :

Le taux d'apprentissage contrôle la taille des pas que l'optimiseur effectue dans
l'espace des paramètres lors de la mise à jour des poids du réseau neuronal.
Une valeur de taux d'apprentissage trop élevée peut conduire à une convergence
rapide, mais risque également de sauter par-dessus le minimum global ou de diverger.
Une valeur trop faible peut entraîner une convergence lente.
Dans nos tests, on peut observer que pour learning_rate de 1e-2, le modèle converge
mieux que pour learning_rate de 1e-3, montrant ainsi l'impact significatif du taux
d'apprentissage sur les performances du modèle.

Taille du lot (batch size) :

Le batch size détermine le nombre d'exemples de données utilisés dans une seule
itération de la descente de gradient.
Un batch size plus grand peut conduire à une convergence plus rapide, car il utilise
plus d'informations pour mettre à jour les poids du réseau à chaque itération.
Cependant, des batchs plus grands nécessitent également plus de mémoire et
peuvent être plus lents à calculer.
Dans nos tests, on constate que des batchs de taille 64 ont généralement des taux de
reconnaissance plus élevés que des batchs de taille 16, bien que cela puisse varier
selon d'autres facteurs.

Nombre d'époques (epochs) :

Le nombre d'époques représente le nombre de fois que l'ensemble complet des

données d'entraînement est passé à travers le réseau neuronal.
Augmenter le nombre d'époques peut permettre au modèle de mieux apprendre les
motifs dans les données, mais cela peut aussi entraîner un surapprentissage
(overfitting) si le modèle devient trop adapté aux données d'entraînement et ne
généralise pas bien sur de nouvelles données.
Dans nos tests, on peut voir que les performances sur l'ensemble de test continuent
d'augmenter avec le nombre d'époques jusqu'à un certain point, après quoi elles
commencent à stagner ou à diminuer, ce qui indique un ajustement excessif.

2- Mettre en évidence l’apport de la fonction d’activation RELU() par rapport à la

fonction Sigmoïde()
Pour Architecture : MLP comportant 3 couches 512 – 128 – 10 activation nn.Sigmoid()
Paramètres SGD: un batch de 64, learning_rate de 1e-2, 20 époques
Pour l’architecture : MLP comportant 3 couches 512 – 128 – 10 activation nn.ReLU()
Paramètres SGD: un batch de 64, learning_rate de 1e-2, 20 époques, on obtient :

En observant les résultats obtenus avec les deux configurations, nous pouvons mettre
en évidence l'apport de la fonction d'activation ReLU par rapport à la fonction
d'activation Sigmoid dans le contexte de l'apprentissage d'un MLP (Perceptron Multi-
Couches) pour la tâche de classification MNIST.

Performances en termes de perte et de précision :

Avec la fonction d'activation Sigmoid, nous observons que la perte diminue

progressivement au fil des époques, mais à un rythme assez lent. La perte de
validation semble stagner autour de 0.55 après 20 époques. Cependant, le taux de
reconnaissance sur l'ensemble de test est de 84.43%.
En revanche, avec la fonction d'activation ReLU, la perte diminue de manière
beaucoup plus rapide et converge vers des valeurs plus basses. La perte de validation
atteint environ 0.16 après 20 époques. De plus, le taux de reconnaissance sur
l'ensemble de test est significativement plus élevé, à 95.74%.

Vitesse de convergence :

La fonction ReLU permet une convergence plus rapide de l'algorithme d'optimisation.

Nous observons que la perte diminue de manière significative dès les premières
époques, ce qui indique une meilleure convergence vers un minimum global ou local.
En conclusion, l'utilisation de la fonction d'activation ReLU a un impact significatif sur
les performances du modèle. Elle permet une convergence plus rapide de l'algorithme
d'optimisation et aide à éviter certains problèmes liés au gradient. Dans nos tests, elle
a conduit à une meilleure précision sur l'ensemble de test par rapport à la fonction
Sigmoid.

3- Comparer SGD et ADAM en termes de convergence (temps et Loss)

On repasse en nn.Sigmoid() :
Architecture : MLP comportant 3 couches 512 – 128 – 10 Sigmoid()
Paramètres ADAM: un batch de 64, learning_rate de 1e-2, 20 époques
Paramètres ADAM: un batch de 64, learning_rate de 1e-2, 60 époques

Pour : Paramètres ADAM: un batch de 64, learning_rate de 1e-3, époques 20

Pour : Paramètres ADAM: un batch de 64, learning_rate de 1e-3, époques 60

Pour comparer SGD et ADAM en termes de convergence, examinons comment ces
algorithmes se comportent en termes de temps de convergence et de diminution de la
fonction de perte (loss) sur le jeu de données d'entraînement.

Convergence (Temps et Loss):

Stochastic Gradient Descent (SGD):
Nous constatons que SGD, un algorithme de descente de gradient stochastique
classique, met à jour les poids du réseau à chaque itération en utilisant un seul
exemple à la fois ou un petit sous-ensemble d'exemples.
En général, SGD peut converger plus lentement vers un minimum global car il peut être
sensible aux oscillations lorsqu'il est proche de minima locaux ou de zones de
plateaux.
Il a tendance à nécessiter un taux d'apprentissage (learning rate) plus petit pour
converger, ce qui peut ralentir la convergence.

ADAM (Adaptive Moment Estimation):

ADAM, un algorithme de descente de gradient, maintient deux moments
exponentiellement décroissants pour les gradients, ainsi qu'une composante de biais
correctif.
ADAM est réputé pour sa capacité à converger rapidement, en particulier dans des cas
où les gradients peuvent être très variables ou bruités.
Il adapte automatiquement le taux d'apprentissage pour chaque paramètre du réseau,
ce qui permet d'éviter les problèmes liés à la mise à l'échelle manuelle du taux
d'apprentissage.
Il est souvent plus rapide à converger que le SGD sur de nombreux problèmes.
Conclusion:
En examinant les résultats que nous avons obtenus, il semble qu'ADAM converge plus
rapidement que SGD pour notre architecture de réseau de neurones spécifique sur le
jeu de données considéré. Les taux de reconnaissance (accuracy) obtenus sur
l'ensemble de test sont similaires entre les deux algorithmes pour des configurations
similaires (même jeu de données, taille de lot (batch size), taux d'apprentissage).
Cependant, ADAM converge plus rapidement en termes d'époques nécessaires pour
atteindre un certain niveau de performance (précision), comme indiqué par les
meilleures époques. De plus, ADAM semble moins dépendant du taux d'apprentissage
initial choisi, car il est capable de s'adapter automatiquement.

En conclusion, sur la base des résultats que nous avons obtenus, ADAM semble être
une meilleure option que SGD en termes de vitesse de convergence et de robustesse
par rapport au choix du taux d'apprentissage pour notre tâche spécifique de
classification
 4- Mettre en évidence l’influence de l’architecture et du nombre de paramètres
Pour l’architecture MLP comportant 3 couches 512 – 128 – 10 activation nn.ReLU()
Paramètres ADAM: un batch de 64, learning_rate de 1e-3, 20 époques on a :

Pour l’architecture MLP comportant 4 couches 512 – 256 – 128 – 10 activation

nn.ReLU() de paramètres ADAM: un batch de 64, learning_rate de 1e-3, 20 époques,
on commence par modifier le code python comme suit :

Dans le code ci-dessus, on ajoute une couche à notre modèle de base.

On obtient les résultats suivants :
Pour l’architecture MLP comportant 2 couches 256 – 10 activation nn.ReLU()
Paramètres ADAM: un batch de 64, learning_rate de 1e-3, 20 époques

En analysant les performances des architectures MLP avec différentes configurations,

nous pouvons mettre en évidence plusieurs observations :

Influence de l'architecture :

L'architecture MLP comportant 3 couches (512-128-10) nous a donné un taux de

reconnaissance en test de 97,74% avec un nombre de paramètres libres de 468 874.
L'architecture MLP comportant 4 couches (512-256-128-10) a obtenu un taux de
reconnaissance en test légèrement inférieur de 97,57% avec un nombre de
paramètres libres plus élevé, soit 567 434.
L'architecture MLP comportant 2 couches (256-10) nous a donné un taux de
reconnaissance en test de 97,69% avec un nombre de paramètres libres plus faible,
soit 203 530.

Nombre de paramètres :

Nous observons une corrélation entre le nombre de paramètres libres et la

performance du modèle. En général, un nombre plus élevé de paramètres libres nous
donne plus de flexibilité pour apprendre des motifs complexes dans les données
d'entraînement. Cependant, cela peut aussi augmenter le risque de surapprentissage.
L'architecture avec le plus grand nombre de paramètres (4 couches) n'a pas
nécessairement donné les meilleures performances en test. Cela suggère que
l'augmentation du nombre de paramètres ne garantit pas toujours une amélioration de
la performance du modèle.

Conclusion :

Les résultats indiquent qu'il y a un compromis entre la complexité de l'architecture

(exprimée par le nombre de couches et le nombre de neurones par couche) et notre
capacité à généraliser sur des données non vues (performance en test).
Une architecture plus complexe n'entraîne pas toujours une amélioration des
performances, et peut même conduire à du surapprentissage dans certains cas.
Il est important de trouver un équilibre entre la complexité du modèle et sa capacité à
généraliser sur de nouvelles données. Cela peut nécessiter une exploration
approfondie des hyperparamètres, y compris le nombre de couches, le nombre de
neurones par couche, le taux d'apprentissage, etc.
Dans ce contexte, l'architecture MLP comportant 3 couches semble offrir un bon
compromis entre performance et complexité, avec un taux de reconnaissance en test
élevé tout en ayant un nombre de paramètres relativement modéré.