Come stampare il valore di un oggetto Tensor in TensorFlow?

Ho usato l'esempio introduttivo della moltiplicazione di matrici in TensorFlow.

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

Quando stampo il prodotto, viene visualizzato come Tensoroggetto:

<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 funzionano Sessions, ma non c'è modo di controllare l'output di un Tensoroggetto senza eseguire il grafico in un session?

Il modo più semplice ^[A] per valutare il valore effettivo di un Tensoroggetto è passarlo al Session.run()metodo o chiamare Tensor.eval()quando si dispone di una sessione predefinita (ovvero in un with tf.Session():blocco o vedere di seguito). In generale ^[B] , non è possibile stampare il valore di un tensore senza eseguire un codice in una sessione.

Se stai sperimentando il modello di programmazione e desideri un modo semplice per valutare i tensori, tf.InteractiveSessionti consente di aprire una sessione all'inizio del programma e quindi utilizzare quella sessione per tutte Tensor.eval()(e Operation.run()) le chiamate. Ciò può essere più semplice in un'impostazione interattiva, come la shell o un notebook IPython, quando è noioso passare un Sessionoggetto ovunque. Ad esempio, quanto segue funziona in un notebook Jupyter:

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

Questo potrebbe sembrare sciocco per un'espressione così piccola, ma una delle idee chiave in Tensorflow 1.x è l' esecuzione differita : è molto economico costruire un'espressione grande e complessa e quando vuoi valutarla, il back-end ( con cui ti colleghi a Session) è in grado di pianificare la sua esecuzione in modo più efficiente (ad es. eseguendo parti indipendenti in parallelo e usando GPU).

[A]: per stampare il valore di un tensore senza restituirlo al programma Python, è possibile utilizzare l' tf.print()operatore, come suggerisce Andrzej in un'altra risposta . Secondo la documentazione ufficiale:

Per assicurarsi che l'operatore tf.compat.v1.Sessionfunzioni , gli utenti devono passare l'operazione prodotta al metodo di esecuzione o utilizzare l'op come dipendenza di controllo per le operazioni eseguite specificando con tf.compat.v1.control_dependencies([print_op]), che viene stampato sull'output standard.

Si noti inoltre che:

Nei notebook e nei colab Jupyter, tf.printstampa sulle uscite delle celle del notebook. Non scriverà nei log della console del kernel del notebook.

[B]: potresti essere in grado di utilizzare la tf.get_static_value()funzione per ottenere il valore costante del tensore dato se il suo valore è calcolabile in modo efficiente.

Mentre altre risposte sono corrette sul fatto che non è possibile stampare il valore fino a quando non si valuta il grafico, non parlano di un modo semplice per stampare effettivamente un valore all'interno del grafico, una volta valutato.

Il modo più semplice per vedere un valore di un tensore ogni volta che il grafico viene valutato (usando runo eval) è usare l' Printoperazione 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, ogni volta che valutiamo l'intero grafico, ad esempio utilizzando b.eval(), otteniamo:

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

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

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

Produzione:

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

No, non puoi vedere il contenuto del tensore senza eseguire il grafico (facendo session.run()). Le uniche cose che puoi vedere sono:

• la dimensionalità del tensore (ma suppongo che non sia difficile calcolarlo per l' elenco delle operazioni che TF ha)
• tipo di operazione che verrà utilizzata per generare il tensore ( transpose_1:0, random_uniform:0)
• tipo di elementi nel tensore ( float32)

Non l'ho trovato nella documentazione, ma credo che i valori delle variabili (e alcune delle costanti non siano calcolate al momento dell'assegnazione).

Dai un'occhiata a questo esempio:

import tensorflow as tf
from datetime import datetime
dim = 7000

Il primo esempio in cui ho appena avviato un tensore costante di numeri casuali viene eseguito all'incirca nello stesso momento, indipendentemente da 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, in cui la costante viene effettivamente valutata e i valori assegnati, il tempo dipende chiaramente da 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 puoi renderlo più chiaro calcolando qualcosa ( d = tf.matrix_determinant(m1), tenendo presente che il tempo scadrà O(dim^2.8))

PS ho trovato dove è spiegato documentazione :

Un oggetto Tensore è un handle simbolico al risultato di un'operazione, ma in realtà non contiene i valori dell'output dell'operazione.

Penso che tu abbia bisogno di capire bene alcuni fondamenti. Con gli esempi precedenti hai creato tensori (array multidimensionale). Ma affinché il flusso di tensore funzioni davvero, devi avviare una " sessione " ed eseguire la tua " operazione " nella sessione. Notare la parola "sessione" e "operazione". Devi sapere 4 cose per lavorare con tensorflow:

1. tensori
2. operazioni
3. sessioni
4. grafici

Ora da quello che hai scritto hai dato il tensore e l'operazione ma non hai una sessione in esecuzione né 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 dici stampa, accedi solo alla forma della variabile o costante che hai definito.

Quindi puoi vedere cosa ti stai perdendo:

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

Spero che sia d'aiuto!

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

Con Tensorflow 2.x, la modalità Eger è abilitata per impostazione predefinita. quindi il codice seguente funziona con 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.]]

Sulla base delle risposte sopra, con il tuo particolare frammento di codice puoi stampare il prodotto in questo modo:

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

In Tensorflow 2.0+ (o in ambiente in modalità Eager) è possibile chiamare il .numpy()metodo:

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 è utile per valutare le piccole espressioni.

tf.keras.backend.eval(op)

TF 1.x e TF 2.0 compatibili.

Esempio verificabile minimo

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)

Ciò è utile perché non è necessario creare esplicitamente un Sessiono InteractiveSession.

È possibile controllare l'output di un oggetto Tensor senza eseguire il grafico in una sessione, abilitando l' esecuzione impaziente .

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

subito dopo di te import tensorflow .

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

Si noti che a partire da ora (novembre 2017) sarà necessario installare una build notturna di Tensorflow per consentire un'esecuzione entusiasta. Le ruote pre-costruite sono disponibili qui .

Si noti che tf.Print()cambierà il nome del tensore. Se il tensore che si desidera stampare è un segnaposto, l'alimentazione dei dati non avrà esito positivo 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))

L'output è:

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

Dovresti pensare ai programmi TensorFlow Core come costituiti da due sezioni discrete:

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

Quindi per il codice qui sotto devi solo costruire il grafico computazionale.

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

È inoltre necessario inizializzare tutte le variabili in un programma TensorFlow, è necessario chiamare esplicitamente un'operazione speciale come segue:

init = tf.global_variables_initializer()

Ora costruisci il grafico e inizializzi tutte le variabili, il passo successivo è valutare i nodi, devi 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 Session e quindi invoca il suo metodo run per eseguire abbastanza del grafico computazionale da valutare product:

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

print(sess.run([product]))

Puoi usare Keras, la risposta di una riga sarà quella di usare il evalmetodo in questo modo:

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

Prova questo semplice codice! (è autoesplicativo)

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)

Non ho trovato facile capire cosa è necessario anche dopo aver letto tutte le risposte fino a quando non ho eseguito questo. TensofFlow è nuovo anche per me.

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

Tuttavia, potrebbe essere necessario il valore restituito eseguendo la sessione.

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

Fondamentalmente, in tensorflow quando si crea un tensore di qualsiasi tipo, vengono creati e memorizzati all'interno a cui è possibile accedere solo quando si esegue una sessione tensorflow. Supponiamo che tu abbia creato un tensore costante
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
Senza eseguire una sessione, puoi ottenere :
- opUn'operazione. Operazione che calcola questo tensore.
- value_index: un int. Indice dell'endpoint dell'operazione che produce questo tensore.
-dtype : un DType. Tipo di elementi memorizzati in questo tensore.

Per ottenere i valori è possibile eseguire una sessione con il tensore richiesto come:

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

L'output sarà qualcosa del genere:

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

Abilita l'esecuzione desiderosa che viene introdotta in tensorflow dopo la versione 1.10. È molto facile da usare.

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

Utilizzando i suggerimenti forniti in https://www.tensorflow.org/api_docs/python/tf/print Uso la log_dfunzione per stampare stringhe formattate.

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 è ora obsoleto, ecco come utilizzare invece tf.print (p minuscola).

Mentre eseguire una sessione è una buona opzione, non è sempre la strada da percorrere. Ad esempio, potresti voler stampare un tensore in una sessione particolare.

Il nuovo metodo di stampa restituisce un'operazione di stampa che non ha tensori di output:

print_op = tf.print(tensor_to_print)

Dal momento che non ha output, non è possibile inserirlo in un grafico come si farebbe con tf.Print. Invece, puoi aggiungerlo per controllare le dipendenze nella tua sessione per farlo stampare.

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)

A volte, in un grafico più grande, forse creato in parte in funzioni secondarie, è ingombrante propagare print_op alla chiamata di sessione. Quindi, tf.tuple può essere utilizzato per accoppiare l'operazione di stampa con un'altra operazione, che verrà quindi eseguita con tale operazione qualunque sessione esegua il codice. Ecco come viene fatto:

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.

Domanda: Come stampare il valore di un oggetto Tensor in TensorFlow?

Risposta:

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)