TensorFlow: numpy.répéter() alternative

Je veux comparer les valeurs prédites yp de mon réseau de neurones par paires de la mode, et j'ai donc été à l'aide de (de retour dans mon ancien numpy mise en œuvre):

idx = np.repeat(np.arange(len(yp)), len(yp))
jdx = np.tile(np.arange(len(yp)), len(yp))
s = yp[[idx]] - yp[[jdx]]

Ce créer une indexation mesh que j'utilise ensuite. idx=[0,0,0,1,1,1,...] tout jdx=[0,1,2,0,1,2...]. Je ne sais pas si il y a une manière plus simple de le faire...

De toute façon, TensorFlow a un tf.tile(), mais il semble manquer un tf.repeat().

idx = np.repeat(np.arange(n), n)
v2 = v[idx]

Et j'obtiens l'erreur:

TypeError: Bad slice index [  0   0   0 ..., 215 215 215] of type <type 'numpy.ndarray'>

Il ne fonctionne pas à utiliser un TensorFlow constante pour l'indexation:

idx = tf.constant(np.repeat(np.arange(n), n))
v2 = v[idx]

TypeError: Bad slice index Tensor("Const:0", shape=TensorShape([Dimension(46656)]), dtype=int64) of type <class 'tensorflow.python.framework.ops.Tensor'>

L'idée est de convertir mon RankNet mise en œuvre de TensorFlow.

InformationsquelleAutor Ricardo Cruz | 2016-02-12

tensorflow

35

Vous pouvez obtenir l'effet de np.repeat() à l'aide d'une combinaison de tf.la tuile() et tf.reshape():
```
idx = tf.range(len(yp))
idx = tf.reshape(idx, [-1, 1])    # Convert to a len(yp) x 1 matrix.
idx = tf.tile(idx, [1, len(yp)])  # Create multiple columns.
idx = tf.reshape(idx, [-1])       # Convert back to a vector.
```
Vous pouvez simplement calculer jdx à l'aide de tf.tile():
```
jdx = tf.range(len(yp))
jdx = tf.tile(jdx, [len(yp)])
```
Pour l'indexation, vous pouvez essayer d'utiliser tf.gather() pour extraire non contigus des tranches de l' yp tenseur:
```
s = tf.gather(yp, idx) - tf.gather(yp, jdx)
```
- Semble qu'il y est une erreur dans le code? J'ai couru avec len(yp)==4 et la sortie de idx était [0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3] et pas [0,0,0,1,1,1,...].
- L'ajout d'un tf.transpose appel après la pose du carrelage obtient de bons résultats [0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3]. La ligne correcte est idx = tf.transpose(tf.tile(idx, [len(yp), 1]))?
- Bonne prise - la réponse a effectivement donné une trop longue haleine façon de calculer jdx! J'ai mis à jour pour clarifier la façon dont on pourrait calculé idx et jdx.
InformationsquelleAutor mrry
2

Il ressemble à votre question est si populaire que les gens consultez sur TF tracker. Malheureusement, la même fonction n'est pas encore mis en œuvre en TF.

Vous pouvez la mettre en œuvre en combinant tf.tuile, tf.remodeler, tf.squeeze. Voici un moyen de convertir des exemples de np.répétez:
```
import numpy as np
import tensorflow as tf

x = [[1,2],[3,4]]
print np.repeat(3, 4)
print np.repeat(x, 2)
print np.repeat(x, 3, axis=1)

x = tf.constant([[1,2],[3,4]])
with tf.Session() as sess:
    print sess.run(tf.tile([3], [4]))
    print sess.run(tf.squeeze(tf.reshape(tf.tile(tf.reshape(x, (-1, 1)), (1, 2)), (1, -1))))
    print sess.run(tf.reshape(tf.tile(tf.reshape(x, (-1, 1)), (1, 3)), (2, -1)))
```
Dans le dernier cas, où les répétitions sont différents pour chaque élément, vous sera très probablement besoin boucles.

InformationsquelleAutor Salvador Dali

1-d tenseurs, j'ai fait cette fonction

def tf_repeat(y,repeat_num)   
        return tf.reshape(tf.tile(tf.expand_dims(y,axis=-1),[1,repeat_num]),[-1])

InformationsquelleAutor tom minatozaki

1

Juste au cas où quelqu'un est intéressé pour un 2D méthode pour copier les matrices. Je pense que cela pourrait fonctionner:
```
TF_obj = tf.zeros([128, 128])
tf.tile(tf.expand_dims(TF_obj, 2), [1, 1, 2])
```
InformationsquelleAutor beniroquai

import numpy as np
import tensorflow as tf
import itertools    

x = np.arange(6).reshape(3,2)
x = tf.convert_to_tensor(x)
N = 3 # number of repetition
K = x.shape[0] # for here 3

order = list(range(0, N*K, K))
order = [[x+i for x in order] for i in range(K)]
order = list(itertools.chain.from_iterable(order))
x_rep = tf.gather(tf.tile(x, [N, 1]), order)

Résultats à partir de:

   [0, 1],
   [2, 3],
   [4, 5]]

À:

  [[0, 1],
   [0, 1],
   [0, 1],
   [2, 3],
   [2, 3],
   [2, 3],
   [4, 5],
   [4, 5],
   [4, 5]]

Si vous le souhaitez:

  [[0, 1],
   [2, 3],
   [4, 5],
   [0, 1],
   [2, 3],
   [4, 5],
   [0, 1],
   [2, 3],
   [4, 5]]

Simplement utiliser tf.tile(x, [N, 1])

InformationsquelleAutor Panfeng Li

Selon tf api document, tf.keras.backend.repeat_elements() fait le même travail avec np.repeat() . Par exemple,

x = tf.constant([1, 3, 3, 1], dtype=tf.float32)
rep_x = tf.keras.backend.repeat_elements(x, 5, axis=0)
# result: [1. 1. 1. 1. 1. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 1. 1. 1. 1. 1.]

InformationsquelleAutor zong fan

0

Vous pouvez simuler manquant tf.repeat par tf.stacking la valeur de lui-même:
```
value = np.arange(len(yp))  # what to repeat
repeat_count = len(yp)      # how many times
repeated = tf.stack ([value for i in range(repeat_count)], axis=1)
```
Je le conseil à l'aide de ce sur des petites répétez compte.

InformationsquelleAutor jaros

Bien que beaucoup de nettoyage et de solutions de travail ont été donnés, ils semblent tous être basée sur la production de l'ensemble des indices à partir de zéro à chaque itération.

Alors que le coût de production de ces nœuds n'est généralement pas significative au cours de la formation, il peut être important si l'utilisation de votre modèle pour l'inférence.

Répéter tf.gamme (comme ton exemple) a mis un peu de temps alors j'ai construit la fonction suivante créateur. Étant donné le nombre maximum de fois que quelque chose sera répété et le nombre maximum de choses qui ont besoin de la répétition, elle renvoie une fonction qui produit les mêmes valeurs que np.repeat(np.arange(len(multiples)), multiples).

import tensorflow as tf
import numpy as np


def numpy_style_repeat_1d_creator(max_multiple=100, max_to_repeat=10000):
    board_num_lookup_ary = np.repeat(
        np.arange(max_to_repeat),
        np.full([max_to_repeat], max_multiple))
    board_num_lookup_ary = board_num_lookup_ary.reshape(max_to_repeat, max_multiple)

    def fn_to_return(multiples):
        board_num_lookup_tensor = tf.constant(board_num_lookup_ary, dtype=tf.int32)
        casted_multiples = tf.cast(multiples, dtype=tf.int32)
        padded_multiples = tf.pad(
            casted_multiples,
            [[0, max_to_repeat - tf.shape(multiples)[0]]])

        return tf.boolean_mask(
            board_num_lookup_tensor,
            tf.sequence_mask(padded_multiples, maxlen=max_multiple))

    return fn_to_return

#Here's an example of how it can be used
with tf.Session() as sess:
    repeater = numpy_style_repeat_1d_creator(5,4)
    multiples = tf.constant([4,1,3])

    repeated_values = repeater(multiples)
    print(sess.run(repeated_values))

L'idée générale est de stocker un répétée tenseur, puis masque, mais il peut aider à voir visuellement (c'est pour l'exemple donné ci-dessus):

In the example above the following Tensor is produced:
[[0,0,0,0,0],
 [1,1,1,1,1],
 [2,2,2,2,2],
 [3,3,3,3,3]]

For multiples [4,1,3] it will collect the non-X values:
[[0,0,0,0,X],
 [1,X,X,X,X],
 [2,2,2,X,X],
 [X,X,X,X,X]]

resulting in:
[0,0,0,0,1,2,2,2]

tl;dr: Pour éviter de produire des indices à chaque fois (peut être coûteux), pré-répéter tout et puis masque tenseur chaque fois

InformationsquelleAutor Sam Ragusa

Un relativement rapide mise en œuvre a été récemment ajouté à RaggedTensor utilitaires de 1,13, mais ce n'est pas une partie de la exporté officiellement API. Vous pouvez toujours l'utiliser, mais il y a une chance qu'il pourrait disparaître.

from tensorflow.python.ops.ragged.ragged_util import repeat

À partir du code source:

# This op is intended to exactly match the semantics of numpy.repeat, with
# one exception: numpy.repeat has special (and somewhat non-intuitive) behavior
# when axis is not specified.  Rather than implement that special behavior, we
# simply make `axis` be a required argument.

InformationsquelleAutor DomJack

Vous devez vous connecter pour publier un commentaire.