python - tutorial - TensorFlow sobrecarga del operador

tensorflow seq2seq

Question

Cuál es la diferencia entre

   tf.add(x, y)

y

   x + y

en TensorFlow? ¿Qué sería diferente en su gráfico de cálculo cuando construye su gráfico con + lugar de tf.add() ?

En términos más generales, ¿están sobrecargadas las operaciones + u otras para los tensores?

Answer 1

Mrry explicó amablemente que no hay una diferencia real. Solo tf.add cuando usar tf.add sea ​​beneficioso.

tf.add tiene un parámetro importante que es el name . Le permite nombrar la operación en un gráfico que será visible en el tensorboard. Entonces, mi regla general, si será beneficioso nombrar una operación en el tensorboard, uso tf. equivalente, de lo contrario voy por brevedad y uso la versión sobrecargada.

Answer 2

Si al menos uno de x o y es un objeto tf.Tensor , las expresiones tf.add(x, y) y x + y son equivalentes. La razón principal por la que podría usar tf.add() es para especificar un argumento de palabra clave de name explícito para la tf.add() creada, lo cual no es posible con la versión de operador sobrecargada.

Tenga en cuenta que si ni x ni y es un tf.Tensor ejemplo, si son matrices NumPy, entonces x + y no creará una operación TensorFlow. tf.add() siempre crea una tf.add() TensorFlow y convierte sus argumentos en objetos tf.Tensor . Por lo tanto, si está escribiendo una función de biblioteca que podría aceptar tanto los tensores como las matrices NumPy, es posible que prefiera usar tf.add() .

Los siguientes operadores están sobrecargados en la API de TensorFlow Python:

• __neg__ (unario - )
• __abs__ ( abs() )
• __invert__ (unario ~ )
• __add__ (binario + )
• __sub__ (binario - )
• __mul__ (elemento binario * )
• __div__ (binario / en Python 2)
• __floordiv__ (binario // en Python 3)
• __truediv__ (binario / en Python 3)
• __mod__ ( % binario)
• __pow__ (binario ** )
• __and__ (binario & )
• __or__ (binario | )
• __xor__ (binario ^ )
• __lt__ (binario < )
• __le__ (binario <= )
• __gt__ (binario > )
• __ge__ (binario >= )

Tenga en cuenta que __eq__ (binario == ) no está sobrecargado. x == y simplemente devolverá un booleano Python si y refieren al mismo tensor. tf.equal() usar tf.equal() explícitamente para verificar la igualdad entre elementos. Lo mismo va para no igual, __ne__ (binario != ).