openvino.runtime.opset6.tensor_iterator#

class openvino.runtime.opset6.tensor_iterator#

Bases: Node

openvino.impl.op.TensorIterator wraps ov::op::v0::TensorIterator

__init__(self: openvino._pyopenvino.op.tensor_iterator) → None#

Methods

`__add__`(right_node[, auto_broadcast, name])	Return node which applies f(A,B) = A+B to the input nodes element-wise.
`__delattr__`(name, /)	Implement delattr(self, name).
`__dir__`()	Default dir() implementation.
`__div__`(right_node[, auto_broadcast, name])	Return node which applies f(x) = A/B to the input nodes element-wise.
`__eq__`(right_node[, auto_broadcast, name])	Return node which checks if input nodes are equal element-wise.
`__format__`(format_spec, /)	Default object formatter.
`__ge__`(right_node[, auto_broadcast, name])	Return node which checks if left node is greater or equal to the right node element-wise.
`__getattr__`(self, arg0)
`__getattribute__`(name, /)	Return getattr(self, name).
`__gt__`(right_node[, auto_broadcast, name])	Return node which checks if left input node is greater than the right node element-wise.
`__hash__`()	Return hash(self).
`__init__`(self)
`__init_subclass__`	This method is called when a class is subclassed.
`__le__`(right_node[, auto_broadcast, name])	Return node which checks if left input node is less or equal the right node element-wise.
`__lt__`(right_node[, auto_broadcast, name])	Return node which checks if left input node is less than the right node element-wise.
`__mul__`(right_node[, auto_broadcast, name])	Return node which applies f(A,B) = A*B to the input nodes elementwise.
`__ne__`(right_node[, auto_broadcast, name])	Return node which checks if input nodes are unequal element-wise.
`__new__`(**kwargs)
`__radd__`(right)
`__rdiv__`(right)
`__reduce__`()	Helper for pickle.
`__reduce_ex__`(protocol, /)	Helper for pickle.
`__repr__`(self)
`__rmul__`(right)
`__rsub__`(right)
`__rtruediv__`(right)
`__setattr__`(name, value, /)	Implement setattr(self, name, value).
`__sizeof__`()	Size of object in memory, in bytes.
`__str__`()	Return str(self).
`__sub__`(right_node[, auto_broadcast, name])	Return node which applies f(x) = A-B to the input nodes element-wise.
`__subclasshook__`	Abstract classes can override this to customize issubclass().
`__truediv__`(right_node[, auto_broadcast, name])	Return node which applies f(x) = A/B to the input nodes element-wise.
`constructor_validate_and_infer_types`(self)
`evaluate`(args, *kwargs)	Overloaded function.
`get_attributes`(self)
`get_body`(self)
`get_concatenated_slices`(self, value, start, ...)
`get_element_type`(self)	Checks that there is exactly one output and returns it's element type.
`get_friendly_name`(self)	Gets the friendly name for a node.
`get_function`(self)
`get_input_descriptions`(self)
`get_input_element_type`(self, index)	Returns the element type for input index
`get_input_partial_shape`(self, index)	Returns the partial shape for input index
`get_input_shape`(self, index)	Returns the shape for input index
`get_input_size`(self)	Returns the number of inputs to the node.
`get_input_tensor`(self, index)	Returns the tensor for the node's input with index i
`get_instance_id`(self)	Returns id of the node.
`get_iter_value`(self, body_value, iteration)
`get_name`(self)	Get the unique name of the node
`get_num_iterations`(self)
`get_output_descriptions`(self)
`get_output_element_type`(self, index)	Returns the element type for output index
`get_output_partial_shape`(self, index)	Returns the partial shape for output index
`get_output_shape`(self, index)	Returns the shape for output index
`get_output_size`(self)	Returns the number of outputs from the node.
`get_output_tensor`(self, index)	Returns the tensor for output index
`get_rt_info`(self)	Returns PyRTMap which is a dictionary of user defined runtime info.
`get_type_info`(self)
`get_type_name`(self)	Returns Type's name from the node.
`input`(self, input_index)	A handle to the input_index input of this node.
`input_value`(self, index)	Returns input of the node with index i
`input_values`(self)	Returns list of node's inputs, in order.
`inputs`(self)	A list containing a handle for each of this node's inputs, in order.
`output`(self, output_index)	A handle to the output_index output of this node.
`outputs`(self)	A list containing a handle for each of this node's outputs, in order.
`set_argument`(self, arg0, arg1)
`set_arguments`(args, *kwargs)	Overloaded function.
`set_attribute`(self, arg0, arg1)
`set_body`(self, body)
`set_friendly_name`(self, name)	Sets a friendly name for a node.
`set_function`(self, func)
`set_input_descriptions`(self, inputs)
`set_invariant_input`(self, body_parameter, value)
`set_merged_input`(self, body_parameter, ...)
`set_output_descriptions`(self, outputs)
`set_output_size`(self, size)	Sets the number of outputs
`set_output_type`(self, index, element_type, shape)	Sets output's element type and shape.
`set_sliced_input`(self, parameter, value, ...)
`validate_and_infer_types`(self)	Verifies that attributes and inputs are consistent and computes output shapes and element types.

Attributes

`friendly_name`
`name`
`rt_info`
`shape`
`type_info`

__add__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which applies f(A,B) = A+B to the input nodes element-wise.

Parameters:

left_node – The first input node for add operation.
right_node – The second input node for add operation.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors. Defaults to “NUMPY”.
name – The optional name for output new node.

Returns:

The node performing element-wise addition.

__class__#: alias of pybind11_type

__delattr__(name, /)#: Implement delattr(self, name).

__dir__()#: Default dir() implementation.

__div__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which applies f(x) = A/B to the input nodes element-wise.

Parameters:

left_node – The node providing dividend data.
right_node – The node providing divisor data.
auto_broadcast – Specifies rules used for auto-broadcasting of input tensors.
name – Optional name for output node.

Returns:

The node performing element-wise division.

__eq__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which checks if input nodes are equal element-wise.

Parameters:

left_node – The first input node for equal operation.
right_node – The second input node for equal operation.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
name – The optional name for output new node.

Returns:

The node performing element-wise equality check.

__format__(format_spec, /)#: Default object formatter.

__ge__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which checks if left node is greater or equal to the right node element-wise.

Parameters:

left_node – The first input node providing data.
right_node – The second input node providing data.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
name – The optional new name for output node.

Returns:

The node performing element-wise check whether left_node is greater than or equal right_node.

__getattr__(self: openvino._pyopenvino.Node, arg0: str) → Callable#

__getattribute__(name, /)#: Return getattr(self, name).

__gt__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which checks if left input node is greater than the right node element-wise.

Parameters:

left_node – The first input node providing data.
right_node – The second input node providing data.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
name – The optional new name for output node.

Returns:

The node performing element-wise check whether left_node is greater than right_node.

__hash__()#: Return hash(self).

__init__(self: openvino._pyopenvino.op.tensor_iterator) → None#

__init_subclass__()#

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which checks if left input node is less or equal the right node element-wise.

Parameters:

left_node – The first input node providing data.
right_node – The second input node providing data.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
name – The optional new name for output node.

Returns:

The node performing element-wise check whether left_node is less than or equal the right_node.

__lt__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which checks if left input node is less than the right node element-wise.

Parameters:

left_node – The first input node providing data.
right_node – The second input node providing data.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
name – The optional new name for output node.

Returns:

The node performing element-wise check whether left_node is less than the right_node.

__mul__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which applies f(A,B) = A*B to the input nodes elementwise.

Parameters:

left_node – The first input node for multiply operation.
right_node – The second input node for multiply operation.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors. Defaults to “NUMPY”.
name – The optional name for output new node.

Returns:

The node performing element-wise multiplication.

__ne__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which checks if input nodes are unequal element-wise.

Parameters:

left_node – The first input node for not-equal operation.
right_node – The second input node for not-equal operation.
auto_broadcast – The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
name – The optional name for output new node.

Returns:

The node performing element-wise inequality check.

__new__(**kwargs)#

__radd__(right)#

__rdiv__(right)#

__reduce__()#: Helper for pickle.

__reduce_ex__(protocol, /)#: Helper for pickle.

__repr__(self: openvino._pyopenvino.op.tensor_iterator) → str#

__rmul__(right)#

__rsub__(right)#

__rtruediv__(right)#

__setattr__(name, value, /)#: Implement setattr(self, name, value).

__sizeof__()#: Size of object in memory, in bytes.

__str__()#: Return str(self).

__sub__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which applies f(x) = A-B to the input nodes element-wise.

Parameters:

left_node – The node providing data for left hand side of operator.
right_node – The node providing data for right hand side of operator.
auto_broadcast – The type of broadcasting that specifies mapping of input tensor axes to output shape axes. Range of values: numpy, explicit.
name – The optional name for output node.

Returns:

The new output node performing subtraction operation on both tensors element-wise.

__subclasshook__()#

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

__truediv__(right_node: Node | int | float | ndarray, auto_broadcast: str = 'NUMPY', name: str | None = None) → Node#

Return node which applies f(x) = A/B to the input nodes element-wise.

Parameters:

left_node – The node providing dividend data.
right_node – The node providing divisor data.
auto_broadcast – Specifies rules used for auto-broadcasting of input tensors.
name – Optional name for output node.

Returns:

The node performing element-wise division.

constructor_validate_and_infer_types(self: openvino._pyopenvino.Node) → None#

evaluate(*args, **kwargs)#

Overloaded function.

evaluate(self: openvino._pyopenvino.Node, output_values: list[ov::Tensor], input_values: list[ov::Tensor], evaluationContext: openvino._pyopenvino.RTMap) -> bool

Evaluate the node on inputs, putting results in outputs

param output_tensors:

Tensors for the outputs to compute. One for each result.

type output_tensors:

List[openvino.runtime.Tensor]

param input_tensors:

Tensors for the inputs. One for each inputs.

type input_tensors:

List[openvino.runtime.Tensor]

param evaluation_context:

Storage of additional settings and attributes that can be used

when evaluating the function. This additional information can be shared across nodes. :type evaluation_context: openvino.runtime.RTMap :rtype: bool
evaluate(self: openvino._pyopenvino.Node, output_values: list[ov::Tensor], input_values: list[ov::Tensor]) -> bool

Evaluate the function on inputs, putting results in outputs

param output_tensors:

Tensors for the outputs to compute. One for each result.

type output_tensors:

List[openvino.runtime.Tensor]

param input_tensors:

Tensors for the inputs. One for each inputs.

type input_tensors:

List[openvino.runtime.Tensor]

rtype:

bool

property friendly_name#

get_attributes(self: openvino._pyopenvino.Node) → dict#

get_body(self: openvino._pyopenvino.op.tensor_iterator) → object#

get_concatenated_slices(self: openvino._pyopenvino.op.tensor_iterator, value: ov::Output<ov::Node>, start: int, stride: int, part_size: int, end: int, axis: int) → ov::Output<ov::Node>#

get_element_type(self: openvino._pyopenvino.Node) → openvino._pyopenvino.Type#

Checks that there is exactly one output and returns it’s element type.

Returns:: Type of the output.
Return type:: openvino.runtime.Type

get_friendly_name(self: openvino._pyopenvino.Node) → str#

Gets the friendly name for a node. If no friendly name has been set via set_friendly_name then the node’s unique name is returned.

Returns:: Friendly name of the node.
Return type:: str

get_function(self: openvino._pyopenvino.op.tensor_iterator) → object#

get_input_descriptions(self: openvino._pyopenvino.op.tensor_iterator) → list#

get_input_element_type(self: openvino._pyopenvino.Node, index: int) → openvino._pyopenvino.Type#

Returns the element type for input index

Parameters:: index (int) – Index of the input.
Returns:: Type of the input index
Return type:: openvino.Type

get_input_partial_shape(self: openvino._pyopenvino.Node, index: int) → openvino._pyopenvino.PartialShape#

Returns the partial shape for input index

Parameters:: index (int) – Index of the input.
Returns:: PartialShape of the input index
Return type:: openvino.PartialShape

get_input_shape(self: openvino._pyopenvino.Node, index: int) → openvino._pyopenvino.Shape#

Returns the shape for input index

Parameters:: index (int) – Index of the input.
Returns:: Shape of the input index
Return type:: openvino.Shape

get_input_size(self: openvino._pyopenvino.Node) → int#

Returns the number of inputs to the node.

Returns:: Number of inputs.
Return type:: int

get_input_tensor(self: openvino._pyopenvino.Node, index: int) → ov::descriptor::Tensor#

Returns the tensor for the node’s input with index i

Parameters:: index (int) – Index of Input.
Returns:: Tensor of the input index
Return type:: openvino._pyopenvino.DescriptorTensor

get_instance_id(self: openvino._pyopenvino.Node) → int#

Returns id of the node. May be used to compare nodes if they are same instances.

Returns:: id of the node.
Return type:: int

get_iter_value(self: openvino._pyopenvino.op.tensor_iterator, body_value: ov::Output<ov::Node>, iteration: int = -1) → ov::Output<ov::Node>#

get_name(self: openvino._pyopenvino.Node) → str#

Get the unique name of the node

Returns:: Unique name of the node.
Return type:: str

get_num_iterations(self: openvino._pyopenvino.op.tensor_iterator) → int#

get_output_descriptions(self: openvino._pyopenvino.op.tensor_iterator) → list#

get_output_element_type(self: openvino._pyopenvino.Node, index: int) → openvino._pyopenvino.Type#

Returns the element type for output index

Parameters:: index (int) – Index of the output.
Returns:: Type of the output index
Return type:: openvino.runtime.Type

get_output_partial_shape(self: openvino._pyopenvino.Node, index: int) → openvino._pyopenvino.PartialShape#

Returns the partial shape for output index

Parameters:: index (int) – Index of the output.
Returns:: PartialShape of the output index
Return type:: openvino.runtime.PartialShape

get_output_shape(self: openvino._pyopenvino.Node, index: int) → openvino._pyopenvino.Shape#

Returns the shape for output index

Parameters:: index (int) – Index of the output.
Returns:: Shape of the output index
Return type:: openvino.runtime.Shape

get_output_size(self: openvino._pyopenvino.Node) → int#

Returns the number of outputs from the node.

Returns:: Number of outputs.
Return type:: int

get_output_tensor(self: openvino._pyopenvino.Node, index: int) → ov::descriptor::Tensor#

Returns the tensor for output index

Parameters:: index (int) – Index of the output.
Returns:: Tensor of the output index
Return type:: openvino._pyopenvino.DescriptorTensor

get_rt_info(self: openvino._pyopenvino.Node) → openvino._pyopenvino.RTMap#

Returns PyRTMap which is a dictionary of user defined runtime info.

Returns:: A dictionary of user defined data.
Return type:: openvino.runtime.RTMap

get_type_info(self: openvino._pyopenvino.Node) → ov::DiscreteTypeInfo#

get_type_name(self: openvino._pyopenvino.Node) → str#

Returns Type’s name from the node.

Returns:: String representing Type’s name.
Return type:: str

input(self: openvino._pyopenvino.Node, input_index: int) → ov::Input<ov::Node>#

A handle to the input_index input of this node.

Parameters:: input_index (int) – Index of Input.
Returns:: Input of this node.
Return type:: openvino.runtime.Input

input_value(self: openvino._pyopenvino.Node, index: int) → ov::Output<ov::Node>#

Returns input of the node with index i

Parameters:: index (int) – Index of Input.
Returns:: Input of this node.
Return type:: openvino.runtime.Input

input_values(self: openvino._pyopenvino.Node) → list[ov::Output<ov::Node>]#

Returns list of node’s inputs, in order.

Returns:: List of node’s inputs
Return type:: List[openvino.runtime.Input]

inputs(self: openvino._pyopenvino.Node) → list[ov::Input<ov::Node>]#

A list containing a handle for each of this node’s inputs, in order.

Returns:: List of node’s inputs.
Return type:: List[openvino.runtime.Input]

property name#

output(self: openvino._pyopenvino.Node, output_index: int) → ov::Output<ov::Node>#

A handle to the output_index output of this node.

Parameters:: output_index (int) – Index of Output.
Returns:: Output of this node.
Return type:: openvino.runtime.Output

outputs(self: openvino._pyopenvino.Node) → list[ov::Output<ov::Node>]#

A list containing a handle for each of this node’s outputs, in order.

Returns:: List of node’s outputs.
Return type:: List[openvino.runtime.Output]

property rt_info#

set_argument(self: openvino._pyopenvino.Node, arg0: int, arg1: ov::Output<ov::Node>) → None#

set_arguments(*args, **kwargs)#

Overloaded function.

set_arguments(self: openvino._pyopenvino.Node, arg0: list[openvino._pyopenvino.Node]) -> None
set_arguments(self: openvino._pyopenvino.Node, arg0: list[ov::Output<ov::Node>]) -> None

set_attribute(self: openvino._pyopenvino.Node, arg0: str, arg1: object) → None#

set_body(self: openvino._pyopenvino.op.tensor_iterator, body: ov::Model) → None#

set_friendly_name(self: openvino._pyopenvino.Node, name: str) → None#

Sets a friendly name for a node. This does not overwrite the unique name of the node and is retrieved via get_friendly_name(). Used mainly for debugging. The friendly name may be set exactly once.

Parameters:: name (str) – Friendly name to set.

set_function(self: openvino._pyopenvino.op.tensor_iterator, func: ov::Model) → None#

set_input_descriptions(self: openvino._pyopenvino.op.tensor_iterator, inputs: list) → None#

set_invariant_input(self: openvino._pyopenvino.op.tensor_iterator, body_parameter: openvino._pyopenvino.op.Parameter, value: ov::Output<ov::Node>) → None#

set_merged_input(self: openvino._pyopenvino.op.tensor_iterator, body_parameter: openvino._pyopenvino.op.Parameter, initial_value: ov::Output<ov::Node>, successive_value: ov::Output<ov::Node>) → None#

set_output_descriptions(self: openvino._pyopenvino.op.tensor_iterator, outputs: list) → None#

set_output_size(self: openvino._pyopenvino.Node, size: int) → None#

Sets the number of outputs

Parameters:: size (int) – number of outputs.

set_output_type(self: openvino._pyopenvino.Node, index: int, element_type: openvino._pyopenvino.Type, shape: openvino._pyopenvino.PartialShape) → None#

Sets output’s element type and shape.

Parameters:

index (int) – Index of the output.
element_type (openvino.Type) – Element type of the output.
shape (openvino.PartialShape) – Shape of the output.

set_sliced_input(self: openvino._pyopenvino.op.tensor_iterator, parameter: openvino._pyopenvino.op.Parameter, value: ov::Output<ov::Node>, start: int, stride: int, part_size: int, end: int, axis: int) → None#

property shape#

property type_info#

validate_and_infer_types(self: openvino._pyopenvino.Node) → None#

Verifies that attributes and inputs are consistent and computes output shapes and element types. Must be implemented by concrete child classes so that it can be run any number of times.

Throws if the node is invalid.