tensorflow:: ops:: DepthToSpace

#include <array_ops.h>

ProfundidadEspacial para tensores de tipo T.

Resumen

Reorganiza los datos de profundidad en bloques de datos espaciales. Esta es la transformación inversa de SpaceToDepth. Más específicamente, esta operación genera una copia del tensor de entrada donde los valores de la dimensión depth se mueven en bloques espaciales a las dimensiones height y width . El atributo block_size indica el tamaño del bloque de entrada y cómo se mueven los datos.

  • Los fragmentos de datos de tamaño block_size * block_size de la profundidad se reorganizan en bloques no superpuestos de tamaño block_size x block_size
  • El ancho del tensor de salida es input_depth * block_size , mientras que la altura es input_height * block_size .
  • Las coordenadas Y, X dentro de cada bloque de la imagen de salida están determinadas por el componente de orden superior del índice del canal de entrada.
  • La profundidad del tensor de entrada debe ser divisible por block_size * block_size .

El atributo data_format especifica la disposición de los tensores de entrada y salida con las siguientes opciones: "NHWC": [ batch, height, width, channels ] "NCHW": [ batch, channels, height, width ] "NCHW_VECT_C": qint8 [ batch, channels / 4, height, width, 4 ]

Resulta útil considerar la operación como la transformación de un tensor de 6 dimensiones. Por ejemplo, para data_format = NHWC, cada elemento del tensor de entrada se puede especificar mediante 6 coordenadas, ordenadas según su importancia decreciente en la disposición de la memoria: n, iY, iX, bY, bX, oC (donde n = índice del lote, iX, iY representan las coordenadas X o Y dentro de la imagen de entrada, bX, bY representan las coordenadas dentro del bloque de salida, oC representa los canales de salida). La salida sería la entrada transpuesta a la siguiente disposición: n, iY, bY, iX, bX, oC.

Esta operación resulta útil para redimensionar las activaciones entre convoluciones (manteniendo todos los datos), por ejemplo, en lugar de utilizar la agrupación (pooling). También es útil para entrenar modelos puramente convolucionales.

Por ejemplo, dado un dato de entrada con forma [1, 1, 1, 4] , data_format = "NHWC" y block_size = 2: 

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

  

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

  

    
   [[[[1], [2]],
     [[3], [4]]]]
 Aquí, la entrada tiene un lote de 1 y cada elemento del lote tiene forma [1, 1, 4] , la salida correspondiente tendrá 2x2 elementos y tendrá una profundidad de 1 canal (1 = 4 / (block_size * block_size) ). La forma del elemento de salida es [2, 2, 1] .
 Para un tensor de entrada con mayor profundidad, en este caso de forma [1, 1, 1, 12] , por ejemplo 
x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
 Esta operación, para un tamaño de bloque de 2, devolverá el siguiente tensor de forma [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]]]]
 El operador devolverá el siguiente tensor de forma [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
 producción 
::tensorflow::Output output
 Funciones públicas 
 Profundidad al espacio 
 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size
)
 Profundidad al espacio 
 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size,
  const DepthToSpace::Attrs & attrs
)
 nodo 
::tensorflow::Node * node() const 
 operador::tensorflow::Input 
 operator::tensorflow::Input() const 
 operador::tensorflow::Salida 
 operator::tensorflow::Output() const 
 funciones estáticas públicas 
 Formato de datos 
Attrs DataFormat(
  StringPiece x
)