Examen du graphique TensorFlow

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Aperçu

Le tableau de bord Graphiques de TensorBoard est un outil puissant pour l' examen de votre modèle tensorflow. Vous pouvez rapidement afficher un graphique conceptuel de la structure de votre modèle et vous assurer qu'il correspond à votre conception prévue. Vous pouvez également afficher un graphique au niveau opérationnel pour comprendre comment TensorFlow comprend votre programme. L'examen du graphique de niveau opérationnel peut vous donner un aperçu de la façon de modifier votre modèle. Par exemple, vous pouvez reconcevoir votre modèle si l'entraînement progresse plus lentement que prévu.

Ce didacticiel présente un aperçu rapide de la façon de générer des données de diagnostic de graphique et de les visualiser dans le tableau de bord Graphiques de TensorBoard. Vous définirez et entraînerez un modèle Keras séquentiel simple pour l'ensemble de données Fashion-MNIST et apprendrez à enregistrer et à examiner les graphiques de votre modèle. Vous utiliserez également une API de traçage pour générer des données de graphique pour les fonctions créées à l' aide de la nouvelle tf.function annotation.

Installer

# Load the TensorBoard notebook extension.
%load_ext tensorboard

from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."

TensorFlow version:  2.2.0

import tensorboard
tensorboard.__version__

'2.2.1'

# Clear any logs from previous runs
rm -rf ./logs/

Définir un modèle Keras

Dans cet exemple, le classificateur est un modèle séquentiel simple à quatre couches.

# Define the model.
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'])

Téléchargez et préparez les données d'entraînement.

(train_images, train_labels), _ = keras.datasets.fashion_mnist.load_data()
train_images = train_images / 255.0

Entraîner le modèle et enregistrer les données

Avant la formation, définir le rappel Keras TensorBoard , en spécifiant le répertoire du journal. En passant ce rappel à Model.fit(), vous vous assurez que les données du graphique sont enregistrées pour la visualisation dans TensorBoard.

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

# Train the model.
model.fit(
    train_images,
    train_labels, 
    batch_size=64,
    epochs=5, 
    callbacks=[tensorboard_callback])

Epoch 1/5
938/938 [==============================] - 2s 2ms/step - loss: 0.6955 - accuracy: 0.7618
Epoch 2/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4877 - accuracy: 0.8296
Epoch 3/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4458 - accuracy: 0.8414
Epoch 4/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4246 - accuracy: 0.8476
Epoch 5/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4117 - accuracy: 0.8508
<tensorflow.python.keras.callbacks.History at 0x7f656ecc3fd0>

Graphique de niveau opérationnel

Démarrez TensorBoard et attendez quelques secondes que l'interface utilisateur se charge. Sélectionnez le tableau de bord Graphiques en appuyant sur « Graphiques » en haut.

%tensorboard --logdir logs

Vous pouvez également éventuellement utiliser TensorBoard.dev pour créer une expérience hébergée et partageable.

!tensorboard dev upload \
  --logdir logs \
  --name "Sample op-level graph" \
  --one_shot

Par défaut, TensorBoard affiche le graphique au niveau de l' op. (Sur la gauche, vous pouvez voir la balise "Par défaut" sélectionnée.) Notez que le graphique est inversé ; les données circulent de bas en haut, elles sont donc à l'envers par rapport au code. Cependant, vous pouvez voir que le graphique correspond étroitement à la définition du modèle Keras, avec des arêtes supplémentaires vers d'autres nœuds de calcul.

Les graphiques sont souvent très volumineux, vous pouvez donc manipuler la visualisation du graphique :

  • Faites défiler jusqu'à zoom avant et arrière
  • Faites glisser dans la poêle
  • Un double clic permet de basculer l' expansion de noeud (un nœud peut être un conteneur pour d' autres noeuds)

Vous pouvez également voir les métadonnées en cliquant sur un nœud. Cela vous permet de voir les entrées, les sorties, les formes et d'autres détails.

Graphique conceptuel

En plus du graphe d'exécution, TensorBoard affiche également un graphique conceptuel. Ceci est une vue du modèle Keras uniquement. Cela peut être utile si vous réutilisez un modèle enregistré et que vous souhaitez examiner ou valider sa structure.

Pour voir le graphe conceptuel, sélectionnez la balise « keras ». Pour cet exemple, vous verrez un nœud séquentiel effondré. Double-cliquez sur le nœud pour voir la structure du modèle :


Graphiques de tf.functions

Les exemples jusqu'à présent ont décrit des graphiques de modèles Keras, où les graphiques ont été créés en définissant des couches Keras et en appelant Model.fit().

Vous pouvez rencontrer une situation où vous devez utiliser la tf.function annotation « autographe » , à savoir, transformer, une fonction de calcul Python dans un graphique de tensorflow haute performance. Pour ces situations, vous utilisez tensorflow Résumé API Trace pour connecter les fonctions dédicacé pour la visualisation en TensorBoard.

Pour utiliser l'API de suivi récapitulatif :

  • Définir et annoter une fonction avec tf.function
  • Utilisez tf.summary.trace_on() immédiatement avant que votre site d'appel de fonction.
  • Ajouter des informations de profil (mémoire, temps CPU) au graphique en passant profiler=True
  • Avec un écrivain de fichier Résumé, appel tf.summary.trace_export() pour enregistrer les données du journal

Vous pouvez ensuite utiliser TensorBoard pour voir comment votre fonction se comporte.

# The function to be traced.
@tf.function
def my_func(x, y):
  # A simple hand-rolled layer.
  return tf.nn.relu(tf.matmul(x, y))

# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = 'logs/func/%s' % stamp
writer = tf.summary.create_file_writer(logdir)

# Sample data for your function.
x = tf.random.uniform((3, 3))
y = tf.random.uniform((3, 3))

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True, profiler=True)
# Call only one tf.function when tracing.
z = my_func(x, y)
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)

%tensorboard --logdir logs/func

Vous pouvez maintenant voir la structure de votre fonction telle qu'elle est comprise par TensorBoard. Cliquez sur le bouton radio "Profil" pour voir les statistiques du processeur et de la mémoire.