Renamed ov::Function to ov::Model (#9051)

* Renamed ov::Function to ov::Model

* Fixed all for macos

* Fixed build

* Fixed build

* Revert changes in GPU plugin

* Fixed ngraphFunctions

* Fixed all for mac

* Fixed new test

* Fixed if for Windows

* Fixed unit tests and renamed Function in python API

* Fixed code style

* Fixed import

* Fixed conflict

* Fixed merge issues

src/common/low_precision_transformations/include/low_precision/align_quantization_intervals.hpp

@@ -21,5 +21,5 @@ class LP_TRANSFORMATIONS_API AlignQuantizationIntervals;
 class ngraph::pass::low_precision::AlignQuantizationIntervals : public ngraph::pass::FunctionPass {
 public:
     NGRAPH_RTTI_DECLARATION;
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 };

src/common/low_precision_transformations/include/low_precision/align_quantization_parameters.hpp

@@ -22,5 +22,5 @@ class LP_TRANSFORMATIONS_API AlignQuantizationParameters;
 class ngraph::pass::low_precision::AlignQuantizationParameters : public ngraph::pass::FunctionPass {
 public:
     NGRAPH_RTTI_DECLARATION;
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 };

src/common/low_precision_transformations/include/low_precision/low_precision.hpp

@@ -43,7 +43,7 @@ public:
     MarkupOptimizations(
         const std::vector<OperationPrecisionRestriction>& precisionRestrictions,
         const std::vector<OperationPerTensorQuantizationRestriction>& quantizationRestrictions);
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 private:
     const std::vector<OperationPrecisionRestriction>& precisionRestrictions;
     const std::vector<OperationPerTensorQuantizationRestriction>& quantizationRestrictions;
@@ -62,7 +62,7 @@ public:
         const std::vector<OperationPrecisionRestriction>& precisionRestrictions = {},
         const std::vector<OperationPerTensorQuantizationRestriction>& quantizationRestrictions = {},
         const LayerTransformation::Params = LayerTransformation::Params());
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 
     static bool isFunctionQuantized(const std::shared_ptr<const ngraph::Function>& function);
     static bool isFQLevelsPresent(const std::shared_ptr<const ngraph::Function>& function, const std::set<size_t>& levels);

src/common/low_precision_transformations/include/low_precision/markup_avg_pool_precision_preserved.hpp

@@ -21,5 +21,5 @@ class LP_TRANSFORMATIONS_API MarkupAvgPoolPrecisionPreserved;
 class ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved : public ngraph::pass::FunctionPass {
 public:
     NGRAPH_RTTI_DECLARATION;
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 };

src/common/low_precision_transformations/include/low_precision/markup_can_be_quantized.hpp

@@ -21,5 +21,5 @@ class LP_TRANSFORMATIONS_API MarkupCanBeQuantized;
 class ngraph::pass::low_precision::MarkupCanBeQuantized : public ngraph::pass::FunctionPass {
 public:
     NGRAPH_RTTI_DECLARATION;
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 };

src/common/low_precision_transformations/include/low_precision/markup_per_tensor_quantization.hpp

@@ -37,7 +37,7 @@ public:
 
     NGRAPH_RTTI_DECLARATION;
     explicit MarkupPerTensorQuantization(const std::vector<OperationPerTensorQuantizationRestriction>& restrictions = {});
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 
 private:
     std::unordered_map<std::string, PerTensorQuantization> restrictionsByOperation;

src/common/low_precision_transformations/include/low_precision/markup_precisions.hpp

@@ -38,7 +38,7 @@ public:
 
     NGRAPH_RTTI_DECLARATION;
     explicit MarkupPrecisions(const std::vector<OperationPrecisionRestriction>& restrictions = {});
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 
 private:
     static bool isPrecisionPreserved(const std::shared_ptr<Node>& node);

src/common/low_precision_transformations/include/low_precision/propagate_precisions.hpp

@@ -25,5 +25,5 @@ class LP_TRANSFORMATIONS_API PropagatePrecisions;
 class ngraph::pass::low_precision::PropagatePrecisions : public ngraph::pass::FunctionPass {
 public:
     NGRAPH_RTTI_DECLARATION;
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 };

src/common/low_precision_transformations/include/low_precision/propagate_shared_value.hpp

@@ -30,7 +30,7 @@ class LP_TRANSFORMATIONS_API PropagateSharedValue;
 template <class AttributeType>
 class ngraph::pass::low_precision::PropagateSharedValue : public ngraph::pass::FunctionPass {
 public:
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override {
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& f) override {
         OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::LPT_LT, "PropagateSharedValue");
 
         std::vector<std::shared_ptr<ngraph::Node>> nodes(f->get_ordered_ops());

src/common/low_precision_transformations/src/align_quantization_intervals.cpp

@@ -14,7 +14,7 @@ using namespace ngraph::pass::low_precision;
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::AlignQuantizationIntervals, "AlignQuantizationIntervals", 0);
 
-bool ngraph::pass::low_precision::AlignQuantizationIntervals::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::AlignQuantizationIntervals::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     ngraph::pass::Manager manager;
     manager.set_per_pass_validation(false);
     std::shared_ptr<ngraph::pass::GraphRewrite> intervalsAlignment = manager.register_pass<ngraph::pass::GraphRewrite>();

src/common/low_precision_transformations/src/align_quantization_parameters.cpp

@@ -15,7 +15,7 @@ using namespace ngraph::pass::low_precision;
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::AlignQuantizationParameters, "AlignQuantizationParameters", 0);
 
-bool ngraph::pass::low_precision::AlignQuantizationParameters::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::AlignQuantizationParameters::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     ngraph::pass::Manager manager;
     manager.set_per_pass_validation(false);
     std::shared_ptr<ngraph::pass::GraphRewrite> propagation = manager.register_pass<ngraph::pass::GraphRewrite>();

src/common/low_precision_transformations/src/low_precision.cpp

@@ -166,7 +166,7 @@ MarkupOptimizations::MarkupOptimizations(
     precisionRestrictions(precisionRestrictions),
     quantizationRestrictions(quantizationRestrictions) {}
 
-bool ngraph::pass::low_precision::MarkupOptimizations::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::MarkupOptimizations::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     ngraph::pass::Manager markup(get_pass_config());
     markup.set_per_pass_validation(false);
     markup.register_pass<low_precision::MarkupCanBeQuantized>();
@@ -188,7 +188,7 @@ bool ngraph::pass::low_precision::MarkupOptimizations::run_on_function(std::shar
     return false;
 }
 
-bool ngraph::pass::low_precision::LowPrecision::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::LowPrecision::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::LPT_LT, "LowPrecision");
 
     auto passConfig = get_pass_config();

src/common/low_precision_transformations/src/markup_avg_pool_precision_preserved.cpp

@@ -14,7 +14,7 @@ using namespace ngraph;
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved, "MarkupAvgPoolPrecisionPreserved", 0);
 
-bool ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     ngraph::pass::Manager manager;
     manager.set_per_pass_validation(false);
     std::shared_ptr<ngraph::pass::GraphRewrite> markupAvgPoolPrecision = manager.register_pass<ngraph::pass::GraphRewrite>();

src/common/low_precision_transformations/src/markup_can_be_quantized.cpp

@@ -18,7 +18,7 @@ using namespace ngraph;
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::MarkupCanBeQuantized, "MarkupCanBeQuantized", 0);
 
-bool ngraph::pass::low_precision::MarkupCanBeQuantized::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::MarkupCanBeQuantized::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     auto setEmptyPrecisions = [](const std::shared_ptr<ngraph::Node>& node) {
         for (auto& input : node->inputs()) {
             auto& rt = input.get_rt_info();

src/common/low_precision_transformations/src/markup_per_tensor_quantization.cpp

@@ -28,7 +28,7 @@ ngraph::pass::low_precision::MarkupPerTensorQuantization::MarkupPerTensorQuantiz
     }
 }
 
-bool ngraph::pass::low_precision::MarkupPerTensorQuantization::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::MarkupPerTensorQuantization::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     auto setRestriction = [](const std::shared_ptr<Node>& node, const std::vector<size_t>& restrictedPorts) {
         auto createAttribute = [](Input<Node>& input){
             auto &rt = input.get_rt_info();

src/common/low_precision_transformations/src/markup_precisions.cpp

@@ -62,7 +62,7 @@ void setRestriction(
 }
 } // namespace
 
-bool ngraph::pass::low_precision::MarkupPrecisions::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::MarkupPrecisions::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     for (const std::shared_ptr<Node>& node : f->get_ordered_ops()) {
         if (node->get_input_size() == 0) {
             continue;

src/common/low_precision_transformations/src/propagate_precisions.cpp

@@ -17,7 +17,7 @@ using namespace ngraph::pass::low_precision;
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::PropagatePrecisions, "PropagatePrecisions", 0);
 
-bool ngraph::pass::low_precision::PropagatePrecisions::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::low_precision::PropagatePrecisions::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     ngraph::pass::Manager manager;
     manager.set_per_pass_validation(false);
     std::shared_ptr<ngraph::pass::GraphRewrite> precisionsPropagation = manager.register_pass<ngraph::pass::GraphRewrite>();