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
0 | 0 | DepthToSpace rearranges (permutes) data from depth into blocks of spatial data. | DepthToSpace rearranges (permutes) data from depth into blocks of spatial data. |
1 | 1 | This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of | This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of |
2 | 2 | the input tensor where values from the depth dimension are moved in spatial blocks to the height | the input tensor where values from the depth dimension are moved in spatial blocks to the height |
3 | 3 | and width dimensions. By default, mode = DCR. | and width dimensions. By default, mode = DCR. |
4 | 4 | In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the | In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the |
5 | 5 | following 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: |
6 | 6 | | |
7 | 7 | b, c, h, w = x.shape | b, c, h, w = x.shape |
8 | 8 | | |
9 | 9 | tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w]) | tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w]) |
10 | 10 | | |
11 | 11 | tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2]) | tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2]) |
12 | 12 | | |
13 | 13 | y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize]) | y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize]) |
14 | 14 | | |
15 | 15 | In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the | In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the |
16 | 16 | following 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: |
17 | 17 | | |
18 | 18 | b, c, h, w = x.shape | b, c, h, w = x.shape |
19 | 19 | | |
20 | 20 | tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w]) | tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w]) |
21 | 21 | | |
22 | 22 | tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3]) | tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3]) |
23 | 23 | | |
24 | 24 | y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize]) | y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize]) |
25 | 25 | | |
26 | 26 | **Attributes** | **Attributes** |
27 | 27 | | |
28 | 28 | * **blocksize** (required): | * **blocksize** (required): |
29 | 29 | Blocks of [blocksize, blocksize] are moved. | Blocks of [blocksize, blocksize] are moved. |
30 | 30 | * **mode**: | * **mode**: |
31 | 31 | DCR (default) for depth-column-row order re-arrangement. Use CRD for | DCR (default) for depth-column-row order re-arrangement. Use CRD for |
32 | 32 | column-row-depth order. Default value is 'DCR'. | column-row-depth order. Default value is 'DCR'. |
33 | 33 | | |
34 | 34 | **Inputs** | **Inputs** |
35 | 35 | | |
36 | 36 | * **input** (heterogeneous) - **T**: | * **input** (heterogeneous) - **T**: |
37 | 37 | 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 |
38 | 38 | channel or depth, H is the height and W is the width. | channel or depth, H is the height and W is the width. |
39 | 39 | | |
40 | 40 | **Outputs** | **Outputs** |
41 | 41 | | |
42 | 42 | * **output** (heterogeneous) - **T**: | * **output** (heterogeneous) - **T**: |
43 | 43 | Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * | Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * |
44 | 44 | blocksize]. | blocksize]. |
45 | 45 | | |
46 | 46 | **Type Constraints** | **Type Constraints** |
47 | 47 | | |
48 | 48 | * **T** in ( | * **T** in ( |
49 | tensor(bfloat16), | ||
49 | 50 | tensor(bool), | tensor(bool), |
50 | 51 | tensor(complex128), | tensor(complex128), |
51 | 52 | tensor(complex64), | tensor(complex64), |
52 | 53 | tensor(double), | tensor(double), |
53 | 54 | tensor(float), | tensor(float), |
54 | 55 | tensor(float16), | tensor(float16), |
55 | 56 | tensor(int16), | tensor(int16), |
56 | 57 | tensor(int32), | tensor(int32), |
57 | 58 | tensor(int64), | tensor(int64), |
58 | 59 | tensor(int8), | tensor(int8), |
59 | 60 | tensor(string), | tensor(string), |
60 | 61 | tensor(uint16), | tensor(uint16), |
61 | 62 | tensor(uint32), | tensor(uint32), |
62 | 63 | tensor(uint64), | tensor(uint64), |
63 | 64 | tensor(uint8) | tensor(uint8) |
64 | 65 | ): | ): |
65 | 66 | 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
0 | 0 | DepthToSpace rearranges (permutes) data from depth into blocks of spatial data. | DepthToSpace rearranges (permutes) data from depth into blocks of spatial data. |
1 | 1 | This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of | This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of |
2 | 2 | the input tensor where values from the depth dimension are moved in spatial blocks to the height | the input tensor where values from the depth dimension are moved in spatial blocks to the height |
3 | 3 | and width dimensions. | |
4 | In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the | ||
5 | following order: depth, column, and then row. The output y is computed from the input x as below: | ||
4 | 6 | | |
7 | b, c, h, w = x.shape | ||
8 | | ||
9 | tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w]) | ||
10 | | ||
11 | tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2]) | ||
12 | | ||
13 | y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize]) | ||
14 | | ||
15 | In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the | ||
16 | following order: column, row, and the depth. The output y is computed from the input x as below: | ||
17 | | ||
18 | b, c, h, w = x.shape | ||
19 | | ||
20 | tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w]) | ||
21 | | ||
22 | tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3]) | ||
23 | | ||
24 | y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize]) | ||
25 | | ||
5 | 26 | **Attributes** | **Attributes** |
6 | 27 | | |
7 | 28 | * **blocksize** (required): | * **blocksize** (required): |
8 | 29 | 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'. | ||
9 | 33 | | |
10 | 34 | **Inputs** | **Inputs** |
11 | 35 | | |
12 | 36 | * **input** (heterogeneous) - **T**: | * **input** (heterogeneous) - **T**: |
13 | 37 | 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 |
14 | 38 | channel or depth, H is the height and W is the width. | channel or depth, H is the height and W is the width. |
15 | 39 | | |
16 | 40 | **Outputs** | **Outputs** |
17 | 41 | | |
18 | 42 | * **output** (heterogeneous) - **T**: | * **output** (heterogeneous) - **T**: |
19 | 43 | Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * | Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * |
20 | 44 | blocksize]. | blocksize]. |
21 | 45 | | |
22 | 46 | **Type Constraints** | **Type Constraints** |
23 | 47 | | |
24 | 48 | * **T** in ( | * **T** in ( |
25 | 49 | tensor(bool), | tensor(bool), |
26 | 50 | tensor(complex128), | tensor(complex128), |
27 | 51 | tensor(complex64), | tensor(complex64), |
28 | 52 | tensor(double), | tensor(double), |
29 | 53 | tensor(float), | tensor(float), |
30 | 54 | tensor(float16), | tensor(float16), |
31 | 55 | tensor(int16), | tensor(int16), |
32 | 56 | tensor(int32), | tensor(int32), |
33 | 57 | tensor(int64), | tensor(int64), |
34 | 58 | tensor(int8), | tensor(int8), |
35 | 59 | tensor(string), | tensor(string), |
36 | 60 | tensor(uint16), | tensor(uint16), |
37 | 61 | tensor(uint32), | tensor(uint32), |
38 | 62 | tensor(uint64), | tensor(uint64), |
39 | 63 | tensor(uint8) | tensor(uint8) |
40 | 64 | ): | ): |
41 | 65 | 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.