Tutoriel TensorBoard : Visualisation de graphes TensorFlow

Par : Evelyn Clarke Evelyn Clarke
Hours Le kit de préparation mis à jour

⚡ Résumé intelligent

TensorBoard est l'interface visuelle des entraînements TensorFlow, permettant de tracer les courbes de perte, les graphiques du modèle, les histogrammes de poids et les plongements lexicaux. Ce tutoriel explique comment générer des fichiers d'événements avec un estimateur, puis ouvrir le tableau de bord sur le port 6006.

  • (I.e. Cinq tableaux de bord : Les scalaires, les graphiques, les distributions, les histogrammes et le projecteur lisent chacun un type de résumé différent.
  • ☑️ Répertoire des journaux : L'argument model_dir détermine l'emplacement où TensorFlow écrit les fichiers events.out.tfevents.
  • ✅ Commande de lancement : Exécutez la commande tensorboard –logdir=PATH, puis ouvrez http://localhost:6006 dans n'importe quel navigateur.
  • 🧪 Taux d'apprentissage : Une courbe de perte irrégulière signale un taux trop élevé pour que le modèle converge.
  • ️ TensorFlow 2 : Le rappel Keras TensorBoard remplace la journalisation de l'estimateur présentée dans l'exemple original.
  • ⚠️ Dépannage: Un tableau de bord vide signifie presque toujours que le chemin d'accès au répertoire des journaux ne correspond pas à l'exécution de l'entraînement.
En savoir plus

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 :

Tableau de bord TensorBoard Scalars affichant la courbe de perte moyenne du régresseur DNN entraîné

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.

Barre de navigation de TensorBoard avec les onglets Scalaires, Graphiques, Distributions, Histogrammes et Projecteur

  • 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.

Graphique TensorFlow dans TensorBoard avec des nœuds numérotés pour la file d'attente d'entrée, le bloc DNN et l'opération de sauvegarde

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 :

Deux courbes de perte TensorBoard côte à côte, comparant un modèle qui n'apprend pas avec un modèle qui converge.

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.

Ne manquez pas:

Pour macOS des opportunités

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

macOS Liste des fichiers montrant les dossiers de journalisation train et linreg avec les fichiers checkpoint, events et graph.pbtxt

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.

Windows Vue explorateur du dossier train linreg contenant les fichiers d'événements et de points de contrôle TensorFlow

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

chaise Ce qu'il contrôle
--logdir Répertoire contenant les fichiers d'événements. C'est le seul paramètre requis.
--port Port à utiliser. Par défaut : 6006 ; modifiez-le si une session précédente utilise encore ce port.
--bind_all Servir sur chaque interface réseau. Par défaut, TensorBoard se lie uniquement à localhost ; l’accès distant nécessite donc cette option, et elle ne peut être combinée avec… --host.
--reload_interval Fréquence, en secondes, de réanalyse du répertoire journal pour détecter de nouvelles données.
--logdir_spec Solution de repli héritée acceptant plusieurs chemins séparés par des virgules ; --logdir ne prend plus en charge ce formulaire.

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.

L'invite de commande Anaconda exécute la commande tensorboard et affiche l'adresse du serveur sur le port 6006.

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

Le tableau de bord TensorBoard Scalars s'ouvre correctement dans un navigateur une fois le répertoire des journaux chargé.

Si vous voyez plutôt quelque chose comme ceci :

Page d'erreur TensorBoard : Aucun fichier de définition de graphe n'a été trouvé.

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.

Invite de commande Anaconda affichant l'environnement hello-tf actif et 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

Une exécution terminée génère un index de point de contrôle, un ou plusieurs fichiers model.ckpt, un fichier graph.pbtxt et au moins un fichier events.out.tfevents. TensorBoard ne lit que les fichiers d'événements ; les points de contrôle permettent de reprendre l'entraînement là où il s'est arrêté.

Oui. PyTorch navires un résuméWriter Le format des fichiers d'événements est identique, la commande `tensorboard --logdir` permet donc d'afficher le tableau de bord sans problème. Rien ne change côté serveur : seule la bibliothèque qui génère les résumés diffère.

Non. Le service hébergé a fermé le 1er janvier 2024 et la sous-commande tensorboard dev renvoie désormais une erreur. Partagez vos résultats en exécutant TensorBoard dans un notebook, par exemple : Google Colab, ou en exportant les graphiques au format CSV ou JSON.

Attribuez à chaque exécution son propre sous-dossier sous un dossier parent commun, puis spécifiez le chemin du dossier parent avec l'option `--logdir`. Chaque sous-dossier apparaît comme une exécution distincte dans le panneau de gauche, et les courbes sont tracées sur les mêmes axes, chacune étant associée à une case à cocher.

Le graphique au niveau des opérations est la vue par défaut et illustre la manière dont TensorFlow interprète le programme, selon une approche ascendante. La sélection de l'étiquette Keras permet d'afficher le graphique conceptuel, qui présente uniquement les couches du modèle et facilite la vérification par rapport à votre conception.

Les analyses automatisées génèrent des dizaines d'exécutions simultanément ; le tableau de bord devient alors un outil de comparaison plutôt qu'un outil de suivi d'exécution unique. Le plugin HParams enregistre chaque configuration ainsi que ses métriques, ce qui permet de trier les essais au lieu de lire les courbes une par une.

Copilote GitHub Générez rapidement le code de rappel et le modèle de résumé. Considérez le résultat comme une ébauche : il mélange souvent les API TensorFlow 1.x et 2.x ; vérifiez donc chaque nom par rapport à la documentation actuelle avant d’exécuter le code.

Soit aucun fichier d'événements n'a été créé, soit le chemin d'accès passé à –logdir ne correspond pas à celui utilisé par la tâche d'entraînement. Vérifiez qu'un fichier events.out.tfevents existe dans ce dossier, et sur Windows Démarrez TensorBoard depuis la même lettre de lecteur.

Résumez cet article avec :