tensorflow :: operaciones :: BatchToSpaceND

BatchToSpace para tensores ND de tipo T.

Resumen

Esta operación transforma la dimensión de "lote" 0 en M + 1 dimensiones de forma block_shape + [batch] , intercala estos bloques de nuevo 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 según los crops para producir el resultado. Este es el reverso de SpaceToBatch. Consulte a continuación para obtener una descripción precisa.

Argumentos:

• alcance: un objeto de alcance
• input: ND con forma input_shape = [batch] + spatial_shape + remaining_shape , donde espacial_shape tiene M dimensiones.
• block_shape: 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 cultivar de la dimensión de entrada i + 1 , que corresponde a la 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. Reforma de la input para reshaped forma: [block_shape [0], ..., block_shape [M-1], lote / producción (block_shape), input_shape [1], ..., input_shape [N-1]]
2. Permutar dimensiones de reshaped para producir permuted de 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. Reformar permuted para producir reshaped_permuted de forma [lote / prod (forma_bloque), forma_entrada [1] * forma_bloque [0], ..., forma_entrada [M] * forma_bloque [M-1], forma_entrada [M + 1], .. ., input_shape [N-1]]
4. Recorta el inicio y el final de las dimensiones [1, ..., M] de reshaped_permuted según los crops para producir el resultado de la forma: [lote / prod (block_shape), input_shape [1] * block_shape [0] - cultivos [0, 0] - cultivos [0,1], ..., input_shape [M] * block_shape [M-1] - cultivos [M-1,0] - cultivos [M-1,1], input_shape [M + 1] , ..., input_shape [N-1]]

Algunos ejemplos:

(1) Para la siguiente entrada de forma [4, 1, 1, 1] , block_shape = [2, 2] y block_shape = [2, 2] 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 block_shape = [2, 2] 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 block_shape = [2, 2] 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 block_shape = [2, 2] 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:

• Output : el tensor de salida.

Atributos públicos

Operation operation

::tensorflow::Output output

 BatchToSpaceND(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input block_shape,
  ::tensorflow::Input crops
)

::tensorflow::Node * node() const 

 operator::tensorflow::Input() const 

 operator::tensorflow::Output() const