ReduceL1#
ReduceL1  18#
Version
name: ReduceL1 (GitHub)
domain: main
since_version: 18
function: True
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 18.
Summary
Computes the L1 norm of the input tensor’s element along the provided axes. The resulting tensor has the same rank as the input if keepdims equals 1. If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
The above behavior is similar to numpy, with the exception that numpy defaults keepdims to False instead of True.
Attributes
keepdims: Keep the reduced dimension or not, default 1 means keep reduced dimension. Default value is
1
.noop_with_empty_axes: Defines behavior if ‘axes’ is empty. Default behavior with ‘false’ is to reduce all axes. When axes is empty and this attribute is set to true, input tensor will not be reduced,and the output tensor would be equivalent to input tensor. Default value is
0
.
Inputs
Between 1 and 2 inputs.
data (heterogeneous)  T: An input tensor.
axes (optional, heterogeneous)  tensor(int64): Optional input list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor if ‘noop_with_empty_axes’ is false, else act as an Identity op when ‘noop_with_empty_axes’ is true. Accepted range is [r, r1] where r = rank(data).
Outputs
reduced (heterogeneous)  T: Reduced output tensor.
Type Constraints
T in ( tensor(bfloat16), tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ): Constrain input and output types to highprecision numeric tensors.
Examples
_do_not_keepdims
shape = [3, 2, 2]
axes = np.array([2], dtype=np.int64)
keepdims = 0
node = onnx.helper.make_node(
"ReduceL1",
inputs=["data", "axes"],
outputs=["reduced"],
keepdims=keepdims,
)
data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
# print(data)
# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
# print(reduced)
# [[3., 7.], [11., 15.], [19., 23.]]
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_do_not_keepdims_example",
)
np.random.seed(0)
data = np.random.uniform(10, 10, shape).astype(np.float32)
reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_do_not_keepdims_random",
)
_keepdims
shape = [3, 2, 2]
axes = np.array([2], dtype=np.int64)
keepdims = 1
node = onnx.helper.make_node(
"ReduceL1",
inputs=["data", "axes"],
outputs=["reduced"],
keepdims=keepdims,
)
data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
# print(data)
# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
# print(reduced)
# [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_keep_dims_example",
)
np.random.seed(0)
data = np.random.uniform(10, 10, shape).astype(np.float32)
reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_keep_dims_random",
)
_default_axes_keepdims
shape = [3, 2, 2]
axes = np.array([], dtype=np.int64)
keepdims = 1
node = onnx.helper.make_node(
"ReduceL1", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
)
data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
# print(data)
# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
# print(reduced)
# [[[78.]]]
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_default_axes_keepdims_example",
)
np.random.seed(0)
data = np.random.uniform(10, 10, shape).astype(np.float32)
reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_default_axes_keepdims_random",
)
_negative_axes_keepdims
shape = [3, 2, 2]
axes = np.array([1], dtype=np.int64)
keepdims = 1
node = onnx.helper.make_node(
"ReduceL1",
inputs=["data", "axes"],
outputs=["reduced"],
keepdims=keepdims,
)
data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
# print(data)
# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
# print(reduced)
# [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_negative_axes_keep_dims_example",
)
np.random.seed(0)
data = np.random.uniform(10, 10, shape).astype(np.float32)
reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
expect(
node,
inputs=[data, axes],
outputs=[reduced],
name="test_reduce_l1_negative_axes_keep_dims_random",
)
Differences
0  0  Computes the L1 norm of the input tensor's element along the provided axes. The resulting  Computes the L1 norm of the input tensor's element along the provided axes. The resulting 
1  1  tensor has the same rank as the input if keepdims equals 1. If keepdims equals 0, then  tensor has the same rank as the input if keepdims equals 1. If keepdims equals 0, then 
2  2  the resulting tensor has the reduced dimension pruned.  the resulting tensor has the reduced dimension pruned. 
3  3 


4  4  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to 
5  5  False instead of True.  False instead of True. 
6  6 


7  7  **Attributes**  **Attributes** 
8  8 


9  * **keepdims**:  
9  10  * **axes**: 

10  11  A list of integers, along which to reduce. The default is to reduce 

11  12  over all the dimensions of the input tensor. Accepted range is [r, 

12  13  r1] where r = rank(data). 

13  14  * **keepdims**: 

14  Keep the reduced dimension or not, default 1 means keep reduced  
15  15  dimension. Default value is 1. 

16  would be equivalent to input tensor. Default value is 0.  
16  17 


17  18  **Inputs**  **Inputs** 
18  19 


20  Between 1 and 2 inputs.  
21 
 
19  22  * **data** (heterogeneous)  **T**:  * **data** (heterogeneous)  **T**: 
23  An input tensor.  
20  24  An input tensor. 

25  Optional input list of integers, along which to reduce. The default  
26  is to reduce over all the dimensions of the input tensor if  
27  'noop_with_empty_axes' is false, else act as an Identity op when  
28  'noop_with_empty_axes' is true. Accepted range is [r, r1] where r  
29  = rank(data).  
21  30 


22  31  **Outputs**  **Outputs** 
23  32 


24  33  * **reduced** (heterogeneous)  **T**:  * **reduced** (heterogeneous)  **T**: 
25  34  Reduced output tensor.  Reduced output tensor. 
26  35 


27  36  **Type Constraints**  **Type Constraints** 
28  37 


29  38  * **T** in (  * **T** in ( 
30  39  tensor(bfloat16),  tensor(bfloat16), 
31  40  tensor(double),  tensor(double), 
32  41  tensor(float),  tensor(float), 
33  42  tensor(float16),  tensor(float16), 
34  43  tensor(int32),  tensor(int32), 
35  44  tensor(int64),  tensor(int64), 
36  45  tensor(uint32),  tensor(uint32), 
37  46  tensor(uint64)  tensor(uint64) 
38  47  ):  ): 
39  48  Constrain input and output types to highprecision numeric tensors.  Constrain input and output types to highprecision numeric tensors. 
ReduceL1  13#
Version
name: ReduceL1 (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
Computes the L1 norm of the input tensor’s element along the provided axes. The resulting tensor has the same rank as the input if keepdims equals 1. If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
The above behavior is similar to numpy, with the exception that numpy defaults keepdims to False instead of True.
Attributes
axes: A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [r, r1] where r = rank(data).
keepdims: Keep the reduced dimension or not, default 1 means keep reduced dimension. Default value is
1
.
Inputs
data (heterogeneous)  T: An input tensor.
Outputs
reduced (heterogeneous)  T: Reduced output tensor.
Type Constraints
T in ( tensor(bfloat16), tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ): Constrain input and output types to highprecision numeric tensors.
Differences
0  0  Computes the L1 norm of the input tensor's element along the provided axes. The resulting  Computes the L1 norm of the input tensor's element along the provided axes. The resulting 
1  1  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then 

2  2  the resulted tensor have the reduced dimension pruned. 

3  3 


4  4  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to 
5  5  False instead of True.  False instead of True. 
6  6 


7  7  **Attributes**  **Attributes** 
8  8 


9  9  * **axes**:  * **axes**: 
10  10  A list of integers, along which to reduce. The default is to reduce  A list of integers, along which to reduce. The default is to reduce 
11  11  over all the dimensions of the input tensor. Accepted range is [r,  over all the dimensions of the input tensor. Accepted range is [r, 
12  12  r1] where r = rank(data).  r1] where r = rank(data). 
13  13  * **keepdims**:  * **keepdims**: 
14  14  Keep the reduced dimension or not, default 1 means keep reduced  Keep the reduced dimension or not, default 1 means keep reduced 
15  15  dimension. Default value is 1.  dimension. Default value is 1. 
16  16 


17  17  **Inputs**  **Inputs** 
18  18 


19  19  * **data** (heterogeneous)  **T**:  * **data** (heterogeneous)  **T**: 
20  20  An input tensor.  An input tensor. 
21  21 


22  22  **Outputs**  **Outputs** 
23  23 


24  24  * **reduced** (heterogeneous)  **T**:  * **reduced** (heterogeneous)  **T**: 
25  25  Reduced output tensor.  Reduced output tensor. 
26  26 


27  27  **Type Constraints**  **Type Constraints** 
28  28 


29  29  * **T** in (  * **T** in ( 
30  tensor(bfloat16),  
30  31  tensor(double),  tensor(double), 
31  32  tensor(float),  tensor(float), 
32  33  tensor(float16),  tensor(float16), 
33  34  tensor(int32),  tensor(int32), 
34  35  tensor(int64),  tensor(int64), 
35  36  tensor(uint32),  tensor(uint32), 
36  37  tensor(uint64)  tensor(uint64) 
37  38  ):  ): 
38  39  Constrain input and output types to highprecision numeric tensors.  Constrain input and output types to highprecision numeric tensors. 
ReduceL1  11#
Version
name: ReduceL1 (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
Computes the L1 norm of the input tensor’s element along the provided axes. The resulting tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then the resulted tensor have the reduced dimension pruned.
The above behavior is similar to numpy, with the exception that numpy defaults keepdims to False instead of True.
Attributes
axes: A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [r, r1] where r = rank(data).
keepdims: Keep the reduced dimension or not, default 1 means keep reduced dimension. Default value is
1
.
Inputs
data (heterogeneous)  T: An input tensor.
Outputs
reduced (heterogeneous)  T: Reduced output tensor.
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ): Constrain input and output types to highprecision numeric tensors.
Differences
0  0  Computes the L1 norm of the input tensor's element along the provided axes. The resulting  Computes the L1 norm of the input tensor's element along the provided axes. The resulting 
1  1  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then 
2  2  the resulted tensor have the reduced dimension pruned.  the resulted tensor have the reduced dimension pruned. 
3  3 


4  4  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to 
5  5  False instead of True.  False instead of True. 
6  6 


7  7  **Attributes**  **Attributes** 
8  8 


9  9  * **axes**:  * **axes**: 
10  10  A list of integers, along which to reduce. The default is to reduce  A list of integers, along which to reduce. The default is to reduce 
11  11  over all the dimensions of the input tensor. 

12  r1] where r = rank(data).  
12  13  * **keepdims**:  * **keepdims**: 
13  14  Keep the reduced dimension or not, default 1 means keep reduced  Keep the reduced dimension or not, default 1 means keep reduced 
14  15  dimension. Default value is 1.  dimension. Default value is 1. 
15  16 


16  17  **Inputs**  **Inputs** 
17  18 


18  19  * **data** (heterogeneous)  **T**:  * **data** (heterogeneous)  **T**: 
19  20  An input tensor.  An input tensor. 
20  21 


21  22  **Outputs**  **Outputs** 
22  23 


23  24  * **reduced** (heterogeneous)  **T**:  * **reduced** (heterogeneous)  **T**: 
24  25  Reduced output tensor.  Reduced output tensor. 
25  26 


26  27  **Type Constraints**  **Type Constraints** 
27  28 


28  29  * **T** in (  * **T** in ( 
29  30  tensor(double),  tensor(double), 
30  31  tensor(float),  tensor(float), 
31  32  tensor(float16),  tensor(float16), 
32  33  tensor(int32),  tensor(int32), 
33  34  tensor(int64),  tensor(int64), 
34  35  tensor(uint32),  tensor(uint32), 
35  36  tensor(uint64)  tensor(uint64) 
36  37  ):  ): 
37  38  Constrain input and output types to highprecision numeric tensors.  Constrain input and output types to highprecision numeric tensors. 
ReduceL1  1#
Version
name: ReduceL1 (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
Computes the L1 norm of the input tensor’s element along the provided axes. The resulting tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then the resulted tensor have the reduced dimension pruned.
The above behavior is similar to numpy, with the exception that numpy defaults keepdims to False instead of True.
Attributes
axes: A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.
keepdims: Keep the reduced dimension or not, default 1 means keep reduced dimension. Default value is
1
.
Inputs
data (heterogeneous)  T: An input tensor.
Outputs
reduced (heterogeneous)  T: Reduced output tensor.
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ): Constrain input and output types to highprecision numeric tensors.