Gibt es einen Weg, um tensorflow tf.Print-Ausgabe erscheint in Jupyter Notebook-Ausgang

Update Feb 3, 2017
Ich habe verpackt diese in memory_util Paket. Beispiel für die Verwendung

# install memory util
import urllib.request
response = urllib.request.urlopen("https://raw.githubusercontent.com/yaroslavvb/memory_util/master/memory_util.py")
open("memory_util.py", "wb").write(response.read())

import memory_util

sess = tf.Session()
a = tf.random_uniform((1000,))
b = tf.random_uniform((1000,))
c = a + b
with memory_util.capture_stderr() as stderr:
    sess.run(c.op)

print(stderr.getvalue())

** Old stuff**

Könnte man wiederverwenden FD redirector von IPython Kern. (Idee von Mark Sandler)

import os
import sys

STDOUT = 1
STDERR = 2

class FDRedirector(object):
    """ Class to redirect output (stdout or stderr) at the OS level using
        file descriptors.
    """ 

    def __init__(self, fd=STDOUT):
        """ fd is the file descriptor of the outpout you want to capture.
            It can be STDOUT or STERR.
        """
        self.fd = fd
        self.started = False
        self.piper = None
        self.pipew = None

    def start(self):
        """ Setup the redirection.
        """
        if not self.started:
            self.oldhandle = os.dup(self.fd)
            self.piper, self.pipew = os.pipe()
            os.dup2(self.pipew, self.fd)
            os.close(self.pipew)

            self.started = True

    def flush(self):
        """ Flush the captured output, similar to the flush method of any
        stream.
        """
        if self.fd == STDOUT:
            sys.stdout.flush()
        elif self.fd == STDERR:
            sys.stderr.flush()

    def stop(self):
        """ Unset the redirection and return the captured output. 
        """
        if self.started:
            self.flush()
            os.dup2(self.oldhandle, self.fd)
            os.close(self.oldhandle)
            f = os.fdopen(self.piper, 'r')
            output = f.read()
            f.close()

            self.started = False
            return output
        else:
            return ''

    def getvalue(self):
        """ Return the output captured since the last getvalue, or the
        start of the redirection.
        """
        output = self.stop()
        self.start()
        return output

import tensorflow as tf
x = tf.constant([1,2,3])
a=tf.Print(x, [x])

redirect=FDRedirector(STDERR)

sess = tf.InteractiveSession()
redirect.start();
a.eval();
print "Result"
print redirect.stop()

Können Sie überprüfen Sie das terminal, wo Sie startete die jupyter notebook um die Nachricht zu Lesen.

import tensorflow as tf

tf.InteractiveSession()

a = tf.constant(1)
b = tf.constant(2)

opt = a + b
opt = tf.Print(opt, [opt], message="1 + 2 = ")

opt.eval()

In der Klemme, ich kann sehen:

2018-01-02 23:38:07.691808: I tensorflow/core/kernels/logging_ops.cc:79] 1 + 2 = [3]

Das Problem, das ich konfrontiert wurde, war, dass man nicht eine session im Tensorflow Graphen, wie Sie im training oder bei der Auswertung.
Das ist, warum die Optionen zu verwenden sess.run(opt) oder opt.eval() waren nicht eine Lösung für mich.
Das beste war die Verwendung tf.Print() und leiten Sie die Protokollierung in eine externe Datei.
Ich Tat dies mit einer zeitlichen Datei, die ich übertragen auf eine normale Datei wie dieser:

STDERR=2
import os
import sys
import tempfile

class captured:
    def __init__(self, fd=STDERR):
        self.fd = fd
        self.prevfd = None
    def __enter__(self):
        t = tempfile.NamedTemporaryFile()
        self.prevfd = os.dup(self.fd)
        os.dup2(t.fileno(), self.fd)
        return t
    def __exit__(self, exc_type, exc_value, traceback):
        os.dup2(self.prevfd, self.fd)

with captured(fd=STDERR) as tmp:
    ...
    classifier.evaluate(input_fn=input_fn, steps=100)

with open('log.txt', 'w') as f:
    print(open(tmp.name).read(), file=f)

Und dann in meine Auswertung mache ich:

a = tf.constant(1)
a = tf.Print(a, [a], message="a: ")