tensorflow::ops::ProfondeurDansEspace

#include <array_ops.h>

ProfondeurToSpace pour les tenseurs de type T.

Résumé

Réorganise les données de profondeur en blocs spatiaux. Il s'agit de la transformation inverse de SpaceToDepth. Plus précisément, cette opération génère une copie du tenseur d'entrée où les valeurs de la dimension depth sont déplacées par blocs spatiaux vers les dimensions height et width . L'attribut block_size indique la taille des blocs d'entrée et la manière dont les données sont déplacées.

  • Les blocs de données de taille block_size * block_size provenant de la profondeur sont réorganisés en blocs non chevauchants de taille block_size x block_size
  • La largeur du tenseur de sortie est input_depth * block_size , tandis que la hauteur est input_height * block_size .
  • Les coordonnées Y et X de chaque bloc de l'image de sortie sont déterminées par la composante d'ordre supérieur de l'indice du canal d'entrée.
  • La profondeur du tenseur d'entrée doit être divisible par block_size * block_size .

L'attribut data_format spécifie la disposition des tenseurs d'entrée et de sortie avec les options suivantes : « NHWC » : [ batch, height, width, channels ] « NCHW » : [ batch, channels, height, width ] « NCHW_VECT_C » : qint8 [ batch, channels / 4, height, width, 4 ]

Il est utile de considérer l'opération comme la transformation d'un tenseur 6D. Par exemple, pour `data_format = NHWC`, chaque élément du tenseur d'entrée peut être spécifié par 6 coordonnées, ordonnées par ordre décroissant d'importance en mémoire : n, iY, iX, bY, bX, oC (où n = index du lot, iX et iY = coordonnées X et Y dans l'image d'entrée, bX et bY = coordonnées dans le bloc de sortie, et oC = canaux de sortie). La sortie correspond à l'entrée transposée selon la disposition suivante : n, iY, bY, iX, bX, oC.

Cette opération est utile pour redimensionner les activations entre les convolutions (tout en conservant toutes les données), par exemple au lieu d'un pooling. Elle est également utile pour l'entraînement de modèles purement convolutionnels.

Par exemple, étant donné une entrée de forme [1, 1, 1, 4] , data_format = "NHWC" et block_size = 2 : 

x = [[[[1, 2, 3, 4]]]]

  

  
This operation will output a tensor of shape [1, 2, 2, 1]:

  

    
   [[[[1], [2]],
     [[3], [4]]]]
 Ici, l'entrée comporte un lot de 1 et chaque élément du lot a la forme [1, 1, 4] . La sortie correspondante aura 2x2 éléments et une profondeur de 1 canal (1 = 4 / (block_size * block_size) ). La forme des éléments de sortie est [2, 2, 1] .
 Pour un tenseur d'entrée de plus grande profondeur, ici de forme [1, 1, 1, 12] , par exemple 
x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
 Cette opération, pour une taille de bloc de 2, renverra le tenseur suivant de forme [1, 2, 2, 3] 
   [[[[1, 2, 3], [4, 5, 6]],
     [[7, 8, 9], [10, 11, 12]]]]
  

  
Similarly, for the following input of shape [1 2 2 4], and a block size of 2:

  

    
x =  [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
 l'opérateur renverra le tenseur suivant de forme [1 4 4 1] : 
x = [[[ [1],   [2],  [5],  [6]],
      [ [3],   [4],  [7],  [8]],
      [ [9],  [10], [13],  [14]],
      [ [11], [12], [15],  [16]]]]
  

  
Arguments:
    
      
  • scope: A Scope object
    • 
      
  • block_size: The size of the spatial block, same as in Space2Depth.
    • 
    

  
Returns:

                                              




        
Constructors and Destructors

      		





        DepthToSpace(const ::tensorflow::Scope & scope, ::tensorflow::Input input, int64 block_size)
        

      		





        DepthToSpace(const ::tensorflow::Scope & scope, ::tensorflow::Input input, int64 block_size, const DepthToSpace::Attrs & attrs)
        

      		




                                                          




        
Public attributes

      		





        operation
      

        
      





        output
      

        
      




                                                                              




        
Public functions

      		





        node() const 
      

        

          ::tensorflow::Node *
        

      		





        operator::tensorflow::Input() const 
      

        

          
        

      		





        operator::tensorflow::Output() const 
      

        

          
        

      		




                                      




        
Public static functions

      		





        DataFormat(StringPiece x)
      

        
      




                                      




        
Structs

      		





        tensorflow::ops::DepthToSpace::Attrs
      

        
Optional attribute setters for DepthToSpace. 

      		




  
Public attributes

  

    
operation

    
Operation operation
 sortir 
::tensorflow::Output output
 fonctions publiques 
 Profondeur à l'espace 
 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size
)
 Profondeur à l'espace 
 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size,
  const DepthToSpace::Attrs & attrs
)
 nœud 
::tensorflow::Node * node() const 
 opérateur::tensorflow::Entrée 
 operator::tensorflow::Input() const 
 opérateur::tensorflow::Sortie 
 operator::tensorflow::Output() const 
 fonctions statiques publiques 
 Format de données 
Attrs DataFormat(
  StringPiece x
)