Como imprimir o valor de um objeto Tensor no TensorFlow?

Eu tenho usado o exemplo introdutório de multiplicação de matrizes no TensorFlow.

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

Quando imprimo o produto, ele é exibido como um Tensorobjeto:

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

Mas como eu sei o valor de product?

O seguinte não ajuda:

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

Eu sei que os gráficos são executados Sessions, mas não há como verificar a saída de um Tensorobjeto sem executar o gráfico em um session?

A maneira ^{[A] mais} fácil de avaliar o valor real de um Tensorobjeto é transmiti-lo ao Session.run()método ou ligar Tensor.eval()quando você tiver uma sessão padrão (por exemplo, em um with tf.Session():bloco ou veja abaixo). Em geral ^[B] , você não pode imprimir o valor de um tensor sem executar algum código em uma sessão.

Se você está experimentando o modelo de programação e deseja uma maneira fácil de avaliar os tensores, tf.InteractiveSessionpermite abrir uma sessão no início do programa e usá-la para todas as chamadas Tensor.eval()(e Operation.run()). Isso pode ser mais fácil em um ambiente interativo, como o shell ou um notebook IPython, quando é entediante passar um Sessionobjeto por toda parte. Por exemplo, o seguinte funciona em um notebook Jupyter:

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

Isso pode parecer bobagem para uma expressão tão pequena, mas uma das idéias principais do Tensorflow 1.x é a execução adiada : é muito barato criar uma expressão grande e complexa e, quando você deseja avaliá-la, o back-end (para com o qual você se conecta a Session) pode agendar sua execução com mais eficiência (por exemplo, executando partes independentes em paralelo e usando GPUs).

[A]: Para imprimir o valor de um tensor sem retorná-lo ao seu programa Python, você pode usar o tf.print()operador, como Andrzej sugere em outra resposta . De acordo com a documentação oficial:

Para garantir que o operador seja executado, os usuários precisam passar o tf.compat.v1.Sessionmétodo de operação produzido para a operação, ou usar a operação como uma dependência de controle para operações executadas, especificando com tf.compat.v1.control_dependencies([print_op]), que é impresso na saída padrão.

Observe também que:

Nos notebooks e colabs Jupyter, tf.printimprime nas saídas da célula do notebook. Ele não será gravado nos logs do console do notebook.

[B]: Você poderá usar a tf.get_static_value()função para obter o valor constante do tensor fornecido, se o seu valor for eficientemente calculável.

Enquanto outras respostas estão corretas, você não pode imprimir o valor até avaliar o gráfico, mas elas não falam sobre uma maneira fácil de realmente imprimir um valor dentro do gráfico, depois que você o avaliar.

A maneira mais fácil de ver o valor de um tensor sempre que o gráfico é avaliado (usando runou eval) é usar a Printoperação como neste exemplo:

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

Agora, sempre que avaliarmos o gráfico inteiro, por exemplo b.eval(), usando , obtemos:

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

Reiterando o que os outros disseram, não é possível verificar os valores sem executar o gráfico.

Um trecho simples para quem procura um exemplo fácil para imprimir valores é o seguinte. O código pode ser executado sem nenhuma modificação no notebook 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))

Resultado:

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

Não, você não pode ver o conteúdo do tensor sem executar o gráfico (fazer session.run()). As únicas coisas que você pode ver são:

• a dimensionalidade do tensor (mas presumo que não seja difícil calculá-lo para a lista de operações que o TF possui)
• tipo de operação que será usada para gerar o tensor ( transpose_1:0, random_uniform:0)
• tipo de elementos no tensor ( float32)

Não encontrei isso na documentação, mas acredito que os valores das variáveis ​​(e algumas das constantes não são calculadas no momento da atribuição).

Veja este exemplo:

import tensorflow as tf
from datetime import datetime
dim = 7000

O primeiro exemplo em que eu apenas inicio um tensor constante de números aleatórios é executado aproximadamente ao mesmo tempo, independentemente 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

No segundo caso, onde a constante é realmente avaliada e os valores atribuídos, o tempo 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

E você pode deixar isso mais claro ao calcular algo ( d = tf.matrix_determinant(m1)tendo em mente que o tempo se esgotará O(dim^2.8))

PS eu encontrei onde é explicado na documentação :

Um objeto Tensor é um identificador simbólico para o resultado de uma operação, mas na verdade não mantém os valores da saída da operação.

Eu acho que você precisa acertar alguns fundamentos. Com os exemplos acima, você criou tensores (matriz multidimensional). Mas, para que o fluxo tensor funcione, é necessário iniciar uma " sessão " e executar sua " operação " na sessão. Observe a palavra "sessão" e "operação". Você precisa saber quatro coisas para trabalhar com o tensorflow:

1. tensores
2. Operações
3. Sessões
4. Gráficos

Agora, pelo que você escreveu, você forneceu o tensor e a operação, mas não possui sessão em execução nem gráfico. O tensor (bordas do gráfico) flui pelos gráficos e é manipulado por operações (nós do gráfico). Há um gráfico padrão, mas você pode iniciar o seu em uma sessão.

Quando você diz imprimir, você acessa apenas o formato da variável ou constante que você definiu.

Então você pode ver o que está perdendo:

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

Espero que ajude!

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

Com o Tensorflow 2.x, o modo ansioso é ativado por padrão. portanto, o código a seguir funciona com o 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.]]

Com base nas respostas acima, com seu snippet de código específico, você pode imprimir o produto assim:

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

No Tensorflow 2.0+ (ou no ambiente do modo Ansioso), você pode chamar o .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 é útil para avaliar pequenas expressões.

tf.keras.backend.eval(op)

TF 1.xe TF 2.0 compatíveis.

Exemplo mínimo verificável

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)

Isso é útil porque você não precisa criar explicitamente um Sessionou InteractiveSession.

Você pode verificar a saída de um TensorObject sem executar o gráfico em uma sessão, permitindo uma execução rápida .

Basta adicionar as duas linhas de código a seguir: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

logo depois de você import tensorflow.

A saída de print productno seu exemplo agora será: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Observe que, a partir de agora (novembro de 2017), você precisará instalar uma compilação noturna do Tensorflow para permitir uma execução rápida. Rodas pré-fabricadas podem ser encontradas aqui .

Observe que tf.Print()isso mudará o nome do tensor. Se o tensor que você deseja imprimir for um espaço reservado, a alimentação dos dados falhará, pois o nome original não será encontrado durante a alimentação. Por exemplo:

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

A saída é:

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

Você deve pensar nos programas do TensorFlow Core como consistindo em duas seções distintas:

• Construindo o gráfico computacional.
• Executando o gráfico computacional.

Portanto, para o código abaixo, você apenas Constrói o gráfico computacional.

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

Você também precisa Para inicializar todas as variáveis ​​em um programa TensorFlow, você deve chamar explicitamente uma operação especial da seguinte maneira:

init = tf.global_variables_initializer()

Agora você constrói o gráfico e inicializa todas as variáveis. O próximo passo é avaliar os nós; você deve executar o gráfico computacional em uma sessão. Uma sessão encapsula o controle e o estado do tempo de execução do TensorFlow.

O código a seguir cria um objeto Session e chama seu método run para executar o suficiente do gráfico computacional para avaliar product:

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

print(sess.run([product]))

Você pode usar o Keras, a resposta em uma linha será usar o evalmétodo da seguinte forma:

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

Experimente este código simples! (é auto-explicativo)

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)

Não achei fácil entender o que é necessário, mesmo depois de ler todas as respostas até executar isso. O TensofFlow também é novo para mim.

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

Mas você ainda pode precisar do valor retornado executando a sessão.

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

Basicamente, no tensorflow, quando você cria um tensor de qualquer tipo, ele é criado e armazenado dentro do qual só pode ser acessado quando você executa uma sessão de tensorflow. Digamos que você tenha criado um tensor constante
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Sem executar uma sessão, você pode obter
- op: Uma Operação. Operação que calcula este tensor.
- value_index: Um int. Índice do terminal da operação que produz esse tensor.
- dtype: um DType. Tipo de elementos armazenados neste tensor.

Para obter os valores, você pode executar uma sessão com o tensor necessário, como:

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

A saída será algo como isto:

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

Habilite a execução rápida que é introduzida no tensorflow após a versão 1.10. É muito 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)

Usando as dicas fornecidas em https://www.tensorflow.org/api_docs/python/tf/print , uso a log_dfunção para imprimir seqüências de caracteres formatadas.

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

Agora, o tf.Print está obsoleto. Veja como usar o tf.print (letra minúscula p).

Embora a execução de uma sessão seja uma boa opção, nem sempre é o caminho a percorrer. Por exemplo, você pode imprimir algum tensor em uma sessão específica.

O novo método de impressão retorna uma operação de impressão que não possui tensores de saída:

print_op = tf.print(tensor_to_print)

Como não possui saídas, não é possível inseri-lo em um gráfico da mesma maneira que faria com tf.Print. Em vez disso, você pode adicioná-lo para controlar as dependências da sua sessão para imprimi-la.

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)

Às vezes, em um gráfico maior, talvez criado parcialmente em subfunções, é complicado propagar o print_op para a chamada da sessão. Em seguida, tf.tuple pode ser usado para associar a operação de impressão a outra operação, que será executada com essa operação, independentemente da sessão que executar o código. Aqui está como isso é feito:

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.

Pergunta: Como imprimir o valor de um objeto Tensor no TensorFlow?

Responda:

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)