Un moyen simple de visualiser un graphique TensorFlow dans Jupyter?
La manière officielle de visualiser un graphique TensorFlow est d'utiliser TensorBoard, mais parfois, je souhaite simplement jeter un coup d'œil rapide sur le graphique lorsque je travaille dans Jupyter.
Existe-t-il une solution rapide, idéalement basée sur les outils TensorFlow, ou sur les packages SciPy standard (tels que matplotlib), mais éventuellement sur la base de bibliothèques tierces?
TensorFlow 2.0 Prend désormais en charge les commandes TensorBoardin Jupytervia (par exemple, %tensorboard --logdir logs/train). Voici un lien vers des tutoriels et des exemples.
[MODIFICATIONS 1, 2]
Comme @MiniQuark l'a mentionné dans un commentaire, nous devons d'abord charger l'extension (%load_ext tensorboard.notebook).
Vous trouverez ci-dessous des exemples d'utilisation du mode graphique , @tf.function et tf.keras (in tensorflow==2.0.0-alpha0):
1. Exemple d'utilisation du mode graphique dans TF2 (via tf.compat.v1.disable_eager_execution())
%load_ext tensorboard.notebook
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
from tensorflow.python.ops.array_ops import placeholder
from tensorflow.python.training.gradient_descent import GradientDescentOptimizer
from tensorflow.python.summary.writer.writer import FileWriter
with tf.name_scope('inputs'):
x = placeholder(tf.float32, shape=[None, 2], name='x')
y = placeholder(tf.int32, shape=[None], name='y')
with tf.name_scope('logits'):
layer = tf.keras.layers.Dense(units=2)
logits = layer(x)
with tf.name_scope('loss'):
xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)
loss_op = tf.reduce_mean(xentropy)
with tf.name_scope('optimizer'):
optimizer = GradientDescentOptimizer(0.01)
train_op = optimizer.minimize(loss_op)
FileWriter('logs/train', graph=train_op.graph).close()
%tensorboard --logdir logs/train
2. Même exemple que ci-dessus mais en utilisant maintenant @tf.function décorateur pour les passes avant-arrière et sans désactiver l'exécution impatiente:
%load_ext tensorboard.notebook
import tensorflow as tf
import numpy as np
logdir = 'logs/'
writer = tf.summary.create_file_writer(logdir)
tf.summary.trace_on(graph=True, profiler=True)
@tf.function
def forward_and_backward(x, y, w, b, lr=tf.constant(0.01)):
with tf.name_scope('logits'):
logits = tf.matmul(x, w) + b
with tf.name_scope('loss'):
loss_fn = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=y, logits=logits)
reduced = tf.reduce_sum(loss_fn)
with tf.name_scope('optimizer'):
grads = tf.gradients(reduced, [w, b])
_ = [x.assign(x - g*lr) for g, x in Zip(grads, [w, b])]
return reduced
# inputs
x = tf.convert_to_tensor(np.ones([1, 2]), dtype=tf.float32)
y = tf.convert_to_tensor(np.array([1]))
# params
w = tf.Variable(tf.random.normal([2, 2]), dtype=tf.float32)
b = tf.Variable(tf.zeros([1, 2]), dtype=tf.float32)
loss_val = forward_and_backward(x, y, w, b)
with writer.as_default():
tf.summary.trace_export(
name='NN',
step=0,
profiler_outdir=logdir)
%tensorboard --logdir logs/
3. Utilisation de l’API tf.keras:
%load_ext tensorboard.notebook
import tensorflow as tf
import numpy as np
x_train = [np.ones((1, 2))]
y_train = [np.ones(1)]
model = tf.keras.models.Sequential([tf.keras.layers.Dense(2, input_shape=(2, ))])
model.compile(
optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
logdir = "logs/"
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir)
model.fit(x_train,
y_train,
batch_size=1,
epochs=1,
callbacks=[tensorboard_callback])
%tensorboard --logdir logs/
Ces exemples produiront quelque chose comme ceci sous la cellule:
Voici une recette que j'ai copiée de l'un des rêves profonds d'Alex Mordvintsev bloc-notes à un moment donné
from IPython.display import clear_output, Image, display, HTML
import numpy as np
def strip_consts(graph_def, max_const_size=32):
"""Strip large constant values from graph_def."""
strip_def = tf.GraphDef()
for n0 in graph_def.node:
n = strip_def.node.add()
n.MergeFrom(n0)
if n.op == 'Const':
tensor = n.attr['value'].tensor
size = len(tensor.tensor_content)
if size > max_const_size:
tensor.tensor_content = "<stripped %d bytes>"%size
return strip_def
def show_graph(graph_def, max_const_size=32):
"""Visualize TensorFlow graph."""
if hasattr(graph_def, 'as_graph_def'):
graph_def = graph_def.as_graph_def()
strip_def = strip_consts(graph_def, max_const_size=max_const_size)
code = """
<script>
function load() {{
document.getElementById("{id}").pbtxt = {data};
}}
</script>
<link rel="import" href="https://tensorboard.appspot.com/tf-graph-basic.build.html" onload=load()>
<div style="height:600px">
<tf-graph-basic id="{id}"></tf-graph-basic>
</div>
""".format(data=repr(str(strip_def)), id='graph'+str(np.random.Rand()))
iframe = """
<iframe seamless style="width:1200px;height:620px;border:0" srcdoc="{}"></iframe>
""".format(code.replace('"', '"'))
display(HTML(iframe))
Ensuite, pour visualiser le graphique actuel
show_graph(tf.get_default_graph().as_graph_def())
Si votre graphique est enregistré en tant que pbtxt, vous pouvez le faire
gdef = tf.GraphDef()
from google.protobuf import text_format
text_format.Merge(open("tf_persistent.pbtxt").read(), gdef)
show_graph(gdef)
Vous verrez quelque chose comme ça
J'ai écrit une extension Jupyter pour l'intégration de tensorboard. Ça peut:
- Lancez tensorboard en cliquant simplement sur un bouton dans Jupyter
- Gérer plusieurs instances de tensorboard.
- Intégration transparente avec l'interface Jupyter.
J'ai écrit une aide simple qui démarre un tableau de bord à partir du cahier Jupyter. Ajoutez simplement cette fonction quelque part en haut de votre ordinateur portable
def TB(cleanup=False):
import webbrowser
webbrowser.open('http://127.0.1.1:6006')
!tensorboard --logdir="logs"
if cleanup:
!rm -R logs/
Puis lancez-le TB() à chaque fois que vous avez généré vos résumés. Au lieu d’ouvrir un graphique dans la même fenêtre jupyter, cela:
- commence un tensorboard
- ouvre un nouvel onglet avec tensorboard
- accédez à cet onglet
Une fois l’exploration terminée, cliquez simplement sur l’onglet et arrêtez d’interrompre le noyau. Si vous souhaitez nettoyer votre répertoire de journaux, après l'exécution, exécutez simplement TB(1)
Une version gratuite Tensorboard/iframes de cette visualisation qui s’avère encombrée rapidement peut
import pydot
from itertools import chain
def tf_graph_to_dot(in_graph):
dot = pydot.Dot()
dot.set('rankdir', 'LR')
dot.set('concentrate', True)
dot.set_node_defaults(shape='record')
all_ops = in_graph.get_operations()
all_tens_dict = {k: i for i,k in enumerate(set(chain(*[c_op.outputs for c_op in all_ops])))}
for c_node in all_tens_dict.keys():
node = pydot.Node(c_node.name)#, label=label)
dot.add_node(node)
for c_op in all_ops:
for c_output in c_op.outputs:
for c_input in c_op.inputs:
dot.add_Edge(pydot.Edge(c_input.name, c_output.name))
return dot
qui peut ensuite être suivi de
from IPython.display import SVG
# Define model
tf_graph_to_dot(graph).write_svg('simple_tf.svg')
SVG('simple_tf.svg')
rendre le graphique sous forme d'enregistrements dans un fichier SVG statique 
Code
def tb(logdir="logs", port=6006, open_tab=True, sleep=2):
import subprocess
proc = subprocess.Popen(
"tensorboard --logdir={0} --port={1}".format(logdir, port), Shell=True)
if open_tab:
import time
time.sleep(sleep)
import webbrowser
webbrowser.open("http://127.0.0.1:{}/".format(port))
return proc
tilisation
tb() # Starts a TensorBoard server on the logs directory, on port 6006
# and opens a new tab in your browser to use it.
tb("logs2", 6007) # Starts a second server on the logs2 directory, on port 6007,
# and opens a new tab to use it.
Le démarrage d'un serveur ne bloque pas Jupyter (sauf 2 secondes pour s'assurer que le serveur a le temps de démarrer avant d'ouvrir un onglet). Tous les serveurs TensorBoard s’arrêteront lorsque vous interrompez le noyau.
tilisation avancée
Si vous voulez plus de contrôle, vous pouvez tuer les serveurs par programme comme ceci:
server1 = tb()
server2 = tb("logs2", 6007)
# and later...
server1.kill() # stops the first server
server2.kill() # stops the second server
Vous pouvez définir open_tab=False Si vous ne voulez pas que de nouveaux onglets s'ouvrent. Vous pouvez également définir sleep sur une autre valeur si 2 secondes est trop long ou pas assez sur votre système.
Si vous préférez suspendre Jupyter pendant que TensorBoard est en cours d'exécution, vous pouvez appeler la méthode wait() de n'importe quel serveur. Cela bloquera Jupyter jusqu'à ce que vous interrompiez le noyau, ce qui arrêtera ce serveur et tous les autres.
server1.wait()
Prérequis
Cette solution suppose que vous avez installé TensorBoard (par exemple, en utilisant pip install tensorboard) Et qu’il est disponible dans l’environnement dans lequel vous avez démarré Jupyter.
accusé de réception
Cette réponse a été inspirée par la réponse de @ SalvadorDali. Sa solution est simple et agréable, mais je voulais pouvoir démarrer plusieurs instances de tensorboard sans bloquer Jupyter. De plus, je préfère ne pas supprimer les répertoires de journaux. Au lieu de cela, je démarre tensorboard sur le répertoire de journal racine et chaque TensorFlow exécute les journaux dans un sous-répertoire différent.
TensorBoard Visualize Nodes - Graphique d'architecture
<img src="https://www.tensorflow.org/images/graph_vis_animation.gif" width=1300 height=680>