SpaceToBatchNd

clase final pública SpaceToBatchNd

SpaceToBatch para tensores ND de tipo T.

Esta operación divide las dimensiones "espaciales" `[1, ..., M]` de la entrada en una cuadrícula de bloques de forma `block_shape` y entrelaza estos bloques con la dimensión "por lotes" (0) de modo que en la salida , las dimensiones espaciales `[1, ..., M]` corresponden a la posición dentro de la cuadrícula, y la dimensión del lote combina tanto la posición dentro de un bloque espacial como la posición del lote original. Antes de la división en bloques, las dimensiones espaciales de la entrada se rellenan opcionalmente con ceros según "paddings". Consulte a continuación para obtener una descripción precisa.

Constantes

Cadena OP_NOMBRE El nombre de esta operación, como lo conoce el motor central de TensorFlow.

Métodos públicos

Salida <T>
como salida ()
Devuelve el identificador simbólico del tensor.
estático <T extiende TType > SpaceToBatchNd <T>
crear (alcance alcance , entrada del operando <T>, operando <? extiende TNumber > blockShape, operando <? extiende TNumber > rellenos)
Método de fábrica para crear una clase que envuelve una nueva operación SpaceToBatchNd.
Salida <T>
producción ()

Métodos heredados

Constantes

Cadena final estática pública OP_NAME

El nombre de esta operación, como lo conoce el motor central de TensorFlow.

Valor constante: "SpaceToBatchND"

Métodos públicos

Salida pública <T> como Salida ()

Devuelve el identificador simbólico del tensor.

Las entradas a 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.

creación pública estática de SpaceToBatchNd <T> (alcance del alcance , entrada del operando <T>, operando <? extiende TNumber > blockShape, operando <? extiende TNumber > rellenos)

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

Parámetros
alcance alcance actual
aporte ND con forma `input_shape = [batch] + espacial_shape + restante_shape`, donde espacial_shape tiene dimensiones `M`.
bloqueForma 1-D con forma `[M]`, todos los valores deben ser >= 1.
acolchados 2-D con forma `[M, 2]`, todos los valores deben ser >= 0. `paddings[i] = [pad_start, pad_end]` especifica el relleno para la dimensión de entrada `i + 1`, que corresponde a la dimensión espacial `yo`. Se requiere que `block_shape[i]` divida `input_shape[i + 1] + pad_start + pad_end`.

Esta operación equivale a los siguientes pasos:

1. Rellene con ceros el inicio y el final de las dimensiones `[1, ..., M]` de la entrada de acuerdo con `paddings` para producir `padded` con la forma `padded_shape`.

2. Cambie la forma de "relleno" a "reformado_relleno":

[lote] + [forma_rellenada[1] / forma_bloque[0], forma_bloque[0], ..., forma_rellenada[M] / forma_bloque[M-1], forma_bloque[M-1]] + forma_restante

3. Permute las dimensiones de `reshape_padded` para producir `permuted_reshape_padded` de forma:

forma_bloque + [lote] + [forma_rellenada[1] / forma_bloque[0], ..., forma_rellenada[M] / forma_bloque[M-1]] + forma_restante

4. Cambie la forma de `permuted_reshape_padded` para aplanar `block_shape` en la dimensión del lote, produciendo un tensor de forma de salida:

[lote * prod(forma_bloque)] + [forma_relleno[1] / forma_bloque[0], ..., forma_relleno[M] / forma_bloque[M-1]] + forma_restante

Algunos ejemplos:

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

x = [[[[1], [2]], [[3], [4]]]]
El tensor de salida tiene la forma `[4, 1, 1, 1]` y valor: 
[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
(2) Para la siguiente entrada de forma `[1, 2, 2, 3]`, `block_shape = [ 2, 2]` y `paddings = [[0, 0], [0, 0]]`: 
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
El tensor de salida tiene forma `[4, 1, 1, 3]` y valor: 
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
(3) Para la siguiente entrada de forma `[1, 4, 4, 1]`, `block_shape = [2, 2]` y `paddings = [[0, 0], [0, 0]]`: 
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]],
       [[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
El tensor de salida tiene la forma `[4, 2, 2, 1]` y valor: 
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
(4) Para la siguiente entrada de forma `[2, 2, 4, 1]`, block_shape = `[ 2, 2]` y paddings = `[[0, 0], [2, 0]]`: 
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
El tensor de salida tiene forma `[8, 1, 3, 1]` y valor: 
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]]]]
Entre otras, esta operación es útil para reducir la convolución atroz a una convolución regular.

Devoluciones
  • una nueva instancia de SpaceToBatchNd

Salida pública <T> salida ()