Come stampare il valore di un oggetto Tensor in TensorFlow?

Question

Ho utilizzato l'esempio introduttivo della moltiplicazione della matrice in TensorFlow.

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

Quando stampo il prodotto, si sta visualizzando come un oggetto Tensor:

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

Ma come faccio a sapere il valore di product?

Quanto segue non aiuta:

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

so che i grafici eseguiti sul Sessions, ma non c'è un modo per controllare l'output di un oggetto Tensor senza correre il grafico in una session?

Answer 1

Il * modo più semplice per valutare il valore reale di un oggetto Tensor è quello di passare al metodo Session.run(), oppure chiamare Tensor.eval() quando si dispone di una sessione di default (cioè in un blocco with tf.Session():, o vedi sotto). In generale, ** non è possibile stampare il valore di un tensore senza eseguire alcun codice in una sessione.

Se si stanno sperimentando con il modello di programmazione, e volete un modo semplice per valutare tensori, il tf.InteractiveSession consente di aprire una sessione all'inizio del vostro programma, e quindi utilizzare tale sessione per tutta Tensor.eval() (e Operation.run()) chiama. Questo può essere più semplice in un'impostazione interattiva, come la shell o un notebook IPython, quando è noioso passare intorno a un oggetto Session ovunque.

Questo potrebbe sembrare sciocco per un piccolo un'espressione così, ma una delle idee chiave in tensorflow è esecuzione differita: è molto a buon mercato per costruire una grande e complessa espressione, e quando si vuole valutare, il back- end (a cui ci si connette con un Session) è in grado di pianificare la sua esecuzione in modo più efficiente (ad esempio eseguendo parti indipendenti in parallelo e utilizzando GPU).

---

*   Per stampare il valore di un tensore senza tornare al vostro programma Python, è possibile utilizzare l'operatore tf.Print(), come Andrzej suggests in another answer. Si noti che è ancora necessario eseguire parte del grafico per vedere l'output di questo op, che viene stampato sullo standard output. Se stai distribuendo TensorFlow distribuito, tf.Print() stamperà il suo output sullo standard output dell'attività in cui viene eseguito quell'op.

**   È potrebbe essere in grado di utilizzare la funzione sperimentale tf.contrib.util.constant_value() per ottenere il valore di un tensore costante, ma non è inteso per uso generale, e non è definito per molti operatori.

Answer 2

No, non è possibile visualizzare il contenuto del tensore senza eseguire il grafico (facendo session.run()).Le uniche cose che si possono vedere sono:

• la dimensionalità del tensore (ma suppongo che non è difficile calcolare per la list of the operations che TF ha)
• tipo di operazione che verrà utilizzato per generare il tensore (transpose_1:0, random_uniform:0)
• tipo di elementi nel tensore (float32)

non ho trovato questo nella documentazione, ma credo che i valori delle variabili (e alcune delle costanti non sono calcolati al momento dell'assegnazione).

---

Date un'occhiata a questo esempio:

import tensorflow as tf 
from datetime import datetime 
dim = 7000 

Il primo esempio dove ho appena inizio una Tensor costante di numeri casuali gestiscono circa alla stessa ora irrespectibly di 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 

Nel secondo caso, dove viene effettivamente valutata la costante e vengono assegnati i valori, il tempo dipende chiaramente dalla luminosità (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 si può rendere più chiaro calcolando qualcosa (d = tf.matrix_determinant(m1), tenendo presente che il tempo sarà eseguito in O(dim^2.8))

P.S. Ho trovato erano è spiegato in documentation:

un tensore oggetto è un handle simbolico al risultato di un'operazione, ma in realtà non memorizzare i valori di uscita del funzionamento.

Answer 3

Mentre altre risposte sono corrette che non è possibile stampare il valore finché non si valuta il grafico, non si parla di un modo semplice di stampare effettivamente un valore all'interno del grafico, dopo averlo valutato.

Il modo più semplice per visualizzare un valore di un tensore ogniqualvolta viene valutato il grafico (usando run o eval) è quello di utilizzare l'operazione Print come in questo esempio:

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

Ora, quando si valuta l'intera grafico, ad es utilizzando b.eval(), otteniamo:

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

Answer 4

Ribadendo ciò che gli altri hanno detto, non è possibile controllare i valori senza correre il grafico.

Un semplice frammento per chi cerca un esempio semplice per stampare valori è il seguente.Il codice può essere eseguito senza alcuna modifica in 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)) 

uscita:

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

Answer 5

Sulla base delle risposte di cui sopra, con il codice particolare frammento è possibile stampare il prodotto come questo:

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

Prova questo semplice codice! (è auto esplicativo)

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

Penso che sia necessario ottenere alcune nozioni fondamentali. Con gli esempi sopra hai creato tensori (array multidimensionale). Tuttavia, affinché il flusso tensoriale funzioni realmente, è necessario avviare una "sessione" ed eseguire l'operazione "" nella sessione. Si noti la parola "sessione" e "operazione". Hai bisogno di sapere 4 cose da lavorare con tensorflow:

1. tensori
2. Operations
3. Sessions
4. Grafici

Ora da quello che hai scritto fuori hai dato il tensore, e l'operazione ma non hai una sessione in corso o un grafico. Il tensore (bordi del grafico) scorre attraverso i grafici e viene manipolato dalle operazioni (nodi del grafico). C'è un grafico predefinito ma puoi iniziare il tuo in una sessione.

Quando si dice stampa, si accede solo alla forma della variabile o della costante definita.

Così si può vedere che cosa ti manca:

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

Speranza che aiuta!

Answer 8

Si prega di notare che tf.Print() cambierà il nome del tensore. Se il tensore che si desidera stampare è un segnaposto, l'alimentazione dei dati ad esso avrà esito negativo poiché il nome originale non verrà trovato durante l'alimentazione. Per esempio:

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

uscita è:

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

si dovrebbe pensare di programmi tensorflow core come costituito da due sezioni distinte:

• Costruire il grafico computazionale.
• Esecuzione del grafico computazionale.

Quindi per il codice seguente è sufficiente creare il grafico computazionale.

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

è necessario anche inizializzare tutte le variabili in un programma tensorflow, è necessario chiamare in modo esplicito di un'operazione speciale nel seguente modo:

init = tf.global_variables_initializer() 

Ora si costruisce il grafico e inizializzato tutte le variabili, il prossimo passo è per valutare i nodi, è necessario eseguire il grafico computazionale all'interno di una sessione. Una sessione incapsula il controllo e lo stato del runtime TensorFlow.

Il codice seguente crea un oggetto di sessione e poi invoca il suo metodo run per eseguire abbastanza del grafico di calcolo per valutare product:

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

print(sess.run([product])) 

Answer 10

È possibile controllare l'output di un TensorObject senza correre il grafico in una sessione , abilitando eager execution.

Basta aggiungere le seguenti due righe di codice: import tensorflow.contrib.eager as tfe tfe.enable_eager_execution()

subito dopo si import tensorflow.

L'uscita del print product nel tuo esempio sarà ora: tf.Tensor([[ 12.]], shape=(1, 1), dtype=float32)

Nota che a partire da oggi (novembre 2017) si dovrà installare un tensorflow nightly build per consentire l'esecuzione ansioso. Le ruote pre-costruite possono essere trovate here.