wake-up-neo.com

Wie wird der Wert eines Tensor-Objekts in TensorFlow gedruckt?

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 Tensor-Objekt 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 auf Sessions laufen, aber gibt es keine Möglichkeit, die Ausgabe eines Tensor-Objekts zu überprüfen, ohne das Diagramm in einer session auszuführen?

193
Dawny33

Das einfachste[EIN] Um den tatsächlichen Wert eines Tensor Objekts auszuwerten, müssen Sie ihn an die Session.run() -Methode übergeben oder Tensor.eval() aufrufen, wenn Sie eine Standardsitzung haben (z. B. in einer 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 auf einfache Weise Tensoren auswerten möchten, können Sie mit tf.InteractiveSession eine Sitzung zu Beginn Ihres Programms öffnen und Verwenden Sie diese Sitzung dann für alle Aufrufe von Tensor.eval() (und Operation.run()). Dies kann in einer interaktiven Umgebung wie der Shell oder einem IPython-Notizbuch einfacher sein, wenn es mühsam ist, ein Session -Objekt überall herumzugeben.

Dies mag für einen so kleinen Ausdruck albern erscheinen, aber eine der Schlüsselideen in Tensorflow ist 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 (zu dem Sie eine Verbindung mit Session herstellen) kann die Ausführung effizienter planen (z. B. parallele Ausführung unabhängiger Teile und Verwendung von GPUs).


[A]: Mit dem Operator tf.Print() können Sie den Wert eines Tensors drucken, ohne ihn an Ihr Programm Python= zurückzugeben , wie Andrzej in einer anderen Antwort vorschlägt Beachten Sie, dass Sie immer noch einen Teil des Diagramms ausführen müssen, um die Ausgabe dieser Operation zu sehen, die als Standardausgabe ausgegeben wird Wenn Sie verteilten TensorFlow ausführen, druckt tf.Print() seine Ausgabe auf die Standardausgabe der Task, auf der dieser Vorgang ausgeführt wird. Wenn Sie also https://colab.research.google.com Zum Beispiel oder ein anderes Jupyter-Notizbuch, dann werden Sie nicht sehen die Ausgabe von tf.Print() im Notizbuch ; In diesem Fall lesen Sie in dieser Antwort nach, wie Sie es zum Drucken bringen können.

[B]: Sie könnten können die experimentelle tf.contrib.util.constant_value() Funktion verwenden, um den Wert eines konstanten Tensors zu erhalten, aber es ist nicht für den allgemeinen Gebrauch gedacht und für viele Bediener nicht definiert.

217
mrry

Während andere Antworten richtig sind, dass Sie den Wert erst drucken können, wenn Sie die Grafik ausgewertet haben, sprechen sie nicht über eine einfache Möglichkeit, einen Wert innerhalb der Grafik auszudrucken, sobald Sie ihn ausgewertet haben. 

Der einfachste Weg, einen Wert eines Tensors zu sehen, wenn der Graph ausgewertet wird (mit run oder eval), ist die Verwendung der Operation Print 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 die gesamte Grafik auswerten, z. mit b.eval() erhalten wir:

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

Noch einmal, was andere gesagt haben, ist es nicht möglich, die Werte zu überprüfen, ohne das Diagramm auszuführen.

Ein einfacher Ausschnitt für alle, die ein einfaches Beispiel zum Drucken von Werten suchen, finden Sie unten. Der Code kann ohne Änderung 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]]
25
Jeevan

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

  • die Dimensionalität des Tensors (aber ich gehe davon aus, dass es nicht schwer ist, ihn für die Liste der Operationen zu berechnen die TF hat)
  • typ der Operation, die zur Generierung des Tensors verwendet wird (transpose_1:0, random_uniform:0)
  • art der Elemente im Tensor (float32)

Ich habe dies in der Dokumentation nicht gefunden, aber ich glaube, dass die Werte der Variablen (und einige 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, bei 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 wird 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), wobei zu berücksichtigen ist, dass die Zeit in O(dim^2.8) abläuft).

P.S. Ich habe herausgefunden, wo es in documentation erklärt wird:

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

19
Salvador Dali

Ich denke, du musst ein paar Grundlagen schaffen. 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 "session" und "operation" . Sie müssen 4 Dinge kennen, um mit tensorflow zu arbeiten: 

  1. tensoren
  2. Operationen
  3. Sitzungen
  4. Diagramme

Nun haben Sie aus dem, was Sie geschrieben haben, den Tensor und die Operation angegeben, aber Sie haben weder eine Sitzung noch ein Diagramm. Tensor (Kanten des Graphen) fließen durch Graphen und werden durch Operationen (Knoten des Graphen) manipuliert. Es gibt eine Standardgrafik, aber Sie können Ihre in einer Sitzung initiieren.

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

So können Sie sehen, was Ihnen fehlt:

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

Ich hoffe es hilft!

11
user29120

Im aktuellen Tensorflow 1.13.1

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.0 ist der Eifermodus 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 folgendermaßen 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()
7
Ben

Sie können die Ausgabe eines TensorObjects überprüfen, ohne das Diagramm in einer Sitzung auszuführen, indem Sie eager execution 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 von print product in Ihrem Beispiel lautet nun: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

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

6
Giorgos Sfikas

Sie sollten an TensorFlow Core-Programme denken, die aus zwei getrennten Abschnitten bestehen:

  • Erstellen des Berechnungsgraphen.
  • Ausführen des Berechnungsgraphen.

Für den folgenden Code erstellen Sie einfach den Berechnungsgraph. 

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

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

init = tf.global_variables_initializer()

Jetzt erstellen Sie den Graphen und initialisieren alle Variablen. Im nächsten Schritt werden die Knoten ausgewertet. Sie müssen den Berechnungsgraph innerhalb einer Sitzung ausführen. Eine Sitzung enthält die Steuerung und den Status der TensorFlow-Laufzeitumgebung.

Der folgende Code erstellt ein Session-Objekt und ruft dann seine run-Methode auf, um genügend Berechnungsdiagramm auszuführen, um product auszuwerten:

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

print(sess.run([product]))
5
Ahmed Gamal

Bitte beachten Sie, dass tf.Print() den Tensornamen ändert. Wenn der Tensor, den Sie drucken möchten, ein Platzhalter ist, schlagen die Dateneingaben fehl, da der ursprüngliche Name während des Transports nicht gefunden wird.

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
4
npit

Versuchen Sie diesen einfachen Code! (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)
3
Ganindu

tf.keras.backend.eval ist nützlich, um kleine Ausdrücke auszuwerten.

_tf.keras.backends.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 nicht explizit ein Session oder InteractiveSession erstellen müssen.

2
cs95

In Tensorflow 2.0+ (oder im Eager-Modus) können Sie die Methode .numpy() 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()) 
1
Madiyar

Grundsätzlich werden Tensor-Flows, wenn Sie einen beliebigen Tensor erstellen, erstellt und gespeichert, auf den nur zugegriffen werden kann, wenn Sie eine Tensor-Flowsitzung 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 erhalten
- op: Eine Operation. Operation, die diesen Tensor berechnet.
- value_index: Ein int. Index des Operationsendpunkts, 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 Tensor ausführen, den Sie benötigen als:

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)

1

Ich habe es nicht leicht verstanden zu verstehen, was erforderlich ist, auch nachdem ich alle Antworten gelesen hatte, bis ich das ausgeführt habe. TensofFlow ist auch neu für mich.

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()

Trotzdem benötigen Sie möglicherweise 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()
1

Sie können Keras verwenden. Bei einer einzeiligen Antwort wird die eval -Methode folgendermaßen verwendet:

import keras.backend as K
print(K.eval(your_tensor))
1
chandresh
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()
0
Prakhar Agarwal

Aktivieren Sie die eifrige Ausführung, die in Tensorflow nach Version 1.10 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)
0
Aashish Dahiya

Unter Verwendung der Tipps in https://www.tensorflow.org/api_docs/python/tf/print benutze ich die Funktion log_d, um formatierte Zeichenfolgen zu drucken.

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)
0
Batta

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)
0