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 elementwise binary addition (with Numpystyle broadcasting support).
This operator supports multidirectional (i.e., Numpystyle) 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
default
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(3, 4, 5).astype(np.float32)
expect(node, inputs=[x, y], outputs=[x + y], name="test_add")
_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 elementwise binary addition (with Numpystyle broadcasting support).  Performs elementwise binary addition (with Numpystyle broadcasting support). 
1  1 


2  2  This operator supports **multidirectional (i.e., Numpystyle) broadcasting**; for more details please check Broadcasting in ONNX  This operator supports **multidirectional (i.e., Numpystyle) 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 highprecision 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 elementwise binary addition (with Numpystyle broadcasting support).
This operator supports multidirectional (i.e., Numpystyle) 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 highprecision numeric tensors.
Differences
0  0  Performs elementwise binary addition (with Numpystyle broadcasting support).  Performs elementwise binary addition (with Numpystyle broadcasting support). 
1  1 


2  2  This operator supports **multidirectional (i.e., Numpystyle) broadcasting**; for more details please check Broadcasting in ONNX  This operator supports **multidirectional (i.e., Numpystyle) 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 highprecision numeric tensors.  Constrain input and output types to highprecision 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 elementwise binary addition (with Numpystyle broadcasting support).
This operator supports multidirectional (i.e., Numpystyle) 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 highprecision numeric tensors.
Differences
0  0  Performs elementwise binary addition (with limited broadcast support). 

1  1 


2  If necessary the righthandside argument will be broadcasted to match the  
3  shape of lefthandside 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. 1dim 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 1element 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 highprecision numeric tensors.  Constrain input and output types to highprecision 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 elementwise binary addition (with limited broadcast support).
If necessary the righthandside argument will be broadcasted to match the shape of lefthandside 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. 1dim 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 1element 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 highprecision numeric tensors.
Differences
0  0  Performs elementwise binary addition (with limited broadcast support).  Performs elementwise binary addition (with limited broadcast support). 
1  1 


2  2  If necessary the righthandside argument will be broadcasted to match the  If necessary the righthandside argument will be broadcasted to match the 
3  3  shape of lefthandside argument. When broadcasting is specified, the second  shape of lefthandside 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. 1dim expansion doesn't work yet.  suffix matching is assumed. 1dim 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 1element tensor  shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1element 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 elementwise binary addition (with limited broadcast support).
If necessary the righthandside argument will be broadcasted to match the shape of lefthandside 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. 1dim 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 1element 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.