Простой способ визуализации графика TensorFlow в Jupyter?

Официальным способом визуализации графика TensorFlow является TensorBoard, но иногда я просто хочу быстро взглянуть на график, когда я работаю в Jupyter.

Есть ли быстрое решение, идеально основанное на инструментах TensorFlow или стандартных пакетах SciPy (например, matplotlib), но при необходимости на основе сторонних библиотек?

Ответы

Ответ 1

TensorFlow 2.0 теперь поддерживает TensorBoard в Jupyter помощью магических команд (например, %tensorboard --logdir logs/train). Здесь ссылка на учебные пособия и примеры.

[ИЗДАНИЯ 1, 2]

Как упомянуто в комментарии @MiniQuark, нам нужно сначала загрузить расширение (%load_ext tensorboard.notebook).

Ниже приведены примеры использования режима графика, @tf.function и tf.keras (in tensorflow==2.0.0-alpha0):

1. Пример использования графического режима в TF2 (через 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. Тот же пример, что и выше, но теперь с использованием декоратора @tf.function для @tf.function вперед-назад и без отключения энергичного выполнения:

%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. Использование 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/

Ответ 2

Вот рецепт, который я скопировал у Алексея Мордвинцева в тетрадь глубокого сна в какой-то момент

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('"', '&quot;'))
    display(HTML(iframe))

Затем визуализировать текущий график

show_graph(tf.get_default_graph().as_graph_def())

Если ваш график сохранен как pbtxt, вы можете сделать

gdef = tf.GraphDef()
from google.protobuf import text_format
text_format.Merge(open("tf_persistent.pbtxt").read(), gdef)
show_graph(gdef)

Вы увидите что-то подобное

enter image description here

Ответ 3

Я написал расширение Jupyter для интеграции с тензорной доской. Оно может:

  1. Запустите тензорную доску, просто нажав кнопку в Jupyter
  2. Управление несколькими экземплярами тензорной доски.
  3. Полная интеграция с интерфейсом Jupyter.

Github: https://github.com/lspvic/jupyter_tensorboard

Ответ 4

Я написал простой помощник, который запускает тензограмму из ноутбука jupyter. Просто добавьте эту функцию где-нибудь в верхней части ноутбука

def TB(cleanup=False):
    import webbrowser
    webbrowser.open('http://127.0.1.1:6006')

    !tensorboard --logdir="logs"

    if cleanup:
        !rm -R logs/

И затем запустите его TB() всякий раз, когда вы сгенерировали свои резюме. Вместо того, чтобы открывать график в том же окне jupyter, он:

  • запускает тензограмму
  • открывает новую вкладку с тензограммой
  • перейдите к этой вкладке

После того, как вы закончите исследование, просто нажмите вкладку и остановите прерывание ядра. Если вы хотите очистить каталог журнала, после запуска просто запустите TB(1)

Ответ 5

A Tensorboard/iframes бесплатная версия этой визуализации, которая, по общему признанию, быстро загромождает, может

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

за которым после этого следует

from IPython.display import SVG
# Define model
tf_graph_to_dot(graph).write_svg('simple_tf.svg')
SVG('simple_tf.svg')

чтобы отобразить график в виде записей в статическом SVG файле Интегрированный график Tensorflow в точках

Ответ 6

Код

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

использование

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.

Запуск сервера не блокирует Jupyter (за исключением 2 секунд, чтобы убедиться, что у сервера есть время для запуска перед открытием вкладки). Все серверы TensorBoard остановятся, когда вы прервете ядро.

Расширенное использование

Если вы хотите больше контроля, вы можете программно убить серверы следующим образом:

server1 = tb()
server2 = tb("logs2", 6007)
# and later...
server1.kill()  # stops the first server
server2.kill()  # stops the second server

Вы можете установить open_tab=False если не хотите открывать новые вкладки. Вы также можете установить для sleep другое значение, если в вашей системе 2 секунды слишком много или недостаточно.

Если вы предпочитаете останавливать Jupyter во время работы TensorBoard, вы можете вызвать любой метод сервера wait(). Это будет блокировать Jupyter до тех пор, пока вы не прервете ядро, что остановит этот сервер и все остальные.

server1.wait()

Предпосылки

Это решение предполагает, что вы установили TensorBoard (например, используя pip install tensorboard) и что он доступен в среде, в которой вы запускали Jupyter.

Подтверждение

Этот ответ был вдохновлен ответом @SalvadorDali. Его решение приятно и просто, но я хотел иметь возможность запускать несколько экземпляров тензорной доски, не блокируя Jupyter. Также я предпочитаю не удалять каталоги журналов. Вместо этого я запускаю tenorboard в корневом каталоге журналов, и каждый прогон TensorFlow регистрирует журналы в разных подкаталогах.