openvino.runtime.opset10

Functions

abs(node[, name])

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

absolute(node[, name])

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

acos(node[, name])

Apply inverse cosine function on the input node element-wise.

acosh(node[, name])

Apply hyperbolic inverse cosine function on the input node element-wise.

adaptive_avg_pool(data, output_shape)

Return a node which performs AdaptiveAvgPool operation.

adaptive_max_pool(data, output_shape[, ...])

Return a node which performs AdaptiveMaxPool operation.

add(left_node, right_node[, auto_broadcast, ...])

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

asin(node[, name])

Apply inverse sine function on the input node element-wise.

asinh(node[, name])

Apply hyperbolic inverse sinus function on the input node element-wise.

assign(new_value, variable_id[, name])

Return a node which produces the Assign operation.

atan(node[, name])

Apply inverse tangent function on the input node element-wise.

atanh(node[, name])

Apply hyperbolic inverse tangent function on the input node element-wise.

avg_pool(data_batch, strides, pads_begin, ...)

Return average pooling node.

batch_norm_inference(data, gamma, beta, ...)

Perform layer normalizes a input tensor by mean and variance with appling scale and offset.

batch_to_space(data, block_shape, ...[, name])

Perform BatchToSpace operation on the input tensor.

binary_convolution(data, filters, strides, ...)

Create node performing convolution with binary weights, binary input and integer output.

broadcast(data, target_shape[, ...])

Create a node which broadcasts the input node's values along specified axes to a desired shape.

bucketize(data, buckets[, output_type, ...])

Return a node which produces the Bucketize operation.

ceil(node[, name])

Return node which applies ceiling to the input node element-wise.

ceiling(node[, name])

Return node which applies ceiling to the input node element-wise.

clamp(data, min_value, max_value[, name])

Perform clamp element-wise on data from input node.

concat(nodes, axis[, name])

Concatenate input nodes into single new node along specified axis.

constant(value[, dtype, name])

Create a Constant node from provided value.

convert(data, destination_type[, name])

Return node which casts input node values to specified type.

convert_like(data, like[, name])

Return node which casts data node values to the type of another node.

convolution(data, filters, strides, ...[, ...])

Return node performing batched convolution operation.

convolution_backprop_data(data, filters, strides)

Create node performing a batched-convolution backprop data operation.

cos(node[, name])

Apply cosine function on the input node element-wise.

cosh(node[, name])

Apply hyperbolic cosine function on the input node element-wise.

ctc_greedy_decoder(data, sequence_mask[, ...])

Perform greedy decoding on the logits given in input (best path).

ctc_greedy_decoder_seq_len(data, sequence_length)

Return a node which performs CTCGreedyDecoderSeqLen.

ctc_loss(logits, logit_length, labels, ...)

Return a node which performs CTCLoss.

cum_sum(arg, axis[, exclusive, reverse, name])

Construct a cumulative summation operation.

cumsum(arg, axis[, exclusive, reverse, name])

Construct a cumulative summation operation.

deformable_convolution(data, offsets, ...[, ...])

Return a node which performs deformable convolution operation.

deformable_psroi_pooling(feature_maps, ...)

Return node performing DeformablePSROIPooling operation.

depth_to_space(node, mode[, block_size, name])

Rearranges input tensor from depth into blocks of spatial data.

detection_output(box_logits, class_preds, ...)

Generate the detection output using information on location and confidence predictions.

dft(data, axes[, signal_size])

Return a node which performs DFT operation.

divide(left_node, right_node[, ...])

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

einsum(inputs, equation)

Return a node which performs Einsum operation.

elu(data, alpha[, name])

Perform Exponential Linear Unit operation element-wise on data from input node.

embedding_bag_offsets_sum(emb_table, ...[, ...])

Return a node which performs sums of bags of embeddings without the intermediate embeddings.

embedding_bag_packed_sum(emb_table, indices)

Return an EmbeddingBagPackedSum node.

embedding_segments_sum(emb_table, indices, ...)

Return an EmbeddingSegmentsSum node.

equal(left_node, right_node[, ...])

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

erf(node[, name])

Return node which calculates Gauss error function element-wise with given tensor.

exp(node[, name])

Return node which applies exponential function to the input node element-wise.

extract_image_patches(image, sizes, strides, ...)

Return a node which produces the ExtractImagePatches operation.

eye(num_rows, num_columns, diagonal_index, ...)

Return a node which performs eye operation.

fake_quantize(data, input_low, input_high, ...)

Perform an element-wise linear quantization on input data.

floor(node[, name])

Return node which applies floor to the input node element-wise.

floor_mod(left_node, right_node[, ...])

Return node performing element-wise FloorMod (division reminder) with two given tensors.

gather(data, indices, axis[, batch_dims])

Return a node which performs Gather with support of negative indices.

gather_elements(data, indices[, axis, name])

Return a node which performs GatherElements.

gather_nd(data, indices[, batch_dims, name])

Return a node which performs GatherND.

gather_tree(step_ids, parent_idx, ...[, name])

Perform GatherTree operation.

gelu(data, approximation_mode[, name])

Return a node which performs Gelu activation function.

generate_proposals(im_info, anchors, deltas, ...)

Return a node which performs GenerateProposals operation.

greater(left_node, right_node[, ...])

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

greater_equal(left_node, right_node[, ...])

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

grid_sample(data, grid, attributes[, name])

Return a node which performs GridSample operation.

grn(data, bias[, name])

Perform Global Response Normalization with L2 norm (across channels only).

group_convolution(data, filters, strides, ...)

Perform Group Convolution operation on data from input node.

group_convolution_backprop_data(data, ...[, ...])

Perform Group Convolution operation on data from input node.

gru_cell(X, initial_hidden_state, W, R, B, ...)

Perform GRUCell operation on the tensor from input node.

gru_sequence(X, initial_hidden_state, ...[, ...])

Return a node which performs GRUSequence operation.

hard_sigmoid(data, alpha, beta[, name])

Perform Hard Sigmoid operation element-wise on data from input node.

hsigmoid(data[, name])

Return a node which performs HSigmoid.

hswish(data[, name])

Return a node which performs HSwish (hard version of Swish).

i420_to_bgr(arg[, arg_u, arg_v, name])

Return a node which performs I420toBGR operation.

i420_to_rgb(arg[, arg_u, arg_v, name])

Return a node which performs I420toRGB operation.

idft(data, axes[, signal_size])

Return a node which performs IDFT operation.

interpolate(image, output_shape, scales, ...)

Perform interpolation of independent slices in input tensor.

irdft(data, axes[, signal_size])

Return a node which performs IRDFT operation.

is_finite(data[, name])

Performs element-wise mapping from NaN and Infinity to False.

is_inf(data[, attributes, name])

Return a node which performs IsInf operation.

is_nan(data[, name])

Performs element-wise mapping from NaN to True.

less(left_node, right_node[, ...])

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

less_equal(left_node, right_node[, ...])

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

log(node[, name])

Return node which applies natural logarithm to the input node element-wise.

log_softmax(data, axis[, name])

Apply LogSoftmax operation on each element of input tensor.

logical_and(left_node, right_node[, ...])

Return node which perform logical and operation on input nodes element-wise.

logical_not(node[, name])

Return node which applies element-wise logical negation to the input node.

logical_or(left_node, right_node[, ...])

Return node which performs logical OR operation on input nodes element-wise.

logical_xor(left_node, right_node[, ...])

Return node which performs logical XOR operation on input nodes element-wise.

lrn(data, axes[, alpha, beta, bias, size, name])

Return a node which performs element-wise Local Response Normalization (LRN) operation.

lstm_cell(X, initial_hidden_state, ...[, ...])

Return a node which performs LSTMCell operation.

lstm_sequence(X, initial_hidden_state, ...)

Return a node which performs LSTMSequence operation.

matmul(data_a, data_b, transpose_a, transpose_b)

Return the Matrix Multiplication operation.

matrix_nms(boxes, scores[, ...])

Return a node which performs MatrixNms.

max_pool(data, strides, dilations, ...[, ...])

Perform max pooling operation and return both values and indices of the selected elements.

maximum(left_node, right_node[, ...])

Return node which applies the maximum operation to input nodes elementwise.

minimum(left_node, right_node[, ...])

Return node which applies the minimum operation to input nodes elementwise.

mish(data[, name])

Return a node which performs Mish.

mod(left_node, right_node[, auto_broadcast, ...])

Return node performing element-wise division reminder with two given tensors.

multiclass_nms(boxes, scores[, roisnum, ...])

Return a node which performs MulticlassNms.

multiply(left_node, right_node[, ...])

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

mvn(data, axes, normalize_variance, eps, ...)

Return a node which performs MeanVarianceNormalization (MVN).

negative(node[, name])

Return node which applies f(x) = -x to the input node elementwise.

non_max_suppression(boxes, scores[, ...])

Return a node which performs NonMaxSuppression.

non_zero(data[, output_type, name])

Return the indices of the elements that are non-zero.

normalize_l2(data, axes, eps, eps_mode[, name])

Construct an NormalizeL2 operation.

not_equal(left_node, right_node[, ...])

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

nv12_to_bgr(arg[, arg_uv, name])

Return a node which performs NV12toBGR operation.

nv12_to_rgb(arg[, arg_uv, name])

Return a node which performs NV12toRGB operation.

one_hot(indices, depth, on_value, off_value, ...)

Create node performing one-hot encoding on input data.

pad(arg, pads_begin, pads_end, pad_mode[, ...])

Return a generic padding operation.

parameter(shape[, dtype, name])

Return an openvino Parameter object.

power(left_node, right_node[, ...])

Return node which perform element-wise exponentiation operation.

prelu(data, slope[, name])

Perform Parametrized Relu operation element-wise on data from input node.

prior_box(layer_shape, image_shape, attrs[, ...])

Generate prior boxes of specified sizes and aspect ratios across all dimensions.

prior_box_clustered(output_size, image_size, ...)

Generate prior boxes of specified sizes normalized to the input image size.

proposal(class_probs, bbox_deltas, ...[, name])

Filter bounding boxes and outputs only those with the highest prediction confidence.

psroi_pooling(input, coords, output_dim, ...)

Return a node which produces a PSROIPooling operation.

random_uniform(output_shape, min_val, ...[, ...])

Return a node which generates sequence of random values from uniform distribution.

range(start, stop, step[, name])

Return a node which produces the Range operation.

rdft(data, axes[, signal_size])

Return a node which performs RDFT operation.

read_value(init_value, variable_id[, name])

Return a node which produces the Assign operation.

reduce_l1(node, reduction_axes[, keep_dims, ...])

L1-reduction operation on input tensor, eliminating the specified reduction axes.

reduce_l2(node, reduction_axes[, keep_dims, ...])

L2-reduction operation on input tensor, eliminating the specified reduction axes.

reduce_logical_and(node, reduction_axes[, ...])

Logical AND reduction operation on input tensor, eliminating the specified reduction axes.

reduce_logical_or(node, reduction_axes[, ...])

Logical OR reduction operation on input tensor, eliminating the specified reduction axes.

reduce_max(node, reduction_axes[, ...])

Max-reduction operation on input tensor, eliminating the specified reduction axes.

reduce_mean(node, reduction_axes[, ...])

Mean-reduction operation on input tensor, eliminating the specified reduction axes.

reduce_min(node, reduction_axes[, ...])

Min-reduction operation on input tensor, eliminating the specified reduction axes.

reduce_prod(node, reduction_axes[, ...])

Product-reduction operation on input tensor, eliminating the specified reduction axes.

reduce_sum(node, reduction_axes[, ...])

Perform element-wise sums of the input tensor, eliminating the specified reduction axes.

region_yolo(input, coords, classes, num, ...)

Return a node which produces the RegionYolo operation.

relu(node[, name])

Perform rectified linear unit operation on input node element-wise.

reorg_yolo(input, stride[, name])

Return a node which produces the ReorgYolo operation.

reshape(node, output_shape, special_zero[, name])

Return reshaped node according to provided parameters.

result(data[, name])

Return a node which represents an output of a graph (Model).

reverse_sequence(input, seq_lengths, ...[, name])

Return a node which produces a ReverseSequence operation.

rnn_cell(X, initial_hidden_state, W, R, B, ...)

Perform RNNCell operation on tensor from input node.

rnn_sequence(X, initial_hidden_state, ...[, ...])

Return a node which performs RNNSequence operation.

roi_align(data, rois, batch_indices, ...[, ...])

Return a node which performs ROIAlign operation.

roi_pooling(input, coords, output_size, ...)

Return a node which produces an ROIPooling operation.

roll(data, shift, axes)

Return a node which performs Roll operation.

round(data[, mode, name])

Apply Round operation on each element of input tensor.

scatter_elements_update(data, indices, ...)

Return a node which produces a ScatterElementsUpdate operation.

scatter_update(data, indices, updates, axis)

Return a node which produces a ScatterUpdate operation.

select(cond, then_node, else_node[, ...])

Perform an element-wise selection operation on input tensors.

selu(data, alpha, lambda_value[, name])

Perform a Scaled Exponential Linear Unit (SELU) operation on input node element-wise.

shape_of(data[, output_type, name])

Return a node which produces a tensor containing the shape of its input data.

shuffle_channels(data, axis, group[, name])

Perform permutation on data in the channel dimension of the input tensor.

sigmoid(data[, name])

Return a node which applies the sigmoid function element-wise.

sign(node[, name])

Perform element-wise sign operation.

sin(node[, name])

Apply sine function on the input node element-wise.

sinh(node[, name])

Apply hyperbolic sine function on the input node element-wise.

slice(data, start, stop, step[, axes, name])

Return a node which generates Slice operation.

softmax(data, axis[, name])

Apply softmax operation on each element of input tensor.

softplus(data[, name])

Apply SoftPlus operation on each element of input tensor.

softsign(node[, name])

Apply SoftSign operation on the input node element-wise.

space_to_batch(data, block_shape, ...[, name])

Perform SpaceToBatch operation on the input tensor.

space_to_depth(data, mode[, block_size, name])

Perform SpaceToDepth operation on the input tensor.

split(data, axis, num_splits[, name])

Return a node which splits the input tensor into same-length slices.

sqrt(node[, name])

Return node which applies square root to the input node element-wise.

squared_difference(x1, x2[, auto_broadcast, ...])

Perform an element-wise squared difference between two tensors.

squeeze(data, axes[, name])

Perform squeeze operation on input tensor.

strided_slice(data, begin, end, strides, ...)

Return a node which dynamically repeats(replicates) the input data tensor.

subtract(left_node, right_node[, ...])

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

swish(data[, beta, name])

Return a node which performing Swish activation function Swish(x, beta=1.0) = x * sigmoid(x * beta)).

tan(node[, name])

Apply tangent function on the input node element-wise.

tanh(node[, name])

Return node which applies hyperbolic tangent to the input node element-wise.

tile(data, repeats[, name])

Return a node which dynamically repeats(replicates) the input data tensor.

topk(data, k, axis, mode, sort[, ...])

Return a node which performs TopK.

transpose(data, input_order[, name])

Return a node which transposes the data in the input tensor.

unique(data[, axis, sorted, ...])

Operator which selects and returns unique elements or unique slices of the input tensor.

unsqueeze(data, axes[, name])

Perform unsqueeze operation on input tensor.

variadic_split(data, axis, split_lengths[, name])

Return a node which splits the input tensor into variadic length slices.

Classes

if_op

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

loop

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

tensor_iterator

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