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 manera 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.

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.

Métodos públicos

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

Métodos heredados

Métodos públicos

Salida pública <T> como Salida ()

Devuelve el identificador simbólico de un 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>, forma de bloque del operando <U>, rellenos del operando <V>)

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`.
Devoluciones
  • una nueva instancia de SpaceToBatchNd

Salida pública <T> salida ()