BatchToSpaceNd

classe finale pubblica 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 nuovamente 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 poi facoltativamente ritagliate in base ai "ritagli" per produrre l'output. Questo è il contrario di SpaceToBatch. Vedi sotto per una descrizione precisa.

Metodi pubblici

Uscita <T>
comeuscita ()
Restituisce la maniglia simbolica di un tensore.
statico <T, U estende Numero, V estende Numero> BatchToSpaceNd <T>
create (ambito dell'ambito , input dell'operando <T>, forma del blocco dell'operando <U>, ritagli dell'operando <V>)
Metodo factory per creare una classe che racchiude una nuova operazione BatchToSpaceNd.
Uscita <T>
produzione ()

Metodi ereditati

Metodi pubblici

Uscita pubblica <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> ritagli)

Metodo factory per creare una classe che racchiude una nuova operazione BatchToSpaceNd.

Parametri
scopo ambito attuale
ingresso ND con forma `forma_input = [batch] + forma_spaziale + forma_rimanente`, dove forma_spaziale ha M dimensioni.
bloccoForma 1-D con forma `[M]`, tutti i valori devono essere >= 1.
raccolti 2-D con forma "[M, 2]", tutti i valori devono essere >= 0. "crops[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 `reshape` della forma: [block_shape[0], ..., block_shape[M-1], batch / prod(block_shape), input_shape[1], ..., input_shape[N- 1]]

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

forma_input[1], forma_blocco[0], ..., forma_input[M], forma_blocco[M-1],

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

3. Rimodellare "permutato" per produrre "rimodellato_permutato" della forma [batch / prod(block_shape),

forma_input[1] * forma_blocco[0], ..., forma_input[M] * forma_blocco[M-1],

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

4. Ritaglia l'inizio e la fine delle dimensioni "[1, ..., M]" di "reshape_permuted" in base a "crops" per produrre l'output di shape: [batch / prod(block_shape),

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

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

Qualche esempio:

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

[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
Il tensore di output ha forma `[1, 2, 2, 1]` e valore: 
x = [[[[1], [2]], [[3], [4]]]]
(2) Per il seguente input di forma `[4, 1, 1, 3]`, `block_shape = [ 2, 2]` e `crops = [[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 forma "[4, 2, 2, 1]", "block_shape = [2, 2]" e "crops = [[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 `crops = [[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 output 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

Uscita pubblica <T> uscita ()