BatchToSpaceNd

public final class BatchToSpaceNd

BatchToSpace per tensori ND di tipo T.

Questa operazione rimodella la dimensione "batch" 0 nelle dimensioni "M + 1" della forma "block_shape + [batch]", intercala questi blocchi nella griglia definita dalle dimensioni spaziali "[1, ..., M]", per ottenere un risultato con lo stesso rango dell'input. Le dimensioni spaziali di questo risultato intermedio vengono quindi eventualmente ritagliate in base a "crop" per produrre l'output. Questo è il contrario di SpaceToBatch. Vedi sotto per una descrizione precisa.

Metodi pubblici

Uscita <T>
asOutput ()
Restituisce la maniglia simbolica di un tensore.
static <T, U estende il numero, V estende il numero> BatchToSpaceNd <T>
create ( ambito ambito, operando <T> input, operando <U> blockShape, operando <V> ritaglia)
Metodo Factory per creare una classe che avvolge una nuova operazione BatchToSpaceNd.
Uscita <T>
uscita ()

Metodi ereditati

Metodi pubblici

output pubblico <T> asOutput ()

Restituisce la maniglia simbolica di un tensore.

Gli input per le operazioni TensorFlow sono output di un'altra operazione TensorFlow. Questo metodo viene utilizzato per ottenere un handle simbolico che rappresenta il calcolo dell'input.

public static BatchToSpaceNd <T> create ( ambito ambito, operando <T> input, operando <U> blockShape, operando <V> crop)

Metodo Factory per creare una classe che avvolge una nuova operazione BatchToSpaceNd.

Parametri
scopo ambito attuale
ingresso ND con forma `input_shape = [batch] + spatial_shape + rimanente_shape`, dove spatial_shape ha dimensioni M.
blockShape 1-D con forma "[M]", tutti i valori devono essere> = 1.
colture 2-D con forma "[M, 2]", tutti i valori devono essere> = 0. "crop [i] = [crop_start, crop_end]" specifica la quantità da ritagliare dalla dimensione di input "i + 1", che corrisponde a dimensione spaziale "i". È necessario che `crop_start [i] + crop_end [i] <= block_shape [i] * input_shape [i + 1]`.

Questa operazione equivale ai seguenti passaggi:

1. Rimodellare "input" in "reshaped" della forma: [block_shape [0], ..., block_shape [M-1], batch / prod (block_shape), input_shape [1], ..., input_shape [N- 1]]

2. Permuta le dimensioni di "rimodellato" per produrre "permutato" di forma [batch / prod (block_shape)

input_shape [1], block_shape [0], ..., input_shape [M], block_shape [M-1],

input_shape [M + 1], ..., input_shape [N-1]]

3. Rimodellare "permuted" per produrre "reshaped_permuted" di forma [batch / prod (block_shape),

input_shape [1] * block_shape [0], ..., input_shape [M] * block_shape [M-1],

input_shape [M + 1], ..., input_shape [N-1]]

4. Ritaglia l'inizio e la fine delle dimensioni "[1, ..., M]" di "reshaped_permuted" secondo "crop" per produrre l'output di shape: [batch / prod (block_shape),

input_shape [1] * block_shape [0] - raccolti [0,0] - raccolti [0,1], ..., input_shape [M] * block_shape [M-1] - raccolti [M-1,0] - raccolti [M-1,1],

input_shape [M + 1], ..., input_shape [N-1]]

Qualche esempio:

(1) Per il seguente input di forma "[4, 1, 1, 1]", "block_shape = [2, 2]" e "crop = [[0, 0], [0, 0]]":

[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
 
Il tensore di uscita ha forma "[1, 2, 2, 1]" e valore:
x = [[[[1], [2]], [[3], [4]]]]
 
(2) Per il seguente ingresso di forma "[4, 1, 1, 3]", "block_shape = [2, 2] `, e` crop = [[0, 0], [0, 0]] `:
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
 
Il tensore di output ha forma` [1, 2, 2, 3] `e valore:
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
 
(3) Per il seguente input di shape `[4, 2, 2, 1]`, `block_shape = [2, 2]` e `crop = [[0, 0], [0, 0]]`:
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
 
Il tensore di output ha forma `[ 1, 4, 4, 1] "e valore:
x = [[[[1],   [2],  [3],  [4]],
      [[5],   [6],  [7],  [8]],
      [[9],  [10], [11],  [12]],
      [[13], [14], [15],  [16]]]]
 
(4) Per il seguente input di forma" [8, 1, 3, 1] "," block_shape = [2, 2] "e" crop = [[ 0, 0], [2, 0]] `:
x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
      [[[0], [2], [4]]], [[[0], [10], [12]]],
      [[[0], [5], [7]]], [[[0], [13], [15]]],
      [[[0], [6], [8]]], [[[0], [14], [16]]]]
 
Il tensore di uscita ha forma` [2, 2, 4, 1] `e valore:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
 
ritorna
  • una nuova istanza di BatchToSpaceNd

output pubblico <T> output ()