SpaceToBatchNd

classe finale publique SpaceToBatchNd

SpaceToBatch pour les tenseurs ND de type T.

Cette opération divise les dimensions "spatiales" `[1, ..., M]` de l'entrée en une grille de blocs de forme `block_shape`, et entrelace ces blocs avec la dimension "batch" (0) telle que dans la sortie , les dimensions spatiales « [1, ..., M] » correspondent à la position dans la grille, et la dimension du lot combine à la fois la position dans un bloc spatial et la position d'origine du lot. Avant la division en blocs, les dimensions spatiales de l'entrée sont éventuellement complétées par des zéros en fonction des « paddings ». Voir ci-dessous pour une description précise.

Constantes

Chaîne OP_NAME Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Méthodes publiques

Sortie <T>
comme Sortie ()
Renvoie le handle symbolique du tenseur.
statique <T étend TType > SpaceToBatchNd <T>
créer ( Portée de la portée , Entrée Opérande <T>, Opérande <? étend TNumber > blockShape, Opérande <? étend TNumber > paddings)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération SpaceToBatchNd.
Sortie <T>
sortir ()

Méthodes héritées

Constantes

chaîne finale statique publique OP_NAME

Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Valeur constante : "SpaceToBatchND"

Méthodes publiques

sortie publique <T> asOutput ()

Renvoie le handle symbolique du 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 SpaceToBatchNd <T> créer (portée de la portée , entrée de l'opérande <T>, opérande <? étend TNumber > blockShape, opérande <? étend TNumber > paddings)

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

Paramètres
portée portée actuelle
saisir ND avec la forme `input_shape = [batch] + spatial_shape + left_shape`, où spatial_shape a des dimensions `M`.
forme de bloc 1-D avec la forme `[M]`, toutes les valeurs doivent être >= 1.
rembourrages 2-D avec la forme `[M, 2]`, toutes les valeurs doivent être >= 0. `paddings[i] = [pad_start, pad_end]` spécifie le remplissage pour la dimension d'entrée `i + 1`, qui correspond à la dimension spatiale 'je'. Il est nécessaire que `block_shape[i]` divise `input_shape[i + 1] + pad_start + pad_end`.

Cette opération équivaut aux étapes suivantes :

1. Complétez par zéro le début et la fin des dimensions `[1, ..., M]` de l'entrée en fonction des `paddings` pour produire un `rembourré` de forme `padded_shape`.

2. Remodelez « padded » en « reshape_padded » de forme :

[lot] + [padded_shape[1] / block_shape[0], block_shape[0], ..., padded_shape[M] / block_shape[M-1], block_shape[M-1]] + restant_shape

3. Permutez les dimensions de `reshape_padded` pour produire `permuted_reshape_padded` de forme :

block_shape + [batch] + [padded_shape[1] / block_shape[0], ..., padded_shape[M] / block_shape[M-1]] + restant_shape

4. Remodelez `permuted_reshape_padded` pour aplatir `block_shape` dans la dimension du lot, produisant un tenseur de sortie de forme :

[batch * prod(block_shape)] + [padded_shape[1] / block_shape[0], ..., padded_shape[M] / block_shape[M-1]] + restant_shape

Quelques exemples:

(1) Pour l'entrée suivante de forme `[1, 2, 2, 1]`, `block_shape = [2, 2]` et `paddings = [[0, 0], [0, 0]]` : 

x = [[[[1], [2]], [[3], [4]]]]
Le tenseur de sortie a la forme `[4, 1, 1, 1]` et la valeur : 
[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
(2) Pour l'entrée suivante de forme `[1, 2, 2, 3]`, `block_shape = [ 2, 2]` et `paddings = [[0, 0], [0, 0]]` : 
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
Le tenseur de sortie a la forme `[4, 1, 1, 3]` et la valeur : 
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
(3) Pour l'entrée suivante de forme `[1, 4, 4, 1]`, `block_shape = [2, 2]` et `paddings = [[0, 0], [0, 0]]` : 
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]],
       [[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
Le tenseur de sortie a la forme `[4, 2, 2, 1]` et la valeur : 
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
(4) Pour l'entrée suivante de forme `[2, 2, 4, 1]`, block_shape = `[ 2, 2]` et paddings = `[[0, 0], [2, 0]]` : 
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
Le tenseur de sortie a la forme `[8, 1, 3, 1]` et la valeur : 
x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
      [[[0], [2], [4]]], [[[0], [10], [12]]],
      [[[0], [5], [7]]], [[[0], [13], [15]]],
      [[[0], [6], [8]]], [[[0], [14], [16]]]]
Entre autres, cette opération est utile pour réduire la circonvolution atreuse en circonvolution régulière.

Retour
  • une nouvelle instance de SpaceToBatchNd

sortie publique <T> sortie ()