Pow#

Pow - 15#

Version

  • name: Pow (GitHub)

  • domain: main

  • since_version: 15

  • function: False

  • support_level: SupportType.COMMON

  • shape inference: True

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

Summary

Pow takes input data (Tensor<T>) and exponent Tensor, and produces one output data (Tensor<T>) where the function f(x) = x^exponent, is applied to the data tensor elementwise. This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.

Inputs

  • X (heterogeneous) - T: First operand, base of the exponent.

  • Y (heterogeneous) - T1: Second operand, power of the exponent.

Outputs

  • Z (heterogeneous) - T: Output tensor

Type Constraints

  • T in ( tensor(bfloat16), tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64) ): Constrain input X and output types to float/int tensors.

  • T1 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 Y types to float/int tensors.

Examples

default

node = onnx.helper.make_node(
    'Pow',
    inputs=['x', 'y'],
    outputs=['z'],
)

x = np.array([1, 2, 3]).astype(np.float32)
y = np.array([4, 5, 6]).astype(np.float32)
z = pow(x, y)  # expected output [1., 32., 729.]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_example')

x = np.arange(60).reshape(3, 4, 5).astype(np.float32)
y = np.random.randn(3, 4, 5).astype(np.float32)
z = pow(x, y)
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow')

_pow_broadcast

node = onnx.helper.make_node(
    'Pow',
    inputs=['x', 'y'],
    outputs=['z'],
)

x = np.array([1, 2, 3]).astype(np.float32)
y = np.array(2).astype(np.float32)
z = pow(x, y)  # expected output [1., 4., 9.]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_bcast_scalar')

node = onnx.helper.make_node(
    'Pow',
    inputs=['x', 'y'],
    outputs=['z'],
)
x = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
y = np.array([1, 2, 3]).astype(np.float32)
# expected output [[1, 4, 27], [4, 25, 216]]
z = pow(x, y)
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_bcast_array')

_types

node = onnx.helper.make_node(
    'Pow',
    inputs=['x', 'y'],
    outputs=['z'],
)

x = np.array([1, 2, 3]).astype(np.float32)
y = np.array([4, 5, 6]).astype(np.int64)
z = pow(x, y)  # expected output [1., 32., 729.]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_float32_int64')

x = np.array([1, 2, 3]).astype(np.int64)
y = np.array([4, 5, 6]).astype(np.float32)
z = pow(x, y)  # expected output [1, 32, 729]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_int64_float32')

x = np.array([1, 2, 3]).astype(np.float32)
y = np.array([4, 5, 6]).astype(np.int32)
z = pow(x, y)  # expected output [1., 32., 729.]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_float32_int32')

x = np.array([1, 2, 3]).astype(np.int32)
y = np.array([4, 5, 6]).astype(np.float32)
z = pow(x, y)  # expected output [1, 32, 729]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_int32_float32')

x = np.array([1, 2, 3]).astype(np.float32)
y = np.array([4, 5, 6]).astype(np.uint64)
z = pow(x, y)  # expected output [1., 32., 729.]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_float32_uint64')

x = np.array([1, 2, 3]).astype(np.float32)
y = np.array([4, 5, 6]).astype(np.uint32)
z = pow(x, y)  # expected output [1., 32., 729.]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_float32_uint32')

x = np.array([1, 2, 3]).astype(np.int64)
y = np.array([4, 5, 6]).astype(np.int64)
z = pow(x, y)  # expected output [1, 32, 729]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_int64_int64')

x = np.array([1, 2, 3]).astype(np.int32)
y = np.array([4, 5, 6]).astype(np.int32)
z = pow(x, y)  # expected output [1, 32, 729]
expect(node, inputs=[x, y], outputs=[z],
       name='test_pow_types_int32_int32')

Differences

00Pow takes input data (Tensor) and exponent Tensor, andPow takes input data (Tensor) and exponent Tensor, and
11produces one output data (Tensor) where the function f(x) = x^exponent,produces one output data (Tensor) where the function f(x) = x^exponent,
22is applied to the data tensor elementwise.is applied to the data tensor elementwise.
33This 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 _.
44
55**Inputs****Inputs**
66
77* **X** (heterogeneous) - **T**:* **X** (heterogeneous) - **T**:
88 First operand, base of the exponent. First operand, base of the exponent.
99* **Y** (heterogeneous) - **T1**:* **Y** (heterogeneous) - **T1**:
1010 Second operand, power of the exponent. Second operand, power of the exponent.
1111
1212**Outputs****Outputs**
1313
1414* **Z** (heterogeneous) - **T**:* **Z** (heterogeneous) - **T**:
1515 Output tensor Output tensor
1616
1717**Type Constraints****Type Constraints**
1818
1919* **T** in (* **T** in (
2020 tensor(bfloat16), tensor(bfloat16),
2121 tensor(double), tensor(double),
2222 tensor(float), tensor(float),
2323 tensor(float16), tensor(float16),
2424 tensor(int32), tensor(int32),
2525 tensor(int64) tensor(int64)
2626 ): ):
2727 Constrain input X and output types to float/int tensors. Constrain input X and output types to float/int tensors.
2828* **T1** in (* **T1** in (
29 tensor(bfloat16),
2930 tensor(double), tensor(double),
3031 tensor(float), tensor(float),
3132 tensor(float16), tensor(float16),
3233 tensor(int16), tensor(int16),
3334 tensor(int32), tensor(int32),
3435 tensor(int64), tensor(int64),
3536 tensor(int8), tensor(int8),
3637 tensor(uint16), tensor(uint16),
3738 tensor(uint32), tensor(uint32),
3839 tensor(uint64), tensor(uint64),
3940 tensor(uint8) tensor(uint8)
4041 ): ):
4142 Constrain input Y types to float/int tensors. Constrain input Y types to float/int tensors.

Pow - 13#

Version

  • name: Pow (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

Pow takes input data (Tensor<T>) and exponent Tensor, and produces one output data (Tensor<T>) where the function f(x) = x^exponent, is applied to the data tensor elementwise. This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.

Inputs

  • X (heterogeneous) - T: First operand, base of the exponent.

  • Y (heterogeneous) - T1: Second operand, power of the exponent.

Outputs

  • Z (heterogeneous) - T: Output tensor

Type Constraints

  • T in ( tensor(bfloat16), tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64) ): Constrain input X and output types to float/int tensors.

  • T1 in ( tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input Y types to float/int tensors.

Differences

00Pow takes input data (Tensor) and exponent Tensor, andPow takes input data (Tensor) and exponent Tensor, and
11produces one output data (Tensor) where the function f(x) = x^exponent,produces one output data (Tensor) where the function f(x) = x^exponent,
22is applied to the data tensor elementwise.is applied to the data tensor elementwise.
33This 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 _.
44
55**Inputs****Inputs**
66
77* **X** (heterogeneous) - **T**:* **X** (heterogeneous) - **T**:
88 First operand, base of the exponent. First operand, base of the exponent.
99* **Y** (heterogeneous) - **T1**:* **Y** (heterogeneous) - **T1**:
1010 Second operand, power of the exponent. Second operand, power of the exponent.
1111
1212**Outputs****Outputs**
1313
1414* **Z** (heterogeneous) - **T**:* **Z** (heterogeneous) - **T**:
1515 Output tensor. Output tensor
1616
1717**Type Constraints****Type Constraints**
1818
1919* **T** in (* **T** in (
20 tensor(bfloat16),
2021 tensor(double), tensor(double),
2122 tensor(float), tensor(float),
2223 tensor(float16), tensor(float16),
2324 tensor(int32), tensor(int32),
2425 tensor(int64) tensor(int64)
2526 ): ):
2627 Constrain input X and output types to float/int tensors. Constrain input X and output types to float/int tensors.
2728* **T1** in (* **T1** in (
2829 tensor(double), tensor(double),
2930 tensor(float), tensor(float),
3031 tensor(float16), tensor(float16),
3132 tensor(int16), tensor(int16),
3233 tensor(int32), tensor(int32),
3334 tensor(int64), tensor(int64),
3435 tensor(int8), tensor(int8),
3536 tensor(uint16), tensor(uint16),
3637 tensor(uint32), tensor(uint32),
3738 tensor(uint64), tensor(uint64),
3839 tensor(uint8) tensor(uint8)
3940 ): ):
4041 Constrain input Y types to float/int tensors. Constrain input Y types to float/int tensors.

Pow - 12#

Version

  • name: Pow (GitHub)

  • domain: main

  • since_version: 12

  • function: False

  • support_level: SupportType.COMMON

  • shape inference: True

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

Summary

Pow takes input data (Tensor<T>) and exponent Tensor, and produces one output data (Tensor<T>) where the function f(x) = x^exponent, is applied to the data tensor elementwise. This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.

Inputs

  • X (heterogeneous) - T: First operand, base of the exponent.

  • Y (heterogeneous) - T1: Second operand, power of the exponent.

Outputs

  • Z (heterogeneous) - T: Output tensor.

Type Constraints

  • T in ( tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64) ): Constrain input X and output types to float/int tensors.

  • T1 in ( tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input Y types to float/int tensors.

Differences

00Pow takes input data (Tensor) and exponent Tensor, andPow takes input data (Tensor) and exponent Tensor, and
11produces one output data (Tensor) where the function f(x) = x^exponent,produces one output data (Tensor) where the function f(x) = x^exponent,
22is applied to the data tensor elementwise.is applied to the data tensor elementwise.
33This 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 _.
44
55**Inputs****Inputs**
66
77* **X** (heterogeneous) - **T**:* **X** (heterogeneous) - **T**:
88 First operand, base of the exponent. First operand, base of the exponent.
99* **Y** (heterogeneous) - **T**:* **Y** (heterogeneous) - **T1**:
1010 Second operand, power of the exponent. Second operand, power of the exponent.
1111
1212**Outputs****Outputs**
1313
1414* **Z** (heterogeneous) - **T**:* **Z** (heterogeneous) - **T**:
1515 Output tensor. Output tensor.
1616
1717**Type Constraints****Type Constraints**
1818
1919* **T** in (* **T** in (
2020 tensor(double), tensor(double),
2121 tensor(float), tensor(float),
2222 tensor(float16) tensor(float16),
23 tensor(int32),
24 tensor(int64)
2325 ): ):
2426 Constrain input and output types to float tensors. Constrain input X and output types to float/int tensors.
27* **T1** in (
28 tensor(double),
29 tensor(float),
30 tensor(float16),
31 tensor(int16),
32 tensor(int32),
33 tensor(int64),
34 tensor(int8),
35 tensor(uint16),
36 tensor(uint32),
37 tensor(uint64),
38 tensor(uint8)
39 ):
40 Constrain input Y types to float/int tensors.

Pow - 7#

Version

  • name: Pow (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

Pow takes input data (Tensor<T>) and exponent Tensor, and produces one output data (Tensor<T>) where the function f(x) = x^exponent, is applied to the data tensor elementwise. This operator supports multidirectional (i.e., Numpy-style) broadcasting; for more details please check Broadcasting in ONNX.

Inputs

  • X (heterogeneous) - T: First operand, base of the exponent.

  • Y (heterogeneous) - T: Second operand, power of the exponent.

Outputs

  • Z (heterogeneous) - T: Output tensor.

Type Constraints

  • T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.

Differences

00Pow takes input data (Tensor) and exponent Tensor, andPow takes input data (Tensor) and exponent Tensor, and
11produces one output data (Tensor) where the function f(x) = x^exponent,produces one output data (Tensor) where the function f(x) = x^exponent,
22is applied to the data tensor elementwise.is applied to the data tensor elementwise.
3
43If necessary the right-hand-side argument will be broadcasted to match theThis operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check Broadcasting in ONNX <https://github.com/onnx/onnx/blob/master/docs/Broadcasting.md>_.
4
55shape of left-hand-side argument. When broadcasting is specified, the second**Inputs**
6
67tensor can either be of element size 1 (including a scalar tensor and any* **X** (heterogeneous) - **T**:
78tensor with rank equal to or smaller than the first tensor), or having its First operand, base of the exponent.
89shape as a contiguous subset of the first tensor's shape. The starting of the* **Y** (heterogeneous) - **T**:
910mutually equal shape is specified by the argument "axis", and if it is not set, Second operand, power of the exponent.
10suffix matching is assumed. 1-dim expansion doesn't work yet.
1111
12For example, the following tensor shapes are supported (with broadcast=1):
13
14 shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
15 shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
16 shape(A) = (2, 3, 4, 5), shape(B) = (5,)
17 shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
18 shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
19 shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
20
21Attribute broadcast=1 needs to be passed to enable broadcasting.
22
23**Attributes**
24
25* **axis**:
26 If set, defines the broadcast dimensions. See doc for details.
27* **broadcast**:
28 Pass 1 to enable broadcasting Default value is 0.
29
30**Inputs**
31
32* **X** (heterogeneous) - **T**:
33 Input tensor of any shape, base of the exponent.
34* **Y** (heterogeneous) - **T**:
35 Input tensor of any shape broadcastable to X shape, the exponent
36 component.
37
3812**Outputs****Outputs**
3913
4014* **Z** (heterogeneous) - **T**:* **Z** (heterogeneous) - **T**:
4115 Output tensor (same size as X) Output tensor.
4216
4317**Type Constraints****Type Constraints**
4418
4519* **T** in (* **T** in (
4620 tensor(double), tensor(double),
4721 tensor(float), tensor(float),
4822 tensor(float16) tensor(float16)
4923 ): ):
5024 Constrain input and output types to float tensors. Constrain input and output types to float tensors.

Pow - 1#

Version

  • name: Pow (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

Pow takes input data (Tensor<T>) and exponent Tensor, and produces one output data (Tensor<T>) where the function f(x) = x^exponent, is applied to the data tensor elementwise.

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

  • X (heterogeneous) - T: Input tensor of any shape, base of the exponent.

  • Y (heterogeneous) - T: Input tensor of any shape broadcastable to X shape, the exponent component.

Outputs

  • Z (heterogeneous) - T: Output tensor (same size as X)

Type Constraints

  • T in ( tensor(double), tensor(float), tensor(float16) ): Constrain input and output types to float tensors.