Évaluer son Deep Learning avec des graphiques élégants – TensorBoard

Aujourd’hui nous allons voir comment évaluer nos modèles de Deep Learning avec des graphiques élégants grâce à TensorBoard !

Dans les derniers articles, on utilisait matplotlib pour afficher nos métriques et évaluer les performances de notre modèle. Cette librairie est pratique car rapide a utilisé et répond efficacement a nos besoin.

Dans cet article, on va voir comment aller encore plus loin dans cette analyse et, en plus de cela, afficher des graphiques esthétique pour analyser l’apprentissage de notre modèle.

Afficher TensorBoard

Sur Terminal

Pour analyser les performances de notre modèle il faut d’abord enregistrer ses résultats durant son entraînement.

Pour cela, nous allons premièrement créer un dossier my_log_dir pour regrouper les enregistrements des résultats.

mkdir my_log_dir

Ensuite, on peut coder notre programme de Deep Learning en Python (si vous n’en avez pas déjà, prenez celui expliqué dans cet article).

Avant l’entraînement de notre modèle avec la fonction fit() on créer un callback, littéralement rappel ou enregistrement. En fait, cet fonction permet de garder en mémoire les résultats de notre modèle à chaque epoch en les enregistrant dans notre dossier précédemment créé.

import keras

callbacks = [keras.callbacks.TensorBoard(
 log_dir='my_log_dir',
 histogram_freq=1,
 embeddings_freq=1
)]

Puis, on peut entraîner notre modèle en y insérant les callbacks !

history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=32,
 validation_split=0.2,
 callbacks=callbacks)

Une fois notre programme entièrement codé, on l’exécute sur le terminal.

python programme_DeepLearning.py

Lors de l’exécution de notre programme, le modèle de Deep Learning s’entraîne et donc enregistre chacun des résultats dans le dossier my_log_dir. On active ensuite TensorBoard qui va utiliser les informations de notre dossier !

tensorboard --logdir=my_log_dir

Finalement on peut accéder à TensorBoard en allant sur l’adresse web affichée sur le terminal (http://localhost:6006).

Sur Google Colab / Notebook

Sur Google Colab le processus est similaire !

Premièrement on initialise TensorBoard :

%load_ext tensorboard

Comme sur le terminal, on créé un fichier pour enregistrer les résultats du modèle pendant son apprentissage (aussi appelés logs).

import datetime, os

logdir = os.path.join("logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))

Puis, on code notre programme de Deep Learning et avant de lancer l’entrainement, on créé une variable callbacks qui va garder en mémoire les résultats de notre modèle à chaque epoch en les enregistrant dans notre dossier précédemment créé.

import keras

callbacks = keras.callbacks.TensorBoard(logdir, histogram_freq=1, embeddings_freq=1)

Ensuite on entraîne notre modèle en intégrant les callbacks :

history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=32,
 validation_split=0.2,
 callbacks=callbacks)

Et voilà ! Il ne nous reste plus qu’à lancer TensorBoard pour évaluer notre modèle !

%tensorboard --logdir logs

Ici, pas besoin de visiter une adresse web, TensorBoard s’affiche directement dans le notebook !

Analyser les graphiques

Une fois que TensorBoard est activé, nous pouvons analyser de nombreuses métriques. Nous allons les détailler une à une.

Scalars

Scalars nous permet de voir la précision (accuracy) et l’erreur (loss) de notre modèle… les métriques classiques qu’on ne présente plus ! L’objectif principal de l’entrainement est de maximiser l’une et de minimiser l’autre.

Nous avons :

• En orange, les résultats sur les données d’entraînement
• En bleu, les résultats sur les données de validation

On peut même télécharger les graphiques en activant Show data download links en haut à gauche puis en cliquant sur les liens de téléchargement !

Graphs

La partie Graph de TensorBoard permet d’analyser la structure de notre modèle de Deep Learning.

On peut afficher le graphique opérationnel de la structure de votre modèle. Ce graphique est assez technique car il représente les tenseurs et opérations mathématiques réalisé pendant l’apprentissage.

Ces différents liens et opérations sont représentés par des nœuds. On peut voir les métadonnées d’un nœud en cliquant dessus (entrées, sorties et autres détails).

Comme on peut le voir, il se passe beaucoup plus de choses pendant l’apprentissage qu’on ne le pense de prime abord.

Le modèle que l’on construit peut sembler simple lorsqu’on utilise Keras mais derrière les rideaux se cache une structure assez complexe pour réaliser le Deep Learning. Une grande partie de cette structure est liée au processus de descente de gradient que l’on a abordé dans cet article.

Sinon, on peut aussi afficher le graphique conceptuel qui, lui, est beaucoup plus simple. Il affiche les couches de notre modèle de Deep Learning. Il suffit de sélectionner keras dans la liste déroulante Tag.

Histograms

Avec les histogrammes on peut voir en détail l’évolution des poids et des biais durant l’apprentissage de notre modèle.

Un histogramme comporte trois dimensions : la profondeur (dimension y) correspond aux epoch, plus les valeurs sont profondes (et sombres), plus elles sont anciennes. La dimension z est la densité des valeurs représentées dans les vecteurs de la dimension x. Plus la valeur sur l’axe z est élevée plus le vecteur x contient des données de cette valeur spécifique.

Distributions

La Distribution est une autre approche pour visualiser l’évolution des données dans le temps.

On peut voir sur cette image que la distribution est une vue de haut de l’histogramme avec y en abscisse et x en ordonnée.

TensorBoard est un excellent moyen de visualiser ce qui passe dans nos modèles de Deep Learning. N’hésitez pas a bidouiller les paramètres pour explorer en détail votre modèle par vous-mêmes !

Pour les plus paresseux, le code pour afficher TensorBoard est disponible à cet adresse sur Github 😉

Photo by :

• Taan Huyn on Unsplash
• Isaac Smith on Unsplash