Inverse les tranches de longueur variable.
Cette opération coupe d'abord `input` le long de la dimension `batch_dim`, et pour chaque tranche `i`, inverse les premiers éléments `seq_lengths[i]` le long de la dimension `seq_dim`.
Les éléments de `seq_lengths` doivent obéir à `seq_lengths[i] <= input.dims[seq_dim]`, et `seq_lengths` doit être un vecteur de longueur `input.dims[batch_dim]`.
La tranche de sortie `i` le long de la dimension `batch_dim` est ensuite donnée par la tranche d'entrée `i`, les premières tranches `seq_lengths[i]` le long de la dimension `seq_dim` étant inversées.
Par exemple :
# Given this:
batch_dim = 0
seq_dim = 1
input.dims = (4, 8, ...)
seq_lengths = [7, 2, 3, 5]
# then slices of input are reversed on seq_dim, but only up to seq_lengths:
output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
# while entries past seq_lens are copied through:
output[0, 7:, :, ...] = input[0, 7:, :, ...]
output[1, 2:, :, ...] = input[1, 2:, :, ...]
output[2, 3:, :, ...] = input[2, 3:, :, ...]
output[3, 2:, :, ...] = input[3, 2:, :, ...]
# Given this:
batch_dim = 2
seq_dim = 0
input.dims = (8, ?, 4, ...)
seq_lengths = [7, 2, 3, 5]
# then slices of input are reversed on seq_dim, but only up to seq_lengths:
output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
# while entries past seq_lens are copied through:
output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
Classes imbriquées
| classe | ReverseSequence.Options | Attributs facultatifs pour ReverseSequence | |
Méthodes publiques
| Sortie <T> | comme Sortie () Renvoie le handle symbolique d'un tenseur. |
| ReverseSequence.Options statique | batchDim (Long batchDim) |
| statique <T, U étend le nombre> ReverseSequence <T> | créer ( Scope scope, Opérande <T> entrée, Opérande <U> seqLengths, Long seqDim, Options... options) Méthode d'usine pour créer une classe encapsulant une nouvelle opération ReverseSequence. |
| Sortie <T> | sortir () L'entrée partiellement inversée. |
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 statique ReverseSequence.Options batchDim (Long batchDim)
Paramètres
| batchDim | Dimension le long de laquelle l'inversion est effectuée. |
|---|
public static ReverseSequence <T> créer ( Portée de portée , Entrée Opérande <T>, Opérande <U> seqLengths, Long seqDim, Options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération ReverseSequence.
Paramètres
| portée | portée actuelle |
|---|---|
| saisir | L'entrée à inverser. |
| longueurs de séquence | 1-D avec la longueur `input.dims(batch_dim)` et `max(seq_lengths) <= input.dims(seq_dim)` |
| seqDim | La dimension qui est partiellement inversée. |
| choix | porte des valeurs d'attributs facultatifs |
Retour
- une nouvelle instance de ReverseSequence