SpaceToDepth

SpaceToDepth para tensores de tipo T.

Reorganiza bloques de datos espaciales en profundidad. Más específicamente, esta operación genera una copia del tensor de entrada donde los valores de las dimensiones de "altura" y "ancho" se mueven a la dimensión de "profundidad". El atributo `block_size` indica el tamaño del bloque de entrada.

* Los bloques no superpuestos de tamaño `block_size x block size` se reorganizan en profundidad en cada ubicación. * La profundidad del tensor de salida es `block_size * block_size * input_depth`. * Las coordenadas Y, X dentro de cada bloque de la entrada se convierten en el componente de orden superior del índice del canal de salida. * La altura y el ancho del tensor de entrada deben ser divisibles por 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, oY, bY, oX, bX, iC (donde n = índice de lote, oX, oY significa X o coordenadas Y dentro de la imagen de salida, bX, bY significa coordenadas dentro del bloque de entrada, iC significa canales de entrada). La salida sería una transposición al siguiente diseño: n, oY, oX, bY, bX, iC

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, 2, 2, 1]`, data_format = "NHWC" y block_size = 2:

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

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

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

Aquí, la entrada tiene un lote de 1 y cada elemento de proceso por lotes tiene forma` [2, 2, 1] `, la salida correspondiente tendrá un único elemento (es decir, anchura y altura son ambos 1) y Will tener una profundidad de 4 canales (1 * block_size * block_size). La forma del elemento de salida es "[1, 1, 4]".

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

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

Esta operación, por block_size de 2, devolverá el siguiente tensor de la forma `[1, 1, 1, 12] `

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

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

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

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

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