Como imprimir o valor de um objeto Tensor no TensorFlow?

259

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?

Dawny33
fonte

Respostas:

250

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.

mrry
fonte
17
É possível obter alguns atributos de um tensor sem chamar Session.run (). Por exemplo, você pode chamar tensor.get_shape (). Em muitos casos, isso fornece informações suficientes para depuração.
23716 Ian Goodfellow
5
Consulte também a resposta de And sobre a operação tf.Print abaixo. Eu continuo encontrando essa resposta do stackoverflow enquanto pesquisava "impressão de fluxo tensor" e essa resposta superior faz parecer que não há tf.Print op.
23716 Ian Goodfellow
2
Eu adicionei algumas advertências à resposta, então deve ficar mais claro agora. (Eu não acho que a pergunta original foi interessado em obter a forma de um tensor, apenas o valor.)
mrry
1
Existe uma maneira de salvar em um arquivo em vez de imprimir no console (via tf.Print)?
thang
tf.Session()não funciona no Tensorflow 2. Você pode usar tf.compat.v1.Session().
mic
158

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]
Andrzej Pronobis
fonte
37
é MUITO importante que você use a de a = tf.print em outra coisa! tf.print (a, [a]) não fará nada de outra maneira
Fábio Dias
5
Podemos apenas usar a.eval()então!
Udayraj Deshmukh
1
@FabioDias Acho que não entendi seu ponto? Poderia, por favor, elaborar gentilmente quando tiver tempo ...
yuqli
7
Observe que tf.Print()foi preterido e (agora) removido. Em vez disso, use tf.print(). Consulte docs: tensorflow.org/api_docs/python/tf/Print e tensorflow.org/api_docs/python/tf/print .
Hefesto
1
wow Estou surpreso ao ver meu próprio comentário um ano depois @yuqli, mas agora entendo o que ele disse. Veja esta postagem, que ainda trata da API descontinuada, mas as idéias provavelmente são semelhantes.
precisa saber é
27

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]]
Jeevan
fonte
2
Apenas FYI:WARNING:tensorflow:From <ipython-input-25-8583e1c5b3d6>:1: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02. Instructions for updating: Use 'tf.global_variables_initializer' instead.
Mark Cramer
20

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.

Salvador Dalí
fonte
15

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!

sorriso
fonte
13

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.]]
Vishnuvardhan Janapati
fonte
1
Instalei o TensorFlow versão 1.13.2 e habilitei a execução rápida (verifiquei se estiver executando com tf.executing_eagerly ()) e obtendo o erro 'O objeto' Tensor 'não tem atributo' numpy 'ao tentar avaliar o valor do tensor na função de perda personalizada. Eu realmente aprecio qualquer ajuda para resolver o problema.
Niko Gamulin
1
@NikoGamulin verifique se você colocou tf.compat.v1.enable_eager_execution () no início do seu script. Eu tenho a versão 1.14.0, estou executando meu script em PyCharm e tensor.numpy () funciona
Tommaso Di Noto
1
@NikoGamulin esse erro aparece apenas quando você está tentando acessar um tensor no modo Gráfico. Eu acho que, pode ser ansioso execução não foi habilitado corretamente. Para verificar a execução rápida, basta definir aa = tf.constant (2.0), b = tf.constant (3.0), print (tf.add (a, b)). Se você vir a resposta como 5.0, o ansioso foi ativado corretamente.
Janish Vishnuvardhan
9

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()
Ben
fonte
8

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()) 
Madiyar
fonte
tf.print(product)também me dá a mesma saída que print(product.numpy())com o TF 2.0.
HUSMEN 20/10/19
8

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.

cs95
fonte
7

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 .

Giorgos Sfikas
fonte
5

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
npit
fonte
5

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]))
Ahmed Gamal
fonte
4

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))
CKM
fonte
3

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)
Ganindu
fonte
2

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()
Mohan Radhakrishnan
fonte
1

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)

Bhaskar Chakradhar
fonte
1

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)
Aashish Dahiya
fonte
1

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)
Batta
fonte
0
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()
Prakhar Agarwal
fonte
0

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.
Tore Rudberg
fonte
-2

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