DepthToSpace#

DepthToSpace - 13#

Version

  • name: DepthToSpace (GitHub)

  • domain: main

  • since_version: 13

  • function: False

  • support_level: SupportType.COMMON

  • shape inference: True

This version of the operator has been available since version 13.

Summary

DepthToSpace rearranges (permutes) 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. By default, mode = DCR. In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the following order: depth, column, and then row. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])

tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])

y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])

In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the following order: column, row, and the depth. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])

tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])

y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])

Attributes

  • blocksize (required): Blocks of [blocksize, blocksize] are moved.

  • mode: DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order. Default value is 'DCR'.

Inputs

  • input (heterogeneous) - T: Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.

Outputs

  • output (heterogeneous) - T: Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].

Type Constraints

  • T in ( tensor(bfloat16), tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input and output types to all tensor types.

Examples

_default_mode_example

node = onnx.helper.make_node(
    'DepthToSpace',
    inputs=['x'],
    outputs=['y'],
    blocksize=2,
    mode='DCR'
)

# (1, 8, 2, 3) input tensor
x = np.array([[[[0., 1., 2.],
                [3., 4., 5.]],
               [[9., 10., 11.],
                [12., 13., 14.]],
               [[18., 19., 20.],
                [21., 22., 23.]],
               [[27., 28., 29.],
                [30., 31., 32.]],
               [[36., 37., 38.],
                [39., 40., 41.]],
               [[45., 46., 47.],
                [48., 49., 50.]],
               [[54., 55., 56.],
                [57., 58., 59.]],
               [[63., 64., 65.],
                [66., 67., 68.]]]]).astype(np.float32)

# (1, 2, 4, 6) output tensor
y = np.array([[[[0., 18., 1., 19., 2., 20.],
                [36., 54., 37., 55., 38., 56.],
                [3., 21., 4., 22., 5., 23.],
                [39., 57., 40., 58., 41., 59.]],
               [[9., 27., 10., 28., 11., 29.],
                [45., 63., 46., 64., 47., 65.],
                [12., 30., 13., 31., 14., 32.],
                [48., 66., 49., 67., 50., 68.]]]]).astype(np.float32)
expect(node, inputs=[x], outputs=[y],
       name='test_depthtospace_example')

_crd_mode_example

node = onnx.helper.make_node(
    'DepthToSpace',
    inputs=['x'],
    outputs=['y'],
    blocksize=2,
    mode='CRD'
)

# (1, 8, 2, 3) input tensor
x = np.array([[[[0., 1., 2.],
                [3., 4., 5.]],
               [[9., 10., 11.],
                [12., 13., 14.]],
               [[18., 19., 20.],
                [21., 22., 23.]],
               [[27., 28., 29.],
                [30., 31., 32.]],
               [[36., 37., 38.],
                [39., 40., 41.]],
               [[45., 46., 47.],
                [48., 49., 50.]],
               [[54., 55., 56.],
                [57., 58., 59.]],
               [[63., 64., 65.],
                [66., 67., 68.]]]]).astype(np.float32)

# (1, 2, 4, 6) output tensor
y = np.array([[[[0., 9., 1., 10., 2., 11.],
                [18., 27., 19., 28., 20., 29.],
                [3., 12., 4., 13., 5., 14.],
                [21., 30., 22., 31., 23., 32.]],
               [[36., 45., 37., 46., 38., 47.],
                [54., 63., 55., 64., 56., 65.],
                [39., 48., 40., 49., 41., 50.],
                [57., 66., 58., 67., 59., 68.]]]]).astype(np.float32)
expect(node, inputs=[x], outputs=[y],
       name='test_depthtospace_crd_mode_example')

Differences

00DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
11This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy ofThis is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
22the input tensor where values from the depth dimension are moved in spatial blocks to the heightthe input tensor where values from the depth dimension are moved in spatial blocks to the height
33and width dimensions. By default, mode = DCR.and width dimensions. By default, mode = DCR.
44In the DCR mode, elements along the depth dimension from the input tensor are rearranged in theIn the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
55following order: depth, column, and then row. The output y is computed from the input x as below:following order: depth, column, and then row. The output y is computed from the input x as below:
66
77b, c, h, w = x.shapeb, c, h, w = x.shape
88
99tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
1010
1111tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
1212
1313y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
1414
1515In the CRD mode, elements along the depth dimension from the input tensor are rearranged in theIn the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
1616following order: column, row, and the depth. The output y is computed from the input x as below:following order: column, row, and the depth. The output y is computed from the input x as below:
1717
1818b, c, h, w = x.shapeb, c, h, w = x.shape
1919
2020tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
2121
2222tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
2323
2424y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
2525
2626**Attributes****Attributes**
2727
2828* **blocksize** (required):* **blocksize** (required):
2929 Blocks of [blocksize, blocksize] are moved. Blocks of [blocksize, blocksize] are moved.
3030* **mode**:* **mode**:
3131 DCR (default) for depth-column-row order re-arrangement. Use CRD for DCR (default) for depth-column-row order re-arrangement. Use CRD for
3232 column-row-depth order. Default value is 'DCR'. column-row-depth order. Default value is 'DCR'.
3333
3434**Inputs****Inputs**
3535
3636* **input** (heterogeneous) - **T**:* **input** (heterogeneous) - **T**:
3737 Input tensor of [N,C,H,W], where N is the batch axis, C is the Input tensor of [N,C,H,W], where N is the batch axis, C is the
3838 channel or depth, H is the height and W is the width. channel or depth, H is the height and W is the width.
3939
4040**Outputs****Outputs**
4141
4242* **output** (heterogeneous) - **T**:* **output** (heterogeneous) - **T**:
4343 Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W *
4444 blocksize]. blocksize].
4545
4646**Type Constraints****Type Constraints**
4747
4848* **T** in (* **T** in (
49 tensor(bfloat16),
4950 tensor(bool), tensor(bool),
5051 tensor(complex128), tensor(complex128),
5152 tensor(complex64), tensor(complex64),
5253 tensor(double), tensor(double),
5354 tensor(float), tensor(float),
5455 tensor(float16), tensor(float16),
5556 tensor(int16), tensor(int16),
5657 tensor(int32), tensor(int32),
5758 tensor(int64), tensor(int64),
5859 tensor(int8), tensor(int8),
5960 tensor(string), tensor(string),
6061 tensor(uint16), tensor(uint16),
6162 tensor(uint32), tensor(uint32),
6263 tensor(uint64), tensor(uint64),
6364 tensor(uint8) tensor(uint8)
6465 ): ):
6566 Constrain input and output types to all tensor types. Constrain input and output types to all tensor types.

DepthToSpace - 11#

Version

  • name: DepthToSpace (GitHub)

  • domain: main

  • since_version: 11

  • function: False

  • support_level: SupportType.COMMON

  • shape inference: True

This version of the operator has been available since version 11.

Summary

DepthToSpace rearranges (permutes) 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. By default, mode = DCR. In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the following order: depth, column, and then row. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])

tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])

y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])

In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the following order: column, row, and the depth. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])

tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])

y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])

Attributes

  • blocksize (required): Blocks of [blocksize, blocksize] are moved.

  • mode: DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order. Default value is 'DCR'.

Inputs

  • input (heterogeneous) - T: Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.

Outputs

  • output (heterogeneous) - T: Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].

Type Constraints

  • T in ( tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input and output types to all tensor types.

Differences

00DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
11This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy ofThis is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
22the input tensor where values from the depth dimension are moved in spatial blocks to the heightthe input tensor where values from the depth dimension are moved in spatial blocks to the height
33and width dimensions.and width dimensions. By default, mode = DCR.
4In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
5following order: depth, column, and then row. The output y is computed from the input x as below:
46
7b, c, h, w = x.shape
8
9tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
10
11tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
12
13y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
14
15In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
16following order: column, row, and the depth. The output y is computed from the input x as below:
17
18b, c, h, w = x.shape
19
20tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
21
22tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
23
24y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
25
526**Attributes****Attributes**
627
728* **blocksize** (required):* **blocksize** (required):
829 Blocks of [blocksize, blocksize] are moved. Blocks of [blocksize, blocksize] are moved.
30* **mode**:
31 DCR (default) for depth-column-row order re-arrangement. Use CRD for
32 column-row-depth order. Default value is 'DCR'.
933
1034**Inputs****Inputs**
1135
1236* **input** (heterogeneous) - **T**:* **input** (heterogeneous) - **T**:
1337 Input tensor of [N,C,H,W], where N is the batch axis, C is the Input tensor of [N,C,H,W], where N is the batch axis, C is the
1438 channel or depth, H is the height and W is the width. channel or depth, H is the height and W is the width.
1539
1640**Outputs****Outputs**
1741
1842* **output** (heterogeneous) - **T**:* **output** (heterogeneous) - **T**:
1943 Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W *
2044 blocksize]. blocksize].
2145
2246**Type Constraints****Type Constraints**
2347
2448* **T** in (* **T** in (
2549 tensor(bool), tensor(bool),
2650 tensor(complex128), tensor(complex128),
2751 tensor(complex64), tensor(complex64),
2852 tensor(double), tensor(double),
2953 tensor(float), tensor(float),
3054 tensor(float16), tensor(float16),
3155 tensor(int16), tensor(int16),
3256 tensor(int32), tensor(int32),
3357 tensor(int64), tensor(int64),
3458 tensor(int8), tensor(int8),
3559 tensor(string), tensor(string),
3660 tensor(uint16), tensor(uint16),
3761 tensor(uint32), tensor(uint32),
3862 tensor(uint64), tensor(uint64),
3963 tensor(uint8) tensor(uint8)
4064 ): ):
4165 Constrain input and output types to all tensor types. Constrain input and output types to all tensor types.

DepthToSpace - 1#

Version

  • name: DepthToSpace (GitHub)

  • domain: main

  • since_version: 1

  • function: False

  • support_level: SupportType.COMMON

  • shape inference: True

This version of the operator has been available since version 1.

Summary

DepthToSpace rearranges (permutes) 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.

Attributes

  • blocksize (required): Blocks of [blocksize, blocksize] are moved.

Inputs

  • input (heterogeneous) - T: Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.

Outputs

  • output (heterogeneous) - T: Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].

Type Constraints

  • T in ( tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input and output types to all tensor types.