Dans TensorFlow, quelle est la différence entre Session.run () et Tensor.eval ()?

TensorFlow a deux façons d'évaluer une partie du graphique: Session.runsur une liste de variables et Tensor.eval. Y a-t-il une différence entre ces deux?

Si vous avez un Tensort, appeler t.eval()équivaut à appeler tf.get_default_session().run(t).

Vous pouvez définir une session par défaut comme suit:

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 différence la plus importante est que vous pouvez utiliser sess.run()pour récupérer les valeurs de nombreux tenseurs dans la même étape:

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

Notez que chaque appel à evalet runexécutera le graphique entier à partir de zéro. Pour mettre en cache le résultat d'un calcul, affectez-le à a tf.Variable.

La session FAQ sur l'écoulement tensoriel a une réponse à exactement la même question . Je vais juste aller de l'avant et le laisser ici:

Si test un Tensorobjet, t.eval()est un raccourci pour sess.run(t)(où sessest la session par défaut en cours. Les deux extraits de code suivants sont équivalents:

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

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

Dans le deuxième exemple, la session agit comme un gestionnaire de contexte, ce qui a pour effet de l'installer comme session par défaut pour la durée de vie du withbloc. L'approche du gestionnaire de contexte peut conduire à un code plus concis pour des cas d'utilisation simples (comme les tests unitaires); si votre code traite de plusieurs graphiques et sessions, il peut être plus simple d'appeler explicitement vers Session.run().

Je vous recommande de parcourir au moins toute la FAQ, car cela pourrait clarifier beaucoup de choses.

eval() ne peut pas gérer l'objet liste

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

mais Session.run()peut

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

Corrigez-moi si je me trompe

La chose la plus importante à retenir:

La seule façon d'obtenir une variable constante (n'importe quel résultat) de TenorFlow est la session.

Savoir tout cela est simple :

Les deux tf.Session.run()et tf.Tensor.eval()obtenir les résultats de la session où se tf.Tensor.eval()trouve un raccourci pour appelertf.get_default_session().run(t)

Je décrirais également la méthode tf.Operation.run()comme ici :

Une fois le graphique lancé dans une session, une opération peut être exécutée en la passant à tf.Session.run(). op.run()est un raccourci pour appeler tf.get_default_session().run(op).

Dans tensorflow, vous créez des graphiques et passez des valeurs à ce graphique. Le graphique fait tout le travail et génère la sortie en fonction de la configuration que vous avez effectuée dans le graphique. Maintenant Lorsque vous transmettez des valeurs au graphique, vous devez d'abord créer une session tensorflow.

tf.Session()

Une fois la session initialisée, vous êtes censé utiliser cette session car toutes les variables et tous les paramètres font désormais partie de la session. Il existe donc deux façons de transmettre des valeurs externes au graphique afin que le graphique les accepte. L'une consiste à appeler le .run () pendant que vous utilisez la session en cours d'exécution.

Une autre manière qui est fondamentalement un raccourci pour cela est d'utiliser .eval (). J'ai dit raccourci car la forme complète de .eval () est

tf.get_default_session().run(values)

Vous pouvez le vérifier vous-même. Sur le lieu de la values.eval()course tf.get_default_session().run(values). Vous devez avoir le même comportement.

ce que fait eval, c'est d'utiliser la session par défaut, puis d'exécuter run ().

Réponse compatible Tensorflow 2.x : Conversion du code de mrry Tensorflow 2.x (>= 2.0)pour le bénéfice de la communauté.

!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