DynamicStitch

classe finale publique DynamicStitch

Entrelacez les valeurs des tenseurs « données » en un seul tenseur.

Construit un tenseur fusionné tel que

merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
Par exemple, si chaque `indices[m]` est scalaire ou vectoriel, nous avons
# Scalar indices:
     merged[indices[m], ...] = data[m][...]
 
     # Vector indices:
     merged[indices[m][i], ...] = data[m][i, ...]
Chaque `data[i].shape` doit commencer par les `indices[i].shape` correspondants, et le reste de `data[i].shape` doit être constant par rapport à `i`. Autrement dit, nous devons avoir `data[i].shape = indices[i].shape + constant`. En termes de cette « constante », la forme de sortie est

merged.shape = [max(indices) + 1] + constante

Les valeurs sont fusionnées dans l'ordre, donc si un index apparaît à la fois dans `indices[m][i]` et `indices[n][j]` pour `(m,i) < (n,j)` la tranche `data [n][j]` apparaîtra dans le résultat fusionné. Si vous n'avez pas besoin de cette garantie, ParallelDynamicStitch peut fonctionner mieux sur certains appareils.

Par exemple:

indices[0] = 6
     indices[1] = [4, 1]
     indices[2] = [[5, 2], [0, 3]]
     data[0] = [61, 62]
     data[1] = [[41, 42], [11, 12]]
     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
               [51, 52], [61, 62]]
Cette méthode peut être utilisée pour fusionner des partitions créées par `dynamic_partition` comme illustré dans l'exemple suivant : 
# Apply function (increments x_i) on elements for which a certain condition
     # apply (x_i != -1 in this example).
     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
     condition_mask=tf.not_equal(x,tf.constant(-1.))
     partitioned_data = tf.dynamic_partition(
         x, tf.cast(condition_mask, tf.int32) , 2)
     partitioned_data[1] = partitioned_data[1] + 1.0
     condition_indices = tf.dynamic_partition(
         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
     x = tf.dynamic_stitch(condition_indices, partitioned_data)
     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
     # unchanged.

Méthodes publiques

Sortie <T>
comme Sortie ()
Renvoie le handle symbolique d'un tenseur.
statique <T> DynamicStitch <T>
créer ( Scope scope, Iterable< Operand <Integer>> indices, Iterable< Operand <T>> données)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération DynamicStitch.
Sortie <T>
fusionné ()

Méthodes héritées

Méthodes publiques

sortie publique <T> asOutput ()

Renvoie le handle symbolique d'un tenseur.

Les entrées des opérations TensorFlow sont les sorties d'une autre opération TensorFlow. Cette méthode est utilisée pour obtenir un handle symbolique qui représente le calcul de l’entrée.

public static DynamicStitch <T> créer (portée de portée , indices Iterable< Operand <Integer>>, données Iterable< Operand <T>>)

Méthode d'usine pour créer une classe encapsulant une nouvelle opération DynamicStitch.

Paramètres
portée portée actuelle
Retours
  • une nouvelle instance de DynamicStitch

sortie publique <T> fusionnée ()