OptionalGetElement#

OptionalGetElement - 18 #

Version

name: OptionalGetElement (GitHub)
domain: main
since_version: 18
function: False
support_level: SupportType.COMMON
shape inference: True

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

Summary

If the input is a tensor or sequence type, it returns the input. If the input is an optional type, it outputs the element in the input. It is an error if the input is an empty optional-type (i.e. does not have an element) and the behavior is undefined in this case.

Inputs

input (heterogeneous) - O: The optional input.

Outputs

output (heterogeneous) - V: Output element in the optional input.

Type Constraints

O in ( optional(seq(tensor(bool))), optional(seq(tensor(complex128))), optional(seq(tensor(complex64))), optional(seq(tensor(double))), optional(seq(tensor(float))), optional(seq(tensor(float16))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(int8))), optional(seq(tensor(string))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(uint8))), optional(tensor(bool)), optional(tensor(complex128)), optional(tensor(complex64)), optional(tensor(double)), optional(tensor(float)), optional(tensor(float16)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(int8)), optional(tensor(string)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(uint8)), seq(tensor(bool)), seq(tensor(complex128)), seq(tensor(complex64)), seq(tensor(double)), seq(tensor(float)), seq(tensor(float16)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(int8)), seq(tensor(string)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(uint8)), tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain input type to optional tensor and optional sequence types.
V in ( seq(tensor(bool)), seq(tensor(complex128)), seq(tensor(complex64)), seq(tensor(double)), seq(tensor(float)), seq(tensor(float16)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(int8)), seq(tensor(string)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(uint8)), tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ): Constrain output type to all tensor or sequence types.

Examples

_get_element_tensor

optional = np.array([1, 2, 3, 4]).astype(np.float32)
tensor_type_proto = onnx.helper.make_tensor_type_proto(
    elem_type=onnx.TensorProto.FLOAT,
    shape=[
        4,
    ],
)
optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)

node = onnx.helper.make_node(
    "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
)
output = optional_get_element_reference_implementation(optional)
expect(
    node,
    inputs=[optional],
    outputs=[output],
    input_type_protos=[optional_type_proto],
    name="test_optional_get_element_optional_tensor",
)
expect(
    node,
    inputs=[optional],
    outputs=[output],
    input_type_protos=[tensor_type_proto],
    name="test_optional_get_element_tensor",
)

_get_element_sequence

optional = [np.array([1, 2, 3, 4]).astype(np.int32)]
tensor_type_proto = onnx.helper.make_tensor_type_proto(
    elem_type=onnx.TensorProto.INT32,
    shape=[
        4,
    ],
)
seq_type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto)
optional_type_proto = onnx.helper.make_optional_type_proto(seq_type_proto)

node = onnx.helper.make_node(
    "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
)
output = optional_get_element_reference_implementation(optional)
expect(
    node,
    inputs=[optional],
    outputs=[output],
    input_type_protos=[optional_type_proto],
    name="test_optional_get_element_optional_sequence",
)
expect(
    node,
    inputs=[optional],
    outputs=[output],
    input_type_protos=[seq_type_proto],
    name="test_optional_get_element_sequence",
)

Differences

	`0`		`If the input is a tensor or sequence type, it returns the input.`
`0`	`1`	`Outputs the element in the optional-type input. It is an error if the input value does not have an element`	`If the input is an optional type, it outputs the element in the input.`
`1`	`2`	`and the behavior is undefined in this case.`	`It is an error if the input is an empty optional-type (i.e. does not have an element) and the behavior is undefined in this case.`
`2`	`3`
`3`	`4`	`Inputs`	`Inputs`
`4`	`5`
`5`	`6`	`* input (heterogeneous) - O:`	`* input (heterogeneous) - O:`
`6`	`7`	`The optional input.`	`The optional input.`
`7`	`8`
`8`	`9`	`Outputs`	`Outputs`
`9`	`10`
`10`	`11`	`* output (heterogeneous) - V:`	`* output (heterogeneous) - V:`
`11`	`12`	`Output element in the optional input.`	`Output element in the optional input.`
`12`	`13`
`13`	`14`	`Type Constraints`	`Type Constraints`
`14`	`15`
`15`	`16`	`* O in (`	`* O in (`
`16`	`17`	`optional(seq(tensor(bool))),`	`optional(seq(tensor(bool))),`
`17`	`18`	`optional(seq(tensor(complex128))),`	`optional(seq(tensor(complex128))),`
`18`	`19`	`optional(seq(tensor(complex64))),`	`optional(seq(tensor(complex64))),`
`19`	`20`	`optional(seq(tensor(double))),`	`optional(seq(tensor(double))),`
`20`	`21`	`optional(seq(tensor(float))),`	`optional(seq(tensor(float))),`
`21`	`22`	`optional(seq(tensor(float16))),`	`optional(seq(tensor(float16))),`
`22`	`23`	`optional(seq(tensor(int16))),`	`optional(seq(tensor(int16))),`
`23`	`24`	`optional(seq(tensor(int32))),`	`optional(seq(tensor(int32))),`
`24`	`25`	`optional(seq(tensor(int64))),`	`optional(seq(tensor(int64))),`
`25`	`26`	`optional(seq(tensor(int8))),`	`optional(seq(tensor(int8))),`
`26`	`27`	`optional(seq(tensor(string))),`	`optional(seq(tensor(string))),`
`27`	`28`	`optional(seq(tensor(uint16))),`	`optional(seq(tensor(uint16))),`
`28`	`29`	`optional(seq(tensor(uint32))),`	`optional(seq(tensor(uint32))),`
`29`	`30`	`optional(seq(tensor(uint64))),`	`optional(seq(tensor(uint64))),`
`30`	`31`	`optional(seq(tensor(uint8))),`	`optional(seq(tensor(uint8))),`
`31`	`32`	`optional(tensor(bool)),`	`optional(tensor(bool)),`
`32`	`33`	`optional(tensor(complex128)),`	`optional(tensor(complex128)),`
`33`	`34`	`optional(tensor(complex64)),`	`optional(tensor(complex64)),`
`34`	`35`	`optional(tensor(double)),`	`optional(tensor(double)),`
`35`	`36`	`optional(tensor(float)),`	`optional(tensor(float)),`
`36`	`37`	`optional(tensor(float16)),`	`optional(tensor(float16)),`
`37`	`38`	`optional(tensor(int16)),`	`optional(tensor(int16)),`
`38`	`39`	`optional(tensor(int32)),`	`optional(tensor(int32)),`
`39`	`40`	`optional(tensor(int64)),`	`optional(tensor(int64)),`
`40`	`41`	`optional(tensor(int8)),`	`optional(tensor(int8)),`
`41`	`42`	`optional(tensor(string)),`	`optional(tensor(string)),`
`42`	`43`	`optional(tensor(uint16)),`	`optional(tensor(uint16)),`
`43`	`44`	`optional(tensor(uint32)),`	`optional(tensor(uint32)),`
`44`	`45`	`optional(tensor(uint64)),`	`optional(tensor(uint64)),`
`45`	`46`	`optional(tensor(uint8))`	`optional(tensor(uint8)),`
	`47`		`seq(tensor(bool)),`
	`48`		`seq(tensor(complex128)),`
	`49`		`seq(tensor(complex64)),`
	`50`		`seq(tensor(double)),`
	`51`		`seq(tensor(float)),`
	`52`		`seq(tensor(float16)),`
	`53`		`seq(tensor(int16)),`
	`54`		`seq(tensor(int32)),`
	`55`		`seq(tensor(int64)),`
	`56`		`seq(tensor(int8)),`
	`57`		`seq(tensor(string)),`
	`58`		`seq(tensor(uint16)),`
	`59`		`seq(tensor(uint32)),`
	`60`		`seq(tensor(uint64)),`
	`61`		`seq(tensor(uint8)),`
	`62`		`tensor(bool),`
	`63`		`tensor(complex128),`
	`64`		`tensor(complex64),`
	`65`		`tensor(double),`
	`66`		`tensor(float),`
	`67`		`tensor(float16),`
	`68`		`tensor(int16),`
	`69`		`tensor(int32),`
	`70`		`tensor(int64),`
	`71`		`tensor(int8),`
	`72`		`tensor(string),`
	`73`		`tensor(uint16),`
	`74`		`tensor(uint32),`
	`75`		`tensor(uint64),`
	`76`		`tensor(uint8)`
`46`	`77`	`):`	`):`
`47`	`78`	`Constrain input type to optional tensor and optional sequence types.`	`Constrain input type to optional tensor and optional sequence types.`
`48`	`79`	`* V in (`	`* V in (`
`49`	`80`	`seq(tensor(bool)),`	`seq(tensor(bool)),`
`50`	`81`	`seq(tensor(complex128)),`	`seq(tensor(complex128)),`
`51`	`82`	`seq(tensor(complex64)),`	`seq(tensor(complex64)),`
`52`	`83`	`seq(tensor(double)),`	`seq(tensor(double)),`
`53`	`84`	`seq(tensor(float)),`	`seq(tensor(float)),`
`54`	`85`	`seq(tensor(float16)),`	`seq(tensor(float16)),`
`55`	`86`	`seq(tensor(int16)),`	`seq(tensor(int16)),`
`56`	`87`	`seq(tensor(int32)),`	`seq(tensor(int32)),`
`57`	`88`	`seq(tensor(int64)),`	`seq(tensor(int64)),`
`58`	`89`	`seq(tensor(int8)),`	`seq(tensor(int8)),`
`59`	`90`	`seq(tensor(string)),`	`seq(tensor(string)),`
`60`	`91`	`seq(tensor(uint16)),`	`seq(tensor(uint16)),`
`61`	`92`	`seq(tensor(uint32)),`	`seq(tensor(uint32)),`
`62`	`93`	`seq(tensor(uint64)),`	`seq(tensor(uint64)),`
`63`	`94`	`seq(tensor(uint8)),`	`seq(tensor(uint8)),`
`64`	`95`	`tensor(bool),`	`tensor(bool),`
`65`	`96`	`tensor(complex128),`	`tensor(complex128),`
`66`	`97`	`tensor(complex64),`	`tensor(complex64),`
`67`	`98`	`tensor(double),`	`tensor(double),`
`68`	`99`	`tensor(float),`	`tensor(float),`
`69`	`100`	`tensor(float16),`	`tensor(float16),`
`70`	`101`	`tensor(int16),`	`tensor(int16),`
`71`	`102`	`tensor(int32),`	`tensor(int32),`
`72`	`103`	`tensor(int64),`	`tensor(int64),`
`73`	`104`	`tensor(int8),`	`tensor(int8),`
`74`	`105`	`tensor(string),`	`tensor(string),`
`75`	`106`	`tensor(uint16),`	`tensor(uint16),`
`76`	`107`	`tensor(uint32),`	`tensor(uint32),`
`77`	`108`	`tensor(uint64),`	`tensor(uint64),`
`78`	`109`	`tensor(uint8)`	`tensor(uint8)`
`79`	`110`	`):`	`):`
`80`	`111`	`Constrain output type to all tensor or sequence types.`	`Constrain output type to all tensor or sequence types.`

OptionalGetElement - 15 #

Version

name: OptionalGetElement (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.