.. _l-onnx-doc-Less: ==== Less ==== .. contents:: :local: .. _l-onnx-op-less-13: Less - 13 ========= **Version** * **name**: `Less (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** Returns the tensor resulted from performing the `less` logical operation elementwise on the input tensors `A` and `B` (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 input operand for the logical operator. * **B** (heterogeneous) - **T**: Second input operand for the logical operator. **Outputs** * **C** (heterogeneous) - **T1**: Result tensor. **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 types to all numeric tensors. * **T1** in ( tensor(bool) ): Constrain output to boolean tensor. **Examples** **default** :: node = onnx.helper.make_node( 'Less', inputs=['x', 'y'], outputs=['less'], ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.random.randn(3, 4, 5).astype(np.float32) z = np.less(x, y) expect(node, inputs=[x, y], outputs=[z], name='test_less') **_less_broadcast** :: node = onnx.helper.make_node( 'Less', inputs=['x', 'y'], outputs=['less'], ) x = np.random.randn(3, 4, 5).astype(np.float32) y = np.random.randn(5).astype(np.float32) z = np.less(x, y) expect(node, inputs=[x, y], outputs=[z], name='test_less_bcast') **Differences** .. raw:: html
 `0` `0` `Returns the tensor resulted from performing the less logical operation` `Returns the tensor resulted from performing the less logical operation` `1` `1` `elementwise on the input tensors A and B (with Numpy-style broadcasting support).` `elementwise on the input tensors A and B (with Numpy-style broadcasting support).` `2` `2` `3` `3` `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 _.` `4` `4` `5` `5` `**Inputs**` `**Inputs**` `6` `6` `7` `7` `* **A** (heterogeneous) - **T**:` `* **A** (heterogeneous) - **T**:` `8` `8` ` First input operand for the logical operator.` ` First input operand for the logical operator.` `9` `9` `* **B** (heterogeneous) - **T**:` `* **B** (heterogeneous) - **T**:` `10` `10` ` Second input operand for the logical operator.` ` Second input operand for the logical operator.` `11` `11` `12` `12` `**Outputs**` `**Outputs**` `13` `13` `14` `14` `* **C** (heterogeneous) - **T1**:` `* **C** (heterogeneous) - **T1**:` `15` `15` ` Result tensor.` ` Result tensor.` `16` `16` `17` `17` `**Type Constraints**` `**Type Constraints**` `18` `18` `19` `19` `* **T** in (` `* **T** in (` `20` ` tensor(bfloat16),` `20` `21` ` tensor(double),` ` tensor(double),` `21` `22` ` tensor(float),` ` tensor(float),` `22` `23` ` tensor(float16),` ` tensor(float16),` `23` `24` ` tensor(int16),` ` tensor(int16),` `24` `25` ` tensor(int32),` ` tensor(int32),` `25` `26` ` tensor(int64),` ` tensor(int64),` `26` `27` ` tensor(int8),` ` tensor(int8),` `27` `28` ` tensor(uint16),` ` tensor(uint16),` `28` `29` ` tensor(uint32),` ` tensor(uint32),` `29` `30` ` tensor(uint64),` ` tensor(uint64),` `30` `31` ` tensor(uint8)` ` tensor(uint8)` `31` `32` ` ):` ` ):` `32` `33` ` Constrain input types to all numeric tensors.` ` Constrain input types to all numeric tensors.` `33` `34` `* **T1** in (` `* **T1** in (` `34` `35` ` tensor(bool)` ` tensor(bool)` `35` `36` ` ):` ` ):` `36` `37` ` Constrain output to boolean tensor.` ` Constrain output to boolean tensor.`
.. _l-onnx-op-less-9: Less - 9 ======== **Version** * **name**: `Less (GitHub) `_ * **domain**: **main** * **since_version**: **9** * **function**: False * **support_level**: SupportType.COMMON * **shape inference**: True This version of the operator has been available **since version 9**. **Summary** Returns the tensor resulted from performing the `less` logical operation elementwise on the input tensors `A` and `B` (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 input operand for the logical operator. * **B** (heterogeneous) - **T**: Second input operand for the logical operator. **Outputs** * **C** (heterogeneous) - **T1**: Result tensor. **Type Constraints** * **T** 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 types to all numeric tensors. * **T1** in ( tensor(bool) ): Constrain output to boolean tensor. **Differences** .. raw:: html
 `0` `0` `Returns the tensor resulted from performing the less logical operation` `Returns the tensor resulted from performing the less logical operation` `1` `1` `elementwise on the input tensors A and B (with Numpy-style broadcasting support).` `elementwise on the input tensors A and B (with Numpy-style broadcasting support).` `2` `2` `3` `3` `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 _.` `4` `4` `5` `5` `**Inputs**` `**Inputs**` `6` `6` `7` `7` `* **A** (heterogeneous) - **T**:` `* **A** (heterogeneous) - **T**:` `8` `8` ` First input operand for the logical operator.` ` First input operand for the logical operator.` `9` `9` `* **B** (heterogeneous) - **T**:` `* **B** (heterogeneous) - **T**:` `10` `10` ` Second input operand for the logical operator.` ` Second input operand for the logical operator.` `11` `11` `12` `12` `**Outputs**` `**Outputs**` `13` `13` `14` `14` `* **C** (heterogeneous) - **T1**:` `* **C** (heterogeneous) - **T1**:` `15` `15` ` Result tensor.` ` Result tensor.` `16` `16` `17` `17` `**Type Constraints**` `**Type Constraints**` `18` `18` `19` `19` `* **T** in (` `* **T** in (` `20` `20` ` tensor(double),` ` tensor(double),` `21` `21` ` tensor(float),` ` tensor(float),` `22` `22` ` tensor(float16)` ` tensor(float16),` `23` ` tensor(int16),` `24` ` tensor(int32),` `25` ` tensor(int64),` `26` ` tensor(int8),` `27` ` tensor(uint16),` `28` ` tensor(uint32),` `29` ` tensor(uint64),` `30` ` tensor(uint8)` `23` `31` ` ):` ` ):` `24` `32` ` Constrain input to float tensors.` ` Constrain input types to all numeric tensors.` `25` `33` `* **T1** in (` `* **T1** in (` `26` `34` ` tensor(bool)` ` tensor(bool)` `27` `35` ` ):` ` ):` `28` `36` ` Constrain output to boolean tensor.` ` Constrain output to boolean tensor.`
.. _l-onnx-op-less-7: Less - 7 ======== **Version** * **name**: `Less (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** Returns the tensor resulted from performing the `less` logical operation elementwise on the input tensors `A` and `B` (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 input operand for the logical operator. * **B** (heterogeneous) - **T**: Second input operand for the logical operator. **Outputs** * **C** (heterogeneous) - **T1**: Result tensor. **Type Constraints** * **T** in ( tensor(double), tensor(float), tensor(float16) ): Constrain input to float tensors. * **T1** in ( tensor(bool) ): Constrain output to boolean tensor. **Differences** .. raw:: html
 `0` `0` `Returns the tensor resulted from performing the less logical operation` `Returns the tensor resulted from performing the less logical operation` `1` `1` `elementwise on the input tensors A and B.` `elementwise on the input tensors A and B (with Numpy-style broadcasting support).` `2` `2` `3` `3` `If broadcasting is enabled, the right-hand-side argument will be broadcasted` `This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check Broadcasting in ONNX _.` `4` `to match the shape of left-hand-side argument. See the doc of Add for a` `5` `detailed description of the broadcasting rules.` `6` `4` `7` `**Attributes**` `8` `9` `* **axis**:` `10` ` If set, defines the broadcast dimensions.` `11` `* **broadcast**:` `12` ` Enable broadcasting Default value is 0.` `13` `14` `5` `**Inputs**` `**Inputs**` `15` `6` `16` `7` `* **A** (heterogeneous) - **T**:` `* **A** (heterogeneous) - **T**:` `17` `8` ` Left input tensor for the logical operator.` ` First input operand for the logical operator.` `18` `9` `* **B** (heterogeneous) - **T**:` `* **B** (heterogeneous) - **T**:` `19` `10` ` Right input tensor for the logical operator.` ` Second input operand for the logical operator.` `20` `11` `21` `12` `**Outputs**` `**Outputs**` `22` `13` `23` `14` `* **C** (heterogeneous) - **T1**:` `* **C** (heterogeneous) - **T1**:` `24` `15` ` Result tensor.` ` Result tensor.` `25` `16` `26` `17` `**Type Constraints**` `**Type Constraints**` `27` `18` `28` `19` `* **T** in (` `* **T** in (` `29` `20` ` tensor(double),` ` tensor(double),` `30` `21` ` tensor(float),` ` tensor(float),` `31` `22` ` tensor(float16)` ` tensor(float16)` `32` `23` ` ):` ` ):` `33` `24` ` Constrain input to float tensors.` ` Constrain input to float tensors.` `34` `25` `* **T1** in (` `* **T1** in (` `35` `26` ` tensor(bool)` ` tensor(bool)` `36` `27` ` ):` ` ):` `37` `28` ` Constrain output to boolean tensor.` ` Constrain output to boolean tensor.`
.. _l-onnx-op-less-1: Less - 1 ======== **Version** * **name**: `Less (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** Returns the tensor resulted from performing the `less` logical operation elementwise on the input tensors `A` and `B`. If broadcasting is enabled, the right-hand-side argument will be broadcasted to match the shape of left-hand-side argument. See the doc of `Add` for a detailed description of the broadcasting rules. **Attributes** * **axis**: If set, defines the broadcast dimensions. * **broadcast**: Enable broadcasting Default value is ``0``. **Inputs** * **A** (heterogeneous) - **T**: Left input tensor for the logical operator. * **B** (heterogeneous) - **T**: Right input tensor for the logical operator. **Outputs** * **C** (heterogeneous) - **T1**: Result tensor. **Type Constraints** * **T** in ( tensor(double), tensor(float), tensor(float16) ): Constrain input to float tensors. * **T1** in ( tensor(bool) ): Constrain output to boolean tensor.