natas_hw
/
openvino
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove ngraph node (#22460)

This commit is contained in:
Oleg Pipikin 2024-01-29 18:40:24 +01:00 committed by GitHub
parent 679ce62c73
commit 8073c7be9f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
81 changed files with 167 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
docs/snippets/lpt_intel_cpu_plugin.cpp
View File

@ -52,12 +52,12 @@ if (useLpt) {
if (useLpt) {
// convert not supported cases FakeQuantize -> Convert -> Convert -> Subtract -> Multiply to a single FakeQuantize
pass_config->set_callback<ov::pass::ConvertQuantizeDequantize>([&defaultPrecisions](const std::shared_ptr<const ngraph::Node> &node) -> bool {
pass_config->set_callback<ov::pass::ConvertQuantizeDequantize>([&defaultPrecisions](const std::shared_ptr<const ov::Node> &node) -> bool {
return ov::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node, defaultPrecisions);
});
// convert not supported cases FakeQuantize -> Convert -> Convert -> Subtract -> Multiply to a single FakeQuantize
pass_config->set_callback<ov::pass::ConvertSubtract>([&defaultPrecisions](const std::shared_ptr<const ngraph::Node> &node) -> bool {
pass_config->set_callback<ov::pass::ConvertSubtract>([&defaultPrecisions](const std::shared_ptr<const ov::Node> &node) -> bool {
return ov::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node, defaultPrecisions);
});
}
@ -95,16 +95,16 @@ if (useLpt) {
lptManager.register_pass<ov::pass::low_precision::LowPrecision>(supportedPrecisions, perTensorQuantization);
// Low precision transformations plugin specific configuration: transformation callbacks definition
lptManager.get_pass_config()->set_callback<MarkupPrecisions>([](const std::shared_ptr<const ngraph::Node>& node) -> bool {
lptManager.get_pass_config()->set_callback<MarkupPrecisions>([](const std::shared_ptr<const ov::Node>& node) -> bool {
if (const auto multiply = std::dynamic_pointer_cast<const ov::opset1::Multiply>(node)) {
return !MultiplyToGroupConvolutionTransformation::canBeTransformedToGroupConvolution(multiply);
}
return false;
});
lptManager.get_pass_config()->set_callback<ConvolutionBackpropDataTransformation>([&defaultPrecisions](const std::shared_ptr<const ngraph::Node>& node) -> bool {
lptManager.get_pass_config()->set_callback<ConvolutionBackpropDataTransformation>([&defaultPrecisions](const std::shared_ptr<const ov::Node>& node) -> bool {
return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || WeightableLayerTransformation::isAsymmetricOnWeights(node);
});
lptManager.get_pass_config()->set_callback<MultiplyToGroupConvolutionTransformation>([](const std::shared_ptr<const ngraph::Node>& node) -> bool {
lptManager.get_pass_config()->set_callback<MultiplyToGroupConvolutionTransformation>([](const std::shared_ptr<const ov::Node>& node) -> bool {
return MultiplyToGroupConvolutionTransformation::isDynamicOrScalar(node);
});
@ -177,7 +177,7 @@ using namespace ov::pass::low_precision;
ov::pass::Manager lptManager;
lptManager.register_pass<ov::pass::low_precision::LowPrecision>();
lptManager.get_pass_config()->set_callback<ConvolutionBackpropDataTransformation>([&defaultPrecisions](const std::shared_ptr<const ngraph::Node>& node) -> bool {
lptManager.get_pass_config()->set_callback<ConvolutionBackpropDataTransformation>([&defaultPrecisions](const std::shared_ptr<const ov::Node>& node) -> bool {
return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || WeightableLayerTransformation::isAsymmetricOnWeights(node);
});
lptManager.run_passes(nGraphFunc);

30
src/core/include/ngraph/evaluator.hpp
View File

@ -19,8 +19,8 @@
#include <utility>
#include "ngraph/deprecated.hpp"
#include "ngraph/node.hpp"
#include "ngraph/shape.hpp"
#include "openvino/core/node.hpp"
#include "openvino/core/type/element_type_traits.hpp"
namespace ngraph {
@ -32,16 +32,16 @@ class NGRAPH_API_DEPRECATED Evaluator {
NGRAPH_SUPPRESS_DEPRECATED_START
public:
/// \brief values we compute for outputs
using value_map = std::map<RawNodeOutput, V>;
using value_map = std::map<ov::RawNodeOutput, V>;
/// \brief Handler for a computation of a value about an op
///
/// A handler is passed a Node* and a vector of computed input values. The handler should
/// return a vector of computed output values.
using op_handler = std::function<std::vector<V>(Node* op, std::vector<V>& inputs)>;
using op_handler = std::function<std::vector<V>(ov::Node* op, std::vector<V>& inputs)>;
/// \brief Table of ops with handlers
using op_handler_map = std::map<Node::type_info_t, op_handler>;
using op_handler_map = std::map<ov::Node::type_info_t, op_handler>;
/// \brief construct handler using the provided op handlers.
///
@ -78,7 +78,7 @@ public:
}
protected:
op_handler get_handler(Node* node) {
op_handler get_handler(ov::Node* node) {
op_handler handler = m_universal_handler;
if (!handler) {
auto it = m_handlers.find(node->get_type_info());
@ -98,27 +98,27 @@ protected:
/// \brief Intstructions for evaluations state machine
class Inst {
protected:
Inst(Node* node) : m_node(node) {}
Inst(ov::Node* node) : m_node(node) {}
public:
virtual ~Inst() {}
virtual void handle(Evaluator& evaluator, InstStack& inst_stack, Node* node) = 0;
Node* get_node() {
virtual void handle(Evaluator& evaluator, InstStack& inst_stack, ov::Node* node) = 0;
ov::Node* get_node() {
return m_node;
}
protected:
Node* m_node;
ov::Node* m_node;
};
/// \brief Ensure value has been analyzed
class ValueInst : public Inst {
public:
ValueInst(const ov::Output<Node>& value) : Inst(value.get_node()), m_index(value.get_index()) {}
ValueInst(const ov::Output<ov::Node>& value) : Inst(value.get_node()), m_index(value.get_index()) {}
ValueInst(const RawNodeOutput& value) : Inst(value.node), m_index(value.index) {}
ValueInst(const ov::RawNodeOutput& value) : Inst(value.node), m_index(value.index) {}
void handle(Evaluator& evaluator, InstStack& inst_stack, Node* node) override {
void handle(Evaluator& evaluator, InstStack& inst_stack, ov::Node* node) override {
// Request to analyze this value if we can
if (auto handler = evaluator.get_handler(node)) {
// Ensure the inputs are processed and then execute the op handler
@ -141,9 +141,9 @@ protected:
/// \brief All arguments have been handled; execute the node handler
class ExecuteInst : public Inst {
public:
ExecuteInst(Node* node, op_handler& handler) : Inst(node), m_handler(handler) {}
ExecuteInst(ov::Node* node, op_handler& handler) : Inst(node), m_handler(handler) {}
void handle(Evaluator& evaluator, InstStack& inst_stack, Node* node) override {
void handle(Evaluator& evaluator, InstStack& inst_stack, ov::Node* node) override {
// Request to execute the handleer. Pass what we know about the inputs to the
// handler and associate the results with the outputs
std::vector<V> inputs;
@ -162,7 +162,7 @@ protected:
public:
/// \brief Determine information about value
V evaluate(const ov::Output<Node>& value) {
V evaluate(const ov::Output<ov::Node>& value) {
InstStack inst_stack;
inst_stack.push(InstPtr(new ValueInst(value)));
while (!inst_stack.empty()) {

70
src/core/include/ngraph/graph_util.hpp
View File

@ -25,7 +25,7 @@
#include <vector>
#include "ngraph/check.hpp"
#include "ngraph/node.hpp"
#include "ngraph/deprecated.hpp"
#include "openvino/core/graph_util.hpp"
namespace ov {
@ -53,17 +53,19 @@ using ov::replace_output_update_name;
using ov::topological_sort;
using ov::traverse_nodes;
using NodeMap = std::unordered_map<ov::Node*, std::shared_ptr<ov::Node>>;
NGRAPH_API_DEPRECATED
NGRAPH_API
ov::NodeVector find_common_args(std::shared_ptr<Node> target, std::shared_ptr<Node> replacement);
ov::NodeVector find_common_args(std::shared_ptr<ov::Node> target, std::shared_ptr<ov::Node> replacement);
/// Topological sort of just nodes
template <typename T>
NGRAPH_API_DEPRECATED std::vector<std::shared_ptr<Node>> subgraph_topological_sort(T nodes) {
std::stack<Node*, std::vector<Node*>> nodes_to_do;
std::unordered_set<Node*> nodes_done;
std::unordered_set<Node*> nodes_to_emit;
std::vector<std::shared_ptr<Node>> result;
NGRAPH_API_DEPRECATED std::vector<std::shared_ptr<ov::Node>> subgraph_topological_sort(T nodes) {
std::stack<ov::Node*, std::vector<ov::Node*>> nodes_to_do;
std::unordered_set<ov::Node*> nodes_done;
std::unordered_set<ov::Node*> nodes_to_emit;
std::vector<std::shared_ptr<ov::Node>> result;
for (auto& node : nodes) {
nodes_to_emit.insert(node.get());
@ -72,19 +74,19 @@ NGRAPH_API_DEPRECATED std::vector<std::shared_ptr<Node>> subgraph_topological_so
// NB: Some centos versions implement std::list::size() by counting elements
size_t nodes_remaining = nodes_to_emit.size();
while (nodes_to_do.size() > 0 && nodes_remaining > 0) {
Node* node = nodes_to_do.top();
ov::Node* node = nodes_to_do.top();
if (nodes_done.count(node) == 0) {
bool can_add = true;
size_t arg_count = node->get_input_size();
for (size_t i = 0; i < arg_count; ++i) {
Node* dep = node->get_input_node_ptr(arg_count - i - 1);
ov::Node* dep = node->get_input_node_ptr(arg_count - i - 1);
if (nodes_done.count(dep) == 0 && nodes_to_emit.count(node) != 0) {
can_add = false;
nodes_to_do.push(dep);
}
}
for (auto& depptr : node->get_control_dependencies()) {
Node* dep = depptr.get();
ov::Node* dep = depptr.get();
if (nodes_done.count(dep) == 0) {
can_add = false;
nodes_to_do.push(dep);
@ -119,53 +121,53 @@ NGRAPH_API_DEPRECATED void validate_nodes_and_infer_types(const T& nodes) {
// Check if all paths from X to a result go through Y
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_post_dominated(Node* X, Node* Y);
bool is_post_dominated(ov::Node* X, ov::Node* Y);
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_equal_to_const_value(const std::string& const_value, const ov::Output<Node>& reduce_constant);
bool is_equal_to_const_value(const std::string& const_value, const ov::Output<ov::Node>& reduce_constant);
// input nodes are cloned and returned
// NodeMap input may contain default node mapping i.e. pre-cloned nodes
// NodeMap output (by reference) fully maps input and cloned nodes
NGRAPH_API_DEPRECATED
NGRAPH_API
std::vector<std::shared_ptr<ngraph::Node>> clone_nodes(const std::vector<std::shared_ptr<ngraph::Node>>& nodes,
NodeMap& node_map);
std::vector<std::shared_ptr<ov::Node>> clone_nodes(const std::vector<std::shared_ptr<ov::Node>>& nodes,
NodeMap& node_map);
// input nodes are cloned and returned
// NodeMap input may contain default node mapping i.e. pre-cloned nodes
// NodeMap output (by reference) fully maps input and cloned nodes
NGRAPH_API_DEPRECATED
NGRAPH_API
std::list<std::shared_ptr<ngraph::Node>> clone_nodes(const std::vector<std::shared_ptr<ngraph::Node>>& nodes,
RawNodeOutputMap& node_map);
std::list<std::shared_ptr<ov::Node>> clone_nodes(const std::vector<std::shared_ptr<ov::Node>>& nodes,
ov::RawNodeOutputMap& node_map);
NGRAPH_API_DEPRECATED
NGRAPH_API
std::pair<std::shared_ptr<op::v0::Result>, std::shared_ptr<op::v0::Parameter>> insert_result_parameter_split(
const std::shared_ptr<Node>& src_node,
const std::shared_ptr<Node>& dst_node);
const std::shared_ptr<ov::Node>& src_node,
const std::shared_ptr<ov::Node>& dst_node);
NGRAPH_API_DEPRECATED
NGRAPH_API
void insert_new_node_between(const std::shared_ptr<Node>& src_node,
const std::shared_ptr<Node>& dst_node,
const std::shared_ptr<Node>& new_node);
void insert_new_node_between(const std::shared_ptr<ov::Node>& src_node,
const std::shared_ptr<ov::Node>& dst_node,
const std::shared_ptr<ov::Node>& new_node);
NGRAPH_API_DEPRECATED
NGRAPH_API
std::shared_ptr<Node> make_zero(const ov::element::Type& element_type, const ov::Shape& shape);
std::shared_ptr<ov::Node> make_zero(const ov::element::Type& element_type, const ov::Shape& shape);
NGRAPH_API_DEPRECATED
NGRAPH_API
std::shared_ptr<Node> make_constant_from_string(std::string val,
const ov::element::Type& element_type,
const ov::Shape& shape);
std::shared_ptr<ov::Node> make_constant_from_string(std::string val,
const ov::element::Type& element_type,
const ov::Shape& shape);
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_zero(const ov::Output<Node>& reduce_constant);
bool is_zero(const ov::Output<ov::Node>& reduce_constant);
NGRAPH_API_DEPRECATED
NGRAPH_API
@ -183,43 +185,43 @@ ov::NodeVector extract_subgraph(const ov::NodeVector& results, const ov::NodeVec
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_one(const ov::Output<Node>& reduce_constant);
bool is_one(const ov::Output<ov::Node>& reduce_constant);
// Returns true if `node` is live in the graph i.e. a result op
// transitively uses this `node`
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_used(Node* node);
bool is_used(ov::Node* node);
// Returns count of `node` users that are still live in the graph
NGRAPH_API_DEPRECATED
NGRAPH_API
size_t get_user_count(Node* node);
size_t get_user_count(ov::Node* node);
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_strided(const Strides& strides);
bool is_strided(const ov::Strides& strides);
NGRAPH_API_DEPRECATED
NGRAPH_API
bool is_valid_rank(const std::shared_ptr<Node>& node, std::vector<size_t> valid_ranks);
bool is_valid_rank(const std::shared_ptr<ov::Node>& node, std::vector<size_t> valid_ranks);
NGRAPH_API_DEPRECATED
NGRAPH_API
void plot_graph(std::shared_ptr<ov::Model> f,
const std::string& filename,
std::function<void(const Node& node, std::vector<std::string>& attributes)> = nullptr);
std::function<void(const ov::Node& node, std::vector<std::string>& attributes)> = nullptr);
/// \return A vector containing handles for each input of dst that is connected to an output
/// of `src`.
NGRAPH_API_DEPRECATED
NGRAPH_API
std::vector<ov::Input<Node>> get_inputs_from(Node& src, Node& dst);
std::vector<ov::Input<ov::Node>> get_inputs_from(ov::Node& src, ov::Node& dst);
/// \return A vector containing a handle for each output of src that is connected to an input
/// of `dst`.
NGRAPH_API_DEPRECATED
NGRAPH_API
std::vector<ov::Output<Node>> get_outputs_to(Node& src, Node& dst);
std::vector<ov::Output<ov::Node>> get_outputs_to(ov::Node& src, ov::Node& dst);
/// Checks the func for graph cycles starting from results going backwards, then from parameters
/// going forward.

169
src/core/include/ngraph/node.hpp
View File

@ -1,169 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#if !defined(IN_OV_COMPONENT) && !defined(NGRAPH_LEGACY_HEADER_INCLUDED)
# define NGRAPH_LEGACY_HEADER_INCLUDED
# ifdef _MSC_VER
# pragma message( \
"The nGraph API is deprecated and will be removed in the 2024.0 release. For instructions on transitioning to the new API, please refer to https://docs.openvino.ai/latest/openvino_2_0_transition_guide.html")
# else
# warning("The nGraph API is deprecated and will be removed in the 2024.0 release. For instructions on transitioning to the new API, please refer to https://docs.openvino.ai/latest/openvino_2_0_transition_guide.html")
# endif
#endif
#include <atomic>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "ngraph/check.hpp"
#include "ngraph/coordinate_diff.hpp"
#include "ngraph/deprecated.hpp"
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/strides.hpp"
#include "openvino/core/any.hpp"
#include "openvino/core/descriptor/input.hpp"
#include "openvino/core/descriptor/output.hpp"
#include "openvino/core/descriptor/tensor.hpp"
#include "openvino/core/node.hpp"
#include "openvino/core/node_vector.hpp"
#include "openvino/op/util/variable.hpp"
#include "openvino/op/util/variable_value.hpp"
namespace ov {
namespace op {
namespace v0 {
class Result;
}
} // namespace op
} // namespace ov
namespace ngraph {
using ov::Node;
namespace op {
namespace v0 {
using ov::op::v0::Result;
}
} // namespace op
using EvaluationContext = ov::EvaluationContext;
using ResultVector = std::vector<std::shared_ptr<ngraph::op::v0::Result>>;
const auto node_validation_failure_loc_string = ov::node_validation_failure_loc_string;
NGRAPH_API
NGRAPH_API_DEPRECATED
const std::shared_ptr<Node>& check_single_output_arg(const std::shared_ptr<Node>& node, size_t i);
NGRAPH_API
NGRAPH_API_DEPRECATED
const ov::NodeVector& check_single_output_args(const ov::NodeVector& args);
const auto as_output_vector = ov::as_output_vector;
const auto as_node_vector = ov::as_node_vector;
const auto as_result_vector = ov::as_result_vector;
/// Alias useful for cloning
using NodeMap = std::unordered_map<ngraph::Node*, std::shared_ptr<ngraph::Node>>;
/// Nodes are the backbone of the graph of Value dataflow. Every node has
/// zero or more nodes as arguments and one value, which is either a tensor
/// or a (possibly empty) tuple of values.
using ov::NodeValidationFailure;
using NodeTypeInfo = Node::type_info_t;
// Like an Output but with a Node* instead of a shared_ptr<Node>
using ov::RawNodeOutput;
using RawNodeOutputMap = std::map<RawNodeOutput, ov::Output<Node>>;
using ov::check_new_args_count;
/// Helper macro that puts necessary declarations of RTTI block inside a class definition.
/// Should be used in the scope of class that requires type identification besides one provided by
/// C++ RTTI.
/// Recommended to be used for all classes that are inherited from class ov::Node to enable
/// pattern
/// matching for them. Accepts necessary type identification details like type of the operation,
/// version and optional parent class.
///
/// Applying this macro within a class definition provides declaration of type_info static
/// constant for backward compatibility with old RTTI definition for Node,
/// static function get_type_info_static which returns a reference to an object that is equal to
/// type_info but not necessary to the same object, and get_type_info virtual function that
/// overrides Node::get_type_info and returns a reference to the same object that
/// get_type_info_static gives.
///
/// Use this macro as a public part of the class definition:
///
/// class MyOp : public Node
/// {
/// public:
/// // Don't use Node as a parent for type_info, it doesn't have any value and
/// prohibited
/// NGRAPH_RTTI_DECLARATION;
///
/// ...
/// };
///
/// class MyInheritedOp : public MyOp
/// {
/// public:
/// NGRAPH_RTTI_DECLARATION;
///
/// ...
/// };
///
/// To complete type identification for a class, use NGRAPH_RTTI_DEFINITION.
///
#ifdef OPENVINO_STATIC_LIBRARY
# define NGRAPH_RTTI_DECLARATION \
const ::ngraph::Node::type_info_t& get_type_info() const override; \
static const ::ngraph::Node::type_info_t& get_type_info_static()
# define _NGRAPH_RTTI_DEFINITION_COMMON(CLASS) \
const ::ngraph::Node::type_info_t& CLASS::get_type_info() const { \
return get_type_info_static(); \
}
#else
# define NGRAPH_RTTI_DECLARATION \
static const ::ngraph::Node::type_info_t type_info; \
const ::ngraph::Node::type_info_t& get_type_info() const override; \
static const ::ngraph::Node::type_info_t& get_type_info_static()
# define _NGRAPH_RTTI_DEFINITION_COMMON(CLASS) \
const ::ngraph::Node::type_info_t& CLASS::get_type_info() const { \
return get_type_info_static(); \
}
#endif
#define _NGRAPH_RTTI_DEFINITION_WITH_PARENT(CLASS, TYPE_NAME, PARENT_CLASS) \
const ::ngraph::Node::type_info_t& CLASS::get_type_info_static() { \
static const ::ngraph::Node::type_info_t type_info_static{TYPE_NAME, &PARENT_CLASS::get_type_info_static()}; \
return type_info_static; \
} \
_NGRAPH_RTTI_DEFINITION_COMMON(CLASS)
#define _NGRAPH_RTTI_DEFINITION_NO_PARENT(CLASS, TYPE_NAME) \
const ::ngraph::Node::type_info_t& CLASS::get_type_info_static() { \
static const ::ngraph::Node::type_info_t type_info_static{TYPE_NAME}; \
return type_info_static; \
} \
_NGRAPH_RTTI_DEFINITION_COMMON(CLASS)
#define NGRAPH_RTTI_DEFINITION(...) \
_OPENVINO_RTTI_EXPAND(_OPENVINO_RTTI_DEFINITION_SELECTOR(__VA_ARGS__, \
_NGRAPH_RTTI_DEFINITION_WITH_PARENT, \
_NGRAPH_RTTI_DEFINITION_NO_PARENT)(__VA_ARGS__))
} // namespace ngraph

1
src/core/include/ngraph/op/split.hpp
View File

@ -17,7 +17,6 @@
#include <memory>
#include <vector>
#include "ngraph/node.hpp"
#include "openvino/op/split.hpp"
namespace ngraph {

1
src/core/include/ngraph/op/util/op_types.hpp
View File

@ -17,7 +17,6 @@
#include <memory>
#include "ngraph/ngraph_visibility.hpp"
#include "ngraph/node.hpp"
#include "openvino/op/util/op_types.hpp"
namespace ngraph {

1
src/core/include/ngraph/util.hpp
View File

@ -31,7 +31,6 @@
#include "ngraph/axis_vector.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/node.hpp"
#include "ngraph/shape.hpp"
#include "openvino/core/enum_mask.hpp"
#include "openvino/core/type/element_type.hpp"

2
src/core/src/graph_util.cpp
View File

@ -448,7 +448,7 @@ std::vector<std::shared_ptr<ov::Node>> clone_nodes(const std::vector<std::shared
}
std::list<std::shared_ptr<ov::Node>> clone_nodes(const std::vector<std::shared_ptr<ov::Node>>& nodes,
RawNodeOutputMap& output_map) {
ov::RawNodeOutputMap& output_map) {
// for each node in topological order
auto sorted_nodes = topological_sort(nodes);
std::list<std::shared_ptr<Node>> cloned_nodes;

14
src/core/src/node.cpp
View File

@ -534,20 +534,6 @@ std::string ov::node_validation_failure_loc_string(const Node* node) {
return ss.str();
}
OPENVINO_SUPPRESS_DEPRECATED_START
const std::shared_ptr<ov::Node>& ngraph::check_single_output_arg(const std::shared_ptr<Node>& node, size_t i) {
OPENVINO_ASSERT(node->get_output_size() == 1, "Argument ", i, node, " must produce exactly one value.");
return node;
}
const ov::NodeVector& ngraph::check_single_output_args(const ov::NodeVector& args) {
for (size_t i = 0; i < args.size(); ++i) {
ngraph::check_single_output_arg(args.at(i), i);
}
return args;
}
OPENVINO_SUPPRESS_DEPRECATED_END
bool ov::Node::match_value(ov::pass::pattern::Matcher* matcher,
const Output<Node>& pattern_value,
const Output<Node>& graph_value) {

2
src/core/src/specialize_function.cpp
View File

@ -86,7 +86,7 @@ std::shared_ptr<ov::Model> ngraph::specialize_function(std::shared_ptr<ov::Model
new_parameters[i]->set_friendly_name(name);
}
ResultVector new_results = f->get_results();
ov::ResultVector new_results = f->get_results();
for (size_t i = 0; i < new_results.size(); i++) {
auto name = new_results[i]->get_friendly_name();
new_results[i] = std::static_pointer_cast<ov::op::v0::Result>(m[new_results[i].get()]);

4
src/core/tests/specialize_function.cpp
View File

@ -158,7 +158,7 @@ TEST(specialize_function, et_static_shape_rank_dynamic_validation_fails) {
{ov::PartialShape{1, 2, 3}, ov::PartialShape{1, 2, 3, 4}},
param_vals);
},
NodeValidationFailure);
ov::NodeValidationFailure);
}
// Test specialization of dynamic element types to a case where validation will fail.
@ -182,7 +182,7 @@ TEST(specialize_function, et_dynamic_shape_static_validation_fails) {
{ov::PartialShape{1, 2, 3}, ov::PartialShape{1, 2, 3}},
param_vals);
},
NodeValidationFailure);
ov::NodeValidationFailure);
}
// Test specialization of rank-static dynamic shapes, where the replacement shapes have the wrong

1
src/frontends/onnx/docs/how_to_add_op.md
View File

@ -9,7 +9,6 @@ The declaration in `.hpp` can look like:
```cpp
#pragma once
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/bitwise_not.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

22
src/frontends/onnx/frontend/src/op/conv_transpose.cpp
View File

@ -30,8 +30,8 @@ ov::Output<ov::Node> make_group_conv_backprop(const ov::Output<ov::Node>& data,
const ov::Output<ov::Node>& filters,
const Strides& strides,
const Strides& dilations,
const CoordinateDiff& pads_begin,
const CoordinateDiff& pads_end,
const ov::CoordinateDiff& pads_begin,
const ov::CoordinateDiff& pads_end,
const ov::op::PadType& auto_pad_type,
const std::vector<std::int64_t>& output_shape,
const std::vector<std::int64_t>& output_padding) {
@ -44,7 +44,7 @@ ov::Output<ov::Node> make_group_conv_backprop(const ov::Output<ov::Node>& data,
pads_end,
dilations,
auto_pad_type,
CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
ov::CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
} else {
return std::make_shared<v1::GroupConvolutionBackpropData>(
data,
@ -53,7 +53,7 @@ ov::Output<ov::Node> make_group_conv_backprop(const ov::Output<ov::Node>& data,
strides,
dilations,
auto_pad_type,
CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
ov::CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
}
}
@ -61,8 +61,8 @@ ov::Output<ov::Node> make_conv_backprop(const ov::Output<ov::Node>& data,
const ov::Output<ov::Node>& filters,
const Strides& strides,
const Strides& dilations,
const CoordinateDiff& pads_begin,
const CoordinateDiff& pads_end,
const ov::CoordinateDiff& pads_begin,
const ov::CoordinateDiff& pads_end,
const ov::op::PadType& auto_pad_type,
const std::vector<std::int64_t>& output_shape,
const std::vector<std::int64_t>& output_padding) {
@ -75,7 +75,7 @@ ov::Output<ov::Node> make_conv_backprop(const ov::Output<ov::Node>& data,
pads_end,
dilations,
auto_pad_type,
CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
ov::CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
} else {
return std::make_shared<v1::ConvolutionBackpropData>(
data,
@ -86,7 +86,7 @@ ov::Output<ov::Node> make_conv_backprop(const ov::Output<ov::Node>& data,
pads_end,
dilations,
auto_pad_type,
CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
ov::CoordinateDiff(std::begin(output_padding), std::end(output_padding)));
}
}
@ -140,7 +140,7 @@ ov::OutputVector conv_transpose(const Node& node) {
std::size_t num_spatial_dims = 0;
Strides strides, dilations;
std::pair<CoordinateDiff, CoordinateDiff> paddings;
std::pair<ov::CoordinateDiff, ov::CoordinateDiff> paddings;
ov::op::PadType auto_pad_type = convpool::get_auto_pad(node);
// Get attirbutes or infer them from input data rank it it's static.
@ -163,8 +163,8 @@ ov::OutputVector conv_transpose(const Node& node) {
strides = convpool::get_strides(node, num_spatial_dims);
dilations = convpool::get_dilations(node, num_spatial_dims);
paddings = convpool::get_pads(node, num_spatial_dims);
CoordinateDiff pads_begin = paddings.first;
CoordinateDiff pads_end = paddings.second;
ov::CoordinateDiff pads_begin = paddings.first;
ov::CoordinateDiff pads_end = paddings.second;
std::vector<std::int64_t> output_shape{node.get_attribute_value<std::vector<std::int64_t>>("output_shape", {})};

22
src/frontends/onnx/frontend/src/op/quant_conv.cpp
View File

@ -34,21 +34,21 @@ namespace ngraph
{
struct OpScale
{
Output<ngraph::Node> data_scale;
Output<ngraph::Node> filter_scale;
Output<ngraph::Node> output_scale;
Output<ov::Node> data_scale;
Output<ov::Node> filter_scale;
Output<ov::Node> output_scale;
};
struct OpZeroPoint
{
Output<ngraph::Node> data_zero_point;
Output<ngraph::Node> filter_zero_point;
Output<ngraph::Node> output_zero_point;
Output<ov::Node> data_zero_point;
Output<ov::Node> filter_zero_point;
Output<ov::Node> output_zero_point;
};
std::shared_ptr<ngraph::Node>
make_ng_quant_conv(const Output<ngraph::Node>& data,
const Output<ngraph::Node>& filters,
std::shared_ptr<ov::Node>
make_ng_quant_conv(const Output<ov::Node>& data,
const Output<ov::Node>& filters,
const Strides& strides,
const Strides& filter_dilations,
const CoordinateDiff& padding_below,
@ -57,7 +57,7 @@ namespace ngraph
int groups,
const OpScale& op_scale,
const OpZeroPoint& op_zero_point,
const Output<ngraph::Node>& bias = nullptr)
const Output<ov::Node>& bias = nullptr)
{
ngraph:: ov::element::Type output_type;
if (data.get_element_type() == ngraph:: ov::element::u8 &&
@ -228,7 +228,7 @@ namespace ngraph
padding_below,
padding_above);
std::shared_ptr<ngraph::Node> conv_node = nullptr;
std::shared_ptr<ov::Node> conv_node = nullptr;
// no bias param
if (inputs.size() == 9 && !ngraph::op::is_null(inputs.at(8)))

1
src/frontends/onnx/frontend/src/op/scan.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/scatter_elements.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/scatter_nd.hpp
View File

@ -10,7 +10,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/selu.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/shape.cpp
View File

@ -7,7 +7,6 @@
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "op/shape.hpp"
#include "openvino/core/type/element_type.hpp"

1
src/frontends/onnx/frontend/src/op/shape.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

9
src/frontends/onnx/frontend/src/op/shrink.cpp
View File

@ -38,17 +38,16 @@ ov::OutputVector shrink(const Node& node) {
// Create a mask indicating locations of values that need to be adjusted
// by adding and subtracting bias
// All other values indicated by 'false' in the masks need to be zeroed out
std::shared_ptr<ngraph::Node> values_below_neg_lambd = std::make_shared<default_opset::Less>(input, negative_lambd);
std::shared_ptr<ngraph::Node> values_above_pos_lambd =
std::make_shared<default_opset::Greater>(input, positive_lambd);
std::shared_ptr<ov::Node> values_below_neg_lambd = std::make_shared<default_opset::Less>(input, negative_lambd);
std::shared_ptr<ov::Node> values_above_pos_lambd = std::make_shared<default_opset::Greater>(input, positive_lambd);
// Convert from bool to the input type to be able to multiply adjusted inputs
// by the created masks
values_below_neg_lambd = std::make_shared<default_opset::Convert>(values_below_neg_lambd, input_element_type);
values_above_pos_lambd = std::make_shared<default_opset::Convert>(values_above_pos_lambd, input_element_type);
std::shared_ptr<ngraph::Node> input_minus_bias = std::make_shared<default_opset::Subtract>(input, bias_tensor);
std::shared_ptr<ngraph::Node> input_plus_bias = std::make_shared<default_opset::Add>(input, bias_tensor);
std::shared_ptr<ov::Node> input_minus_bias = std::make_shared<default_opset::Subtract>(input, bias_tensor);
std::shared_ptr<ov::Node> input_plus_bias = std::make_shared<default_opset::Add>(input, bias_tensor);
// multiply by the corresponding mask to zero-out the values within
// the <-lambd;lambd> range and keep the bias-adjusted values from outside of it

1
src/frontends/onnx/frontend/src/op/shrink.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/sigmoid.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/sign.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/sin.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/sinh.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/size.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

4
src/frontends/onnx/frontend/src/op/slice.cpp
View File

@ -27,7 +27,7 @@ ov::OutputVector slice(const Node& node) {
const bool axes_input_provided = inputs.size() >= 4 && !is_null(inputs.at(3));
const bool steps_input_provided = inputs.size() == 5 && !is_null(inputs.at(4));
ov::Output<ngraph::Node> steps;
ov::Output<ov::Node> steps;
if (steps_input_provided) {
steps = inputs.at(4);
} else {
@ -48,7 +48,7 @@ ov::OutputVector slice(const Node& node) {
namespace set_1 {
ov::OutputVector slice(const Node& node) {
ov::Output<ngraph::Node> data = node.get_ng_inputs().at(0);
ov::Output<ov::Node> data = node.get_ng_inputs().at(0);
const auto starts_atr = node.get_attribute_value<std::vector<int64_t>>("starts");
const auto ends = node.get_attribute_as_constant<std::vector<int64_t>>("ends");

1
src/frontends/onnx/frontend/src/op/slice.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

6
src/frontends/onnx/frontend/src/op/softmax.cpp
View File

@ -14,7 +14,7 @@ OPENVINO_SUPPRESS_DEPRECATED_START
namespace ngraph {
namespace onnx_import {
namespace {
std::shared_ptr<ngraph::Node> onnx_softmax(const ov::Output<ngraph::Node> data, const int64_t axis) {
std::shared_ptr<ov::Node> onnx_softmax(const ov::Output<ov::Node> data, const int64_t axis) {
const auto coerced_data = ov::op::util::flatten(data, static_cast<int>(axis));
const auto result = std::make_shared<default_opset::Softmax>(coerced_data, 1);
const auto data_shape = std::make_shared<default_opset::ShapeOf>(data);
@ -32,7 +32,7 @@ ov::OutputVector softmax(const Node& node) {
const auto axis = node.get_attribute_value<int64_t>("axis", 1);
std::shared_ptr<ngraph::Node> result;
std::shared_ptr<ov::Node> result;
switch (data_rank.get_length()) {
case 0: {
result = default_opset::Constant::create(data.get_element_type(), Shape{}, {1});
@ -55,7 +55,7 @@ ov::OutputVector softmax(const Node& node) {
const auto axis = node.get_attribute_value<int64_t>("axis", 1);
std::shared_ptr<ngraph::Node> result;
std::shared_ptr<ov::Node> result;
switch (data_rank.get_length()) {
case 0: {
result = default_opset::Constant::create(data.get_element_type(), Shape{}, {1});

1
src/frontends/onnx/frontend/src/op/softmax.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/softplus.cpp
View File

@ -7,7 +7,6 @@
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/softplus.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/softsign.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/space_to_depth.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/split.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/sqrt.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/squeeze.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/stft.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/sub.hpp
View File

@ -8,7 +8,6 @@
OPENVINO_SUPPRESS_DEPRECATED_START
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

3
src/frontends/onnx/frontend/src/op/sum.hpp
View File

@ -8,7 +8,6 @@
OPENVINO_SUPPRESS_DEPRECATED_START
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
#include "utils/variadic.hpp"
@ -17,7 +16,7 @@ namespace onnx_import {
namespace op {
namespace set_1 {
inline ov::OutputVector sum(const Node& node) {
return variadic::make_ng_variadic_op<default_opset::Add>(node, ngraph::op::AutoBroadcastType::NONE);
return variadic::make_ng_variadic_op<default_opset::Add>(node, ov::op::AutoBroadcastType::NONE);
}
} // namespace set_1

1
src/frontends/onnx/frontend/src/op/tan.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/tanh.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/thresholded_relu.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/tile.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

31
src/frontends/onnx/frontend/src/op/topk.cpp
View File

@ -8,7 +8,6 @@
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "ngraph/shape.hpp"
#include "openvino/core/type/element_type.hpp"
#include "openvino/frontend/exception.hpp"
@ -17,7 +16,7 @@
OPENVINO_SUPPRESS_DEPRECATED_START
namespace {
/// \return Return the second input to the TopK node reshaped to a scalar.
ov::Output<ngraph::Node> get_k(const ngraph::onnx_import::Node& node) {
ov::Output<ov::Node> get_k(const ngraph::onnx_import::Node& node) {
auto k_node = node.get_ng_inputs().at(1);
FRONT_END_GENERAL_CHECK(shape_size(k_node.get_shape()) == 1,
"ONNX TopK operator: 'K' parameter must contain a single positive value.",
@ -36,13 +35,12 @@ ov::OutputVector topk(const Node& node) {
const auto k_node = node.get_attribute_as_constant<std::int64_t>("k");
const std::int64_t axis{node.get_attribute_value<std::int64_t>("axis", -1)};
std::shared_ptr<ngraph::Node> top_k =
std::make_shared<default_opset::TopK>(data,
k_node,
axis,
default_opset::TopK::Mode::MAX,
default_opset::TopK::SortType::SORT_VALUES,
ov::element::i64);
std::shared_ptr<ov::Node> top_k = std::make_shared<default_opset::TopK>(data,
k_node,
axis,
default_opset::TopK::Mode::MAX,
default_opset::TopK::SortType::SORT_VALUES,
ov::element::i64);
return {top_k->output(0), top_k->output(1)};
}
@ -54,13 +52,12 @@ ov::OutputVector topk(const Node& node) {
auto k = get_k(node);
const std::int64_t axis{node.get_attribute_value<std::int64_t>("axis", -1)};
std::shared_ptr<ngraph::Node> top_k =
std::make_shared<default_opset::TopK>(data,
k,
axis,
default_opset::TopK::Mode::MAX,
default_opset::TopK::SortType::SORT_VALUES,
ov::element::i64);
std::shared_ptr<ov::Node> top_k = std::make_shared<default_opset::TopK>(data,
k,
axis,
default_opset::TopK::Mode::MAX,
default_opset::TopK::SortType::SORT_VALUES,
ov::element::i64);
return {top_k->output(0), top_k->output(1)};
}
@ -83,7 +80,7 @@ ov::OutputVector topk(const Node& node) {
const auto compute_max = static_cast<bool>(largest);
const auto mode = compute_max ? default_opset::TopK::Mode::MAX : default_opset::TopK::Mode::MIN;
std::shared_ptr<ngraph::Node> top_k =
std::shared_ptr<ov::Node> top_k =
std::make_shared<default_opset::TopK>(data, k, axis, mode, sort_type, ov::element::i64);
return {top_k->output(0), top_k->output(1)};

1
src/frontends/onnx/frontend/src/op/topk.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

3
src/frontends/onnx/frontend/src/op/transpose.cpp
View File

@ -7,7 +7,6 @@
#include <memory>
#include <vector>
#include "ngraph/node.hpp"
#include "ov_models/ov_builders/reshape.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
@ -16,7 +15,7 @@ namespace onnx_import {
namespace op {
namespace set_1 {
ov::OutputVector transpose(const Node& node) {
ov::Output<ngraph::Node> data = node.get_ng_inputs().at(0);
ov::Output<ov::Node> data = node.get_ng_inputs().at(0);
auto permute_axes = node.get_attribute_value<std::vector<std::size_t>>("perm", {});

1
src/frontends/onnx/frontend/src/op/transpose.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

4
src/frontends/onnx/frontend/src/op/trilu.cpp
View File

@ -76,7 +76,7 @@ ov::OutputVector trilu(const Node& node) {
std::make_shared<default_opset::Range>(zero, M, one, ov::element::i64),
zero);
// create 2D tensor with shape [N, 1] and values [[k], [k + 1], ..., [N + k - 1]]
std::shared_ptr<ngraph::Node> vertical_range;
std::shared_ptr<ov::Node> vertical_range;
if (is_k_available) {
vertical_range = std::make_shared<default_opset::Range>(inputs[1],
std::make_shared<default_opset::Add>(N, inputs[1]),
@ -88,7 +88,7 @@ ov::OutputVector trilu(const Node& node) {
vertical_range = std::make_shared<default_opset::Unsqueeze>(vertical_range, one);
const bool upper = node.get_attribute_value<int64_t>("upper", 1) == 1;
std::shared_ptr<ngraph::Node> mask;
std::shared_ptr<ov::Node> mask;
if (upper) {
mask = std::make_shared<default_opset::GreaterEqual>(horizontal_range, vertical_range);
} else {

1
src/frontends/onnx/frontend/src/op/unique.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/unsqueeze.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/upsample.hpp
View File

@ -7,7 +7,6 @@
#include "openvino/core/deprecated.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

1
src/frontends/onnx/frontend/src/op/where.hpp
View File

@ -10,7 +10,6 @@ OPENVINO_SUPPRESS_DEPRECATED_START
#include <memory>
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {

8
src/frontends/onnx/frontend/src/op/xor.hpp
View File

@ -8,7 +8,6 @@
OPENVINO_SUPPRESS_DEPRECATED_START
#include "default_opset.hpp"
#include "ngraph/node.hpp"
#include "onnx_import/core/node.hpp"
namespace ngraph {
@ -16,10 +15,9 @@ namespace onnx_import {
namespace op {
namespace set_1 {
inline ov::OutputVector logical_xor(const Node& node) {
return {std::make_shared<default_opset::LogicalXor>(
node.get_ng_inputs().at(0),
node.get_ng_inputs().at(1),
ngraph::op::AutoBroadcastSpec(ngraph::op::AutoBroadcastType::NUMPY))};
return {std::make_shared<default_opset::LogicalXor>(node.get_ng_inputs().at(0),
node.get_ng_inputs().at(1),
ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::NUMPY))};
}
} // namespace set_1

8
src/frontends/onnx/frontend/src/utils/convpool.hpp
View File

@ -56,7 +56,7 @@ ov::op::RoundingType get_rounding_type(const Node& node);
///
/// \return A pair of (padding_above, padding_below), which elements contains number of
/// pixels to pad in respective dimensions (height, width, depth).
std::pair<CoordinateDiff, CoordinateDiff> get_pads(const Node& node, const size_t kernel_rank);
std::pair<ov::CoordinateDiff, ov::CoordinateDiff> get_pads(const Node& node, const size_t kernel_rank);
/// \brief Get padding values for the operation described by an ONNX node.
/// \details Values are taken from the `pads` attribute.
@ -67,7 +67,7 @@ std::pair<CoordinateDiff, CoordinateDiff> get_pads(const Node& node, const size_
///
/// \return A pair of (padding_above, padding_below), which elements contains number of
/// pixels to pad in respective dimensions (height, width, depth).
std::pair<CoordinateDiff, CoordinateDiff> get_pads(const Node& node);
std::pair<ov::CoordinateDiff, ov::CoordinateDiff> get_pads(const Node& node);
///
/// \brief Calculate paddings with respect to auto_pad value.
@ -86,8 +86,8 @@ void calculate_auto_pads(const Shape& data_shape,
const Strides& strides,
const Strides& dilations,
const ov::op::PadType& pad_type,
CoordinateDiff& padding_below,
CoordinateDiff& padding_above);
ov::CoordinateDiff& padding_below,
ov::CoordinateDiff& padding_above);
/// \brief Gets the 'auto_pad' attribute value.
///

4
src/frontends/onnx/frontend/src/utils/pooling_factory.cpp
View File

@ -44,8 +44,8 @@ PoolingFactory::PoolingFactory(const Node& node)
m_auto_pad{convpool::get_auto_pad(node)},
m_rounding_type{convpool::get_rounding_type(node)} {
const auto paddings = convpool::get_pads(node, m_kernel_shape.size());
const CoordinateDiff& padding_above{paddings.second};
const CoordinateDiff& padding_below{paddings.first};
const ov::CoordinateDiff& padding_above{paddings.second};
const ov::CoordinateDiff& padding_below{paddings.first};
m_padding_below = Shape{std::begin(padding_below), std::end(padding_below)};
m_padding_above = Shape{std::begin(padding_above), std::end(padding_above)};
m_storage_order = static_cast<StorageOrder>(node.get_attribute_value<int64_t>("storage_order", 0));

10
src/inference/src/cnn_network_ngraph_impl.cpp
View File

@ -36,7 +36,7 @@ using namespace InferenceEngine;
using details::CNNNetworkNGraphImpl;
using InferenceEngine::details::CNNNetworkNGraphImpl;
void CNNNetworkNGraphImpl::createDataForResult(const ::ov::Output<::ngraph::Node>& output,
void CNNNetworkNGraphImpl::createDataForResult(const ::ov::Output<::ov::Node>& output,
const std::string& outName,
DataPtr& ptr) {
const auto isCompatible = [](int64_t size, const Layout& l) -> bool {
@ -88,7 +88,7 @@ void CNNNetworkNGraphImpl::createDataForResult(const ::ov::Output<::ngraph::Node
void CNNNetworkNGraphImpl::validateFunctionNames() const {
// nGraph function parameters and pre-Results operations should have unique names
std::unordered_map<std::string, std::shared_ptr<ngraph::Node>> unique_names;
std::unordered_map<std::string, std::shared_ptr<ov::Node>> unique_names;
for (const auto& param : _ngraph_function->get_parameters()) {
if (unique_names.count(param->get_friendly_name())) {
IE_THROW() << "Function contains several inputs with one friendly name!";
@ -296,7 +296,7 @@ StatusCode CNNNetworkNGraphImpl::addOutput(const std::string& layerName,
return DescriptionBuffer(NOT_FOUND, resp) << "Cannot add output! Layer " << layerName << " wasn't found!";
}
void CNNNetworkNGraphImpl::addOutput(const ::ov::Output<::ngraph::Node>& output) {
void CNNNetworkNGraphImpl::addOutput(const ::ov::Output<::ov::Node>& output) {
auto dataName = ov::op::util::create_ie_output_name(output);
DataPtr data;
if (_data.count(dataName))
@ -317,7 +317,7 @@ size_t CNNNetworkNGraphImpl::getBatchSize() const {
// This is not correct in general. We can follow the same semantics, but order of inputs should be
// guaranteed to be the same.
auto params = _ngraph_function->get_parameters();
sort(params.begin(), params.end(), [](std::shared_ptr<ngraph::Node> lhs, std::shared_ptr<ngraph::Node> rhs) {
sort(params.begin(), params.end(), [](std::shared_ptr<ov::Node> lhs, std::shared_ptr<ov::Node> rhs) {
return lhs->get_friendly_name() < rhs->get_friendly_name();
});
@ -592,7 +592,7 @@ StatusCode CNNNetworkNGraphImpl::setBatchSize(size_t size, ResponseDesc* respons
const auto first_parameter =
*std::min_element(original_parameters.begin(),
original_parameters.end(),
[](std::shared_ptr<ngraph::Node> lhs, std::shared_ptr<ngraph::Node> rhs) {
[](std::shared_ptr<ov::Node> lhs, std::shared_ptr<ov::Node> rhs) {
return lhs->get_friendly_name() < rhs->get_friendly_name();
});
const auto first_parameter_pshape = first_parameter->get_output_partial_shape(0);

2
src/inference/src/cpp_interfaces/interface/ie_iplugin_internal.cpp
View File

@ -281,7 +281,7 @@ std::unordered_set<std::string> GetRemovedNodes(const std::shared_ptr<const ov::
std::unordered_set<std::string> GetSupportedNodes(
const std::shared_ptr<const ov::Model>& model,
std::function<void(std::shared_ptr<ov::Model>&)> transform,
std::function<bool(const std::shared_ptr<ngraph::Node>)> is_node_supported) {
std::function<bool(const std::shared_ptr<ov::Node>)> is_node_supported) {
return ov::get_supported_nodes(model, transform, is_node_supported);
}

2
src/inference/src/dev/converter_utils.cpp
View File

@ -47,7 +47,7 @@
namespace {
std::string get_legacy_name_from_port(const ov::Output<const ov::Node>& port) {
ov::Output<ngraph::Node> p(std::const_pointer_cast<ov::Node>(port.get_node_shared_ptr()), port.get_index());
ov::Output<ov::Node> p(std::const_pointer_cast<ov::Node>(port.get_node_shared_ptr()), port.get_index());
if (auto node = std::dynamic_pointer_cast<ov::op::v0::Result>(p.get_node_shared_ptr())) {
p = node->input_value(0);
}

4
src/plugins/intel_cpu/src/nodes/rope.cpp
View File

@ -18,7 +18,7 @@ namespace ov {
namespace intel_cpu {
namespace node {
RoPE::RoPE(const std::shared_ptr<ngraph::Node>& op, const GraphContext::CPtr context)
RoPE::RoPE(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
: Node(op, context, NgraphShapeInferFactory(op, EMPTY_PORT_MASK)) {
std::string errorMessage;
if (!isSupportedOperation(op, errorMessage)) {
@ -287,7 +287,7 @@ void RoPE::execute(dnnl::stream strm) {
m_executor->execute(strm, m_config, inputs, outputs);
}
bool RoPE::isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept {
bool RoPE::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
try {
const auto node = std::dynamic_pointer_cast<const RoPENode>(op);
if (!node) {

4
src/plugins/intel_cpu/src/nodes/rope.h
View File

@ -13,7 +13,7 @@ namespace node {
class RoPE : public Node {
public:
RoPE(const std::shared_ptr<ngraph::Node>& op, const GraphContext::CPtr context);
RoPE(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
void getSupportedDescriptors() override {}
bool created() const override {
@ -27,7 +27,7 @@ public:
}
void initSupportedPrimitiveDescriptors() override;
void execute(dnnl::stream strm) override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
private:
struct Executor {

4
src/plugins/intel_cpu/src/nodes/scaled_attn.cpp
View File

@ -638,7 +638,7 @@ struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAtt
}
};
ScaledDotProductAttention::ScaledDotProductAttention(const std::shared_ptr<ngraph::Node>& op, const GraphContext::CPtr context)
ScaledDotProductAttention::ScaledDotProductAttention(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
: Node(op, context, SDPAShapeInferFactory(op)), m_tmp_reorder(true) {
std::string errorMessage;
if (!isSupportedOperation(op, errorMessage)) {
@ -773,7 +773,7 @@ void ScaledDotProductAttention::execute(dnnl::stream strm) {
m_executor->execute(strm, m_config, inputs, output, presentk_input, presentv_input, beam_input);
}
bool ScaledDotProductAttention::isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept {
bool ScaledDotProductAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
try {
if (!std::dynamic_pointer_cast<const ov::op::v13::ScaledDotProductAttention>(op) &&
!std::dynamic_pointer_cast<const ScaledDotProductAttentionWithKVCache>(op)) {

4
src/plugins/intel_cpu/src/nodes/scaled_attn.h
View File

@ -15,7 +15,7 @@ namespace node {
class ScaledDotProductAttention : public Node {
public:
ScaledDotProductAttention(const std::shared_ptr<ngraph::Node>& op, const GraphContext::CPtr context);
ScaledDotProductAttention(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
void getSupportedDescriptors() override {}
bool created() const override {
@ -34,7 +34,7 @@ public:
void initSupportedPrimitiveDescriptors() override;
void execute(dnnl::stream strm) override;
void createPrimitive() override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
enum KernelTypes { KT_REF, KT_ONEDNN, KT_MLAS};

2
src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/rope.cpp
View File

@ -11,7 +11,7 @@ ov::intel_cpu::RoPENode::RoPENode(const OutputVector& args, const Config& cfg) :
constructor_validate_and_infer_types();
}
std::shared_ptr<ngraph::Node> ov::intel_cpu::RoPENode::clone_with_new_inputs(
std::shared_ptr<ov::Node> ov::intel_cpu::RoPENode::clone_with_new_inputs(
const ov::OutputVector& new_args) const {
INTERNAL_OP_SCOPE(RoPENode_with_new_inputs);
check_new_args_count(this, new_args);

2
src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/rope.hpp
View File

@ -4,8 +4,6 @@
#pragma once
#include <ngraph/node.hpp>
#include "openvino/op/op.hpp"
namespace ov {

2
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.cpp
View File

@ -10,8 +10,6 @@
#include "itt.hpp"
NGRAPH_RTTI_DEFINITION(ov::intel_cpu::SwapConvertTranspose, "SwapConvertTranspose");
ov::intel_cpu::SwapConvertTranspose::SwapConvertTranspose() {
MATCHER_SCOPE(SwapConvertTranspose);
ov::element::TypeVector param_precisions{ ov::element::i8, ov::element::u8 };

1
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.hpp
View File

@ -11,7 +11,6 @@ namespace intel_cpu {
class SwapConvertTranspose : public ov::pass::MatcherPass {
public:
NGRAPH_RTTI_DECLARATION;
SwapConvertTranspose();
};

2
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/topk.cpp
View File

@ -78,7 +78,7 @@ void TopKLayerTestGPU::SetUp() {
auto topk = std::dynamic_pointer_cast<ov::op::v11::TopK>(
std::make_shared<ov::op::v11::TopK>(params[0], k, axis, mode, sort, ov::element::Type_t::i64, stable));
ngraph::ResultVector results;
ov::ResultVector results;
for (size_t i = 0; i < topk->get_output_size(); i++) {
results.push_back(std::make_shared<ov::op::v0::Result>(topk->output(i)));
}

2
src/tests/functional/shared_test_classes/include/shared_test_classes/single_layer/memory.hpp
View File

@ -49,7 +49,7 @@ private:
void ApplyLowLatency();
InferenceEngine::Precision netPrecision;
ngraph::EvaluationContext eval_context;
ov::EvaluationContext eval_context;
ngraph::helpers::MemoryTransformation transformation;
int64_t iteration_count;

4
src/tests/functional/shared_test_classes/src/base/layer_test_utils.cpp
View File

@ -653,10 +653,10 @@ std::string LayerTestsCommon::getRuntimePrecisionByFusedName(const std::string&
return "";
}
std::map<std::string, ngraph::Node::RTMap> LayerTestsCommon::getRuntimeInfo() {
std::map<std::string, ov::Node::RTMap> LayerTestsCommon::getRuntimeInfo() {
const auto execGraph = executableNetwork.GetExecGraphInfo();
const auto function = execGraph.getFunction();
std::map<std::string, ngraph::Node::RTMap> runtimeInfo;
std::map<std::string, ov::Node::RTMap> runtimeInfo;
for (const auto& op : function->get_ops()) {
runtimeInfo[op->get_friendly_name()] = op->get_rt_info();
}

2
src/tests/functional/shared_test_classes/src/single_layer/memory.cpp
View File

@ -188,7 +188,7 @@ void MemoryTest::CreateCommonFunc() {
auto add = std::make_shared<ov::op::v1::Add>(read_value, param.at(0));
auto assign = CreateAssignOp(add, variable);
auto res = std::make_shared<ov::op::v0::Result>(add);
function = std::make_shared<ov::Model>(ResultVector{res}, ov::SinkVector{assign}, param, "TestMemory");
function = std::make_shared<ov::Model>(ov::ResultVector{res}, ov::SinkVector{assign}, param, "TestMemory");
}
void MemoryTest::ApplyLowLatency() {

2
src/tests/functional/shared_test_classes/src/single_layer/random_uniform.cpp
View File

@ -77,7 +77,7 @@ void RandomUniformLayerTest::SetUp() {
precision,
global_seed,
op_seed);
ngraph::ResultVector results{std::make_shared<ov::op::v0::Result>(random_uniform)};
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(random_uniform)};
function = std::make_shared<ov::Model>(results, ngraph::ParameterVector{input}, "random_uniform");
}

26
src/tests/ov_helpers/ov_models/include/ov_models/builders.hpp
View File

@ -79,7 +79,7 @@ std::shared_ptr<ov::Node> makeConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases = false,
const std::vector<float>& filterWeights = {},
@ -93,7 +93,7 @@ std::shared_ptr<ov::Node> makeConvolution(const ov::Output<Node>& in_data,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases = false,
const std::vector<float>& biasesWeights = {});
@ -105,7 +105,7 @@ std::shared_ptr<ov::Node> makeGroupConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
size_t numGroups,
bool addBiases = false,
@ -119,7 +119,7 @@ std::shared_ptr<ov::Node> makeGroupConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
bool addBiases = false,
const std::vector<float>& biasesWeights = {});
@ -130,7 +130,7 @@ std::shared_ptr<ov::Node> makeConvolutionBackpropData(const ov::Output<Node>& in
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases = false,
const std::vector<ptrdiff_t>& outputPadding = {},
@ -144,7 +144,7 @@ std::shared_ptr<ov::Node> makeConvolutionBackpropData(const ov::Output<Node>& in
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
bool addBiases = false,
const std::vector<ptrdiff_t>& outputPadding = {},
const std::vector<float>& biasesWeights = {});
@ -157,7 +157,7 @@ std::shared_ptr<ov::Node> makeConvolutionBackpropData(const ov::Output<Node>& in
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases = false,
const std::vector<ptrdiff_t>& outputPadding = {},
@ -199,7 +199,7 @@ std::shared_ptr<ov::Node> makeGroupConvolutionBackpropData(const ov::Output<Node
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
size_t numGroups,
bool addBiases = false,
@ -214,7 +214,7 @@ std::shared_ptr<ov::Node> makeGroupConvolutionBackpropData(const ov::Output<Node
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
bool addBiases = false,
const std::vector<ptrdiff_t>& outputPadding = {},
const std::vector<float>& biasesWeights = {});
@ -227,7 +227,7 @@ std::shared_ptr<ov::Node> makeGroupConvolutionBackpropData(const ov::Output<Node
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
size_t numGroups,
bool addBiases = false,
@ -241,7 +241,7 @@ std::shared_ptr<ov::Node> makeBinaryConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
float padValue,
const std::vector<int8_t>& filterWeihgts = {});
@ -393,8 +393,8 @@ std::shared_ptr<Node> makePooling(const ov::Output<Node>& in,
const std::vector<size_t>& padsBegin,
const std::vector<size_t>& padsEnd,
const std::vector<size_t>& kernel,
const op::RoundingType& roundingType,
const op::PadType& padType,
const ov::op::RoundingType& roundingType,
const ov::op::PadType& padType,
bool excludePad,
const ov::test::utils::PoolingTypes& poolType);

2
src/tests/ov_helpers/ov_models/src/binary_convolution.cpp
View File

@ -19,7 +19,7 @@ std::shared_ptr<Node> makeBinaryConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
float padValue,
const std::vector<int8_t>& filterWeihgts) {

4
src/tests/ov_helpers/ov_models/src/convolution.cpp
View File

@ -21,7 +21,7 @@ std::shared_ptr<Node> makeConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases,
const std::vector<float>& filterWeights,
@ -58,7 +58,7 @@ std::shared_ptr<Node> makeConvolution(const ov::Output<Node>& in_data,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases,
const std::vector<float>& biasesWeights) {

6
src/tests/ov_helpers/ov_models/src/convolution_backprop_data.cpp
View File

@ -20,7 +20,7 @@ std::shared_ptr<Node> makeConvolutionBackpropData(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases,
const std::vector<ptrdiff_t>& outputPadding,
@ -53,7 +53,7 @@ std::shared_ptr<Node> makeConvolutionBackpropData(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
bool addBiases,
const std::vector<ptrdiff_t>& outputPadding,
const std::vector<float>& biasesWeights) {
@ -94,7 +94,7 @@ std::shared_ptr<Node> makeConvolutionBackpropData(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
bool addBiases,
const std::vector<ptrdiff_t>& outputPadding,

4
src/tests/ov_helpers/ov_models/src/group_convolution.cpp
View File

@ -20,7 +20,7 @@ std::shared_ptr<Node> makeGroupConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
size_t numGroups,
bool addBiases,
@ -57,7 +57,7 @@ std::shared_ptr<Node> makeGroupConvolution(const ov::Output<Node>& in,
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
bool addBiases,
const std::vector<float>& biasesWeights) {
auto conv =

6
src/tests/ov_helpers/ov_models/src/group_convolution_backprop_data.cpp
View File

@ -20,7 +20,7 @@ std::shared_ptr<Node> makeGroupConvolutionBackpropData(const ov::Output<Node>& i
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
size_t numGroups,
bool addBiases,
@ -59,7 +59,7 @@ std::shared_ptr<Node> makeGroupConvolutionBackpropData(const ov::Output<Node>& i
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
bool addBiases,
const std::vector<ptrdiff_t>& outputPadding,
const std::vector<float>& biasesWeights) {
@ -99,7 +99,7 @@ std::shared_ptr<Node> makeGroupConvolutionBackpropData(const ov::Output<Node>& i
const std::vector<ptrdiff_t>& padsBegin,
const std::vector<ptrdiff_t>& padsEnd,
const std::vector<size_t>& dilations,
const op::PadType& autoPad,
const ov::op::PadType& autoPad,
size_t numOutChannels,
size_t numGroups,
bool addBiases,

4
src/tests/ov_helpers/ov_models/src/pooling.cpp
View File

@ -17,8 +17,8 @@ std::shared_ptr<Node> makePooling(const ov::Output<Node>& in,
const std::vector<size_t>& padsBegin,
const std::vector<size_t>& padsEnd,
const std::vector<size_t>& kernel,
const op::RoundingType& roundingType,
const op::PadType& padType,
const ov::op::RoundingType& roundingType,
const ov::op::PadType& padType,
bool excludePad,
const ov::test::utils::PoolingTypes& poolType) {
std::shared_ptr<ov::Node> pooling;