¿Cómo imprimir el valor de un objeto Tensor en TensorFlow?

He estado usando el ejemplo introductorio de la multiplicación de matrices en TensorFlow.

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

Cuando imprimo el producto, lo muestra como un Tensorobjeto:

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

Pero, ¿cómo sé el valor de product?

Lo siguiente no ayuda:

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

Sé que los gráficos se ejecutan Sessions, pero ¿no hay alguna manera de que pueda verificar la salida de un Tensorobjeto sin ejecutar el gráfico en un session?

La forma más fácil ^[A] de evaluar el valor real de un Tensorobjeto es pasarlo al Session.run()método, o llamar Tensor.eval()cuando tenga una sesión predeterminada (es decir, en un with tf.Session():bloque, o ver más abajo). En general ^[B] , no puede imprimir el valor de un tensor sin ejecutar algún código en una sesión.

Si está experimentando con el modelo de programación y desea una manera fácil de evaluar los tensores, le tf.InteractiveSessionpermite abrir una sesión al comienzo de su programa y luego usar esa sesión para todas Tensor.eval()(y Operation.run()) llamadas. Esto puede ser más fácil en una configuración interactiva, como el shell o una computadora portátil IPython, cuando es tedioso pasar un Sessionobjeto a todas partes. Por ejemplo, lo siguiente funciona en un cuaderno Jupyter:

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

Esto puede parecer una tontería para una expresión tan pequeña, pero una de las ideas clave en Tensorflow 1.x es la ejecución diferida : es muy barato construir una expresión grande y compleja, y cuando desea evaluarla, el back-end (para con el que se conecta a Session) puede programar su ejecución de manera más eficiente (por ejemplo, ejecutar partes independientes en paralelo y usar GPU).

[A]: para imprimir el valor de un tensor sin devolverlo a su programa Python, puede usar el tf.print()operador, como sugiere Andrzej en otra respuesta . Según la documentación oficial:

Para asegurarse de que el operador se ejecuta, los usuarios deben pasar el op producido al tf.compat.v1.Sessionmétodo de ejecución o usar el op como una dependencia de control para los ops ejecutados especificando con tf.compat.v1.control_dependencies([print_op]), que se imprime en la salida estándar.

También tenga en cuenta que:

En los cuadernos y colabs Jupyter, tf.printimprime en las salidas de celda del cuaderno. No escribirá en los registros de la consola del kernel del notebook.

[B]: es posible que pueda usar la tf.get_static_value()función para obtener el valor constante del tensor dado si su valor es eficientemente calculable.

Si bien otras respuestas son correctas de que no puede imprimir el valor hasta que evalúe el gráfico, no hablan de una manera fácil de imprimir realmente un valor dentro del gráfico, una vez que lo evalúa.

La forma más fácil de ver el valor de un tensor cada vez que se evalúa el gráfico (usando runo eval) es usar la Printoperación como en este ejemplo:

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

Ahora, cada vez que evaluamos todo el gráfico, por ejemplo b.eval(), usando , obtenemos:

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

Reiterando lo que otros dijeron, no es posible verificar los valores sin ejecutar el gráfico.

Un fragmento simple para cualquiera que busque un ejemplo sencillo para imprimir valores es el siguiente. El código se puede ejecutar sin ninguna modificación en el cuaderno de ipython

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

Salida:

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

No, no puede ver el contenido del tensor sin ejecutar el gráfico (haciendo session.run()). Las únicas cosas que puedes ver son:

• la dimensionalidad del tensor (pero supongo que no es difícil calcularlo para la lista de las operaciones que tiene TF)
• tipo de la operación que se utilizará para generar el tensor ( transpose_1:0, random_uniform:0)
• tipo de elementos en el tensor ( float32)

No he encontrado esto en la documentación, pero creo que los valores de las variables (y algunas de las constantes no se calculan en el momento de la asignación).

Echale un vistazo a éste ejemplo:

import tensorflow as tf
from datetime import datetime
dim = 7000

El primer ejemplo donde acabo de iniciar un Tensor constante de números aleatorios se ejecuta aproximadamente al mismo tiempo, independientemente de 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

En el segundo caso, donde la constante se evalúa y se asignan los valores, el tiempo depende claramente de dim ( 0:00:01.244642)

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

Y puede hacerlo más claro calculando algo ( d = tf.matrix_determinant(m1)teniendo en cuenta que el tiempo se acabará O(dim^2.8))

PD que encontré donde se explica en la documentación :

Un objeto Tensor es un identificador simbólico del resultado de una operación, pero en realidad no contiene los valores de la salida de la operación.

Creo que necesitas tener algunos fundamentos correctos. Con los ejemplos anteriores, ha creado tensores (matriz multidimensional). Pero para que el flujo de tensor realmente funcione, debe iniciar una " sesión " y ejecutar su " operación " en la sesión. Observe la palabra "sesión" y "operación". Necesita saber 4 cosas para trabajar con tensorflow:

1. tensores
2. Operaciones
3. Sesiones
4. Gráficos

Ahora, por lo que escribió, le ha dado el tensor y la operación, pero no tiene sesión en ejecución ni un gráfico. El tensor (bordes del gráfico) fluye a través de los gráficos y son manipulados por operaciones (nodos del gráfico). Hay un gráfico predeterminado pero puede iniciar el suyo en una sesión.

Cuando dice imprimir, solo accede a la forma de la variable o constante que definió.

Para que puedas ver lo que te estás perdiendo:

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

¡Espero eso ayude!

En 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.]]

Con Tensorflow 2.x, el modo ansioso está habilitado de forma predeterminada. entonces el siguiente código funciona con 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.]]

Según las respuestas anteriores, con su fragmento de código particular puede imprimir el producto de esta manera:

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

En Tensorflow 2.0+ (o en el entorno del modo Eager) puede llamar al .numpy()método:

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 Es útil para evaluar expresiones pequeñas.

tf.keras.backend.eval(op)

TF 1.xy TF 2.0 compatibles.

Ejemplo mínimo verificable

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)

Esto es útil porque no tiene que crear explícitamente un Sessiono InteractiveSession.

Puede verificar la salida de un TensorObject sin ejecutar el gráfico en una sesión, habilitando la ejecución ansiosa .

Simplemente agregue las siguientes dos líneas de código: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

justo después de ti import tensorflow.

La salida de print producten su ejemplo ahora será: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Tenga en cuenta que a partir de ahora (noviembre de 2017) tendrá que instalar una compilación nocturna Tensorflow para permitir una ejecución ansiosa. Las ruedas prefabricadas se pueden encontrar aquí .

Tenga en cuenta que tf.Print()cambiará el nombre del tensor. Si el tensor que desea imprimir es un marcador de posición, la alimentación de datos fallará ya que no se encontrará el nombre original durante la alimentación. Por ejemplo:

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

Salida es:

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

Debería pensar en los programas de TensorFlow Core como dos secciones discretas:

• Construyendo el gráfico computacional.
• Ejecutando el gráfico computacional.

Entonces, para el siguiente código, solo construye el gráfico computacional.

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

También debe inicializar todas las variables en un programa TensorFlow, debe llamar explícitamente a una operación especial de la siguiente manera:

init = tf.global_variables_initializer()

Ahora construye el gráfico e inicializa todas las variables, el siguiente paso es evaluar los nodos, debe ejecutar el gráfico computacional dentro de una sesión. Una sesión encapsula el control y el estado del tiempo de ejecución de TensorFlow.

El siguiente código crea un objeto Session y luego invoca su método de ejecución para ejecutar suficiente gráfica computacional para evaluar product:

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

print(sess.run([product]))

Puede usar Keras, la respuesta de una línea será usar un evalmétodo como este:

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

¡Prueba este código simple! (se explica por sí mismo)

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)

No me resultó fácil entender lo que se requiere incluso después de leer todas las respuestas hasta que ejecuté esto. TensofFlow también es nuevo para mí.

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

Pero aún puede necesitar el valor devuelto al ejecutar la sesión.

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

Básicamente, en tensorflow cuando crea un tensor de cualquier tipo, se crean y almacenan dentro, a los que solo se puede acceder cuando ejecuta una sesión de tensorflow. Digamos que usted ha creado un tensor constante
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Sin ejecutar una sesión, usted puede conseguir
- op: una operación. Operación que calcula este tensor.
- value_index: Un int. Índice del punto final de la operación que produce este tensor.
- dtype: Un DType. Tipo de elementos almacenados en este tensor.

Para obtener los valores, puede ejecutar una sesión con el tensor que necesita como:

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

La salida será algo como esto:

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

Habilite la ejecución ansiosa que se introduce en tensorflow después de la versión 1.10. Es muy fácil de usar.

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

Utilizando los consejos proporcionados en https://www.tensorflow.org/api_docs/python/tf/print , uso la log_dfunción para imprimir cadenas formateadas.

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 ahora está en desuso, aquí se explica cómo usar tf.print (p minúscula).

Si bien ejecutar una sesión es una buena opción, no siempre es el camino a seguir. Por ejemplo, es posible que desee imprimir algún tensor en una sesión particular.

El nuevo método de impresión devuelve una operación de impresión que no tiene tensores de salida:

print_op = tf.print(tensor_to_print)

Como no tiene salidas, no puede insertarlo en un gráfico de la misma manera que lo haría con tf.Print. En cambio, puede agregarlo para controlar las dependencias en su sesión para que se imprima.

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)

A veces, en un gráfico más grande, tal vez creado en parte en subfunciones, es engorroso propagar print_op a la llamada de sesión. Luego, tf.tuple se puede usar para acoplar la operación de impresión con otra operación, que luego se ejecutará con esa operación, cualquiera que sea la sesión que ejecute el código. Así es como se hace:

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.

Pregunta: ¿Cómo imprimir el valor de un objeto Tensor en TensorFlow?

Responder:

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)