SpaceToBatchNd

SpaceToBatchNd public final class

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.

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]] + restante_forma

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

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

4. Cambie la forma de `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 de `[4, 1, 1, 1]` y el valor: 
[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
(2) Para la siguiente entrada de la 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 de` [4, 1, 1, 3] `y el 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 de `[4, 2, 2, 1]` y el valor: 
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
(4) Para la siguiente entrada de la forma `[2, 2, 4, 1]`, block_shape = `[ 2, 2] `, y juntas =` [[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 de` [8, 1, 3, 1] `y el 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 una convolución atroz a una convolución regular.

Métodos públicos

Salida <T>
asOutput ()
Devuelve el identificador simbólico de un tensor.
estática <T, U se extiende Número, V se extiende 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

pública de salida <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 2-D 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`.
Devoluciones
  • una nueva instancia de SpaceToBatchNd

pública de salida <T> salida ()