flujo tensor:: operaciones:: Lote al espacioND

BatchToSpace para tensores ND de tipo T.

Resumen

Esta operación remodela la dimensión "lote" 0 en M + 1 dimensiones de forma block_shape + [batch] , entrelaza 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 según crops para producir el resultado. Esto es lo contrario de SpaceToBatch. Consulte a continuación para obtener una descripción precisa.

Argumentos:

• alcance: un objeto de alcance
• entrada: ND con forma input_shape = [batch] + spatial_shape + remaining_shape , donde forma_espacial 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 recortar 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 equivale a los siguientes pasos:

1. Transformar input para reshaped la forma: [block_shape[0], ..., block_shape[M-1], lote / prod(block_shape), input_shape[1], ..., input_shape[N-1]]
2. Permutar dimensiones de reshaped para producir forma permuted [batch / prod(block_shape),input_shape[1], block_shape[0], ..., input_shape[M], block_shape[M-1],input_shape[M+1], ..., forma_entrada[N-1]]
3. Reforma permuted para producir reshaped_permuted de forma [batch / prod(block_shape),input_shape[1] * block_shape[0], ..., input_shape[M] * block_shape[M-1],input_shape[M+1], .. ., forma_entrada[N-1]]
4. Recorte el inicio y el final de las dimensiones [1, ..., M] de reshaped_permuted según los crops para producir la salida de forma: [batch / prod(block_shape),input_shape[1] * block_shape[0] - crop[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:

• 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