In TensorFlow, qual è la differenza tra Session.run () e Tensor.eval ()?

TensorFlow ha due modi per valutare parte del grafico: Session.runsu un elenco di variabili e Tensor.eval. C'è una differenza tra questi due?

Se hai una Tensort, chiamare t.eval()equivale a chiamare tf.get_default_session().run(t).

È possibile impostare una sessione come predefinita:

t = tf.constant(42.0)
sess = tf.Session()
with sess.as_default():   # or `with sess:` to close on exit
    assert sess is tf.get_default_session()
    assert t.eval() == sess.run(t)

La differenza più importante è che puoi usare sess.run()per recuperare i valori di molti tensori nello stesso passaggio:

t = tf.constant(42.0)
u = tf.constant(37.0)
tu = tf.mul(t, u)
ut = tf.mul(u, t)
with sess.as_default():
   tu.eval()  # runs one step
   ut.eval()  # runs one step
   sess.run([tu, ut])  # evaluates both tensors in a single step

Si noti che ogni chiamata a evaled runeseguirà l'intero grafico da zero. Per memorizzare nella cache il risultato di un calcolo, assegnarlo a tf.Variable.

La sessione FAQ sul flusso tensore ha una risposta esattamente alla stessa domanda . Andrò avanti e lo lascerò qui:

If tè un Tensoroggetto, t.eval()è una scorciatoia per sess.run(t)(dove si sesstrova la sessione predefinita corrente. I due seguenti frammenti di codice sono equivalenti:

sess = tf.Session()
c = tf.constant(5.0)
print sess.run(c)

c = tf.constant(5.0)
with tf.Session():
  print c.eval()

Nel secondo esempio, la sessione funge da gestore del contesto, il che ha l'effetto di installarlo come sessione predefinita per la durata del withblocco. L'approccio del gestore del contesto può portare a un codice più conciso per casi d'uso semplici (come i test unitari); se il tuo codice si occupa di più grafici e sessioni, potrebbe essere più semplice chiamare esplicitamente Session.run().

Ti consiglio di sfogliare almeno in tutte le FAQ, poiché potrebbe chiarire molte cose.

eval() impossibile gestire l'oggetto elenco

tf.reset_default_graph()

a = tf.Variable(0.2, name="a")
b = tf.Variable(0.3, name="b")
z = tf.constant(0.0, name="z0")
for i in range(100):
    z = a * tf.cos(z + i) + z * tf.sin(b - i)
grad = tf.gradients(z, [a, b])

init = tf.global_variables_initializer()

with tf.Session() as sess:
    init.run()
    print("z:", z.eval())
    print("grad", grad.eval())

ma Session.run()può

print("grad", sess.run(grad))

correggimi se sbaglio

La cosa più importante da ricordare:

L'unico modo per ottenere una costante, variabile (qualsiasi risultato) da TenorFlow è la sessione.

Sapendo questo tutto il resto è facile :

Entrambi tf.Session.run()e tf.Tensor.eval()ottenere risultati dalla sessione in cui tf.Tensor.eval()è presente un collegamento per la chiamatatf.get_default_session().run(t)

Vorrei anche delineare il metodo tf.Operation.run()come qui :

Dopo che il grafico è stato lanciato in una sessione, è possibile eseguire un'operazione passandola a tf.Session.run(). op.run()è una scorciatoia per chiamare tf.get_default_session().run(op).

In tensorflow si creano grafici e si passano i valori a quel grafico. Il grafico esegue tutto il duro lavoro e genera l'output in base alla configurazione effettuata nel grafico. Ora Quando si passano i valori al grafico, prima è necessario creare una sessione tensorflow.

tf.Session()

Una volta inizializzata la sessione, è necessario utilizzare quella sessione perché tutte le variabili e le impostazioni fanno ora parte della sessione. Quindi, ci sono due modi per passare valori esterni al grafico in modo che il grafico li accetti. Uno è chiamare .run () mentre si sta utilizzando la sessione in esecuzione.

Un altro modo che è fondamentalmente una scorciatoia per questo è usare .eval (). Ho detto scorciatoia perché la forma completa di .eval () è

tf.get_default_session().run(values)

Puoi verificarlo tu stesso. Nel luogo di values.eval()corsa tf.get_default_session().run(values). Devi avere lo stesso comportamento.

ciò che sta facendo eval è usare la sessione predefinita e quindi eseguire run ().

Risposta compatibile Tensorflow 2.x : conversione del codice di mrry a Tensorflow 2.x (>= 2.0)beneficio della comunità.

!pip install tensorflow==2.1
import tensorflow as tf

tf.compat.v1.disable_eager_execution()    

t = tf.constant(42.0)
sess = tf.compat.v1.Session()
with sess.as_default():   # or `with sess:` to close on exit
    assert sess is tf.compat.v1.get_default_session()
    assert t.eval() == sess.run(t)

#The most important difference is that you can use sess.run() to fetch the values of many tensors in the same step:

t = tf.constant(42.0)
u = tf.constant(37.0)
tu = tf.multiply(t, u)
ut = tf.multiply(u, t)
with sess.as_default():
   tu.eval()  # runs one step
   ut.eval()  # runs one step
   sess.run([tu, ut])  # evaluates both tensors in a single step