No TensorFlow, qual é a diferença entre Session.run () e Tensor.eval ()?

O TensorFlow tem duas maneiras de avaliar parte do gráfico: Session.runem uma lista de variáveis ​​e Tensor.eval. Existe alguma diferença entre esses dois?

Se você tiver um Tensort, chamar t.eval()é equivalente a chamar tf.get_default_session().run(t).

Você pode tornar uma sessão o padrão da seguinte maneira:

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)

A diferença mais importante é que você pode usar sess.run()para buscar os valores de muitos tensores na mesma etapa:

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

Observe que cada chamada para evale runexecutará o gráfico inteiro do zero. Para armazenar em cache o resultado de uma computação, atribua-o a a tf.Variable.

A sessão de perguntas frequentes sobre o fluxo tensor tem uma resposta exatamente à mesma pergunta . Vou seguir em frente e deixar aqui:

If té um Tensorobjeto, t.eval()é uma abreviação de sess.run(t)(onde sessé a sessão padrão atual. Os dois trechos de código a seguir são equivalentes:

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

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

No segundo exemplo, a sessão atua como um gerenciador de contexto, que tem o efeito de instalá-la como a sessão padrão para a vida útil do withbloco. A abordagem do gerenciador de contexto pode levar a um código mais conciso para casos de uso simples (como testes de unidade); se o seu código lida com vários gráficos e sessões, pode ser mais simples chamadas explícitas para Session.run().

Eu recomendo que você pelo menos percorra toda a FAQ, pois isso pode esclarecer muitas coisas.

eval() não pode lidar com o objeto de lista

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

mas Session.run()pode

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

corrija-me se eu estiver errada

A coisa mais importante a lembrar:

A única maneira de obter uma variável constante (qualquer resultado) do TenorFlow é a sessão.

Saber disso tudo é fácil :

Ambos tf.Session.run()e tf.Tensor.eval()obter resultados da sessão, onde tf.Tensor.eval()é um atalho para chamartf.get_default_session().run(t)

Eu também descreveria o método tf.Operation.run()como aqui :

Após o lançamento do gráfico em uma sessão, uma Operação pode ser executada passando-o para tf.Session.run(). op.run()é um atalho para chamadas tf.get_default_session().run(op).

No tensorflow, você cria gráficos e passa valores para esse gráfico. O Graph faz todo o trabalho duro e gera a saída com base na configuração que você fez no gráfico. Agora, quando você passa valores para o gráfico, primeiro você precisa criar uma sessão de fluxo tensor.

tf.Session()

Depois que a sessão é inicializada, você deve usá-la porque todas as variáveis ​​e configurações agora fazem parte da sessão. Portanto, existem duas maneiras de passar valores externos para o gráfico, para que o gráfico os aceite. Uma é chamar o .run () enquanto você estiver usando a sessão que está sendo executada.

Outra maneira que é basicamente um atalho para isso é usar .eval (). Eu disse atalho porque a forma completa de .eval () é

tf.get_default_session().run(values)

Você pode verificar isso sozinho. No local da values.eval()corrida tf.get_default_session().run(values). Você deve ter o mesmo comportamento.

o que eval está fazendo é usar a sessão padrão e depois executar run ().

Resposta compatível com Tensorflow 2.x : Convertendo o código de mrry Tensorflow 2.x (>= 2.0)para o benefício da comunidade.

!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