Dans Tensorflow, comment utiliser tf.gather () pour la dernière dimension?

Je suis en train de rassembler les morceaux du tenseur dans les termes de la dernière dimension pour une partie de la connexion entre les couches. Parce que la sortie du tenseur de forme est [batch_size, h, w, depth]je veux sélectionner des tranches en fonction de la dernière dimension, comme

# L is intermediate tensor
partL = L[:, :, :, [0,2,3,8]]

Cependant, tf.gather(L, [0, 2,3,8]) semble être la seule à travailler pour la première dimension (à droite?) Quelqu'un peut me dire comment faire?

source d'informationauteur YW P Kwon

  1. 9

    Il y a un suivi de bug à l'appui de ce cas d'utilisation ici: https://github.com/tensorflow/tensorflow/issues/206

    Pour l'instant vous pouvez:

    1. transposer votre matrice de sorte que la dimension de rassembler est le premier (transposition est cher)

    2. remodeler votre tenseur en 1d (remodeler n'est pas cher) et faire de votre recueillir des indices de colonne dans une liste d'indice de l'élément linéaire à l'indexation, puis remodeler retour

    3. utilisation gather_nd. Aura encore besoin pour transformer votre colonne des indices dans la liste d'indice de l'élément.
  2. 12

    De TensorFlow 1.3 tf.gather a un axis paramètre, donc les différentes solutions de contournement ici ne sont plus nécessaires.

    https://www.tensorflow.org/versions/r1.3/api_docs/python/tf/gather
    https://github.com/tensorflow/tensorflow/issues/11223

  3. 6

    Avec gather_nd vous pouvez désormais le faire comme suit:

    cat_idx = tf.concat([tf.range(0, tf.shape(x)[0]), indices_for_dim1], axis=0)
result = tf.gather_nd(matrix, cat_idx)

    Également, comme indiqué par l'utilisateur Nova dans un fil de discussion référencés par @Yaroslav Bulatov:

    x = tf.constant([[1, 2, 3],
                 [4, 5, 6],
                 [7, 8, 9]])
idx = tf.constant([1, 0, 2])
idx_flattened = tf.range(0, x.shape[0]) * x.shape[1] + idx
y = tf.gather(tf.reshape(x, [-1]),  # flatten input
              idx_flattened)  # use flattened indices

with tf.Session(''):
  print y.eval()  # [2 4 9]

    L'essentiel est d'aplatir le tenseur et l'utilisation strided 1D adressage avec tf.rassembler(...).

  4. 3

    Encore une autre solution à l'aide de tf.dépiler(...), tf.rassembler(...) et de la tf.pile(..)

    Code:

    import tensorflow as tf
import numpy as np

shape = [2, 2, 2, 10] 
L = np.arange(np.prod(shape))
L = np.reshape(L, shape)

indices = [0, 2, 3, 8]
axis = -1 # last dimension

def gather_axis(params, indices, axis=0):
    return tf.stack(tf.unstack(tf.gather(tf.unstack(params, axis=axis), indices)), axis=axis)

print(L)
with tf.Session() as sess:
    partL = sess.run(gather_axis(L, indices, axis))
    print(partL)

    Résultat:

    L = 
[[[[ 0  1  2  3  4  5  6  7  8  9]
   [10 11 12 13 14 15 16 17 18 19]]

  [[20 21 22 23 24 25 26 27 28 29]
   [30 31 32 33 34 35 36 37 38 39]]]


 [[[40 41 42 43 44 45 46 47 48 49]
   [50 51 52 53 54 55 56 57 58 59]]

  [[60 61 62 63 64 65 66 67 68 69]
   [70 71 72 73 74 75 76 77 78 79]]]]

partL = 
[[[[ 0  2  3  8]
   [10 12 13 18]]

  [[20 22 23 28]
   [30 32 33 38]]]


 [[[40 42 43 48]
   [50 52 53 58]]

  [[60 62 63 68]
   [70 72 73 78]]]]
  5. 2

    Une version correcte de @Andrei réponse lire

    cat_idx = tf.stack([tf.range(0, tf.shape(x)[0]), indices_for_dim1], axis=1)
result = tf.gather_nd(matrix, cat_idx)
  6. 1

    Vous pouvez essayer de cette façon, par exemple(dans la plupart des cas en PNL au moins),

    Le paramètre est de la forme [batch_size, depth] et les indices sont [i, j, k, n, m] dont la longueur est batch_size. Puis gather_nd peut être utile. 

    parameters = tf.constant([
                          [11, 12, 13], 
                          [21, 22, 23], 
                          [31, 32, 33], 
                          [41, 42, 43]])    
targets = tf.constant([2, 1, 0, 1])    
batch_nums = tf.range(0, limit=parameters.get_shape().as_list()[0])     
indices = tf.stack((batch_nums, targets), axis=1) # the axis is the dimension number   
items = tf.gather_nd(parameters, indices)  
# which is what we want: [13, 22, 31, 42]

    Cet extrait d'abord trouver le poing dimension par le biais de la batch_num, puis extraire l'élément le long de cette dimension par le numéro de la cible.

  7. 0

    La mise en œuvre 2. @Yaroslav Bulatov:

    #Your indices
indices = [0, 2, 3, 8]

#Remember for final reshaping
n_indices = tf.shape(indices)[0]

flattened_L = tf.reshape(L, [-1])

#Walk strided over the flattened array
offset = tf.expand_dims(tf.range(0, tf.reduce_prod(tf.shape(L)), tf.shape(L)[-1]), 1)
flattened_indices = tf.reshape(tf.reshape(indices, [-1])+offset, [-1])
selected_rows = tf.gather(flattened_L, flattened_indices)

#Final reshape
partL = tf.reshape(selected_rows, tf.concat(0, [tf.shape(L)[:-1], [n_indices]]))

    De crédit à Comment sélectionner les lignes à partir d'un 3-D Tenseur dans TensorFlow?

  8. 0

    Tenseur n'a pas d'attribut de la forme, mais get_shape() la méthode. Ci-dessous est praticable par Python 2.7

    import tensorflow as tf
import numpy as np
x = tf.constant([[1, 2, 3],
                 [4, 5, 6],
                 [7, 8, 9]])
idx = tf.constant([1, 0, 2])
idx_flattened = tf.range(0, x.get_shape()[0]) * x.get_shape()[1] + idx
y = tf.gather(tf.reshape(x, [-1]),  # flatten input
              idx_flattened)  # use flattened indices

with tf.Session(''):
  print y.eval()  # [2 4 9]