Se usó la API de Cloud Translation para traducir esta página.
Switch to English

tensorflow :: operaciones :: DepthToSpace

#include <array_ops.h>

DepthToSpace para tensores de tipo T.

Resumen

Reorganiza los datos de profundidad en bloques de datos espaciales. Esta es la transformación inversa de SpaceToDepth. Más específicamente, esta operación genera una copia del tensor de entrada donde los valores de la dimensión de depth se mueven en bloques espaciales a las dimensiones de height y width . El atributo block_size indica el tamaño del bloque de entrada y cómo se mueven los datos.

  • Los fragmentos de datos de tamaño block_size * block_size de la profundidad se reordenan en bloques no superpuestos de tamaño block_size x block_size
  • El ancho del tensor de salida es input_depth * block_size , mientras que la altura es input_height * block_size .
  • Las coordenadas Y, X dentro de cada bloque de la imagen de salida están determinadas por el componente de orden superior del índice del canal de entrada.
  • La profundidad del tensor de entrada debe ser divisible por block_size * block_size .

El atributo data_format especifica el diseño de los tensores de entrada y salida con las siguientes opciones: "NHWC": [ batch, height, width, channels ] "NCHW": [ batch, channels, height, width ] "NCHW_VECT_C": qint8 [ batch, channels / 4, height, width, 4 ]

Es útil considerar la operación como una transformación de un tensor 6-D. Por ejemplo, para data_format = NHWC, cada elemento en el tensor de entrada se puede especificar a través de 6 coordenadas, ordenadas disminuyendo la importancia del diseño de la memoria como: n, iY, iX, bY, bX, oC (donde n = índice de lote, iX, iY significa X o coordenadas Y dentro de la imagen de entrada, bX, bY significa coordenadas dentro del bloque de salida, oC significa canales de salida). La salida sería la entrada transpuesta al siguiente diseño: n, iY, bY, iX, bX, oC

Esta operación es útil para cambiar el tamaño de las activaciones entre convoluciones (pero manteniendo todos los datos), por ejemplo, en lugar de agrupar. También es útil para entrenar modelos puramente convolucionales.

Por ejemplo, dada una entrada de forma [1, 1, 1, 4] , data_format = "NHWC" y block_size = 2:

x = [[[[1, 2, 3, 4]]]]

  

This operation will output a tensor of shape [1, 2, 2, 1]:

   [[[[1], [2]],
     [[3], [4]]]]

Aquí, la entrada tiene un lote de 1 y cada elemento del lote tiene forma [1, 1, 4] , la salida correspondiente tendrá 2x2 elementos y tendrá una profundidad de 1 canal (1 = 4 / (block_size * block_size) ). La forma del elemento de salida es [2, 2, 1] .

Para un tensor de entrada con mayor profundidad, aquí de forma [1, 1, 1, 12] , p. Ej.

x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]

Esta operación, para un tamaño de bloque de 2, devolverá el siguiente tensor de forma [1, 2, 2, 3]

   [[[[1, 2, 3], [4, 5, 6]],
     [[7, 8, 9], [10, 11, 12]]]]

  

Similarly, for the following input of shape [1 2 2 4], and a block size of 2:

x =  [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]

el operador devolverá el siguiente tensor de forma [1 4 4 1] :

x = [[[ [1],   [2],  [5],  [6]],
      [ [3],   [4],  [7],  [8]],
      [ [9],  [10], [13],  [14]],
      [ [11], [12], [15],  [16]]]]

  

Arguments:

  • scope: A Scope object
  • block_size: The size of the spatial block, same as in Space2Depth.

Returns:

Constructors and Destructors

DepthToSpace(const ::tensorflow::Scope & scope, ::tensorflow::Input input, int64 block_size)
DepthToSpace(const ::tensorflow::Scope & scope, ::tensorflow::Input input, int64 block_size, const DepthToSpace::Attrs & attrs)

Public attributes

operation
output

Public functions

node() const
::tensorflow::Node *
operator::tensorflow::Input() const
operator::tensorflow::Output() const

Public static functions

DataFormat(StringPiece x)

Structs

tensorflow::ops::DepthToSpace::Attrs

Optional attribute setters for DepthToSpace.

Public attributes

operation

Operation operation

salida

::tensorflow::Output output

Funciones publicas

DepthToSpace

 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size
)

DepthToSpace

 DepthToSpace(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  int64 block_size,
  const DepthToSpace::Attrs & attrs
)

nodo

::tensorflow::Node * node() const 

operador :: tensorflow :: Entrada

 operator::tensorflow::Input() const 

operador :: tensorflow :: Salida

 operator::tensorflow::Output() const 

Funciones estáticas públicas

Formato de datos

Attrs DataFormat(
  StringPiece x
)