python - que - tensorflow keras tutorial

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

Question

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 objeto Tensor :

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

Pero, ¿cómo sé el valor del 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 en Sessions , pero ¿no hay forma de que pueda verificar la salida de un objeto Tensor sin ejecutar el gráfico en una session ?

Answer 1

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

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

Answer 2

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 has creado un tensor constante
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Sin ejecutar una sesión, puede obtener
- 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:

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)

La salida será algo como esto:

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

Answer 3

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:

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

¡Espero eso ayude!

Answer 4

Debe 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.

init = tf.global_variables_initializer()

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

sess = tf.Session()
// run variables initializer
sess.run(init)
print(sess.run([product]))

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áfico computacional para evaluar el product :

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)

Answer 5

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

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

Answer 6

En el reciente Tensorflow 1.13.1

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

Con Tensorflow 2.0, el modo ansioso está habilitado de forma predeterminada. entonces el siguiente código funciona con TF2.0.

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

Answer 7

La forma más fácil ^[A] de evaluar el valor real de un objeto Tensor es pasarlo al método Session.run() , o llamar a Tensor.eval() cuando tiene una sesión predeterminada (es decir, en un with tf.Session(): bloquear, 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, tf.InteractiveSession permite abrir una sesión al comienzo de su programa y luego usar esa sesión para todo Tensor.eval() (y Operation.run() ) llamadas. Esto puede ser más fácil en una configuración interactiva, como el shell o un cuaderno de IPython, cuando es tedioso pasar un objeto Session todas partes. Por ejemplo, lo siguiente funciona en un cuaderno Jupyter:

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

Esto puede parecer tonto para una expresión tan pequeña, pero una de las ideas clave en Tensorflow es la ejecución diferida : es muy barato construir una expresión grande y compleja, y cuando desea evaluarla, el back-end (al que se conecta con una 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 operador tf.Print() , como sugiere Andrzej en otra respuesta . Tenga en cuenta que aún necesita ejecutar parte del gráfico para ver la salida de esta operación, que se imprime en la salida estándar. Si está ejecutando TensorFlow distribuido, tf.Print() imprimirá su salida en la salida estándar de la tarea donde se ejecuta esa operación. Esto significa que si usa https://colab.research.google.com, por ejemplo, o cualquier otro Jupyter Notebook, no verá la salida de tf.Print() en el cuaderno; en ese caso, consulte esta respuesta sobre cómo hacer que se imprima todavía.

[B]: es posible que pueda usar la función experimental tf.contrib.util.constant_value() para obtener el valor de un tensor constante, pero no está destinado para uso general, y no está definido para muchos operadores .

Answer 8

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í.

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)

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

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

Answer 9

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

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

El primer ejemplo en el que 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)
sess = tf.Session()
sess.run(m1)
print datetime.now() - startTime

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

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

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

PD que encontré donde se explica en la documentation :

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.

Answer 10

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

Responder:

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)

Answer 11

Puede usar Keras, la respuesta de una línea será usar el método eval manera:

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

Answer 12

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 import tensorflow .

La salida del print product en 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 here .

Answer 13

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

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

Salida:

import tensorflow as tf
from datetime import datetime
dim = 7000

Answer 14

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

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

Answer 15

Si bien otras respuestas son correctas y 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 run o evaluar) es usar la operación Print como en este ejemplo:

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

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

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

Answer 16

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

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

Salida es:

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

Answer 17

Utilizando los consejos proporcionados en tensorflow.org/api_docs/python/tf/print , uso la función log_d para imprimir cadenas formateadas.

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

Answer 18

tf.keras.backend.eval es útil para evaluar expresiones pequeñas.

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

TF 1.xy TF 2.0 compatibles.

Ejemplo mínimo verificable

tf.keras.backends.eval(op)

Esto es útil porque no tiene que crear explícitamente una Session o una Session InteractiveSession .

Answer 19

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)

Answer 20

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