如何在 TensorFlow 中打印 Tensor 对象的值？

Question

我一直在使用 TensorFlow 中矩阵乘法的入门示例。

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

当我打印产品时，它显示为 Tensor 对象：

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

但是我怎么知道 product 的值呢？

以下没有帮助：

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

我知道运行在 Sessions 上的图表，但是没有任何方法可以在不运行图表的情况下检查 Tensor 对象的输出在 session?

Answer 1

评估 Tensor 对象实际值的最简单^[A] 方法是将其传递给 Session.run() 方法，或调用 Tensor.eval() 当你有一个默认会话时（即在 with tf.Session(): 块中，或见下文）。一般来说^[B]，如果没有运行会话中的一些代码，你无法打印张量的值。

如果您正在试验编程模型，并且想要一种简单的方法来评估张量，tf.InteractiveSession 允许您在程序开始时打开一个会话，然后将该会话用于所有 Tensor.eval()（和 Operation.run()）调用。这在交互式设置中会更容易，例如 shell 或 IPython 笔记本，因为到处传递 Session 对象很乏味。例如，以下在 Jupyter notebook 中有效：

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

对于这么小的表达式，这可能看起来很愚蠢，但 Tensorflow 1.x 的关键思想之一是 延迟执行：构建一个大且复杂的表达式，当你想计算它时，后端（你用 Session 连接到它）能够更有效地安排它的执行（例如并行执行独立部分和使用 GPU）。

[A]：要打印张量的值而不将其返回到您的 Python 程序，您可以使用 tf.print() operator, as 。根据官方文档：

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.

另请注意：

In Jupyter notebooks and colabs, tf.print prints to the notebook cell outputs. It will not write to the notebook kernel's console logs.

[B]：你可能能够使用tf.get_static_value()函数来获得给定张量的常数值，如果它的值是可有效计算的。

Answer 2

不，如果不运行绘制图表（session.run()），您将看不到张量的内容。您唯一可以看到的是：

张量的维数（但我认为对于 TF 具有的 list of the operations 计算它并不难）
将用于生成张量的操作类型（transpose_1:0、random_uniform:0）
张量中的元素类型 (float32)

我没有在文档中找到这个，但我相信变量的值（和一些常量在赋值时没有计算）。

看看这个例子：

import tensorflow as tf
from datetime import datetime
dim = 7000

第一个例子，我只是在几乎相同的时间启动一个随机数的常量张量运行，与 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

在第二种情况下，实际计算常量并分配值，时间显然取决于 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

你可以通过一些计算让它更清楚（d = tf.matrix_determinant(m1)，记住时间会运行在 O(dim^2.8)）

P.S。我发现它在 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.

Answer 3

虽然其他答案是正确的，即在评估图形之前无法打印值，但他们并没有谈论一种在评估图形后实际打印值的简单方法。

每当计算图形（使用 run 或 eval）时，查看张量值的最简单方法是使用 Print 操作，如本例所示：

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

现在，每当我们评估整个图时，例如使用 b.eval()，我们得到：

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

Answer 4

重申其他人所说的，没有运行图表无法检查值。

对于任何正在寻找打印值的简单示例的人来说，一个简单的代码段如下所示。代码在ipythonnotebook

中无需任何修改即可执行

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

Answer 5

根据以上答案，使用您的特定代码片段，您可以像这样打印产品：

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 6

试试这个简单的代码！（这是不言自明的）

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 7

我认为您需要掌握一些基本知识。通过上面的示例，您已经创建了张量（多维数组）。但是要使张量流真正起作用，您必须在会话中启动“session”和运行您的“operation”。注意单词 "session" 和 "operation"。要使用 tensorflow，您需要知道 4 件事：

张量
运营
会话
图表

现在根据你写的内容，你已经给出了张量和操作，但你没有会话运行ning 也没有图表。张量（图的边）流经图并由操作（图的节点）操纵。有默认图表，但您可以在会话中启动您的图表。

当你说 print 时，你只能访问你定义的变量或常量的形状。

所以你可以看到你错过了什么:

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

希望对您有所帮助！

Answer 8

请注意，tf.Print() 将更改张量名称。如果您要打印的张量是一个占位符，则向其提供数据将失败，因为在提供过程中将找不到原始名称。例如：

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

输出为：

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

Answer 9

您应该将 TensorFlow Core 程序视为由两个独立的部分组成：

构建计算图。
运行计算图。

因此对于下面的代码，您只需构建计算图。

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

你还需要初始化一个TensorFlow程序中的所有变量，你必须显式调用一个特殊的操作如下：

init = tf.global_variables_initializer()

现在您构建了图并初始化了所有变量，下一步是评估节点，您必须运行会话中的计算图。一个session封装了TensorFlow的控制和状态运行time.

以下代码创建一个 Session 对象，然后调用其运行方法来运行足够的计算图来评估 product :

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

print(sess.run([product]))

Answer 10

您可以通过启用 eager execution.

在会话中检查没有运行图的 TensorObject 的输出

只需添加以下两行代码： import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

就在你之后 import tensorflow.

您示例中 print product 的输出现在将是： tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

请注意，截至目前（2017 年 11 月），您必须安装 Tensorflow 每晚构建以启用即时执行。可以找到预制轮子 here。

Answer 11

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

在我执行此操作之前，即使在阅读了所有答案之后，我也很难理解需要什么。 TensofFlow 对我来说也是新手。

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

但您可能仍然需要执行会话返回的值。

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

Answer 13

基本上，在 tensorflow 中，当您创建任何类型的张量时，它们都会被创建并存储在其中，只有当您运行一个 tensorflow 会话时才能访问它们。假设您创建了一个常量张量
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
无需运行会话，您可以获得
- op：一个操作。计算此张量的操作。
- value_index：一个整数。生成此张量的操作端点的索引。
- dtype：一个 DType。此张量中存储的元素类型。

要获得这些值，您可以运行使用您需要的张量进行会话：

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

输出将是这样的：

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

Answer 14

问：如何在TensorFlow中打印Tensor对象的值？

答案：

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)

Answer 15

在Tensorflow 2.0+（或Eager模式环境下）可以调用.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 16

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

使用 Tensorflow 2.x，默认情况下启用急切模式。所以下面的代码适用于 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.]]

Answer 17

启用tensorflow 1.10版本后引入的eager execution。非常好用。

# 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 对于计算小表达式很有用。

tf.keras.backend.eval(op)

TF 1.x 和 TF 2.0 兼容。

最小可验证示例

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)

这很有用，因为您不必显式创建 Session 或 InteractiveSession。

Answer 19

您可以使用 Keras，单行答案将是使用 eval 方法，如下所示：

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

Answer 20

使用 https://www.tensorflow.org/api_docs/python/tf/print 中提供的提示，我使用 log_d 函数打印格式化字符串。

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 21

tf.Print 现已弃用，以下是使用 tf.print（小写 p）的方法。

虽然运行宁 session 是一个不错的选择，但并不总是可行的方法。例如，您可能想在特定的 session.

中打印一些张量

新的打印方法returns没有输出张量的打印操作：

print_op = tf.print(tensor_to_print)

由于它没有输出，因此您不能像使用 tf.Print 那样将其插入图表中。相反，您可以添加它来控制 session 中的依赖项以使其打印。

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)

有时，在更大的图中，可能部分在子函数中创建，将 print_op 传播到 session 调用很麻烦。然后，tf.tuple 可用于将打印操作与另一个操作耦合，然后运行将与 session 执行代码的那个操作相结合。这是如何完成的：

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.

Answer 22

在 Tensorflow V2 中，张量的打印值使用：tf.keras.backend.print_tensor(x, message='')

Answer 23

我不确定我是否遗漏了这里，但我认为最简单和最好的方法是使用 tf.keras.backend.get_value API.

print(product)
>>tf.Tensor([[12.]], shape=(1, 1), dtype=float32)
print(tf.keras.backend.get_value(product))
>>[[12.]]

Answer 24

您可以在会话中打印出张量值，如下所示：

import tensorflow as tf

a = tf.constant([1, 1.5, 2.5], dtype=tf.float32)
b = tf.constant([1, -2, 3], dtype=tf.float32)
c = a * b

with tf.Session() as sess:
    result = c.eval()
   
print(result)

如何在 TensorFlow 中打印 Tensor 对象的值？

How to print the value of a Tensor object in TensorFlow?

python

tensorflow

tensor