DepthToSpace

DepthToSpace para tensores de tipo T.

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 "profundidad" se mueven en bloques espaciales a las dimensiones "altura" y "ancho". 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 el diseño de los tensores de entrada y salida con las siguientes opciones:" NHWC ":` [lote, alto, ancho, canales] `" NCHW ":` [lote, canales, alto, ancho] `" NCHW_VECT_C ":` qint8 [lote, canales / 4, alto, ancho, 4] `

Es útil considerar la operación como una transformación de un tensor 6-D. Por ejemplo, para data_format = NHWC, cada elemento en el tensor de entrada se puede especificar a través de 6 coordenadas, ordenadas disminuyendo la importancia del diseño de la memoria como: n, iY, iX, bY, bX, oC (donde n = índice de lote, iX, iY significa X o coordenadas Y dentro de la imagen de entrada, bX, bY significa coordenadas dentro del bloque de salida, oC significa canales de salida). La salida sería la entrada transpuesta al siguiente diseño: n, iY, bY, iX, bX, oC

Esta operación es útil para cambiar el tamaño de las activaciones entre convoluciones (pero manteniendo todos los datos), por ejemplo, en lugar de agrupar. También es útil para entrenar modelos puramente convolucionales.

Por ejemplo, dada una entrada de forma `[1, 1, 1, 4]`, data_format = "NHWC" y block_size = 2:

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

Esta salida de operación voluntad un tensor de la forma `[1, 2, 2, 1 ] `:

[[[[1], [2]],
      [[3], [4]]]]
 

Aquí, la entrada tiene un lote de 1 y cada elemento de proceso por lotes tiene forma` [1, 1, 4] `, la salida correspondiente tendrá 2x2 elementos y tendrá una profundidad de 1 canal (1 =` 4 / (tamaño_bloque * tamaño_bloque) `). La forma del elemento de salida es "[2, 2, 1]".

Para un tensor de entrada con la profundidad más grande, aquí de forma `[1, 1, 1, 12]`, por ejemplo

x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
 

Esta operación, por tamaño de bloque de 2, volverá la siguiente tensor de la forma `[1, 2, 2 , 3] `

[[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
 
 

mismo modo, para la siguiente entrada de la forma` [1 2 2 4] `, y un tamaño de bloque de 2:

x =  [[[[1, 2, 3, 4],
        [5, 6, 7, 8]],
       [[9, 10, 11, 12],
        [13, 14, 15, 16]]]]
 

el operador volverá la siguiente tensor de la forma` [1 4 4 1] `:

x = [[[ [1],   [2],  [5],  [6]],
       [ [3],   [4],  [7],  [8]],
       [ [9],  [10], [13],  [14]],
       [ [11], [12], [15],  [16]]]]