Boucler sur un tenseur

Je suis en train de traiter un tenseur de taille variable, dans un python qui serait quelque chose comme:

# X is of shape [m, n]
for x in X:
    process(x)

J'ai essayé d'utiliser tf.analyse, le truc c'est que je veux traiter chaque sous-tenseur, j'ai donc essayé d'utiliser un imbriquée analyse, mais j'étais permettre de le faire, parce que tf.analyse travail avec l'accumulateur, si elle ne trouve pas qu'il va prendre la première entrée de la elems comme initialiseur, dont je n'ai pas envie de faire.
Par exemple, supposons que je veux ajouter un à chaque élément de mon tenseur (c'est juste un exemple), et je veux traiter l'élément par élément. Si j'exécute le code ci-dessous, je n'aurai que l'on ajoute à un sous-tenseur, parce que analyse considèrent que le premier tenseur d'initialiseur, avec le premier élément de chaque sous-tenseur.

import numpy as np
import tensorflow as tf

batch_x = np.random.randint(0, 10, size=(5, 10))
x = tf.placeholder(tf.float32, shape=[None, 10])

def inner_loop(x_in):
    return tf.scan(lambda _, x_: x_ + 1, x_in)

outer_loop = tf.scan(lambda _, input_: inner_loop(input_), x, back_prop=True)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    rs = sess.run(outer_loop, feed_dict={x: batch_x})

Des suggestions ?

OriginalL'auteur Mohamed Lakhal | 2017-04-10

  1. 7

    Plus de tensorflow fonctions intégrées pourraient être appliquées elementwise. Si vous pouviez juste passer un tenseur dans une fonction. Comme:

    outer_loop = inner_loop(x)

    Toutefois, si vous avez une fonction qui ne peut pas être appliquée de cette façon (c'est vraiment tentant de voir cette fonction), vous pouvez utiliser map_fn.

    Dire, votre fonction s'ajoute 1 à chaque élément d'un tenseur (ou autre): 

    inputs = tf.placeholder...

def my_elementwise_func(x):
    return x + 1

def recursive_map(inputs):
   if tf.shape(inputs).ndims > 0:
       return tf.map_fn(recursive_map, inputs)
   else:
       return my_elementwise_func(inputs)

result = recursive_map(inputs)
    Mon problème est plus général que ça, et j'ai été à la recherche pour trouver des solutions mais pour l'instant je suis à l'échec. Je veux effectuer des opérations sur chaque entrée du Tenseur, la solution ci-dessus ne fait que l'élément de sage opérations. D'autres suggestions ?
    Pourriez-vous fournir un exemple d'une fonction qui agit sur chaque entrée d'un tenseur?
    Je veux traiter chaque entrée selon certaines règles, dire par exemple que je veux: somme(pos_xi) + 2 * somme(neg_xi). La matrice = [[1, -2, 3], [-5, 0, 1]] la Première entrée: (1+3) + 2*(-2) = 0 Deuxième entrée: (0+1) + 2*(-5) = -9 Résultat = [0, -9]
    Dans ce cas particulier tf.reduce_sum(a, 1), où a est tf.maximum(t, 0) - 2*tf.maximum(-t, 0). Tensorflow a beaucoup de fonctions qui effectuent réduire les opérations (somme, moyenne, max, min, etc.) et elementwise opérations. En combinant ces fonctions, il est possible de parvenir à un résultat souhaité dans la grande majorité des situations.
    Après un peu de recherche, il semble que, comme vous l'avez souligné à effectuer un roi de traitement, vous devez combiner des opérations sur votre tenseur, et trouver un moyen de les vectoriser votre calcul. Pour cette partie, vous devrez presser votre esprit et votre main sale !

    OriginalL'auteur Dmitriy Danevskiy

  2. 7

    Faire une boucle sur un tenseur vous pouvez essayer de tf.dépiler

    Déballe la dimension donnée de rang R tenseur en rang-(R-1) les tenseurs.

    Afin d'ajouter 1 à chaque tenseur ressemblerait à quelque chose comme:

    import tensorflow as tf
x = tf.placeholder(tf.float32, shape=(None, 10))
x_unpacked = tf.unstack(x) # defaults to axis 0, returns a list of tensors

processed = [] # this will be the list of processed tensors
for t in x_unpacked:
    # do whatever
    result_tensor = t + 1
    processed.append(result_tensor)

output = tf.concat(processed, 0)

with tf.Session() as sess:
    print(sess.run([output], feed_dict={x: np.zeros((5, 10))}))

    Évidemment, vous pouvez décompresser chaque tenseur de la liste à traiter, jusqu'à des éléments uniques. Pour éviter beaucoup de imbriquée déballage cependant, vous pourriez peut-être essayer un aplatissement x avec tf.reshape(x, [-1]) d'abord, et ensuite une boucle sur elle comme

    flattened_unpacked = tf.unstack(tf.reshape(x, [-1])
for elem in flattened_unpacked:
    process(elem)

    Dans ce cas elem est un scalaire.

    J'ai essayé cela avant, et il raise ValueError exception, parce que nous travaillons avec un Aucun tenseur dim_0
    Ah oui désolé, j'ai manqué unstack ne fonctionne pas avec Aucun des dimensions. J'ai trouvé cette question, à l'Aide de tf.unpack() lors de la première dimension de la Variable est Aucun qui semble être répondu assez bien.

    OriginalL'auteur Dzjkb