Add#
Add - 14#
Version
name: Add (GitHub)
domain: main
since_version: 14
function: False
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 14.
Summary
Performs element-wise binary addition (with Numpy-style broadcasting support).
This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.
(Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
Inputs
A (heterogeneous) - T: First operand.
B (heterogeneous) - T: Second operand.
Outputs
C (heterogeneous) - T: Result, has same element type as two inputs
Type Constraints
T in ( tensor(bfloat16), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input and output types to all numeric tensors.
Examples
add_uint8
node = onnx.helper.make_node(
'Add',
inputs=['x', 'y'],
outputs=['sum'],
)
x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
expect(node, inputs=[x, y], outputs=[x + y],
name='test_add_uint8')
add_broadcast
node = onnx.helper.make_node(
'Add',
inputs=['x', 'y'],
outputs=['sum'],
)
x = np.random.randn(3, 4, 5).astype(np.float32)
y = np.random.randn(5).astype(np.float32)
expect(node, inputs=[x, y], outputs=[x + y],
name='test_add_bcast')
Differences
0 | 0 | Performs element-wise binary addition (with Numpy-style broadcasting support). | Performs element-wise binary addition (with Numpy-style broadcasting support). |
1 | 1 | | |
2 | 2 | This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check Broadcasting in ONNX | This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check Broadcasting in ONNX |
3 | 3 | | |
4 | (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16. | ||
5 | | ||
4 | 6 | **Inputs** | **Inputs** |
5 | 7 | | |
6 | 8 | * **A** (heterogeneous) - **T**: | * **A** (heterogeneous) - **T**: |
7 | 9 | First operand. | First operand. |
8 | 10 | * **B** (heterogeneous) - **T**: | * **B** (heterogeneous) - **T**: |
9 | 11 | Second operand. | Second operand. |
10 | 12 | | |
11 | 13 | **Outputs** | **Outputs** |
12 | 14 | | |
13 | 15 | * **C** (heterogeneous) - **T**: | * **C** (heterogeneous) - **T**: |
14 | 16 | Result, has same element type as two inputs | Result, has same element type as two inputs |
15 | 17 | | |
16 | 18 | **Type Constraints** | **Type Constraints** |
17 | 19 | | |
18 | 20 | * **T** in ( | * **T** in ( |
19 | 21 | tensor(bfloat16), | tensor(bfloat16), |
20 | 22 | tensor(double), | tensor(double), |
21 | 23 | tensor(float), | tensor(float), |
22 | 24 | tensor(float16), | tensor(float16), |
25 | tensor(int16), | ||
23 | 26 | tensor(int32), | tensor(int32), |
24 | 27 | tensor(int64), | tensor(int64), |
28 | tensor(int8), | ||
29 | tensor(uint16), | ||
25 | 30 | tensor(uint32), | tensor(uint32), |
26 | 31 | tensor(uint64) | |
32 | tensor(uint8) | ||
27 | 33 | ): | ): |
28 | 34 | Constrain input and output types to high-precision numeric tensors. | |
Add - 13#
Version
name: Add (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
Performs element-wise binary addition (with Numpy-style broadcasting support).
This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.
Inputs
A (heterogeneous) - T: First operand.
B (heterogeneous) - T: Second operand.
Outputs
C (heterogeneous) - T: Result, has same element type as two inputs
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 high-precision numeric tensors.
Differences
0 | 0 | Performs element-wise binary addition (with Numpy-style broadcasting support). | Performs element-wise binary addition (with Numpy-style broadcasting support). |
1 | 1 | | |
2 | 2 | This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check Broadcasting in ONNX | This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check Broadcasting in ONNX |
3 | 3 | | |
4 | 4 | **Inputs** | **Inputs** |
5 | 5 | | |
6 | 6 | * **A** (heterogeneous) - **T**: | * **A** (heterogeneous) - **T**: |
7 | 7 | First operand. | First operand. |
8 | 8 | * **B** (heterogeneous) - **T**: | * **B** (heterogeneous) - **T**: |
9 | 9 | Second operand. | Second operand. |
10 | 10 | | |
11 | 11 | **Outputs** | **Outputs** |
12 | 12 | | |
13 | 13 | * **C** (heterogeneous) - **T**: | * **C** (heterogeneous) - **T**: |
14 | 14 | Result, has same element type as two inputs | Result, has same element type as two inputs |
15 | 15 | | |
16 | 16 | **Type Constraints** | **Type Constraints** |
17 | 17 | | |
18 | 18 | * **T** in ( | * **T** in ( |
19 | tensor(bfloat16), | ||
19 | 20 | tensor(double), | tensor(double), |
20 | 21 | tensor(float), | tensor(float), |
21 | 22 | tensor(float16), | tensor(float16), |
22 | 23 | tensor(int32), | tensor(int32), |
23 | 24 | tensor(int64), | tensor(int64), |
24 | 25 | tensor(uint32), | tensor(uint32), |
25 | 26 | tensor(uint64) | tensor(uint64) |
26 | 27 | ): | ): |
27 | 28 | Constrain input and output types to high-precision numeric tensors. | Constrain input and output types to high-precision numeric tensors. |
Add - 7#
Version
name: Add (GitHub)
domain: main
since_version: 7
function: False
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 7.
Summary
Performs element-wise binary addition (with Numpy-style broadcasting support).
This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.
Inputs
A (heterogeneous) - T: First operand.
B (heterogeneous) - T: Second operand.
Outputs
C (heterogeneous) - T: Result, has same element type as two inputs
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ): Constrain input and output types to high-precision numeric tensors.
Differences
0 | 0 | Performs element-wise binary addition (with limited broadcast support). | |
1 | 1 | | |
2 | If necessary the right-hand-side argument will be broadcasted to match the | ||
3 | shape of left-hand-side argument. When broadcasting is specified, the second | ||
4 | tensor can either be of element size 1 (including a scalar tensor and any | ||
5 | tensor with rank equal to or smaller than the first tensor), or having its | ||
6 | shape as a contiguous subset of the first tensor's shape. The starting of the | ||
7 | 2 | mutually equal shape is specified by the argument "axis", and if it is not set, | |
8 | suffix matching is assumed. 1-dim expansion doesn't work yet. | ||
9 | 3 | | |
10 | For example, the following tensor shapes are supported (with broadcast=1): | ||
11 | | ||
12 | shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor | ||
13 | shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor | ||
14 | shape(A) = (2, 3, 4, 5), shape(B) = (5,) | ||
15 | shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) | ||
16 | shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 | ||
17 | shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 | ||
18 | | ||
19 | Attribute broadcast=1 needs to be passed to enable broadcasting. | ||
20 | | ||
21 | **Attributes** | ||
22 | | ||
23 | * **axis**: | ||
24 | If set, defines the broadcast dimensions. See doc for details. | ||
25 | * **broadcast**: | ||
26 | Pass 1 to enable broadcasting Default value is 0. | ||
27 | | ||
28 | 4 | **Inputs** | **Inputs** |
29 | 5 | | |
30 | 6 | * **A** (heterogeneous) - **T**: | * **A** (heterogeneous) - **T**: |
31 | 7 | First operand, should share the type with the second operand. | |
32 | 8 | * **B** (heterogeneous) - **T**: | * **B** (heterogeneous) - **T**: |
33 | 9 | Second operand. With broadcasting can be of smaller size than A. If | |
34 | broadcasting is disabled it should be of the same size. | ||
35 | 10 | | |
36 | 11 | **Outputs** | **Outputs** |
37 | 12 | | |
38 | 13 | * **C** (heterogeneous) - **T**: | * **C** (heterogeneous) - **T**: |
39 | 14 | Result, has same dimensions and type as A | |
40 | 15 | | |
41 | 16 | **Type Constraints** | **Type Constraints** |
42 | 17 | | |
43 | 18 | * **T** in ( | * **T** in ( |
44 | 19 | tensor(double), | tensor(double), |
45 | 20 | tensor(float), | tensor(float), |
46 | 21 | tensor(float16), | tensor(float16), |
47 | 22 | tensor(int32), | tensor(int32), |
48 | 23 | tensor(int64), | tensor(int64), |
49 | 24 | tensor(uint32), | tensor(uint32), |
50 | 25 | tensor(uint64) | tensor(uint64) |
51 | 26 | ): | ): |
52 | 27 | Constrain input and output types to high-precision numeric tensors. | Constrain input and output types to high-precision numeric tensors. |
Add - 6#
Version
name: Add (GitHub)
domain: main
since_version: 6
function: False
support_level: SupportType.COMMON
shape inference: True
This version of the operator has been available since version 6.
Summary
Performs element-wise binary addition (with limited broadcast support).
If necessary the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. When broadcasting is specified, the second tensor can either be of element size 1 (including a scalar tensor and any tensor with rank equal to or smaller than the first tensor), or having its shape as a contiguous subset of the first tensor’s shape. The starting of the mutually equal shape is specified by the argument “axis”, and if it is not set, suffix matching is assumed. 1-dim expansion doesn’t work yet.
For example, the following tensor shapes are supported (with broadcast=1):
shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor shape(A) = (2, 3, 4, 5), shape(B) = (5,) shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
Attribute broadcast=1 needs to be passed to enable broadcasting.
Attributes
axis: If set, defines the broadcast dimensions. See doc for details.
broadcast: Pass 1 to enable broadcasting Default value is
0.
Inputs
A (heterogeneous) - T: First operand, should share the type with the second operand.
B (heterogeneous) - T: Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.
Outputs
C (heterogeneous) - T: Result, has same dimensions and type as A
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ): Constrain input and output types to high-precision numeric tensors.
Differences
0 | 0 | Performs element-wise binary addition (with limited broadcast support). | Performs element-wise binary addition (with limited broadcast support). |
1 | 1 | | |
2 | 2 | If necessary the right-hand-side argument will be broadcasted to match the | If necessary the right-hand-side argument will be broadcasted to match the |
3 | 3 | shape of left-hand-side argument. When broadcasting is specified, the second | shape of left-hand-side argument. When broadcasting is specified, the second |
4 | 4 | tensor can either be of element size 1 (including a scalar tensor and any | tensor can either be of element size 1 (including a scalar tensor and any |
5 | 5 | tensor with rank equal to or smaller than the first tensor), or having its | tensor with rank equal to or smaller than the first tensor), or having its |
6 | 6 | shape as a contiguous subset of the first tensor's shape. The starting of the | shape as a contiguous subset of the first tensor's shape. The starting of the |
7 | 7 | mutually equal shape is specified by the argument "axis", and if it is not set, | mutually equal shape is specified by the argument "axis", and if it is not set, |
8 | 8 | suffix matching is assumed. 1-dim expansion doesn't work yet. | suffix matching is assumed. 1-dim expansion doesn't work yet. |
9 | 9 | | |
10 | 10 | For example, the following tensor shapes are supported (with broadcast=1): | For example, the following tensor shapes are supported (with broadcast=1): |
11 | 11 | | |
12 | 12 | shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor | shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor |
13 | 13 | shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor | shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor |
14 | 14 | shape(A) = (2, 3, 4, 5), shape(B) = (5,) | shape(A) = (2, 3, 4, 5), shape(B) = (5,) |
15 | 15 | shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) | shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) |
16 | 16 | shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 | shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 |
17 | 17 | shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 | shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0 |
18 | 18 | | |
19 | 19 | Attribute broadcast=1 needs to be passed to enable broadcasting. | Attribute broadcast=1 needs to be passed to enable broadcasting. |
20 | 20 | | |
21 | 21 | **Attributes** | **Attributes** |
22 | 22 | | |
23 | 23 | * **axis**: | * **axis**: |
24 | 24 | If set, defines the broadcast dimensions. See doc for details. | If set, defines the broadcast dimensions. See doc for details. |
25 | 25 | * **broadcast**: | * **broadcast**: |
26 | 26 | Pass 1 to enable broadcasting Default value is 0. | Pass 1 to enable broadcasting Default value is 0. |
27 | * **consumed_inputs**: | ||
28 | legacy optimization attribute. | ||
29 | 27 | | |
30 | 28 | **Inputs** | **Inputs** |
31 | 29 | | |
32 | 30 | * **A** (heterogeneous) - **T**: | * **A** (heterogeneous) - **T**: |
33 | 31 | First operand, should share the type with the second operand. | First operand, should share the type with the second operand. |
34 | 32 | * **B** (heterogeneous) - **T**: | * **B** (heterogeneous) - **T**: |
35 | 33 | Second operand. With broadcasting can be of smaller size than A. If | Second operand. With broadcasting can be of smaller size than A. If |
36 | 34 | broadcasting is disabled it should be of the same size. | broadcasting is disabled it should be of the same size. |
37 | 35 | | |
38 | 36 | **Outputs** | **Outputs** |
39 | 37 | | |
40 | 38 | * **C** (heterogeneous) - **T**: | * **C** (heterogeneous) - **T**: |
41 | 39 | Result, has same dimensions and type as A | Result, has same dimensions and type as A |
42 | 40 | | |
43 | 41 | **Type Constraints** | **Type Constraints** |
44 | 42 | | |
45 | 43 | * **T** in ( | * **T** in ( |
46 | 44 | tensor(double), | tensor(double), |
47 | 45 | tensor(float), | tensor(float), |
48 | 46 | tensor(float16) | |
47 | tensor(int32), | ||
48 | tensor(int64), | ||
49 | tensor(uint32), | ||
50 | tensor(uint64) | ||
49 | 51 | ): | ): |
50 | 52 | Constrain input and output types to float tensors. | |
Add - 1#
Version
name: Add (GitHub)
domain: main
since_version: 1
function: False
support_level: SupportType.COMMON
shape inference: False
This version of the operator has been available since version 1.
Summary
Performs element-wise binary addition (with limited broadcast support).
If necessary the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. When broadcasting is specified, the second tensor can either be of element size 1 (including a scalar tensor and any tensor with rank equal to or smaller than the first tensor), or having its shape as a contiguous subset of the first tensor’s shape. The starting of the mutually equal shape is specified by the argument “axis”, and if it is not set, suffix matching is assumed. 1-dim expansion doesn’t work yet.
For example, the following tensor shapes are supported (with broadcast=1):
shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor shape(A) = (2, 3, 4, 5), shape(B) = (5,) shape(A) = (2, 3, 4, 5), shape(B) = (4, 5) shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
Attribute broadcast=1 needs to be passed to enable broadcasting.
Attributes
axis: If set, defines the broadcast dimensions. See doc for details.
broadcast: Pass 1 to enable broadcasting Default value is
0.consumed_inputs: legacy optimization attribute.
Inputs
A (heterogeneous) - T: First operand, should share the type with the second operand.
B (heterogeneous) - T: Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.
Outputs
C (heterogeneous) - T: Result, has same dimensions and type as A
Type Constraints
T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.