Как напечатать значение объекта Tensor в TensorFlow?

Я использовал вводный пример умножения матриц в 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?

Самый простой способ ^[A] оценить действительное значение Tensorобъекта - передать его Session.run()методу или вызвать, Tensor.eval()когда у вас есть сеанс по умолчанию (т. Е. В with tf.Session():блоке или см. Ниже). В общем случае ^[B] вы не можете распечатать значение тензора без выполнения некоторого кода в сеансе.

Если вы экспериментируете с моделью программирования и хотите получить простой способ оценки тензоров, то tf.InteractiveSessionвы можете открыть сеанс в начале вашей программы, а затем использовать этот сеанс для всех Tensor.eval()(и Operation.run()) вызовов. Это может быть проще в интерактивном режиме, например, в оболочке или записной книжке IPython, когда утомительно обходить Sessionобъект повсюду. Например, в блокноте Jupyter работает следующее:

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

Это может показаться глупым для такого маленького выражения, но одна из ключевых идей в Tensorflow 1.x - это отложенное выполнение : создание большого и сложного выражения очень дешево, а когда вы хотите его оценить, - с которым вы соединяетесь Session) может более эффективно планировать его выполнение (например, параллельное выполнение независимых частей и использование графических процессоров).

[A]: Чтобы напечатать значение тензора, не возвращая его в вашу программу Python, вы можете использовать tf.print()оператор, как предлагает Анджей в другом ответе . Согласно официальной документации:

Чтобы оператор tf.compat.v1.Sessionвыполнялся , пользователи должны передать произведенный оператор методу run или использовать оператор в качестве управляющей зависимости для выполняемых операций, указав с помощью tf.compat.v1.control_dependencies([print_op]), который выводится на стандартный вывод.

Также обратите внимание, что:

В записных книжках и колабах Jupyter tf.printпечатает на выходах ячейки записной книжки. Он не будет записывать в журналы консоли ядра ноутбука.

[B]: Вы можете использовать tf.get_static_value()функцию для получения постоянного значения данного тензора, если его значение эффективно рассчитывается.

Хотя другие ответы верны, вы не можете напечатать значение до тех пор, пока не оцените график, но они не говорят об одном простом способе фактической печати значения внутри графика после его оценки.

Самый простой способ увидеть значение тензора при оценке графа (с помощью 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]

Повторяя то, что говорили другие, невозможно проверить значения без запуска графика.

Простой фрагмент кода для тех, кто ищет простой пример для печати значений, приведен ниже. Код может быть выполнен без каких-либо изменений в ноутбуке 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))

Вывод:

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

Нет, вы не можете увидеть содержимое тензора без запуска графика (делать session.run()). Единственное, что вы можете увидеть:

• размерность тензора (но я предполагаю, что нетрудно вычислить его для списка операций которые имеет TF)
• тип операции, которая будет использоваться для генерации тензора ( 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))

PS Я нашел, это было объяснено в документации :

Объект Tensor является символическим дескриптором результата операции, но на самом деле не содержит значений выходных данных операции.

Я думаю, вам нужно правильно разобраться в некоторых основах. В приведенных выше примерах вы создали тензоры (многомерный массив). Но чтобы тензорный поток действительно работал, вы должны инициировать « сеанс » и запустить « операцию » в сеансе. Обратите внимание на слова «сессия» и «операция». Вам нужно знать 4 вещи для работы с tenorflow:

1. тензоры
2. операции
3. сессии
4. диаграммы

Теперь из того, что вы написали, вы дали тензор и операцию, но у вас нет ни сеанса, ни графика. Тензор (ребра графа) проходят через графы и управляются операциями (узлами графа). Есть график по умолчанию, но вы можете инициировать свой в сеансе.

Когда вы говорите «печать», вы получаете доступ только к форме определенной вами переменной или константы.

Таким образом, вы можете увидеть, что вам не хватает:

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

Надеюсь, поможет!

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

Основываясь на ответах выше, вы можете распечатать продукт следующим образом:

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

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

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.

Вы можете проверить вывод TensorObject, не запуская график в сеансе, включив активное выполнение .

Просто добавьте следующие две строки кода: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

сразу после тебя import tensorflow.

Вывод print productв вашем примере теперь будет: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Обратите внимание, что на данный момент (ноябрь 2017 года) вам необходимо установить ночную сборку Tensorflow, чтобы обеспечить активное выполнение. Готовые колеса можно найти здесь .

Обратите внимание, что 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

Вы должны думать о программах TensorFlow Core как о двух отдельных разделах:

• Построение вычислительного графа.
• Запуск вычислительного графа.

Поэтому для приведенного ниже кода вы просто строите вычислительный граф.

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

Вам также необходимо инициализировать все переменные в программе TensorFlow, вы должны явно вызвать специальную операцию следующим образом:

init = tf.global_variables_initializer()

Теперь вы строите график и инициализируете все переменные, следующим шагом является оценка узлов, вы должны запустить вычислительный граф в течение сеанса. Сеанс инкапсулирует управление и состояние среды выполнения TensorFlow.

Следующий код создает объект Session, а затем вызывает его метод run для запуска достаточного количества вычислительного графа для оценки product:

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

print(sess.run([product]))

Вы можете использовать Keras, однострочный ответ будет использовать evalметод следующим образом:

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

Попробуйте этот простой код! (это говорит само за себя)

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)

Мне было нелегко понять, что требуется, даже после прочтения всех ответов, пока я не выполнил это. 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()

По сути, в тензорном потоке, когда вы создаете тензор любого рода, они создаются и хранятся внутри, к которым можно получить доступ только при запуске сеанса тензорного потока. Допустим, вы создали постоянный тензор.
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Не запуская сеанс, вы можете получить :
- opОперацию. Операция, которая вычисляет этот тензор.
- value_indexInt. Индекс конечной точки операции, которая производит этот тензор.
-dtype : DType. Тип элементов хранится в этом тензоре.

Чтобы получить значения, вы можете запустить сеанс с нужным вам тензором:

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

Вывод будет примерно таким:

массив ([[1., 2., 3.], [4., 5., 6.]], dtype = float32)

Включите активное выполнение, которое представлено в tenorflow после версии 1.10. Это очень просто в использовании.

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

Используя советы, представленные в 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)

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 устарела, вот как вместо этого использовать tf.print (строчная p).

Хотя запуск сеанса является хорошим вариантом, это не всегда правильный путь. Например, вы можете напечатать тензор в конкретном сеансе.

Новый метод печати возвращает операцию печати, у которой нет выходных тензоров:

print_op = tf.print(tensor_to_print)

Поскольку он не имеет выходных данных, вы не можете вставить его в график так же, как вы могли бы использовать tf.Print. Вместо этого вы можете добавить его для управления зависимостями в сеансе, чтобы сделать его печатным.

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 на вызов сеанса. Затем tf.tuple можно использовать для связывания операции печати с другой операцией, которая затем будет выполняться с этой операцией в зависимости от того, какой сеанс выполняет код. Вот как это делается:

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.

Вопрос: Как напечатать значение объекта Tensor в TensorFlow?

Ответ:

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)