Solving problem is about exposing yourself to as many situations as possible like How to print the value of a Tensor object in TensorFlow? and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about How to print the value of a Tensor object in TensorFlow?, which can be followed any time. Take easy to follow this discuss.
I have been using the introductory example of matrix multiplication in TensorFlow.
matrix1 = tf.constant([[3., 3.]]) matrix2 = tf.constant([[2.],[2.]]) product = tf.matmul(matrix1, matrix2)
When I print the product, it is displaying it as a
<tensorflow.python.framework.ops.Tensor object at 0x10470fcd0>
But how do I know the value of
The following doesn’t help:
print product Tensor("MatMul:0", shape=TensorShape([Dimension(1), Dimension(1)]), dtype=float32)
I know that graphs run on
Sessions, but isn’t there any way I can check the output of a
Tensor object without running the graph in a
The easiest[A] way to evaluate the actual value of a
Tensor object is to pass it to the
Session.run() method, or call
Tensor.eval() when you have a default session (i.e. in a
with tf.Session(): block, or see below). In general[B], you cannot print the value of a tensor without running some code in a session.
If you are experimenting with the programming model, and want an easy way to evaluate tensors, the
tf.InteractiveSession lets you open a session at the start of your program, and then use that session for all
Operation.run()) calls. This can be easier in an interactive setting, such as the shell or an IPython notebook, when it’s tedious to pass around a
Session object everywhere. For example, the following works in a Jupyter notebook:
with tf.Session() as sess: print(product.eval())
This might seem silly for such a small expression, but one of the key ideas in Tensorflow 1.x is deferred execution: it’s very cheap to build a large and complex expression, and when you want to evaluate it, the back-end (to which you connect with a
Session) is able to schedule its execution more efficiently (e.g. executing independent parts in parallel and using GPUs).
To make sure the operator runs, users need to pass the produced op to
tf.compat.v1.Session‘s run method, or to use the op as a control dependency for executed ops by specifying with
tf.compat.v1.control_dependencies([print_op]), which is printed to standard output.
Also note that:
In Jupyter notebooks and colabs,
tf.printprints to the notebook cell outputs. It will not write to the notebook kernel’s console logs.
[B]: You might be able to use the
tf.get_static_value() function to get the constant value of the given tensor if its value is efficiently calculable.
While other answers are correct that you cannot print the value until you evaluate the graph, they do not talk about one easy way of actually printing a value inside the graph, once you evaluate it.
The easiest way to see a value of a tensor whenever the graph is evaluated (using
eval) is to use the
# 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)
Now, whenever we evaluate the whole graph, e.g. using
b.eval(), we get:
I tensorflow/core/kernels/logging_ops.cc:79] This is a: [1 3]
Reiterating what others said, its not possible to check the values without running the graph.
A simple snippet for anyone looking for an easy example to print values is as below. The code can be executed without any modification in ipython notebook
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))
[[-0.16702934 0.07173464 -0.04512421] [-0.02265321 0.06509651 -0.01419079]]
No, you can not see the content of the tensor without running the graph (doing
session.run()). The only things you can see are:
- the dimensionality of the tensor (but I assume it is not hard to calculate it for the list of the operations that TF has)
- type of the operation that will be used to generate the tensor (
- type of elements in the tensor (
I have not found this in documentation, but I believe that the values of the variables (and some of the constants are not calculated at the time of assignment).
Take a look at this example:
import tensorflow as tf from datetime import datetime dim = 7000
The first example where I just initiate a constant Tensor of random numbers run approximately the same time irrespectibly of dim (
startTime = datetime.now() m1 = tf.truncated_normal([dim, dim], mean=0.0, stddev=0.02, dtype=tf.float32, seed=1) print datetime.now() - startTime
In the second case, where the constant is actually gets evaluated and the values are assigned, the time clearly depends on dim (
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
And you can make it more clear by calculating something (
d = tf.matrix_determinant(m1), keeping in mind that the time will run in
P.S. I found were it is explained in documentation:
A Tensor object is a symbolic handle to the result of an operation,
but does not actually hold the values of the operation’s output.
I think you need to get some fundamentals right. With the examples above you have created tensors (multi dimensional array). But for tensor flow to really work you have to initiate a “session” and run your “operation” in the session. Notice the word “session” and “operation”.
You need to know 4 things to work with tensorflow:
Now from what you wrote out you have given the tensor, and the operation but you have no session running nor a graph. Tensor (edges of the graph) flow through graphs and are manipulated by operations (nodes of the graph). There is default graph but you can initiate yours in a session.
When you say print , you only access the shape of the variable or constant you defined.
So you can see what you are missing :
with tf.Session() as sess: print(sess.run(product)) print (product.eval())
Hope it helps!
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.]]
With Tensorflow 2.x, eager mode is enabled by default. so the following code works with 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.]]
tf.keras.backend.eval is useful for evaluating small expressions.
TF 1.x and TF 2.0 compatible.
Minimal Verifiable Example
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)
This is useful because you do not have to explicitly create a
Based on the answers above, with your particular code snippet you can print the product like this:
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()