Jupyter에서 TensorFlow 그래프를 시각화하는 간단한 방법은 무엇입니까?

Jupyter에서 TensorFlow 그래프를 시각화하는 간단한 방법은 무엇입니까?

---

TensorFlow 그래프를 시각화하는 공식적인 방법은 TensorBoard를 사용하는 것이지만 때로는 Jupyter에서 작업 할 때 그래프를 빠르게보고 싶을 때가 있습니다.

이상적으로는 TensorFlow 도구 또는 표준 SciPy 패키지 (예 : matplotlib)를 기반으로하는 빠른 솔루션이 있지만 필요한 경우 타사 라이브러리를 기반으로합니까?

---

TensorFlow 2.0이제 매직 명령 TensorBoard을 Jupyter통해 in 을 지원 합니다 (예 :) %tensorboard --logdir logs/train. 다음은 튜토리얼 및 예제에 대한 링크 입니다.

[편집 1, 2]

@MiniQuark가 주석에서 언급했듯이 먼저 확장 프로그램을로드해야합니다 ( %load_ext tensorboard.notebook).

다음은 사용에 대한 사용 예이다 그래프 모드 , @tf.function및 tf.keras(에이 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앞뒤로 전달되고 eager 실행을 비활성화하지 않고 데코레이터를 사용합니다 .

%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. tf.kerasAPI 사용 :

%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/

이 예제는 셀 아래에 다음과 같은 것을 생성합니다.

---

여기 조리법 알렉스 Mordvintsev 깊은 꿈 중 하나에서 복사 된 노트북 어떤 점에서

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)

다음과 같은 것을 볼 수 있습니다.

---

텐서 보드 통합을위한 Jupyter 확장을 작성했습니다. 다음을 수행 할 수 있습니다.

1. Jupyter에서 버튼을 클릭하여 텐서 보드를 시작하십시오.
2. 여러 텐서 보드 인스턴스를 관리합니다.
3. Jupyter 인터페이스와 원활하게 통합됩니다.

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

---

나는 jupyter 노트북에서 tensorboard를 시작하는 간단한 도우미를 작성했습니다. 노트북 상단 어딘가에이 기능을 추가하면됩니다.

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)

---

이 시각화의 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 파일의 레코드로 렌더링하려면

---

암호

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.

Starting a server does not block Jupyter (except for 2 seconds to ensure the server has the time to start before opening a tab). All TensorBoard servers will stop when you interrupt the kernel.

Advanced usage

If you want more control, you can kill the servers programmatically like this:

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

You can set open_tab=False if you don't want new tabs to open. You can also set sleep to some other value if 2 seconds is too much or not enough on your system.

If you prefer to pause Jupyter while TensorBoard is running, then you can call any server's wait() method. This will block Jupyter until you interrupt the kernel, which will stop this server and all the others.

server1.wait()

Prerequisites

이 솔루션은 TensorBoard를 설치 (예 : 사용 pip install tensorboard)했고 Jupyter를 시작한 환경에서 사용할 수 있다고 가정합니다 .

승인

이 답변은 @SalvadorDali의 답변에서 영감을 얻었습니다. 그의 솔루션은 훌륭하고 간단하지만 Jupyter를 차단하지 않고 여러 텐서 보드 인스턴스를 시작할 수 있기를 원했습니다. 또한 로그 디렉토리를 삭제하지 않는 것을 선호합니다. 대신 루트 로그 디렉터리에서 텐서 보드를 시작하고 각 TensorFlow는 다른 하위 디렉터리에서 로그를 실행합니다.

---

TensorBoard Visualize Nodes-아키텍처 그래프

<img src="https://www.tensorflow.org/images/graph_vis_animation.gif" width=1300 height=680>

참고 URL : https://stackoverflow.com/questions/38189119/simple-way-to-visualize-a-tensorflow-graph-in-jupyter