SpaceToDepth

SpaceToDepth per tensori di tipo T.

Riorganizza blocchi di dati spaziali, in profondità. Più specificamente, questa operazione restituisce una copia del tensore di input in cui i valori delle dimensioni "altezza" e "larghezza" vengono spostati nella dimensione "profondità". L'attributo "block_size" indica la dimensione del blocco di input.

* I blocchi non sovrapposti di dimensione "dimensione_blocco x dimensione blocco" vengono riorganizzati in profondità in ciascuna posizione. * La profondità del tensore di output è "dimensione_blocco * dimensione_blocco * profondità_input". * Le coordinate Y, X all'interno di ciascun blocco di input diventano il componente di ordine superiore dell'indice del canale di output. * L'altezza e la larghezza del tensore di input devono essere divisibili per 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,oY,bY,oX,bX,iC (dove n=indice batch, oX, oY significa X o coordinate Y all'interno dell'immagine di output, bX, bY significa coordinate all'interno del blocco di input, iC significa canali di input). L'output sarebbe una trasposizione nel seguente layout: n,oY,oX,bY,bX,iC

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

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

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

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

Qui, l'input ha un batch pari a 1 e ciascun elemento batch ha forma "[2, 2, 1]", l'output corrispondente avrà un singolo elemento (ovvero larghezza e altezza sono entrambi 1) e hanno una profondità di 4 canali (1 * block_size * block_size). La forma dell'elemento di output è "[1, 1, 4]".

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

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

Questa operazione, per block_size pari a 2, restituirà il seguente tensore di forma `[1, 1, 1, 12]`

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

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

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

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

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