fluxo tensor:: ops:: Profundidade para espaço

#include <array_ops.h>

DepthToSpace para tensores do tipo T.

Resumo

Reorganiza os dados de profundidade em blocos de dados espaciais. Esta é a transformação reversa do SpaceToDepth. Mais especificamente, esta operação gera uma cópia do tensor de entrada onde os valores da dimensão depth são movidos em blocos espaciais para as dimensões de height e width . O attr block_size indica o tamanho do bloco de entrada e como os dados são movidos.

  • Pedaços de dados de tamanho block_size * block_size de profundidade são reorganizados em blocos não sobrepostos de tamanho block_size x block_size
  • A largura do tensor de saída é input_depth * block_size , enquanto a altura é input_height * block_size .
  • As coordenadas Y, X dentro de cada bloco da imagem de saída são determinadas pelo componente de ordem superior do índice do canal de entrada.
  • A profundidade do tensor de entrada deve ser divisível por block_size * block_size .

O atributo data_format especifica o layout dos tensores de entrada e saída com as seguintes opções: "NHWC": [ batch, height, width, channels ] "NCHW": [ batch, channels, height, width ] "NCHW_VECT_C": qint8 [ batch, channels / 4, height, width, 4 ]

É útil considerar a operação como a transformação de um Tensor 6-D. por exemplo, para data_format = NHWC, cada elemento no tensor de entrada pode ser especificado por meio de 6 coordenadas, ordenadas diminuindo a significância do layout da memória como: n,iY,iX,bY,bX,oC (onde n=índice de lote, iX, iY significa X ou coordenadas Y dentro da imagem de entrada, bX, bY significa coordenadas dentro do bloco de saída, oC significa canais de saída). A saída seria a entrada transposta para o seguinte layout: n,iY,bY,iX,bX,oC

Esta operação é útil para redimensionar as ativações entre convoluções (mas mantendo todos os dados), por exemplo, em vez de agrupar. Também é útil para treinar modelos puramente convolucionais.

Por exemplo, dada uma entrada de formato [1, 1, 1, 4] , data_format = "NHWC" e block_size = 2: 

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

  

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

  

    
   [[[[1], [2]],
     [[3], [4]]]]
 Aqui, a entrada tem um lote de 1 e cada elemento do lote tem formato [1, 1, 4] , a saída correspondente terá 2x2 elementos e terá profundidade de 1 canal (1 = 4 / (block_size * block_size) ). A forma do elemento de saída é [2, 2, 1] .
 Para um tensor de entrada com maior profundidade, aqui de formato [1, 1, 1, 12] , por exemplo 
x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
 Esta operação, para tamanho de bloco 2, retornará o seguinte 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]]]]
 o operador retornará o seguinte 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
 saída 
::tensorflow::Output output
 Funções públicas 
 Profundidade para espaço 
 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size
)
 Profundidade para espaço 
 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size,
  const DepthToSpace::Attrs & attrs
)
 nó 
::tensorflow::Node * node() const 
 operador::tensorflow::Input 
 operator::tensorflow::Input() const 
 operador::tensorflow::Saída 
 operator::tensorflow::Output() const 
 Funções estáticas públicas 
 Formato de dados 
Attrs DataFormat(
  StringPiece x
)