Tutoriel TensorBoard : Visualisation de graphes TensorFlow

Qu'est-ce que TensorBoard ?

TensorBoard est l'interface utilisée pour visualiser le graphe et d'autres outils permettant de comprendre, de déboguer et d'optimiser le modèle. C'est un outil qui fournit des mesures et des visualisations pour un flux de travail d'apprentissage automatique. Il aide track métriques telles que la perte et la précision, visualisent le graphe du modèle et projettent les plongements dans des espaces de dimension inférieure.

TensorBoard est livré avec TensorFlow et fonctionne comme un petit serveur web local qui lit les fichiers d'événements qu'un travail d'entraînement écrit sur le disque.

Exemple de visualisation de graphes TensorFlow à l'aide de TensorBoard

L'image ci-dessous provient du graphique TensorBoard que vous générerez dans ce tutoriel. Il s'agit du panneau principal :

Dans l'image ci-dessous, vous pouvez voir le panneau de visualisation graphique TensorBoard. Le panneau contient différents onglets, liés au niveau d'informations que vous ajoutez lorsque vous exécutez le modèle.

• Scalaires : Afficher différentes informations utiles pendant l'entraînement du modèle
• Graphes: Afficher le modèle
• Histogramme : Afficher les poids sous forme d'histogramme
• Distribution: Afficher la répartition du poids
• Projecteur: Présentez l'analyse en composantes principales et l'algorithme T-SNE. Technique utilisée pour la réduction de dimensionnalité.

Dans ce tutoriel TensorBoard, vous entraînerez un modèle simple. l'apprentissage en profondeur Le modèle, et le graphique qu'il produit, se lit de bas en haut.

Le graphique permet de comprendre le fonctionnement du modèle. Les badges numérotés dans la capture d'écran ci-dessous indiquent ces quatre étapes :

1. Mettez les données en file d'attente dans le modèle : envoyez une quantité de données égale à la taille du lot vers le modèle, c'est-à-dire le nombre de flux de données après chaque itération.
2. Alimenter les données vers les Tensors
3. Former le modèle
4. Afficher le nombre de lots pendant la formation. Enregistrez le modèle sur le disque.

L'idée de base de TensorBoard est qu'un réseau neuronal peut se comporter comme une boîte noire, et qu'il faut un outil pour en explorer le fonctionnement interne. On peut comparer TensorBoard à une lampe torche permettant de plonger au cœur du réseau.

Il aide à comprendre les dépendances entre les opérations, la façon dont les poids sont calculés, affiche la fonction de perte et bien d'autres informations utiles. Lorsque vous rassemblez toutes ces informations, vous disposez d’un excellent outil pour déboguer et trouver comment améliorer le modèle.

Pour vous donner une idée de l'utilité du graphique TensorBoard, regardez les deux courbes de perte ci-dessous :

Un réseau de neurones détermine comment connecter les différents neurones et le nombre de couches nécessaires avant que le modèle puisse prédire un résultat. Une fois l'architecture définie, il faut non seulement entraîner le modèle, mais aussi une métrique qui mesure la précision de la prédiction. Cette métrique est appelée fonction de perte, et l'objectif est de la minimiser, ce qui signifie simplement que le modèle commet moins d'erreurs.

Chaque algorithme d'apprentissage répète le calcul de nombreuses fois jusqu'à ce que la perte se stabilise. Minimiser la perte nécessite également un taux d'apprentissage, qui correspond à la vitesse à laquelle le modèle apprend. Si ce taux est trop élevé, le modèle n'a jamais le temps d'apprendre : c'est ce qu'illustre le graphique de gauche, où la courbe oscille car le modèle procède par tâtonnements. Le graphique de droite montre la perte qui diminue au fil des itérations jusqu'à ce que la courbe s'aplatisse, indiquant ainsi que le modèle a trouvé une solution.

TensorBoard est un outil précieux pour visualiser ces indicateurs et identifier les problèmes potentiels. Un réseau neuronal peut mettre des heures, voire des semaines, à trouver une solution, et TensorBoard actualise les indicateurs pendant l'exécution. Vous n'avez donc pas besoin d'attendre la fin de l'entraînement pour vérifier son bon déroulement : ouvrez TensorBoard, suivez l'avancement de l'entraînement et apportez les modifications nécessaires.

Comment utiliser TensorBoard ?

Dans cette section, vous apprendrez comment ouvrir TensorBoard depuis le terminal. macOS et à partir de la ligne de commande sur WindowsL'accent est mis ici sur l'outil plutôt que sur le modèle, c'est pourquoi le code d'entraînement est volontairement court.

Vous devez tout d'abord importer les bibliothèques que vous utiliserez pendant la formation.

## Import the library
import tensorflow as tf
import numpy as np

Vous créez les données. Il s'agit d'un tableau de 10 000 lignes et 5 colonnes.

X_train = (np.random.sample((10000,5)))
y_train =  (np.random.sample((10000,1)))
X_train.shape

Sortie

(10000, 5)

Le code ci-dessous transforme les données et crée le modèle.

Notez que le taux d'apprentissage est égal à 0.1. Si vous augmentez ce taux, le modèle ne trouvera pas de solution. C'est ce qui s'est produit à gauche de l'image ci-dessus.

Cet exemple utilise un estimateur TensorFlow, l'API de haut niveau qui encapsule les calculs mathématiques. Les estimateurs appartiennent à l'API TensorFlow 1.x ; par conséquent, les deux extraits de code ci-dessous s'exécutent sous une installation 1.x ou via… tf.compat.v1 espace de noms.

Pour créer les fichiers journaux, vous devez spécifier le chemin d'accès. Cela se fait avec l'argument. model_dir.

Dans l'exemple TensorBoard ci-dessous, vous stockez le modèle dans le répertoire de travail, c'est-à-dire là où vous stockez le notebook ou Python Dans ce chemin, TensorFlow créera un dossier appelé train contenant un sous-dossier nommé linreg.

feature_columns = [
      tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
DNN_reg = tf.estimator.DNNRegressor(feature_columns=feature_columns,
# Indicate where to store the log file    
     model_dir='train/linreg',    
     hidden_units=[500, 300],    
     optimizer=tf.train.ProximalAdagradOptimizer(      
          learning_rate=0.1,      
          l1_regularization_strength=0.001    
      )
)

Sortie

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {&#x27;_model_dir': 'train/linreg', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1818e63828>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

La dernière étape de cet exemple de visualisation de graphes avec TensorFlow consiste à entraîner le modèle. Durant l'entraînement, TensorFlow enregistre les informations dans le répertoire du modèle.

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(    
     x={"x": X_train},    
     y=y_train, shuffle=False,num_epochs=None)
DNN_reg.train(train_input,steps=3000)

Sortie

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train/linreg/model.ckpt.
INFO:tensorflow:loss = 40.060104, step = 1
INFO:tensorflow:global_step/sec: 197.061
INFO:tensorflow:loss = 10.62989, step = 101 (0.508 sec)
INFO:tensorflow:global_step/sec: 172.487
INFO:tensorflow:loss = 11.255318, step = 201 (0.584 sec)
INFO:tensorflow:global_step/sec: 193.295
INFO:tensorflow:loss = 10.604872, step = 301 (0.513 sec)
INFO:tensorflow:global_step/sec: 175.378
INFO:tensorflow:loss = 10.090343, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 209.737
INFO:tensorflow:loss = 10.057928, step = 501 (0.476 sec)
INFO:tensorflow:global_step/sec: 171.646
INFO:tensorflow:loss = 10.460144, step = 601 (0.583 sec)
INFO:tensorflow:global_step/sec: 192.269
INFO:tensorflow:loss = 10.529617, step = 701 (0.519 sec)
INFO:tensorflow:global_step/sec: 198.264
INFO:tensorflow:loss = 9.100082, step = 801 (0.504 sec)
INFO:tensorflow:global_step/sec: 226.842
INFO:tensorflow:loss = 10.485607, step = 901 (0.441 sec)
INFO:tensorflow:global_step/sec: 152.929
INFO:tensorflow:loss = 10.052481, step = 1001 (0.655 sec)
INFO:tensorflow:global_step/sec: 166.745
INFO:tensorflow:loss = 11.320213, step = 1101 (0.600 sec)
INFO:tensorflow:global_step/sec: 161.854
INFO:tensorflow:loss = 9.603306, step = 1201 (0.619 sec)
INFO:tensorflow:global_step/sec: 179.074
INFO:tensorflow:loss = 11.110269, step = 1301 (0.556 sec)
INFO:tensorflow:global_step/sec: 202.776
INFO:tensorflow:loss = 11.929443, step = 1401 (0.494 sec)
INFO:tensorflow:global_step/sec: 144.161
INFO:tensorflow:loss = 11.951693, step = 1501 (0.694 sec)
INFO:tensorflow:global_step/sec: 154.144
INFO:tensorflow:loss = 8.620987, step = 1601 (0.649 sec)
INFO:tensorflow:global_step/sec: 151.094
INFO:tensorflow:loss = 10.666125, step = 1701 (0.663 sec)
INFO:tensorflow:global_step/sec: 193.644
INFO:tensorflow:loss = 11.0349865, step = 1801 (0.516 sec)
INFO:tensorflow:global_step/sec: 189.707
INFO:tensorflow:loss = 9.860596, step = 1901 (0.526 sec)
INFO:tensorflow:global_step/sec: 176.423
INFO:tensorflow:loss = 10.695, step = 2001 (0.567 sec)
INFO:tensorflow:global_step/sec: 213.066
INFO:tensorflow:loss = 10.426752, step = 2101 (0.471 sec)
INFO:tensorflow:global_step/sec: 220.975
INFO:tensorflow:loss = 10.594796, step = 2201 (0.452 sec)
INFO:tensorflow:global_step/sec: 219.289
INFO:tensorflow:loss = 10.4212265, step = 2301 (0.456 sec)
INFO:tensorflow:global_step/sec: 215.123
INFO:tensorflow:loss = 9.668612, step = 2401 (0.465 sec)
INFO:tensorflow:global_step/sec: 175.65
INFO:tensorflow:loss = 10.009649, step = 2501 (0.569 sec)
INFO:tensorflow:global_step/sec: 206.962
INFO:tensorflow:loss = 10.477722, step = 2601 (0.483 sec)
INFO:tensorflow:global_step/sec: 229.627
INFO:tensorflow:loss = 9.877638, step = 2701 (0.435 sec)
INFO:tensorflow:global_step/sec: 195.792
INFO:tensorflow:loss = 10.274586, step = 2801 (0.512 sec)
INFO:tensorflow:global_step/sec: 176.803
INFO:tensorflow:loss = 10.061047, step = 2901 (0.566 sec)
INFO:tensorflow:Saving checkpoints for 3000 into train/linreg/model.ckpt.
INFO:tensorflow:Loss for final step: 10.73032.

<tensorflow.python.estimator.canned.dnn.DNNRegressor at 0x1818e63630>

Sur TensorFlow 2, le même travail est effectué par le rappel Keras TensorBoard, qui écrit le graphe et les métriques par époque sans aucun code d'estimation :

logdir = "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model.fit(train_images, train_labels, epochs=5,
          callbacks=[tensorboard_callback])

Une fois l'exécution terminée, le répertoire journal contient un fichier de point de contrôle, un graph.pbtxt fichier et un ou plusieurs events.out.tfevents fichiers — exactement ce que TensorBoard lit.

Pour macOS des opportunités

La capture d'écran ci-dessous montre le nouveau dossier train/linreg créé dans le répertoire de travail.

Pour Windows des opportunités

On Windows Les mêmes fichiers apparaissent sous le chemin que vous avez indiqué à model_dir, comme indiqué dans la barre d'adresse.

Le même format de fichier d'événements est produit par PyTorchLe tableau de bord n'est donc pas limité aux exécutions TensorFlow.

Maintenant que les événements de journalisation sont enregistrés, vous pouvez ouvrir TensorBoard. TensorBoard est accessible par défaut sur le port 6006 (Jupyter utilise le port 8888). Utilisez le Terminal sur macOS ou l'invite Anaconda sur Windows.

Pour macOS des opportunités

# Different for you
cd /Users/Guru99/tuto_TF
source activate hello-tf!

Le bloc-notes est stocké dans le répertoire /Users/Guru99/tuto_TF

Pour Windows des opportunités

cd C:\Users\Admin\Anaconda3
activate hello-tf

Le notebook est stocké dans le chemin C:\Users\Admin\Anaconda3

Pour lancer TensorBoard, exécutez la commande suivante depuis ce répertoire.

Pour macOS des opportunités

tensorboard --logdir=./train/linreg

Pour Windows des opportunités

tensorboard --logdir=.\train\linreg

TensorBoard est alors accessible à l'adresse http://localhost:6006

Le tensorboard dev La sous-commande ne fonctionne plus : le service hébergé TensorBoard.dev a été arrêté le 1er janvier 2024. L’utilisation locale n’est pas affectée.

Sur certaines machines, la console affiche le nom d'hôte au lieu de localhost, comme dans l'invite Anaconda ci-dessous. Les deux adresses ouvrent le même tableau de bord.

Copiez et collez l'adresse dans votre navigateur préféré. Le tableau de bord Scalars devrait s'afficher ci-dessous.

Si vous voyez plutôt quelque chose comme ceci :

Cela signifie que TensorBoard ne trouve pas le fichier journal. Assurez-vous de bien l'indiquer. cd Vérifiez que vous êtes sur la bonne voie ou revérifiez que l'événement de journalisation a bien été créé. Si ce n'est pas le cas, relancez le code d'entraînement.

Pour fermer TensorBoard, appuyez sur CTRL+C dans la fenêtre du terminal.

Conseil : vérifiez votre invite de commande Anaconda pour connaître le répertoire de travail actuel.

Dans la capture d'écran ci-dessus, l'invite de commande se trouve à l'emplacement C:\Users\Admin ; le fichier journal devrait donc être créé dans ce dossier.

FAQ