Package org.tensorflow.op.nn

Class SpaceToDepth<T>

java.lang.Object

org.tensorflow.op.PrimitiveOp

org.tensorflow.op.nn.SpaceToDepth<T>

Type Parameters:

T - data type for output() output

All Implemented Interfaces:

Op, Operand<T>

@Operator(group="nn")
public final class SpaceToDepth<T>
extends PrimitiveOp
implements Operand<T>

SpaceToDepth for tensors of type T.

Rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of the input tensor where values from the `height` and `width` dimensions are moved to the `depth` dimension. The attr `block_size` indicates the input block size.

* Non-overlapping blocks of size `block_size x block size` are rearranged into depth at each location. * The depth of the output tensor is `block_size * block_size * input_depth`. * The Y, X coordinates within each block of the input become the high order component of the output channel index. * The input tensor's height and width must be divisible by 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, 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,oY,bY,oX,bX,iC (where n=batch index, oX, oY means X or Y coordinates within the output image, bX, bY means coordinates within the input block, iC means input channels). The output would be a transpose to the following layout: n,oY,oX,bY,bX,iC

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, 2, 2, 1]`, data_format = "NHWC" and block_size = 2:

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

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

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

Here, the input has a batch of 1 and each batch element has shape `[2, 2, 1]`, the corresponding output will have a single element (i.e. width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is `[1, 1, 4]`.

For an input tensor with larger depth, here of shape `[1, 2, 2, 3]`, 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, 1, 1, 12]`

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

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

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

the operator will return the following tensor of shape `[1 2 2 4]`:

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

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	SpaceToDepth.Options	Optional attributes for SpaceToDepth

Field Summary

Fields inherited from class org.tensorflow.op.PrimitiveOp

operation

Method Summary

Modifier and Type	Method	Description
Output<T>	asOutput()	Returns the symbolic handle of a tensor.
static <T> SpaceToDepth<T>	create(Scope scope, Operand<T> input, java.lang.Long blockSize, SpaceToDepth.Options... options)	Factory method to create a class to wrap a new SpaceToDepth operation to the graph.
static SpaceToDepth.Options	dataFormat(java.lang.String dataFormat)
Output<T>	output()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from class org.tensorflow.op.PrimitiveOp

equals, hashCode, toString

Method Detail

create

public static <T> SpaceToDepth<T> create(Scope scope,
                                         Operand<T> input,
                                         java.lang.Long blockSize,
                                         SpaceToDepth.Options... options)

Factory method to create a class to wrap a new SpaceToDepth operation to the graph.

Parameters:

scope - current graph scope

input -

blockSize - The size of the spatial block.

options - carries optional attributes values

Returns:

a new instance of SpaceToDepth

dataFormat

public static SpaceToDepth.Options dataFormat(java.lang.String dataFormat)

Parameters:

dataFormat -

output

public Output<T> output()

asOutput

public Output<T> asOutput()

Description copied from interface: Operand

Returns the symbolic handle of a tensor.

Inputs to TensorFlow operations are outputs of another TensorFlow operation. This method is used to obtain a symbolic handle that represents the computation of the input.

Specified by:

asOutput in interface Operand<T>

See Also:

OperationBuilder.addInput(Output)