namespace ov

Overview

transformation aligns elementwise constant inputs ranks with its output rank More…

namespace ov {

// namespaces

namespace ov::batch_util;
namespace ov::cmp;
namespace ov::descriptor;
namespace ov::detail;
namespace ov::device;
    namespace ov::device::capability;
namespace ov::element;
namespace ov::frontend;
    namespace ov::frontend::type;
namespace ov::helpers;
namespace ov::hint;
namespace ov::intel_auto;
namespace ov::intel_cpu;
namespace ov::intel_gna;
namespace ov::intel_gpu;
    namespace ov::intel_gpu::capability;
    namespace ov::intel_gpu::hint;
    namespace ov::intel_gpu::memory_type;
    namespace ov::intel_gpu::ocl;
namespace ov::intel_myriad;
    namespace ov::intel_myriad::hddl;
namespace ov::internal;
namespace ov::layout;
namespace ov::log;
namespace ov::op;
    namespace ov::op::ShapeInferLSTM;
    namespace ov::op::ShapeInferRange;
    namespace ov::op::eye;
    namespace ov::op::internal;
    namespace ov::op::rnn;
    namespace ov::op::slice;
    namespace ov::op::util;
        namespace ov::op::util::detail;
        namespace ov::op::util::error;
        namespace ov::op::util::rfft_common_validation;
    namespace ov::op::v0;
    namespace ov::op::v1;
        namespace ov::op::v1::utils;
            namespace ov::op::v1::utils::one_hot;
    namespace ov::op::v10;
    namespace ov::op::v3;
    namespace ov::op::v4;
    namespace ov::op::v5;
    namespace ov::op::v6;
    namespace ov::op::v7;
    namespace ov::op::v8;
    namespace ov::op::v9;
namespace ov::opset1;
namespace ov::opset10;
namespace ov::opset2;
namespace ov::opset3;
namespace ov::opset4;
namespace ov::opset5;
namespace ov::opset6;
namespace ov::opset7;
namespace ov::opset8;
namespace ov::opset9;
namespace ov::pass;
    namespace ov::pass::pattern;
        namespace ov::pass::pattern::op;
namespace ov::preprocess;
namespace ov::runtime;
namespace ov::streams;
namespace ov::util;

// typedefs

typedef std::map<std::string, Any> AnyMap;
typedef AnyMap RTMap;
typedef std::vector<ov::Any> AnyVector;
typedef std::vector<label_t> TensorLabel;
typedef std::vector<TensorLabel> TensorLabelVector;
typedef uint32_t label_t;
typedef ngraph::runtime::HostTensor HostTensor;
typedef std::shared_ptr<HostTensor> HostTensorPtr;
typedef std::vector<HostTensorPtr> HostTensorVector;
typedef ov::RTMap EvaluationContext;
typedef Node::type_info_t NodeTypeInfo;
typedef std::map<RawNodeOutput, Output<Node>> RawNodeOutputMap;
typedef std::vector<std::shared_ptr<Node>> NodeVector;
typedef std::vector<Output<Node>> OutputVector;
typedef std::vector<std::shared_ptr<ov::op::v0::Result>> ResultVector;
typedef Dimension Rank;
typedef typename element_type_traits<Type>::value_type fundamental_type_for;
typedef std::vector<std::shared_ptr<op::v0::Parameter>> ParameterVector;
typedef std::vector<std::shared_ptr<op::Sink>> SinkVector;
typedef std::function<bool(pass::pattern::Matcher&m)> matcher_pass_callback;
typedef std::function<bool(pass::pattern::Matcher&m)> graph_rewrite_callback;
typedef std::function<bool(pass::pattern::RecurrentMatcher&m)> recurrent_graph_rewrite_callback;
typedef std::function<bool(const std::shared_ptr<Node>&node)> handler_callback;
typedef std::vector<Tensor> TensorVector;
typedef std::map<std::string, std::string> SupportedOpsMap;

// enums

enum Affinity;
enum Direction;
enum PropertyMutability;

// structs

struct CheckLocInfo;
struct DiscreteTypeInfo;
struct MemBandwidthPressure;
struct ProfilingInfo;
template <typename T>
struct Property<T, PropertyMutability::RO>;
struct PropertyName;
struct RawNodeOutput;
template <class T>
struct SoPtr;
struct Version;
template <>
struct element_type_traits<element::Type_t::i32>;
template <>
struct element_type_traits<element::Type_t::f16>;
template <>
struct element_type_traits<element::Type_t::f32>;
template <>
struct element_type_traits<element::Type_t::u8>;
template <>
struct element_type_traits<element::Type_t::boolean>;
template <element::Type_t>
struct element_type_traits;
template <>
struct element_type_traits<element::Type_t::bf16>;
template <>
struct element_type_traits<element::Type_t::i16>;
template <>
struct element_type_traits<element::Type_t::u64>;
template <>
struct element_type_traits<element::Type_t::u32>;
template <>
struct element_type_traits<element::Type_t::i64>;
template <>
struct element_type_traits<element::Type_t::i4>;
template <>
struct element_type_traits<element::Type_t::u4>;
template <>
struct element_type_traits<element::Type_t::f64>;
template <>
struct element_type_traits<element::Type_t::u16>;
template <>
struct element_type_traits<element::Type_t::u1>;
template <>
struct element_type_traits<element::Type_t::i8>;

// templates

template AllocatorImpl;
template ICore;

// classes

class Allocator;
class Any;
class AssertFailure;
template <>
class AttributeAdapter<ov::op::util::FrameworkNodeAttrs>;
template <>
class AttributeAdapter<ov::NodeVector>;
template <>
class AttributeAdapter<ov::PartialShape>;
template <>
class AttributeAdapter<ov::Shape>;
template <>
class AttributeAdapter<ParameterVector>;
template <>
class AttributeAdapter<ResultVector>;
template <>
class AttributeAdapter<ov::element::TypeVector>;
template <>
class AttributeAdapter<std::set<std::string>>;
template <>
class AttributeAdapter<ov::element::Type_t>;
template <>
class AttributeAdapter<ov::element::Type>;
template <>
class AttributeAdapter<ov::Dimension>;
template <>
class AttributeAdapter<op::v9::GridSample::PaddingMode>;
template <>
class AttributeAdapter<op::v9::GridSample::InterpolationMode>;
template <>
class AttributeAdapter<op::v8::MatrixNms::SortResultType>;
template <>
class AttributeAdapter<std::shared_ptr<ngraph::runtime::AlignedBuffer>>;
template <>
class AttributeAdapter<op::v9::NonMaxSuppression::BoxEncodingType>;
template <>
class AttributeAdapter<op::v9::ROIAlign::PoolingMode>;
template <>
class AttributeAdapter<op::v9::ROIAlign::AlignedMode>;
template <>
class AttributeAdapter<ov::AxisSet>;
template <>
class AttributeAdapter<std::shared_ptr<op::util::Variable>>;
template <>
class AttributeAdapter<std::shared_ptr<ov::Model>>;
template <>
class AttributeAdapter<std::shared_ptr<ov::Node>>;
template <>
class AttributeAdapter<Strides>;
template <>
class AttributeAdapter<std::vector<uint8_t>>;
template <>
class AttributeAdapter<std::vector<uint64_t>>;
template <>
class AttributeAdapter<std::vector<uint32_t>>;
template <>
class AttributeAdapter<uint16_t>;
template <>
class AttributeAdapter<uint64_t>;
template <>
class AttributeAdapter<uint32_t>;
template <>
class AttributeAdapter<uint8_t>;
template <>
class AttributeAdapter<op::v8::MatrixNms::DecayFunction>;
template <>
class AttributeAdapter<std::vector<uint16_t>>;
template <>
class AttributeAdapter<std::vector<std::shared_ptr<op::util::MultiSubGraphOp::OutputDescription>>>;
template <>
class AttributeAdapter<std::vector<float>>;
template <>
class AttributeAdapter<std::vector<double>>;
template <>
class AttributeAdapter<std::string>;
template <>
class AttributeAdapter<std::vector<std::string>>;
template <>
class AttributeAdapter<std::vector<int16_t>>;
template <>
class AttributeAdapter<std::vector<int64_t>>;
template <>
class AttributeAdapter<std::vector<int32_t>>;
template <>
class AttributeAdapter<std::vector<int8_t>>;
template <>
class AttributeAdapter<op::v5::Round::RoundMode>;
template <>
class AttributeAdapter<std::vector<std::shared_ptr<op::util::MultiSubGraphOp::InputDescription>>>;
template <>
class AttributeAdapter<op::v5::Loop::SpecialBodyPorts>;
template <>
class AttributeAdapter<ngraph::reduction::Type>;
template <>
class AttributeAdapter<Layout>;
template <>
class AttributeAdapter<op::v5::NonMaxSuppression::BoxEncodingType>;
template <>
class AttributeAdapter<int8_t>;
template <>
class AttributeAdapter<op::AutoBroadcastSpec>;
template <>
class AttributeAdapter<op::BroadcastType>;
template <>
class AttributeAdapter<op::AutoBroadcastType>;
template <>
class AttributeAdapter<op::EpsMode>;
template <>
class AttributeAdapter<op::GeluApproximationMode>;
template <>
class AttributeAdapter<int64_t>;
template <>
class AttributeAdapter<int16_t>;
template <>
class AttributeAdapter<bool>;
template <>
class AttributeAdapter<AxisVector>;
template <typename AT>
class AttributeAdapter;
template <>
class AttributeAdapter<int32_t>;
template <>
class AttributeAdapter<Coordinate>;
template <>
class AttributeAdapter<double>;
template <>
class AttributeAdapter<CoordinateDiff>;
template <>
class AttributeAdapter<float>;
template <>
class AttributeAdapter<op::LSTMWeightsFormat>;
template <>
class AttributeAdapter<op::BroadcastModeSpec>;
template <>
class AttributeAdapter<op::PadMode>;
template <>
class AttributeAdapter<op::MVNEpsMode>;
template <>
class AttributeAdapter<op::v1::Reverse::Mode>;
template <>
class AttributeAdapter<op::v1::NonMaxSuppression::BoxEncodingType>;
template <>
class AttributeAdapter<op::v1::BinaryConvolution::BinaryConvolutionMode>;
template <>
class AttributeAdapter<op::v3::ROIAlign::PoolingMode>;
template <>
class AttributeAdapter<op::v4::Interpolate::InterpolateMode>;
template <>
class AttributeAdapter<op::v4::Interpolate::CoordinateTransformMode>;
template <>
class AttributeAdapter<op::v4::Interpolate::ShapeCalcMode>;
template <>
class AttributeAdapter<op::v4::Interpolate::NearestMode>;
template <>
class AttributeAdapter<op::v0::SpaceToDepth::SpaceToDepthMode>;
template <>
class AttributeAdapter<op::v3::NonMaxSuppression::BoxEncodingType>;
template <>
class AttributeAdapter<op::v0::DepthToSpace::DepthToSpaceMode>;
template <>
class AttributeAdapter<op::RoundingType>;
template <>
class AttributeAdapter<op::v0::Interpolate::InterpolateMode>;
template <>
class AttributeAdapter<op::RecurrentSequenceDirection>;
template <>
class AttributeAdapter<op::TopKMode>;
template <>
class AttributeAdapter<op::util::MulticlassNmsBase::SortResultType>;
template <>
class AttributeAdapter<op::TopKSortType>;
template <>
class AttributeAdapter<op::PadType>;
class AttributeVisitor;
class AxisSet;
class AxisVector;
class BaseOpExtension;
class Busy;
class Cancelled;
class CompiledModel;
class Coordinate;
class CoordinateDiff;
class Core;
class Decompression;
class DequantizationNode;
class Dimension;
template <typename AT>
class DirectValueAccessor;
class DisableFP16Compression;
template <typename AT>
class EnumAttributeAdapterBase;
template <typename T>
class EnumMask;
template <typename EnumType>
class EnumNames;
class Exception;
class Extension;
class FusedNames;
class ICompiledModel;
class IPlugin;
template <typename AT, typename VAT>
class IndirectScalarValueAccessor;
template <typename AT, typename VAT>
class IndirectVectorValueAccessor;
class InferRequest;
template <typename NodeType>
class Input;
template <>
class Input<const Node>;
template <>
class Input<Node>;
class Interval;
class Layout;
class LayoutAttribute;
class Model;
class NmsSelectedIndices;
class NoTransposeSinkingAttr;
class Node;
class NodeValidationFailure;
class NonconvertibleDivide;
class NotImplemented;
class OldApiMapElementType;
class OldApiMapOrder;
template <class T>
class OpExtension;
class OpSet;
template <>
class Output<const Node>;
template <>
class Output<Node>;
template <typename NodeType>
class Output;
class PartialShape;
class PrecisionSensitive;
class PreprocessingAttribute;
class PrimitivesPriority;
template <typename T, PropertyMutability mutability_ = PropertyMutability::RW>
class Property;
class RemoteContext;
class RemoteTensor;
class RuntimeAttribute;
template <class T, Direction D = Direction::FORWARD>
class SeqGen;
class Shape;
class Strides;
class StridesPropagation;
class Tensor;
template <>
class ValueAccessor<void \*>;
template <>
class ValueAccessor<void>;
template <typename VAT>
class ValueAccessor;
class VariableState;
class VisitorAdapter;
class bfloat16;
class float16;

// global variables

static constexpr Property<std::vector<PropertyName>, PropertyMutability::RO> caching_properties {"CACHING_PROPERTIES"};
static constexpr Property<std::vector<PropertyName>, PropertyMutability::RO> supported_properties {     "SUPPORTED_PROPERTIES"};
static constexpr Property<std::vector<std::string>, PropertyMutability::RO> available_devices {"AVAILABLE_DEVICES"};
static constexpr Property<std::string, PropertyMutability::RO> model_name {"NETWORK_NAME"};
static constexpr Property<uint32_t, PropertyMutability::RO> optimal_number_of_infer_requests {     "OPTIMAL_NUMBER_OF_INFER_REQUESTS"};
static constexpr Property<element::Type, PropertyMutability::RW> inference_precision {"INFERENCE_PRECISION_HINT"};
static constexpr Property<bool> enable_profiling {"PERF_COUNT"};
static constexpr Property<std::string> cache_dir {"CACHE_DIR"};
static constexpr Property<bool, PropertyMutability::RO> loaded_from_cache {"LOADED_FROM_CACHE"};
static constexpr Property<std::tuple<unsigned int, unsigned int>, PropertyMutability::RO> range_for_streams {     "RANGE_FOR_STREAMS"};
static constexpr Property<unsigned int, PropertyMutability::RO> optimal_batch_size {"OPTIMAL_BATCH_SIZE"};
static constexpr Property<uint32_t, PropertyMutability::RO> max_batch_size {"MAX_BATCH_SIZE"};
static constexpr Property<uint32_t, PropertyMutability::RW> auto_batch_timeout {"AUTO_BATCH_TIMEOUT"};
static constexpr Property<std::tuple<unsigned int, unsigned int, unsigned int>, PropertyMutability::RO> range_for_async_infer_requests {"RANGE_FOR_ASYNC_INFER_REQUESTS"};
static constexpr Property<bool, PropertyMutability::RW> force_tbb_terminate {"FORCE_TBB_TERMINATE"};
static constexpr Property<streams::Num, PropertyMutability::RW> num_streams {"NUM_STREAMS"};
static constexpr Property<int32_t, PropertyMutability::RW> inference_num_threads {"INFERENCE_NUM_THREADS"};
static constexpr Property<int32_t, PropertyMutability::RW> compilation_num_threads {"COMPILATION_NUM_THREADS"};
static constexpr Property<Affinity> affinity {"AFFINITY"};
static constexpr Property<std::vector<std::string>, PropertyMutability::RO> execution_devices {"EXECUTION_DEVICES"};

// global functions

void mark_as_decompression(const std::shared_ptr<Node>& node);
void unmark_as_decompression(const std::shared_ptr<Node>& node);
bool is_decompression(const std::shared_ptr<Node>& node);
void mark_as_dequantization_node(const std::shared_ptr<Node>& node);
bool is_dequantization_node(const std::shared_ptr<Node>& node);
void disable_fp16_compression(const std::shared_ptr<Node>& node);
void enable_fp16_compression(const std::shared_ptr<Node>& node);
bool fp16_compression_is_disabled(const std::shared_ptr<const Node>& node);
std::string getFusedNames(const std::shared_ptr<ov::Node>& node);
std::vector<std::string> getFusedNamesVector(const std::shared_ptr<ov::Node>& node);
bool has_nms_selected_indices(const Node \* node);
void set_nms_selected_indices(Node \* node);
void disable_divide_conversion(const std::shared_ptr<Node>& node);
void enable_divide_conversion(const std::shared_ptr<Node>& node);
bool divide_is_nonconvertible(const std::shared_ptr<Node>& node);
bool has_old_api_map_element_type(const std::shared_ptr<Node>& node);
OldApiMapElementType get_old_api_map_element_type(const std::shared_ptr<Node>& node);

void set_old_api_map_element_type(
    const std::shared_ptr<Node>& node,
    const OldApiMapElementType& old_api_map
    );

bool has_old_api_map_order(const std::shared_ptr<Node>& node);
OldApiMapOrder get_old_api_map_order(const std::shared_ptr<Node>& node);

void set_old_api_map_order(
    std::shared_ptr<Node>& node,
    const OldApiMapOrder& old_api_map
    );

bool is_preprocesing_node(const std::shared_ptr<Node>& node);
void set_is_preprocessing_node(std::shared_ptr<Node> node);
std::string getPrimitivesPriority(const std::shared_ptr<Node>& node);
bool has_strides_prop(const Input<Node>& node);
ov::Strides get_strides_prop(const Input<Node>& node);
void insert_strides_prop(Input<Node>& node, const Strides& strides);
void remove_strides_prop(Input<Node>& node);
void mark_as_no_sinking_node(const std::shared_ptr<Node>& node);
bool is_sinking_node(const std::shared_ptr<Node>& node);
bool is_sinking_node(const Node \* node);
bool is_sinking_node(ov::Output<ov::Node> output);

template <typename A, typename B>
A copy_from(B& b);

OPENVINO_API std::ostream& operator << (std::ostream& s, const AxisSet& axis_set);

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const AxisVector& axis_vector
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const Coordinate& coordinate
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const CoordinateDiff& coordinate_diff
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& str,
    const Dimension& dimension
    );

template <typename Type, typename Value>
std::enable_if<std::is_convertible<Value, std::string>::value, Type>::type as_enum(const Value& value);

template <typename Value>
const std::string& as_string(Value value);

static std::ostream& write_all_to_stream(std::ostream& str);

template <typename T, typename... TS>
static std::ostream& write_all_to_stream(
    std::ostream& str,
    const T& arg,
    TS&&... args
    );

void create_extensions(std::vector<Extension::Ptr>&);

OPENVINO_API void traverse_nodes(
    const std::shared_ptr<const Model>& p,
    const std::function<void(const std::shared_ptr<Node>&)>& f
    );

OPENVINO_API void traverse_nodes(
    const Model \* p,
    const std::function<void(const std::shared_ptr<Node>&)>& f
    );

OPENVINO_API void traverse_nodes(
    const NodeVector& subgraph_results,
    const std::function<void(const std::shared_ptr<Node>&)>& f,
    const NodeVector& subgraph_params = {}
    );

OPENVINO_API void replace_node(
    const std::shared_ptr<Node>& target,
    const std::shared_ptr<Node>& replacement,
    const std::vector<int64_t>& output_order
    );

OPENVINO_API void replace_node(
    const std::shared_ptr<Node>& target,
    const OutputVector& replacement_values
    );

OPENVINO_API void replace_node(
    const std::shared_ptr<Node>& target,
    const std::shared_ptr<Node>& replacement
    );

OPENVINO_API void replace_nodes(
    const std::shared_ptr<Model>& f,
    const std::unordered_map<std::shared_ptr<op::v0::Parameter>, std::shared_ptr<op::v0::Parameter>>& parameter_replacement_map,
    const std::unordered_map<std::shared_ptr<Node>, std::shared_ptr<Node>>& body_replacement_map
    );

template <typename T>
std::vector<std::shared_ptr<Node>> topological_sort(T root_nodes);

OPENVINO_API std::shared_ptr<ov::Model> clone_model(
    const ov::Model& model,
    std::unordered_map<Node \*, std::shared_ptr<Node>>& node_map
    );

OPENVINO_API std::shared_ptr<ov::Model> clone_model(const ov::Model& model);

OPENVINO_API bool compare_constants(
    const std::shared_ptr<Node>& n1,
    const std::shared_ptr<Node>& n2
    );

OPENVINO_API bool replace_output_update_name(
    Output<Node> node,
    const Output<Node>& node_input
    );

OPENVINO_API bool replace_node_update_name(
    const std::shared_ptr<Node>& target,
    const std::shared_ptr<Node>& replacement
    );

OPENVINO_API void serialize(
    const std::shared_ptr<const ov::Model>& m,
    const std::string& xml_path,
    const std::string& bin_path = "",
    ov::pass::Serialize::Version version = ov::pass::Serialize::Version::UNSPECIFIED
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& str,
    const Interval& interval
    );

OPENVINO_API std::ostream& operator << (std::ostream&, const Model&);
OPENVINO_API ov::Dimension get_batch(const std::shared_ptr<const ov::Model>& f);

OPENVINO_API void set_batch(
    const std::shared_ptr<ov::Model>& model,
    ov::Dimension batch_size
    );

OPENVINO_API std::string node_validation_failure_loc_string(const Node \* node);
OPENVINO_API std::ostream& operator << (std::ostream&, const Node&);
OPENVINO_API std::ostream& operator << (std::ostream&, const Node \*);

template <typename T>
void check_new_args_count(const Node \* node, T new_args);

OPENVINO_API std::ostream& operator << (
    std::ostream& out,
    const Input<Node>& input
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& out,
    const Input<const Node>& input
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& out,
    const Output<Node>& output
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& out,
    const Output<const Node>& output
    );

OPENVINO_API OutputVector as_output_vector(const NodeVector& args);
OPENVINO_API NodeVector as_node_vector(const OutputVector& values);
OPENVINO_API ResultVector as_result_vector(const OutputVector& values);

OPENVINO_API PartialShape operator + (
    const PartialShape& s1,
    const PartialShape& s2
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& str,
    const PartialShape& shape
    );

OPENVINO_API void copy_runtime_info(
    const std::shared_ptr<ov::Node>& from,
    const std::shared_ptr<ov::Node>& to
    );

OPENVINO_API void copy_runtime_info(
    const std::shared_ptr<ov::Node>& from,
    ov::NodeVector to
    );

OPENVINO_API void copy_runtime_info(
    const ov::NodeVector& from,
    const std::shared_ptr<ov::Node>& to
    );

OPENVINO_API void copy_runtime_info(
    const ov::NodeVector& from,
    ov::NodeVector to
    );

OPENVINO_API void copy_output_runtime_info(
    const ov::OutputVector& from,
    ov::OutputVector to
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& os,
    const RuntimeAttribute& attrubute
    );

template <typename SHAPE_TYPE>
size_t shape_size(const SHAPE_TYPE& shape);

template <typename ForwardIt>
size_t shape_size(
    ForwardIt start_dim,
    const ForwardIt end_dim
    );

template <typename SHAPE_TYPE>
std::vector<size_t> row_major_strides(const SHAPE_TYPE& shape);

template <typename SHAPE_TYPE>
size_t row_major_stride(
    const SHAPE_TYPE& shape,
    size_t axis
    );

template <typename SHAPE_TYPE>
bool is_scalar(const SHAPE_TYPE& shape);

template <typename SHAPE_TYPE>
bool is_vector(const SHAPE_TYPE& shape);

OPENVINO_API std::ostream& operator << (std::ostream& s, const Shape& shape);
OPENVINO_API std::ostream& operator << (std::ostream& s, const Strides& strides);

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const DiscreteTypeInfo& info
    );

bool ::type is_type(Value value);
Type \*::type as_type(Value value);

template <typename T, typename U>
auto as_type_ptr(const U& value);

OPENVINO_API PartialShape infer_convolution_forward(
    const Node \* node,
    const PartialShape& data_batch_shape,
    const Strides& data_dilation,
    const CoordinateDiff& data_padding_below,
    const CoordinateDiff& data_padding_above,
    const PartialShape& filters_shape,
    const Strides& filter_strides,
    const Strides& filter_dilation
    );

OPENVINO_API void infer_auto_padding(
    const Shape& image_shape,
    const Shape& filter_shape,
    const Strides& filter_strides,
    const Strides& filter_dilations,
    const op::PadType pad_type,
    CoordinateDiff& padding_above,
    CoordinateDiff& padding_below
    );

OPENVINO_API int64_t normalize(const int64_t& value, const int64_t& max);

OPENVINO_API int64_t normalize_axis(
    const Node \* node,
    std::int64_t axis,
    const Rank& tensor_rank
    );

OPENVINO_API std::vector<size_t> normalize_axes(
    const std::string& node_description,
    const std::vector<int64_t>& axes,
    const Rank& tensor_rank
    );

OPENVINO_API int64_t normalize_axis(
    const std::string& node_description,
    std::int64_t axis,
    const Rank& tensor_rank
    );

OPENVINO_API int64_t normalize_axis(
    const Node \* node,
    std::int64_t axis,
    std::uint64_t tensor_rank,
    std::int64_t axis_range_min,
    std::int64_t axis_range_max
    );

OPENVINO_API int64_t normalize_axis(
    const std::string& node_description,
    std::int64_t axis,
    std::uint64_t tensor_rank,
    std::int64_t axis_range_min,
    std::int64_t axis_range_max
    );

OPENVINO_API void normalize_axes(
    const Node \* node,
    const int64_t& tensor_rank,
    std::vector<int64_t>& axes
    );

OPENVINO_API bool evaluate_as_partial_shape(
    const Output<Node>& output,
    PartialShape& pshape
    );

OPENVINO_API std::shared_ptr<op::v0::Constant> get_constant_from_source(const Output<Node>& source);

OPENVINO_API bool default_label_evaluator(
    const Node \* node,
    TensorLabelVector& output_labels
    );

OPENVINO_API void generate_transpose_default_order(
    std::vector<int64_t>& axes_order,
    const size_t length
    );

OPENVINO_API bool is_valid_axes_order(
    const std::vector<int64_t>& axes_order,
    const size_t size
    );

OPENVINO_API bool has_no_labels(const TensorLabel& labels);
OPENVINO_API std::vector<PartialShape> get_node_input_partial_shapes(const ov::Node& node);

OPENVINO_API bool is_rank_compatible_any_of(
    const ov::Rank& rank,
    const std::vector<ov::Rank>& ranks
    );

OPENVINO_API bool are_unique(const std::vector<int64_t>& data);

OPENVINO_API int64_t clip(
    const int64_t& value,
    const int64_t& min,
    const int64_t& max
    );

OPENVINO_API std::shared_ptr<op::v0::Constant> constantfold_subgraph(const Output<Node>& subgraph_sink);
OPENVINO_API std::ostream& operator << (std::ostream& s, const Version& version);

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const std::map<std::string, Version>& versions
    );

OPENVINO_API_C(const Version);

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v1::BinaryConvolution::BinaryConvolutionMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v0::DepthToSpace::DepthToSpaceMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v9::GridSample::InterpolationMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v9::GridSample::PaddingMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v0::Interpolate::InterpolateMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v4::Interpolate::InterpolateMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v4::Interpolate::CoordinateTransformMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v4::Interpolate::NearestMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v4::Interpolate::ShapeCalcMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::LSTMWeightsFormat& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v8::MatrixNms::DecayFunction& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v8::MatrixNms::SortResultType& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v1::NonMaxSuppression::BoxEncodingType& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v3::NonMaxSuppression::BoxEncodingType& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v5::NonMaxSuppression::BoxEncodingType& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v9::NonMaxSuppression::BoxEncodingType& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v1::Reverse::Mode& type
    );

std::ostream& operator << (
    std::ostream& s,
    const op::v3::ROIAlign::PoolingMode& mode
    );

std::ostream& operator << (
    std::ostream& s,
    const op::v9::ROIAlign::PoolingMode& mode
    );

std::ostream& operator << (
    std::ostream& s,
    const op::v9::ROIAlign::AlignedMode& mode
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v5::Round::RoundMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::v0::SpaceToDepth::SpaceToDepthMode& type
    );

OPENVINO_API std::ostream& operator << (
    std::ostream& s,
    const op::util::MulticlassNmsBase::SortResultType& type
    );

void OPENVINO_API mark_as_precision_sensitive(ov::Input<ov::Node> node_input);
void OPENVINO_API unmark_as_precision_sensitive(ov::Input<ov::Node> node_input);
bool OPENVINO_API is_precision_sensitive(const ov::Input<ov::Node>& node_input);
const OPENVINO_API OpSet& get_opset1();
const OPENVINO_API OpSet& get_opset2();
const OPENVINO_API OpSet& get_opset3();
const OPENVINO_API OpSet& get_opset4();
const OPENVINO_API OpSet& get_opset5();
const OPENVINO_API OpSet& get_opset6();
const OPENVINO_API OpSet& get_opset7();
const OPENVINO_API OpSet& get_opset8();
const OPENVINO_API OpSet& get_opset9();
const OPENVINO_API OpSet& get_opset10();
const OPENVINO_API std::map<std::string, std::function<const ov::OpSet&()>>& get_available_opsets();

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_raw_data_as(
    const element::Type_t et,
    const void \*const ptr,
    const size_t size,
    UnaryOperation&& func
    );

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_tensor_data_as(
    HostTensor& tv,
    UnaryOperation&& func
    );

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_tensor_data_as(
    HostTensor \* tv,
    UnaryOperation&& func
    );

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_tensor_data_as(
    const Tensor& t,
    UnaryOperation&& func
    );

void FRONTEND_API shutdown();

static MemBandwidthPressure MemBandwidthPressureTolerance(
    const std::shared_ptr<ngraph::Function> nGraphFunc,
    const float cache_size,
    const float memThresholdAssumeLimited = MemBandwidthPressure::LIMITED
    );

} // namespace ov

Detailed Documentation

transformation aligns elementwise constant inputs ranks with its output rank

OpenVINO C++ API.

Resolves transpose_b key from MatMul operation if corresponding input is constant or FakeQuantize by inserting Transpose.

Typedefs

typedef std::vector<label_t> TensorLabel

Alias for label tensor.

typedef std::vector<TensorLabel> TensorLabelVector

Alias for vector of label tensors.

typedef uint32_t label_t

Alias for dimension label type.

typedef ov::RTMap EvaluationContext

EvaluationContext stores and manages a context (additional parameters, values and environment) for evaluating ov::Model.

typedef Dimension Rank

Alias for Dimension, used when the value represents the number of axes in a shape, rather than the size of one dimension in a shape.

typedef std::vector<Tensor> TensorVector

A vector of Tensor ‘s.

Global Functions

OPENVINO_API std::ostream& operator << (
    std::ostream& str,
    const Dimension& dimension
    )

Insert a human-readable representation of a dimension into an output stream.

Inserts the string ? if dimension is dynamic; else inserts dimension.get_length().

Parameters:

str

The output stream targeted for insertion.

dimension

The dimension to be inserted into str.

Returns:

A reference to str after insertion.

template <typename Type, typename Value>
std::enable_if<std::is_convertible<Value, std::string>::value, Type>::type as_enum(const Value& value)

Returns the enum value matching the string.

template <typename Value>
const std::string& as_string(Value value)

Returns the string matching the enum value.

void create_extensions(std::vector<Extension::Ptr>&)

The entry point for library with OpenVINO extensions.

Parameters:

vector

of extensions

OPENVINO_API void traverse_nodes(
    const NodeVector& subgraph_results,
    const std::function<void(const std::shared_ptr<Node>&)>& f,
    const NodeVector& subgraph_params = {}
    )

Visit each node in a sub-graph of the entire graph.

Traverses a sub-graph starting from subgraph_results moving up towards parameter nodes. Traversal stops if it hits a node in subgraph_params.

Most useful for finding parameters of a graph directly from the result nodes and not from function parameters or extracting a subgraph relevant to the computation of certain outputs

Parameters:

subgraph_results

The output nodes of the sub-graph

f

Model to execute at each node in the traversal

subgraph_params

Input nodes of the sub-graph (optional)

OPENVINO_API void replace_node(
    const std::shared_ptr<Node>& target,
    const std::shared_ptr<Node>& replacement,
    const std::vector<int64_t>& output_order
    )

Replace the node target with the node replacement, i.e., redirect all users and control dependencies of target to replacement.

This is primarily used in graph-rewriting passes. For example, we might “fuse” two Concat operations as follows:

(Step 0: Original graph)

A B | | v v N0[Concat, concatenation_axis=3] C | | v v N1[Concat, concatenation_axis=3] | | v v some_user another_user

(Step 1: Construct replacement)

shared_ptr<Node> new_N1 = make_shared<op::Concat>({A,B,C},3);

A————————————-. | | | B————-). | | | | v v | | N0[Concat, concatenation_axis=3] C–)). | | | | | v v v v v N1[Concat, concatenation_axis=3] new_N1[Concat, concatenation_axis=3] | | v v some_user another_user

(Step 2: Replace N1 with new_N1)

replace_node(N1, new_N1);

A————————————-. | | | B————-). | | | | v v | | N0[Concat, concatenation_axis=3] C–)). | | | | | v v v v v N1[Concat, concatenation_axis=3] new_N1[Concat, concatenation_axis=3] | | v v some_user another_user

(Step 3: N0 and N1 are now dead, nodes will be freed)

[happens automatically, once all shared_ptrs to N1 are released]

A————————————-. | B————-). | | | | C–)). | | | v v v new_N1[Concat, concatenation_axis=3] | | v v some_user another_user

NOTE 1: replace_node is not type-safe (the graph is not revalidated). For example, the following is allowed, even if node some_user requires an input of shape 2x2:

(Before) A(shape=2x2) B(shape=3x3) | v some_user(requires 2x2 input)

(After graph is now invalid)

replace_node(A, B);

A(shape=2x2)  B(shape=3x3)
              |
              v
           some_user(requires 2x2 input)

NOTE 2: it is possible to insert a cycle into the graph with replace_node, resulting in an invalid graph. Care must be taken to avoid this. One common example is when you are attempting to insert a new node M “after” a node N`. For example, you might expect this to work:

shared_ptr<Node> M = make_shared<SomeUnaryOp>(N); replace_node(M, N);

The problem is that at replacement time, N itself is a user of M. So we end up introducing a cycle as follows:

N
|
v

other users…

|||
vvv

 N------------>M
 |
 v

other users…

|||
vvv

         .----.
        |      |
        |      |
 N      `----->M
               |
               v
          other users...

To avoid the cycle, a valid way to perform the above desired insertion would be,

auto new_N = N->clone_with_new_inputs(N->input_values());
shared_ptr<Node> M = make_shared<SomeUnaryOp>(new_N);
replace_node(N, M);

Parameters:

target

Node to be replaced.

replacement

Node to replace target with.

output_order

Vector determines order of replacement node’s outputs.

OPENVINO_API void replace_node(
    const std::shared_ptr<Node>& target,
    const OutputVector& replacement_values
    )

Replace target.outputs[i] with replacement_values[i] and transfer control dependents and.

OPENVINO_API void replace_nodes(
    const std::shared_ptr<Model>& f,
    const std::unordered_map<std::shared_ptr<op::v0::Parameter>, std::shared_ptr<op::v0::Parameter>>& parameter_replacement_map,
    const std::unordered_map<std::shared_ptr<Node>, std::shared_ptr<Node>>& body_replacement_map
    )

Replace multiple nodes in a function.

Limitations:

  • No check is made that the replaced nodes in parameter_replacement_map are actually among the bound parameters of f. (If a parameter appears in the map that is not bound by f, it will be silently ignored.)

  • If a parameter node appears as a key in both parameter_replacement_map and in body_replacement_map, behavior is unspecified.

Parameters:

f

Model where replacement is taking place.

parameter_replacement_map

A mapping from parameter shared pointers to parameter shared pointers. For each pair (k,v) in the map, parameter k is replaced by parameter v, except if k==v or k is not a parameter bound by f, in which case the pair (k,v) is ignored.

body_replacement_map

A mapping from node shared pointers to node shared pointers. For each pair (k,v) in the map, node k is replaced by node v, except if k==v, the pair (k,v) is ignored. Note that if k is a parameter, its users will be redirected to v, but k will not be replaced in the function’s parameter list.

template <typename T>
std::vector<std::shared_ptr<Node>> topological_sort(T root_nodes)

Topological sort of nodes needed to compute root_nodes.

OPENVINO_API void serialize(
    const std::shared_ptr<const ov::Model>& m,
    const std::string& xml_path,
    const std::string& bin_path = "",
    ov::pass::Serialize::Version version = ov::pass::Serialize::Version::UNSPECIFIED
    )

Serialize given model into IR. The generated .xml and .bin files will be saved into provided paths.

Parameters:

m

Model which will be converted to IR representation.

xml_path

Path where .xml file will be saved.

bin_path

Path where .bin file will be saved (optional). The same name as for xml_path will be used by default.

version

Version of the generated IR (optional).

OPENVINO_API ov::Dimension get_batch(const std::shared_ptr<const ov::Model>& f)

Helper method to get associated batch size for a Model.

Checks layout of each parameter in a Model and extracts value for N (B) dimension. All values are then merged and returned

Parameters:

ov::AssertFailure

with details in case of error. Possible errors are:

  • There is no parameter with layout set. Model shall have at least one parameter with layout with ‘N’ dimension. Recommended fix is to use Parameter::set_layout API, e.g. model->get_parameters()[some_index]->set_layout("NCHW");

  • Several parameters have conflicting N dimension, e.g. param1 NCHW{1,3,224,224} and param2 NCHW{2,3,224,224}. This is ambiguous, most probably first dimension is incorrectly marked as ‘batch’ (N) in some layout. User shall fix it before using of ‘get_batch’ (in example above correct layout for param2 from ‘NCHW’ to ‘CHWN’)

f

Model where to look for a batch_size value

Returns:

Dimension representing current batch size. Can represent a number or be a dynamic

OPENVINO_API void set_batch(
    const std::shared_ptr<ov::Model>& model,
    ov::Dimension batch_size
    )

Helper method to set batch size to a Model.

Checks layout of each parameter in a Model and sets value for N (B) dimension. Then performs validation and type propagation

Parameters:

ov::AssertFailure

with details in case of error. Possible errors are:

  • There is no parameter with N dimension in layout. Model shall have at least one parameter with layout with ‘N’ dimension. Recommended fix is to use Parameter::set_layout API, e.g. model->get_parameters()[some_index]->set_layout("NCHW");

  • Several parameters have conflicting N dimension, e.g. param1 NCHW{1,3,224,224} and param2 NCHW{3,224,224,1}. This is ambiguous (1 != 3), most probably some dimension is incorrectly marked as ‘batch’ (N) in some layout. User shall fix it before using of ‘set_batch’ (in example above correct layout for param2 from ‘NCHW’ to ‘CHWN’)

  • Validation fails after setting batch_size. Model becomes in inconsistent state after new batch size value is applied. Possible reason could be that layout was not set for some parameters, or batch size can’t be applied to model at all

model

model where to set batch_size value

batch_size

Batch size value. For dynamic batch size, Dimension::dynamic() can be passed.

OPENVINO_API ResultVector as_result_vector(const OutputVector& values)

Returns a ResultVector referencing values.

OPENVINO_API PartialShape operator + (
    const PartialShape& s1,
    const PartialShape& s2
    )

Elementwise addition of two PartialShape objects.

  • If s1 or s2 has dynamic rank, returns PartialShape::dynamic().

  • If s1 and s2` both have static rank, and their ranks are unequal, throws std::invalid_argument.

  • If s1 and s2 both have static rank, and their ranks are equal, returns a new shape whose i th dimension is s1[i] + s2[i].

Parameters:

s1

Left operand for addition.

s2

Right operand for addition.

std::invalid_argument

If s1 and s2 have inconsistent ranks.

Returns:

The result of elementwise adding s1 to s2 (see description).

OPENVINO_API std::ostream& operator << (
    std::ostream& str,
    const PartialShape& shape
    )

Inserts a human-readable representation of a PartialShape into an output stream.

The output to the stream is in “informal” notation. In other words:

  • If shape has dynamic rank, inserts the string ?.

  • If shape has static rank, inserts the string {, then inserts each dimension of shape into the output stream separated by commas, then inserts }.

Example:

PartialShape s1{PartialShape::dynamic())};
PartialShape s2{};
PartialShape s3{1,Dimension::dynamic(),2,3};
PartialShape s4{2,3,4};
std::cout << s1 << std::endl
          << s2 << std::endl
          << s3 << std::endl
          << s4 << std::endl;

Output :

?
{}
{1,?,2,3}
{2,3,4}

Parameters:

str

The output stream targeted for insertion.

shape

The shape to be inserted into str.

Returns:

A reference to str after insertion.

template <typename SHAPE_TYPE>
std::vector<size_t> row_major_strides(const SHAPE_TYPE& shape)

Row-major strides for a shape.

template <typename T, typename U>
auto as_type_ptr(const U& value)

Casts a std::shared_ptr<Value> to a std::shared_ptr<Type> if it is of type Type, nullptr otherwise

OPENVINO_API int64_t normalize(const int64_t& value, const int64_t& max)

Normalize value to the max if value is negative.

Parameters:

value

Input value to normalize.

max

Value used for normalization

Returns:

Value if positive otherwise return value + max

OPENVINO_API int64_t normalize_axis(
    const Node \* node,
    std::int64_t axis,
    const Rank& tensor_rank
    )

Handle out of range axis.

Parameters:

node

The node with requested axis.

axis

The requested axis value.

tensor_rank

The corresponding tensor rank.

Returns:

Checking if axis is in range [-tensor_rank, tensor_rank-1], otherwise returns error. If negative axis, it counts from the last to the first axis, by adding tensor_rank to axis.

OPENVINO_API std::vector<size_t> normalize_axes(
    const std::string& node_description,
    const std::vector<int64_t>& axes,
    const Rank& tensor_rank
    )

Handle out of range axes in vector.

Parameters:

node_description

The name of node with requested axes.

axes

The requested vector of axes.

tensor_rank

The corresponding tensor rank.

Returns:

If any negative axis in vector, it counts from the last to the first axis, by adding tensor_rank to axis.

OPENVINO_API int64_t normalize_axis(
    const std::string& node_description,
    std::int64_t axis,
    const Rank& tensor_rank
    )

Handle out of range axis.

Parameters:

node_description

The node with requested axis.

axis

The requested axis value.

tensor_rank

The corresponding tensor rank.

Returns:

Checking if axis is in range [-tensor_rank, tensor_rank-1], otherwise returns error. If negative axis, it counts from the last to the first axis, by adding tensor_rank to axis.

OPENVINO_API int64_t normalize_axis(
    const Node \* node,
    std::int64_t axis,
    std::uint64_t tensor_rank,
    std::int64_t axis_range_min,
    std::int64_t axis_range_max
    )

Handle out of range axis.

Parameters:

node

The node with requested axis.

axis

The requested axis value.

tensor_rank

The corresponding tensor rank.

axis_range_min

The min value of accepted range for axis.

axis_range_max

The max value of accepted range for axis.

Returns:

Checking if axis is in range [axis_range_min, axis_range_max], otherwise returns error. If negative axis, it counts from the last to the first axis, by adding tensor_rank to axis.

OPENVINO_API int64_t normalize_axis(
    const std::string& node_description,
    std::int64_t axis,
    std::uint64_t tensor_rank,
    std::int64_t axis_range_min,
    std::int64_t axis_range_max
    )

Handle out of range axis.

Parameters:

node_description

The name of node with requested axis.

axis

The requested axis value.

tensor_rank

The corresponding tensor rank.

axis_range_min

The min value of accepted range for axis.

axis_range_max

The max value of accepted range for axis.

Returns:

Checking if axis is in range [axis_range_min, axis_range_max], otherwise returns error. If negative axis, it counts from the last to the first axis, by adding tensor_rank to axis.

OPENVINO_API void normalize_axes(
    const Node \* node,
    const int64_t& tensor_rank,
    std::vector<int64_t>& axes
    )

Handle out of range axes in vector. If any negative axis in vector, it counts from the last to the first axis, by adding tensor_rank to axis. Changes axes vector inplace.

Parameters:

node

The node with requested axes.

tensor_rank

The corresponding tensor rank.

axes

The requested vector of axes.

OPENVINO_API bool evaluate_as_partial_shape(
    const Output<Node>& output,
    PartialShape& pshape
    )

Evaluates lower and upper value estimations for the output tensor. Estimation would be represented as partial shape object using Dimension(min, max) for each element.

Parameters:

output

Node output pointing to the tensor for estimation.

pshape

Resulting estimation would be stored in this PartialShape.

Returns:

boolean status if value evaluation was successful.

OPENVINO_API std::shared_ptr<op::v0::Constant> get_constant_from_source(const Output<Node>& source)

Runs an estimation of source tensor. If it succeeded to calculate both bounds and they are the same returns Constant operation from the resulting bound, otherwise nullptr.

OPENVINO_API bool default_label_evaluator(
    const Node \* node,
    TensorLabelVector& output_labels
    )

Propagates value label from 0 input to the only output through an operation. Not applicable for operations which require values interaction (example: mathematical operations). Could be used for movement operations (example: gathering, shape change)

Parameters:

node

Operation to be performed

output_labels

Vector of TensorLabel objects representing resulting value labels

Returns:

boolean status if label evaluation was successful.

OPENVINO_API void generate_transpose_default_order(
    std::vector<int64_t>& axes_order,
    const size_t length
    )

Generates transpose default axes order at end of input vector.

Default axes order is decreasing sequence numbers which start from length - 1.

Parameters:

axes_order

Vector where default order will be generated.

length

Sequence length of axes order.

OPENVINO_API bool is_valid_axes_order(
    const std::vector<int64_t>& axes_order,
    const size_t size
    )

Check if vector of axes order has got valid values.

Axes order has to be unique numbers in range of [0, size).

Parameters:

axes_order

Vector with axes order to check.

size

Input for transpose rank size.

Returns:

true if axes order is valid otherwise false.

OPENVINO_API bool has_no_labels(const TensorLabel& labels)

Checks label tensor if there is no label.

Parameters:

labels

Label tensor for check.

Returns:

True if there is no labels, otherwise false.

OPENVINO_API std::vector<PartialShape> get_node_input_partial_shapes(const ov::Node& node)

Get the node input partial shapes.

Parameters:

node

Node to extract input shapes.

Returns:

Vector of PartialShapes of each input.

OPENVINO_API bool is_rank_compatible_any_of(
    const ov::Rank& rank,
    const std::vector<ov::Rank>& ranks
    )

Check if rank is compatible to any of rank from container.

Parameters:

rank

Rank to check.

ranks

VEctor of ranks used to check input rank compatibility.

Returns:

True if rank compatible to any from ranks, otherwise false.

OPENVINO_API bool are_unique(const std::vector<int64_t>& data)

Check if values in vector are unique.

Parameters:

data

Input data to check.

Returns:

True if unique otherwise false.

OPENVINO_API int64_t clip(
    const int64_t& value,
    const int64_t& min,
    const int64_t& max
    )

Clip value to minimum if below min, or to maximum of above max.

Parameters:

value

Value to be clipped.

min

Minimum value bound.

max

Maximum value boiund

Returns:

Value if between min, max otherwise min or max.

OPENVINO_API std::shared_ptr<op::v0::Constant> constantfold_subgraph(const Output<Node>& subgraph_sink)

Constant folds a subgraph to a constant node.

Parameters:

subgraph

sink

Returns:

Constant node or nullptr if unable to constantfold the subgraph

OPENVINO_API_C(const Version)

Gets the current OpenVINO version.

Returns:

The current OpenVINO version

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_raw_data_as(
    const element::Type_t et,
    const void \*const ptr,
    const size_t size,
    UnaryOperation&& func
    )

Get the raw data as TResult object.

Parameters:

T

TResult data type.

TResult

Type of return object, must support creation of std::inserter. Default std::vector<T>.

UnaryOperation

Unary function object applied on data with signature (T f(const U u)).

et

Element type of input data.

ptr

Pointer to data of type et.

size

Data size as number of elements.

func

Unary operation function object.

ov::AssertionFailure

for not supported element type.

Returns:

Object of TResult with data from input pointer and transformed by unary operation.

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_tensor_data_as(
    HostTensor& tv,
    UnaryOperation&& func
    )

Get data from Host tensor as object TResult.

Parameters:

T

TResult data type.

TResult

Type of return object, must support creation of std::inserter. Default std::vector<T>.

UnaryOperation

Unary function object applied on data with signature (T f(const U u)).

tv

Input host tensor.

func

Unary operation function object.

Returns:

Object of TResult with data from host tensor.

template <class T, class TResult = std::vector<T>, class UnaryOperation>
TResult get_tensor_data_as(
    const Tensor& t,
    UnaryOperation&& func
    )

Get data from ov:tensor as object TResult.

Parameters:

T

TResult data type.

TResult

Type of return object, must support creation of std::inserter. Default std::vector<T>.

UnaryOperation

Unary function object applied on data with signature (T f(const U u)).

t

Input tensor.

func

Unary operation function object.

Returns:

Object of TResult with data from tensor.

void FRONTEND_API shutdown()

Shut down the OpenVINO by deleting all static-duration objects allocated by the library and releasing dependent resources.

This function should be used by advanced user to control unload the resources.

You might want to use this function if you are developing a dynamically-loaded library which should clean up all resources after itself when the library is unloaded.