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 tanto la posición dentro de un bloque espacial como la posición original del lote. Antes de la división en bloques, las dimensiones espaciales de la entrada se rellenan opcionalmente con ceros de acuerdo con los "rellenos". Consulte a continuación para obtener una descripción precisa.

Métodos públicos

Salida <T>
asOutput ()
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, operando <T> de entrada, operando <U> blockShape, operando <V> paddings)
Método de fábrica para crear una clase que envuelva una nueva operación SpaceToBatchNd.
Salida <T>
salida ()

Métodos heredados

Métodos públicos

Salida pública <T> asOutput ()

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.

public static SpaceToBatchNd <T> crear ( Alcance alcance, operando <T> de entrada, operando <U> blockShape, operando <V> paddings)

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

Parámetros
alcance alcance actual
aporte ND con forma `input_shape = [batch] + space_shape + left_shape`, donde espacial_shape tiene dimensiones` M`.
blockShape 1-D con forma `[M]`, todos los valores deben ser> = 1.
acolchados 2D con forma `[M, 2]`, todos los valores deben ser> = 0. `paddings [i] = [pad_start, pad_end]` especifica el padding 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 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 "paddings" para producir "padded" de forma "padded_shape".

2. Cambie la forma de "padded" a "rehaped_padded":

[batch] + [padded_shape [1] / block_shape [0], block_shape [0], ..., padded_shape [M] / block_shape [M-1], block_shape [M-1]] + remanente

3. Permutar las dimensiones de `rehaped_padded` para producir` permuted_reshaped_padded` de forma:

block_shape + [lote] + [padded_shape [1] / block_shape [0], ..., padded_shape [M] / block_shape [M-1]] + forma_restante

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

[batch * prod (block_shape)] + [padded_shape [1] / block_shape [0], ..., padded_shape [M] / block_shape [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` 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 shape `[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 rellenos =` [[ 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 en convolución regular.
Devoluciones
  • una nueva instancia de SpaceToBatchNd

salida pública <T> salida ()