Cette page a été traduite par l'API Cloud Translation.
Switch to English

Examen du graphe TensorFlow

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub

Aperçu

Le tableau de bord Graphiques de TensorBoard est un outil puissant pour examiner votre modèle TensorFlow. Vous pouvez afficher rapidement 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 manière 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 graphique et de les visualiser dans le tableau de bord Graphiques de TensorBoard. Vous allez définir et entraîner un modèle séquentiel Keras simple pour l'ensemble de données Fashion-MNIST et apprendre à consigner et à examiner vos graphiques de modèle. Vous utiliserez également une API de traçage pour générer des données graphiques pour les fonctions créées à l'aide de la nouvelle annotation tf.function .

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 simple modèle séquentiel à 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

Former le modèle et enregistrer les données

Avant l'entraînement, définissez le rappel Keras TensorBoard , en spécifiant le répertoire du journal. En transmettant 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 au niveau des opérations

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

Par défaut, TensorBoard affiche le graphique de niveau opérationnel . (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 pour zoomer et dézoomer
  • Faites glisser pour faire un panoramique
  • Un double-clic active l' extension du nœud (un nœud peut être un conteneur pour d'autres nœuds)

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

Graphique conceptuel

En plus du graphique d'exécution, TensorBoard affiche également un graphique conceptuel . Ceci n'est qu'une vue du modèle Keras. 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 réduit. 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 l'annotation tf.function pour «autographier» , c'est-à-dire transformer une fonction de calcul Python en un graphe TensorFlow haute performance. Dans ces situations, vous utilisez l' API TensorFlow Summary Trace pour consigner les fonctions autographiées à des fins de visualisation dans TensorBoard.

Pour utiliser l'API Summary Trace:

  • Définir et annoter une fonction avec tf.function
  • Utilisez tf.summary.trace_on() juste avant votre site d'appel de fonction.
  • Ajoutez des informations de profil (mémoire, temps CPU) au graphique en passant profiler=True
  • Avec un écrivain de fichier récapitulatif, appelez 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.