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

docs/snippets/Graph_debug_capabilities0.cpp

@@ -1,13 +1,13 @@
 #include <ie_core.hpp>
-#include <ngraph/function.hpp>
-#include <ngraph/pass/visualize_tree.hpp>
+#include <openvino/core/model.hpp>
+#include <openvino/pass/visualize_tree.hpp>
 
 int main() {
 using namespace InferenceEngine;
 //! [part0]
-std::shared_ptr<ngraph::Function> nGraph;
+std::shared_ptr<ov::Model> model;
 // ...
-ngraph::pass::VisualizeTree("after.png").run_on_function(nGraph);     // Visualize the nGraph function to an image
+ov::pass::VisualizeTree("after.png").run_on_model(model);     // Visualize the nGraph function to an image
 //! [part0]
 return 0;
 }

docs/snippets/ov_common.cpp

@@ -62,7 +62,7 @@ int main() {
     //! [ov_api_2_0:create_core]
 
     //! [ov_api_2_0:read_model]
-    std::shared_ptr<ov::Function> network = core.read_model("model.xml");
+    std::shared_ptr<ov::Model> network = core.read_model("model.xml");
     //! [ov_api_2_0:read_model]
 
     //! [ov_api_2_0:get_inputs_outputs]

docs/snippets/ov_graph.cpp

@@ -40,8 +40,7 @@ int main() {
     auto result = std::make_shared<ov::opset8::Result>(concat);
     result->set_friendly_name("result");  // operation name
 
-    auto f =
-        std::make_shared<ov::Function>(ov::ResultVector{result}, ov::ParameterVector{data1, data2}, "function_name");
+    auto f = std::make_shared<ov::Model>(ov::ResultVector{result}, ov::ParameterVector{data1, data2}, "function_name");
     //! [ov:graph]
     return 0;
 }

docs/template_plugin/src/template_executable_network.cpp

@@ -221,7 +221,7 @@ void TemplatePlugin::ExecutableNetwork::Export(std::ostream& modelStream) {
     OPENVINO_SUPPRESS_DEPRECATED_START
     ov::pass::Serialize serializer(xmlFile, binFile, custom_opsets);
     OPENVINO_SUPPRESS_DEPRECATED_END
-    serializer.run_on_function(_function);
+    serializer.run_on_model(_function);
 
     auto m_constants = binFile.str();
     auto m_model = xmlFile.str();

docs/template_plugin/src/transformations/preprocessing/preprocessing.cpp

@@ -15,7 +15,7 @@ NGRAPH_RTTI_DEFINITION(ngraph::pass::AddPreprocessing, "AddPreprocessing", 0);
 ngraph::pass::AddPreprocessing::AddPreprocessing(const InferenceEngine::InputsDataMap& inputInfoMap)
     : m_inputInfoMap(inputInfoMap) {}
 
-bool ngraph::pass::AddPreprocessing::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool ngraph::pass::AddPreprocessing::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
     ngraph::pass::AddMeanSubtract::MeanMap meanMap;
     ngraph::pass::AddStdScale::ScaleMap scaleMap;
 

docs/template_plugin/src/transformations/preprocessing/preprocessing.hpp

@@ -32,5 +32,5 @@ public:
     NGRAPH_RTTI_DECLARATION;
     explicit AddPreprocessing(const InferenceEngine::InputsDataMap& inputInfoMap);
 
-    bool run_on_function(std::shared_ptr<ngraph::Function> f) override;
+    bool run_on_model(const std::shared_ptr<ngraph::Function>& m) override;
 };

docs/template_plugin/src/transformations/template_function_transformation.cpp

@@ -12,7 +12,7 @@ using namespace ngraph;
 // template_function_transformation.cpp
 NGRAPH_RTTI_DEFINITION(ngraph::pass::MyFunctionTransformation, "MyFunctionTransformation", 0);
 
-bool pass::MyFunctionTransformation::run_on_function(std::shared_ptr<ngraph::Function> f) {
+bool pass::MyFunctionTransformation::run_on_model(const std::shared_ptr<ov::Model>& f) {
     RUN_ON_FUNCTION_SCOPE(MyFunctionTransformation);
     // Example transformation code
     NodeVector nodes;

docs/template_plugin/src/transformations/template_function_transformation.hpp

@@ -19,6 +19,6 @@ class MyFunctionTransformation;
 class ngraph::pass::MyFunctionTransformation : 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<ov::Model>& f) override;
 };
 // ! [function_pass:template_transformation_hpp]

docs/template_plugin/src/transformations/template_pattern_transformation.cpp

@@ -143,7 +143,7 @@ void run_matcher_with_gr(std::shared_ptr<ngraph::Function> f) {
     ngraph::pass::GraphRewrite pass;
     pass.add_matcher<ngraph::pass::DecomposeDivideMatcher>();
     pass.add_matcher<ngraph::pass::ReluReluFusionMatcher>();
-    pass.run_on_function(f);
+    pass.run_on_model(f);
     // ! [matcher_pass:graph_rewrite]
 }
 

docs/template_plugin/tests/functional/op_reference/abs.cpp

@@ -49,12 +49,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto log = std::make_shared<op::v0::Abs>(in);
-        return std::make_shared<Function>(NodeVector{log}, ParameterVector{in});
+        return std::make_shared<Model>(NodeVector{log}, ParameterVector{in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/acos.cpp

@@ -39,10 +39,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto acos = std::make_shared<op::v0::Acos>(in);
-        return std::make_shared<Function>(NodeVector {acos}, ParameterVector {in});
+        return std::make_shared<Model>(NodeVector {acos}, ParameterVector {in});
     }
 };
 
@@ -79,4 +79,4 @@ INSTANTIATE_TEST_SUITE_P(
                           .input({{2}, element::u64, std::vector<uint64_t> {0, 1}})
                           .expected({{2}, element::u64, std::vector<uint64_t> {1, 0}})),
     ReferenceAcosLayerTest::getTestCaseName);
-}  // namespace reference_tests
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/acosh.cpp

@@ -39,10 +39,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto acosh = std::make_shared<op::v3::Acosh>(in);
-        return std::make_shared<ov::Function>(NodeVector {acosh}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {acosh}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/adaptive_avg_pool.cpp

@@ -64,14 +64,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type& input_type,
                                                     const Shape& adaptive_shape,
                                                     const std::vector<int64_t> adaptive_values) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto out = op::v0::Constant::create<int64_t>(element::Type_t::i64, adaptive_shape, adaptive_values);
         const auto adaptive_avg_pool = std::make_shared<op::v8::AdaptiveAvgPool>(in, out);
-        return std::make_shared<Function>(NodeVector{adaptive_avg_pool}, ParameterVector{in});
+        return std::make_shared<Model>(NodeVector{adaptive_avg_pool}, ParameterVector{in});
     }
 };
 
@@ -178,4 +178,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForAdaptiveAvgPool()),
     ReferenceAdaptiveAvgPoolLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/adaptive_max_pool.cpp

@@ -67,14 +67,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type& input_type,
                                                     const Shape& adaptive_shape,
                                                     const std::vector<int64_t> adaptive_values) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto out = op::v0::Constant::create<int64_t>(element::Type_t::i64, adaptive_shape, adaptive_values);
         const auto adaptive_max_pool = std::make_shared<op::v8::AdaptiveMaxPool>(in, out);
-        return std::make_shared<Function>(adaptive_max_pool->outputs(), ParameterVector{in});
+        return std::make_shared<Model>(adaptive_max_pool->outputs(), ParameterVector{in});
     }
 };
 
@@ -214,4 +214,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForAdaptiveMaxPool()),
     ReferenceAdaptiveMaxPoolLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/add.cpp

@@ -56,14 +56,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in1 = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto add = std::make_shared<op::v1::Add>(in1, in2);
-        return std::make_shared<Function>(NodeVector{add}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{add}, ParameterVector{in1, in2});
     }
 };
 
@@ -87,7 +87,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -97,7 +97,7 @@ private:
         add = std::make_shared<op::v1::Add>(add, add);
         add = std::make_shared<op::v1::Add>(add, add);
         add = std::make_shared<op::v1::Add>(add, add);
-        return std::make_shared<Function>(NodeVector{add}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{add}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/asin.cpp

@@ -40,10 +40,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto Asin = std::make_shared<op::v0::Asin>(in);
-        return std::make_shared<ov::Function>(NodeVector {Asin}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Asin}, ParameterVector {in});
     }
 };
 
@@ -96,4 +96,4 @@ INSTANTIATE_TEST_SUITE_P(
             .expected({{2}, element::u64, std::vector<uint64_t> {0, 1}})),
 
     ReferenceAsinLayerTest::getTestCaseName);
-}  // namespace reference_tests
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/asinh.cpp

@@ -40,10 +40,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto Asinh = std::make_shared<op::v3::Asinh>(in);
-        return std::make_shared<ov::Function>(NodeVector {Asinh}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Asinh}, ParameterVector {in});
     }
 };
 
@@ -96,4 +96,4 @@ INSTANTIATE_TEST_SUITE_P(
             .expected({{6}, element::u64, std::vector<uint64_t> {0, 1, 1, 2, 2, 2}})),
 
     ReferenceAsinhLayerTest::getTestCaseName);
-}  // namespace reference_tests
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/atan.cpp

@@ -39,10 +39,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto atan = std::make_shared<op::v0::Atan>(in);
-        return std::make_shared<ov::Function>(NodeVector{atan}, ParameterVector{in});
+        return std::make_shared<ov::Model>(NodeVector{atan}, ParameterVector{in});
     }
 };
 
@@ -94,4 +94,4 @@ INSTANTIATE_TEST_SUITE_P(
             .input({{5}, element::u64, std::vector<uint64_t>{0, 1, 2, 3, 4}})
             .expected({{5}, element::u64, std::vector<uint64_t>{0, 1, 1, 1, 1}})),
     ReferenceAtanLayerTest::getTestCaseName);
-}  // namespace reference_tests
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/atanh.cpp

@@ -44,10 +44,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto out = std::make_shared<op::v3::Atanh>(in);
-        return std::make_shared<ov::Function>(NodeVector{out}, ParameterVector{in});
+        return std::make_shared<ov::Model>(NodeVector{out}, ParameterVector{in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/avg_pool.cpp

@@ -87,7 +87,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type& input_type,
                                                     const Strides& strides,
                                                     const Shape& pads_begin,
@@ -105,7 +105,7 @@ private:
                                                                exclude_pad,
                                                                rounding_type,
                                                                pad_type);
-        return std::make_shared<Function>(NodeVector{avgPool}, ParameterVector{in});
+        return std::make_shared<Model>(NodeVector{avgPool}, ParameterVector{in});
     }
 };
 
@@ -268,4 +268,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForAvgPool()),
     ReferenceAvgPoolLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/base_reference_test.hpp

@@ -28,7 +28,7 @@ public:
 protected:
     const std::string targetDevice;
     std::shared_ptr<ov::runtime::Core> core;
-    std::shared_ptr<ov::Function> function;
+    std::shared_ptr<ov::Model> function;
 
     ov::runtime::ExecutableNetwork executableNetwork;
     ov::runtime::InferRequest inferRequest;

docs/template_plugin/tests/functional/op_reference/batch_norm.cpp

@@ -77,7 +77,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type_t& input_type,
                                                     const float epsilon) {
         Shape channel_shape{input_shape.at(1)};
@@ -88,7 +88,7 @@ private:
         auto variance = std::make_shared<op::v0::Parameter>(input_type, channel_shape);
         auto batch_norm = std::make_shared<op::v0::BatchNormInference>(in, gamma, beta, mean, variance, epsilon);
 
-        return std::make_shared<ov::Function>(batch_norm, ParameterVector{in, gamma, beta, mean, variance});
+        return std::make_shared<ov::Model>(batch_norm, ParameterVector{in, gamma, beta, mean, variance});
     }
 };
 
@@ -102,7 +102,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type_t& input_type,
                                                     const float epsilon) {
         Shape channel_shape{input_shape.at(1)};
@@ -113,7 +113,7 @@ private:
         auto variance = std::make_shared<op::v0::Parameter>(input_type, channel_shape);
         auto batch_norm = std::make_shared<op::v5::BatchNormInference>(in, gamma, beta, mean, variance, epsilon);
 
-        return std::make_shared<ov::Function>(batch_norm, ParameterVector{in, gamma, beta, mean, variance});
+        return std::make_shared<ov::Model>(batch_norm, ParameterVector{in, gamma, beta, mean, variance});
     }
 };
 
@@ -258,4 +258,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForBatchNorm()),
     ReferenceBatchNormV5LayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/batch_to_space.cpp

@@ -59,13 +59,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const BatchToSpaceParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const BatchToSpaceParams& params) {
         const auto data = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto blockShape = std::make_shared<opset1::Constant>(element::i64, params.blockShapeTensor.shape, params.blockShapeTensor.data.data());
         const auto cropsBegin = std::make_shared<opset1::Constant>(element::i64, params.cropsBeginTensor.shape, params.cropsBeginTensor.data.data());
         const auto cropsEnd = std::make_shared<opset1::Constant>(element::i64, params.cropsEndTensor.shape, params.cropsEndTensor.data.data());
         const auto batchToSpace = std::make_shared<opset2::BatchToSpace>(data, blockShape, cropsBegin, cropsEnd);
-        return std::make_shared<Function>(NodeVector {batchToSpace}, ParameterVector {data});
+        return std::make_shared<Model>(NodeVector {batchToSpace}, ParameterVector {data});
     }
 };
 
@@ -219,4 +219,4 @@ std::vector<BatchToSpaceParams> generateBatchToSpaceCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_BatchToSpace_With_Hardcoded_Refs, ReferenceBatchToSpaceLayerTest,
     testing::ValuesIn(generateBatchToSpaceCombinedParams()), ReferenceBatchToSpaceLayerTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/binary_convolution.cpp

@@ -89,7 +89,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const BinaryConvolutionParams& params, const std::vector<uint8_t>& filterData) {
+    static std::shared_ptr<Model> CreateFunction(const BinaryConvolutionParams& params, const std::vector<uint8_t>& filterData) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
         auto filter = std::make_shared<opset8::Constant>(ov::element::u1, params.filterShape, &filterData[0]);
@@ -102,7 +102,7 @@ private:
                                                                        params.mode,
                                                                        params.padValue,
                                                                        auto_pad);
-        return std::make_shared<ov::Function>(NodeVector {BinaryConvolution}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {BinaryConvolution}, ParameterVector {in});
     }
 };
 
@@ -313,4 +313,4 @@ std::vector<BinaryConvolutionParams> generateBinaryConvolutionCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_BinaryConvolution_With_Hardcoded_Refs, ReferenceBinaryConvolutionLayerTest,
     testing::ValuesIn(generateBinaryConvolutionCombinedParams()), ReferenceBinaryConvolutionLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/broadcast.cpp

@@ -52,9 +52,9 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const BroadcastParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const BroadcastParams& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
-        const auto f = std::make_shared<Function>(
+        const auto f = std::make_shared<Model>(
             std::make_shared<opset1::Broadcast>(A, opset1::Constant::create(params.targetShapeTensor.type,
                                                                             params.targetShapeTensor.shape,
                                                                             params.targetShapeTensor.data.data())),
@@ -69,9 +69,9 @@ TEST_P(ReferenceBroadcastTest, CompareWithRefs) {
 
 class ReferenceBroadcastTestV3 : public ReferenceBroadcastTest {
 private:
-    static std::shared_ptr<Function> CreateFunction(const BroadcastParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const BroadcastParams& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
-        const auto f = std::make_shared<Function>(
+        const auto f = std::make_shared<Model>(
             std::make_shared<opset3::Broadcast>(A, opset1::Constant::create(params.targetShapeTensor.type,
                                                                             params.targetShapeTensor.shape,
                                                                             params.targetShapeTensor.data.data())),
@@ -123,9 +123,9 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const BroadcastParamsExplicitAxis& params) {
+    static std::shared_ptr<Model> CreateFunction(const BroadcastParamsExplicitAxis& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
-        const auto f = std::make_shared<Function>(
+        const auto f = std::make_shared<Model>(
             std::make_shared<opset1::Broadcast>(A,
                                                 opset1::Constant::create(params.targetShapeTensor.type,
                                                                          params.targetShapeTensor.shape,
@@ -191,7 +191,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const BroadcastParamsTestHelper& params) {
+    static std::shared_ptr<Model> CreateFunction(const BroadcastParamsTestHelper& params) {
         const auto A = std::make_shared<opset1::Parameter>(element::f32, params.shapeA);
         const auto shape_const = opset1::Constant::create(element::u64, Shape{params.shapeR.size()}, params.shapeR);
         std::shared_ptr<Node> broadcast;
@@ -201,7 +201,7 @@ private:
         } else {
             broadcast = std::make_shared<opset1::Broadcast>(A, shape_const);
         }
-        auto f = std::make_shared<Function>(broadcast, ParameterVector{A});
+        auto f = std::make_shared<Model>(broadcast, ParameterVector{A});
         return f;
     }
 
@@ -226,7 +226,7 @@ TEST_P(ReferenceBroadcastTestTestHelper, CompareWithRefs) {
 
 class ReferenceBroadcastTestExplicitAxisReversed : public ReferenceBroadcastTestExplicitAxis {
 private:
-    static std::shared_ptr<Function> CreateFunction(const BroadcastParamsExplicitAxis& params) {
+    static std::shared_ptr<Model> CreateFunction(const BroadcastParamsExplicitAxis& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         auto broadcast = std::make_shared<opset1::Broadcast>(
             A,
@@ -239,7 +239,7 @@ private:
         auto reverse = std::make_shared<opset1::Reverse>(broadcast,
                                                          opset1::Constant::create(element::i64, {1}, {1}),
                                                          opset1::Reverse::Mode::INDEX);
-        auto f = std::make_shared<Function>(NodeVector{reverse}, ParameterVector{A});
+        auto f = std::make_shared<Model>(NodeVector{reverse}, ParameterVector{A});
         return f;
     }
 };
@@ -525,4 +525,4 @@ std::vector<BroadcastParamsExplicitAxis> generateCombinedParamsExplicitAxisRever
 
 INSTANTIATE_TEST_SUITE_P(smoke_Broadcast_With_Hardcoded_Refs, ReferenceBroadcastTestExplicitAxisReversed,
     testing::ValuesIn(generateCombinedParamsExplicitAxisReversed()), ReferenceBroadcastTestExplicitAxis::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/bucketize.cpp

@@ -59,12 +59,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const element::Type& input_type, const PartialShape& input_pshape,
+    static std::shared_ptr<Model> CreateFunction(const element::Type& input_type, const PartialShape& input_pshape,
                                                     const element::Type& bucket_type, const PartialShape& bucket_pshape,
                                                     const bool with_right_bound, const element::Type& output_type) {
         auto data = std::make_shared<op::v0::Parameter>(input_type, input_pshape);
         auto buckets = std::make_shared<op::v0::Parameter>(bucket_type, bucket_pshape);
-        return std::make_shared<Function>(std::make_shared<op::v3::Bucketize>(data, buckets, output_type, with_right_bound),
+        return std::make_shared<Model>(std::make_shared<op::v3::Bucketize>(data, buckets, output_type, with_right_bound),
                                               ParameterVector {data, buckets});
     }
 };

docs/template_plugin/tests/functional/op_reference/ceiling.cpp

@@ -49,12 +49,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto ceiling = std::make_shared<op::v0::Ceiling>(in);
-        return std::make_shared<Function>(NodeVector {ceiling}, ParameterVector {in});
+        return std::make_shared<Model>(NodeVector {ceiling}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/clamp.cpp

@@ -53,11 +53,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type,
                                                     const ov::element::Type& expected_output_type, const double min, const double max) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Clamp = std::make_shared<op::v0::Clamp>(in, min, max);
-        return std::make_shared<ov::Function>(NodeVector {Clamp}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Clamp}, ParameterVector {in});
     }
 };
 
@@ -198,4 +198,4 @@ std::vector<ClampParams> generateClampCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_Clamp_With_Hardcoded_Refs, ReferenceClampLayerTest,
     testing::ValuesIn(generateClampCombinedParams()), ReferenceClampLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/comparison.hpp

@@ -46,13 +46,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<ov::Function> CreateFunction(ngraph::helpers::ComparisonTypes comp_op_type, const ov::PartialShape& input_shape1,
+    static std::shared_ptr<ov::Model> CreateFunction(ngraph::helpers::ComparisonTypes comp_op_type, const ov::PartialShape& input_shape1,
                                                             const ov::PartialShape& input_shape2, const ov::element::Type& input_type,
                                                             const ov::element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto comp = ngraph::builder::makeComparison(in, in2, comp_op_type);
-        return std::make_shared<ov::Function>(ov::NodeVector {comp}, ov::ParameterVector {in, in2});
+        return std::make_shared<ov::Model>(ov::NodeVector {comp}, ov::ParameterVector {in, in2});
     }
 };
 }  // namespace ComparisonOpsRefTestDefinitions

docs/template_plugin/tests/functional/op_reference/concat.cpp

@@ -58,7 +58,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParams& params) {
         std::shared_ptr<opset1::Parameter> A, B, C;
         if (params.dynamicShape.is_dynamic()) {
             A = std::make_shared<opset1::Parameter>(params.A.type, params.dynamicShape);
@@ -69,7 +69,7 @@ private:
             B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
             C = std::make_shared<opset1::Parameter>(params.C.type, params.C.shape);
         }
-        auto f = std::make_shared<Function>(std::make_shared<opset1::Concat>(NodeVector{A, B, C}, params.axis), ParameterVector{A, B, C});
+        auto f = std::make_shared<Model>(std::make_shared<opset1::Concat>(NodeVector{A, B, C}, params.axis), ParameterVector{A, B, C});
         return f;
     }
 };
@@ -183,7 +183,7 @@ public:
             inputs_param.push_back(A);
             inputs.push_back(A);
         }
-        function = std::make_shared<Function>(std::make_shared<opset1::Concat>(inputs, 0), inputs_param);
+        function = std::make_shared<Model>(std::make_shared<opset1::Concat>(inputs, 0), inputs_param);
 
         std::vector<float> ref_result;
         for (uint32_t i = 0; i < params.numInputs; i++) {
@@ -284,7 +284,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlace2dTensor& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlace2dTensor& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto add1 = std::make_shared<opset1::Add>(A, B);
@@ -292,7 +292,7 @@ private:
         const auto D = std::make_shared<opset1::Parameter>(params.D.type, params.D.shape);
         const auto add2 = std::make_shared<opset1::Add>(C, D);
         const auto subtract = std::make_shared<opset1::Subtract>(C, A);
-        const auto f = std::make_shared<Function>(
+        const auto f = std::make_shared<Model>(
             std::make_shared<opset1::Concat>(NodeVector{add1, add2, subtract}, params.axis),
                                              ParameterVector{A, B, C, D});
         return f;
@@ -389,7 +389,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlacePropagate2dTensor& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlacePropagate2dTensor& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto add1 = std::make_shared<opset1::Add>(A, B);
@@ -398,7 +398,7 @@ private:
         const auto add2 = std::make_shared<opset1::Add>(C, D);
         const auto concat1 = std::make_shared<opset1::Concat>(NodeVector{add1, add2}, params.axis);
         const auto subtract = std::make_shared<opset1::Subtract>(C, A);
-        const auto f = std::make_shared<Function>(
+        const auto f = std::make_shared<Model>(
             std::make_shared<opset1::Concat>(NodeVector{concat1, subtract}, params.axis),
                                              ParameterVector{A, B, C, D});
         return f;
@@ -489,13 +489,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlaceTree1& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlaceTree1& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto add1 = std::make_shared<opset1::Add>(A, B);
         const auto add2 = std::make_shared<opset1::Add>(A, B);
         const auto concat = std::make_shared<opset1::Concat>(NodeVector{add1, add2}, params.axis);
-        const auto f = std::make_shared<Function>(std::make_shared<opset1::Add>(concat, concat),
+        const auto f = std::make_shared<Model>(std::make_shared<opset1::Add>(concat, concat),
                                                   ParameterVector{A, B});
         return f;
     }
@@ -583,7 +583,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlaceTree2& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlaceTree2& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto add1 = std::make_shared<opset1::Add>(A, B);
@@ -591,7 +591,7 @@ private:
         const auto concat1 = std::make_shared<opset1::Concat>(NodeVector{add1, add2}, params.axis);
         const auto concat2 = std::make_shared<opset1::Concat>(NodeVector{add1, add2}, params.axis);
         const auto concat12 = std::make_shared<opset1::Concat>(NodeVector{concat1, concat2}, params.axis);
-        const auto f = std::make_shared<Function>(std::make_shared<opset1::Add>(concat12, concat12),
+        const auto f = std::make_shared<Model>(std::make_shared<opset1::Add>(concat12, concat12),
                                                   ParameterVector{A, B});
         return f;
     }
@@ -680,7 +680,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlaceTree3& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlaceTree3& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto concat1 = std::make_shared<opset1::Concat>(NodeVector{A, B}, params.axis);
@@ -690,7 +690,7 @@ private:
         const auto concat12 = std::make_shared<opset1::Concat>(NodeVector{concat1, concat2}, params.axis);
         const auto concat34 = std::make_shared<opset1::Concat>(NodeVector{concat3, concat4}, params.axis);
         const auto concat14 = std::make_shared<opset1::Concat>(NodeVector{concat12, concat34}, params.axis);
-        const auto f = std::make_shared<Function>(std::make_shared<opset1::Add>(concat14, concat14),
+        const auto f = std::make_shared<Model>(std::make_shared<opset1::Add>(concat14, concat14),
                                                   ParameterVector{A, B});
         return f;
     }
@@ -781,14 +781,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlaceAddConcat& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlaceAddConcat& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto add1 = std::make_shared<opset1::Add>(A, B);
         const auto add2 = std::make_shared<opset1::Add>(add1, add1);
         const auto concat = std::make_shared<opset1::Concat>(NodeVector{add1, add2}, params.axis);
         const auto add3 = std::make_shared<opset1::Add>(concat, concat);
-        const auto f = std::make_shared<Function>(add3, ParameterVector{A, B});
+        const auto f = std::make_shared<Model>(add3, ParameterVector{A, B});
         return f;
     }
 };
@@ -875,7 +875,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsInPlaceAddConcat2& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsInPlaceAddConcat2& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto add1 = std::make_shared<opset1::Add>(A, B);
@@ -886,7 +886,7 @@ private:
         const auto concat1 = std::make_shared<opset1::Concat>(NodeVector{add1, add2, add3}, params.axis);
         const auto concat2 = std::make_shared<opset1::Concat>(NodeVector{add4, add2, add5}, params.axis);
         const auto add6 = std::make_shared<opset1::Add>(concat1, concat2);
-        const auto f = std::make_shared<Function>(add6, ParameterVector{A, B});
+        const auto f = std::make_shared<Model>(add6, ParameterVector{A, B});
         return f;
     }
 };
@@ -976,12 +976,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParams5d& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParams5d& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto C = std::make_shared<opset1::Parameter>(params.C.type, params.C.shape);
         const auto concat = std::make_shared<opset1::Concat>(NodeVector{A, B, C}, params.axis);
-        const auto f = std::make_shared<Function>(concat, ParameterVector{A, B, C});
+        const auto f = std::make_shared<Model>(concat, ParameterVector{A, B, C});
         return f;
     }
 };
@@ -1103,11 +1103,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsZeroLength1dLast& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsZeroLength1dLast& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto concat = std::make_shared<opset1::Concat>(NodeVector{A, B}, params.axis);
-        const auto f = std::make_shared<Function>(concat, ParameterVector{A, B});
+        const auto f = std::make_shared<Model>(concat, ParameterVector{A, B});
         return f;
     }
 };
@@ -1197,12 +1197,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsZeroLength1dMiddle& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsZeroLength1dMiddle& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto C = std::make_shared<opset1::Parameter>(params.C.type, params.C.shape);
         const auto concat = std::make_shared<opset1::Concat>(NodeVector{A, B, C}, params.axis);
-        const auto f = std::make_shared<Function>(concat, ParameterVector{A, B, C});
+        const auto f = std::make_shared<Model>(concat, ParameterVector{A, B, C});
         return f;
     }
 };
@@ -1287,10 +1287,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsZeroZero& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsZeroZero& params) {
         const auto constant_1 = std::make_shared<opset1::Constant>(params.A.type, params.A.shape, params.A.data.data());
         const auto concat_1 = std::make_shared<opset1::Concat>(NodeVector{constant_1, constant_1}, params.axis);
-        const auto f = std::make_shared<Function>(concat_1, ParameterVector{});
+        const auto f = std::make_shared<Model>(concat_1, ParameterVector{});
         return f;
     }
 };
@@ -1379,12 +1379,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConcatParamsZeroLength4dMiddle& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConcatParamsZeroLength4dMiddle& params) {
         const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
         const auto B = std::make_shared<opset1::Parameter>(params.B.type, params.B.shape);
         const auto C = std::make_shared<opset1::Parameter>(params.C.type, params.C.shape);
         const auto concat = std::make_shared<opset1::Concat>(NodeVector{A, B, C}, params.axis);
-        const auto f = std::make_shared<Function>(concat, ParameterVector{A, B, C});
+        const auto f = std::make_shared<Model>(concat, ParameterVector{A, B, C});
         return f;
     }
 };
@@ -1430,4 +1430,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestZe
     testing::ValuesIn(generateCombinedParamsZeroLength4dMiddle()), ReferenceConcatTestZeroLength4dMiddle::getTestCaseName);
 
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/constant.cpp

@@ -59,9 +59,9 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ParamType& params) {
+    static std::shared_ptr<Model> CreateFunction(const ParamType& params) {
         auto A = op::v0::Constant::create(params.inType, params.inputShape.to_shape(), params.inputData.data());
-        return std::make_shared<Function>(A, ParameterVector{});
+        return std::make_shared<Model>(A, ParameterVector{});
     }
 };
 
@@ -74,10 +74,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ParamType& params) {
+    static std::shared_ptr<Model> CreateFunction(const ParamType& params) {
         auto A = op::v0::Constant::create(params.inType, params.inputShape.to_shape(), params.inputData.data());
         auto B = op::v0::Constant::create(params.inType, params.inputShape.to_shape(), params.inputData.data());
-        return std::make_shared<Function>(NodeVector{A, B}, ParameterVector{});
+        return std::make_shared<Model>(NodeVector{A, B}, ParameterVector{});
     }
 };
 
@@ -90,9 +90,9 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ParamType& params) {
+    static std::shared_ptr<Model> CreateFunction(const ParamType& params) {
         auto A = op::v0::Constant::create(params.inType, params.inputShape.to_shape(), params.inputData.data());
-        return std::make_shared<Function>(std::make_shared<op::v0::Abs>(A), ParameterVector{});
+        return std::make_shared<Model>(std::make_shared<op::v0::Abs>(A), ParameterVector{});
     }
 };
 
@@ -105,12 +105,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ParamType& params) {
+    static std::shared_ptr<Model> CreateFunction(const ParamType& params) {
         const auto A = std::make_shared<op::v0::Constant>(
             params.inType,
             params.inputShape.to_shape(),
             std::vector<std::string>{std::to_string(*reinterpret_cast<int*>(params.inputData.data()))});
-        return std::make_shared<Function>(A, ParameterVector{});
+        return std::make_shared<Model>(A, ParameterVector{});
     }
 };
 
@@ -123,10 +123,10 @@ public:
     }
 
 protected:
-    static std::shared_ptr<Function> CreateFunction(const ParamType& params) {
+    static std::shared_ptr<Model> CreateFunction(const ParamType& params) {
         auto A = op::v0::Constant::create(params.inType, params.inputShape.to_shape(), params.inputData.data());
         auto B = op::v0::Constant::create(params.inType, params.inputShape.to_shape(), {true, true, true, true});
-        return std::make_shared<Function>(std::make_shared<op::v1::Equal>(A, B), ParameterVector{});
+        return std::make_shared<Model>(std::make_shared<op::v1::Equal>(A, B), ParameterVector{});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/conversion.hpp

@@ -51,12 +51,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<ov::Function> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type,
+    static std::shared_ptr<ov::Model> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type,
                                                         const ov::element::Type& expected_output_type,
                                                         const ngraph::helpers::ConversionTypes& conversion_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto convert = ngraph::builder::makeConversion(in, expected_output_type, conversion_type);
-        return std::make_shared<ov::Function>(ov::NodeVector {convert}, ov::ParameterVector {in});
+        return std::make_shared<ov::Model>(ov::NodeVector {convert}, ov::ParameterVector {in});
     }
 };
 } // namespace ConversionOpsRefTestDefinitions

docs/template_plugin/tests/functional/op_reference/convert_color_i420.cpp

@@ -4,7 +4,7 @@
 
 #include <gtest/gtest.h>
 
-#include <openvino/core/function.hpp>
+#include <openvino/core/model.hpp>
 #include <tuple>
 #include <openvino/op/i420_to_rgb.hpp>
 #include <openvino/op/i420_to_bgr.hpp>
@@ -26,23 +26,23 @@ public:
 
 public:
     template <typename T>
-    static std::shared_ptr<Function> CreateFunction(const Tensor& input) {
+    static std::shared_ptr<Model> CreateFunction(const Tensor& input) {
         const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
         std::shared_ptr<Node> conv;
         conv = std::make_shared<T>(in);
         auto res = std::make_shared<op::v0::Result>(conv);
-        return std::make_shared<Function>(ResultVector{res}, ParameterVector {in});
+        return std::make_shared<Model>(ResultVector{res}, ParameterVector {in});
     }
 
     template <typename T>
-    static std::shared_ptr<Function> CreateFunction3(const Tensor& input1, const Tensor& input2, const Tensor& input3) {
+    static std::shared_ptr<Model> CreateFunction3(const Tensor& input1, const Tensor& input2, const Tensor& input3) {
         const auto in1 = std::make_shared<op::v0::Parameter>(input1.type, input1.shape);
         const auto in2 = std::make_shared<op::v0::Parameter>(input2.type, input2.shape);
         const auto in3 = std::make_shared<op::v0::Parameter>(input3.type, input3.shape);
         std::shared_ptr<Node> conv;
         conv = std::make_shared<T>(in1, in2, in3);
         auto res = std::make_shared<op::v0::Result>(conv);
-        return std::make_shared<Function>(ResultVector{res}, ParameterVector {in1, in2, in3});
+        return std::make_shared<Model>(ResultVector{res}, ParameterVector {in1, in2, in3});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/convert_color_nv12.cpp

@@ -4,7 +4,7 @@
 
 #include <gtest/gtest.h>
 
-#include <openvino/core/function.hpp>
+#include <openvino/core/model.hpp>
 #include <tuple>
 #include <openvino/op/nv12_to_rgb.hpp>
 #include <openvino/op/nv12_to_bgr.hpp>
@@ -26,22 +26,22 @@ public:
 
 public:
     template <typename T>
-    static std::shared_ptr<Function> CreateFunction(const Tensor& input) {
+    static std::shared_ptr<Model> CreateFunction(const Tensor& input) {
         const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
         std::shared_ptr<Node> conv;
         conv = std::make_shared<T>(in);
         auto res = std::make_shared<op::v0::Result>(conv);
-        return std::make_shared<Function>(ResultVector{res}, ParameterVector {in});
+        return std::make_shared<Model>(ResultVector{res}, ParameterVector {in});
     }
 
     template <typename T>
-    static std::shared_ptr<Function> CreateFunction2(const Tensor& input1, const Tensor& input2) {
+    static std::shared_ptr<Model> CreateFunction2(const Tensor& input1, const Tensor& input2) {
         const auto in1 = std::make_shared<op::v0::Parameter>(input1.type, input1.shape);
         const auto in2 = std::make_shared<op::v0::Parameter>(input2.type, input2.shape);
         std::shared_ptr<Node> conv;
         conv = std::make_shared<T>(in1, in2);
         auto res = std::make_shared<op::v0::Result>(conv);
-        return std::make_shared<Function>(ResultVector{res}, ParameterVector {in1, in2});
+        return std::make_shared<Model>(ResultVector{res}, ParameterVector {in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/convolution.cpp

@@ -94,7 +94,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConvolutionParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConvolutionParams& params) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -115,9 +115,9 @@ private:
                                                                            params.padEnd,
                                                                            params.dialations,
                                                                            auto_pad);
-            return std::make_shared<ov::Function>(NodeVector {Convolution2}, ParameterVector {in, filter});
+            return std::make_shared<ov::Model>(NodeVector {Convolution2}, ParameterVector {in, filter});
         } else {
-            return std::make_shared<ov::Function>(NodeVector {Convolution}, ParameterVector {in, filter});
+            return std::make_shared<ov::Model>(NodeVector {Convolution}, ParameterVector {in, filter});
         }
     }
 };
@@ -1086,4 +1086,4 @@ std::vector<ConvolutionParams> generateConvolutionCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_Convolution_With_Hardcoded_Refs, ReferenceConvolutionLayerTest,
     testing::ValuesIn(generateConvolutionCombinedParams()), ReferenceConvolutionLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/convolution_backprop.cpp

@@ -93,7 +93,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ConvolutionBackpropParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const ConvolutionBackpropParams& params) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -107,7 +107,7 @@ private:
                                                                        auto_pad,
                                                                        params.outPadding);
 
-        return std::make_shared<ov::Function>(NodeVector {ConvolutionBackprop}, ParameterVector {in, filter});
+        return std::make_shared<ov::Model>(NodeVector {ConvolutionBackprop}, ParameterVector {in, filter});
     }
 };
 
@@ -1773,4 +1773,4 @@ std::vector<ConvolutionBackpropParams> generateConvolutionBackpropCombinedParams
 INSTANTIATE_TEST_SUITE_P(smoke_ConvolutionBackprop_With_Hardcoded_Refs, ReferenceConvolutionBackpropLayerTest,
     testing::ValuesIn(generateConvolutionBackpropCombinedParams()), ReferenceConvolutionBackpropLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/cos.cpp

@@ -39,10 +39,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto Cos = std::make_shared<op::v0::Cos>(in);
-        return std::make_shared<ov::Function>(NodeVector {Cos}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Cos}, ParameterVector {in});
     }
 };
 
@@ -95,4 +95,4 @@ INSTANTIATE_TEST_SUITE_P(
             .expected({{3}, element::u64, std::vector<uint64_t> {1, 0, 0}})),
 
     ReferenceCosLayerTest::getTestCaseName);
-}  // namespace reference_tests
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/cosh.cpp

@@ -39,10 +39,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& shape, const element::Type& type) {
         const auto in = std::make_shared<op::v0::Parameter>(type, shape);
         const auto Cosh = std::make_shared<op::v0::Cosh>(in);
-        return std::make_shared<ov::Function>(NodeVector {Cosh}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Cosh}, ParameterVector {in});
     }
 };
 
@@ -95,4 +95,4 @@ INSTANTIATE_TEST_SUITE_P(
             .expected({{4}, element::u64, std::vector<uint64_t> {1, 2, 4, 27}})),
 
     ReferenceCoshLayerTest::getTestCaseName);
-}  // namespace reference_tests
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/ctc_greedy_decoder.cpp

@@ -53,12 +53,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const CTCGreedyDecoderParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const CTCGreedyDecoderParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto indices = std::make_shared<op::v0::Parameter>(params.masksTensor.type, params.masksTensor.shape);
         const auto decoder = std::make_shared<op::v0::CTCGreedyDecoder>(data, indices, params.ctcMergedRepeat);
-        function = std::make_shared<ov::Function>(NodeVector{decoder}, ParameterVector{data, indices});
+        function = std::make_shared<ov::Model>(NodeVector{decoder}, ParameterVector{data, indices});
         return function;
     }
 };
@@ -129,4 +129,4 @@ std::vector<CTCGreedyDecoderParams> generateCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_CTCGreedyDecoder_With_Hardcoded_Refs, ReferenceCTCGreedyDecoderTest,
     testing::ValuesIn(generateCombinedParams()), ReferenceCTCGreedyDecoderTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/ctc_greedy_decoder_seq_len.cpp

@@ -73,14 +73,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const CTCGreedyDecoderSeqLenParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const CTCGreedyDecoderSeqLenParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto seq_len = std::make_shared<op::v0::Parameter>(params.seqLenTensor.type, params.seqLenTensor.shape);
         auto blank_index = std::make_shared<op::v0::Constant>(params.blankIndexTensor.type, params.blankIndexTensor.shape,
                                                               params.blankIndexTensor.data.data());
         const auto decoder = std::make_shared<op::v6::CTCGreedyDecoderSeqLen>(data, seq_len, blank_index, params.mergeRepeated);
-        function = std::make_shared<ov::Function>(decoder->outputs(), ParameterVector{data, seq_len});
+        function = std::make_shared<ov::Model>(decoder->outputs(), ParameterVector{data, seq_len});
         return function;
     }
 };
@@ -114,12 +114,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const CTCGreedyDecoderSeqLenParamsNoOptionalInput& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const CTCGreedyDecoderSeqLenParamsNoOptionalInput& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto seq_len = std::make_shared<op::v0::Parameter>(params.seqLenTensor.type, params.seqLenTensor.shape);
         const auto decoder = std::make_shared<op::v6::CTCGreedyDecoderSeqLen>(data, seq_len, params.mergeRepeated);
-        function = std::make_shared<ov::Function>(decoder->outputs(), ParameterVector{data, seq_len});
+        function = std::make_shared<ov::Model>(decoder->outputs(), ParameterVector{data, seq_len});
         return function;
     }
 };
@@ -225,4 +225,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_CTCGreedyDecoderSeqLen_With_Hardcoded_Refs, Refer
 
 INSTANTIATE_TEST_SUITE_P(smoke_CTCGreedyDecoderSeqLen_With_Hardcoded_Refs, ReferenceCTCGreedyDecoderSeqLenTestNoOptionalInput,
     testing::ValuesIn(generateCombinedParamsNoOptionalInput()), ReferenceCTCGreedyDecoderSeqLenTestNoOptionalInput::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/ctc_loss.cpp

@@ -61,7 +61,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const CTCLossParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const CTCLossParams& params) {
         const auto A = std::make_shared<op::v0::Parameter>(params.logits.type, params.logits.shape);        // logits
         const auto B = std::make_shared<op::v0::Parameter>(params.logitsLen.type, params.logitsLen.shape);  // logitsLen
         const auto C = std::make_shared<op::v0::Parameter>(params.labels.type, params.labels.shape);        // labels
@@ -69,7 +69,7 @@ private:
         const auto E = std::make_shared<op::v0::Parameter>(params.blankIdx.type, params.blankIdx.shape);    // blankIdx
 
         const auto ctcLoss = std::make_shared<op::v4::CTCLoss>(A, B, C, D, E, params.preprocessCollapseRepeated, params.ctcMergeRepeated, params.unique);
-        return std::make_shared<ov::Function>(NodeVector {ctcLoss}, ParameterVector {A, B, C, D, E});
+        return std::make_shared<ov::Model>(NodeVector {ctcLoss}, ParameterVector {A, B, C, D, E});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/cum_sum.cpp

@@ -85,18 +85,18 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& data_shape, const element::Type& data_type, const PartialShape& axis_shape,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& data_shape, const element::Type& data_type, const PartialShape& axis_shape,
                                                     const element::Type& axis_type, const bool execlusive, const bool reverse) {
         const auto data_param = std::make_shared<op::v0::Parameter>(data_type, data_shape);
         const auto axis_param = std::make_shared<op::v0::Parameter>(axis_type, axis_shape);
         const auto cum_sum = std::make_shared<op::v0::CumSum>(data_param, axis_param, execlusive, reverse);
-        return std::make_shared<ov::Function>(NodeVector {cum_sum}, ParameterVector {data_param, axis_param});
+        return std::make_shared<ov::Model>(NodeVector {cum_sum}, ParameterVector {data_param, axis_param});
     }
 
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& data_shape, const element::Type& data_type) {
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& data_shape, const element::Type& data_type) {
         const auto data_param = std::make_shared<op::v0::Parameter>(data_type, data_shape);
         const auto cum_sum = std::make_shared<op::v0::CumSum>(data_param);
-        return std::make_shared<ov::Function>(NodeVector {cum_sum}, ParameterVector {data_param});
+        return std::make_shared<ov::Model>(NodeVector {cum_sum}, ParameterVector {data_param});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/deformable_convolution.cpp

@@ -133,7 +133,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const DeformableConvolutionParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const DeformableConvolutionParams& params) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -149,7 +149,7 @@ private:
                                                                        auto_pad,
                                                                        params.group,
                                                                        params.deformableGroup);
-        return std::make_shared<ov::Function>(NodeVector {DeformableConvolution}, ParameterVector {in, offset, filter});
+        return std::make_shared<ov::Model>(NodeVector {DeformableConvolution}, ParameterVector {in, offset, filter});
     }
 };
 
@@ -191,7 +191,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const DeformableConvolutionParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const DeformableConvolutionParams& params) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -211,7 +211,7 @@ private:
                                                                         params.group,
                                                                         params.deformableGroup,
                                                                         params.use_bilinear_interpolation_padding);
-            return std::make_shared<ov::Function>(NodeVector {DeformableConvolutionV8}, ParameterVector {in, offset, filter, mask});
+            return std::make_shared<ov::Model>(NodeVector {DeformableConvolutionV8}, ParameterVector {in, offset, filter, mask});
         } else {
             const auto DeformableConvolutionV8 = std::make_shared<op::v8::DeformableConvolution>(in,
                                                                         offset,
@@ -224,7 +224,7 @@ private:
                                                                         params.group,
                                                                         params.deformableGroup,
                                                                         params.use_bilinear_interpolation_padding);
-            return std::make_shared<ov::Function>(NodeVector {DeformableConvolutionV8}, ParameterVector {in, offset, filter});
+            return std::make_shared<ov::Model>(NodeVector {DeformableConvolutionV8}, ParameterVector {in, offset, filter});
         }
     }
 };
@@ -5795,4 +5795,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_DeformableConvolution_With_Hardcoded_Refs, Refere
 INSTANTIATE_TEST_SUITE_P(smoke_DeformableConvolutionV8_With_Hardcoded_Refs, ReferenceDeformableConvolutionV8LayerTest,
     testing::ValuesIn(generateDeformableConvolutionV8CombinedParams()), ReferenceDeformableConvolutionV8LayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/deformable_psroi_pooling.cpp

@@ -153,7 +153,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const DeformablePSROIPoolingParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const DeformablePSROIPoolingParams& params) {
         const auto input = std::make_shared<op::v0::Parameter>(params.inputType, params.inputShape);
         const auto rois = std::make_shared<op::v0::Parameter>(params.roisType, params.roisShape);
         if (params.offsetsShape.size() != 0) {
@@ -169,7 +169,7 @@ private:
                                                                             params.spatialBinsY,
                                                                             params.transStd,
                                                                             params.partSize);
-            return std::make_shared<ov::Function>(NodeVector {DeformablePSROIPooling}, ParameterVector {input, rois, offsets});
+            return std::make_shared<ov::Model>(NodeVector {DeformablePSROIPooling}, ParameterVector {input, rois, offsets});
         } else {
             const auto DeformablePSROIPooling = std::make_shared<opset1::DeformablePSROIPooling>(input,
                                                                             rois,
@@ -181,7 +181,7 @@ private:
                                                                             params.spatialBinsY,
                                                                             params.transStd,
                                                                             params.partSize);
-            return std::make_shared<ov::Function>(NodeVector {DeformablePSROIPooling}, ParameterVector {input, rois});
+            return std::make_shared<ov::Model>(NodeVector {DeformablePSROIPooling}, ParameterVector {input, rois});
         }
     }
 };
@@ -351,4 +351,4 @@ std::vector<DeformablePSROIPoolingParams> generateDeformablePSROIPoolingCombined
 INSTANTIATE_TEST_SUITE_P(smoke_DeformablePSROIPooling_With_Hardcoded_Refs, ReferenceDeformablePSROIPoolingLayerTest,
     testing::ValuesIn(generateDeformablePSROIPoolingCombinedParams()), ReferenceDeformablePSROIPoolingLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/depth_to_space.cpp

@@ -49,12 +49,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const DepthToSpaceParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const DepthToSpaceParams& params) {
         opset1::DepthToSpace::DepthToSpaceMode mode = params.mode == "DEPTH_FIRST" ?
             opset1::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST : opset1::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST;
         const auto data = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto depthToSpace = std::make_shared<opset1::DepthToSpace>(data, mode, params.blockSize);
-        return std::make_shared<Function>(NodeVector {depthToSpace}, ParameterVector {data});
+        return std::make_shared<Model>(NodeVector {depthToSpace}, ParameterVector {data});
     }
 };
 
@@ -154,4 +154,4 @@ std::vector<DepthToSpaceParams> generateDepthToSpaceCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_DepthToSpace_With_Hardcoded_Refs, ReferenceDepthToSpaceLayerTest,
     testing::ValuesIn(generateDepthToSpaceCombinedParams()), ReferenceDepthToSpaceLayerTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/detection_output.cpp

@@ -179,7 +179,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const DetectionOutputParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const DetectionOutputParams& params) {
         const auto loc = std::make_shared<op::v0::Parameter>(params.inType, params.locShape);
         const auto conf = std::make_shared<op::v0::Parameter>(params.inType, params.confShape);
         const auto priorBoxes = std::make_shared<op::v0::Parameter>(params.inType, params.priorBoxesShape);
@@ -187,10 +187,10 @@ private:
             const auto auxConf = std::make_shared<op::v0::Parameter>(params.inType, params.auxConfShape);
             const auto auxLoc = std::make_shared<op::v0::Parameter>(params.inType, params.auxLocShape);
             const auto DetectionOutput = std::make_shared<op::v0::DetectionOutput>(loc, conf, priorBoxes, auxConf, auxLoc, params.attrs);
-            return std::make_shared<ov::Function>(NodeVector {DetectionOutput}, ParameterVector {loc, conf, priorBoxes, auxConf, auxLoc});
+            return std::make_shared<ov::Model>(NodeVector {DetectionOutput}, ParameterVector {loc, conf, priorBoxes, auxConf, auxLoc});
         } else {
             const auto DetectionOutput = std::make_shared<op::v0::DetectionOutput>(loc, conf, priorBoxes, params.attrs);
-            return std::make_shared<ov::Function>(NodeVector {DetectionOutput}, ParameterVector {loc, conf, priorBoxes});
+            return std::make_shared<ov::Model>(NodeVector {DetectionOutput}, ParameterVector {loc, conf, priorBoxes});
         }
     }
 };
@@ -224,7 +224,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const DetectionOutputParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const DetectionOutputParams& params) {
         const auto loc = std::make_shared<op::v0::Parameter>(params.inType, params.locShape);
         const auto conf = std::make_shared<op::v0::Parameter>(params.inType, params.confShape);
         const auto priorBoxes = std::make_shared<op::v0::Parameter>(params.inType, params.priorBoxesShape);
@@ -233,11 +233,11 @@ private:
             const auto auxLoc = std::make_shared<op::v0::Parameter>(params.inType, params.auxLocShape);
             const auto DetectionOutput =
                 std::make_shared<op::v8::DetectionOutput>(loc, conf, priorBoxes, auxConf, auxLoc, params.attrs_v8);
-            return std::make_shared<ov::Function>(NodeVector{DetectionOutput},
+            return std::make_shared<ov::Model>(NodeVector{DetectionOutput},
                                                   ParameterVector{loc, conf, priorBoxes, auxConf, auxLoc});
         } else {
             const auto DetectionOutput = std::make_shared<op::v8::DetectionOutput>(loc, conf, priorBoxes, params.attrs_v8);
-            return std::make_shared<ov::Function>(NodeVector{DetectionOutput}, ParameterVector{loc, conf, priorBoxes});
+            return std::make_shared<ov::Model>(NodeVector{DetectionOutput}, ParameterVector{loc, conf, priorBoxes});
         }
     }
 };
@@ -574,4 +574,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_DetectionOutput_With_Hardcoded_Refs,
                          testing::ValuesIn(generateDetectionOutputCombinedParams()),
                          ReferenceDetectionOutputV8LayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/dft.cpp

@@ -71,18 +71,18 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(DFTParams& p) {
+    static std::shared_ptr<Model> CreateFunction(DFTParams& p) {
         auto in = std::make_shared<op::v0::Parameter>(p.m_input_type, p.m_input_shape);
         auto dft = std::make_shared<op::v7::DFT>(in, p.m_axes);
 
-        return std::make_shared<ov::Function>(dft, ParameterVector{in});
+        return std::make_shared<ov::Model>(dft, ParameterVector{in});
     }
 
-    static std::shared_ptr<Function> CreateFunctionWithSignal(DFTParams& p) {
+    static std::shared_ptr<Model> CreateFunctionWithSignal(DFTParams& p) {
         auto in = std::make_shared<op::v0::Parameter>(p.m_input_type, p.m_input_shape);
         auto dft = std::make_shared<op::v7::DFT>(in, p.m_axes, p.m_signal);
 
-        return std::make_shared<ov::Function>(dft, ParameterVector{in});
+        return std::make_shared<ov::Model>(dft, ParameterVector{in});
     }
 };
 
@@ -1408,4 +1408,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForDFT()),
     ReferenceDFTLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/divide.cpp

@@ -70,14 +70,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in1 = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto divide = std::make_shared<op::v1::Divide>(in1, in2);
-        return std::make_shared<Function>(NodeVector{divide}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{divide}, ParameterVector{in1, in2});
     }
 };
 
@@ -101,7 +101,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type,
@@ -109,7 +109,7 @@ private:
         const auto in1 = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto divide = std::make_shared<op::v1::Divide>(in1, in2, pythondiv);
-        return  std::make_shared<Function>(NodeVector{divide}, ParameterVector{in1, in2});
+        return  std::make_shared<Model>(NodeVector{divide}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/elu.cpp

@@ -50,11 +50,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type, const double alpha) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Elu = std::make_shared<op::v0::Elu>(in, alpha);
-        return std::make_shared<ov::Function>(NodeVector {Elu}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Elu}, ParameterVector {in});
     }
 };
 
@@ -143,4 +143,4 @@ std::vector<EluParams> generateEluCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_Elu_With_Hardcoded_Refs, ReferenceEluLayerTest,
     testing::ValuesIn(generateEluCombinedParams()), ReferenceEluLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/embedding_segments_sum.cpp

@@ -9,7 +9,7 @@
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
+using namespace ov;
 using namespace InferenceEngine;
 
 struct EmbeddingSegmentsSumParams {
@@ -79,7 +79,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(
+    static std::shared_ptr<Model> CreateFunction(
         const PartialShape& input_shape,
         const element::Type& input_type,
         const std::shared_ptr<ngraph::opset1::Constant> indices,
@@ -87,7 +87,7 @@ private:
         const std::shared_ptr<ngraph::opset1::Constant> num_segments,
         const std::shared_ptr<ngraph::opset1::Constant> default_index,
         const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
 
         if (default_index) {
             if (per_sample_weights) {
@@ -97,18 +97,18 @@ private:
                                                                                 num_segments,
                                                                                 default_index,
                                                                                 per_sample_weights);
-                return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+                return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
             } else {
                 const auto ess = std::make_shared<op::v3::EmbeddingSegmentsSum>(in,
                                                                                 indices,
                                                                                 segment_ids,
                                                                                 num_segments,
                                                                                 default_index);
-                return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+                return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
             }
         } else {
             const auto ess = std::make_shared<op::v3::EmbeddingSegmentsSum>(in, indices, segment_ids, num_segments);
-            return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+            return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
         }
     }
 };

docs/template_plugin/tests/functional/op_reference/embeddingbag_offsetssum.cpp

@@ -9,7 +9,7 @@
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
+using namespace ov;
 using namespace InferenceEngine;
 
 struct EmbeddingBagOffsetsSumParams {
@@ -74,14 +74,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(
+    static std::shared_ptr<ov::Model> CreateFunction(
         const PartialShape& input_shape,
         const element::Type& input_type,
         const std::shared_ptr<ngraph::opset1::Constant> indices,
         const std::shared_ptr<ngraph::opset1::Constant> offsets,
         const std::shared_ptr<ngraph::opset1::Constant> default_index,
         const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
 
         if (default_index) {
             if (per_sample_weights) {
@@ -90,14 +90,14 @@ private:
                                                                                   offsets,
                                                                                   default_index,
                                                                                   per_sample_weights);
-                return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+                return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
             } else {
                 const auto ess = std::make_shared<op::v3::EmbeddingBagOffsetsSum>(in, indices, offsets, default_index);
-                return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+                return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
             }
         } else {
             const auto ess = std::make_shared<op::v3::EmbeddingBagOffsetsSum>(in, indices, offsets);
-            return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+            return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
         }
     }
 };

docs/template_plugin/tests/functional/op_reference/embeddingbag_packedsum.cpp

@@ -9,7 +9,7 @@
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
+using namespace ov;
 using namespace InferenceEngine;
 
 struct EmbeddingBagPackedSumParams {
@@ -63,19 +63,19 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(
+    static std::shared_ptr<Model> CreateFunction(
         const PartialShape& input_shape,
         const element::Type& input_type,
         const std::shared_ptr<ngraph::opset1::Constant> indices,
         const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
 
         if (per_sample_weights) {
             const auto ess = std::make_shared<op::v3::EmbeddingBagPackedSum>(in, indices, per_sample_weights);
-            return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+            return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
         } else {
             const auto ess = std::make_shared<op::v3::EmbeddingBagPackedSum>(in, indices);
-            return std::make_shared<Function>(NodeVector{ess}, ParameterVector{in});
+            return std::make_shared<Model>(NodeVector{ess}, ParameterVector{in});
         }
     }
 };

docs/template_plugin/tests/functional/op_reference/erf.cpp

@@ -60,11 +60,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto erf = std::make_shared<op::v0::Erf>(in);
-        return std::make_shared<ov::Function>(NodeVector {erf}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {erf}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/exp.cpp

@@ -49,11 +49,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Exp = std::make_shared<op::v0::Exp>(in);
-        return std::make_shared<ov::Function>(NodeVector {Exp}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Exp}, ParameterVector {in});
     }
 };
 
@@ -75,12 +75,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Exp = std::make_shared<op::v0::Exp>(in);
         const auto ExpInPlace = std::make_shared<op::v0::Exp>(Exp);
-        return std::make_shared<ov::Function>(NodeVector {ExpInPlace}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {ExpInPlace}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/experimental_detectron_detection_output.cpp

@@ -79,7 +79,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ExperimentalDOParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const ExperimentalDOParams& params) {
         const auto rois = std::make_shared<op::v0::Parameter>(params.inType, params.roisShape);
         const auto deltas = std::make_shared<op::v0::Parameter>(params.inType, params.deltasShape);
         const auto scores = std::make_shared<op::v0::Parameter>(params.inType, params.scoresShape);
@@ -89,7 +89,7 @@ private:
                                                                     scores,
                                                                     im_info,
                                                                     params.attrs);
-        return std::make_shared<ov::Function>(ExperimentalDO->outputs(), ParameterVector {rois, deltas, scores, im_info});
+        return std::make_shared<ov::Model>(ExperimentalDO->outputs(), ParameterVector {rois, deltas, scores, im_info});
     }
 };
 
@@ -173,4 +173,4 @@ std::vector<ExperimentalDOParams> generateExperimentalDOCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_ExperimentalDetectronDetectionOutput_With_Hardcoded_Refs, ReferenceExperimentalDOLayerTest,
     testing::ValuesIn(generateExperimentalDOCombinedParams()), ReferenceExperimentalDOLayerTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/experimental_detectron_detection_prior_grid.cpp

@@ -93,7 +93,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ExperimentalPGGParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const ExperimentalPGGParams& params) {
         const auto priors = std::make_shared<op::v0::Parameter>(params.inType, params.priorsShape);
         const auto featureMap = std::make_shared<op::v0::Parameter>(params.inType, params.featureMapShape);
         const auto im_info = std::make_shared<op::v0::Parameter>(params.inType, params.imageSizeInfoShape);
@@ -101,7 +101,7 @@ private:
                                                                     featureMap,
                                                                     im_info,
                                                                     params.attrs);
-        return std::make_shared<ov::Function>(NodeVector {ExperimentalPGG}, ParameterVector {priors, featureMap, im_info});
+        return std::make_shared<ov::Model>(NodeVector {ExperimentalPGG}, ParameterVector {priors, featureMap, im_info});
     }
 };
 
@@ -223,4 +223,4 @@ std::vector<ExperimentalPGGParams> generateExperimentalPGGCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_ExperimentalDetectronPriorGridGenerator_With_Hardcoded_Refs, ReferenceExperimentalPGGLayerTest,
     testing::ValuesIn(generateExperimentalPGGCombinedParams()), ReferenceExperimentalPGGLayerTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/experimental_detectron_generate_proposals.cpp

@@ -77,7 +77,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ExperimentalGPParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const ExperimentalGPParams& params) {
         const auto im_info = std::make_shared<op::v0::Parameter>(params.inType, params.imageSizeInfoShape);
         const auto anchors = std::make_shared<op::v0::Parameter>(params.inType, params.anchorsShape);
         const auto deltas = std::make_shared<op::v0::Parameter>(params.inType, params.deltasShape);
@@ -87,7 +87,7 @@ private:
                                                                     deltas,
                                                                     scores,
                                                                     params.attrs);
-        return std::make_shared<ov::Function>(ExperimentalGP->outputs(), ParameterVector {im_info, anchors, deltas, scores});
+        return std::make_shared<ov::Model>(ExperimentalGP->outputs(), ParameterVector {im_info, anchors, deltas, scores});
     }
 };
 
@@ -207,4 +207,4 @@ std::vector<ExperimentalGPParams> generateExperimentalGPCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_ExperimentalDetectronGenerateProposalsSingleImage_With_Hardcoded_Refs, ReferenceExperimentalGPLayerTest,
     testing::ValuesIn(generateExperimentalGPCombinedParams()), ReferenceExperimentalGPLayerTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp

@@ -44,7 +44,7 @@ public:
     }
 
 private:
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& inputs) {
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& inputs) {
         op::v6::ExperimentalDetectronROIFeatureExtractor::Attributes attrs;
         attrs.aligned = false;
         attrs.output_size = 3;
@@ -62,7 +62,7 @@ private:
         }
 
         auto roi = std::make_shared<op::v6::ExperimentalDetectronROIFeatureExtractor>(node_vector, attrs);
-        auto fun = std::make_shared<ov::Function>(OutputVector{roi->output(0), roi->output(1)}, parameter_vector);
+        auto fun = std::make_shared<ov::Model>(OutputVector{roi->output(0), roi->output(1)}, parameter_vector);
         return fun;
     }
 };

docs/template_plugin/tests/functional/op_reference/experimental_detectron_topkrois.cpp

@@ -53,12 +53,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const ExperimentalDetectronTopKROIsParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const ExperimentalDetectronTopKROIsParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto probs = std::make_shared<op::v0::Parameter>(params.probsTensor.type, params.probsTensor.shape);
         const auto topkRois = std::make_shared<op::v6::ExperimentalDetectronTopKROIs>(data, probs, params.numRois);
-        function = std::make_shared<ov::Function>(topkRois, ParameterVector{data, probs});
+        function = std::make_shared<ov::Model>(topkRois, ParameterVector{data, probs});
         return function;
     }
 };
@@ -105,4 +105,4 @@ std::vector<ExperimentalDetectronTopKROIsParams> generateCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_ExperimentalDetectronTopKROIs_With_Hardcoded_Refs, ReferenceExperimentalDetectronTopKROIsTest,
     testing::ValuesIn(generateCombinedParams()), ReferenceExperimentalDetectronTopKROIsTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/fake_quantize.cpp

@@ -89,7 +89,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const Shape& expected_shape,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_type,
@@ -101,12 +101,12 @@ private:
                                                     const op::AutoBroadcastSpec& broadcast) {
         auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         if (broadcast == op::AutoBroadcastType::NONE) {
-            return std::make_shared<Function>(
+            return std::make_shared<Model>(
                 NodeVector{std::make_shared<op::v0::FakeQuantize>(in, input_low, input_high, output_low, output_high, levels)},
                 ParameterVector{in});
 
         } else {
-            return std::make_shared<Function>(
+            return std::make_shared<Model>(
                 NodeVector{std::make_shared<op::v0::FakeQuantize>(in, input_low, input_high, output_low, output_high, levels, broadcast)},
                 ParameterVector{in});
         }
@@ -224,4 +224,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForFakeQuantize()),
     ReferenceFakeQuantizeLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/floor.cpp

@@ -49,12 +49,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto floor = std::make_shared<op::v0::Floor>(in);
-        return std::make_shared<Function>(NodeVector{floor}, ParameterVector{in});
+        return std::make_shared<Model>(NodeVector{floor}, ParameterVector{in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/floor_mod.cpp

@@ -56,7 +56,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -64,7 +64,7 @@ private:
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto floormod = std::make_shared<op::v1::FloorMod>(in1, in2);
 
-        return std::make_shared<Function>(NodeVector{floormod}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{floormod}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/gather.cpp

@@ -56,13 +56,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GatherParams& params) {
         const auto P = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto I = std::make_shared<opset1::Parameter>(params.indicesTensor.type, params.indicesTensor.shape);
         const auto A = opset1::Constant::create(params.axisTensor.type, params.axisTensor.shape,
                                                 params.axisTensor.data.data());
         const auto G = std::make_shared<opset1::Gather>(P, I, A);
-        const auto f = std::make_shared<Function>(G, ParameterVector{P, I});
+        const auto f = std::make_shared<Model>(G, ParameterVector{P, I});
         return f;
     }
 };
@@ -116,13 +116,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherParamsV7& params) {
+    static std::shared_ptr<Model> CreateFunction(const GatherParamsV7& params) {
         const auto P = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto I = std::make_shared<opset1::Parameter>(params.indicesTensor.type, params.indicesTensor.shape);
         const auto A = opset1::Constant::create(params.axisTensor.type, params.axisTensor.shape,
                                                 params.axisTensor.data.data());
         const auto G = std::make_shared<opset7::Gather>(P, I, A, params.batchDims);
-        const auto f = std::make_shared<Function>(G, ParameterVector{P, I});
+        const auto f = std::make_shared<Model>(G, ParameterVector{P, I});
         return f;
     }
 };
@@ -133,13 +133,13 @@ TEST_P(ReferenceGatherTestV7, CompareWithRefs) {
 
 class ReferenceGatherTestV8 : public ReferenceGatherTestV7 {
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherParamsV7& params) {
+    static std::shared_ptr<Model> CreateFunction(const GatherParamsV7& params) {
         const auto P = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto I = std::make_shared<opset1::Parameter>(params.indicesTensor.type, params.indicesTensor.shape);
         const auto A = opset1::Constant::create(params.axisTensor.type, params.axisTensor.shape,
                                                 params.axisTensor.data.data());
         const auto G = std::make_shared<opset8::Gather>(P, I, A, params.batchDims);
-        const auto f = std::make_shared<Function>(G, ParameterVector{P, I});
+        const auto f = std::make_shared<Model>(G, ParameterVector{P, I});
         return f;
     }
 };
@@ -955,4 +955,4 @@ std::vector<GatherParamsV7> generateCombinedParamsV8() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_Gather_With_Hardcoded_Refs, ReferenceGatherTestV8,
     testing::ValuesIn(generateCombinedParamsV8()), ReferenceGatherTestV8::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/gather_elements.cpp

@@ -53,14 +53,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherElementsParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const GatherElementsParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type,
                                                               PartialShape{params.dataTensor.shape});
         const auto indices = std::make_shared<op::v0::Parameter>(params.indicesTensor.type,
                                                                  PartialShape{params.indicesTensor.shape});
         const auto gatherElement = std::make_shared<op::v6::GatherElements>(data, indices, params.axis);
-        function = std::make_shared<ov::Function>(NodeVector {gatherElement}, ParameterVector {data, indices});
+        function = std::make_shared<ov::Model>(NodeVector {gatherElement}, ParameterVector {data, indices});
         return function;
     }
 };
@@ -222,4 +222,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_With_Hardcoded_Refs, ReferenceGath
 
 INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_With_Hardcoded_Refs, ReferenceGatherElementsTestNegative,
     testing::ValuesIn(generateParamsNegative()), ReferenceGatherElementsTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/gather_nd.cpp

@@ -53,8 +53,8 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherNDParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const GatherNDParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type,
                                                               PartialShape{params.dataTensor.shape});
         const auto indices = std::make_shared<op::v0::Parameter>(params.indicesTensor.type,
@@ -65,7 +65,7 @@ private:
         } else {
             gatherND = std::make_shared<op::v5::GatherND>(data, indices, params.batchDims);
         }
-        function = std::make_shared<ov::Function>(NodeVector {gatherND}, ParameterVector {data, indices});
+        function = std::make_shared<ov::Model>(NodeVector {gatherND}, ParameterVector {data, indices});
         return function;
     }
 };
@@ -235,8 +235,8 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherNDParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const GatherNDParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type,
                                                               PartialShape{params.dataTensor.shape});
         const auto indices = std::make_shared<op::v0::Parameter>(params.indicesTensor.type,
@@ -247,7 +247,7 @@ private:
         } else {
             gatherND = std::make_shared<op::v8::GatherND>(data, indices, params.batchDims);
         }
-        function = std::make_shared<ov::Function>(NodeVector {gatherND}, ParameterVector {data, indices});
+        function = std::make_shared<ov::Model>(NodeVector {gatherND}, ParameterVector {data, indices});
         return function;
     }
 };

docs/template_plugin/tests/functional/op_reference/gather_tree.cpp

@@ -61,13 +61,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GatherTreeParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GatherTreeParams& params) {
         const auto step_ids = std::make_shared<opset1::Parameter>(params.stepIds.type, params.stepIds.shape);
         const auto parent_idx = std::make_shared<opset1::Parameter>(params.parentIdx.type, params.parentIdx.shape);
         const auto max_seq_len = std::make_shared<opset1::Parameter>(params.maxSeqLen.type, params.maxSeqLen.shape);
         const auto end_token = std::make_shared<opset1::Parameter>(params.endToken.type, params.endToken.shape);
         const auto gather_tree = std::make_shared<opset1::GatherTree>(step_ids, parent_idx, max_seq_len, end_token);
-        const auto f = std::make_shared<Function>(gather_tree, ParameterVector{step_ids, parent_idx, max_seq_len, end_token});
+        const auto f = std::make_shared<Model>(gather_tree, ParameterVector{step_ids, parent_idx, max_seq_len, end_token});
         return f;
     }
 };
@@ -170,4 +170,4 @@ std::vector<GatherTreeParams> generateCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_GatherTree_With_Hardcoded_Refs, ReferenceGatherTreeTest,
     testing::ValuesIn(generateCombinedParams()), ReferenceGatherTreeTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/gelu.cpp

@@ -49,11 +49,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type, const op::GeluApproximationMode mode) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Gelu = std::make_shared<op::v0::Gelu>(in);
-        return std::make_shared<ov::Function>(NodeVector {Gelu}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Gelu}, ParameterVector {in});
     }
 };
 
@@ -76,11 +76,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type, const op::GeluApproximationMode mode) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Gelu = std::make_shared<op::v7::Gelu>(in, mode);
-        return std::make_shared<ov::Function>(NodeVector {Gelu}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Gelu}, ParameterVector {in});
     }
 };
 
@@ -171,4 +171,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Gelu_v2_With_Hardcoded_Refs, ReferenceGeluV0Layer
 INSTANTIATE_TEST_SUITE_P(smoke_Gelu_v7_With_Hardcoded_Refs, ReferenceGeluV7LayerTest,
     testing::ValuesIn(generateGeluV7CombinedParams()), ReferenceGeluV7LayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/grn.cpp

@@ -43,10 +43,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(float bias, const PartialShape& input_shape, const element::Type& input_type) {
+    static std::shared_ptr<Model> CreateFunction(float bias, const PartialShape& input_shape, const element::Type& input_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto grn = std::make_shared<op::v0::GRN>(in, bias);
-        return std::make_shared<ov::Function>(NodeVector {grn}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {grn}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/group_convolution.cpp

@@ -70,7 +70,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GroupConvolutionParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GroupConvolutionParams& params) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -82,7 +82,7 @@ private:
                                                                        params.padEnd,
                                                                        params.dialations,
                                                                        auto_pad);
-        return std::make_shared<ov::Function>(NodeVector {GroupConvolution}, ParameterVector {in, filter});
+        return std::make_shared<ov::Model>(NodeVector {GroupConvolution}, ParameterVector {in, filter});
     }
 };
 
@@ -249,4 +249,4 @@ std::vector<GroupConvolutionParams> generateGroupConvolutionCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_GroupConvolution_With_Hardcoded_Refs, ReferenceGroupConvolutionLayerTest,
     testing::ValuesIn(generateGroupConvolutionCombinedParams()), ReferenceGroupConvolutionLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/group_convolution_backprop.cpp

@@ -112,7 +112,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GroupConvolutionBackpropDataParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GroupConvolutionBackpropDataParams& params) {
         const op::PadType auto_pad{op::PadType::EXPLICIT};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -126,7 +126,7 @@ private:
                                                                         params.dialations,
                                                                         auto_pad,
                                                                         params.outPadding);
-            return std::make_shared<ov::Function>(NodeVector {GroupConvolutionBackpropData}, ParameterVector {in, filter});
+            return std::make_shared<ov::Model>(NodeVector {GroupConvolutionBackpropData}, ParameterVector {in, filter});
         } else {
             const auto GroupConvolutionBackpropData = std::make_shared<op::v1::GroupConvolutionBackpropData>(in,
                                                                         filter,
@@ -135,7 +135,7 @@ private:
                                                                         params.padEnd,
                                                                         params.dialations,
                                                                         auto_pad);
-            return std::make_shared<ov::Function>(NodeVector {GroupConvolutionBackpropData}, ParameterVector {in, filter});
+            return std::make_shared<ov::Model>(NodeVector {GroupConvolutionBackpropData}, ParameterVector {in, filter});
         }
     }
 };
@@ -164,7 +164,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GroupConvolutionBackpropDataOutShapeParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GroupConvolutionBackpropDataOutShapeParams& params) {
         const op::PadType auto_pad{op::PadType::SAME_UPPER};
 
         const auto in = std::make_shared<op::v0::Parameter>(params.inType, params.inputShape);
@@ -176,7 +176,7 @@ private:
                                                                     params.strides,
                                                                     params.dialations,
                                                                     auto_pad);
-        return std::make_shared<ov::Function>(NodeVector {GroupConvolutionBackpropData}, ParameterVector {in, filter});
+        return std::make_shared<ov::Model>(NodeVector {GroupConvolutionBackpropData}, ParameterVector {in, filter});
     }
 };
 
@@ -495,4 +495,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_GroupConvolutionBackpropData_With_Hardcoded_Refs,
 INSTANTIATE_TEST_SUITE_P(smoke_GroupConvolutionBackpropDataOutShape_With_Hardcoded_Refs, ReferenceGroupConvolutionBackpropDataLayerOutShapeTest,
     testing::ValuesIn(generateGroupConvolutionBackpropDataOutShapeCombinedParams()), ReferenceGroupConvolutionBackpropDataLayerOutShapeTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/gru_cell.cpp

@@ -69,7 +69,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GRUCellParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GRUCellParams& params) {
         float clip = 2.88f;
 
         const auto X = std::make_shared<op::v0::Parameter>(params.X.type, params.X.shape);
@@ -90,7 +90,7 @@ private:
                                                                 clip,
                                                                 params.linearBeforeReset);
 
-        auto function = std::make_shared<Function>(NodeVector{gru_cell}, ParameterVector{X, H_t, W, R, B});
+        auto function = std::make_shared<Model>(NodeVector{gru_cell}, ParameterVector{X, H_t, W, R, B});
         return function;
     }
 };
@@ -107,7 +107,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const GRUCellParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const GRUCellParams& params) {
         float clip = 2.88f;
 
         const auto X = std::make_shared<op::v0::Parameter>(params.X.type, params.X.shape);
@@ -128,7 +128,7 @@ private:
                                                                 clip,
                                                                 params.linearBeforeReset);
 
-        auto function = std::make_shared<Function>(NodeVector{gru_cell}, ParameterVector{X, H_t, W, R, B});
+        auto function = std::make_shared<Model>(NodeVector{gru_cell}, ParameterVector{X, H_t, W, R, B});
         return function;
     }
 };
@@ -291,4 +291,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_GRUCell_With_Hardcoded_Refs, ReferenceGRUCellTest
 
 INSTANTIATE_TEST_SUITE_P(smoke_GRUCell_With_Hardcoded_Refs, ReferenceGRUCellTestHardsigmoidActivationFunction,
     testing::ValuesIn(generateCombinedParamsHardsigmoidActivationFunction()), ReferenceGRUCellTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/hard_sigmoid.cpp

@@ -53,7 +53,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type, const float alphaData, const float betaData) {
         std::vector<float> alphaArray;
         std::vector<float> betaArray;
@@ -63,7 +63,7 @@ private:
         const auto alpha = ngraph::op::Constant::create(input_type, Shape{}, {alphaData});
         const auto beta = ngraph::op::Constant::create(input_type, Shape{}, {betaData});
         const auto HardSigmoid = std::make_shared<op::v0::HardSigmoid>(in, alpha, beta);
-        return std::make_shared<ov::Function>(NodeVector {HardSigmoid}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {HardSigmoid}, ParameterVector {in});
     }
 };
 
@@ -108,4 +108,4 @@ std::vector<HardSigmoidParams> generateHardSigmoidCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_HardSigmoid_With_Hardcoded_Refs, ReferenceHardSigmoidLayerTest,
     testing::ValuesIn(generateHardSigmoidCombinedParams()), ReferenceHardSigmoidLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/hsigmoid.cpp

@@ -45,11 +45,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& HSigmoidected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto HSigmoid = std::make_shared<op::v5::HSigmoid>(in);
-        return std::make_shared<ov::Function>(NodeVector {HSigmoid}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {HSigmoid}, ParameterVector {in});
     }
 };
 
@@ -87,4 +87,4 @@ std::vector<HSigmoidParams> generateHSigmoidCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_HSigmoid_With_Hardcoded_Refs, ReferenceHSigmoidLayerTest,
     testing::ValuesIn(generateHSigmoidCombinedParams()), ReferenceHSigmoidLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/hswish.cpp

@@ -46,11 +46,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& HSwishected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto HSwish = std::make_shared<op::v4::HSwish>(in);
-        return std::make_shared<ov::Function>(NodeVector {HSwish}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {HSwish}, ParameterVector {in});
     }
 };
 
@@ -92,4 +92,4 @@ std::vector<HSwishParams> generateHSwishCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_HSwish_With_Hardcoded_Refs, ReferenceHSwishLayerTest,
     testing::ValuesIn(generateHSwishCombinedParams()), ReferenceHSwishLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/idft.cpp

@@ -71,18 +71,18 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(IDFTParams& p) {
+    static std::shared_ptr<Model> CreateFunction(IDFTParams& p) {
         auto in = std::make_shared<op::v0::Parameter>(p.m_input_type, p.m_input_shape);
         auto idft = std::make_shared<op::v7::IDFT>(in, p.m_axes);
 
-        return std::make_shared<ov::Function>(idft, ParameterVector{in});
+        return std::make_shared<ov::Model>(idft, ParameterVector{in});
     }
 
-    static std::shared_ptr<Function> CreateFunctionWithSignal(IDFTParams& p) {
+    static std::shared_ptr<Model> CreateFunctionWithSignal(IDFTParams& p) {
         auto in = std::make_shared<op::v0::Parameter>(p.m_input_type, p.m_input_shape);
         auto idft = std::make_shared<op::v7::IDFT>(in, p.m_axes, p.m_signal);
 
-        return std::make_shared<ov::Function>(idft, ParameterVector{in});
+        return std::make_shared<ov::Model>(idft, ParameterVector{in});
     }
 };
 
@@ -1399,4 +1399,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForIDFT()),
     ReferenceIDFTLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/if.cpp

@@ -14,40 +14,40 @@
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
+using namespace ov;
 using namespace InferenceEngine;
 
 struct IfFunctionalBase {
-    virtual std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    virtual std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                                       const std::vector<Tensor>& results) = 0;
     IfFunctionalBase() {}
 };
 
 struct IfCondConst : public IfFunctionalBase {
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                               const std::vector<Tensor>& results) override {
         NGRAPH_CHECK(if_inputs.size() == 2, "Incorrect test case! Number of inputs is not 2.");
         NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
-        auto X = std::make_shared<op::Parameter>(if_inputs[0].type, if_inputs[0].shape);
-        auto Y = std::make_shared<op::Parameter>(if_inputs[1].type, if_inputs[1].shape);
-        auto cond = std::make_shared<op::Constant>(ngraph::element::boolean, Shape{1}, cond_value);
-        auto Xt = std::make_shared<op::Parameter>(if_inputs[0].type, PartialShape::dynamic());
-        auto Yt = std::make_shared<op::Parameter>(if_inputs[1].type, PartialShape::dynamic());
-        auto Xe = std::make_shared<op::Parameter>(if_inputs[0].type, PartialShape::dynamic());
+        auto X = std::make_shared<op::v0::Parameter>(if_inputs[0].type, if_inputs[0].shape);
+        auto Y = std::make_shared<op::v0::Parameter>(if_inputs[1].type, if_inputs[1].shape);
+        auto cond = std::make_shared<op::v0::Constant>(ngraph::element::boolean, Shape{1}, cond_value);
+        auto Xt = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic());
+        auto Yt = std::make_shared<op::v0::Parameter>(if_inputs[1].type, PartialShape::dynamic());
+        auto Xe = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic());
         auto then_op = std::make_shared<op::v1::Multiply>(Xt, Yt);
-        auto res0 = std::make_shared<op::Result>(then_op);
-        auto res1 = std::make_shared<op::Result>(Xe);
-        auto then_body = std::make_shared<ngraph::Function>(OutputVector{res0}, ParameterVector{Xt, Yt});
-        auto else_body = std::make_shared<ngraph::Function>(OutputVector{res1}, ParameterVector{Xe});
+        auto res0 = std::make_shared<op::v0::Result>(then_op);
+        auto res1 = std::make_shared<op::v0::Result>(Xe);
+        auto then_body = std::make_shared<ov::Model>(OutputVector{res0}, ParameterVector{Xt, Yt});
+        auto else_body = std::make_shared<ov::Model>(OutputVector{res1}, ParameterVector{Xe});
         auto if_op = std::make_shared<op::v8::If>(cond);
         if_op->set_then_body(then_body);
         if_op->set_else_body(else_body);
         if_op->set_input(X, Xt, Xe);
         if_op->set_input(Y, Yt, nullptr);
         auto result = if_op->set_output(res0, res1);
-        auto res = std::make_shared<op::Result>(result);
-        auto fun = std::make_shared<Function>(OutputVector{res}, ParameterVector{X, Y});
+        auto res = std::make_shared<op::v0::Result>(result);
+        auto fun = std::make_shared<Model>(OutputVector{res}, ParameterVector{X, Y});
         return fun;
     }
 
@@ -56,88 +56,88 @@ struct IfCondConst : public IfFunctionalBase {
 };
 
 struct IfCondIsNonConst : public IfFunctionalBase {
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                               const std::vector<Tensor>& results) override {
         NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
         NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
-        auto X = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto Y = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto cond = std::make_shared<op::Parameter>(element::boolean, Shape{1});
+        auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1});
         // Set up the cell body, a function from (Xi, Yi) -> (Zo)
         // Body parameters
-        auto Xt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Yt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Xe = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Ye = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Yt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xe = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Ye = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
         // Body
         auto then_op = std::make_shared<op::v1::Multiply>(Xt, Yt);
         auto else_op = std::make_shared<op::v1::Add>(Xe, Ye);
-        auto then_op_result = std::make_shared<op::Result>(then_op);
-        auto else_op_result = std::make_shared<op::Result>(else_op);
-        auto then_body = std::make_shared<ngraph::Function>(OutputVector{then_op_result}, ParameterVector{Xt, Yt});
-        auto else_body = std::make_shared<ngraph::Function>(OutputVector{else_op_result}, ParameterVector{Xe, Ye});
+        auto then_op_result = std::make_shared<op::v0::Result>(then_op);
+        auto else_op_result = std::make_shared<op::v0::Result>(else_op);
+        auto then_body = std::make_shared<ov::Model>(OutputVector{then_op_result}, ParameterVector{Xt, Yt});
+        auto else_body = std::make_shared<ov::Model>(OutputVector{else_op_result}, ParameterVector{Xe, Ye});
         auto if_op = std::make_shared<op::v8::If>(cond);
         if_op->set_then_body(then_body);
         if_op->set_else_body(else_body);
         if_op->set_input(X, Xt, Xe);
         if_op->set_input(Y, Yt, Ye);
         auto result = if_op->set_output(then_op_result, else_op_result);
-        auto res = std::make_shared<op::Result>(result);
-        auto fun = std::make_shared<Function>(OutputVector{res}, ParameterVector{cond, X, Y});
+        auto res = std::make_shared<op::v0::Result>(result);
+        auto fun = std::make_shared<Model>(OutputVector{res}, ParameterVector{cond, X, Y});
         return fun;
     }
 };
 
 struct IfWithoutAdditionalInputs : IfFunctionalBase {
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                               const std::vector<Tensor>& results) override {
         NGRAPH_CHECK(if_inputs.size() == 1, "Incorrect test case! Number of inputs is not 1.");
         NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
-        auto cond = std::make_shared<op::Parameter>(element::boolean, Shape{1});
-        auto A = std::make_shared<op::Constant>(element::f32, Shape{1}, 8.0);
-        auto B = std::make_shared<op::Constant>(element::f32, Shape{1}, 2.0);
-        auto A_res = std::make_shared<op::Result>(A);
-        auto B_res = std::make_shared<op::Result>(B);
-        auto then_body = std::make_shared<ngraph::Function>(OutputVector{A_res}, ParameterVector{});
-        auto else_body = std::make_shared<ngraph::Function>(OutputVector{B_res}, ParameterVector{});
+        auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1});
+        auto A = std::make_shared<op::v0::Constant>(element::f32, Shape{1}, 8.0);
+        auto B = std::make_shared<op::v0::Constant>(element::f32, Shape{1}, 2.0);
+        auto A_res = std::make_shared<op::v0::Result>(A);
+        auto B_res = std::make_shared<op::v0::Result>(B);
+        auto then_body = std::make_shared<ov::Model>(OutputVector{A_res}, ParameterVector{});
+        auto else_body = std::make_shared<ov::Model>(OutputVector{B_res}, ParameterVector{});
         auto if_op = std::make_shared<op::v8::If>(cond);
         if_op->set_then_body(then_body);
         if_op->set_else_body(else_body);
         auto res = if_op->set_output(A_res, B_res);
-        auto fun = std::make_shared<Function>(OutputVector{res}, ParameterVector{cond});
+        auto fun = std::make_shared<Model>(OutputVector{res}, ParameterVector{cond});
         return fun;
     }
 };
 
 struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase {
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                               const std::vector<Tensor>& results) override {
         NGRAPH_CHECK(if_inputs.size() == 4, "Incorrect test case! Number of inputs is not 4.");
         NGRAPH_CHECK(results.size() == 2, "Incorrect test case! Number of outputs is not 2.");
 
-        auto X = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto Y = std::make_shared<op::Parameter>(element::f32, Shape{4, 2, 2});
-        auto Z = std::make_shared<op::Parameter>(element::f32, Shape{8, 8, 8});
-        auto cond = std::make_shared<op::Parameter>(element::boolean, Shape{1});
+        auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{4, 2, 2});
+        auto Z = std::make_shared<op::v0::Parameter>(element::f32, Shape{8, 8, 8});
+        auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1});
         // Set up the cell body, a function from (Xi, Yi) -> (Zo)
         // Body parameters
-        auto Xt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Yt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Xe = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Ze = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Yt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xe = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Ze = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
         // Body
         auto then_op = std::make_shared<op::v1::Multiply>(Xt, Xt);
         auto else_op = std::make_shared<op::v1::Add>(Xe, Xe);
-        auto then_op_result1 = std::make_shared<op::Result>(then_op);
-        auto then_op_result2 = std::make_shared<op::Result>(Yt);
-        auto else_op_result1 = std::make_shared<op::Result>(else_op);
-        auto else_op_result2 = std::make_shared<op::Result>(Ze);
+        auto then_op_result1 = std::make_shared<op::v0::Result>(then_op);
+        auto then_op_result2 = std::make_shared<op::v0::Result>(Yt);
+        auto else_op_result1 = std::make_shared<op::v0::Result>(else_op);
+        auto else_op_result2 = std::make_shared<op::v0::Result>(Ze);
         auto then_body =
-            std::make_shared<ngraph::Function>(OutputVector{then_op_result1, then_op_result2}, ParameterVector{Xt, Yt});
+            std::make_shared<ov::Model>(OutputVector{then_op_result1, then_op_result2}, ParameterVector{Xt, Yt});
         auto else_body =
-            std::make_shared<ngraph::Function>(OutputVector{else_op_result1, else_op_result2}, ParameterVector{Xe, Ze});
+            std::make_shared<ov::Model>(OutputVector{else_op_result1, else_op_result2}, ParameterVector{Xe, Ze});
         auto if_op = std::make_shared<op::v8::If>(cond);
         if_op->set_then_body(then_body);
         if_op->set_else_body(else_body);
@@ -146,35 +146,35 @@ struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase {
         if_op->set_input(Z, nullptr, Ze);
         auto res1 = if_op->set_output(then_op_result1, else_op_result1);
         auto res2 = if_op->set_output(then_op_result2, else_op_result2);
-        auto result_if1 = std::make_shared<op::Result>(res1);
-        auto result_if2 = std::make_shared<op::Result>(res2);
-        auto fun = std::make_shared<Function>(OutputVector{result_if1, result_if2}, ParameterVector{cond, X, Y, Z});
+        auto result_if1 = std::make_shared<op::v0::Result>(res1);
+        auto result_if2 = std::make_shared<op::v0::Result>(res2);
+        auto fun = std::make_shared<Model>(OutputVector{result_if1, result_if2}, ParameterVector{cond, X, Y, Z});
         return fun;
     }
 };
 
 struct IfConditionIsScalar : public IfFunctionalBase {
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                               const std::vector<Tensor>& results) override {
         NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
         NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
-        auto X = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto Y = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto cond = std::make_shared<op::Parameter>(element::boolean, Shape{});
+        auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{});
         // Set up the cell body, a function from (Xi, Yi) -> (Zo)
         // Body parameters
-        auto Xt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Yt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Xe = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Ye = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Yt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xe = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Ye = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
         // Body
         auto then_op = std::make_shared<op::v1::Multiply>(Xt, Yt);
         auto else_op = std::make_shared<op::v1::Add>(Xe, Ye);
-        auto then_op_result = std::make_shared<op::Result>(then_op);
-        auto else_op_result = std::make_shared<op::Result>(else_op);
-        auto then_body = std::make_shared<ngraph::Function>(OutputVector{then_op_result}, ParameterVector{Xt, Yt});
-        auto else_body = std::make_shared<ngraph::Function>(OutputVector{else_op_result}, ParameterVector{Xe, Ye});
+        auto then_op_result = std::make_shared<op::v0::Result>(then_op);
+        auto else_op_result = std::make_shared<op::v0::Result>(else_op);
+        auto then_body = std::make_shared<ov::Model>(OutputVector{then_op_result}, ParameterVector{Xt, Yt});
+        auto else_body = std::make_shared<ov::Model>(OutputVector{else_op_result}, ParameterVector{Xe, Ye});
         auto if_op = std::make_shared<op::v8::If>(cond);
         if_op->set_then_body(then_body);
         if_op->set_else_body(else_body);
@@ -184,42 +184,42 @@ struct IfConditionIsScalar : public IfFunctionalBase {
         if_op->validate_and_infer_types();
         std::vector<float> X_v{1.0, 2.0, 3.0, 4.0};
         std::vector<float> Y_v{2.0, 1.0, 2.0, 3.0};
-        auto fun = std::make_shared<Function>(OutputVector{res}, ParameterVector{cond, X, Y});
+        auto fun = std::make_shared<ov::Model>(OutputVector{res}, ParameterVector{cond, X, Y});
         return fun;
     }
 };
 
 struct IfConditionIsDynamic : public IfFunctionalBase {
-    std::shared_ptr<Function> create_function(const std::vector<Tensor>& if_inputs,
+    std::shared_ptr<Model> create_function(const std::vector<Tensor>& if_inputs,
                                               const std::vector<Tensor>& results) override {
         NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
         NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
-        auto X = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto Y = std::make_shared<op::Parameter>(element::f32, Shape{1, 2, 2});
-        auto cond = std::make_shared<op::Parameter>(element::boolean, PartialShape{Dimension::dynamic()});
-        // auto cond = std::make_shared<op::Parameter>(element::boolean, Shape{1});
+        auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
+        auto cond = std::make_shared<op::v0::Parameter>(element::boolean, PartialShape{Dimension::dynamic()});
+        // auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1});
         // Set up the cell body, a function from (Xi, Yi) -> (Zo)
         // Body parameters
-        auto Xt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Yt = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Xe = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-        auto Ye = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Yt = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Xe = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
+        auto Ye = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
         // Body
         auto then_op = std::make_shared<op::v1::Multiply>(Xt, Yt);
         auto else_op = std::make_shared<op::v1::Add>(Xe, Ye);
-        auto then_op_result = std::make_shared<op::Result>(then_op);
-        auto else_op_result = std::make_shared<op::Result>(else_op);
-        auto then_body = std::make_shared<ngraph::Function>(OutputVector{then_op_result}, ParameterVector{Xt, Yt});
-        auto else_body = std::make_shared<ngraph::Function>(OutputVector{else_op_result}, ParameterVector{Xe, Ye});
+        auto then_op_result = std::make_shared<op::v0::Result>(then_op);
+        auto else_op_result = std::make_shared<op::v0::Result>(else_op);
+        auto then_body = std::make_shared<ov::Model>(OutputVector{then_op_result}, ParameterVector{Xt, Yt});
+        auto else_body = std::make_shared<ov::Model>(OutputVector{else_op_result}, ParameterVector{Xe, Ye});
         auto if_op = std::make_shared<op::v8::If>(cond);
         if_op->set_then_body(then_body);
         if_op->set_else_body(else_body);
         if_op->set_input(X, Xt, Xe);
         if_op->set_input(Y, Yt, Ye);
         auto rs = if_op->set_output(then_op_result, else_op_result);
-        auto result = std::make_shared<op::Result>(rs);
-        auto fun = std::make_shared<Function>(OutputVector{result}, ParameterVector{cond, X, Y});
+        auto result = std::make_shared<op::v0::Result>(rs);
+        auto fun = std::make_shared<Model>(OutputVector{result}, ParameterVector{cond, X, Y});
         return fun;
     }
 };
@@ -365,4 +365,4 @@ INSTANTIATE_TEST_SUITE_P(
                                 Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
                                 Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
             std::vector<Tensor>{Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
-            "if_condition_is_dynamic_cond_false")));
+            "if_condition_is_dynamic_cond_false")));

docs/template_plugin/tests/functional/op_reference/log.cpp

@@ -49,12 +49,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto log = std::make_shared<op::v0::Log>(in);
-        return std::make_shared<Function>(NodeVector{log}, ParameterVector{in});
+        return std::make_shared<Model>(NodeVector{log}, ParameterVector{in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/log_softmax.cpp

@@ -51,11 +51,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type, const int64_t axis) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto LogSoftmax = std::make_shared<op::v5::LogSoftmax>(in, axis);
-        return std::make_shared<ov::Function>(NodeVector {LogSoftmax}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {LogSoftmax}, ParameterVector {in});
     }
 };
 
@@ -245,4 +245,4 @@ std::vector<LogSoftmaxParams> generateLogSoftmaxCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_LogSoftmax_With_Hardcoded_Refs, ReferenceLogSoftmaxLayerTest,
     testing::ValuesIn(generateLogSoftmaxCombinedParams()), ReferenceLogSoftmaxLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/logical.hpp

@@ -48,14 +48,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<ov::Function> CreateFunction(ngraph::helpers::LogicalTypes op_type, const std::vector<Tensor>& inputs) {
+    static std::shared_ptr<ov::Model> CreateFunction(ngraph::helpers::LogicalTypes op_type, const std::vector<Tensor>& inputs) {
         ov::ParameterVector params_vec;
         for (auto& input : inputs) {
             params_vec.push_back(std::make_shared<op::v0::Parameter>(input.type, input.shape));
         }
 
         const auto logical_op = ngraph::builder::makeLogical(params_vec, op_type);
-        return std::make_shared<ov::Function>(ov::NodeVector {logical_op}, ov::ParameterVector {params_vec});
+        return std::make_shared<ov::Model>(ov::NodeVector {logical_op}, ov::ParameterVector {params_vec});
     }
 };
 }  // namespace LogicalOpsRefTestDefinitions

docs/template_plugin/tests/functional/op_reference/lrn.cpp

@@ -114,7 +114,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type_t& input_type,
                                                     const float& alpah,
                                                     const float& beta,
@@ -130,7 +130,7 @@ private:
             lrn = std::make_shared<op::v0::LRN>(in, alpah, beta, bias, size);
         }
 
-        return std::make_shared<ov::Function>(lrn, ParameterVector{in});
+        return std::make_shared<ov::Model>(lrn, ParameterVector{in});
     }
 };
 
@@ -352,4 +352,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForLRN()),
     ReferenceLRNLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/lstm_cell.cpp

@@ -73,7 +73,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const LSTMCellParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const LSTMCellParams& params) {
         const auto X = std::make_shared<op::v0::Parameter>(params.X.type, params.X.shape);
         const auto W = std::make_shared<op::v0::Parameter>(params.W.type, params.W.shape);
         const auto R = std::make_shared<op::v0::Parameter>(params.R.type, params.R.shape);
@@ -90,7 +90,7 @@ private:
                                                op::util::convert_lstm_node_format(B, op::util::LSTMWeightsFormat::IOFC),
                                                params.hiddenSize);
 
-        auto function = std::make_shared<Function>(lstm_cell->outputs(), ParameterVector{X, H_t, C_t, W, R, B});
+        auto function = std::make_shared<Model>(lstm_cell->outputs(), ParameterVector{X, H_t, C_t, W, R, B});
         return function;
     }
 };
@@ -106,7 +106,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const LSTMCellParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const LSTMCellParams& params) {
         const auto X = std::make_shared<op::v0::Parameter>(params.X.type, params.X.shape);
         const auto W = std::make_shared<op::v0::Parameter>(params.W.type, params.W.shape);
         const auto R = std::make_shared<op::v0::Parameter>(params.R.type, params.R.shape);
@@ -123,7 +123,7 @@ private:
                                                op::util::convert_lstm_node_format(B, op::util::LSTMWeightsFormat::IOFC),
                                                params.hiddenSize);
 
-        auto function = std::make_shared<Function>(lstm_cell->outputs(), ParameterVector{X, H_t, C_t, W, R, B});
+        auto function = std::make_shared<Model>(lstm_cell->outputs(), ParameterVector{X, H_t, C_t, W, R, B});
         return function;
     }
 };
@@ -139,7 +139,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const LSTMCellParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const LSTMCellParams& params) {
         const float clip_threshold = 3.5f;
 
         const auto X = std::make_shared<op::v0::Parameter>(params.X.type, params.X.shape);
@@ -162,7 +162,7 @@ private:
                                                std::vector<float>{},
                                                clip_threshold);
 
-        auto function = std::make_shared<Function>(lstm_cell->outputs(), ParameterVector{X, H_t, C_t, W, R, B});
+        auto function = std::make_shared<Model>(lstm_cell->outputs(), ParameterVector{X, H_t, C_t, W, R, B});
         return function;
     }
 };
@@ -376,4 +376,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_LSTMCell_With_Hardcoded_Refs, ReferenceLSTMCellTe
 
 INSTANTIATE_TEST_SUITE_P(smoke_LSTMCell_With_Hardcoded_Refs, ReferenceLSTMCellTestBiasClip,
     testing::ValuesIn(generateCombinedParamsBiasClip()), ReferenceLSTMCellTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/matmul.cpp

@@ -118,20 +118,20 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunctionWithParam(MatMulParams& p) {
+    static std::shared_ptr<Model> CreateFunctionWithParam(MatMulParams& p) {
         auto in1 = std::make_shared<op::v0::Parameter>(p.m_input_type1, p.m_input_shape1);
         auto in2 = std::make_shared<op::v0::Parameter>(p.m_input_type2, p.m_input_shape2);
         auto matmul = std::make_shared<op::v0::MatMul>(in1, in2, p.m_transpose1, p.m_transpose2);
 
-        return std::make_shared<ov::Function>(matmul, ParameterVector{in1, in2});
+        return std::make_shared<ov::Model>(matmul, ParameterVector{in1, in2});
     }
 
-    static std::shared_ptr<Function> CreateFunctionWithConst(MatMulParams& p) {
+    static std::shared_ptr<Model> CreateFunctionWithConst(MatMulParams& p) {
         auto in1 = std::make_shared<op::v0::Parameter>(p.m_input_type1, p.m_input_shape1);
         auto in2 = std::make_shared<op::v0::Constant>(p.m_input_type2, p.m_input_shape2, p.m_input_value2.data());
         auto matmul = std::make_shared<op::v0::MatMul>(in1, in2, p.m_transpose1, p.m_transpose2);
 
-        return std::make_shared<ov::Function>(matmul, ParameterVector{in1});
+        return std::make_shared<ov::Model>(matmul, ParameterVector{in1});
     }
 };
 
@@ -635,4 +635,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_MatMul_With_Hardcoded_Refs,
                          ::testing::ValuesIn(generateCombinedParamsForMatMul()),
                          ReferenceMatMulLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/matrix_nms.cpp

@@ -65,11 +65,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const MatrixNmsParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const MatrixNmsParams& params) {
         const auto boxes = std::make_shared<opset1::Parameter>(params.boxes.type, PartialShape::dynamic());
         const auto scores = std::make_shared<opset1::Parameter>(params.scores.type, PartialShape::dynamic());
         const auto nms = std::make_shared<opset8::MatrixNms>(boxes, scores, params.attrs);
-        const auto f = std::make_shared<Function>(nms->outputs(), ParameterVector{boxes, scores});
+        const auto f = std::make_shared<Model>(nms->outputs(), ParameterVector{boxes, scores});
         return f;
     }
 };
@@ -478,4 +478,4 @@ std::vector<MatrixNmsParams> generateCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_MatrixNms_With_Hardcoded_Refs, ReferenceMatrixNmsTest,
     testing::ValuesIn(generateCombinedParams()), ReferenceMatrixNmsTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/max_pool.cpp

@@ -79,7 +79,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const MaxPoolParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const MaxPoolParams& params) {
         const auto in = std::make_shared<op::v0::Parameter>(params.m_input_type, params.m_input_shape);
         const auto max_pool = std::make_shared<op::v8::MaxPool>(in,
                                                                 params.m_strides,
@@ -91,7 +91,7 @@ private:
                                                                 params.m_pad_type,
                                                                 params.m_indices_type,
                                                                 params.m_axis);
-        return std::make_shared<ov::Function>(max_pool, ParameterVector{in});
+        return std::make_shared<ov::Model>(max_pool, ParameterVector{in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/maximum.cpp

@@ -56,7 +56,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -64,7 +64,7 @@ private:
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto maximum = std::make_shared<op::v1::Maximum>(in1, in2);
 
-        return std::make_shared<Function>(NodeVector{maximum}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{maximum}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/minimum.cpp

@@ -48,10 +48,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& shape, const element::Type& data_type) {
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& shape, const element::Type& data_type) {
         auto A = std::make_shared<op::v0::Parameter>(data_type, shape);
         auto B = std::make_shared<op::v0::Parameter>(data_type, shape);
-        return std::make_shared<ov::Function>(std::make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
+        return std::make_shared<ov::Model>(std::make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/mish.cpp

@@ -58,10 +58,10 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type) {
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto Mish = std::make_shared<op::v4::Mish>(in);
-        return std::make_shared<ov::Function>(NodeVector {Mish}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {Mish}, ParameterVector {in});
     }
 };
 
@@ -125,4 +125,4 @@ std::vector<MishParams> generateMishCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_Mish_With_Hardcoded_Refs, ReferenceMishLayerTest,
     testing::ValuesIn(generateMishCombinedParams()), ReferenceMishLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/mod.cpp

@@ -56,7 +56,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -64,7 +64,7 @@ private:
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto mod = std::make_shared<op::v1::Mod>(in1, in2);
 
-        return std::make_shared<Function>(NodeVector{mod}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{mod}, ParameterVector{in1, in2});
     }
 };
 
@@ -88,7 +88,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -97,7 +97,7 @@ private:
         auto mod = std::make_shared<op::v1::Mod>(in1, in2);
         mod = std::make_shared<op::v1::Mod>(mod, mod);
 
-        return std::make_shared<Function>(NodeVector{mod}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{mod}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/multiclass_nms.cpp

@@ -93,7 +93,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const MulticlassNmsParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const MulticlassNmsParams& params) {
         op::v8::MulticlassNms::Attributes attrs;
         attrs.nms_top_k = params.nms_top_k;
         attrs.iou_threshold = params.iou_threshold;
@@ -108,7 +108,7 @@ private:
         const auto boxes = std::make_shared<op::v0::Parameter>(params.boxes.type, PartialShape::dynamic());
         const auto scores = std::make_shared<op::v0::Parameter>(params.scores.type, PartialShape::dynamic());
         const auto nms = std::make_shared<op::v8::MulticlassNms>(boxes, scores, attrs);
-        const auto f = std::make_shared<Function>(nms->outputs(), ParameterVector{boxes, scores});
+        const auto f = std::make_shared<Model>(nms->outputs(), ParameterVector{boxes, scores});
         return f;
     }
 };
@@ -564,4 +564,4 @@ std::vector<MulticlassNmsParams> generateCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_MulticlassNms_With_Hardcoded_Refs, ReferenceMulticlassNmsTest,
     testing::ValuesIn(generateCombinedParams()), ReferenceMulticlassNmsTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/multiply.cpp

@@ -56,7 +56,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -64,7 +64,7 @@ private:
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto multiply = std::make_shared<op::v1::Multiply>(in1, in2);
 
-        return std::make_shared<Function>(NodeVector{multiply}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{multiply}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/mvn.cpp

@@ -54,14 +54,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Tensor& input, const ngraph::AxisSet& reductionAxes, const bool acrossChannels,
+    static std::shared_ptr<Model> CreateFunction(const Tensor& input, const ngraph::AxisSet& reductionAxes, const bool acrossChannels,
                                                     const bool normalizeVariance, const double eps) {
         const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
         auto mvn = std::make_shared<op::v0::MVN>(in, acrossChannels, normalizeVariance, eps);
         if (!reductionAxes.empty()) {
             mvn = std::make_shared<op::v0::MVN>(in, reductionAxes, normalizeVariance, eps);
         }
-        return std::make_shared<ov::Function>(NodeVector {mvn}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {mvn}, ParameterVector {in});
     }
 };
 
@@ -177,7 +177,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Tensor& input, const Tensor& reductionAxes, const bool normalizeVariance, const double eps,
+    static std::shared_ptr<Model> CreateFunction(const Tensor& input, const Tensor& reductionAxes, const bool normalizeVariance, const double eps,
                                                     const op::MVNEpsMode epsMode) {
         std::vector<int64_t> dataVector(reductionAxes.shape[0]);
         const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
@@ -187,7 +187,7 @@ private:
         }
         const auto axes = std::make_shared<op::v0::Constant>(reductionAxes.type, reductionAxes.shape, dataVector);
         auto mvn = std::make_shared<op::v6::MVN>(in, axes, normalizeVariance, eps, epsMode);
-        return std::make_shared<ov::Function>(NodeVector {mvn}, ParameterVector {in});
+        return std::make_shared<ov::Model>(NodeVector {mvn}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/negative.cpp

@@ -49,12 +49,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto negative = std::make_shared<op::v0::Negative>(in);
-        return std::make_shared<Function>(NodeVector{negative}, ParameterVector{in});
+        return std::make_shared<Model>(NodeVector{negative}, ParameterVector{in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/non_max_suppression.cpp

@@ -71,7 +71,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const NonMaxSuppressionParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const NonMaxSuppressionParams& params) {
         const auto boxes = std::make_shared<op::v0::Parameter>(params.boxes.type, params.boxes.shape);
         const auto scores = std::make_shared<op::v0::Parameter>(params.scores.type, params.scores.shape);
         const auto max_output_boxes_per_class = std::make_shared<op::v0::Constant>(
@@ -90,7 +90,7 @@ private:
                                                                      soft_nms_sigma,
                                                                      params.boxEncoding,
                                                                      false);
-        const auto f = std::make_shared<Function>(nms->outputs(), ParameterVector{boxes, scores});
+        const auto f = std::make_shared<Model>(nms->outputs(), ParameterVector{boxes, scores});
         return f;
     }
 };
@@ -129,7 +129,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const NonMaxSuppressionParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const NonMaxSuppressionParams& params) {
         const auto boxes = std::make_shared<op::v0::Parameter>(params.boxes.type, params.boxes.shape);
         const auto scores = std::make_shared<op::v0::Parameter>(params.scores.type, params.scores.shape);
         const auto max_output_boxes_per_class = std::make_shared<op::v0::Parameter>(
@@ -148,7 +148,7 @@ private:
                                                                      soft_nms_sigma,
                                                                      params.boxEncoding,
                                                                      false);
-        const auto f = std::make_shared<Function>(nms->outputs(),
+        const auto f = std::make_shared<Model>(nms->outputs(),
                                                   ParameterVector{boxes, scores, max_output_boxes_per_class,
                                                                   iou_threshold, score_threshold, soft_nms_sigma});
         return f;
@@ -486,4 +486,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_NonMaxSuppression_With_Hardcoded_Refs, ReferenceN
     testing::ValuesIn(generateCombinedParams()), ReferenceNonMaxSuppressionTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_NonMaxSuppression_With_Hardcoded_Refs, ReferenceNonMaxSuppressionTestWithoutConstants,
     testing::ValuesIn(generateCombinedParamsWithoutConstants()), ReferenceNonMaxSuppressionTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/nonzero.cpp

@@ -60,11 +60,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& output_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto NonZero = std::make_shared<op::v3::NonZero>(in, output_type);
-        return std::make_shared<Function>(NodeVector {NonZero}, ParameterVector {in});
+        return std::make_shared<Model>(NodeVector {NonZero}, ParameterVector {in});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/normalize_l2.cpp

@@ -104,7 +104,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape,
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape,
                                                     const element::Type_t& input_type,
                                                     const std::vector<int32_t>& axes,
                                                     const op::EpsMode& eps_mode,
@@ -112,7 +112,7 @@ private:
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto axes_data = std::make_shared<op::v0::Constant>(element::Type_t::i32, Shape{axes.size()}, axes);
         auto normalize = std::make_shared<op::v0::NormalizeL2>(in, axes_data, eps, eps_mode);
-        return std::make_shared<ov::Function>(normalize, ParameterVector{in});
+        return std::make_shared<ov::Model>(normalize, ParameterVector{in});
     }
 };
 
@@ -798,4 +798,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForNormalizeL2()),
     ReferenceNormalizeL2LayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/one_hot.cpp

@@ -62,8 +62,8 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const OneHotParams& params) {
-        std::shared_ptr<Function> function;
+    static std::shared_ptr<Model> CreateFunction(const OneHotParams& params) {
+        std::shared_ptr<Model> function;
         const auto data = std::make_shared<op::v0::Parameter>(params.dataTensor.type, params.dataTensor.shape);
         const auto depth = std::make_shared<op::v0::Constant>(params.depthTensor.type, params.depthTensor.shape,
                                                               params.depthTensor.data.data());
@@ -72,7 +72,7 @@ private:
         const auto offValue = std::make_shared<op::v0::Constant>(params.offValueTensor.type, params.offValueTensor.shape,
                                                               params.offValueTensor.data.data());
         const auto oneHot = std::make_shared<op::v1::OneHot>(data, depth, onValue, offValue, params.axis);
-        function = std::make_shared<ov::Function>(oneHot, ParameterVector{data});
+        function = std::make_shared<ov::Model>(oneHot, ParameterVector{data});
         return function;
     }
 };
@@ -223,4 +223,4 @@ std::vector<OneHotParams> generateCombinedParams() {
 
 INSTANTIATE_TEST_SUITE_P(smoke_OneHot_With_Hardcoded_Refs, ReferenceOneHotTest,
     testing::ValuesIn(generateCombinedParams()), ReferenceOneHotTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/pad.cpp

@@ -67,7 +67,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PadParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const PadParams& params) {
         const auto data = std::make_shared<op::v0::Parameter>(params.inputData.type,
                                                               params.inputData.shape);
         const auto padsBegin = op::v0::Constant::create(params.padsBegin.type,
@@ -82,7 +82,7 @@ private:
                 const auto padVal = op::v0::Constant::create(params.constantValue.type,
                                                              params.constantValue.shape,
                                                              params.constantValue.data.data());
-                return std::make_shared<Function>(std::make_shared<op::v1::Pad>(data,
+                return std::make_shared<Model>(std::make_shared<op::v1::Pad>(data,
                                                                                 padsBegin,
                                                                                 padsEnd,
                                                                                 padVal,
@@ -90,7 +90,7 @@ private:
                                                   ParameterVector{data});
             }
 
-            return std::make_shared<Function>(std::make_shared<op::v1::Pad>(data,
+            return std::make_shared<Model>(std::make_shared<op::v1::Pad>(data,
                                                                             padsBegin,
                                                                             padsEnd,
                                                                             params.padMode),
@@ -130,7 +130,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PadParams& params) {
+    static std::shared_ptr<Model> CreateFunction(const PadParams& params) {
         const auto data = std::make_shared<op::v0::Parameter>(params.inputData.type,
                                                               params.inputData.shape);
         const auto padsBegin = std::make_shared<op::v0::Parameter>(params.padsBegin.type,
@@ -142,7 +142,7 @@ private:
                 // pad_value should be used only in CONSTANT mode
                 const auto padVal = std::make_shared<op::v0::Parameter>(params.constantValue.type,
                                                                         params.constantValue.shape);
-                return std::make_shared<Function>(std::make_shared<op::v1::Pad>(data,
+                return std::make_shared<Model>(std::make_shared<op::v1::Pad>(data,
                                                                                 padsBegin,
                                                                                 padsEnd,
                                                                                 padVal,
@@ -150,7 +150,7 @@ private:
                                                   ParameterVector{data, padsBegin, padsEnd, padVal});
             }
 
-            return std::make_shared<Function>(std::make_shared<op::v1::Pad>(data,
+            return std::make_shared<Model>(std::make_shared<op::v1::Pad>(data,
                                                                             padsBegin,
                                                                             padsEnd,
                                                                             params.padMode),
@@ -1167,4 +1167,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Pad_With_Hardcoded_Refs, ReferencePadTestParamsOk
 
 INSTANTIATE_TEST_SUITE_P(smoke_Pad_With_Hardcoded_Refs, ReferencePadTestNonConstPadsBeginPadsEndPadValParamsOk,
     testing::ValuesIn(generateCombinedParamsOk()), ReferencePadTest::getTestCaseName);
-} // namespace
+} // namespace

docs/template_plugin/tests/functional/op_reference/parameter_as_output.cpp

@@ -58,9 +58,9 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const Shape& input_shape, const element::Type_t& input_type) {
+    static std::shared_ptr<Model> CreateFunction(const Shape& input_shape, const element::Type_t& input_type) {
         auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
-        return std::make_shared<ov::Function>(in, ParameterVector{in});
+        return std::make_shared<ov::Model>(in, ParameterVector{in});
     }
 };
 
@@ -115,4 +115,4 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::ValuesIn(generateCombinedParamsForParameter()),
     ReferenceParameterLayerTest::getTestCaseName);
 
-}  // namespace
+}  // namespace

docs/template_plugin/tests/functional/op_reference/power.cpp

@@ -56,7 +56,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape1,
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape1,
                                                     const PartialShape& input_shape2,
                                                     const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
@@ -64,7 +64,7 @@ private:
         const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
         const auto power = std::make_shared<op::v1::Power>(in1, in2);
 
-        return std::make_shared<Function>(NodeVector{power}, ParameterVector{in1, in2});
+        return std::make_shared<Model>(NodeVector{power}, ParameterVector{in1, in2});
     }
 };
 

docs/template_plugin/tests/functional/op_reference/prelu.cpp

@@ -60,11 +60,11 @@ public:
     }
 
 private:
-    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const Shape& slope_shape, const element::Type& input_type) {
+    static std::shared_ptr<Model> CreateFunction(const PartialShape& input_shape, const Shape& slope_shape, const element::Type& input_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto SLOPE = std::make_shared<op::v0::Parameter>(input_type, slope_shape);
         const auto Prelu = std::make_shared<op::v0::PRelu>(in, SLOPE);
-        return std::make_shared<ov::Function>(NodeVector {Prelu}, ParameterVector {in, SLOPE});
+        return std::make_shared<ov::Model>(NodeVector {Prelu}, ParameterVector {in, SLOPE});
     }
 };
 
@@ -418,4 +418,4 @@ std::vector<PreluParams> generatePreluCombinedParams() {
 INSTANTIATE_TEST_SUITE_P(smoke_Prelu_With_Hardcoded_Refs, ReferencePreluLayerTest,
     testing::ValuesIn(generatePreluCombinedParams()), ReferencePreluLayerTest::getTestCaseName);
 
-} // namespace
+} // namespace