DepthToSpace

DepthToSpace per tensori di tipo T.

Riorganizza i dati dalla profondità in blocchi di dati spaziali. Questa è la trasformazione inversa di SpaceToDepth. Più specificamente, questa operazione restituisce una copia del tensore di input in cui i valori dalla dimensione "profondità" vengono spostati in blocchi spaziali alle dimensioni "altezza" e "larghezza". L'attributo "block_size" indica la dimensione del blocco di input e il modo in cui i dati vengono spostati.

* Blocchi di dati di dimensione `block_size * block_size` dalla profondità vengono riorganizzati in blocchi non sovrapposti di dimensione `block_size x block_size` * La larghezza del tensore di output è `input_ Depth * block_size`, mentre l'altezza è `input_height * block_size`. * Le coordinate Y, X all'interno di ciascun blocco dell'immagine di uscita sono determinate dalla componente di ordine superiore dell'indice del canale di ingresso. * La profondità del tensore di input deve essere divisibile per `block_size * block_size`.

L'attributo `data_format` specifica il layout dei tensori di input e output con le seguenti opzioni: "NHWC": `[ batch, altezza, larghezza, canali ]` "NCHW": `[ batch, canali, altezza, larghezza ]` " NCHW_VECT_C": `qint8 [ batch, canali / 4, altezza, larghezza, 4]`

È utile considerare l'operazione come la trasformazione di un tensore 6-D. ad esempio, per data_format = NHWC, ogni elemento nel tensore di input può essere specificato tramite 6 coordinate, ordinate in base al significato decrescente del layout della memoria come: n,iY,iX,bY,bX,oC (dove n=indice batch, iX, iY significa X o coordinate Y all'interno dell'immagine di ingresso, bX, bY significa coordinate all'interno del blocco di uscita, oC significa canali di uscita). L'output sarebbe l'input trasposto nel seguente layout: n,iY,bY,iX,bX,oC

Questa operazione è utile per ridimensionare le attivazioni tra le convoluzioni (ma mantenendo tutti i dati), ad esempio invece del pooling. È utile anche per addestrare modelli puramente convoluzionali.

Ad esempio, dato un input di forma `[1, 1, 1, 4]`, data_format = "NHWC" e block_size = 2:

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

Questa operazione restituirà un tensore di forma `[1, 2, 2, 1 ]`:

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

Qui, l'input ha un batch pari a 1 e ciascun elemento batch ha forma `[1, 1, 4]`, l'output corrispondente avrà 2x2 elementi e avrà una profondità di 1 canale (1 = ` 4 / (dimensione_blocco * dimensione_blocco)`). La forma dell'elemento di output è "[2, 2, 1]".

Per un tensore di input con profondità maggiore, qui di forma `[1, 1, 1, 12]`, ad esempio

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

Questa operazione, per dimensioni del blocco pari a 2, restituirà il seguente tensore di forma `[1, 2, 2 , 3]`

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

Allo stesso modo, per il seguente input di forma "[1 2 2 4]" e una dimensione del blocco pari a 2:

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

l'operatore restituirà il seguente tensore di forma "[1 4 4 1] `:

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