SpaceToBatchNd

public final class SpaceToBatchNd

SpaceToBatch per tensori ND di tipo T.

Questa operazione divide le dimensioni "spaziali" `[1, ..., M]` dell'input in una griglia di blocchi di forma `block_shape`, e intercala questi blocchi con la dimensione" batch "(0) in modo tale che nell'output , le dimensioni spaziali "[1, ..., M]" corrispondono alla posizione all'interno della griglia e la dimensione batch combina sia la posizione all'interno di un blocco spaziale sia la posizione batch originale. Prima della divisione in blocchi, le dimensioni spaziali dell'input sono opzionalmente riempite con zero secondo "paddings". 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> SpaceToBatchNd <T>
create ( ambito ambito, operando <T> input, operando <U> blockShape, operando <V> padding)
Metodo Factory per creare una classe che racchiude una nuova operazione SpaceToBatchNd.
Uscita <T>
output ()

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 SpaceToBatchNd <T> create ( Scope scope, Operand <T> input, Operand <U> blockShape, Operand <V> paddings)

Metodo Factory per creare una classe che racchiude una nuova operazione SpaceToBatchNd.

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.
imbottiture 2-D con forma "[M, 2]", tutti i valori devono essere> = 0. "paddings [i] = [pad_start, pad_end]" specifica il riempimento per la dimensione di input "i + 1", che corrisponde alla dimensione spaziale "io". È necessario che `block_shape [i]` divida `input_shape [i + 1] + pad_start + pad_end`.

Questa operazione equivale ai seguenti passaggi:

1. Zero-pad l'inizio e la fine delle dimensioni "[1, ..., M]" dell'input secondo "paddings" per produrre "padded" di forma "padded_shape".

2. Rimodella "padded" in "reshaped_padded" della forma:

[batch] + [padded_shape [1] / block_shape [0], block_shape [0], ..., padded_shape [M] / block_shape [M-1], block_shape [M-1]] + going_shape

3. Permuta le dimensioni di "reshaped_padded" per produrre "permuted_reshaped_padded" di forma:

block_shape + [batch] + [padded_shape [1] / block_shape [0], ..., padded_shape [M] / block_shape [M-1]] + going_shape

4. Rimodella `permuted_reshaped_padded` per appiattire` block_shape` nella dimensione batch, producendo un tensore di forma di output:

[batch * prod (block_shape)] + [padded_shape [1] / block_shape [0], ..., padded_shape [M] / block_shape [M-1]] + going_shape

Qualche esempio:

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

x = [[[[1], [2]], [[3], [4]]]]
 
Il tensore di uscita ha forma "[4, 1, 1, 1]" e valore:
[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
 
(2) Per il seguente ingresso di forma "[1, 2, 2, 3]", "block_shape = [2, 2] `e` paddings = [[0, 0], [0, 0]] `:
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
 
Il tensore di uscita ha forma` [4, 1, 1, 3] `e valore:
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
 
(3) Per il seguente input di shape `[1, 4, 4, 1]`, `block_shape = [2, 2]` e `paddings = [[0, 0], [0, 0]]`:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]],
       [[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
 
Il tensore di uscita ha forma `[ 4, 2, 2, 1] "e valore:
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
 
(4) Per il seguente input di forma" [2, 2, 4, 1] ", block_shape =" [2, 2] "e paddings =" [[ 0, 0], [2, 0]] `:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
 
Il tensore di uscita ha forma` [8, 1, 3, 1] `e valore:
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]]]]
 
Tra l'altro, questa operazione è utile per ridurre la convoluzione atrosa in convoluzione regolare.
ritorna
  • una nuova istanza di SpaceToBatchNd

output pubblico <T> output ()