Dynamique de la taille de tf.les zéros() (pour une utilisation avec des espaces réservés à Aucune des dimensions)

Considérons le code suivant:

x = tf.placeholder("float", shape=[42, 4])
y = tf.zeros([42, 4], "float")
xy_stacked = tf.concat(1, [x, y])

print(x.get_shape())
print(y.get_shape())
print(xy_stacked.get_shape())

Cela produira la sortie suivante, comme prévu:

TensorShape([Dimension(42), Dimension(4)])
TensorShape([Dimension(42), Dimension(4)])
TensorShape([Dimension(42), Dimension(8)])

Cependant, si l'espace réservé a une dimension dynamique qui est déterminé au moment de l'exécution par la valeur passée à feed_dict=, comme des espaces réservés souvent:

x = tf.placeholder("float", shape=[None, 4])
y = tf.zeros([None, 4], "float")
xy_stacked = tf.concat(1, [x, y])

Cela produira une erreur pour tf.zeros([None, 4], "float"). Apparemment Dimension(None) n'est pas autorisé pour tf.zeros:

TypeError                                 Traceback (most recent call last)
<ipython-input-24-277eca38a392> in <module>()
      2 
      3 x = tf.placeholder("float", shape=[None, 4])
----> 4 y = tf.zeros([None, 4], "float")
      5 xy_stacked = tf.concat(1, [x, y])
      6 
[...]

/usr/local/lib/python3.4/dist-packages/numpy/core/_methods.py in _prod(a, axis, dtype, out, keepdims)
     33 
     34 def _prod(a, axis=None, dtype=None, out=None, keepdims=False):
---> 35     return umr_prod(a, axis, dtype, out, keepdims)
     36 
     37 def _any(a, axis=None, dtype=None, out=None, keepdims=False):

TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'

J'ai compris qu'il ne produit pas une erreur si j'ai mis la première dimension de mes zéros tenseur de None, comme 1:

x = tf.placeholder("float", shape=[None, 4])
y = tf.zeros([1, 4], "float")
xy_stacked = tf.concat(1, [x, y])

mais alors la résultante xy_stacked tenseur est tronqué à cette taille:

TensorShape([Dimension(None), Dimension(4)])
TensorShape([Dimension(1), Dimension(4)])
TensorShape([Dimension(1), Dimension(8)])

Comment puis-je remplir l'espace réservé tenseur avec des zéros si je reçois un tenseur de forme TensorShape([Dimension(None), Dimension(8)]) dans cet exemple?

La seule "solution" que j'ai trouvé jusqu'à présent est soit quelque chose comme ce qui suit:

x = tf.placeholder("float", shape=[None, 4])
y = 0 * x
xy_stacked = tf.concat(1, [x, y])

Ou simplement déclarer y comme un espace réservé et toujours le passage d'un zéro tableau de la bonne taille.

Mais ni ressemble à une propre solution au problème et hacks comme qui sortent de la main rapidement dans une application plus complexe que ce simple exemple..

Je suis en utilisant tensorflow-0.6.0-py3.

  • ce qui se passe avec y=tf.zeros_like(x)?
  • puis-je obtenir quelque chose de la forme TensorShape([Dimension(None), Dimension(None)]) pour y et xy_stacked!? Le 0 * x hack je l'ai mentionné dans la question ne semble plus de sens si x aurait la même forme que y. Dans mon application réelle, tout est plus compliqué, bien sûr, et j'ai pour construire les zéros tenseur par tranchage, de dupliquer et de concaténer le résultat de 0 * <placeholder> pour obtenir un tenseur de la forme dont j'ai besoin.
InformationsquelleAutor CliffordVienna | 2016-01-11
  1. 32

    Recommandé de faire un zéro tenseur avec le même forme comme un autre tenseur est d'utiliser le tf.zeros_like() op:

    x = tf.placeholder(tf.float32, shape=[None, 4])
y = tf.zeros_like(x)

    L'résultant du tenseur de y semble avoir la forme [None, None] selon Tenseur.get_shape(), mais à l'exécution, il sera étendu à la même forme que x:

    print y.get_shape()
# ==> TensorShape([Dimension(None), Dimension(None)])

sess = tf.Session()
y_result = sess.run(y, feed_dict={x: np.random.rand(4, 4)})

print y_result.shape
# ==> (4, 4)

    La [None, None] statique de la forme est retourné en raison de la forme de l'inférence n'a pas été spécialisé pour tf.zeros_like(). J'ai déposé une GitHub problème pour que et il devrait être bientôt corrigé.

    EDIT: Dans votre commentaire, vous avez demandé comment traiter le cas où le zéro tenseur avait une forme basée sur, mais différente de le tenseur d'origine. Cela est également possible, à l'aide de tf.la forme() et tf.pile() pour construire les dimensions, et tf.fill() pour produire le zéro tenseur:

    x = tf.placeholder(tf.float32, shape=[None, 4])

# Use tf.shape() to get the runtime size of `x` in the 0th dimension.
zeros_dims = tf.stack([tf.shape(x)[0], 7])

y = tf.fill(zeros_dims, 0.0)

sess = tf.Session()
y_result = sess.run(y, feed_dict={x: np.random.rand(4, 4)})
print y_result.shape
# ==> (4, 7)
    • Que dois-je faire si la 2ème dimension ne correspond pas? E. g. Je veux x avoir shape=[None, 4] et y avoir shape=[None, 7]. (Dans mon application la 2ème dimensions de ces tenseurs sont indépendants des paramètres de configuration. Je ne peux même pas vous dire à l'avance qui est plus grand.) Désolé de ne pas mentionner que, dans la question en premier lieu..
    • Mise à jour de ma réponse pour couvrir votre cas.
    • Notez que sur tf 1.x+ tf.pack a été renommé tf.pile
    • J'ai mis à jour l'extrait de code pour utiliser la post-1.0 de l'API.
    InformationsquelleAutor mrry