#include <array_ops.h>
DepthToSpace for tensors of type T.
Rearranges data from depth into blocks of spatial data. This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of the input tensor where values from the depth
dimension are moved in spatial blocks to the height
and width
dimensions. The attr block_size
indicates the input block size and how the data is moved.
block_size * block_size
from depth are rearranged into non-overlapping blocks of size block_size x block_size
input_depth * block_size
, whereas the height is input_height * block_size
.block_size * block_size
.The data_format
attr specifies the layout of the input and output tensors with the following options: "NHWC": [ batch, height, width, channels ]
"NCHW": [ batch, channels, height, width ]
"NCHW_VECT_C": qint8 [ batch, channels / 4, height, width, channels % 4 ]
It is useful to consider the operation as transforming a 6-D Tensor. e.g. for data_format = NHWC, Each element in the input tensor can be specified via 6 coordinates, ordered by decreasing memory layout significance as: n,iY,iX,bY,bX,oC (where n=batch index, iX, iY means X or Y coordinates within the input image, bX, bY means coordinates within the output block, oC means output channels). The output would be the input transposed to the following layout: n,iY,bY,iX,bX,oC
This operation is useful for resizing the activations between convolutions (but keeping all data), e.g. instead of pooling. It is also useful for training purely convolutional models.
For example, given an input of shape [1, 1, 1, 4]
, data_format = "NHWC" and block_size = 2:
``` x = [[[[1, 2, 3, 4]]]]
```
This operation will output a tensor of shape [1, 2, 2, 1]
:
``` [[[[1], [2]], [[3], [4]]]] ```
Here, the input has a batch of 1 and each batch element has shape [1, 1, 4]
, the corresponding output will have 2x2 elements and will have a depth of 1 channel (1 = 4 / (block_size * block_size)
). The output element shape is [2, 2, 1]
.
For an input tensor with larger depth, here of shape [1, 1, 1, 12]
, e.g.
``` x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]] ```
This operation, for block size of 2, will return the following tensor of shape [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]]]] ```
the operator will return the following tensor of shape [1 4 4 1]
:
``` x = [[[ [1], [2], [5], [6]], [ [3], [4], [7], [8]], [ [9], [10], [13], [14]], [ [11], [12], [15], [16]]]]
```
Arguments:
Returns:
Output
: The output tensor. 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 | |
---|---|
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. |
::tensorflow::Output output
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 )
::tensorflow::Node * node() const
operator::tensorflow::Input() const
operator::tensorflow::Output() const
Attrs DataFormat( StringPiece x )
© 2017 The TensorFlow Authors. All rights reserved.
Licensed under the Creative Commons Attribution License 3.0.
Code samples licensed under the Apache 2.0 License.
https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/depth-to-space.html