class ov::op::Op


Root of all actual ops. More…

#include <op.hpp>

class Op: public ov::Node
    // methods

    static const ::ov::Node::type_info_t& get_type_info_static();
    virtual const ::ov::Node::type_info_t& get_type_info() const;

// direct descendants

class ConvolutionIE;
class CropIE;
class DeconvolutionIE;
class Eltwise;
class FullyConnected;
class GRUCellIE;
class GatherIE;
class GatherTreeIE;
class HardSigmoid_IE;
class Interp;
class LRN_IE;
class LSTMCellIE;
class NonMaxSuppressionIE;
class NonMaxSuppressionIE3;
class NormalizeIE;
class OneHotIE;
class PadIE;
class PowerIE;
class ProposalIE;
class RNNCellIE;
class ReLUIE;
class ResampleV2;
class ScaleShiftIE;
class SeluIE;
class SwishIE;
class TileIE;
class TopKIE;
class NonMaxSuppressionIEInternal;
template BroadcastMove;
template Kernel;
template Load;
template Nop;
class Store;
template Subgraph;
template Tile;
class Sink;
class BinaryElementwiseArithmetic;
class BinaryElementwiseComparison;
class BinaryElementwiseLogical;
class BroadcastBase;
class ConvertColorI420Base;
class ConvertColorNV12Base;
class DeformableConvolutionBase;
class DetectionOutputBase;
class EmbeddingBagOffsetsBase;
class EmbeddingBagPackedBase;
class FFTBase;
class FrameworkNode;
class GatherBase;
class GatherNDBase;
class IndexReduction;
class MaxPoolBase;
class MultiSubGraphOp;
class NmsBase;
class RNNCellBase;
class ReadValueBase;
class ReductionBase;
class ScatterBase;
class ScatterNDBase;
class UnaryElementwiseArithmetic;
class BatchNormInference;
class CTCGreedyDecoder;
class Clamp;
class Concat;
class Constant;
class Convert;
class CumSum;
class DepthToSpace;
class Elu;
class FakeQuantize;
class GRN;
class Gelu;
class HardSigmoid;
class Interpolate;
class LRN;
class LSTMSequence;
class MVN;
class MatMul;
class NormalizeL2;
class PRelu;
class PSROIPooling;
class Parameter;
class PriorBox;
class PriorBoxClustered;
class Proposal;
class ROIPooling;
class Range;
class RegionYolo;
class ReorgYolo;
class Result;
class ReverseSequence;
class Selu;
class ShapeOf;
class ShuffleChannels;
class SpaceToDepth;
class Squeeze;
class Tile;
class Unsqueeze;
class AvgPool;
class BatchToSpace;
class BinaryConvolution;
class ConvertLike;
class Convolution;
class ConvolutionBackpropData;
class DeformablePSROIPooling;
class GatherTree;
class GroupConvolution;
class GroupConvolutionBackpropData;
class LogicalNot;
class NonMaxSuppression;
class OneHot;
class Pad;
class Reshape;
class Reverse;
class Select;
class Softmax;
class SpaceToBatch;
class Split;
class StridedSlice;
class TopK;
class Transpose;
class VariadicSplit;
class Bucketize;
class EmbeddingSegmentsSum;
class ExtractImagePatches;
class NonMaxSuppression;
class NonZero;
class ROIAlign;
class ScatterElementsUpdate;
class ShapeOf;
class CTCLoss;
class Interpolate;
class Mish;
class Range;
class SoftPlus;
class Swish;
class BatchNormInference;
class LogSoftmax;
class NonMaxSuppression;
class Round;
class CTCGreedyDecoderSeqLen;
class ExperimentalDetectronDetectionOutput;
class ExperimentalDetectronGenerateProposalsSingleImage;
class ExperimentalDetectronPriorGridGenerator;
class ExperimentalDetectronROIFeatureExtractor;
class ExperimentalDetectronTopKROIs;
class GatherElements;
class MVN;
class Einsum;
class Roll;
class AdaptiveAvgPool;
class AdaptiveMaxPool;
class PriorBox;
class RandomUniform;
class Slice;
class Softmax;

Inherited Members

    // typedefs

    typedef DiscreteTypeInfo type_info_t;
    typedef std::map<std::string, Any> RTMap;

    // methods

    virtual void validate_and_infer_types();
    void constructor_validate_and_infer_types();
    virtual bool visit_attributes(AttributeVisitor&);
    virtual const ov::op::AutoBroadcastSpec& get_autob() const;
    virtual bool has_evaluate() const;

    virtual bool evaluate(
        const ov::HostTensorVector& output_values,
        const ov::HostTensorVector& input_values
        ) const;

    virtual bool evaluate(
        const ov::HostTensorVector& output_values,
        const ov::HostTensorVector& input_values,
        const EvaluationContext& evaluationContext
        ) const;

    virtual bool evaluate_lower(const ov::HostTensorVector& output_values) const;
    virtual bool evaluate_upper(const ov::HostTensorVector& output_values) const;

    virtual bool evaluate(
        ov::TensorVector& output_values,
        const ov::TensorVector& input_values
        ) const;

    virtual bool evaluate(
        ov::TensorVector& output_values,
        const ov::TensorVector& input_values,
        const ov::EvaluationContext& evaluationContext
        ) const;

    virtual bool evaluate_lower(ov::TensorVector& output_values) const;
    virtual bool evaluate_upper(ov::TensorVector& output_values) const;
    virtual bool evaluate_label(TensorLabelVector& output_labels) const;

    virtual bool constant_fold(
        OutputVector& output_values,
        const OutputVector& inputs_values

    virtual OutputVector decompose_op() const;
    virtual const type_info_t& get_type_info() const = 0;
    const char \* get_type_name() const;
    void set_arguments(const NodeVector& arguments);
    void set_arguments(const OutputVector& arguments);
    void set_argument(size_t position, const Output<Node>& argument);

    void set_output_type(
        size_t i,
        const element::Type& element_type,
        const PartialShape& pshape

    void set_output_size(size_t output_size);
    void invalidate_values();
    virtual void revalidate_and_infer_types();
    virtual std::string description() const;
    const std::string& get_name() const;
    void set_friendly_name(const std::string& name);
    const std::string& get_friendly_name() const;
    virtual bool is_dynamic() const;
    size_t get_instance_id() const;
    virtual std::ostream& write_description(std::ostream& os, uint32_t depth = 0) const;
    const std::vector<std::shared_ptr<Node>>& get_control_dependencies() const;
    const std::vector<Node \*>& get_control_dependents() const;
    void add_control_dependency(std::shared_ptr<Node> node);
    void remove_control_dependency(std::shared_ptr<Node> node);
    void clear_control_dependencies();
    void clear_control_dependents();
    void add_node_control_dependencies(std::shared_ptr<Node> source_node);
    void add_node_control_dependents(std::shared_ptr<Node> source_node);
    void transfer_control_dependents(std::shared_ptr<Node> replacement);
    size_t get_output_size() const;
    const element::Type& get_output_element_type(size_t i) const;
    const element::Type& get_element_type() const;
    const Shape& get_output_shape(size_t i) const;
    const PartialShape& get_output_partial_shape(size_t i) const;
    Output<const Node> get_default_output() const;
    Output<Node> get_default_output();
    virtual size_t get_default_output_index() const;
    size_t no_default_index() const;
    const Shape& get_shape() const;
    descriptor::Tensor& get_output_tensor(size_t i) const;
    descriptor::Tensor& get_input_tensor(size_t i) const;
    const std::string& get_output_tensor_name(size_t i) const;
    std::set<Input<Node>> get_output_target_inputs(size_t i) const;
    size_t get_input_size() const;
    const element::Type& get_input_element_type(size_t i) const;
    const Shape& get_input_shape(size_t i) const;
    const PartialShape& get_input_partial_shape(size_t i) const;
    const std::string& get_input_tensor_name(size_t i) const;
    Node \* get_input_node_ptr(size_t index) const;
    std::shared_ptr<Node> get_input_node_shared_ptr(size_t index) const;
    Output<Node> get_input_source_output(size_t i) const;
    virtual std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const = 0;
    std::shared_ptr<Node> copy_with_new_inputs(const OutputVector& new_args) const;

    std::shared_ptr<Node> copy_with_new_inputs(
        const OutputVector& inputs,
        const std::vector<std::shared_ptr<Node>>& control_dependencies
        ) const;

    bool has_same_type(std::shared_ptr<const Node> node) const;
    RTMap& get_rt_info();
    const RTMap& get_rt_info() const;
    NodeVector get_users(bool check_is_used = false) const;
    virtual size_t get_version() const;
    virtual std::shared_ptr<Node> get_default_value() const;
    bool operator < (const Node& other) const;
    std::vector<Input<Node>> inputs();
    std::vector<Input<const Node>> inputs() const;
    std::vector<Output<Node>> input_values() const;
    std::vector<Output<Node>> outputs();
    std::vector<Output<const Node>> outputs() const;
    Input<Node> input(size_t input_index);
    Input<const Node> input(size_t input_index) const;
    Output<Node> input_value(size_t input_index) const;
    Output<Node> output(size_t output_index);
    Output<const Node> output(size_t output_index) const;
    OPENVINO_SUPPRESS_DEPRECATED_START void set_op_annotations(std::shared_ptr<ngraph::op::util::OpAnnotations> op_annotations);
    std::shared_ptr<ngraph::op::util::OpAnnotations> get_op_annotations() const;

    virtual OPENVINO_SUPPRESS_DEPRECATED_END bool match_value(
        ov::pass::pattern::Matcher \* matcher,
        const Output<Node>& pattern_value,
        const Output<Node>& graph_value

    virtual bool match_node(
        ov::pass::pattern::Matcher \* matcher,
        const Output<Node>& graph_value

Detailed Documentation

Root of all actual ops.


virtual const ::ov::Node::type_info_t& get_type_info() const

Returns the NodeTypeInfo for the node’s class. During transition to type_info, returns a dummy type_info for Node if the class has not been updated yet.