BatchToSpaceNd

classe final pública BatchToSpaceNd

BatchToSpace para tensores ND do tipo T.

Esta operação remodela a dimensão do "lote" 0 em dimensões `M + 1` da forma `block_shape + [lote]`, intercala esses blocos de volta na grade definida pelas dimensões espaciais `[1, ..., M]`, para obter um resultado com a mesma classificação da entrada. As dimensões espaciais deste resultado intermediário são então opcionalmente cortadas de acordo com `crops` para produzir a saída. Este é o inverso do SpaceToBatch. Veja abaixo uma descrição precisa.

Métodos Públicos

Saída <T>
asOutput ()
Retorna o identificador simbólico de um tensor.
estático <T, U estende o número, V estende o número> BatchToSpaceNd <T>
criar (escopo do escopo , entrada do operando <T>, forma do bloco do operando <U>, culturas do operando <V>)
Método de fábrica para criar uma classe que agrupa uma nova operação BatchToSpaceNd.
Saída <T>
saída ()

Métodos herdados

Métodos Públicos

Saída pública <T> asOutput ()

Retorna o identificador simbólico de um tensor.

As entradas para operações do TensorFlow são saídas de outra operação do TensorFlow. Este método é usado para obter um identificador simbólico que representa o cálculo da entrada.

public static BatchToSpaceNd <T> create (escopo do escopo , entrada do operando <T>, forma de bloco do operando <U>, culturas do operando <V>)

Método de fábrica para criar uma classe que agrupa uma nova operação BatchToSpaceNd.

Parâmetros
escopo escopo atual
entrada ND com forma `input_shape = [lote] + espacial_shape + restante_shape`, onde a forma_espacial tem M dimensões.
forma de bloco 1-D com formato `[M]`, todos os valores devem ser >= 1.
plantações 2-D com formato `[M, 2]`, todos os valores devem ser >= 0. `crops[i] = [crop_start, crop_end]` especifica a quantidade a ser cortada da dimensão de entrada `i + 1`, que corresponde a dimensão espacial `i`. É necessário que `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.

Esta operação é equivalente às seguintes etapas:

1. Remodele `input` para `remodelado` da forma: [block_shape[0], ..., block_shape[M-1], batch / prod(block_shape), input_shape[1], ..., input_shape[N- 1]]

2. Permutar dimensões de `remodelado` para produzir `permutado` de forma [batch / prod(block_shape),

forma_de_entrada[1], forma_de_bloco[0], ..., forma_de_entrada[M], forma_de_bloco[M-1],

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

3. Remodele `permuted` para produzir `reformed_permuted` de formato [batch / prod(block_shape),

forma_entrada[1] * forma_bloco[0], ..., forma_entrada[M] * forma_bloco[M-1],

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

4. Corte o início e o fim das dimensões `[1, ..., M]` de `reformed_permuted` de acordo com `crops` para produzir a saída da forma: [batch / prod(block_shape),

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

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

Alguns exemplos:

(1) Para a seguinte entrada de forma `[4, 1, 1, 1]`, `block_shape = [2, 2]` e `crops = [[0, 0], [0, 0]]`:

[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
O tensor de saída tem forma `[1, 2, 2, 1]` e valor:
x = [[[[1], [2]], [[3], [4]]]]
(2) Para a seguinte entrada de 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]]]]
O tensor de saída tem forma `[1, 2, 2, 3]` e valor:
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
(3) Para a seguinte entrada de 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]]]]
O tensor de saída tem forma `[1, 4, 4, 1]` e valor:
x = [[[[1],   [2],  [3],  [4]],
      [[5],   [6],  [7],  [8]],
      [[9],  [10], [11],  [12]],
      [[13], [14], [15],  [16]]]]
(4) Para a seguinte entrada de 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]]]]
O tensor de saída tem forma `[2, 2, 4, 1]` e valor:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]

Devoluções
  • uma nova instância de BatchToSpaceNd

Saída pública <T> saída ()