Nom : Gleyze

Master 1 SD, SIME Prénom : Alexandre

Master 2 SIME
Apprentissage profond

Séance de TP 3
Réseaux Convolutifs – GPU et Tensorboard

1- Comparer les temps d’exécution sur CPU et GPU pour l’apprentissage d’un
MLP ayant la meilleure configuration obtenue lors de la séance précédente,
relever le nombre de batch traités par seconde.
Pour cette question,

On se place sur le GPU :

À l’aide du module time de python nous pouvons relever le temps d’exécution de

notre modele avec le code suivant :
Après execution du code modifié on obtient :

On passe maintenant en mode CPU :

Après une nouvelle exécution du code, nous obtenons :

Pour comparer les temps d'exécution sur CPU et GPU pour l'apprentissage d'un
MLP (Multilayer Perceptron) avec la meilleure configuration obtenue, nous devons
examiner les informations fournies dans les résultats obtenus.

Sur GPU :

- Temps d'exécution total pour l'apprentissage : 29 secondes.

- Nombre de batches traités par seconde : 28.43.

Sur CPU :
 - Temps d'exécution total pour l'apprentissage : 74 secondes.
- Nombre de batches traités par seconde : 11.39.

En comparant les deux :

Le temps d'exécution sur GPU est nettement plus rapide que sur CPU, avec un
temps total de 29 secondes contre 74 secondes sur CPU.
Le nombre de batches traités par seconde est également beaucoup plus élevé sur
GPU que sur CPU, avec 28.43 batches/seconde sur GPU contre 11.39
batches/seconde sur CPU.

Analyse :

Le temps d'exécution sur le GPU est environ deux fois plus rapide que sur le CPU.
Le nombre de batches traités par seconde sur le GPU est également
significativement plus élevé que sur le CPU, ce qui indique une meilleure efficacité
de traitement par lot sur le GPU.

En conclusion, l'utilisation du GPU pour l'entraînement du MLP offre des

performances supérieures en termes de temps d'exécution et de débit de traitement
par lot par rapport au CPU. Cela est cohérent avec les avantages bien connus du
GPU pour les tâches d'apprentissage profond, en raison de sa capacité à paralléliser
efficacement les calculs.
 2- Quelles sont les performances du meilleur MLP sur la base FashionMNIST.
Restituer vos expériences avec des exports de TensorBoard.
On passe en fashion :

Après l’exécution du code avec le GPU nous obtenons :

À partir des résultats fournis, voici ce que nous pouvons conclure sur les
performances du meilleur MLP sur la base de données FashionMNIST :

- Meilleure époque: La meilleure performance du modèle a été observée à

l'époque 4, où il a atteint sa meilleure validation de perte (loss) de 0.966.

- Taux de reconnaissance en Test: Le modèle a obtenu un taux de

reconnaissance de 6181 sur 10000 lors du test. Cela signifie que sur un ensemble
de 10 000 exemples de test, le modèle a correctement classé 6181 exemples.

- Nombre de paramètres libres: Le modèle MLP utilise un total de 468 874

paramètres libres. Cela indique la complexité du modèle et sa capacité à s'adapter
aux données.

- Vitesse de Traitement (Processing Speed): Le modèle a traité les données à un

taux d'environ 28.96 batches par seconde pendant l'apprentissage.
En résumé, le meilleur MLP a montré une performance raisonnable sur l'ensemble
de données FashionMNIST, avec une perte de validation assez basse et un taux de
reconnaissance décent sur l'ensemble de test.

TensorBoard nous offre la possibilité de visualiser les diverses données enregistrées

pendant le processus d'entraînement.
Initialement, nous examinons dans la section "scalars" les courbes de perte pour
l'entraînement et la validation ci-dessous.

Ensuite, dans la section "images", nous observons les échantillons d'images du jeu
de données qui ont été utilisés pour l'entraînement.
Ensuite, dans l'onglet "graphs", nous examinons le graphique représentant
l'architecture du modèle, tel que présenté ci-dessous. Les dimensions d'entrée des
dernières couches du modèle sont 64*10.

Pour conclure, dans l'onglet "projector", nous examinons la projection des données
dans la représentation apprise par le modèle. Cette projection affiche les différents
échantillons du jeu de données utilisés pour l'entraînement du modèle, positionnés
dans un espace à trois dimensions. Les échantillons sont regroupés selon leur classe
dans cet espace ; ainsi, les chaussures sont regroupées ensemble, tout comme les
sacs, les pantalons et les autres éléments du jeu de données.
Pour la suite de cette étude, nous allons réexécuter notre notebook, mais cette fois-ci
en utilisant le processeur (CPU) comme environnement d'exécution.

Nous obtenons les résultats suivant :

Comme nous l'avions constaté lors du test en GPU précédent, les résultats de
l'apprentissage sont pratiquement inchangés d'un processeur à l'autre. Ce qui reste
crucial à retenir, c'est la rapidité de travail offerte par l'utilisation du GPU.
 3- Envisager différentes architectures de réseaux convolutifs pour atteindre les
meilleures performances possibles sur la base Fashion. Restituer les
architectures utilisées les courbes d’apprentissage et les performances grâce
à des exports de TensorBoard.
Pour ce prochain exercice, nous allons expérimenter différentes architectures en
ajustant certains paramètres de notre modèle afin d'améliorer ses performances.
Nous nous baserons sur les expériences précédentes du TP en modifiant les
paramètres qui ont contribué à maximiser l'apprentissage. Plus spécifiquement, nous
ajusterons les tailles de batch, le nombre d'époques et les fonctions d'activation
(Sigmoïde et ReLU). Nous conserverons les paramètres tels que l'algorithme
d'optimisation (ADAM, comme déterminé dans le TP précédent) et le taux
d'apprentissage (optimal selon les résultats du TP précédent), ainsi que
l'environnement d'exécution (GPU, le plus rapide).

Nous avons adapté l'affichage des résultats de notre code pour qu'il puisse présenter
les modifications apportées à chaque nouvelle architecture, ce qui nous fera gagner
du temps lors de nos expérimentations. Nous exporterons également chaque
nouvelle architecture dans TensorBoard.

→ Architecture 1 :

Nombre d'époques = 20
Taille de batch : 128
Taux d'apprentissage = 1e-2
Fonction d'activation : nn.Sigmoid
Algorithme d'optimisation : ADAM
Une note importante à retenir avant de poursuivre : dans la figure ci-dessus, nous
visualisons deux courbes de perte. La première courbe (orange) correspond à celle
déterminée lors de l'exercice précédent. À chaque nouvelle expérience, les courbes
des expériences précédentes sont conservées dans le but de comparer chaque
nouvelle architecture.
→ Architecture 2 :

Nombre d'époques = 60
Taille de batch : 128
Taux d'apprentissage = 1-2
Fonction d'activation : nn.RELU
Algorithme d'optimisation : ADAM

Nous allons maintenant aborder un élément important de TensorBoard qui s'avère

très utile pour nos études, illustré par la figure ci-dessous.
Cette figure présente le déroulement de nos différentes expériences depuis le
chargement de ce TP sur Colab. Le tableau répertorie chaque expérience en
fonction des changements d'hyperparamètres et des métriques observées.

Comme on peut le constater, un certain nombre d'expériences ne sont pas

visualisées dans ce compte-rendu, car nous les avons jugées non pertinentes ou
redondantes.

Ces outils démontrent la puissance de TensorBoard et l'importance de l'utiliser pour

nos futures expériences en apprentissage. Ils nous permettent de comparer nos
résultats antérieurs et de déterminer les meilleures architectures.