Advertencia: esta API está obsoleta y se eliminará en una versión futura de TensorFlow una vez que el reemplazo sea ​​estable.

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`, e intercala estos bloques con la dimensión "lote" (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 la posición dentro de un bloque espacial y la posición del lote original. Antes de la división en bloques, las dimensiones espaciales de la entrada se rellenan opcionalmente con ceros de acuerdo con `rellenos`. Véase más abajo para una descripción precisa.

Esta operación es equivalente a los siguientes pasos:

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

2. Remodele `padded` a `reshaped_padded` de forma:

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

3. Permute las dimensiones de `reshaped_padded` para producir `permuted_reshaped_padded` de forma:

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

4. Remodele `permuted_reshaped_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 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 `rellenos = [[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 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 atrosa 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 Número, V extiende Número> SpaceToBatchNd <T>
crear ( alcance de alcance, entrada de operando <T>, forma de bloque de operando <U>, relleno de operando <V>)
Método de fábrica para crear una clase que envuelve una nueva operación SpaceToBatchNd.
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.

SpaceToBatchNd <T> estático público crear ( ámbito de ámbito, entrada de operando <T>, forma de bloque de operando <U>, relleno de 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 `forma_entrada = [lote] + forma_espacial + forma_restante`, donde forma_espacial tiene dimensiones `M`.
forma de bloque 1-D con forma `[M]`, todos los valores deben ser >= 1.
rellenos 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 ()