BatchToSpaceNd

clase final pública BatchToSpaceNd

BatchToSpace para tensores ND de tipo T.

Esta operación transforma la dimensión 0 del "lote" en dimensiones `M + 1` de la forma `block_shape + [batch]`, intercala estos bloques nuevamente en la cuadrícula definida por las dimensiones espaciales `[1, ..., M]`, para obtener un resultado con el mismo rango que la entrada. Las dimensiones espaciales de este resultado intermedio se recortan opcionalmente de acuerdo con "recortes" para producir la salida. Este es el reverso de SpaceToBatch. Véase más abajo para una descripción precisa.

Métodos públicos

Salida <T>
como salida ()
Devuelve el identificador simbólico de un tensor.
estático <T, U extiende Número, V extiende Número> BatchToSpaceNd <T>
crear ( ámbito de ámbito, entrada de operando <T>, forma de bloque de operando <U>, cultivos de operando <V>)
Método de fábrica para crear una clase que envuelve una nueva operación BatchToSpaceNd.
Salida <T>
salida ()

Métodos Heredados

Métodos públicos

salida pública <T> como salida ()

Devuelve el identificador simbólico de un tensor.

Las entradas de las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.

public static BatchToSpaceNd <T> create ( Scope scope, Operand <T> input, Operand <U> blockShape, Operand <V> crops)

Método de fábrica para crear una clase que envuelve una nueva operación BatchToSpaceNd.

Parámetros
alcance alcance actual
aporte ND con forma `forma_entrada = [lote] + forma_espacial + forma_restante`, donde forma_espacial tiene M dimensiones.
forma de bloque 1-D con forma `[M]`, todos los valores deben ser >= 1.
cultivos 2-D con forma `[M, 2]`, todos los valores deben ser >= 0. `crops[i] = [crop_start, crop_end]` especifica la cantidad a recortar de la dimensión de entrada `i + 1`, que corresponde a dimensión espacial `i`. Se requiere que `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.

Esta operación es equivalente a los siguientes pasos:

1. Reformar `input` a `remodelado` de forma: [block_shape[0], ..., block_shape[M-1], lote / prod(block_shape), input_shape[1], ..., input_shape[N- 1]]

2. Permutar las dimensiones de `remodelado` para producir `permutado` de forma [batch / prod(block_shape),

forma_entrada[1], forma_bloque[0], ..., forma_entrada[M], forma_bloque[M-1],

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

3. Reformar `permutado` para producir `remodelado_permutado` de forma [batch / prod(block_shape),

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

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

4. Recorte el inicio y el final de las dimensiones `[1, ..., M]` de `reshaped_permuted` de acuerdo con `crops` para producir la salida de forma: [batch / prod(block_shape),

forma_entrada[1] * forma_bloque[0] - cultivos[0,0] - cultivos[0,1], ..., forma_entrada[M] * forma_bloque[M-1] - cultivos[M-1,0] - cultivos [M-1,1],

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

Algunos ejemplos:

(1) Para la siguiente entrada de forma `[4, 1, 1, 1]`, `block_shape = [2, 2]` y `crops = [[0, 0], [0, 0]]`: 

[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
El tensor de salida tiene forma `[1, 2, 2, 1]` y valor: 
x = [[[[1], [2]], [[3], [4]]]]
(2) Para la siguiente entrada de forma `[4, 1, 1, 3]`, `block_shape = [ 2, 2]` y `crops = [[0, 0], [0, 0]]`: 
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
El tensor de salida tiene forma `[1, 2, 2, 3]` y valor: 
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
(3) Para la siguiente entrada de forma `[4, 2, 2, 1]`, `block_shape = [2, 2]` y `crops = [[0, 0], [0, 0]]`: 
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
El tensor de salida tiene forma `[1, 4, 4, 1]` y valor: 
x = [[[[1],   [2],  [3],  [4]],
      [[5],   [6],  [7],  [8]],
      [[9],  [10], [11],  [12]],
      [[13], [14], [15],  [16]]]]
(4) Para la siguiente entrada de forma `[8, 1, 3, 1]`, `block_shape = [ 2, 2]` y `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]]]]
El tensor de salida tiene forma `[2, 2, 4, 1]` y valor: 
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]

Devoluciones
  • una nueva instancia de BatchToSpaceNd

salida pública <T> salida ()