Functions | |
| Node | absolute (NodeInput node, Optional[str] name=None) |
| Return node which applies f(x) = abs(x) to the input node element-wise. More... | |
| Node | acos (NodeInput node, Optional[str] name=None) |
| Apply inverse cosine function on the input node element-wise. More... | |
| Node | add (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which applies f(x) = A+B to the input nodes element-wise. More... | |
| Node | asin (NodeInput node, Optional[str] name=None) |
| Apply inverse sine function on the input node element-wise. More... | |
| Node | atan (NodeInput node, Optional[str] name=None) |
| Apply inverse tangent function on the input node element-wise. More... | |
| Node | avg_pool (NodeInput data_batch, List[int] strides, TensorShape pads_begin, TensorShape pads_end, TensorShape kernel_shape, bool exclude_pad, str rounding_type="floor", Optional[str] auto_pad=None, Optional[str] name=None) |
| Return average pooling node. More... | |
| Node | batch_norm_inference (NodeInput data, NodeInput gamma, NodeInput beta, NodeInput mean, NodeInput variance, float epsilon, Optional[str] name=None) |
| Perform layer normalizes a input tensor by mean and variance with appling scale and offset. More... | |
| Node | binary_convolution (NodeInput data, NodeInput filters, List[int] strides, List[int] pads_begin, List[int] pads_end, List[int] dilations, str mode, float pad_value, str auto_pad="EXPLICIT", Optional[str] name=None) |
| Create node performing convolution with binary weights, binary input and integer output. More... | |
| Node | broadcast (NodeInput data, NodeInput target_shape, Optional[NodeInput] axes_mapping=None, str mode="NUMPY", Optional[str] name=None) |
| Create a node which broadcasts the input node's values along specified axes to a desired shape. More... | |
| Node | ctc_greedy_decoder (NodeInput data, NodeInput sequence_mask, bool merge_repeated=True, Optional[str] name=None) |
| Perform greedy decoding on the logits given in input (best path). More... | |
| Node | ceiling (NodeInput node, Optional[str] name=None) |
| Return node which applies ceiling to the input node element-wise. More... | |
| Node | clamp (NodeInput data, ScalarData min_value, ScalarData max_value, Optional[str] name=None) |
| Perform clamp element-wise on data from input node. More... | |
| Node | concat (List[NodeInput] nodes, int axis, Optional[str] name=None) |
| Concatenate input nodes into single new node along specified axis. More... | |
| Constant | constant (NumericData value, NumericType dtype=None, Optional[str] name=None) |
| Create a Constant node from provided value. More... | |
| Node | convert (NodeInput data, Union[str, NumericType] destination_type, Optional[str] name=None) |
| Return node which casts input node values to specified type. More... | |
| Node | convert_like (NodeInput data, NodeInput like, Optional[str] name=None) |
| Return node which casts data node values to the type of another node. More... | |
| Node | convolution (NodeInput data, NodeInput filters, List[int] strides, List[int] pads_begin, List[int] pads_end, List[int] dilations, str auto_pad="EXPLICIT", Optional[str] name=None) |
| Return node performing batched convolution operation. More... | |
| Node | convolution_backprop_data (NodeInput data, NodeInput filters, List[int] strides, Optional[NodeInput] output_shape=None, Optional[List[int]] pads_begin=None, Optional[List[int]] pads_end=None, Optional[List[int]] dilations=None, Optional[str] auto_pad=None, Optional[List[int]] output_padding=None, Optional[str] name=None) |
| Create node performing a batched-convolution backprop data operation. More... | |
| Node | cos (NodeInput node, Optional[str] name=None) |
| Apply cosine function on the input node element-wise. More... | |
| Node | cosh (NodeInput node, Optional[str] name=None) |
| Apply hyperbolic cosine function on the input node element-wise. More... | |
| Node | deformable_convolution (NodeInput data, NodeInput deformable_values, NodeInput filters, List[int] strides, List[int] pads_begin, List[int] pads_end, List[int] dilations, str auto_pad="EXPLICIT", int group=1, int deformable_group=1, Optional[str] name=None) |
| Create node performing deformable convolution. More... | |
| Node | deformable_psroi_pooling (NodeInput feature_maps, NodeInput coords, int output_dim, float spatial_scale, int group_size=1, str mode="bilinear_deformable", int spatial_bins_x=1, int spatial_bins_y=1, float trans_std=1.0, int part_size=1, Optional[NodeInput] offsets=None, Optional[str] name=None) |
| Return node performing DeformablePSROIPooling operation. More... | |
| Node | depth_to_space (Node node, str mode, int block_size=1, str name=None) |
| Rearranges input tensor from depth into blocks of spatial data. More... | |
| Node | detection_output (Node box_logits, Node class_preds, Node proposals, dict attrs, NodeInput aux_class_preds=None, NodeInput aux_box_preds=None, Optional[str] name=None) |
| Generate the detection output using information on location and confidence predictions. More... | |
| Node | divide (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which applies f(x) = A/B to the input nodes element-wise. More... | |
| Node | elu (NodeInput data, NumericType alpha, Optional[str] name=None) |
| Perform Exponential Linear Unit operation element-wise on data from input node. More... | |
| Node | equal (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which checks if input nodes are equal element-wise. More... | |
| Node | erf (NodeInput node, Optional[str] name=None) |
| Return node which calculates Gauss error function element-wise with given tensor. More... | |
| Node | exp (NodeInput node, Optional[str] name=None) |
| Return node which applies exponential function to the input node element-wise. More... | |
| Node | fake_quantize (NodeInput data, NodeInput input_low, NodeInput input_high, NodeInput output_low, NodeInput output_high, int levels, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Perform an element-wise linear quantization on input data. More... | |
| Node | floor (NodeInput node, Optional[str] name=None) |
| Return node which applies floor to the input node element-wise. More... | |
| Node | floor_mod (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node performing element-wise FloorMod (division reminder) with two given tensors. More... | |
| Node | gather (NodeInput data, NodeInput indices, NodeInput axis, Optional[str] name=None) |
| Return Gather node which takes slices from axis of data according to indices. More... | |
| Node | gather_tree (NodeInput step_ids, NodeInput parent_idx, NodeInput max_seq_len, NodeInput end_token, Optional[str] name=None) |
| Perform GatherTree operation. More... | |
| Node | greater (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which checks if left input node is greater than the right node element-wise. More... | |
| Node | greater_equal (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which checks if left node is greater or equal to the right node element-wise. More... | |
| Node | grn (Node data, float bias, Optional[str] name=None) |
| Perform Global Response Normalization with L2 norm (across channels only). More... | |
| Node | group_convolution (NodeInput data, NodeInput filters, List[int] strides, List[int] pads_begin, List[int] pads_end, List[int] dilations, str auto_pad="EXPLICIT", Optional[str] name=None) |
| Perform Group Convolution operation on data from input node. More... | |
| Node | group_convolution_backprop_data (NodeInput data, NodeInput filters, List[int] strides, Optional[NodeInput] output_shape=None, Optional[List[int]] pads_begin=None, Optional[List[int]] pads_end=None, Optional[List[int]] dilations=None, str auto_pad="EXPLICIT", Optional[List[int]] output_padding=None, Optional[str] name=None) |
| Perform Group Convolution operation on data from input node. More... | |
| Node | hard_sigmoid (Node data, NodeInput alpha, NodeInput beta, Optional[str] name=None) |
| Perform Hard Sigmoid operation element-wise on data from input node. More... | |
| Node | interpolate (Node image, NodeInput output_shape, dict attrs, Optional[str] name=None) |
| Perform interpolation of independent slices in input tensor. More... | |
| Node | less (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which checks if left input node is less than the right node element-wise. More... | |
| Node | less_equal (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which checks if left input node is less or equal the right node element-wise. More... | |
| Node | log (NodeInput node, Optional[str] name=None) |
| Return node which applies natural logarithm to the input node element-wise. More... | |
| Node | logical_and (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which perform logical and operation on input nodes element-wise. More... | |
| Node | logical_not (NodeInput node, Optional[str] name=None) |
| Return node which applies element-wise logical negation to the input node. More... | |
| Node | logical_or (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which performs logical OR operation on input nodes element-wise. More... | |
| Node | logical_xor (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which performs logical XOR operation on input nodes element-wise. More... | |
| Node | lrn (NodeInput data, NodeInput axes, float alpha=1, float beta=0.5, float bias=1, int size=5, Optional[str] name=None) |
| Return a node which performs element-wise Local Response Normalization (LRN) operation. More... | |
| Node | lstm_cell (NodeInput X, NodeInput initial_hidden_state, NodeInput initial_cell_state, NodeInput W, NodeInput R, NodeInput B, int hidden_size, List[str] activations=None, List[float] activations_alpha=None, List[float] activations_beta=None, float clip=0.0, Optional[str] name=None) |
| Return a node which performs LSTMCell operation. More... | |
| Node | lstm_sequence (NodeInput X, NodeInput initial_hidden_state, NodeInput initial_cell_state, NodeInput sequence_lengths, NodeInput W, NodeInput R, NodeInput B, int hidden_size, str direction, List[str] activations=None, List[float] activations_alpha=None, List[float] activations_beta=None, float clip=0.0, Optional[str] name=None) |
| Return a node which performs LSTMSequence operation. More... | |
| Node | matmul (NodeInput data_a, NodeInput data_b, bool transpose_a, bool transpose_b, Optional[str] name=None) |
| Return the Matrix Multiplication operation. More... | |
| Node | max_pool (NodeInput data, List[int] strides, List[int] pads_begin, List[int] pads_end, TensorShape kernel_shape, str rounding_type="floor", Optional[str] auto_pad=None, Optional[str] name=None) |
| Perform max pooling operation with given parameters on provided data. More... | |
| Node | maximum (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which applies the maximum operation to input nodes elementwise. More... | |
| Node | minimum (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which applies the minimum operation to input nodes elementwise. More... | |
| Node | mod (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node performing element-wise division reminder with two given tensors. More... | |
| Node | multiply (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which applies f(x) = A*B to the input nodes elementwise. More... | |
| Node | negative (NodeInput node, Optional[str] name=None) |
| Return node which applies f(x) = -x to the input node elementwise. More... | |
| Node | non_max_suppression (NodeInput boxes, NodeInput scores, Optional[NodeInput] max_output_boxes_per_class=None, Optional[NodeInput] iou_threshold=None, Optional[NodeInput] score_threshold=None, str box_encoding="corner", bool sort_result_descending=True, Optional[str] name=None) |
| Return a node which performs NonMaxSuppression. More... | |
| Node | normalize_l2 (NodeInput data, NodeInput axes, float eps, str eps_mode, Optional[str] name=None) |
| Construct an NormalizeL2 operation. More... | |
| Node | not_equal (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which checks if input nodes are unequal element-wise. More... | |
| Node | one_hot (NodeInput indices, NodeInput depth, NodeInput on_value, NodeInput off_value, int axis, Optional[str] name=None) |
| Create node performing one-hot encoding on input data. More... | |
| Node | pad (NodeInput arg, NodeInput pads_begin, NodeInput pads_end, str pad_mode, Optional[NodeInput] arg_pad_value=None, Optional[str] name=None) |
| Return a generic padding operation. More... | |
| Parameter | parameter (TensorShape shape, NumericType dtype=np.float32, Optional[str] name=None) |
| Return an ngraph Parameter object. More... | |
| Node | power (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which perform element-wise exponentiation operation. More... | |
| Node | prelu (NodeInput data, NodeInput slope, Optional[str] name=None) |
| Perform Parametrized Relu operation element-wise on data from input node. More... | |
| Node | prior_box_clustered (Node output_size, NodeInput image_size, dict attrs, Optional[str] name=None) |
| Generate prior boxes of specified sizes normalized to the input image size. More... | |
| Node | prior_box (Node layer_shape, NodeInput image_shape, dict attrs, Optional[str] name=None) |
| Generate prior boxes of specified sizes and aspect ratios across all dimensions. More... | |
| Node | proposal (Node class_probs, Node bbox_deltas, NodeInput image_shape, dict attrs, Optional[str] name=None) |
| Filter bounding boxes and outputs only those with the highest prediction confidence. More... | |
| Node | psroi_pooling (NodeInput input, NodeInput coords, int output_dim, int group_size, float spatial_scale, int spatial_bins_x, int spatial_bins_y, str mode, Optional[str] name=None) |
| Return a node which produces a PSROIPooling operation. More... | |
| Node | range (Node start, NodeInput stop, NodeInput step, Optional[str] name=None) |
| Return a node which produces the Range operation. More... | |
| Node | relu (NodeInput node, Optional[str] name=None) |
| Perform rectified linear unit operation on input node element-wise. More... | |
| Node | reduce_logical_and (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Logical AND reduction operation on input tensor, eliminating the specified reduction axes. More... | |
| Node | reduce_logical_or (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Logical OR reduction operation on input tensor, eliminating the specified reduction axes. More... | |
| Node | reduce_max (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Max-reduction operation on input tensor, eliminating the specified reduction axes. More... | |
| Node | reduce_mean (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Mean-reduction operation on input tensor, eliminating the specified reduction axes. More... | |
| Node | reduce_min (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Min-reduction operation on input tensor, eliminating the specified reduction axes. More... | |
| Node | reduce_prod (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Product-reduction operation on input tensor, eliminating the specified reduction axes. More... | |
| Node | reduce_sum (NodeInput node, NodeInput reduction_axes, bool keep_dims=False, Optional[str] name=None) |
| Perform element-wise sums of the input tensor, eliminating the specified reduction axes. More... | |
| Node | region_yolo (Node input, int coords, int classes, int num, bool do_softmax, List[int] mask, int axis, int end_axis, List[float] anchors=None, Optional[str] name=None) |
| Return a node which produces the RegionYolo operation. More... | |
| Node | reshape (NodeInput node, NodeInput output_shape, bool special_zero, Optional[str] name=None) |
| Return reshaped node according to provided parameters. More... | |
| Node | result (NodeInput data, Optional[str] name=None) |
| Return a node which represents an output of a graph (Function). More... | |
| Node | reverse_sequence (NodeInput input, NodeInput seq_lengths, NumericData batch_axis, NumericData seq_axis, Optional[str] name=None) |
| Return a node which produces a ReverseSequence operation. More... | |
| Node | select (NodeInput cond, NodeInput then_node, NodeInput else_node, str auto_broadcast="numpy", Optional[str] name=None) |
| Perform an element-wise selection operation on input tensors. More... | |
| Node | selu (NodeInput data, NodeInput alpha, NodeInput lambda_value, Optional[str] name=None) |
| Perform a Scaled Exponential Linear Unit (SELU) operation on input node element-wise. More... | |
| Node | shape_of (NodeInput data, Optional[str] name=None) |
| Return a node which produces a tensor containing the shape of its input data. More... | |
| Node | sigmoid (NodeInput data, Optional[str] name=None) |
| Return a node which applies the sigmoid function element-wise. More... | |
| Node | sign (NodeInput node, Optional[str] name=None) |
| Perform element-wise sign operation. More... | |
| Node | sin (NodeInput node, Optional[str] name=None) |
| Apply sine function on the input node element-wise. More... | |
| Node | sinh (NodeInput node, Optional[str] name=None) |
| Apply hyperbolic sine function on the input node element-wise. More... | |
| Node | softmax (NodeInput data, int axis, Optional[str] name=None) |
| Apply softmax operation on each element of input tensor. More... | |
| Node | space_to_depth (Node data, str mode, int block_size=1, str name=None) |
| Perform SpaceToDepth operation on the input tensor. More... | |
| Node | split (NodeInput data, NodeInput axis, int num_splits, Optional[str] name=None) |
| Return a node which splits the input tensor into same-length slices. More... | |
| Node | sqrt (NodeInput node, Optional[str] name=None) |
| Return node which applies square root to the input node element-wise. More... | |
| Node | squared_difference (NodeInput x1, NodeInput x2, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Perform an element-wise squared difference between two tensors. More... | |
| Node | squeeze (NodeInput data, NodeInput axes, Optional[str] name=None) |
| Perform squeeze operation on input tensor. More... | |
| Node | strided_slice (NodeInput data, NodeInput begin, NodeInput end, NodeInput strides, List[int] begin_mask, List[int] end_mask, Optional[List[int]] new_axis_mask=None, Optional[List[int]] shrink_axis_mask=None, Optional[List[int]] ellipsis_mask=None, Optional[str] name=None) |
| Return a node which dynamically repeats(replicates) the input data tensor. More... | |
| Node | subtract (NodeInput left_node, NodeInput right_node, str auto_broadcast="NUMPY", Optional[str] name=None) |
| Return node which applies f(x) = A-B to the input nodes element-wise. More... | |
| Node | tan (NodeInput node, Optional[str] name=None) |
| Apply tangent function on the input node element-wise. More... | |
| Node | tanh (NodeInput node, Optional[str] name=None) |
| Return node which applies hyperbolic tangent to the input node element-wise. More... | |
| Node | tensor_iterator (List[Node] inputs, GraphBody graph_body, List[TensorIteratorSliceInputDesc] slice_input_desc, List[TensorIteratorMergedInputDesc] merged_input_desc, List[TensorIteratorInvariantInputDesc] invariant_input_desc, List[TensorIteratorBodyOutputDesc] body_output_desc, List[TensorIteratorConcatOutputDesc] concat_output_desc, Optional[str] name=None) |
| Perform recurrent execution of the network described in the body, iterating through the data. More... | |
| Node | tile (NodeInput data, NodeInput repeats, Optional[str] name=None) |
| Return a node which dynamically repeats(replicates) the input data tensor. More... | |
| Node | topk (NodeInput data, NodeInput k, int axis, str mode, str sort, Optional[str] name=None) |
| Return a node which performs TopK. More... | |
| Node | transpose (NodeInput data, NodeInput input_order, Optional[str] name=None) |
| Return a node which transposes the data in the input tensor. More... | |
| Node | unsqueeze (NodeInput data, NodeInput axes, Optional[str] name=None) |
| Perform unsqueeze operation on input tensor. More... | |
| Node | variadic_split (NodeInput data, NodeInput axis, NodeInput split_lengths, Optional[str] name=None) |
| Return a node which splits the input tensor into variadic length slices. More... | |
| Node ngraph.opset1.ops.absolute | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies f(x) = abs(x) to the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with Abs operation applied on it.
| Node ngraph.opset1.ops.acos | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply inverse cosine function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with arccos operation applied on it.
| Node ngraph.opset1.ops.add | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which applies f(x) = A+B to the input nodes element-wise.
| Node ngraph.opset1.ops.asin | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply inverse sine function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with arcsin operation applied on it.
| Node ngraph.opset1.ops.atan | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply inverse tangent function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with arctan operation applied on it.
| Node ngraph.opset1.ops.avg_pool | ( | NodeInput | data_batch, |
| List[int] | strides, | ||
| TensorShape | pads_begin, | ||
| TensorShape | pads_end, | ||
| TensorShape | kernel_shape, | ||
| bool | exclude_pad, | ||
| str | rounding_type = "floor", |
||
| Optional[str] | auto_pad = None, |
||
| Optional[str] | name = None |
||
| ) |
Return average pooling node.
@param data_batch: The input node providing data.
@param strides: The window movement strides.
@param pads_begin: The input data optional padding below filled with zeros.
@param pads_end: The input data optional padding below filled with zeros.
@param kernel_shape: The pooling window shape.
@param exclude_pad: Whether or not to include zero padding in average computations.
@param rounding_type: Determines used rounding schema when computing output shape. Acceptable
values are: ['floor', 'ceil']
@param auto_pad: Determines how the padding is calculated. Acceptable values:
[None, 'same_upper', 'same_lower', 'valid']
@param name: Optional name for the new output node.
@return New node with AvgPool operation applied on its data.
| Node ngraph.opset1.ops.batch_norm_inference | ( | NodeInput | data, |
| NodeInput | gamma, | ||
| NodeInput | beta, | ||
| NodeInput | mean, | ||
| NodeInput | variance, | ||
| float | epsilon, | ||
| Optional[str] | name = None |
||
| ) |
Perform layer normalizes a input tensor by mean and variance with appling scale and offset.
@param data: The input tensor with data for normalization.
@param gamma: The scalar scaling for normalized value.
@param beta: The bias added to the scaled normalized value.
@param mean: The value for mean normalization.
@param variance: The value for variance normalization.
@param epsilon: The number to be added to the variance to avoid division
by zero when normalizing a value.
@param name: The optional name of the output node.
@return The new node which performs BatchNormInference.
| Node ngraph.opset1.ops.binary_convolution | ( | NodeInput | data, |
| NodeInput | filters, | ||
| List[int] | strides, | ||
| List[int] | pads_begin, | ||
| List[int] | pads_end, | ||
| List[int] | dilations, | ||
| str | mode, | ||
| float | pad_value, | ||
| str | auto_pad = "EXPLICIT", |
||
| Optional[str] | name = None |
||
| ) |
Create node performing convolution with binary weights, binary input and integer output.
@param data: The node providing data batch tensor. @param filter: The node providing filters tensor. @param strides: The kernel window movement strides. @param pads_begin: The number of pixels to add to the beginning along each axis. @param pads_end: The number of pixels to add to the end along each axis. @param dilations: The distance in width and height between elements (weights) in the filter. @param mode: Defines how input tensor 0/1 values and weights 0/1 are interpreted. @param pad_value: Floating-point value used to fill pad area. @param auto_pad: The type of padding. Range of values: explicit, same_upper, same_lower, valid. @param name: The optional new name for output node. @return New node performing binary convolution operation.
| Node ngraph.opset1.ops.broadcast | ( | NodeInput | data, |
| NodeInput | target_shape, | ||
| Optional[NodeInput] | axes_mapping = None, |
||
| str | mode = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Create a node which broadcasts the input node's values along specified axes to a desired shape.
@param data: The node with input tensor data.
@param target_shape: The node with a new shape we want to broadcast tensor to.
@param axes_mapping: The node with a axis positions (0-based) in the result
that are being broadcast.
@param mode: The type of broadcasting that specifies mapping of input tensor axes
to output shape axes. Range of values: NUMPY, EXPLICIT.
@param name: Optional new name for output node.
@return New node with broadcast shape.
| Node ngraph.opset1.ops.ceiling | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies ceiling to the input node element-wise.
@param node: The node providing data to ceiling operation. @param name: Optional name for output node. @return The node performing element-wise ceiling.
| Node ngraph.opset1.ops.clamp | ( | NodeInput | data, |
| ScalarData | min_value, | ||
| ScalarData | max_value, | ||
| Optional[str] | name = None |
||
| ) |
Perform clamp element-wise on data from input node.
@param data: Input tensor. One of: input node, array or scalar.
@param min_value: The lower bound of the <min_value;max_value> range. Scalar value.
@param max_value: The upper bound of the <min_value;max_value> range. Scalar value.
@param name: Optional output node name.
@return The new node performing a clamp operation on its input data element-wise.
Performs a clipping operation on an input value between a pair of boundary values.
For each element in `data`, if the element's value is lower than `min_value`,
it will be replaced with `min_value`. If the value is higher than `max_value`,
it will be replaced by `max_value`.
Intermediate values of `data` are returned without change.
Clamp uses the following logic:
@code{.py}
if data < min_value:
data=min_value
elif data > max_value:
data=max_value
@endcode
| Node ngraph.opset1.ops.concat | ( | List[NodeInput] | nodes, |
| int | axis, | ||
| Optional[str] | name = None |
||
| ) |
Concatenate input nodes into single new node along specified axis.
@param nodes: The nodes we want concatenate into single new node. @param axis: The axis along which we want to concatenate input nodes. @param name: The optional new name for output node. @return Return new node that is a concatenation of input nodes.
| Constant ngraph.opset1.ops.constant | ( | NumericData | value, |
| NumericType | dtype = None, |
||
| Optional[str] | name = None |
||
| ) |
Create a Constant node from provided value.
@param value: One of: array of values or scalar to initialize node with. @param dtype: The data type of provided data. @param name: Optional name for output node. @return The Constant node initialized with provided data.
| Node ngraph.opset1.ops.convert | ( | NodeInput | data, |
| Union[str, NumericType] | destination_type, | ||
| Optional[str] | name = None |
||
| ) |
Return node which casts input node values to specified type.
@param data: Node which produces the input tensor. @param destination_type: Provides the target type for the conversion. @param name: Optional name for the output node. @return New node performing the conversion operation.
| Node ngraph.opset1.ops.convert_like | ( | NodeInput | data, |
| NodeInput | like, | ||
| Optional[str] | name = None |
||
| ) |
Return node which casts data node values to the type of another node.
@param data: Node which produces the input tensor @param like: Node which provides the target type information for the conversion @param name: Optional name for the output node. @return New node performing the conversion operation.
| Node ngraph.opset1.ops.convolution | ( | NodeInput | data, |
| NodeInput | filters, | ||
| List[int] | strides, | ||
| List[int] | pads_begin, | ||
| List[int] | pads_end, | ||
| List[int] | dilations, | ||
| str | auto_pad = "EXPLICIT", |
||
| Optional[str] | name = None |
||
| ) |
Return node performing batched convolution operation.
@param data: The node providing data batch tensor. @param filter: The node providing filters tensor. @param strides: The kernel window movement strides. @param pads_begin: The number of zero padding elements to add on each axis below 0 coordinate. @param pads_end: The number of zero padding elements to add on each axis above max coordinate @param dilations: The data batch dilation strides. @param auto_pad: The type of padding. Range of values: explicit, same_upper, same_lower, valid. @param name: The optional new name for output node. @return New node performing batched convolution operation.
| Node ngraph.opset1.ops.convolution_backprop_data | ( | NodeInput | data, |
| NodeInput | filters, | ||
| List[int] | strides, | ||
| Optional[NodeInput] | output_shape = None, |
||
| Optional[List[int]] | pads_begin = None, |
||
| Optional[List[int]] | pads_end = None, |
||
| Optional[List[int]] | dilations = None, |
||
| Optional[str] | auto_pad = None, |
||
| Optional[List[int]] | output_padding = None, |
||
| Optional[str] | name = None |
||
| ) |
Create node performing a batched-convolution backprop data operation.
@param data: The node producing data from forward-prop
@param filters: The node producing the filters from forward-prop.
@param output_shape: The node producing output delta.
@param strides: The distance (in pixels) to slide the filter on the feature map
over the axes.
@param pads_begin: The number of pixels to add to the beginning along each axis.
@param pads_end: The number of pixels to add to the end along each axis.
@param dilations: The distance in width and height between elements (weights)
in the filter.
@param name: The node name.
@return The node object representing ConvolutionBackpropData operation.
| Node ngraph.opset1.ops.cos | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply cosine function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with cos operation applied on it.
| Node ngraph.opset1.ops.cosh | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply hyperbolic cosine function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with cosh operation applied on it.
| Node ngraph.opset1.ops.ctc_greedy_decoder | ( | NodeInput | data, |
| NodeInput | sequence_mask, | ||
| bool | merge_repeated = True, |
||
| Optional[str] | name = None |
||
| ) |
Perform greedy decoding on the logits given in input (best path).
@param data: Logits on which greedy decoding is performed. @param sequence_mask: The tensor with sequence masks for each sequence in the batch. @param merge_repeated: The flag for merging repeated labels during the CTC calculation. @param name: Optional name for output node. @return The new node performing an CTCGreedyDecoder operation on input tensor.
| Node ngraph.opset1.ops.deformable_convolution | ( | NodeInput | data, |
| NodeInput | deformable_values, | ||
| NodeInput | filters, | ||
| List[int] | strides, | ||
| List[int] | pads_begin, | ||
| List[int] | pads_end, | ||
| List[int] | dilations, | ||
| str | auto_pad = "EXPLICIT", |
||
| int | group = 1, |
||
| int | deformable_group = 1, |
||
| Optional[str] | name = None |
||
| ) |
Create node performing deformable convolution.
@param data: The node providing data batch tensor.
@param filter: The node providing filters tensor.
@param strides: The distance (in pixels) to slide the filter on the feature map over the axes.
@param pads_begin: The number of pixels to add to the beginning along each axis.
@param pads_end: The number of pixels to add to the end along each axis.
@param dilations: The distance in width and height between elements (weights) in the filter.
@param auto_pad: The type of padding. Range of values: explicit, same_upper, same_lower, valid.
@param group: The number of groups which both output and input should be split into.
@param deformable_group: The number of groups which deformable values and output should be split
into along the channel axis.
@param name: The optional new name for output node.
@return New node performing deformable convolution operation.
| Node ngraph.opset1.ops.deformable_psroi_pooling | ( | NodeInput | feature_maps, |
| NodeInput | coords, | ||
| int | output_dim, | ||
| float | spatial_scale, | ||
| int | group_size = 1, |
||
| str | mode = "bilinear_deformable", |
||
| int | spatial_bins_x = 1, |
||
| int | spatial_bins_y = 1, |
||
| float | trans_std = 1.0, |
||
| int | part_size = 1, |
||
| Optional[NodeInput] | offsets = None, |
||
| Optional[str] | name = None |
||
| ) |
Return node performing DeformablePSROIPooling operation.
DeformablePSROIPooling computes position-sensitive pooling on regions of interest specified by input. @param feature_maps: 4D tensor with feature maps. @param coords: 2D tensor describing box consisting of tuples: [batch_id, x_1, y_1, x_2, y_2]. @param output_dim: A pooled output channel number. @param spatial_scale: A multiplicative spatial scale factor to translate ROI. @param group_size: The number of groups to encode position-sensitive score. @param mode: Specifies mode for pooling. Range of values: ['bilinear_deformable']. @param spatial_bins_x: Specifies numbers of bins to divide the input feature maps over width. @param spatial_bins_y: Specifies numbers of bins to divide the input feature maps over height. @param trans_std: The value that all transformation (offset) values are multiplied with. @param part_size: The number of parts the output tensor spatial dimensions are divided into. @param offsets: Optional node. 4D input blob with transformation values (offsets). @param name: The optional new name for output node. @return New node performing DeformablePSROIPooling operation.
| Node ngraph.opset1.ops.depth_to_space | ( | Node | node, |
| str | mode, | ||
| int | block_size = 1, |
||
| str | name = None |
||
| ) |
Rearranges input tensor from depth into blocks of spatial data.
Values from the height and width dimensions are moved to the depth dimension.
Input tensor has shape [N,C,H,W], where N is the batch axis, C is the channel or depth,
H is the height and W is the width.
Output node produces a tensor with shape:
[N, C * `block_size` * `block_size`, H / `block_size`, W / `block_size`]
@param node: The node with input tensor data.
@param mode: Specifies how the input depth dimension is split to block coordinates
blocks_first: The input is divided to [block_size, ..., block_size, new_depth]
depth_first: The input is divided to [new_depth, block_size, ..., block_size]
@param block_size: The size of the spatial block of values describing
how the tensor's data is to be rearranged.
@param name: Optional output node name.
@return The new node performing an DepthToSpace operation on its input tensor.
| Node ngraph.opset1.ops.detection_output | ( | Node | box_logits, |
| Node | class_preds, | ||
| Node | proposals, | ||
| dict | attrs, | ||
| NodeInput | aux_class_preds = None, |
||
| NodeInput | aux_box_preds = None, |
||
| Optional[str] | name = None |
||
| ) |
Generate the detection output using information on location and confidence predictions.
@param box_logits: The 2D input tensor with box logits.
@param class_preds: The 2D input tensor with class predictions.
@param proposals: The 3D input tensor with proposals.
@param attrs: The dictionary containing key, value pairs for attributes.
@param aux_class_preds: The 2D input tensor with additional class predictions information.
@param aux_box_preds: The 2D input tensor with additional box predictions information.
@param name: Optional name for the output node.
@return Node representing DetectionOutput operation.
Available attributes are:
* num_classes The number of classes to be predicted.
Range of values: positive integer number
Default value: None
Required: yes
* background_label_id The background label id.
Range of values: integer value
Default value: 0
Required: no
* top_k Maximum number of results to be kept per batch after NMS step.
Range of values: integer value
Default value: -1
Required: no
* variance_encoded_in_target The flag that denotes if variance is encoded in target.
Range of values: {False, True}
Default value: False
Required: no
* keep_top_k Maximum number of bounding boxes per batch to be kept after NMS step.
Range of values: integer values
Default value: None
Required: yes
* code_type The type of coding method for bounding boxes.
Range of values: {'caffe.PriorBoxParameter.CENTER_SIZE',
'caffe.PriorBoxParameter.CORNER'}
Default value: 'caffe.PriorBoxParameter.CORNER'
Required: no
* share_location The flag that denotes if bounding boxes are shared among different
classes.
Range of values: {True, False}
Default value: True
Required: no
* nms_threshold The threshold to be used in the NMS stage.
Range of values: floating point value
Default value: None
Required: yes
* confidence_threshold Specifies the minimum confidence threshold for detection boxes to be
considered.
Range of values: floating point value
Default value: 0
Required: no
* clip_after_nms The flag that denotes whether to perform clip bounding boxes after
non-maximum suppression or not.
Range of values: {True, False}
Default value: False
Required: no
* clip_before_nms The flag that denotes whether to perform clip bounding boxes before
non-maximum suppression or not.
Range of values: {True, False}
Default value: False
Required: no
* decrease_label_id The flag that denotes how to perform NMS.
Range of values: False - perform NMS like in Caffe*.
True - perform NMS like in MxNet*.
Default value: False
Required: no
* normalized The flag that denotes whether input tensors with boxes are normalized.
Range of values: {True, False}
Default value: False
Required: no
* input_height The input image height.
Range of values: positive integer number
Default value: 1
Required: no
* input_width The input image width.
Range of values: positive integer number
Default value: 1
Required: no
* objectness_score The threshold to sort out confidence predictions.
Range of values: non-negative float number
Default value: 0
Required: no
Example of attribute dictionary:
@code{.py}
# just required ones
attrs = {
'num_classes': 85,
'keep_top_k': [1, 2, 3],
'nms_threshold': 0.645,
}
attrs = {
'num_classes': 85,
'keep_top_k': [1, 2, 3],
'nms_threshold': 0.645,
'normalized': True,
'clip_before_nms': True,
'input_height': [32],
'input_width': [32],
}
@endcode
Optional attributes which are absent from dictionary will be set with corresponding default.
| Node ngraph.opset1.ops.divide | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which applies f(x) = A/B to the input nodes element-wise.
@param left_node: The node providing dividend data. @param right_node: The node providing divisor data. @param auto_broadcast: Specifies rules used for auto-broadcasting of input tensors. @param name: Optional name for output node. @return The node performing element-wise division.
| Node ngraph.opset1.ops.elu | ( | NodeInput | data, |
| NumericType | alpha, | ||
| Optional[str] | name = None |
||
| ) |
Perform Exponential Linear Unit operation element-wise on data from input node.
Computes exponential linear: alpha * (exp(data) - 1) if < 0, data otherwise. For more information refer to: [Fast and Accurate Deep Network Learning by Exponential Linear Units](http://arxiv.org/abs/1511.07289) @param data: Input tensor. One of: input node, array or scalar. @param alpha: Scalar multiplier for negative values. @param name: Optional output node name. @return The new node performing an ELU operation on its input data element-wise.
| Node ngraph.opset1.ops.equal | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which checks if input nodes are equal element-wise.
@param left_node: The first input node for equal operation.
@param right_node: The second input node for equal operation.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@param name: The optional name for output new node.
@return The node performing element-wise equality check.
| Node ngraph.opset1.ops.erf | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which calculates Gauss error function element-wise with given tensor.
@param node: The node providing data for operation. @param name: The optional name for new output node. @return The new node performing element-wise Erf operation.
| Node ngraph.opset1.ops.exp | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies exponential function to the input node element-wise.
@param node: The node providing data for operation. @param name: The optional name for new output node. @return The new node performing natural exponential operation.
| Node ngraph.opset1.ops.fake_quantize | ( | NodeInput | data, |
| NodeInput | input_low, | ||
| NodeInput | input_high, | ||
| NodeInput | output_low, | ||
| NodeInput | output_high, | ||
| int | levels, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Perform an element-wise linear quantization on input data.
@param data: The node with data tensor.
@param input_low: The node with the minimum for input values.
@param input_high: The node with the maximum for input values.
@param output_low: The node with the minimum quantized value.
@param output_high: The node with the maximum quantized value.
@param levels: The number of quantization levels. Integer value.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@return New node with quantized value.
Input floating point values are quantized into a discrete set of floating point values.
@code{.py}
if x <= input_low:
output = output_low
if x > input_high:
output = output_high
else:
output = fake_quantize(output)
@endcode
Fake quantize uses the following logic:
\f[ output =
\dfrac{round( \dfrac{data - input\_low}{(input\_high - input\_low)\cdot (levels-1)})}
{(levels-1)\cdot (output\_high - output\_low)} + output\_low
\f]
| Node ngraph.opset1.ops.floor | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies floor to the input node element-wise.
@param node: The input node providing data. @param name: The optional name for new output node. @return The node performing element-wise floor operation.
| Node ngraph.opset1.ops.floor_mod | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node performing element-wise FloorMod (division reminder) with two given tensors.
@param left_node: The first input node for FloorMod operation. @param right_node: The second input node for FloorMod operation. @param auto_broadcast: Specifies rules used for auto-broadcasting of input tensors. @param name: Optional name for output node. @return The node performing element-wise FloorMod operation.
| Node ngraph.opset1.ops.gather | ( | NodeInput | data, |
| NodeInput | indices, | ||
| NodeInput | axis, | ||
| Optional[str] | name = None |
||
| ) |
Return Gather node which takes slices from axis of data according to indices.
@param data: The tensor from which slices are gathered. @param indices: Tensor with indexes to gather. @param axis: The dimension index to gather data from. @param name: Optional name for output node. @return The new node performing a Gather operation on the data input tensor.
| Node ngraph.opset1.ops.gather_tree | ( | NodeInput | step_ids, |
| NodeInput | parent_idx, | ||
| NodeInput | max_seq_len, | ||
| NodeInput | end_token, | ||
| Optional[str] | name = None |
||
| ) |
Perform GatherTree operation.
@param step_ids: The tensor with indices from per each step.
@param parent_idx: The tensor with with parent beam indices.
@param max_seq_len: The tensor with maximum lengths for each sequence in the batch.
@param end_token: The scalar tensor with value of the end marker in a sequence.
@param name: Optional name for output node.
@return The new node performing a GatherTree operation.
The GatherTree node generates the complete beams from the indices per each step
and the parent beam indices.
GatherTree uses the following logic:
@code{.py}
for batch in range(BATCH_SIZE):
for beam in range(BEAM_WIDTH):
max_sequence_in_beam = min(MAX_TIME, max_seq_len[batch])
parent = parent_idx[max_sequence_in_beam - 1, batch, beam]
for level in reversed(range(max_sequence_in_beam - 1)):
final_idx[level, batch, beam] = step_idx[level, batch, parent]
parent = parent_idx[level, batch, parent]
@endcode
| Node ngraph.opset1.ops.greater | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which checks if left input node is greater than the right node element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@param name: The optional new name for output node.
@return The node performing element-wise check whether left_node is greater than right_node.
| Node ngraph.opset1.ops.greater_equal | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which checks if left node is greater or equal to the right node element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@param name: The optional new name for output node.
@return The node performing element-wise check whether left_node is greater than or equal
right_node.
| Node ngraph.opset1.ops.grn | ( | Node | data, |
| float | bias, | ||
| Optional[str] | name = None |
||
| ) |
Perform Global Response Normalization with L2 norm (across channels only).
Computes GRN operation on channels for input tensor:
\f[ output_i = \dfrac{input_i}{\sqrt{\sum_{i}^{C} input_i}} \f]
@param data: The node with data tensor.
@param bias: The bias added to the variance. Scalar value.
@param name: Optional output node name.
@return The new node performing a GRN operation on tensor's channels.
| Node ngraph.opset1.ops.group_convolution | ( | NodeInput | data, |
| NodeInput | filters, | ||
| List[int] | strides, | ||
| List[int] | pads_begin, | ||
| List[int] | pads_end, | ||
| List[int] | dilations, | ||
| str | auto_pad = "EXPLICIT", |
||
| Optional[str] | name = None |
||
| ) |
Perform Group Convolution operation on data from input node.
@param data: The node producing input data.
@param filters: The node producing filters data.
@param strides: The distance (in pixels) to slide the filter on the feature map
over the axes.
@param pads_begin: The number of pixels to add at the beginning along each axis.
@param pads_end: The number of pixels to add at the end along each axis.
@param dilations: The distance in width and height between elements (weights) in the filter.
@param auto_pad: Describes how to perform padding. Possible values:
EXPLICIT: Pad dimensions are explicity specified
SAME_LOWER: Pad dimensions computed to match input shape
Ceil(num_dims/2) at the beginning and
Floor(num_dims/2) at the end
SAME_UPPER: Pad dimensions computed to match input shape
Floor(num_dims/2) at the beginning and
Ceil(num_dims/2) at the end
VALID: No padding
@param name: Optional output node name.
@return The new node performing a Group Convolution operation on tensor from input node.
| Node ngraph.opset1.ops.group_convolution_backprop_data | ( | NodeInput | data, |
| NodeInput | filters, | ||
| List[int] | strides, | ||
| Optional[NodeInput] | output_shape = None, |
||
| Optional[List[int]] | pads_begin = None, |
||
| Optional[List[int]] | pads_end = None, |
||
| Optional[List[int]] | dilations = None, |
||
| str | auto_pad = "EXPLICIT", |
||
| Optional[List[int]] | output_padding = None, |
||
| Optional[str] | name = None |
||
| ) |
Perform Group Convolution operation on data from input node.
@param data: The node producing input data.
@param filters: The node producing filter data.
@param strides: The distance (in pixels) to slide the filter on the feature map
over the axes.
@param output_shape: The node that specifies spatial shape of the output.
@param pads_begin: The number of pixels to add at the beginning along each axis.
@param pads_end: The number of pixels to add at the end along each axis.
@param dilations: The distance in width and height between elements (weights)
in the filter.
@param auto_pad: Describes how to perform padding. Possible values:
EXPLICIT: Pad dimensions are explicity specified
SAME_LOWER: Pad dimensions computed to match input shape
Ceil(num_dims/2) at the beginning and
Floor(num_dims/2) at the end
SAME_UPPER: Pad dimensions computed to match input shape
Floor(num_dims/2) at the beginning and
Ceil(num_dims/2) at the end
VALID: No padding
@param output_padding: The additional amount of paddings added per each spatial axis
in the output tensor.
@param name: Optional output node name.
@return The new node performing a Group Convolution operation on tensor from input node.
| Node ngraph.opset1.ops.hard_sigmoid | ( | Node | data, |
| NodeInput | alpha, | ||
| NodeInput | beta, | ||
| Optional[str] | name = None |
||
| ) |
Perform Hard Sigmoid operation element-wise on data from input node.
@param data: The node with data tensor.
@param alpha: A node producing the alpha parameter.
@param beta: A node producing the beta parameter
@param name: Optional output node name.
@return The new node performing a Hard Sigmoid element-wise on input tensor.
Hard Sigmoid uses the following logic:
@code{.py}
y = max(0, min(1, alpha * data + beta))
@endcode
| Node ngraph.opset1.ops.interpolate | ( | Node | image, |
| NodeInput | output_shape, | ||
| dict | attrs, | ||
| Optional[str] | name = None |
||
| ) |
Perform interpolation of independent slices in input tensor.
@param image: The node providing input tensor with data for interpolation.
@param output_shape: 1D tensor describing output shape for spatial axes.
@param attrs: The dictionary containing key, value pairs for attributes.
@param name: Optional name for the output node.
@return Node representing interpolation operation.
Available attributes are:
* axes Specify spatial dimension indices where interpolation is applied.
Type: List of non-negative integer numbers.
Required: yes.
* mode Specifies type of interpolation.
Range of values: one of {nearest, linear, cubic, area}
Type: string
Required: yes
* align_corners A flag that specifies whether to align corners or not. True means the
alignment is applied, False means the alignment isn't applied.
Range of values: True or False. Default: True.
Required: no
* antialias A flag that specifies whether to perform anti-aliasing.
Range of values: False - do not perform anti-aliasing
True - perform anti-aliasing
Default value: False
Required: no
* pads_begin Specify the number of pixels to add to the beginning of the image being
interpolated. A scalar that specifies padding for each spatial dimension.
Range of values: list of non-negative integer numbers. Default value: 0
Required: no
* pads_end Specify the number of pixels to add to the beginning of the image being
interpolated. A scalar that specifies padding for each spatial dimension.
Range of values: list of non-negative integer numbers. Default value: 0
Required: no
Example of attribute dictionary:
@code{.py}
# just required ones
attrs = {
'axes': [2, 3],
'mode': 'cubic',
}
attrs = {
'axes': [2, 3],
'mode': 'cubic',
'antialias': True,
'pads_begin': [2, 2, 2],
}
@endcode
Optional attributes which are absent from dictionary will be set with corresponding default.
| Node ngraph.opset1.ops.less | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which checks if left input node is less than the right node element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@param name: The optional new name for output node.
@return The node performing element-wise check whether left_node is less than the right_node.
| Node ngraph.opset1.ops.less_equal | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which checks if left input node is less or equal the right node element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@param name: The optional new name for output node.
@return The node performing element-wise check whether left_node is less than or equal the
right_node.
| Node ngraph.opset1.ops.log | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies natural logarithm to the input node element-wise.
@param node: The input node providing data for operation. @param name: The optional new name for output node. @return The new node performing log operation element-wise.
| Node ngraph.opset1.ops.logical_and | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which perform logical and operation on input nodes element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting that specifies mapping of input tensor axes
to output shape axes. Range of values: numpy, explicit.
@param name: The optional new name for output node.
@return The node performing logical and operation on input nodes corresponding elements.
| Node ngraph.opset1.ops.logical_not | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies element-wise logical negation to the input node.
@param node: The input node providing data. @param name: The optional new name for output node. @return The node performing element-wise logical NOT operation with given tensor.
| Node ngraph.opset1.ops.logical_or | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which performs logical OR operation on input nodes element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting that specifies mapping of input tensor axes
to output shape axes. Range of values: numpy, explicit.
@param name: The optional new name for output node.
@return The node performing logical or operation on input nodes corresponding elements.
| Node ngraph.opset1.ops.logical_xor | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which performs logical XOR operation on input nodes element-wise.
@param left_node: The first input node providing data.
@param right_node: The second input node providing data.
@param auto_broadcast: The type of broadcasting that specifies mapping of input tensor axes
to output shape axes. Range of values: numpy, explicit.
@param name: The optional new name for output node.
@return The node performing logical or operation on input nodes corresponding elements.
| Node ngraph.opset1.ops.lrn | ( | NodeInput | data, |
| NodeInput | axes, | ||
| float | alpha = 1, |
||
| float | beta = 0.5, |
||
| float | bias = 1, |
||
| int | size = 5, |
||
| Optional[str] | name = None |
||
| ) |
Return a node which performs element-wise Local Response Normalization (LRN) operation.
@param data: Input data. @param alpha: A scale factor (usually positive). @param beta: An exponent. @param bias: An offset (usually positive) to avoid dividing by 0. @param size: Width of the 1-D normalization window. @param name: An optional name of the output node. @return The new node which performs LRN.
| Node ngraph.opset1.ops.lstm_cell | ( | NodeInput | X, |
| NodeInput | initial_hidden_state, | ||
| NodeInput | initial_cell_state, | ||
| NodeInput | W, | ||
| NodeInput | R, | ||
| NodeInput | B, | ||
| int | hidden_size, | ||
| List[str] | activations = None, |
||
| List[float] | activations_alpha = None, |
||
| List[float] | activations_beta = None, |
||
| float | clip = 0.0, |
||
| Optional[str] | name = None |
||
| ) |
Return a node which performs LSTMCell operation.
@param X: The input tensor with shape: [batch_size, input_size]. @param initial_hidden_state: The hidden state tensor with shape: [batch_size, hidden_size]. @param initial_cell_state: The cell state tensor with shape: [batch_size, hidden_size]. @param W: The weight tensor with shape: [4*hidden_size, input_size]. @param R: The recurrence weight tensor with shape: [4*hidden_size, hidden_size]. @param B: The bias tensor for gates with shape: [4*hidden_size]. @param hidden_size: Specifies hidden state size. @param activations: The list of three activation functions for gates. @param activations_alpha: The list of alpha parameters for activation functions. @param activations_beta: The list of beta parameters for activation functions. @param clip: Specifies bound values [-C, C] for tensor clipping performed before activations. @param name: An optional name of the output node. @return The new node represents LSTMCell. Node outputs count: 2.
| Node ngraph.opset1.ops.lstm_sequence | ( | NodeInput | X, |
| NodeInput | initial_hidden_state, | ||
| NodeInput | initial_cell_state, | ||
| NodeInput | sequence_lengths, | ||
| NodeInput | W, | ||
| NodeInput | R, | ||
| NodeInput | B, | ||
| int | hidden_size, | ||
| str | direction, | ||
| List[str] | activations = None, |
||
| List[float] | activations_alpha = None, |
||
| List[float] | activations_beta = None, |
||
| float | clip = 0.0, |
||
| Optional[str] | name = None |
||
| ) |
Return a node which performs LSTMSequence operation.
@param X: The input tensor. Shape: [batch_size, seq_length, input_size].
@param initial_hidden_state: The hidden state tensor.
Shape: [batch_size, num_directions, hidden_size].
@param initial_cell_state: The cell state tensor.
Shape: [batch_size, num_directions, hidden_size].
@param sequence_lengths: Specifies real sequence lengths for each batch element.
Shape: [batch_size]. Integer type.
@param W: Tensor with weights for matrix multiplication operation with input portion of data.
Shape: [num_directions, 4*hidden_size, input_size].
@param R: The tensor with weights for matrix multiplication operation with hidden state.
Shape: [num_directions, 4*hidden_size, hidden_size].
@param B: The tensor with biases.
Shape: [num_directions, 4*hidden_size].
@param hidden_size: Specifies hidden state size.
@param direction: Specifies if the RNN is forward, reverse, or bidirectional.
@param activations: The list of three activation functions for gates.
@param activations_alpha: The list of alpha parameters for activation functions.
@param activations_beta: The list of beta parameters for activation functions.
@param clip: Specifies bound values [-C, C] for tensor clipping performed before activations.
@param name: An optional name of the output node.
@return The new node represents LSTMSequence. Node outputs count: 3.
| Node ngraph.opset1.ops.matmul | ( | NodeInput | data_a, |
| NodeInput | data_b, | ||
| bool | transpose_a, | ||
| bool | transpose_b, | ||
| Optional[str] | name = None |
||
| ) |
Return the Matrix Multiplication operation.
@param data_a: left-hand side matrix @param data_b: right-hand side matrix @param transpose_a: should the first matrix be transposed before operation @param transpose_b: should the second matrix be transposed @return MatMul operation node
| Node ngraph.opset1.ops.max_pool | ( | NodeInput | data, |
| List[int] | strides, | ||
| List[int] | pads_begin, | ||
| List[int] | pads_end, | ||
| TensorShape | kernel_shape, | ||
| str | rounding_type = "floor", |
||
| Optional[str] | auto_pad = None, |
||
| Optional[str] | name = None |
||
| ) |
Perform max pooling operation with given parameters on provided data.
@param data: The node providing input data.
@param strides: The distance (in pixels) to slide the filter on the feature map
over the axes.
@param pads_begin: The number of pixels to add at the beginning along each axis.
@param pads_end: The number of pixels to add at the end along each axis.
@param kernel_shape: The pooling operation kernel shape.
@param rounding_type: Determines used rounding schema when computing output shape. Acceptable
values are: ['floor', 'ceil']
@param auto_pad: Determines how the padding is calculated. Acceptable values:
[None, 'same_upper', 'same_lower', 'valid']
@param name: The optional name for the created output node.
@return The new node performing max pooling operation.
| Node ngraph.opset1.ops.maximum | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which applies the maximum operation to input nodes elementwise.
| Node ngraph.opset1.ops.minimum | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which applies the minimum operation to input nodes elementwise.
| Node ngraph.opset1.ops.mod | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node performing element-wise division reminder with two given tensors.
@param left_node: The first input node for mod operation. @param right_node: The second input node for mod operation. @param auto_broadcast: Specifies rules used for auto-broadcasting of input tensors. @param name: Optional name for output node. @return The node performing element-wise Mod operation.
| Node ngraph.opset1.ops.multiply | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which applies f(x) = A*B to the input nodes elementwise.
| Node ngraph.opset1.ops.negative | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies f(x) = -x to the input node elementwise.
| Node ngraph.opset1.ops.non_max_suppression | ( | NodeInput | boxes, |
| NodeInput | scores, | ||
| Optional[NodeInput] | max_output_boxes_per_class = None, |
||
| Optional[NodeInput] | iou_threshold = None, |
||
| Optional[NodeInput] | score_threshold = None, |
||
| str | box_encoding = "corner", |
||
| bool | sort_result_descending = True, |
||
| Optional[str] | name = None |
||
| ) |
Return a node which performs NonMaxSuppression.
@param boxes: Tensor with box coordinates.
@param scores: Tensor with box scores.
@param max_output_boxes_per_class: Tensor Specifying maximum number of boxes
to be selected per class.
@param iou_threshold: Tensor specifying intersection over union threshold
@param score_threshold: Tensor specifying minimum score to consider box for the processing.
@param box_encoding: Format of boxes data encoding. Range of values: corner or cente.
@param sort_result_descending: Flag that specifies whenever it is necessary to sort selected
boxes across batches or not.
@return The new node which performs NonMaxSuppression
| Node ngraph.opset1.ops.normalize_l2 | ( | NodeInput | data, |
| NodeInput | axes, | ||
| float | eps, | ||
| str | eps_mode, | ||
| Optional[str] | name = None |
||
| ) |
Construct an NormalizeL2 operation.
@param data: Node producing the input tensor @param axes: Node indicating axes along which L2 reduction is calculated @param eps: The epsilon added to L2 norm @param eps_mode: how eps is combined with L2 value (`add` or `max`) @return New node which performs the L2 normalization.
| Node ngraph.opset1.ops.not_equal | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which checks if input nodes are unequal element-wise.
@param left_node: The first input node for not-equal operation.
@param right_node: The second input node for not-equal operation.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@param name: The optional name for output new node.
@return The node performing element-wise inequality check.
| Node ngraph.opset1.ops.one_hot | ( | NodeInput | indices, |
| NodeInput | depth, | ||
| NodeInput | on_value, | ||
| NodeInput | off_value, | ||
| int | axis, | ||
| Optional[str] | name = None |
||
| ) |
Create node performing one-hot encoding on input data.
@param indices: Input tensor of rank N with indices of any supported integer data type.
@param depth: Scalar of any supported integer type that specifies number of classes and
the size of one-hot dimension.
@param on_value: Scalar of any type that is the value that the locations
in output tensor represented by indices in input take.
@param off_value: Scalar of any type that is the value that the locations not represented
by indices in input take.
@param name: The optional name for new output node.
@return New node performing one-hot operation.
| Node ngraph.opset1.ops.pad | ( | NodeInput | arg, |
| NodeInput | pads_begin, | ||
| NodeInput | pads_end, | ||
| str | pad_mode, | ||
| Optional[NodeInput] | arg_pad_value = None, |
||
| Optional[str] | name = None |
||
| ) |
Return a generic padding operation.
@param arg: The node producing input tensor to be padded.
@param pads_begin: number of padding elements to be added before position 0
on each axis of arg.
@param pads_end: number of padding elements to be added after the last element.
@param pad_mode: "constant", "edge", "reflect" or "symmetric"
@param arg_pad_value: value used for padding if pad_mode is "constant"
@return Pad operation node.
| Parameter ngraph.opset1.ops.parameter | ( | TensorShape | shape, |
| NumericType | dtype = np.float32, |
||
| Optional[str] | name = None |
||
| ) |
Return an ngraph Parameter object.
| Node ngraph.opset1.ops.power | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which perform element-wise exponentiation operation.
@param left_node: The node providing the base of operation.
@param right_node: The node providing the exponent of operation.
@param name: The optional name for the new output node.
@param auto_broadcast: The type of broadcasting specifies rules used for
auto-broadcasting of input tensors.
@return The new node performing element-wise exponentiation operation on input nodes.
| Node ngraph.opset1.ops.prelu | ( | NodeInput | data, |
| NodeInput | slope, | ||
| Optional[str] | name = None |
||
| ) |
Perform Parametrized Relu operation element-wise on data from input node.
@param data: The node with data tensor.
@param slope: The node with the multipliers for negative values.
@param name: Optional output node name.
@return The new node performing a PRelu operation on tensor's channels.
PRelu uses the following logic:
@code{.py}
if data < 0:
data = data * slope
elif data >= 0:
data = data
@endcode
| Node ngraph.opset1.ops.prior_box | ( | Node | layer_shape, |
| NodeInput | image_shape, | ||
| dict | attrs, | ||
| Optional[str] | name = None |
||
| ) |
Generate prior boxes of specified sizes and aspect ratios across all dimensions.
@param layer_shape: Shape of layer for which prior boxes are computed.
@param image_shape: Shape of image to which prior boxes are scaled.
@param attrs: The dictionary containing key, value pairs for attributes.
@param name: Optional name for the output node.
@return Node representing prior box operation.
Available attributes are:
* min_size The minimum box size (in pixels).
Range of values: positive floating point numbers
Default value: []
Required: no
* max_size The maximum box size (in pixels).
Range of values: positive floating point numbers
Default value: []
Required: no
* aspect_ratio Aspect ratios of prior boxes.
Range of values: set of positive floating point numbers
Default value: []
Required: no
* flip The flag that denotes that each aspect_ratio is duplicated and flipped.
Range of values: {True, False}
Default value: False
Required: no
* clip The flag that denotes if each value in the output tensor should be clipped
to [0,1] interval.
Range of values: {True, False}
Default value: False
Required: no
* step The distance between box centers.
Range of values: floating point non-negative number
Default value: 0
Required: no
* offset This is a shift of box respectively to top left corner.
Range of values: floating point non-negative number
Default value: None
Required: yes
* variance The variance denotes a variance of adjusting bounding boxes. The attribute
could contain 0, 1 or 4 elements.
Range of values: floating point positive numbers
Default value: []
Required: no
* scale_all_sizes The flag that denotes type of inference.
Range of values: False - max_size is ignored
True - max_size is used
Default value: True
Required: no
* fixed_ratio This is an aspect ratio of a box.
Range of values: a list of positive floating-point numbers
Default value: None
Required: no
* fixed_size This is an initial box size (in pixels).
Range of values: a list of positive floating-point numbers
Default value: None
Required: no
* density This is the square root of the number of boxes of each type.
Range of values: a list of positive floating-point numbers
Default value: None
Required: no
Example of attribute dictionary:
@code{.py}
# just required ones
attrs = {
'offset': 85,
}
attrs = {
'offset': 85,
'flip': True,
'clip': True,
'fixed_size': [32, 64, 128]
}
@endcode
Optional attributes which are absent from dictionary will be set with corresponding default.
| Node ngraph.opset1.ops.prior_box_clustered | ( | Node | output_size, |
| NodeInput | image_size, | ||
| dict | attrs, | ||
| Optional[str] | name = None |
||
| ) |
Generate prior boxes of specified sizes normalized to the input image size.
@param output_size: 1D tensor with two integer elements [height, width]. Specifies the
spatial size of generated grid with boxes.
@param image_size: 1D tensor with two integer elements [image_height, image_width] that
specifies shape of the image for which boxes are generated.
@param attrs: The dictionary containing key, value pairs for attributes.
@param name: Optional name for the output node.
@return Node representing PriorBoxClustered operation.
Available attributes are:
* widths Specifies desired boxes widths in pixels.
Range of values: floating point positive numbers.
Default value: 1.0
Required: no
* heights Specifies desired boxes heights in pixels.
Range of values: floating point positive numbers.
Default value: 1.0
Required: no
* clip The flag that denotes if each value in the output tensor should be clipped
within [0,1].
Range of values: {True, False}
Default value: True
Required: no
* step_widths The distance between box centers.
Range of values: floating point positive number
Default value: 0.0
Required: no
* step_heights The distance between box centers.
Range of values: floating point positive number
Default value: 0.0
Required: no
* offset The shift of box respectively to the top left corner.
Range of values: floating point positive number
Default value: None
Required: yes
* variance Denotes a variance of adjusting bounding boxes.
Range of values: floating point positive numbers
Default value: []
Required: no
Example of attribute dictionary:
@code{.py}
# just required ones
attrs = {
'offset': 85,
}
attrs = {
'offset': 85,
'clip': False,
'step_widths': [1.5, 2.0, 2.5]
}
@endcode
Optional attributes which are absent from dictionary will be set with corresponding default.
| Node ngraph.opset1.ops.proposal | ( | Node | class_probs, |
| Node | bbox_deltas, | ||
| NodeInput | image_shape, | ||
| dict | attrs, | ||
| Optional[str] | name = None |
||
| ) |
Filter bounding boxes and outputs only those with the highest prediction confidence.
@param class_probs: 4D input floating point tensor with class prediction scores.
@param bbox_deltas: 4D input floating point tensor with box logits.
@param image_shape: The 1D input tensor with 3 or 4 elements describing image shape.
@param attrs: The dictionary containing key, value pairs for attributes.
@param name: Optional name for the output node.
@return Node representing Proposal operation.
* base_size The size of the anchor to which scale and ratio attributes are applied.
Range of values: a positive unsigned integer number
Default value: None
Required: yes
* pre_nms_topn The number of bounding boxes before the NMS operation.
Range of values: a positive unsigned integer number
Default value: None
Required: yes
* post_nms_topn The number of bounding boxes after the NMS operation.
Range of values: a positive unsigned integer number
Default value: None
Required: yes
* nms_thresh The minimum value of the proposal to be taken into consideration.
Range of values: a positive floating-point number
Default value: None
Required: yes
* feat_stride The step size to slide over boxes (in pixels).
Range of values: a positive unsigned integer
Default value: None
Required: yes
* min_size The minimum size of box to be taken into consideration.
Range of values: a positive unsigned integer number
Default value: None
Required: yes
* ratio The ratios for anchor generation.
Range of values: a list of floating-point numbers
Default value: None
Required: yes
* scale The scales for anchor generation.
Range of values: a list of floating-point numbers
Default value: None
Required: yes
* clip_before_nms The flag that specifies whether to perform clip bounding boxes before
non-maximum suppression or not.
Range of values: True or False
Default value: True
Required: no
* clip_after_nms The flag that specifies whether to perform clip bounding boxes after
non-maximum suppression or not.
Range of values: True or False
Default value: False
Required: no
* normalize The flag that specifies whether to perform normalization of output boxes to
[0,1] interval or not.
Range of values: True or False
Default value: False
Required: no
* box_size_scale Specifies the scale factor applied to logits of box sizes before decoding.
Range of values: a positive floating-point number
Default value: 1.0
Required: no
* box_coordinate_scale Specifies the scale factor applied to logits of box coordinates
before decoding.
Range of values: a positive floating-point number
Default value: 1.0
Required: no
* framework Specifies how the box coordinates are calculated.
Range of values: "" (empty string) - calculate box coordinates like in Caffe*
tensorflow - calculate box coordinates like in the TensorFlow*
Object Detection API models
Default value: "" (empty string)
Required: no
Example of attribute dictionary:
@code{.py}
# just required ones
attrs = {
'base_size': 85,
'pre_nms_topn': 10,
'post_nms_topn': 20,
'nms_thresh': 0.34,
'feat_stride': 16,
'min_size': 32,
'ratio': [0.1, 1.5, 2.0, 2.5],
'scale': [2, 3, 3, 4],
}
@endcode
Optional attributes which are absent from dictionary will be set with corresponding default.
| Node ngraph.opset1.ops.psroi_pooling | ( | NodeInput | input, |
| NodeInput | coords, | ||
| int | output_dim, | ||
| int | group_size, | ||
| float | spatial_scale, | ||
| int | spatial_bins_x, | ||
| int | spatial_bins_y, | ||
| str | mode, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which produces a PSROIPooling operation.
@param input: Input feature map {N, C, ...}
@param coords: Coordinates of bounding boxes
@param output_dim: Output channel number
@param group_size: Number of groups to encode position-sensitive scores
@param spatial_scale: Ratio of input feature map over input image size
@param spatial_bins_x: Numbers of bins to divide the input feature maps over
@param spatial_bins_y: Numbers of bins to divide the input feature maps over
@param mode: Mode of pooling - "avg" or "bilinear"
@return PSROIPooling node
| Node ngraph.opset1.ops.range | ( | Node | start, |
| NodeInput | stop, | ||
| NodeInput | step, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which produces the Range operation.
@param start: The start value of the generated range @param stop: The stop value of the generated range @param step: The step value for the generated range @param name: Optional name for output node. @return Range node
| Node ngraph.opset1.ops.reduce_logical_and | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Logical AND reduction operation on input tensor, eliminating the specified reduction axes.
@param node: The tensor we want to reduce. @param reduction_axes: The axes to eliminate through AND operation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: Optional name for output node. @return The new node performing reduction operation.
| Node ngraph.opset1.ops.reduce_logical_or | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Logical OR reduction operation on input tensor, eliminating the specified reduction axes.
@param node: The tensor we want to reduce. @param reduction_axes: The axes to eliminate through OR operation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: Optional name for output node. @return The new node performing reduction operation.
| Node ngraph.opset1.ops.reduce_max | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Max-reduction operation on input tensor, eliminating the specified reduction axes.
@param node: The tensor we want to max-reduce. @param reduction_axes: The axes to eliminate through max operation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: Optional name for output node.
| Node ngraph.opset1.ops.reduce_mean | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Mean-reduction operation on input tensor, eliminating the specified reduction axes.
@param node: The tensor we want to mean-reduce. @param reduction_axes: The axes to eliminate through mean operation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: Optional name for output node. @return The new node performing mean-reduction operation.
| Node ngraph.opset1.ops.reduce_min | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Min-reduction operation on input tensor, eliminating the specified reduction axes.
@param node: The tensor we want to min-reduce. @param reduction_axes: The axes to eliminate through min operation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: Optional name for output node.
| Node ngraph.opset1.ops.reduce_prod | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Product-reduction operation on input tensor, eliminating the specified reduction axes.
@param node: The tensor we want to product-reduce. @param reduction_axes: The axes to eliminate through product operation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: Optional name for output node. @return The new node performing product-reduction operation.
| Node ngraph.opset1.ops.reduce_sum | ( | NodeInput | node, |
| NodeInput | reduction_axes, | ||
| bool | keep_dims = False, |
||
| Optional[str] | name = None |
||
| ) |
Perform element-wise sums of the input tensor, eliminating the specified reduction axes.
@param node: The node providing data for operation. @param reduction_axes: The axes to eliminate through summation. @param keep_dims: If set to True it holds axes that are used for reduction @param name: The optional new name for output node. @return The new node performing summation along `reduction_axes` element-wise.
| Node ngraph.opset1.ops.region_yolo | ( | Node | input, |
| int | coords, | ||
| int | classes, | ||
| int | num, | ||
| bool | do_softmax, | ||
| List[int] | mask, | ||
| int | axis, | ||
| int | end_axis, | ||
| List[float] | anchors = None, |
||
| Optional[str] | name = None |
||
| ) |
Return a node which produces the RegionYolo operation.
@param input: Input data @param coords: Number of coordinates for each region @param classes: Number of classes for each region @param num: Number of regions @param do_softmax: Compute softmax @param mask: Mask @param axis: Axis to begin softmax on @param end_axis: Axis to end softmax on @param anchors: A flattened list of pairs `[width, height]` that describes prior box sizes @param name: Optional name for output node. @return RegionYolo node
| Node ngraph.opset1.ops.relu | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Perform rectified linear unit operation on input node element-wise.
@param node: One of: input node, array or scalar. @param name: The optional output node name. @return The new node performing relu operation on its input element-wise.
| Node ngraph.opset1.ops.reshape | ( | NodeInput | node, |
| NodeInput | output_shape, | ||
| bool | special_zero, | ||
| Optional[str] | name = None |
||
| ) |
Return reshaped node according to provided parameters.
@param node: The tensor we want to reshape.
@param output_shape: The node with a new shape for input tensor.
@param special_zero: The boolean variable that controls how zero values in shape are
interpreted. If special_zero is false, then 0 is interpreted as-is
which means that output shape will contain a zero dimension at the
specified location. Input and output tensors are empty in this case.
If special_zero is true, then all zeros in shape implies the copying
of corresponding dimensions from data.shape into the output shape.
Range of values: False or True
| Node ngraph.opset1.ops.result | ( | NodeInput | data, |
| Optional[str] | name = None |
||
| ) |
Return a node which represents an output of a graph (Function).
@param data: The tensor containing the input data @return Result node
| Node ngraph.opset1.ops.reverse_sequence | ( | NodeInput | input, |
| NodeInput | seq_lengths, | ||
| NumericData | batch_axis, | ||
| NumericData | seq_axis, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which produces a ReverseSequence operation.
@param input: tensor with input data to reverse @param seq_lengths: 1D tensor of integers with sequence lengths in the input tensor. @param batch_axis: index of the batch dimension. @param seq_axis: index of the sequence dimension. @return ReverseSequence node
| Node ngraph.opset1.ops.select | ( | NodeInput | cond, |
| NodeInput | then_node, | ||
| NodeInput | else_node, | ||
| str | auto_broadcast = "numpy", |
||
| Optional[str] | name = None |
||
| ) |
Perform an element-wise selection operation on input tensors.
@param cond: Tensor with selection mask of type `boolean`.
@param then_node: Tensor providing data to be selected if respective `cond`
item value is `True`.
@param else_node: Tensor providing data to be selected if respective `cond`
item value is `False`.
@param auto_broadcast: Mode specifies rules used for auto-broadcasting of input tensors.
@param name: The optional new name for output node.
@return The new node with values selected according to provided arguments.
| Node ngraph.opset1.ops.selu | ( | NodeInput | data, |
| NodeInput | alpha, | ||
| NodeInput | lambda_value, | ||
| Optional[str] | name = None |
||
| ) |
Perform a Scaled Exponential Linear Unit (SELU) operation on input node element-wise.
@param data: input node, array or scalar. @param alpha: Alpha coefficient of SELU operation @param lambda_value: Lambda coefficient of SELU operation @param name: The optional output node name. @return The new node performing relu operation on its input element-wise.
| Node ngraph.opset1.ops.shape_of | ( | NodeInput | data, |
| Optional[str] | name = None |
||
| ) |
Return a node which produces a tensor containing the shape of its input data.
@param data: The tensor containing the input data. @return ShapeOf node
| Node ngraph.opset1.ops.sigmoid | ( | NodeInput | data, |
| Optional[str] | name = None |
||
| ) |
Return a node which applies the sigmoid function element-wise.
@param data: The tensor containing the input data @return Sigmoid node
| Node ngraph.opset1.ops.sign | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Perform element-wise sign operation.
@param node: One of: input node, array or scalar.
@param name: The optional new name for output node.
@return The node with mapped elements of the input tensor to -1 (if it is negative),
0 (if it is zero), or 1 (if it is positive).
| Node ngraph.opset1.ops.sin | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply sine function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with sin operation applied on it.
| Node ngraph.opset1.ops.sinh | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply hyperbolic sine function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with sin operation applied on it.
| Node ngraph.opset1.ops.softmax | ( | NodeInput | data, |
| int | axis, | ||
| Optional[str] | name = None |
||
| ) |
Apply softmax operation on each element of input tensor.
@param data: The tensor providing input data. @param axis: An axis along which Softmax should be calculated @return The new node with softmax operation applied on each element.
| Node ngraph.opset1.ops.space_to_depth | ( | Node | data, |
| str | mode, | ||
| int | block_size = 1, |
||
| str | name = None |
||
| ) |
Perform SpaceToDepth operation on the input tensor.
SpaceToDepth rearranges blocks of spatial data into depth.
The operator returns a copy of the input tensor where values from the height
and width dimensions are moved to the depth dimension.
@param data: The node with data tensor.
@param mode: Specifies how the output depth dimension is gathered from block coordinates.
blocks_first: The output depth is gathered from [block_size, ..., block_size, C]
depth_first: The output depth is gathered from [C, block_size, ..., block_size]
@param block_size: The size of the block of values to be moved. Scalar value.
@param name: Optional output node name.
@return The new node performing a SpaceToDepth operation on input tensor.
| Node ngraph.opset1.ops.split | ( | NodeInput | data, |
| NodeInput | axis, | ||
| int | num_splits, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which splits the input tensor into same-length slices.
@param data: The input tensor to be split @param axis: Axis along which the input data will be split @param num_splits: Number of the output tensors that should be produced @return Split node
| Node ngraph.opset1.ops.sqrt | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies square root to the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return The new node with sqrt operation applied element-wise.
| Node ngraph.opset1.ops.squared_difference | ( | NodeInput | x1, |
| NodeInput | x2, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Perform an element-wise squared difference between two tensors.
\f[ y[i] = (x_1[i] - x_2[i])^2 \f]
@param x1: The node with first input tensor.
@param x2: The node with second input tensor.
@param auto_broadcast: The type of broadcasting that specifies mapping of input tensor axes
to output shape axes. Range of values: numpy, explicit.
@param name: Optional new name for output node.
@return The new node performing a squared difference between two tensors.
| Node ngraph.opset1.ops.squeeze | ( | NodeInput | data, |
| NodeInput | axes, | ||
| Optional[str] | name = None |
||
| ) |
Perform squeeze operation on input tensor.
@param data: The node with data tensor.
@param axes: List of non-negative integers, indicate the dimensions to squeeze.
One of: input node or array.
@param name: Optional new name for output node.
@return The new node performing a squeeze operation on input tensor.
Remove single-dimensional entries from the shape of a tensor.
Takes a parameter `axes` with a list of axes to squeeze.
If `axes` is not provided, all the single dimensions will be removed from the shape.
If an `axis` is selected with shape entry not equal to one, an error is raised.
For example:
Inputs: tensor with shape [1, 2, 1, 3, 1, 1], axes=[2, 4]
Result: tensor with shape [1, 2, 3, 1]
| Node ngraph.opset1.ops.strided_slice | ( | NodeInput | data, |
| NodeInput | begin, | ||
| NodeInput | end, | ||
| NodeInput | strides, | ||
| List[int] | begin_mask, | ||
| List[int] | end_mask, | ||
| Optional[List[int]] | new_axis_mask = None, |
||
| Optional[List[int]] | shrink_axis_mask = None, |
||
| Optional[List[int]] | ellipsis_mask = None, |
||
| Optional[str] | name = None |
||
| ) |
Return a node which dynamically repeats(replicates) the input data tensor.
@param data: The tensor to be sliced
@param begin: 1D tensor with begin indexes for input blob slicing
@param end: 1D tensor with end indexes for input blob slicing
@param strides: The slicing strides
@param begin_mask: A mask applied to the 'begin' input indicating which elements
shoud be ignored
@param end_mask: A mask applied to the 'end' input indicating which elements
shoud be ignored
@param new_axis_mask: A mask indicating dimensions where '1' should be inserted
@param shrink_axis_mask: A mask indicating which dimensions should be deleted
@param ellipsis_mask: Indicates positions where missing dimensions should be inserted
@return StridedSlice node
| Node ngraph.opset1.ops.subtract | ( | NodeInput | left_node, |
| NodeInput | right_node, | ||
| str | auto_broadcast = "NUMPY", |
||
| Optional[str] | name = None |
||
| ) |
Return node which applies f(x) = A-B to the input nodes element-wise.
@param left_node: The node providing data for left hand side of operator.
@param right_node: The node providing data for right hand side of operator.
@param auto_broadcast: The type of broadcasting that specifies mapping of input tensor axes
to output shape axes. Range of values: numpy, explicit.
@param name: The optional name for output node.
@return The new output node performing subtraction operation on both tensors element-wise.
| Node ngraph.opset1.ops.tan | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Apply tangent function on the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with tan operation applied on it.
| Node ngraph.opset1.ops.tanh | ( | NodeInput | node, |
| Optional[str] | name = None |
||
| ) |
Return node which applies hyperbolic tangent to the input node element-wise.
@param node: One of: input node, array or scalar. @param name: Optional new name for output node. @return New node with tanh operation applied on it.
| Node ngraph.opset1.ops.tensor_iterator | ( | List[Node] | inputs, |
| GraphBody | graph_body, | ||
| List[TensorIteratorSliceInputDesc] | slice_input_desc, | ||
| List[TensorIteratorMergedInputDesc] | merged_input_desc, | ||
| List[TensorIteratorInvariantInputDesc] | invariant_input_desc, | ||
| List[TensorIteratorBodyOutputDesc] | body_output_desc, | ||
| List[TensorIteratorConcatOutputDesc] | concat_output_desc, | ||
| Optional[str] | name = None |
||
| ) |
Perform recurrent execution of the network described in the body, iterating through the data.
@param inputs: The provided to TensorIterator operator.
@param graph_body: The graph representing the body we execute.
@param slice_input_desc: The descriptors describing sliced inputs, that is nodes
representing tensors we iterate through, processing single
data slice in one iteration.
@param merged_input_desc: The descriptors describing merged inputs, that is nodes
representing variables with initial value at first iteration,
which may be changing through iterations.
@param invariant_input_desc: The descriptors describing invariant inputs, that is nodes
representing variable with persistent value through all
iterations.
@param body_output_desc: The descriptors describing body outputs from specified
iteration.
@param concat_output_desc: The descriptors describing specified output values through
all the iterations concatenated into one node.
@param name: The optional name for output node.
@return Node representing TensorIterator operation.
| Node ngraph.opset1.ops.tile | ( | NodeInput | data, |
| NodeInput | repeats, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which dynamically repeats(replicates) the input data tensor.
@param data: The input tensor to be tiled @param repeats: Per-dimension replication factors @return Tile node
| Node ngraph.opset1.ops.topk | ( | NodeInput | data, |
| NodeInput | k, | ||
| int | axis, | ||
| str | mode, | ||
| str | sort, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which performs TopK.
@param data: Input data.
@param k: K.
@param axis: TopK Axis.
@param mode: Compute TopK largest ('max') or smallest ('min')
@param sort: Order of output elements (sort by: 'none', 'index' or 'value')
@return The new node which performs TopK (both indices and values)
| Node ngraph.opset1.ops.transpose | ( | NodeInput | data, |
| NodeInput | input_order, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which transposes the data in the input tensor.
@param data: The input tensor to be transposed @param input_order: Permutation of axes to be applied to the input tensor @return Transpose node
| Node ngraph.opset1.ops.unsqueeze | ( | NodeInput | data, |
| NodeInput | axes, | ||
| Optional[str] | name = None |
||
| ) |
Perform unsqueeze operation on input tensor.
Insert single-dimensional entries to the shape of a tensor. Takes one required argument axes,
a list of dimensions that will be inserted.
Dimension indices in axes are as seen in the output tensor.
For example: Inputs: tensor with shape [3, 4, 5], axes=[0, 4]
Result: tensor with shape [1, 3, 4, 5, 1]
@param data: The node with data tensor.
@param axes: List of non-negative integers, indicate the dimensions to be inserted.
One of: input node or array.
@return The new node performing an unsqueeze operation on input tensor.
| Node ngraph.opset1.ops.variadic_split | ( | NodeInput | data, |
| NodeInput | axis, | ||
| NodeInput | split_lengths, | ||
| Optional[str] | name = None |
||
| ) |
Return a node which splits the input tensor into variadic length slices.
@param data: The input tensor to be split @param axis: Axis along which the input data will be split @param split_lengths: Sizes of the output tensors along the split axis @return VariadicSplit node