Wie drucke ich den Wert eines Tensor-Objekts in TensorFlow?

Ich habe das einführende Beispiel der Matrixmultiplikation in TensorFlow verwendet.

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

Wenn ich das Produkt drucke, wird es als TensorObjekt angezeigt:

<tensorflow.python.framework.ops.Tensor object at 0x10470fcd0>

Aber woher weiß ich den Wert von product?

Folgendes hilft nicht:

print product
Tensor("MatMul:0", shape=TensorShape([Dimension(1), Dimension(1)]), dtype=float32)

Ich weiß, dass Diagramme ausgeführt werden Sessions, aber gibt es keine Möglichkeit, die Ausgabe eines TensorObjekts zu überprüfen, ohne das Diagramm in einem auszuführen session?

Der einfachste ^[A] Weg, den tatsächlichen Wert eines TensorObjekts zu bewerten, besteht darin, ihn an die Session.run()Methode zu übergeben oder aufzurufen, Tensor.eval()wenn Sie eine Standardsitzung haben (dh in einem with tf.Session():Block oder siehe unten). Im Allgemeinen ^[B] können Sie den Wert eines Tensors nicht drucken, ohne in einer Sitzung Code auszuführen.

Wenn Sie mit dem Programmiermodell experimentieren und eine einfache Möglichkeit zur Bewertung von Tensoren wünschen, tf.InteractiveSessionkönnen Sie zu Beginn Ihres Programms eine Sitzung öffnen und diese Sitzung dann für alle Tensor.eval()(und Operation.run()) Aufrufe verwenden. Dies kann in einer interaktiven Umgebung wie der Shell oder einem IPython-Notizbuch einfacher sein, wenn es mühsam ist, ein SessionObjekt überall herumzugeben. In einem Jupyter-Notizbuch funktioniert beispielsweise Folgendes:

with tf.Session() as sess:  print(product.eval()) 

Dies mag für einen so kleinen Ausdruck albern erscheinen, aber eine der Schlüsselideen in Tensorflow 1.x ist die verzögerte Ausführung : Es ist sehr billig, einen großen und komplexen Ausdruck zu erstellen, und wenn Sie ihn bewerten möchten, das Back-End (to die Sie mit a Session) verbinden, kann die Ausführung effizienter planen (z. B. unabhängige Teile parallel ausführen und GPUs verwenden).

[A]: Um den Wert eines Tensors zu drucken, ohne ihn an Ihr Python-Programm zurückzugeben, können Sie den tf.print()Operator verwenden, wie Andrzej in einer anderen Antwort vorschlägt . Laut offizieller Dokumentation:

Um sicherzustellen, dass der Operator ausgeführt wird, müssen Benutzer die erzeugte Operation an tf.compat.v1.Sessiondie Ausführungsmethode übergeben oder die Operation als Steuerungsabhängigkeit für ausgeführte Operationen verwenden, indem sie mit tf.compat.v1.control_dependencies([print_op]) angeben , das in der Standardausgabe gedruckt wird.

Beachten Sie auch Folgendes:

Druckt in Jupyter-Notizbüchern und -Folabs tf.printauf die Notebook-Zellenausgaben. Es wird nicht in die Konsolenprotokolle des Notebook-Kernels geschrieben.

[B]: Möglicherweise können Sie die tf.get_static_value()Funktion verwenden, um den konstanten Wert des angegebenen Tensors zu erhalten, wenn sein Wert effizient berechenbar ist.

Während andere Antworten richtig sind, dass Sie den Wert erst drucken können, wenn Sie das Diagramm ausgewertet haben, sprechen sie nicht über eine einfache Möglichkeit, einen Wert innerhalb des Diagramms tatsächlich zu drucken, sobald Sie ihn ausgewertet haben.

Der einfachste Weg, einen Tensorwert zu sehen, wenn der Graph ausgewertet wird (mit runoder eval), ist die Verwendung der PrintOperation wie in diesem Beispiel:

# Initialize session
import tensorflow as tf
sess = tf.InteractiveSession()

# Some tensor we want to print the value of
a = tf.constant([1.0, 3.0])

# Add print operation
a = tf.Print(a, [a], message="This is a: ")

# Add more elements of the graph using a
b = tf.add(a, a)

Wenn wir nun den gesamten Graphen auswerten, z. B. mit b.eval(), erhalten wir:

I tensorflow/core/kernels/logging_ops.cc:79] This is a: [1 3]

Es ist nicht möglich, die Werte zu überprüfen, ohne das Diagramm auszuführen.

Ein einfaches Snippet für alle, die nach einem einfachen Beispiel zum Drucken von Werten suchen, ist wie folgt. Der Code kann ohne Änderungen in ipython notebook ausgeführt werden

import tensorflow as tf

#define a variable to hold normal random values 
normal_rv = tf.Variable( tf.truncated_normal([2,3],stddev = 0.1))

#initialize the variable
init_op = tf.initialize_all_variables()

#run the graph
with tf.Session() as sess:
    sess.run(init_op) #execute init_op
    #print the random values that we sample
    print (sess.run(normal_rv))

Ausgabe:

[[-0.16702934  0.07173464 -0.04512421]
 [-0.02265321  0.06509651 -0.01419079]]

Nein, Sie können den Inhalt des Tensors nicht sehen, ohne das Diagramm auszuführen (tun session.run()). Die einzigen Dinge, die Sie sehen können, sind:

• die Dimensionalität des Tensors (aber ich nehme an, es ist nicht schwer, sie für die Liste der Operationen zu berechnen , die TF hat)
• Art der Operation, mit der der Tensor ( transpose_1:0, random_uniform:0) generiert wird
• Art der Elemente im Tensor ( float32)

Ich habe dies nicht in der Dokumentation gefunden, aber ich glaube, dass die Werte der Variablen (und einige der Konstanten zum Zeitpunkt der Zuweisung nicht berechnet werden).

Schauen Sie sich dieses Beispiel an:

import tensorflow as tf
from datetime import datetime
dim = 7000

Das erste Beispiel, in dem ich gerade einen konstanten Tensor von Zufallszahlen initiiere, läuft ungefähr zur gleichen Zeit, unabhängig von dim ( 0:00:00.003261)

startTime = datetime.now()
m1 = tf.truncated_normal([dim, dim], mean=0.0, stddev=0.02, dtype=tf.float32, seed=1)
print datetime.now() - startTime

Im zweiten Fall, in dem die Konstante tatsächlich ausgewertet und die Werte zugewiesen werden, hängt die Zeit eindeutig von dim ( 0:00:01.244642) ab.

startTime = datetime.now()
m1 = tf.truncated_normal([dim, dim], mean=0.0, stddev=0.02, dtype=tf.float32, seed=1)
sess = tf.Session()
sess.run(m1)
print datetime.now() - startTime

Und Sie können es klarer machen, indem Sie etwas berechnen ( d = tf.matrix_determinant(m1)unter Berücksichtigung der Tatsache, dass die Zeit abläuft O(dim^2.8)).

PS Ich fand, wo es in der Dokumentation erklärt wird :

Ein Tensor-Objekt ist ein symbolisches Handle für das Ergebnis einer Operation, enthält jedoch nicht die Werte der Ausgabe der Operation.

Ich denke, Sie müssen einige Grundlagen richtig machen. Mit den obigen Beispielen haben Sie Tensoren (mehrdimensionales Array) erstellt. Damit der Tensorfluss wirklich funktioniert, müssen Sie eine " Sitzung " initiieren und Ihre " Operation " in der Sitzung ausführen . Beachten Sie das Wort "Sitzung" und "Operation". Sie müssen 4 Dinge wissen, um mit Tensorflow zu arbeiten:

1. Tensoren
2. Operationen
3. Sitzungen
4. Grafiken

Nach dem, was Sie geschrieben haben, haben Sie den Tensor und die Operation angegeben, aber Sie haben weder eine laufende Sitzung noch ein Diagramm. Tensor (Kanten des Diagramms) fließen durch Diagramme und werden durch Operationen (Knoten des Diagramms) manipuliert. Es gibt ein Standarddiagramm, aber Sie können Ihr Diagramm in einer Sitzung initiieren.

Wenn Sie "Drucken" sagen, greifen Sie nur auf die Form der von Ihnen definierten Variablen oder Konstante zu.

So können Sie sehen, was Sie vermissen:

 with tf.Session() as sess:     
           print(sess.run(product))
           print (product.eval())

Ich hoffe es hilft!

Im Tensorflow 1.x

import tensorflow as tf
tf.enable_eager_execution()
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

#print the product
print(product)         # tf.Tensor([[12.]], shape=(1, 1), dtype=float32)
print(product.numpy()) # [[12.]]

Mit Tensorflow 2.x ist der Eifersuchtsmodus standardmäßig aktiviert. Der folgende Code funktioniert also mit TF2.0.

import tensorflow as tf
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

#print the product
print(product)         # tf.Tensor([[12.]], shape=(1, 1), dtype=float32)
print(product.numpy()) # [[12.]]

Basierend auf den obigen Antworten können Sie das Produkt mit Ihrem speziellen Code-Snippet wie folgt drucken:

import tensorflow as tf
#Initialize the session
sess = tf.InteractiveSession()

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

#print the product
print(product.eval())

#close the session to release resources
sess.close()

In Tensorflow 2.0+ (oder in der Eager-Modus-Umgebung) können Sie folgende .numpy()Methode aufrufen :

import tensorflow as tf

matrix1 = tf.constant([[3., 3.0]])
matrix2 = tf.constant([[2.0],[2.0]])
product = tf.matmul(matrix1, matrix2)

print(product.numpy()) 

tf.keras.backend.eval ist nützlich für die Auswertung kleiner Ausdrücke.

tf.keras.backend.eval(op)

TF 1.x und TF 2.0 kompatibel.

Minimal verifizierbares Beispiel

from tensorflow.keras.backend import eval

m1 = tf.constant([[3., 3.]])
m2 = tf.constant([[2.],[2.]])

eval(tf.matmul(m1, m2))
# array([[12.]], dtype=float32)

Dies ist nützlich, da Sie kein Sessionoder explizit erstellen müssen InteractiveSession.

Sie können die Ausgabe eines TensorObject überprüfen, ohne das Diagramm in einer Sitzung auszuführen, indem Sie die eifrige Ausführung aktivieren .

Fügen Sie einfach die folgenden zwei Codezeilen hinzu: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

gleich nach dir import tensorflow.

Die Ausgabe print productin Ihrem Beispiel lautet nun: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Beachten Sie, dass Sie ab sofort (November 2017) jeden Abend einen Tensorflow-Build installieren müssen, um eine eifrige Ausführung zu ermöglichen. Vorgefertigte Räder finden Sie hier .

Bitte beachten Sie, dass dadurch der tf.Print()Tensorname geändert wird. Wenn der Tensor, den Sie drucken möchten, ein Platzhalter ist, schlagen die Zuführungsdaten fehl, da der ursprüngliche Name beim Zuführen nicht gefunden wird. Beispielsweise:

import tensorflow as tf
tens = tf.placeholder(tf.float32,[None,2],name="placeholder")
print(eval("tens"))
tens = tf.Print(tens,[tens, tf.shape(tens)],summarize=10,message="tens:")
print(eval("tens"))
res = tens + tens
sess = tf.Session()
sess.run(tf.global_variables_initializer())

print(sess.run(res))

Ausgabe ist:

python test.py
Tensor("placeholder:0", shape=(?, 2), dtype=float32)
Tensor("Print:0", shape=(?, 2), dtype=float32)
Traceback (most recent call last):
[...]
InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'placeholder' with dtype float

Sie sollten sich TensorFlow Core-Programme als zwei diskrete Abschnitte vorstellen:

• Erstellen des Rechengraphen.
• Ausführen des Berechnungsdiagramms.

Für den folgenden Code erstellen Sie einfach das Berechnungsdiagramm.

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

Sie müssen auch Um alle Variablen in einem TensorFlow-Programm zu initialisieren, müssen Sie eine spezielle Operation explizit wie folgt aufrufen:

init = tf.global_variables_initializer()

Nachdem Sie das Diagramm erstellt und alle Variablen initialisiert haben, müssen Sie im nächsten Schritt die Knoten auswerten. Sie müssen das Berechnungsdiagramm innerhalb einer Sitzung ausführen. Eine Sitzung kapselt die Steuerung und den Status der TensorFlow-Laufzeit.

Der folgende Code erstellt ein Sitzungsobjekt und ruft dann seine Ausführungsmethode auf, um genügend Rechengraphen zur Auswertung auszuführen product:

sess = tf.Session()
// run variables initializer
sess.run(init)

print(sess.run([product]))

Sie können Keras verwenden. Eine einzeilige Antwort lautet eval: Verwenden Sie die folgende Methode:

import keras.backend as K
print(K.eval(your_tensor))

Versuchen Sie diesen einfachen Code! (es ist selbsterklärend)

import tensorflow as tf
sess = tf.InteractiveSession() # see the answers above :)
x = [[1.,2.,1.],[1.,1.,1.]]    # a 2D matrix as input to softmax
y = tf.nn.softmax(x)           # this is the softmax function
                               # you can have anything you like here
u = y.eval()
print(u)

Ich fand es nicht leicht zu verstehen, was erforderlich ist, selbst nachdem ich alle Antworten gelesen hatte, bis ich dies ausführte. TensofFlow ist auch für mich neu.

def printtest():
x = tf.constant([1.0, 3.0])
x = tf.Print(x,[x],message="Test")
init = (tf.global_variables_initializer(), tf.local_variables_initializer())
b = tf.add(x, x)
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(b))
    sess.close()

Möglicherweise benötigen Sie jedoch den Wert, der durch Ausführen der Sitzung zurückgegeben wird.

def printtest():
    x = tf.constant([100.0])
    x = tf.Print(x,[x],message="Test")
    init = (tf.global_variables_initializer(), tf.local_variables_initializer())
    b = tf.add(x, x)
    with tf.Session() as sess:
        sess.run(init)
        c = sess.run(b)
        print(c)
        sess.close()

Grundsätzlich werden in Tensorflow beim Erstellen eines Tensors beliebiger Art diese erstellt und gespeichert, auf die nur zugegriffen werden kann, wenn Sie eine Tensorflow-Sitzung ausführen. Angenommen, Sie haben einen konstanten Tensor erstellt.
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Ohne eine Sitzung auszuführen, können Sie Folgendes erhalten :
- opEine Operation. Operation, die diesen Tensor berechnet.
- value_index: Ein int. Index des Endpunkts der Operation, der diesen Tensor erzeugt.
- dtype: Ein DType. Art der in diesem Tensor gespeicherten Elemente.

Um die Werte zu erhalten, können Sie eine Sitzung mit dem gewünschten Tensor ausführen:

with tf.Session() as sess:
    print(sess.run(c))
    sess.close()

Die Ausgabe wird ungefähr so ​​aussehen:

Array ([[1., 2., 3.], [4., 5., 6.]], dtype = float32)

Aktivieren Sie die eifrige Ausführung, die nach Version 1.10 in Tensorflow eingeführt wird. Es ist sehr einfach zu bedienen.

# Initialize session
import tensorflow as tf
tf.enable_eager_execution()


# Some tensor we want to print the value of
a = tf.constant([1.0, 3.0])

print(a)

Mit den in https://www.tensorflow.org/api_docs/python/tf/print bereitgestellten Tipps verwende ich die log_dFunktion zum Drucken formatierter Zeichenfolgen.

import tensorflow as tf

def log_d(fmt, *args):
    op = tf.py_func(func=lambda fmt_, *args_: print(fmt%(*args_,)),
                    inp=[fmt]+[*args], Tout=[])
    return tf.control_dependencies([op])


# actual code starts now...

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

with log_d('MAT1: %s, MAT2: %s', matrix1, matrix2): # this will print the log line
    product = tf.matmul(matrix1, matrix2)

with tf.Session() as sess:
    sess.run(product)

import tensorflow as tf
sess = tf.InteractiveSession()
x = [[1.,2.,1.],[1.,1.,1.]]    
y = tf.nn.softmax(x)           

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1, matrix2)

print(product.eval())
tf.reset_default_graph()
sess.close()

tf.Print ist jetzt veraltet. Hier erfahren Sie, wie Sie stattdessen tf.print (Kleinbuchstabe p) verwenden.

Das Ausführen einer Sitzung ist zwar eine gute Option, aber nicht immer der richtige Weg. Beispielsweise möchten Sie möglicherweise einen Tensor in einer bestimmten Sitzung drucken.

Die neue Druckmethode gibt einen Druckvorgang ohne Ausgabetensoren zurück:

print_op = tf.print(tensor_to_print)

Da es keine Ausgänge gibt, können Sie es nicht auf die gleiche Weise wie mit tf.Print in ein Diagramm einfügen. Stattdessen können Sie es hinzufügen, um Abhängigkeiten in Ihrer Sitzung zu steuern, damit es gedruckt wird.

sess = tf.compat.v1.Session()
with sess.as_default():
  tensor_to_print = tf.range(10)
  print_op = tf.print(tensor_to_print)
with tf.control_dependencies([print_op]):
  tripled_tensor = tensor_to_print * 3
sess.run(tripled_tensor)

In einem größeren Diagramm, das möglicherweise teilweise in Unterfunktionen erstellt wurde, ist es manchmal umständlich, print_op an den Sitzungsaufruf weiterzugeben. Dann kann tf.tuple verwendet werden, um den Druckvorgang mit einem anderen Vorgang zu koppeln, der dann mit diesem Vorgang ausgeführt wird, je nachdem, welche Sitzung den Code ausführt. So geht das:

print_op = tf.print(tensor_to_print)
some_tensor_list = tf.tuple([some_tensor], control_inputs=[print_op])
# Use some_tensor_list[0] instead of any_tensor below.

Frage: Wie drucke ich den Wert eines Tensor-Objekts in TensorFlow?

Antworten:

import tensorflow as tf

# Variable
x = tf.Variable([[1,2,3]])

# initialize
init = (tf.global_variables_initializer(), tf.local_variables_initializer())

# Create a session
sess = tf.Session()

# run the session
sess.run(init)

# print the value
sess.run(x)