diff --git a/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp b/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp
index fa80980c213652..b163cbeeaac04c 100644
--- a/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp
+++ b/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp
@@ -1062,7 +1062,7 @@ void convertFunctionToICNNNetwork(const std::shared_ptr<const ::ngraph::Function
                 std::make_shared<Builder::NodeConverter<::ngraph::op::v1::Softmax>>(),
                 std::make_shared<Builder::NodeConverter<::ngraph::op::v1::Split>>(),
                 std::make_shared<Builder::NodeConverter<::ngraph::op::VariadicSplit>>(),
-                std::make_shared<Builder::NodeConverter<::ngraph::op::Subtract>>(),
+                std::make_shared<Builder::NodeConverter<::ngraph::op::v1::Subtract>>(),
                 std::make_shared<Builder::NodeConverter<::ngraph::op::Tanh>>(),
                 std::make_shared<Builder::NodeConverter<::ngraph::op::TileIE>>(),
                 std::make_shared<Builder::NodeConverter<::ngraph::op::TensorIterator>>(),
diff --git a/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp b/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp
index e6a3ca2566b4e5..50bba3d3b5fdd5 100644
--- a/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp
+++ b/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp
@@ -537,7 +537,7 @@ CNNLayer::Ptr NodeConverter<ngraph::op::v1::Softmax>::createLayer(const std::sha
 }
 
 template <>
-CNNLayer::Ptr NodeConverter<ngraph::op::Subtract>::createLayer(const std::shared_ptr<ngraph::Node>& layer) const {
+CNNLayer::Ptr NodeConverter<ngraph::op::v1::Subtract>::createLayer(const std::shared_ptr<ngraph::Node>& layer) const {
     LayerParams params = {layer->get_friendly_name(), "Eltwise",
                           details::convertPrecision(layer->get_output_element_type(0))};
     auto res = std::make_shared<InferenceEngine::EltwiseLayer>(params);
diff --git a/inference-engine/tests/functional/inference_engine/transformations/algebraic_simplification.cpp b/inference-engine/tests/functional/inference_engine/transformations/algebraic_simplification.cpp
index 567ddda804db24..824e8d8daf73c1 100644
--- a/inference-engine/tests/functional/inference_engine/transformations/algebraic_simplification.cpp
+++ b/inference-engine/tests/functional/inference_engine/transformations/algebraic_simplification.cpp
@@ -36,10 +36,10 @@ TEST(algebraic_simplification, add_negative_tests) {
     auto c = make_shared<op::Parameter>(type, shape);
     auto abs_a = make_shared<op::Abs>(a);
     auto iconst2 = ngraph::make_constant_from_string("2", type, shape);
-    auto add_a_0 = a + iconst2;
-    auto add_a_0_0 = add_a_0 + iconst2;
-    auto add_b_0 = b + abs_a;
-    auto add_b_0_0 = add_b_0 + abs_a;
+    auto add_a_0 = std::make_shared<ngraph::op::v1::Add>(a, iconst2);
+    auto add_a_0_0 = std::make_shared<ngraph::op::v1::Add>(add_a_0, iconst2);
+    auto add_b_0 = std::make_shared<ngraph::op::v1::Add>(b, abs_a);
+    auto add_b_0_0 = std::make_shared<ngraph::op::v1::Add>(add_b_0, abs_a);
 
     auto f = std::make_shared<Function>(ngraph::NodeVector{a, b, add_a_0_0, c, add_b_0_0},
                                         ParameterVector{a, b, c});
@@ -63,10 +63,10 @@ TEST(algebraic_simplification, multiply_negative_tests) {
     auto c = make_shared<op::Parameter>(type, shape);
     auto abs_a = make_shared<op::Abs>(a);
     auto iconst2 = ngraph::make_constant_from_string("2", type, shape);
-    auto add_a_0 = a * iconst2;
-    auto add_a_0_0 = add_a_0 * iconst2;
-    auto add_b_0 = b * abs_a;
-    auto add_b_0_0 = add_b_0 * abs_a;
+    auto add_a_0 = make_shared<op::v1::Multiply>(a, iconst2);
+    auto add_a_0_0 = make_shared<op::v1::Multiply>(add_a_0, iconst2);
+    auto add_b_0 = make_shared<op::v1::Multiply>(b, abs_a);
+    auto add_b_0_0 = make_shared<op::v1::Multiply>(add_b_0, abs_a);
 
     auto f = std::make_shared<Function>(ngraph::NodeVector{a, b, add_a_0_0, c, add_b_0_0},
                                         ParameterVector{a, b, c});
@@ -228,7 +228,7 @@ TEST(algebraic_simplification, log_no_exp) {
     auto a = make_shared<op::Parameter>(element::f32, Shape{96, 100});
     auto b = make_shared<op::Parameter>(element::f32, Shape{96, 100});
     auto abs_a = make_shared<op::Abs>(a);
-    auto div = abs_a / b;
+    auto div = std::make_shared<op::v1::Divide>(abs_a, b);
     auto log_div = make_shared<op::Log>(div);
 
     auto neg_inner = make_shared<op::Negative>(log_div);
@@ -248,7 +248,7 @@ TEST(algebraic_simplification, log_no_divide) {
     auto a = make_shared<op::Parameter>(element::f32, Shape{96, 100});
     auto b = make_shared<op::Parameter>(element::f32, Shape{96, 100});
     auto exp_a = make_shared<op::Exp>(a);
-    auto mul = exp_a * b;
+    auto mul = make_shared<op::v1::Multiply>(exp_a, b);
     auto log_mul = make_shared<op::Log>(mul);
 
     auto neg_inner = make_shared<op::Negative>(log_mul);
diff --git a/inference-engine/tests/functional/plugin/cpu/bfloat16/memory_conv.cpp b/inference-engine/tests/functional/plugin/cpu/bfloat16/memory_conv.cpp
index ba283ab7c87003..839022a082d6c2 100644
--- a/inference-engine/tests/functional/plugin/cpu/bfloat16/memory_conv.cpp
+++ b/inference-engine/tests/functional/plugin/cpu/bfloat16/memory_conv.cpp
@@ -48,7 +48,7 @@ class MemoryConv : public testing::WithParamInterface<LayerTestsUtils::basicPara
         auto mem_i = make_shared<op::v0::Constant>(type, shape, 0);
         auto mem_r = make_shared<op::v3::ReadValue>(mem_i, "id");
 
-        auto mul = make_shared<op::v0::Multiply>(mem_r, input);
+        auto mul = make_shared<op::v1::Multiply>(mem_r, input);
         auto sig = make_shared<op::v0::Sigmoid>(mul);
 
         auto fc1_w = make_shared<op::v0::Constant>(type, Shape{C, C}, 1);
diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp
index 0e0e430248bf16..ac65ff3ff12f31 100644
--- a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp
+++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp
@@ -21,15 +21,16 @@ const std::vector<LayerTransformation::Params> trasformationParamValues = {
 };
 
 const std::vector<ngraph::builder::subgraph::FakeQuantizeOnData> fakeQuantizeOnDataValues = {
-    { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } },
-    {
-        256ul,
-        { 1ul, 3ul, 1ul, 1ul },
-        { 0.f, 0.f, 0.f },
-        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f },
-        { 0.f, 0.f, 0.f },
-        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f }
-    },
+    { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } }
+// TODO: Issue 39810
+//    {
+//        256ul,
+//        { 1ul, 3ul, 1ul, 1ul },
+//        { 0.f, 0.f, 0.f },
+//        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f },
+//        { 0.f, 0.f, 0.f },
+//        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f }
+//    },
 };
 
 INSTANTIATE_TEST_CASE_P(smoke_LPT, FuseFakeQuantizeAndScaleShiftTransformation,
diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp
index 397439e4e7b785..4f10d29387cc09 100644
--- a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp
+++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp
@@ -26,7 +26,7 @@ const std::vector<ReshapeTransformationParam> params = {
     {
         ngraph::Shape{ 1, 3, 32 },
         { 1, 3, 4, 8 },
-        { 256ul, ngraph::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
+        { 256ul, ngraph::Shape{ 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
     },
     // 4D -> 3D
     {
diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp
index 137ff2683b01d0..de81010cf8d127 100644
--- a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp
+++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp
@@ -24,27 +24,27 @@ namespace {
 
     const std::vector<LayerTestsDefinitions::UnsqueezeTransformationParam> params = {
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
             { 0.0, 3.0 },
             { 3, 3, 5}
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
             { 0.0, 1.0 },
             { 3, 3, 3 }
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
             { 3.0 },
             { 3, 4, 5, 6 }
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
             { 0.0, 3.0 },
             { 1, 32, 2}
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
             { 0.0, 1.0 },
             { 46, 128, 2 }
         }
diff --git a/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp b/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp
index 9cdc2bb960b80c..260c322ed4e49c 100644
--- a/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp
+++ b/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.cpp
@@ -22,14 +22,15 @@ const std::vector<LayerTransformation::Params> trasformationParamValues = {
 
 const std::vector<ngraph::builder::subgraph::FakeQuantizeOnData> fakeQuantizeOnDataValues = {
     { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } },
-    {
-        256ul,
-        { 1ul, 3ul, 1ul, 1ul },
-        { 0.f, 0.f, 0.f },
-        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f },
-        { 0.f, 0.f, 0.f },
-        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f }
-    },
+// TODO: Issue 39810
+//    {
+//        256ul,
+//        { 1ul, 3ul, 1ul, 1ul },
+//        { 0.f, 0.f, 0.f },
+//        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f },
+//        { 0.f, 0.f, 0.f },
+//        { 2.55f / 10.f, 2.55f / 5.f, 2.55f / 2.f }
+//    },
 };
 
 INSTANTIATE_TEST_CASE_P(smoke_LPT, FuseFakeQuantizeAndScaleShiftTransformation,
diff --git a/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp b/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp
index 05914a4ce2e717..f7d811871550f5 100644
--- a/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp
+++ b/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp
@@ -26,19 +26,19 @@ const std::vector<ReshapeTransformationParam> params = {
     {
         ngraph::Shape{ 1, 3, 32 },
         { 1, 3, 4, 8 },
-        { 256ul, ngraph::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
+        { 256ul, ngraph::Shape{ 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
     },
     // 4D -> 3D
     {
         ngraph::Shape{ 1, 3, 16, 16 },
         { 1, 3, 256 },
-        { 256ul, ngraph::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
+        { 256ul, ngraph::Shape{ 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
     },
     // 4D -> 2D
     {
         ngraph::Shape{ 1, 3, 4, 8 },
         { 1, -1 },
-        { 256ul, ngraph::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
+        { 256ul, ngraph::Shape{ 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
     },
 };
 
diff --git a/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp b/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp
index 40c15ab7953b3c..d657debac3e2ff 100644
--- a/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp
+++ b/inference-engine/tests/functional/plugin/gpu/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp
@@ -24,27 +24,27 @@ namespace {
 
     const std::vector<LayerTestsDefinitions::UnsqueezeTransformationParam> params = {
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
             { 0.0, 3.0 },
             { 3, 3, 5}
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
             { 0.0, 1.0 },
             { 3, 3, 3 }
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
             { 3.0 },
             { 3, 4, 5, 6 }
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
             { 0.0, 3.0 },
             { 1, 32, 2}
         },
         {
-            { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
+            { 256ul, ngraph::Shape { 1, 1, 1 }, { 0.f }, { 255.f }, { -128.f }, { 127.f } },
             { 0.0, 1.0 },
             { 46, 128, 2 }
         }
diff --git a/inference-engine/tests/functional/plugin/shared/src/execution_graph_tests/keep_assing.cpp b/inference-engine/tests/functional/plugin/shared/src/execution_graph_tests/keep_assing.cpp
index 295629f6277302..a4da8e34831449 100644
--- a/inference-engine/tests/functional/plugin/shared/src/execution_graph_tests/keep_assing.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/execution_graph_tests/keep_assing.cpp
@@ -29,13 +29,13 @@ TEST_P(ExecGraphKeepAssignNode, KeepAssignNode) {
     using std::make_shared;
     using namespace ngraph::op;
 
-    // Some simple graph with Memory(Assign) node            //    in   read     //
-    auto input = make_shared<Parameter>(type, shape);        //    | \  /        //
-    auto mem_i = make_shared<Constant>(type, shape, 0);      //    |  mul        //
-    auto mem_r = make_shared<ReadValue>(mem_i, "id");        //    | /  \        //
-    auto mul   = make_shared<Multiply>(mem_r, input);        //    sum  assign   //
-    auto mem_w = make_shared<Assign>(mul, "id");             //     |            //
-    auto sum   = make_shared<Add>(mul, input);               //    out           //
+    // Some simple graph with Memory(Assign) node                     //    in   read     //
+    auto input = make_shared<Parameter>(type, shape);                 //    | \  /        //
+    auto mem_i = make_shared<Constant>(type, shape, 0);               //    |  mul        //
+    auto mem_r = make_shared<ReadValue>(mem_i, "id");                 //    | /  \        //
+    auto mul   = make_shared<ngraph::op::v1::Multiply>(mem_r, input); //    sum  assign   //
+    auto mem_w = make_shared<Assign>(mul, "id");                      //     |            //
+    auto sum   = make_shared<ngraph::op::v1::Add>(mul, input);        //    out           //
 
     mem_w->add_control_dependency(mem_r);
     sum->add_control_dependency(mem_w);
diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/activation.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/activation.cpp
index 67f182762b0f14..d0fe8056b6d2b3 100644
--- a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/activation.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/activation.cpp
@@ -198,7 +198,7 @@ void ActivationParamLayerTest::SetUp() {
     constantsValue = activationDecl.second;
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     auto params = ngraph::builder::makeParams(ngPrc, {shapes.first});
-    auto activationParams = createActivationParams(ngPrc);
+    auto activationParams = createActivationParams(ngPrc, shapes.second);
 
     params[0]->set_friendly_name("Input");
     params.insert(params.end(), activationParams.begin(), activationParams.end());
diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/batch_to_space.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/batch_to_space.cpp
index c3938d2db38894..b6748e98d65953 100644
--- a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/batch_to_space.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/batch_to_space.cpp
@@ -43,7 +43,6 @@ std::string BatchToSpaceLayerTest::getTestCaseName(const testing::TestParamInfo<
 }
 
 void BatchToSpaceLayerTest::SetUp() {
-    SetRefMode(LayerTestsUtils::RefMode::INTERPRETER_TRANSFORMATIONS);
     std::vector<size_t> inputShape;
     std::vector<int64_t> blockShape, cropsBegin, cropsEnd;
     InferenceEngine::Precision netPrecision;
diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/fake_quantize.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/fake_quantize.cpp
index 511c234f1bb231..1c3bc5fd2c15c7 100644
--- a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/fake_quantize.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/fake_quantize.cpp
@@ -26,8 +26,8 @@
 /**
  * redefine this seed to reproduce issue with given seed that can be read from gtest logs
  */
-#define BASE_SEED   USE_CLOCK_TIME
-#define NGRAPH_SEED USE_CLOCK_TIME
+#define BASE_SEED   123
+#define NGRAPH_SEED 123
 
 namespace LayerTestsDefinitions {
 
@@ -85,6 +85,9 @@ void FakeQuantizeLayerTest::SetUp() {
         inputDataMax = inputArg[1];
         inputDataResolution = inputArg[2];
     }
+    if (fqDirectArg.size() != 0) {
+        threshold = (fqDirectArg[3] - fqDirectArg[2]) / levels;
+    }
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
     auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/loop.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/loop.cpp
index 6cc93f1c453ee8..50f0ee590ae55f 100644
--- a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/loop.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/loop.cpp
@@ -120,7 +120,7 @@ namespace LayerTestsDefinitions {
         // Body
         std::shared_ptr<ngraph::Node> Zo = body_params[0];
         for (int i = 1; i < body_params.size(); ++i) {
-            Zo = body_params[i] + Zo;
+            Zo = std::make_shared<ngraph::op::v1::Add>(body_params[i], Zo);
         }
 
         // body_params.insert(body_params.begin(), current_iteration);
diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/select.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/select.cpp
index d6e405eda6b15b..52d28308ff2524 100644
--- a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/select.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/select.cpp
@@ -37,8 +37,6 @@ namespace LayerTestsDefinitions {
     }
 
     void SelectLayerTest::SetUp() {
-        SetRefMode(LayerTestsUtils::RefMode::CONSTANT_FOLDING);
-
         std::vector<std::vector<size_t>> inputShapes(numOfInputs);
         InferenceEngine::Precision inputPrecision;
         ngraph::op::AutoBroadcastSpec broadcast;
diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/space_to_batch.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/space_to_batch.cpp
index d2b17821f9648f..ed576b42e0c536 100644
--- a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/space_to_batch.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/space_to_batch.cpp
@@ -43,7 +43,6 @@ std::string SpaceToBatchLayerTest::getTestCaseName(const testing::TestParamInfo<
 }
 
 void SpaceToBatchLayerTest::SetUp() {
-    SetRefMode(LayerTestsUtils::RefMode::INTERPRETER_TRANSFORMATIONS);
     std::vector<size_t> inputShape;
     std::vector<int64_t> blockShape, padsBegin, padsEnd;
     InferenceEngine::Precision inputPrecision, netPrecision;
diff --git a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/cascade_concat.cpp b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/cascade_concat.cpp
index f83dde6f5a88be..53b20a7e8693db 100644
--- a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/cascade_concat.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/cascade_concat.cpp
@@ -51,7 +51,7 @@ void CascadeConcat::SetUp() {
     if (multioutput) {
         auto const_mult = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{1, input1[0][1]+input2[0][1]},
                                                   std::vector<float>{1.01f});
-        auto mult = std::make_shared<ngraph::op::v0::Multiply>(concat, const_mult);
+        auto mult = std::make_shared<ngraph::op::v1::Multiply>(concat, const_mult);
         results = ngraph::ResultVector{std::make_shared<ngraph::opset1::Result>(concat2),
                                        std::make_shared<ngraph::opset1::Result>(mult)};
     } else {
diff --git a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/softsign.cpp b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/softsign.cpp
index 0a223272e8bc10..47ffe1eb418170 100644
--- a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/softsign.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/softsign.cpp
@@ -52,7 +52,7 @@ void SoftsignTest::SetUp() {
     auto abs = std::make_shared<ngraph::op::Abs>(params[0]);
     auto add = std::make_shared<ngraph::op::PowerIE>(abs, 1, 1, 1);
     auto power = std::make_shared<ngraph::op::PowerIE>(add, -1, 1, 0);
-    auto mul = std::make_shared<ngraph::op::Multiply>(power, params[0]);
+    auto mul = std::make_shared<ngraph::op::v1::Multiply>(power, params[0]);
     ngraph::ResultVector results{ std::make_shared<ngraph::op::Result>(mul) };
     function = std::make_shared<ngraph::Function>(results, params, "SoftSignTest");
 }
@@ -75,10 +75,10 @@ std::shared_ptr<ngraph::Function> SoftsignTest::GenerateNgraphFriendlySoftSign()
     auto params = ngraph::builder::makeParams(ngPrc, { inputShape });
     auto abs = std::make_shared<ngraph::op::Abs>(params[0]);
     auto constant_0 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, { 1 });
-    auto add = std::make_shared<ngraph::op::Add>(abs, constant_0);
+    auto add = std::make_shared<ngraph::op::v1::Add>(abs, constant_0);
     auto constant_1 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, { -1 });
-    auto power = std::make_shared<ngraph::op::Power>(add, constant_1);
-    auto mul = std::make_shared<ngraph::op::Multiply>(power, params[0]);
+    auto power = std::make_shared<ngraph::op::v1::Power>(add, constant_1);
+    auto mul = std::make_shared<ngraph::op::v1::Multiply>(power, params[0]);
 
     ngraph::ResultVector results{ std::make_shared<ngraph::op::Result>(mul) };
     return std::make_shared<ngraph::Function>(results, params, "SoftSignTest");
diff --git a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/split_concat_memory.cpp b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/split_concat_memory.cpp
index 2643154f6c84a3..98518f9c5517d4 100644
--- a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/split_concat_memory.cpp
+++ b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/split_concat_memory.cpp
@@ -64,7 +64,7 @@ void SplitConcatMemory::SetUp() {
     auto spl = std::make_shared<ngraph::op::v1::VariadicSplit>(cnc, axis_c, chunk_c);
 
     auto one = std::make_shared<ngraph::op::Constant>(ngPrc, ngraph::Shape{}, 1);
-    auto plus = std::make_shared<ngraph::op::Add>(cnc, one, ngraph::op::AutoBroadcastSpec::NUMPY);
+    auto plus = std::make_shared<ngraph::op::v1::Add>(cnc, one, ngraph::op::AutoBroadcastSpec::NUMPY);
     plus->set_friendly_name("plus_one");
 
     auto mem_w = std::make_shared<ngraph::op::Assign>(spl->output(1), "id");
diff --git a/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.cpp b/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.cpp
index 4cbfc20959e564..8ffa066953306a 100644
--- a/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.cpp
+++ b/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.cpp
@@ -370,17 +370,6 @@ std::vector<std::vector<std::uint8_t>> LayerTestsCommon::CalculateRefs() {
             // reference inference on device with other options and nGraph function has to be implemented here
             break;
         }
-        case INTERPRETER_TRANSFORMATIONS: {
-            auto cloned_function = ngraph::clone_function(*function);
-
-            // todo: add functionality to configure the necessary transformations for each test separately
-            ngraph::pass::Manager m;
-            m.register_pass<ngraph::pass::ConvertSpaceToBatch>();
-            m.register_pass<ngraph::pass::ConvertBatchToSpace>();
-            m.run_passes(cloned_function);
-            expectedOutputs = ngraph::helpers::interpreterFunction(cloned_function, referenceInputs, inType, convertType);
-            break;
-        }
     }
 
     return expectedOutputs;
diff --git a/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.hpp b/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.hpp
index bdc1e27b209ece..20c326a4b7e496 100644
--- a/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.hpp
+++ b/inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.hpp
@@ -126,7 +126,6 @@ typedef std::tuple<
 
 enum RefMode {
     INTERPRETER,
-    INTERPRETER_TRANSFORMATIONS,
     CONSTANT_FOLDING,
     IE
 };
diff --git a/inference-engine/tests/unit/cpu/bf16_transformer_test.cpp b/inference-engine/tests/unit/cpu/bf16_transformer_test.cpp
index 2678f2fa808b9a..8c04570b41ee0c 100644
--- a/inference-engine/tests/unit/cpu/bf16_transformer_test.cpp
+++ b/inference-engine/tests/unit/cpu/bf16_transformer_test.cpp
@@ -68,7 +68,7 @@ TEST(BF16TransformerTest, KeepMemoryPrecision) {
     auto mem_r = make_shared<ReadValue>(mem_i, "id");
     mem_r->set_friendly_name("mem_r");
 
-    auto mul = make_shared<Multiply>(mem_r, input);
+    auto mul = make_shared<ngraph::op::v1::Multiply>(mem_r, input);
     auto sig = make_shared<Sigmoid>(mul);
 
     auto fc1_w = make_shared<Constant>(type, Shape{2, 2}, 1);
@@ -131,7 +131,7 @@ TEST(BF16TransformerTest, DISABLED_KeepMemoryPrecisionWithGEMM) {
     auto mem_r = make_shared<ReadValue>(mem_i, "id");
     mem_r->set_friendly_name("mem_r");
 
-    auto mul = make_shared<Multiply>(mem_r, input);
+    auto mul = make_shared<ngraph::op::v1::Multiply>(mem_r, input);
     auto sig = make_shared<Sigmoid>(mul);
 
     auto fc1_w = make_shared<Constant>(type, Shape{2, 2}, 1);
diff --git a/inference-engine/tests_deprecated/unit/engines/gna/layers/gna_eltwise_test.cpp b/inference-engine/tests_deprecated/unit/engines/gna/layers/gna_eltwise_test.cpp
index 2b42d355a03f3c..d652768896524c 100644
--- a/inference-engine/tests_deprecated/unit/engines/gna/layers/gna_eltwise_test.cpp
+++ b/inference-engine/tests_deprecated/unit/engines/gna/layers/gna_eltwise_test.cpp
@@ -69,7 +69,7 @@ class GNAEltwiseTest : public GNATest<>, public testing::WithParamInterface<GNAE
             FC2 = std::make_shared<ngraph::op::v1::Reshape>(FC2, reshape_pattern, false);
         }
 
-        auto add = std::make_shared<ngraph::op::Add>(FC1, FC2);
+        auto add = std::make_shared<ngraph::op::v1::Add>(FC1, FC2);
 
         auto function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{input1, input2});
 
diff --git a/ngraph/core/include/ngraph/op/add.hpp b/ngraph/core/include/ngraph/op/add.hpp
index 73a4824d801698..f5836c567b5266 100644
--- a/ngraph/core/include/ngraph/op/add.hpp
+++ b/ngraph/core/include/ngraph/op/add.hpp
@@ -24,48 +24,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise addition operation.
-            ///
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. Use v1::Add instead of it.")
-                NGRAPH_API Add : public util::BinaryElementwiseArithmetic
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Add", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs an uninitialized addition operation
-                Add()
-                    : util::BinaryElementwiseArithmetic(AutoBroadcastSpec::NONE)
-                {
-                }
-
-                /// \brief Constructs an addition operation.
-                ///
-                /// \param arg0 Output that produces the first input tensor.<br>
-                /// `[d0, ...]`
-                /// \param arg1 Output that produces the second input tensor.<br>
-                /// `[d0, ...]`
-                /// \param auto_broadcast Auto broadcast specification
-                ///
-                /// Output `[d0, ...]`
-                ///
-                Add(const Output<Node>& arg0,
-                    const Output<Node>& arg1,
-                    const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool visit_attributes(AttributeVisitor& visitor) override;
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise addition operation.
@@ -99,19 +57,13 @@ namespace ngraph
 
                 std::shared_ptr<Node>
                     clone_with_new_inputs(const OutputVector& new_args) const override;
+
                 bool visit_attributes(AttributeVisitor& visitor) override;
+
                 size_t get_version() const override { return 1; }
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
             };
-
         } // namespace v1
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Add;
-        NGRAPH_SUPPRESS_DEPRECATED_END
-    } // namespace op
-
-    NGRAPH_DEPRECATED("This operator was deprecated and will be removed with v0 operation.")
-    NGRAPH_API
-    std::shared_ptr<Node> operator+(const Output<Node>& arg0, const Output<Node>& arg1);
-} // namespace ngraph
+    }     // namespace op
+} // namespace ngraph
\ No newline at end of file
diff --git a/ngraph/core/include/ngraph/op/batch_to_space.hpp b/ngraph/core/include/ngraph/op/batch_to_space.hpp
index 8b3433a4052bd1..e48d9e8e0a9085 100644
--- a/ngraph/core/include/ngraph/op/batch_to_space.hpp
+++ b/ngraph/core/include/ngraph/op/batch_to_space.hpp
@@ -54,6 +54,8 @@ namespace ngraph
                              const Output<Node>& block_shape,
                              const Output<Node>& crops_begin,
                              const Output<Node>& crops_end);
+                bool evaluate(const HostTensorVector& outputs,
+                              const HostTensorVector& inputs) const override;
 
                 void validate_and_infer_types() override;
                 std::shared_ptr<Node>
diff --git a/ngraph/core/include/ngraph/op/depth_to_space.hpp b/ngraph/core/include/ngraph/op/depth_to_space.hpp
index 191050f706f2e2..19deb75df5f65d 100644
--- a/ngraph/core/include/ngraph/op/depth_to_space.hpp
+++ b/ngraph/core/include/ngraph/op/depth_to_space.hpp
@@ -20,6 +20,7 @@
 #include "ngraph/op/op.hpp"
 #include "ngraph/op/util/attr_types.hpp"
 #include "ngraph/op/util/fused_op.hpp"
+#include "ngraph/runtime/host_tensor.hpp"
 
 NGRAPH_SUPPRESS_DEPRECATED_START
 
@@ -37,7 +38,7 @@ namespace ngraph
             ///
             ///        Output node produces a tensor with shape:
             ///        [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]
-            class NGRAPH_API DepthToSpace : public ngraph::op::util::FusedOp
+            class NGRAPH_API DepthToSpace : public Op
             {
             public:
                 NGRAPH_RTTI_DECLARATION;
@@ -68,10 +69,11 @@ namespace ngraph
 
                 std::size_t get_block_size() const { return m_blocksize; }
                 DepthToSpaceMode get_mode() const { return m_mode; }
-                virtual OutputVector decompose_op() const override;
-
                 virtual std::shared_ptr<Node>
                     clone_with_new_inputs(const OutputVector& new_args) const override;
+                void validate_and_infer_types() override;
+                bool evaluate(const HostTensorVector& outputs,
+                              const HostTensorVector& inputs) const override;
 
             protected:
                 std::size_t m_blocksize;
diff --git a/ngraph/core/include/ngraph/op/divide.hpp b/ngraph/core/include/ngraph/op/divide.hpp
index 36e6aaa52f3047..fdaef3a49b58e5 100644
--- a/ngraph/core/include/ngraph/op/divide.hpp
+++ b/ngraph/core/include/ngraph/op/divide.hpp
@@ -22,57 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise division operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Divide instead of it.") NGRAPH_API Divide
-                : public util::BinaryElementwiseArithmetic
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Divide", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a division operation.
-                Divide()
-                    : util::BinaryElementwiseArithmetic(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a division operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param pythondiv Use Python style rounding for integral type
-                /// \param auto_broadcast Auto broadcast specification
-                Divide(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       bool pythondiv,
-                       const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                /// \brief Constructs a division operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Divide(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-                bool visit_attributes(AttributeVisitor& visitor) override;
-                bool is_pythondiv() const { return m_pythondiv; }
-                void set_is_pythondiv(bool pythondiv) { m_pythondiv = pythondiv; }
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-
-            protected:
-                bool m_pythondiv{true};
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise division operation.
@@ -121,13 +70,5 @@ namespace ngraph
                 bool m_pythondiv{true};
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Divide;
-        NGRAPH_SUPPRESS_DEPRECATED_END
-    } // namespace op
-
-    NGRAPH_DEPRECATED("This operator was deprecated and will be removed with v0 operation.")
-    NGRAPH_API
-    std::shared_ptr<Node> operator/(const Output<Node>& arg0, const Output<Node>& arg1);
+    }     // namespace op
 } // namespace ngraph
diff --git a/ngraph/core/include/ngraph/op/equal.hpp b/ngraph/core/include/ngraph/op/equal.hpp
index bbb7255c199e22..4b9edc72685c37 100644
--- a/ngraph/core/include/ngraph/op/equal.hpp
+++ b/ngraph/core/include/ngraph/op/equal.hpp
@@ -22,57 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            // clang-format off
-            /// \brief Elementwise is-equal operation.
-            ///
-            /// ## Inputs
-            ///
-            /// |        | Type                              | Description                                            |
-            /// | ------ | --------------------------------- | ------------------------------------------------------ |
-            /// | `arg0` | \f$E[d_1,\dots,d_n]~(n \geq 0)\f$ | A tensor of any shape and element type.                |
-            /// | `arg1` | \f$E[d_1,\dots,d_n]~(n \geq 0)\f$ | A tensor of the same shape and element type as `arg0`. |
-            /// | `autob`| AutoBroadcastSpec                 | Auto broadcast specification.                          |
-            ///
-            /// ## Output
-            ///
-            /// | Type                               | Description                                                                                                                                |
-            /// | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-            /// | \f$\texttt{bool}[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = 1\text{ if }\texttt{arg0}[i_1,\dots,i_n] = \texttt{arg1}[i_1,\dots,i_n]\text{, else } 0\f$ |
-            // clang-format on
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Equal instead of it.") NGRAPH_API Equal
-                : public util::BinaryElementwiseComparison
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Equal", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs an equal operation.
-                Equal()
-                    : util::BinaryElementwiseComparison(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs an equal operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Equal(const Output<Node>& arg0,
-                      const Output<Node>& arg1,
-                      const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             // clang-format off
@@ -118,9 +67,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Equal;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/greater.hpp b/ngraph/core/include/ngraph/op/greater.hpp
index 8cc0330f7b9610..ee55920c63baf4 100644
--- a/ngraph/core/include/ngraph/op/greater.hpp
+++ b/ngraph/core/include/ngraph/op/greater.hpp
@@ -22,40 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise greater-than operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Greater instead of it.") NGRAPH_API Greater
-                : public util::BinaryElementwiseComparison
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Greater", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a greater-than operation.
-                Greater()
-                    : util::BinaryElementwiseComparison(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a greater-than operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Greater(const Output<Node>& arg0,
-                        const Output<Node>& arg1,
-                        const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise greater-than operation.
@@ -84,9 +50,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Greater;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/greater_eq.hpp b/ngraph/core/include/ngraph/op/greater_eq.hpp
index 548463d74a88d3..de4b79f0e55f74 100644
--- a/ngraph/core/include/ngraph/op/greater_eq.hpp
+++ b/ngraph/core/include/ngraph/op/greater_eq.hpp
@@ -22,40 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise greater-than-or-equal operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::GreaterEqual instead of it.") NGRAPH_API GreaterEq
-                : public util::BinaryElementwiseComparison
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"GreaterEq", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a greater-than-or-equal operation.
-                GreaterEq()
-                    : util::BinaryElementwiseComparison(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a greater-than-or-equal operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                GreaterEq(const Output<Node>& arg0,
-                          const Output<Node>& arg1,
-                          const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise greater-than-or-equal operation.
@@ -84,9 +50,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::GreaterEq;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/less.hpp b/ngraph/core/include/ngraph/op/less.hpp
index 56b5e7f9d402f3..fcaa5e505f0b4b 100644
--- a/ngraph/core/include/ngraph/op/less.hpp
+++ b/ngraph/core/include/ngraph/op/less.hpp
@@ -22,40 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise less-than operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Less instead of it.") NGRAPH_API Less
-                : public util::BinaryElementwiseComparison
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Less", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a less-than operation.
-                Less()
-                    : util::BinaryElementwiseComparison(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a less-than operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Less(const Output<Node>& arg0,
-                     const Output<Node>& arg1,
-                     const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise less-than operation.
@@ -84,9 +50,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Less;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/less_eq.hpp b/ngraph/core/include/ngraph/op/less_eq.hpp
index 999d972575f3c6..c87fe31f030a59 100644
--- a/ngraph/core/include/ngraph/op/less_eq.hpp
+++ b/ngraph/core/include/ngraph/op/less_eq.hpp
@@ -51,43 +51,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        namespace v0
-        {
-            /// \brief Elementwise less-than-or-equal operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::LessEqual instead of it.") NGRAPH_API LessEq
-                : public util::BinaryElementwiseComparison
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"LessEq", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a less-than-or-equal operation.
-                LessEq()
-                    : util::BinaryElementwiseComparison(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a less-than-or-equal operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                LessEq(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::LessEq;
-        NGRAPH_SUPPRESS_DEPRECATED_END
-    } // namespace op
+    }     // namespace op
 } // namespace ngraph
diff --git a/ngraph/core/include/ngraph/op/lstm_cell.hpp b/ngraph/core/include/ngraph/op/lstm_cell.hpp
index 9b6885d207ca5a..0c3957c7ecc2fe 100644
--- a/ngraph/core/include/ngraph/op/lstm_cell.hpp
+++ b/ngraph/core/include/ngraph/op/lstm_cell.hpp
@@ -401,7 +401,7 @@ namespace ngraph
 
                 static constexpr std::size_t s_gates_count{4};
             };
-        } // v1
+        } // v4
     }     // namespace op
 
     NGRAPH_API
diff --git a/ngraph/core/include/ngraph/op/maximum.hpp b/ngraph/core/include/ngraph/op/maximum.hpp
index 438e7a0313c2e0..19b3f2d45a05c3 100644
--- a/ngraph/core/include/ngraph/op/maximum.hpp
+++ b/ngraph/core/include/ngraph/op/maximum.hpp
@@ -22,41 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise maximum operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Maximum instead of it.") NGRAPH_API Maximum
-                : public util::BinaryElementwiseArithmetic
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Maximum", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a maximum operation.
-                Maximum()
-                    : util::BinaryElementwiseArithmetic(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a maximum operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Maximum(const Output<Node>& arg0,
-                        const Output<Node>& arg1,
-                        const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise maximum operation.
@@ -88,9 +53,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Maximum;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/minimum.hpp b/ngraph/core/include/ngraph/op/minimum.hpp
index 3611fa0fa79fdf..f053bbccef46b4 100644
--- a/ngraph/core/include/ngraph/op/minimum.hpp
+++ b/ngraph/core/include/ngraph/op/minimum.hpp
@@ -22,41 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise minimum operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Minimum instead of it.") NGRAPH_API Minimum
-                : public util::BinaryElementwiseArithmetic
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Minimum", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a minimum operation.
-                Minimum()
-                    : util::BinaryElementwiseArithmetic(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a minimum operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Minimum(const Output<Node>& arg0,
-                        const Output<Node>& arg1,
-                        const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise minimum operation.
@@ -88,9 +53,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Minimum;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/multiply.hpp b/ngraph/core/include/ngraph/op/multiply.hpp
index b685adea0d7a5b..2eab5b106cf39c 100644
--- a/ngraph/core/include/ngraph/op/multiply.hpp
+++ b/ngraph/core/include/ngraph/op/multiply.hpp
@@ -88,13 +88,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Multiply;
-        NGRAPH_SUPPRESS_DEPRECATED_END
-    } // namespace op
-
-    NGRAPH_DEPRECATED("This operator was deprecated and will be removed with v0 operation.")
-    NGRAPH_API
-    std::shared_ptr<Node> operator*(const Output<Node>& arg0, const Output<Node>& arg1);
+    }     // namespace op
 } // namespace ngraph
diff --git a/ngraph/core/include/ngraph/op/not_equal.hpp b/ngraph/core/include/ngraph/op/not_equal.hpp
index 19ccd637bb631b..dfd551ddbefdca 100644
--- a/ngraph/core/include/ngraph/op/not_equal.hpp
+++ b/ngraph/core/include/ngraph/op/not_equal.hpp
@@ -22,41 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise not-equal operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::NotEqual instead of it.") NGRAPH_API NotEqual
-                : public util::BinaryElementwiseComparison
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"NotEqual", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a not-equal operation.
-                NotEqual()
-                    : util::BinaryElementwiseComparison(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs a not-equal operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                NotEqual(const Output<Node>& arg0,
-                         const Output<Node>& arg1,
-                         const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise not-equal operation.
@@ -86,9 +51,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::NotEqual;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/op_version_tbl.hpp b/ngraph/core/include/ngraph/op/op_version_tbl.hpp
index 9b65f94d195d6b..c87a4cd0fcb250 100644
--- a/ngraph/core/include/ngraph/op/op_version_tbl.hpp
+++ b/ngraph/core/include/ngraph/op/op_version_tbl.hpp
@@ -31,7 +31,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 NGRAPH_OP(Abs, ngraph::op::v0, 0)
 NGRAPH_OP(Acos, ngraph::op::v0, 0)
 NGRAPH_OP(Acosh, ngraph::op::v3, 3)
-NGRAPH_OP(Add, ngraph::op::v0, 0)
 NGRAPH_OP(Add, ngraph::op::v1, 1)
 NGRAPH_OP(Asin, ngraph::op::v0, 0)
 NGRAPH_OP(Asinh, ngraph::op::v3, 3)
@@ -60,13 +59,11 @@ NGRAPH_OP(DeformableConvolution, ngraph::op::v1, 1)
 NGRAPH_OP(DeformablePSROIPooling, ngraph::op::v1, 1)
 NGRAPH_OP(DepthToSpace, ngraph::op::v0, 0)
 NGRAPH_OP(DetectionOutput, ngraph::op::v0, 0)
-NGRAPH_OP(Divide, ngraph::op::v0, 0)
 NGRAPH_OP(Divide, ngraph::op::v1, 1)
 NGRAPH_OP(Elu, ngraph::op::v0, 0)
 NGRAPH_OP(EmbeddingBagOffsetsSum, ngraph::op::v3, 3)
 NGRAPH_OP(EmbeddingBagPackedSum, ngraph::op::v3, 3)
 NGRAPH_OP(EmbeddingSegmentsSum, ngraph::op::v3, 3)
-NGRAPH_OP(Equal, ngraph::op::v0, 0)
 NGRAPH_OP(Equal, ngraph::op::v1, 1)
 NGRAPH_OP(Erf, ngraph::op::v0, 0)
 NGRAPH_OP(Exp, ngraph::op::v0, 0)
@@ -80,9 +77,7 @@ NGRAPH_OP(Gather, ngraph::op::v1, 1)
 NGRAPH_OP(GatherND, ngraph::op::v5, 5)
 NGRAPH_OP(GatherTree, ngraph::op::v1, 1)
 NGRAPH_OP(Gelu, ngraph::op::v0, 0)
-NGRAPH_OP(Greater, ngraph::op::v0, 0)
 NGRAPH_OP(Greater, ngraph::op::v1, 1)
-NGRAPH_OP(GreaterEq, ngraph::op::v0, 0)
 NGRAPH_OP(GreaterEqual, ngraph::op::v1, 1)
 NGRAPH_OP(GroupConvolution, ngraph::op::v1, 1)
 NGRAPH_OP(GroupConvolutionBackpropData, ngraph::op::v1, 1)
@@ -92,9 +87,7 @@ NGRAPH_OP(Interpolate, ngraph::op::v4, 4)
 NGRAPH_OP(LRN, ngraph::op::v0, 0)
 NGRAPH_OP(LSTMCell, ngraph::op::v0, 0)
 NGRAPH_OP(LSTMSequence, ngraph::op::v0, 0)
-NGRAPH_OP(Less, ngraph::op::v0, 0)
 NGRAPH_OP(Less, ngraph::op::v1, 1)
-NGRAPH_OP(LessEq, ngraph::op::v0, 0)
 NGRAPH_OP(LessEqual, ngraph::op::v1, 1)
 NGRAPH_OP(Log, ngraph::op::v0, 0)
 NGRAPH_OP(LogicalAnd, ngraph::op::v1, 1)
@@ -104,26 +97,21 @@ NGRAPH_OP(LogicalXor, ngraph::op::v1, 1)
 NGRAPH_OP(MVN, ngraph::op::v0, 0)
 NGRAPH_OP(MatMul, ngraph::op::v0, 0)
 NGRAPH_OP(MaxPool, ngraph::op::v1, 1)
-NGRAPH_OP(Maximum, ngraph::op::v0, 0)
 NGRAPH_OP(Maximum, ngraph::op::v1, 1)
-NGRAPH_OP(Minimum, ngraph::op::v0, 0)
 NGRAPH_OP(Minimum, ngraph::op::v1, 1)
 NGRAPH_OP(Mod, ngraph::op::v1, 1)
-NGRAPH_OP(Multiply, ngraph::op::v0, 0)
 NGRAPH_OP(Multiply, ngraph::op::v1, 1)
 NGRAPH_OP(Negative, ngraph::op::v0, 0)
 NGRAPH_OP(NonMaxSuppression, ngraph::op::v1, 1)
 NGRAPH_OP(NonMaxSuppression, ngraph::op::v3, 3)
 NGRAPH_OP(NonZero, ngraph::op::v3, 3)
 NGRAPH_OP(NormalizeL2, ngraph::op::v0, 0)
-NGRAPH_OP(NotEqual, ngraph::op::v0, 0)
 NGRAPH_OP(NotEqual, ngraph::op::v1, 1)
 NGRAPH_OP(OneHot, ngraph::op::v1, 1)
 NGRAPH_OP(PRelu, ngraph::op::v0, 0)
 NGRAPH_OP(PSROIPooling, ngraph::op::v0, 0)
 NGRAPH_OP(Pad, ngraph::op::v1, 1)
 NGRAPH_OP(Parameter, ngraph::op::v0, 0)
-NGRAPH_OP(Power, ngraph::op::v0, 0)
 NGRAPH_OP(Power, ngraph::op::v1, 1)
 NGRAPH_OP(PriorBox, ngraph::op::v0, 0)
 NGRAPH_OP(PriorBoxClustered, ngraph::op::v0, 0)
@@ -150,7 +138,6 @@ NGRAPH_OP(Round, ngraph::op::v5, 5)
 NGRAPH_OP(ROIAlign, ngraph::op::v3, 3)
 NGRAPH_OP(ScatterElementsUpdate, ngraph::op::v3, 3)
 NGRAPH_OP(ScatterUpdate, ngraph::op::v3, 3)
-NGRAPH_OP(Select, ngraph::op::v0, 0)
 NGRAPH_OP(Select, ngraph::op::v1, 1)
 NGRAPH_OP(Selu, ngraph::op::v0, 0)
 NGRAPH_OP(ShapeOf, ngraph::op::v0, 0)
@@ -168,7 +155,6 @@ NGRAPH_OP(Sqrt, ngraph::op::v0, 0)
 NGRAPH_OP(SquaredDifference, ngraph::op::v0, 0)
 NGRAPH_OP(Squeeze, ngraph::op::v0, 0)
 NGRAPH_OP(StridedSlice, ngraph::op::v1, 1)
-NGRAPH_OP(Subtract, ngraph::op::v0, 0)
 NGRAPH_OP(Subtract, ngraph::op::v1, 1)
 NGRAPH_OP(Tan, ngraph::op::v0, 0)
 NGRAPH_OP(Tanh, ngraph::op::v0, 0)
diff --git a/ngraph/core/include/ngraph/op/power.hpp b/ngraph/core/include/ngraph/op/power.hpp
index 6eecca88d84f74..0a385c15eba7e2 100644
--- a/ngraph/core/include/ngraph/op/power.hpp
+++ b/ngraph/core/include/ngraph/op/power.hpp
@@ -22,54 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            // clang-format off
-            /// \brief Elementwise exponentiation operation.
-            ///
-            /// ## Inputs
-            ///
-            /// |        | Type                              | Description                                            |
-            /// | ------ | --------------------------------- | ------------------------------------------------------ |
-            /// | `arg0` | \f$N[d_1,\dots,d_n]~(n \geq 0)\f$ | A tensor of any shape and numeric element type.        |
-            /// | `arg1` | \f$N[d_1,\dots,d_n]~(n \geq 0)\f$ | A tensor of the same shape and element type as `arg0`. |
-            ///
-            /// ## Output
-            ///
-            /// | Type                   | Description                                                                                                    |
-            /// | ---------------------- | -------------------------------------------------------------------------------------------------------------- |
-            /// | \f$N[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \texttt{arg0}[i_1,\dots,i_n]^{\texttt{arg1}[i_1,\dots,i_n]}\f$ |
-            // clang-format on
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Power instead of it.") NGRAPH_API Power
-                : public util::BinaryElementwiseArithmetic
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Power", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                Power()
-                    : util::BinaryElementwiseArithmetic(AutoBroadcastSpec::NONE)
-                {
-                }
-                /// \brief Constructs an exponentiation operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Power(const Output<Node>& arg0,
-                      const Output<Node>& arg1,
-                      const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             // clang-format off
@@ -114,9 +66,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Power;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/include/ngraph/op/select.hpp b/ngraph/core/include/ngraph/op/select.hpp
index 14f4ef4da3f11c..6a8639cd1a152c 100644
--- a/ngraph/core/include/ngraph/op/select.hpp
+++ b/ngraph/core/include/ngraph/op/select.hpp
@@ -22,51 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            // clang-format off
-            /// \brief Elementwise selection operation.
-            ///
-            /// ## Inputs
-            ///
-            /// |        | Type                                          | Description                                                  |
-            /// | ------ | --------------------------------------------- | ------------------------------------------------------------ |
-            /// | `arg0` | \f$\texttt{bool}[d_1,\dots,d_n]~(n \geq 0)\f$ | A tensor of any shape, with element `bool`.                  |
-            /// | `arg1` | \f$E[d_1,\dots,d_n]~(n \geq 0)\f$             | A tensor of the same shape as `arg0`, with any element type. |
-            /// | `arg2` | \f$E[d_1,\dots,d_n]~(n \geq 0)\f$             | A tensor of the same shape and element type as `arg1`.       |
-            ///
-            /// ## Output
-            ///
-            /// | Type                   | Description                                                                                                                                                             |
-            /// | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-            /// | \f$E[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \texttt{arg1}[i_1,\dots,i_n]\text{ if }\texttt{arg0}[i_1,\dots,i_n] \neq 0\text{, else }\texttt{arg2}[i_1,\dots,i_n]\f$ |
-            // clang-format on
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Select instead of it.") NGRAPH_API Select : public Op
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Select", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a selection operation.
-                Select() = default;
-                /// \brief Constructs a selection operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param arg2 Node that produces the third input tensor.
-                Select(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       const Output<Node>& arg2);
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                void validate_and_infer_types() override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        } // namespace v0
-
         namespace v1
         {
             // clang-format off
@@ -129,8 +84,5 @@ namespace ngraph
                 AutoBroadcastSpec m_auto_broadcast;
             };
         } // namespace v1
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Select;
-        NGRAPH_SUPPRESS_DEPRECATED_END
-    } // namespace op
+    }     // namespace op
 } // namespace ngraph
diff --git a/ngraph/core/include/ngraph/op/shuffle_channels.hpp b/ngraph/core/include/ngraph/op/shuffle_channels.hpp
index aa7daf7c6d4e39..dae47013a5e120 100644
--- a/ngraph/core/include/ngraph/op/shuffle_channels.hpp
+++ b/ngraph/core/include/ngraph/op/shuffle_channels.hpp
@@ -30,7 +30,7 @@ namespace ngraph
         namespace v0
         {
             /// \brief Permutes data in the channel dimension of the input
-            class NGRAPH_API ShuffleChannels : public ngraph::op::util::FusedOp
+            class NGRAPH_API ShuffleChannels : public Op
             {
             public:
                 static constexpr NodeTypeInfo type_info{"ShuffleChannels", 0};
@@ -53,15 +53,16 @@ namespace ngraph
                 bool visit_attributes(AttributeVisitor& visitor) override;
                 size_t get_zero_based_axis() const;
 
-                virtual void pre_validate_and_infer_types() override;
-
-                virtual OutputVector decompose_op() const override;
+                virtual void validate_and_infer_types() override;
 
                 virtual std::shared_ptr<Node>
                     clone_with_new_inputs(const OutputVector& new_args) const override;
 
                 int64_t get_axis() const { return m_axis; }
                 int64_t get_group() const { return m_group; }
+                bool evaluate(const HostTensorVector& outputs,
+                              const HostTensorVector& inputs) const override;
+
             private:
                 /// \brief Generates a shape required to permute the data
                 ///
diff --git a/ngraph/core/include/ngraph/op/space_to_batch.hpp b/ngraph/core/include/ngraph/op/space_to_batch.hpp
index a355e54427648e..483a1a709fbb9c 100644
--- a/ngraph/core/include/ngraph/op/space_to_batch.hpp
+++ b/ngraph/core/include/ngraph/op/space_to_batch.hpp
@@ -60,6 +60,9 @@ namespace ngraph
                 std::shared_ptr<Node>
                     clone_with_new_inputs(const OutputVector& new_args) const override;
                 bool visit_attributes(AttributeVisitor& visitor) override;
+
+                bool evaluate(const HostTensorVector& outputs,
+                              const HostTensorVector& inputs) const override;
             };
         }
         using v1::SpaceToBatch;
diff --git a/ngraph/core/include/ngraph/op/space_to_depth.hpp b/ngraph/core/include/ngraph/op/space_to_depth.hpp
index 2a35d833d16f10..3af3fbbb50cf61 100644
--- a/ngraph/core/include/ngraph/op/space_to_depth.hpp
+++ b/ngraph/core/include/ngraph/op/space_to_depth.hpp
@@ -18,6 +18,7 @@
 
 #include "ngraph/node.hpp"
 #include "ngraph/op/util/fused_op.hpp"
+#include "ngraph/runtime/host_tensor.hpp"
 
 NGRAPH_SUPPRESS_DEPRECATED_START
 
@@ -34,7 +35,7 @@ namespace ngraph
             ///
             ///        Output node produces a tensor with shape:
             ///        [N, C * blocksize * blocksize, H / blocksize, W / blocksize]
-            class NGRAPH_API SpaceToDepth : public ngraph::op::util::FusedOp
+            class NGRAPH_API SpaceToDepth : public Op
             {
             public:
                 static constexpr NodeTypeInfo type_info{"SpaceToDepth", 0};
@@ -65,11 +66,13 @@ namespace ngraph
                 bool visit_attributes(AttributeVisitor& visitor) override;
                 std::size_t get_block_size() const { return m_blocksize; }
                 SpaceToDepthMode get_mode() const { return m_mode; }
-                virtual OutputVector decompose_op() const override;
-
+                void validate_and_infer_types() override;
                 virtual std::shared_ptr<Node>
                     clone_with_new_inputs(const OutputVector& new_args) const override;
 
+                bool evaluate(const HostTensorVector& outputs,
+                              const HostTensorVector& inputs) const override;
+
             protected:
                 std::size_t m_blocksize;
                 SpaceToDepthMode m_mode;
diff --git a/ngraph/core/include/ngraph/op/subtract.hpp b/ngraph/core/include/ngraph/op/subtract.hpp
index 5e5a0f121118ea..5bac3d12d84722 100644
--- a/ngraph/core/include/ngraph/op/subtract.hpp
+++ b/ngraph/core/include/ngraph/op/subtract.hpp
@@ -22,42 +22,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            /// \brief Elementwise subtraction operation.
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Subtract instead of it.") NGRAPH_API Subtract
-                : public util::BinaryElementwiseArithmetic
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Subtract", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                Subtract()
-                    : util::BinaryElementwiseArithmetic(AutoBroadcastSpec::NONE)
-                {
-                }
-
-                /// \brief Constructs a subtraction operation.
-                ///
-                /// \param arg0 Node that produces the first input tensor.
-                /// \param arg1 Node that produces the second input tensor.
-                /// \param auto_broadcast Auto broadcast specification
-                Subtract(const Output<Node>& arg0,
-                         const Output<Node>& arg1,
-                         const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec());
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-
-        } // namespace v0
-
         namespace v1
         {
             /// \brief Elementwise subtraction operation.
@@ -87,14 +51,5 @@ namespace ngraph
                               const HostTensorVector& inputs) const override;
             };
         } // namespace v1
-
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Subtract;
-        NGRAPH_SUPPRESS_DEPRECATED_END
-    } // namespace op
-
-    NGRAPH_DEPRECATED("This operator was deprecated and will be removed with v0 operation.")
-    NGRAPH_API
-    std::shared_ptr<ngraph::Node> operator-(const Output<ngraph::Node> arg0,
-                                            const Output<ngraph::Node> arg1);
+    }     // namespace op
 } // namespace ngraph
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/autobroadcast_binop.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/autobroadcast_binop.hpp
index 70410784226478..345555b6a8426b 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/autobroadcast_binop.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/autobroadcast_binop.hpp
@@ -388,19 +388,23 @@ namespace ngraph
                         Shape arg1_padded_shape = arg1_shape;
                         Shape arg2_padded_shape = arg2_shape;
 
-                        while (arg1_padded_shape.size() < arg2_padded_shape.size())
+                        size_t max_shape_size = std::max({arg0_padded_shape.size(),
+                                                          arg1_padded_shape.size(),
+                                                          arg2_padded_shape.size()});
+
+                        while (arg0_padded_shape.size() < max_shape_size)
                         {
-                            arg1_padded_shape.insert(arg1_padded_shape.begin(), 1);
+                            arg0_padded_shape.insert(arg0_padded_shape.begin(), 1);
                         }
 
-                        while (arg2_padded_shape.size() < arg1_padded_shape.size())
+                        while (arg1_padded_shape.size() < max_shape_size)
                         {
-                            arg2_padded_shape.insert(arg2_padded_shape.begin(), 1);
+                            arg1_padded_shape.insert(arg1_padded_shape.begin(), 1);
                         }
 
-                        while (arg0_padded_shape.size() < arg1_padded_shape.size())
+                        while (arg2_padded_shape.size() < max_shape_size)
                         {
-                            arg0_padded_shape.insert(arg0_padded_shape.begin(), 1);
+                            arg2_padded_shape.insert(arg2_padded_shape.begin(), 1);
                         }
 
                         Shape arg0_squeezed_shape;
@@ -411,7 +415,7 @@ namespace ngraph
                         AxisSet arg2_squeezed_axes;
                         Shape output_shape;
 
-                        for (size_t i = 0; i < arg1_padded_shape.size(); i++)
+                        for (size_t i = 0; i < max_shape_size; i++)
                         {
                             if (arg1_padded_shape[i] == 1)
                             {
@@ -440,9 +444,9 @@ namespace ngraph
                                 arg0_squeezed_shape.push_back(arg0_padded_shape[i]);
                             }
 
-                            output_shape.push_back(arg1_padded_shape[i] == 1
-                                                       ? arg2_padded_shape[i]
-                                                       : arg1_padded_shape[i]);
+                            output_shape.push_back(std::max({arg0_padded_shape[i],
+                                                             arg2_padded_shape[i],
+                                                             arg1_padded_shape[i]}));
                         }
 
                         CoordinateTransform arg0_transform(arg0_squeezed_shape);
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/avg_pool.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/avg_pool.hpp
index 6daa4024040fe2..5a0e05851d7a10 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/avg_pool.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/avg_pool.hpp
@@ -223,8 +223,8 @@ namespace ngraph
 
                         if (in_bounds || include_padding_in_avg_computation)
                         {
-                            T v =
-                                in_bounds ? arg[input_batch_transform.index(input_batch_coord)] : 0;
+                            T v = in_bounds ? arg[input_batch_transform.index(input_batch_coord)]
+                                            : static_cast<T>(0);
                             result += v;
                             n_elements++;
                         }
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/convolution.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/convolution.hpp
index 2c002ec10055dd..ea64698820418a 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/convolution.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/convolution.hpp
@@ -19,10 +19,13 @@
 #include <cfenv>
 #include <cmath>
 #include <functional>
+#include <numeric>
 
 #include "ngraph/axis_vector.hpp"
 #include "ngraph/coordinate_transform.hpp"
+#include "ngraph/runtime/reference/concat.hpp"
 #include "ngraph/runtime/reference/reverse.hpp"
+#include "ngraph/runtime/reference/split.hpp"
 #include "ngraph/util.hpp"
 
 namespace ngraph
@@ -72,21 +75,8 @@ namespace ngraph
                                      size_t filter_out_channel_axis,
                                      size_t filter_in_channel_axis,
                                      size_t out_batch_axis,
-                                     size_t out_channel_axis,
-                                     const float* input_scale = nullptr,
-                                     const INPUT* input_zero_point = nullptr,
-                                     const float* filter_scale = nullptr,
-                                     const FILTER* filter_zero_point = nullptr,
-                                     const float* output_scale = nullptr,
-                                     const OUTPUT* output_zero_point = nullptr)
+                                     size_t out_channel_axis)
             {
-                bool is_quantized = false;
-                if (input_scale && input_zero_point && filter_scale && filter_zero_point &&
-                    output_scale && output_zero_point)
-                {
-                    is_quantized = true;
-                }
-
                 auto old_mode = std::fegetround();
                 std::fesetround(FE_TONEAREST);
                 // Comments throughout assume without loss of generality that:
@@ -236,11 +226,7 @@ namespace ngraph
                             {
                                 ACCUMULATION in_v = static_cast<ACCUMULATION>(in[in_idx]);
                                 ACCUMULATION f_v = static_cast<ACCUMULATION>(filter[filter_idx]);
-                                if (is_quantized)
-                                {
-                                    in_v = in_v - static_cast<ACCUMULATION>(*input_zero_point);
-                                    f_v = f_v - static_cast<ACCUMULATION>(*filter_zero_point);
-                                }
+
                                 result += in_v * f_v;
                                 in_idx += in_channel_stride;
                                 filter_idx += filter_in_channel_stride;
@@ -249,17 +235,8 @@ namespace ngraph
                         ++in_it;
                         ++filter_it;
                     }
-                    if (is_quantized)
-                    {
-                        float scale = *input_scale * *filter_scale / *output_scale;
-                        out[out_transform.index(out_coord)] =
-                            static_cast<OUTPUT>(std::round(static_cast<float>(result) * scale)) +
-                            *output_zero_point;
-                    }
-                    else
-                    {
-                        out[out_transform.index(out_coord)] = result;
-                    }
+
+                    out[out_transform.index(out_coord)] = result;
                 }
                 std::fesetround(old_mode);
             }
@@ -278,13 +255,7 @@ namespace ngraph
                              const Strides& filter_dilation,
                              const CoordinateDiff& in_pad_below,
                              const CoordinateDiff& in_pad_above,
-                             const Strides& in_dilation,
-                             const float* input_scale = nullptr,
-                             const INPUT* input_zero_point = nullptr,
-                             const float* filter_scale = nullptr,
-                             const FILTER* filter_zero_point = nullptr,
-                             const float* output_scale = nullptr,
-                             const OUTPUT* output_zero_point = nullptr)
+                             const Strides& in_dilation)
 
             {
                 general_convolution<INPUT, FILTER, OUTPUT, ACCUMULATION>(in,
@@ -303,48 +274,7 @@ namespace ngraph
                                                                          0,
                                                                          1,
                                                                          0,
-                                                                         1,
-                                                                         input_scale,
-                                                                         input_zero_point,
-                                                                         filter_scale,
-                                                                         filter_zero_point,
-                                                                         output_scale,
-                                                                         output_zero_point);
-            }
-
-            template <typename INPUT,
-                      typename OUTPUT,
-                      typename FILTER,
-                      typename ACCUMULATION = typename widen<FILTER>::type>
-            void convolution_backprop_filter(const INPUT* in,
-                                             const OUTPUT* delta_out,
-                                             FILTER* delta_filter,
-                                             const Shape& in_shape,
-                                             const Shape& out_shape,
-                                             const Shape& filter_shape,
-                                             const Strides& filter_dilation,
-                                             const Strides& stride,
-                                             const CoordinateDiff& in_pad_below,
-                                             const CoordinateDiff& backprop_in_pad_above,
-                                             const Strides& in_dilation)
-            {
-                general_convolution<INPUT, OUTPUT, FILTER, ACCUMULATION>(in,
-                                                                         delta_out,
-                                                                         delta_filter,
-                                                                         in_shape,
-                                                                         out_shape,
-                                                                         filter_shape,
-                                                                         filter_dilation,
-                                                                         stride,
-                                                                         in_pad_below,
-                                                                         backprop_in_pad_above,
-                                                                         in_dilation,
-                                                                         1,
-                                                                         0,
-                                                                         1,
-                                                                         0,
-                                                                         1,
-                                                                         0);
+                                                                         1);
             }
 
             template <typename OUTPUT,
@@ -359,15 +289,16 @@ namespace ngraph
                                          const Shape& in_shape,
                                          const Strides& in_dilation,
                                          const Strides& filter_dilation,
-                                         const CoordinateDiff& backward_delta_out_pad_below,
-                                         const CoordinateDiff& backward_delta_out_pad_above,
+                                         const CoordinateDiff& forward_in_pad_bellow,
+                                         const CoordinateDiff& forward_in_pad_above,
                                          const Strides& stride)
             {
                 // Note that we only reverse the spatial dimensions here (loop
                 // starts at 2)
                 std::vector<INPUT> reversed(shape_size(filter_shape));
                 AxisSet reverse_axes;
-                for (size_t i = 2; i < filter_shape.size(); ++i)
+                size_t reverse_axes_start = 2;
+                for (size_t i = reverse_axes_start; i < filter_shape.size(); ++i)
                 {
                     reverse_axes.insert(i);
                 }
@@ -377,6 +308,35 @@ namespace ngraph
                         filter_shape,
                         reverse_axes,
                         sizeof(FILTER));
+                size_t filter_out_channel_axis = 1;
+                size_t filter_in_channel_axis = 0;
+
+                // Compute backward pad out pad bellow
+                size_t spatial_dim_count = in_shape.size() - 2;
+
+                CoordinateDiff backward_delta_out_pad_below;
+                backward_delta_out_pad_below.resize(spatial_dim_count);
+
+                for (size_t i = 0; i < spatial_dim_count; i++)
+                {
+                    backward_delta_out_pad_below[i] =
+                        (static_cast<ptrdiff_t>(filter_shape[i + 2]) - 1) * filter_dilation[i] -
+                        forward_in_pad_bellow[i];
+                }
+                // Compute backward pad out pad above
+                CoordinateDiff backward_delta_out_pad_above;
+                backward_delta_out_pad_above.resize(spatial_dim_count);
+
+                for (size_t i = 0; i < spatial_dim_count; i++)
+                {
+                    backward_delta_out_pad_above[i] =
+                        (static_cast<ptrdiff_t>(filter_shape[i + 2]) - 1) * filter_dilation[i] +
+                        ((forward_in_pad_bellow[i] + ((in_shape[i + 2]) - 1) * in_dilation[i] +
+                          forward_in_pad_above[i] -
+                          (static_cast<ptrdiff_t>(filter_shape[i + 2]) - 1) * filter_dilation[i]) %
+                         stride[i]) -
+                        forward_in_pad_above[i];
+                }
 
                 general_convolution<OUTPUT, FILTER, INPUT, ACCUMULATION>(
                     delta_out,
@@ -392,8 +352,8 @@ namespace ngraph
                     stride,
                     0,
                     1,
-                    1,
-                    0,
+                    filter_out_channel_axis,
+                    filter_in_channel_axis,
                     0,
                     1);
             }
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/detection_output.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/detection_output.hpp
index d2499be7cf45a8..9d372b62c633ad 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/detection_output.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/detection_output.hpp
@@ -33,11 +33,11 @@ namespace ngraph
             private:
                 struct NormalizedBBox
                 {
-                    dataType xmin = 0;
-                    dataType ymin = 0;
-                    dataType xmax = 0;
-                    dataType ymax = 0;
-                    dataType size = 0;
+                    dataType xmin = dataType(0);
+                    dataType ymin = dataType(0);
+                    dataType xmax = dataType(0);
+                    dataType ymax = dataType(0);
+                    dataType size = dataType(0);
                 };
                 using LabelBBox = std::map<int, std::vector<NormalizedBBox>>;
 
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/extract_image_patches.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/extract_image_patches.hpp
index 4e16e1c0f75ebf..b78780a3a1b5f7 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/extract_image_patches.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/extract_image_patches.hpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include <ngraph/ops.hpp>
 #include "ngraph/shape_util.hpp"
 
 namespace ngraph
@@ -10,12 +11,12 @@ namespace ngraph
     {
         namespace reference
         {
-            template <typename T, typename U>
-            void extractImagePatches(const op::ExtractImagePatches* extImgPatches,
-                                     const T* input,
-                                     T* out,
-                                     const Shape& inShape,
-                                     const Shape& outShape)
+            template <typename T>
+            void extract_image_patches(const std::shared_ptr<op::ExtractImagePatches> extImgPatches,
+                                       const T* input,
+                                       T* out,
+                                       const Shape& inShape,
+                                       const Shape& outShape)
             {
                 const size_t dimsSize = inShape.size();
                 const size_t BATCH = 0, CHANNEL = 1, HIGHT = 0, WIDTH = 1;
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/fake_quantize.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/fake_quantize.hpp
new file mode 100644
index 00000000000000..bf5f2203b070a8
--- /dev/null
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/fake_quantize.hpp
@@ -0,0 +1,247 @@
+//*****************************************************************************
+// Copyright 2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "ngraph/shape.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            namespace
+            {
+                std::vector<size_t>
+                    calc_broadcast_index_offset(const std::vector<size_t>& memory_offsets,
+                                                const std::vector<size_t>& broadcast_shape)
+                {
+                    std::vector<size_t> broadcast_offsets(broadcast_shape.size(), 0);
+                    for (int i = broadcast_shape.size() - 2; i >= 0; --i)
+                    {
+                        if (broadcast_shape[i] == 1)
+                        {
+                            broadcast_offsets[i] = memory_offsets[i];
+                        }
+                    }
+                    if (!std::all_of(broadcast_shape.begin(),
+                                     broadcast_shape.end(),
+                                     [](size_t i) { return i == 1; }) &&
+                        broadcast_shape.back() == 1)
+                    {
+                        broadcast_offsets[broadcast_offsets.size() - 1] = 1;
+                    }
+                    if (broadcast_shape.back() == 1)
+                    {
+                        for (int i = broadcast_shape.size() - 1; i >= 0; --i)
+                        {
+                            if (broadcast_shape[i] != 1)
+                            {
+                                broadcast_offsets[i] = memory_offsets[i] - 1;
+                                break;
+                            }
+                        }
+                    }
+                    return broadcast_offsets;
+                }
+
+                size_t calc_full_broadcast_offset(const std::vector<size_t>& current_dims,
+                                                  const std::vector<size_t>& offsets)
+                {
+                    size_t full_index_offset = 0;
+                    for (size_t i = 0; i < current_dims.size(); ++i)
+                    {
+                        full_index_offset += offsets[i] * current_dims[i];
+                    }
+                    return full_index_offset;
+                }
+
+                void align_shape_sizes(Shape& shape, size_t target_size)
+                {
+                    for (size_t i = 0; i < shape.size() - target_size; ++i)
+                    {
+                        shape.insert(shape.begin(), 1);
+                    }
+                }
+
+                void increment_current_dim(std::vector<size_t>& current_dims,
+                                           const std::vector<size_t>& shape,
+                                           size_t incremented_dim_number)
+                {
+                    current_dims[incremented_dim_number] += 1;
+                    if (current_dims[incremented_dim_number] == shape[incremented_dim_number] &&
+                        incremented_dim_number != 0)
+                    {
+                        for (size_t i = incremented_dim_number; i < shape.size(); ++i)
+                        {
+                            current_dims[i] = 0;
+                        }
+                        increment_current_dim(current_dims, shape, incremented_dim_number - 1);
+                    }
+                }
+            }
+
+            template <typename T>
+            void fake_quantize(const T* arg,
+                               const T* in_low,
+                               const T* in_high,
+                               const T* out_low,
+                               const T* out_high,
+                               T* out,
+                               const Shape& arg_shape,
+                               const Shape& _in_low_shape,
+                               const Shape& _in_high_shape,
+                               const Shape& _out_low_shape,
+                               const Shape& _out_high_shape,
+                               size_t levels)
+            {
+                auto initial_round_mode = std::fegetround();
+                std::fesetround(FE_TONEAREST);
+                Shape in_low_shape(_in_low_shape);
+                Shape in_high_shape(_in_high_shape);
+                Shape out_low_shape(_out_low_shape);
+                Shape out_high_shape(_out_high_shape);
+
+                if (in_low_shape.size() > arg_shape.size() ||
+                    in_high_shape.size() > arg_shape.size() ||
+                    out_low_shape.size() > arg_shape.size() ||
+                    out_high_shape.size() > arg_shape.size())
+                {
+                    throw std::runtime_error(
+                        std::string("Tensors with inout\\output ranges should have rank less or "
+                                    "equal to data tensor rank equal to ") +
+                        std::to_string(arg_shape.size()));
+                }
+
+                std::vector<size_t> arg_memory_offsets(arg_shape.size(), 0);
+                for (int i = arg_shape.size() - 2; i >= 0; i--)
+                {
+                    arg_memory_offsets[i] = std::accumulate(
+                        arg_shape.begin() + i + 1, arg_shape.end(), 1, std::multiplies<size_t>());
+                }
+                align_shape_sizes(in_low_shape, arg_shape.size());
+                align_shape_sizes(in_high_shape, arg_shape.size());
+                align_shape_sizes(out_low_shape, arg_shape.size());
+                align_shape_sizes(out_high_shape, arg_shape.size());
+
+                std::vector<size_t> in_low_offsets, in_high_offsets, out_low_offsets,
+                    out_high_offsets;
+                bool in_low_trivial_broadcast = false;
+                bool in_high_trivial_broadcast = false;
+                bool out_low_trivial_broadcast = false;
+                bool out_high_trivial_broadcast = false;
+                bool in_low_aligned = false;
+                bool in_high_aligned = false;
+                bool out_low_aligned = false;
+                bool out_high_aligned = false;
+
+                auto check_trivial_broadcast =
+                    [&arg_shape, &arg_memory_offsets](Shape& shape_to_check,
+                                                      std::vector<size_t>& target_offsets,
+                                                      bool& trivial_broadcast,
+                                                      bool& aligned) {
+                        if (shape_size(shape_to_check) == 1 || shape_size(shape_to_check) == 0)
+                        {
+                            trivial_broadcast = true;
+                        }
+                        else if (shape_to_check == arg_shape)
+                        {
+                            aligned = true;
+                        }
+                        else
+                        {
+                            target_offsets =
+                                calc_broadcast_index_offset(arg_memory_offsets, shape_to_check);
+                        }
+                    };
+                check_trivial_broadcast(
+                    in_low_shape, in_low_offsets, in_low_trivial_broadcast, in_low_aligned);
+                check_trivial_broadcast(
+                    in_high_shape, in_high_offsets, in_high_trivial_broadcast, in_high_aligned);
+                check_trivial_broadcast(
+                    out_low_shape, out_low_offsets, out_low_trivial_broadcast, out_low_aligned);
+                check_trivial_broadcast(
+                    out_high_shape, out_high_offsets, out_high_trivial_broadcast, out_high_aligned);
+
+                std::vector<size_t> current_dim(arg_shape.size(), 0);
+
+                auto get_value = [&current_dim](bool is_trivial_broadcast,
+                                                bool is_aligned,
+                                                const T* data,
+                                                size_t idx,
+                                                const std::vector<size_t>& offsets) {
+                    T val;
+                    if (is_aligned)
+                    {
+                        val = data[idx];
+                    }
+                    else if (is_trivial_broadcast)
+                    {
+                        val = data[0];
+                    }
+                    else
+                    {
+                        size_t index_offset = calc_full_broadcast_offset(current_dim, offsets);
+                        if (index_offset != 0)
+                        {
+                            NGRAPH_CHECK(idx >= index_offset, "Incorrect index offset value!");
+                        }
+                        val = data[idx - index_offset];
+                    }
+                    return val;
+                };
+                for (size_t i = 0; i < shape_size(arg_shape); ++i)
+                {
+                    T in_low_val = get_value(
+                        in_low_trivial_broadcast, in_low_aligned, in_low, i, in_low_offsets);
+                    T in_high_val = get_value(
+                        in_high_trivial_broadcast, in_high_aligned, in_high, i, in_high_offsets);
+                    T out_low_val = get_value(
+                        out_low_trivial_broadcast, out_low_aligned, out_low, i, out_low_offsets);
+                    T out_high_val = get_value(out_high_trivial_broadcast,
+                                               out_high_aligned,
+                                               out_high,
+                                               i,
+                                               out_high_offsets);
+                    if (arg[i] <= in_low_val)
+                    {
+                        out[i] = out_low_val;
+                    }
+                    else if (arg[i] > in_high_val)
+                    {
+                        out[i] = out_high_val;
+                    }
+                    else
+                    {
+                        out[i] = nearbyint((arg[i] - in_low_val) / (in_high_val - in_low_val) *
+                                           (levels - 1)) /
+                                     (levels - 1) * (out_high_val - out_low_val) +
+                                 out_low_val;
+                    }
+                    increment_current_dim(current_dim, arg_shape, arg_shape.size() - 1);
+                }
+                std::fesetround(initial_round_mode);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/mvn.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/mvn.hpp
new file mode 100644
index 00000000000000..66f07b460ba271
--- /dev/null
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/mvn.hpp
@@ -0,0 +1,76 @@
+//*****************************************************************************
+// Copyright 2017-2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cstddef>
+#include <ngraph/runtime/reference/mean.hpp>
+#include <ngraph/runtime/reference/multiply.hpp>
+#include <ngraph/runtime/reference/sqrt.hpp>
+#include <ngraph/runtime/reference/subtract.hpp>
+#include <ngraph/runtime/reference/sum.hpp>
+#include <ngraph/shape.hpp>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T>
+            void mvn(const T* arg,
+                     T* out,
+                     const Shape& in_shape,
+                     bool normalize_variance,
+                     AxisSet reduction_axes,
+                     double eps)
+            {
+                auto reduced_shape = reduce(in_shape, reduction_axes, true);
+                std::vector<T> tmp_buffer(shape_size(in_shape));
+                mean(arg, tmp_buffer.data(), in_shape, reduction_axes, true);
+                subtract(arg,
+                         tmp_buffer.data(),
+                         out,
+                         in_shape,
+                         reduced_shape,
+                         op::AutoBroadcastSpec::NUMPY);
+
+                if (normalize_variance)
+                {
+                    multiply(out, out, tmp_buffer.data(), shape_size(in_shape));
+                    std::vector<T> mean_value(shape_size(reduced_shape));
+                    mean(tmp_buffer.data(), mean_value.data(), in_shape, reduction_axes, true);
+
+                    add(mean_value.data(),
+                        std::vector<T>(shape_size(reduced_shape), eps).data(),
+                        tmp_buffer.data(),
+                        reduced_shape,
+                        reduced_shape,
+                        op::AutoBroadcastSpec::NUMPY);
+                    sqrt(tmp_buffer.data(), tmp_buffer.data(), shape_size(reduced_shape));
+
+                    divide(out,
+                           tmp_buffer.data(),
+                           out,
+                           in_shape,
+                           reduced_shape,
+                           op::AutoBroadcastSpec::NUMPY,
+                           true);
+                }
+            }
+        } // namespace reference
+    }     // namespace runtime
+} // namespace ngraph
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/roi_pooling.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/roi_pooling.hpp
index 8ea19700e4d526..de3f61b93cf162 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/roi_pooling.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/roi_pooling.hpp
@@ -109,8 +109,9 @@ namespace ngraph
 
                                     // Define an empty pooling region to be zero
                                     bool is_empty = (h_end <= h_start) || (w_end <= w_start);
-                                    output[pool_index] =
-                                        is_empty ? 0 : std::numeric_limits<T>::lowest();
+                                    output[pool_index] = is_empty
+                                                             ? static_cast<T>(0)
+                                                             : std::numeric_limits<T>::lowest();
 
                                     for (unsigned int h = h_start; h < h_end; h++)
                                     {
@@ -138,8 +139,10 @@ namespace ngraph
                         T roi_height = (roi_h_end - roi_h_start) * (height - 1);
                         T roi_width = (roi_w_end - roi_w_start) * (width - 1);
 
-                        T roi_height_scale = (pooled_h > 1) ? roi_height / (pooled_h - 1) : 0;
-                        T roi_width_scale = (pooled_w > 1) ? roi_width / (pooled_w - 1) : 0;
+                        T roi_height_scale =
+                            (pooled_h > 1) ? roi_height / (pooled_h - 1) : static_cast<T>(0);
+                        T roi_width_scale =
+                            (pooled_w > 1) ? roi_width / (pooled_w - 1) : static_cast<T>(0);
 
                         for (unsigned int c = 0; c < channels; c++)
                         {
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/select.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/select.hpp
index 3f6da667026666..3c81504aeaec20 100644
--- a/ngraph/core/reference/include/ngraph/runtime/reference/select.hpp
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/select.hpp
@@ -32,11 +32,14 @@ namespace ngraph
                         const T* arg1,
                         const T* arg2,
                         T* out,
-                        size_t count) // TODO: using char for bool, is this right?
+                        size_t arg0_count,
+                        size_t arg1_count,
+                        size_t arg2_count,
+                        size_t out_count)
             {
-                for (size_t i = 0; i < count; i++)
+                for (size_t i = 0; i < out_count; i++)
                 {
-                    out[i] = arg0[i] ? arg1[i] : arg2[i];
+                    out[i] = arg0[i % arg0_count] ? arg1[i % arg1_count] : arg2[i % arg2_count];
                 }
             }
 
diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/squared_difference.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/squared_difference.hpp
new file mode 100644
index 00000000000000..ec663788d606d6
--- /dev/null
+++ b/ngraph/core/reference/include/ngraph/runtime/reference/squared_difference.hpp
@@ -0,0 +1,46 @@
+//*****************************************************************************
+// Copyright 2017-2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+
+#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
+#include "ngraph/shape_util.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T>
+            void squared_difference(const T* arg0,
+                                    const T* arg1,
+                                    T* out,
+                                    const Shape& arg0_shape,
+                                    const Shape& arg1_shape,
+                                    const op::AutoBroadcastSpec& broadcast_spec)
+            {
+                autobroadcast_binop(
+                    arg0, arg1, out, arg0_shape, arg1_shape, broadcast_spec, [](T x, T y) -> T {
+                        return (x - y) * (x - y);
+                    });
+            }
+        }
+    }
+}
diff --git a/ngraph/core/src/graph_util.cpp b/ngraph/core/src/graph_util.cpp
index a7c10582a3e2b6..688eeabf80b821 100644
--- a/ngraph/core/src/graph_util.cpp
+++ b/ngraph/core/src/graph_util.cpp
@@ -186,8 +186,8 @@ void ngraph::replace_node(std::shared_ptr<Node> target,
             input.replace_source_output(replacement->output(output_order[i]));
         }
     }
-
     replacement->add_node_control_dependents(target);
+    replacement->add_node_control_dependencies(target);
     target->clear_control_dependents();
 }
 
@@ -212,6 +212,7 @@ void ngraph::replace_node(const std::shared_ptr<Node>& target,
         if (replacement_nodes.find(replacement_node) == replacement_nodes.end())
         {
             replacement_node->add_node_control_dependents(target);
+            replacement_node->add_node_control_dependencies(target);
             target->transfer_provenance_tags(replacement_node);
             replacement_nodes.insert(replacement_node);
         }
diff --git a/ngraph/core/src/op/add.cpp b/ngraph/core/src/op/add.cpp
index bcf0c34284762a..132686defe0072 100644
--- a/ngraph/core/src/op/add.cpp
+++ b/ngraph/core/src/op/add.cpp
@@ -24,35 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ------------------------------- v0 ------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Add::type_info;
-
-op::v0::Add::Add(const Output<Node>& arg0,
-                 const Output<Node>& arg1,
-                 const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Add::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Add>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
-bool op::v0::Add::visit_attributes(AttributeVisitor& visitor)
-{
-    BinaryElementwiseArithmetic::visit_attributes(visitor);
-    return true;
-}
-
-shared_ptr<Node> ngraph::operator+(const Output<Node>& arg0, const Output<Node>& arg1)
-{
-    return make_shared<op::Add>(arg0, arg1);
-}
-
 namespace add
 {
     template <element::Type_t ET>
@@ -107,12 +78,6 @@ namespace add
     }
 }
 
-bool op::v0::Add::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Add::evaluate");
-    return add::evaluate_add(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ------------------------------- v1 ------------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::Add, "Add", 1, util::BinaryElementwiseArithmetic);
@@ -141,4 +106,4 @@ bool op::v1::Add::evaluate(const HostTensorVector& outputs, const HostTensorVect
 {
     OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Add::evaluate");
     return add::evaluate_add(inputs[0], inputs[1], outputs[0], get_autob());
-}
+}
\ No newline at end of file
diff --git a/ngraph/core/src/op/batch_to_space.cpp b/ngraph/core/src/op/batch_to_space.cpp
index 9cc2e620276174..142ec4628af6ad 100644
--- a/ngraph/core/src/op/batch_to_space.cpp
+++ b/ngraph/core/src/op/batch_to_space.cpp
@@ -16,13 +16,19 @@
 #include <cmath>
 #include <cstddef>
 #include <memory>
+#include <numeric>
 #include <ops.hpp>
 
 #include "ngraph/builder/make_constant.hpp"
 #include "ngraph/node.hpp"
 #include "ngraph/op/batch_to_space.hpp"
+#include "ngraph/opsets/opset3.hpp"
 #include "ngraph/shape.hpp"
 
+#include "ngraph/runtime/opt_kernel/reshape.hpp"
+#include "ngraph/runtime/reference/strided_slice.hpp"
+#include "ngraph/slice_plan.hpp"
+
 using namespace std;
 using namespace ngraph;
 
@@ -134,3 +140,115 @@ bool ngraph::op::v1::BatchToSpace::visit_attributes(ngraph::AttributeVisitor& vi
 {
     return true;
 }
+
+bool ngraph::op::v1::BatchToSpace::evaluate(const HostTensorVector& outputs,
+                                            const HostTensorVector& inputs) const
+{
+    auto data = inputs[0];
+    size_t elem_size = data->get_element_type().size();
+
+    if (data->get_partial_shape().is_dynamic())
+    {
+        return false;
+    }
+    auto data_shape = data->get_shape();
+
+    if (!(data->get_shape().size() == 4 || data->get_shape().size() == 5))
+    {
+        return false;
+    }
+    size_t block_values_size = shape_size(inputs[1]->get_shape());
+    const auto* block_values = inputs[1]->get_data_ptr<int64_t>();
+    const auto* crops_begin_values = inputs[2]->get_data_ptr<int64_t>();
+    const auto* crops_end_values = inputs[3]->get_data_ptr<int64_t>();
+
+    Shape dispersed_shape(1);
+    dispersed_shape.insert(dispersed_shape.end(), data_shape.begin(), data_shape.end());
+    std::vector<size_t> axes_order(block_values_size + 1);
+    std::vector<size_t> plain_axes_order(block_values_size + 1);
+    std::iota(plain_axes_order.begin(), plain_axes_order.end(), 0);
+    Shape squeezed_shape(data_shape.begin(), data_shape.end());
+    if (squeezed_shape.size() > block_values_size)
+    {
+        return false;
+    }
+
+    auto* flat_data = data->get_data_ptr<char>();
+    std::vector<char> dispersed_data(shape_size(data_shape) * elem_size);
+
+    Shape post_transpose_shape(axes_order.size());
+    std::vector<char> post_transpose_data(shape_size(data_shape) * elem_size);
+
+    for (size_t block_idx = 1; block_idx < block_values_size; ++block_idx)
+    {
+        dispersed_shape[0] = block_values[block_idx];
+        dispersed_shape[1] /= block_values[block_idx];
+        runtime::opt_kernel::reshape(flat_data,
+                                     dispersed_data.data(),
+                                     data_shape,
+                                     plain_axes_order,
+                                     dispersed_shape,
+                                     elem_size);
+
+        size_t val = 1;
+        for (size_t axis_idx = 0; axis_idx <= block_values_size; ++axis_idx)
+        {
+            if ((block_idx + 1) == axis_idx)
+            {
+                axes_order[axis_idx] = 0;
+            }
+            else
+            {
+                axes_order[axis_idx] = val;
+                val++;
+            }
+        }
+        for (size_t axis_idx = 0; axis_idx < axes_order.size(); ++axis_idx)
+        {
+            post_transpose_shape[axis_idx] = dispersed_shape[axes_order[axis_idx]];
+        }
+
+        runtime::opt_kernel::reshape(dispersed_data.data(),
+                                     post_transpose_data.data(),
+                                     dispersed_shape,
+                                     axes_order,
+                                     post_transpose_shape,
+                                     elem_size);
+        squeezed_shape[0] = dispersed_shape[1];
+        squeezed_shape[block_idx] *= block_values[block_idx];
+        dispersed_shape[block_idx + 1] = squeezed_shape[block_idx];
+        runtime::opt_kernel::reshape(post_transpose_data.data(),
+                                     flat_data,
+                                     post_transpose_shape,
+                                     plain_axes_order,
+                                     squeezed_shape,
+                                     elem_size);
+        data_shape = squeezed_shape;
+    }
+
+    std::vector<int64_t> upperbounds_values(data_shape.size());
+    for (size_t i = 0; i < data_shape.size(); ++i)
+    {
+        upperbounds_values[i] = data_shape[i] - crops_end_values[i];
+    }
+
+    std::vector<size_t> begin_mask(data_shape.size(), 0);
+    std::vector<size_t> end_mask(data_shape.size(), 0);
+
+    std::vector<int64_t> begins(shape_size(inputs[2]->get_shape()));
+    begins.assign(crops_begin_values, crops_begin_values + shape_size(inputs[2]->get_shape()));
+
+    std::vector<int64_t> default_strides(begins.size(), 1);
+    SlicePlan slice_plan = make_slice_plan(data_shape,
+                                           begins,
+                                           upperbounds_values,
+                                           default_strides,
+                                           begin_mask,
+                                           end_mask,
+                                           AxisSet(),
+                                           AxisSet(),
+                                           AxisSet());
+    runtime::reference::strided_slice(
+        flat_data, outputs[0]->get_data_ptr<char>(), data_shape, slice_plan, elem_size);
+    return true;
+}
\ No newline at end of file
diff --git a/ngraph/core/src/op/clamp.cpp b/ngraph/core/src/op/clamp.cpp
index 669117d99bc852..91d26b5edde6fe 100644
--- a/ngraph/core/src/op/clamp.cpp
+++ b/ngraph/core/src/op/clamp.cpp
@@ -221,8 +221,8 @@ OutputVector op::Clamp::decompose_op() const
     default: throw runtime_error("Unsupported data type in op Clamp"); break;
     }
 
-    auto max = make_shared<op::Maximum>(clamp_min, data);
-    return {make_shared<op::Minimum>(clamp_max, max)};
+    auto max = make_shared<op::v1::Maximum>(clamp_min, data);
+    return {make_shared<op::v1::Minimum>(clamp_max, max)};
 }
 
 shared_ptr<Node> op::Clamp::clone_with_new_inputs(const OutputVector& new_args) const
diff --git a/ngraph/core/src/op/depth_to_space.cpp b/ngraph/core/src/op/depth_to_space.cpp
index 277ab856338935..5e0b5424e5e019 100644
--- a/ngraph/core/src/op/depth_to_space.cpp
+++ b/ngraph/core/src/op/depth_to_space.cpp
@@ -16,12 +16,17 @@
 #include <cmath>
 #include <cstddef>
 #include <memory>
+#include <ngraph/op/constant.hpp>
+#include <ngraph/ops.hpp>
+#include <numeric>
 
 #include "depth_to_space.hpp"
 #include "ngraph/builder/reshape.hpp"
 #include "ngraph/node.hpp"
 #include "ngraph/shape.hpp"
 
+#include "ngraph/runtime/opt_kernel/reshape.hpp"
+
 using namespace std;
 using namespace ngraph;
 
@@ -32,7 +37,7 @@ NGRAPH_RTTI_DEFINITION(op::v0::DepthToSpace, "DepthToSpace", 0);
 op::DepthToSpace::DepthToSpace(const Output<Node>& data,
                                const DepthToSpaceMode& mode,
                                const size_t block_size)
-    : FusedOp({data})
+    : Op({data})
     , m_blocksize(block_size)
     , m_mode(mode)
 {
@@ -53,23 +58,73 @@ bool op::DepthToSpace::visit_attributes(AttributeVisitor& visitor)
     return true;
 }
 
-OutputVector op::DepthToSpace::decompose_op() const
+shared_ptr<Node> op::DepthToSpace::clone_with_new_inputs(const OutputVector& new_args) const
+{
+    if (new_args.size() != 1)
+    {
+        throw ngraph_error("Incorrect number of new arguments");
+    }
+    return make_shared<DepthToSpace>(new_args.at(0), m_mode, m_blocksize);
+}
+
+void op::DepthToSpace::validate_and_infer_types()
 {
+    PartialShape data_pshape = get_input_partial_shape(0);
+
+    const auto& data_type = get_input_element_type(0);
+
     auto data = input_value(0);
-    auto data_shape = data.get_shape();
 
-    NODE_VALIDATION_CHECK(this,
-                          (data_shape.size() >= 3),
-                          "The input tensor with rank lower than 3 is not supported (input rank: ",
-                          data_shape.size(),
-                          ")");
+    if (data_pshape.is_static())
+    {
+        const auto& data_shape = data.get_shape();
+
+        NODE_VALIDATION_CHECK(
+            this,
+            !(data_shape.size() < 3),
+            "The input tensor with rank lower than 3 is not supported (input rank: ",
+            data_shape.size(),
+            ")");
 
-    if (data_shape.size() == 3)
+        auto divider = std::pow(m_blocksize, data_shape.size() - 2);
+        NODE_VALIDATION_CHECK(this, (divider), "DepthToSpace: The divider must not be 0");
+
+        NODE_VALIDATION_CHECK(this,
+                              m_blocksize > 0 && !(data_shape[1] % m_blocksize),
+                              "DepthToSpace: The input data's 'channels' axis size: ",
+                              data_shape[1],
+                              " must be a equivalent to 'block_size'^'spatial_dims': ",
+                              divider);
+
+        auto out_shape = data_shape;
+        out_shape[1] /= divider;
+        for (size_t i = 2; i < out_shape.size(); i++)
+        {
+            out_shape[i] *= m_blocksize;
+        }
+
+        set_output_size(1);
+        set_output_type(0, data_type, out_shape);
+    }
+    else
     {
-        // Insert batch axis
-        data_shape.insert(data_shape.begin(), 1);
-        data = builder::opset1::reshape(data, data_shape);
+        set_output_type(0, data_type, PartialShape::dynamic());
     }
+}
+
+bool op::DepthToSpace::evaluate(const HostTensorVector& outputs,
+                                const HostTensorVector& inputs) const
+{
+    const auto& data = inputs[0];
+    const auto& out = outputs[0];
+    const auto& out_shape = out->get_shape();
+    size_t elem_size = data->get_element_type().size();
+
+    if (data->get_partial_shape().is_dynamic())
+    {
+        return false;
+    }
+    auto data_shape = data->get_shape();
     const size_t n_dim = data_shape.at(0);
     const size_t c_dim = data_shape.at(1);
     const size_t spatial_dim_index = 2;
@@ -111,8 +166,6 @@ OutputVector op::DepthToSpace::decompose_op() const
     case DepthToSpaceMode::DEPTH_FIRST:
     {
         dispersed_shape.insert(dispersed_shape.begin() + 1, c_flat);
-        flat_node = builder::opset1::reshape(data, dispersed_shape);
-
         axes_order.push_back(1);
         for (int i = spatial_dim_index; i < data_shape.size(); ++i)
         {
@@ -120,7 +173,6 @@ OutputVector op::DepthToSpace::decompose_op() const
             axes_order.push_back(i);
         }
 
-        flat_node = builder::opset1::reorder_axes(flat_node, axes_order);
         break;
     }
     // x' = reshape(data, [N, block_size, block_size, ..., block_size, C / (block_size ^ K), D1, D2,
@@ -132,36 +184,56 @@ OutputVector op::DepthToSpace::decompose_op() const
     default:
     {
         dispersed_shape.insert(dispersed_shape.begin() + spatial_dims + 1, c_flat);
-        flat_node = builder::opset1::reshape(data, dispersed_shape);
-
         axes_order.push_back(spatial_dims + 1);
         for (int i = 2; i < data_shape.size(); ++i)
         {
             axes_order.push_back(spatial_dims + i);
             axes_order.push_back(i - 1);
         }
-        flat_node = builder::opset1::reorder_axes(flat_node, axes_order);
+        break;
+    }
     }
+    std::vector<size_t> plain_axes_order(data_shape.size());
+    std::iota(plain_axes_order.begin(), plain_axes_order.end(), 0);
+    std::vector<char> dispersed_data(shape_size(data_shape) * elem_size);
+    std::vector<char> transposed_data(shape_size(data_shape) * elem_size);
+
+    runtime::opt_kernel::reshape(data->get_data_ptr<char>(),
+                                 dispersed_data.data(),
+                                 data_shape,
+                                 plain_axes_order,
+                                 dispersed_shape,
+                                 elem_size);
+
+    Shape post_transpose_shape(axes_order.size());
+    for (size_t axis_idx = 0; axis_idx < axes_order.size(); ++axis_idx)
+    {
+        post_transpose_shape[axis_idx] = dispersed_shape[axes_order[axis_idx]];
     }
+    runtime::opt_kernel::reshape(dispersed_data.data(),
+                                 transposed_data.data(),
+                                 dispersed_shape,
+                                 axes_order,
+                                 post_transpose_shape,
+                                 elem_size);
+
     Shape squeezed_shape{n_dim, c_flat};
     for (int i = spatial_dim_index; i < data_shape.size(); ++i)
     {
         squeezed_shape.push_back(data_shape.at(i) * bs);
     }
-    flat_node = builder::opset1::reshape(flat_node, squeezed_shape);
-
-    return OutputVector{flat_node};
-}
-
-shared_ptr<Node> op::DepthToSpace::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    if (new_args.size() != 1)
+    for (size_t i = plain_axes_order.size() - 1; i < post_transpose_shape.size() - 1; ++i)
     {
-        throw ngraph_error("Incorrect number of new arguments");
+        plain_axes_order.push_back(plain_axes_order[i] + 1);
     }
-    return make_shared<DepthToSpace>(new_args.at(0), m_mode, m_blocksize);
+    runtime::opt_kernel::reshape(transposed_data.data(),
+                                 out->get_data_ptr<char>(),
+                                 post_transpose_shape,
+                                 plain_axes_order,
+                                 squeezed_shape,
+                                 elem_size);
+    return true;
 }
-
 namespace ngraph
 {
     template <>
diff --git a/ngraph/core/src/op/divide.cpp b/ngraph/core/src/op/divide.cpp
index b69c51d9588ff8..688c32709202d1 100644
--- a/ngraph/core/src/op/divide.cpp
+++ b/ngraph/core/src/op/divide.cpp
@@ -26,47 +26,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ------------------------------ v0 -------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Divide::type_info;
-
-op::v0::Divide::Divide(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-op::v0::Divide::Divide(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       bool pythondiv,
-                       const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-    , m_pythondiv(pythondiv)
-{
-    constructor_validate_and_infer_types();
-}
-
-bool op::v0::Divide::visit_attributes(AttributeVisitor& visitor)
-{
-    BinaryElementwiseArithmetic::visit_attributes(visitor);
-    visitor.on_attribute("m_pythondiv", m_pythondiv);
-    return true;
-}
-
-shared_ptr<Node> op::v0::Divide::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Divide>(
-        new_args.at(0), new_args.at(1), this->is_pythondiv(), this->get_autob());
-}
-
-shared_ptr<Node> ngraph::operator/(const Output<Node>& arg0, const Output<Node>& arg1)
-{
-    return make_shared<op::v0::Divide>(arg0, arg1);
-}
-
 namespace divide
 {
     template <element::Type_t ET>
@@ -116,12 +75,6 @@ namespace divide
     }
 }
 
-bool op::v0::Divide::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Divide::evaluate");
-    return divide::evaluate_divide(inputs[0], inputs[1], outputs[0], get_autob(), is_pythondiv());
-}
-
 // ------------------------------ v1 -------------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::Divide, "Divide", 1, util::BinaryElementwiseArithmetic);
diff --git a/ngraph/core/src/op/embeddingbag_offsets_sum.cpp b/ngraph/core/src/op/embeddingbag_offsets_sum.cpp
index b4e27c8f697236..93ad5087f17c51 100644
--- a/ngraph/core/src/op/embeddingbag_offsets_sum.cpp
+++ b/ngraph/core/src/op/embeddingbag_offsets_sum.cpp
@@ -69,4 +69,4 @@ shared_ptr<Node>
     {
         throw ngraph_error("Incorrect number of arguments");
     }
-}
+}
\ No newline at end of file
diff --git a/ngraph/core/src/op/equal.cpp b/ngraph/core/src/op/equal.cpp
index bb93b8fb1e69c4..3e7ae54343665c 100644
--- a/ngraph/core/src/op/equal.cpp
+++ b/ngraph/core/src/op/equal.cpp
@@ -24,24 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-//------------------------------- v0 -------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Equal::type_info;
-
-op::v0::Equal::Equal(const Output<Node>& arg0,
-                     const Output<Node>& arg1,
-                     const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseComparison(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Equal::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Equal>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace equal
 {
     template <element::Type_t ET>
@@ -88,12 +70,6 @@ namespace equal
     }
 }
 
-bool op::v0::Equal::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Equal::evaluate");
-    return equal::evaluate_equal(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 //------------------------------- v1 -------------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::Equal, "Equal", 1);
diff --git a/ngraph/core/src/op/fake_quantize.cpp b/ngraph/core/src/op/fake_quantize.cpp
index 5ed3f6fd7a9704..98e1b25dd131bf 100644
--- a/ngraph/core/src/op/fake_quantize.cpp
+++ b/ngraph/core/src/op/fake_quantize.cpp
@@ -130,19 +130,21 @@ OutputVector op::FakeQuantize::decompose_op() const
                          vector<size_t>(shape_size(input_data_shape), m_levels - 1));
 
     // map the number of quantization levels to the nGraph's quantization and dequantization scales
-    const auto quant_scale = (input_high - input_low) / levels_minus_one;
-    const auto dequant_scale = (output_high - output_low) / levels_minus_one;
+    const auto quant_scale = std::make_shared<op::v1::Divide>(
+        std::make_shared<op::v1::Subtract>(input_high, input_low), levels_minus_one);
+    const auto dequant_scale = std::make_shared<op::v1::Divide>(
+        std::make_shared<op::v1::Subtract>(output_high, output_low), levels_minus_one);
 
     // zero_point type needs to match the quantization output type
     const auto zero_point = Constant::create(element::Type_t::i32, data.get_shape(), {0.0});
     const auto axes = get_default_order(input_data_shape);
 
     // clip the input data to the range <input_low;input_high>
-    data =
-        std::make_shared<op::Minimum>(input_high, std::make_shared<op::Maximum>(input_low, data));
+    data = std::make_shared<op::v1::Minimum>(input_high,
+                                             std::make_shared<op::v1::Maximum>(input_low, data));
 
     // shift the input data so that it contains only positive values (and zeros)
-    data = data - input_low;
+    data = std::make_shared<op::v1::Subtract>(data, input_low);
 
     shared_ptr<Node> quantized_data =
         make_shared<op::Quantize>(data,
@@ -155,10 +157,10 @@ OutputVector op::FakeQuantize::decompose_op() const
     quantized_data = make_shared<op::Convert>(quantized_data, input_data_type);
 
     // dequantization without using the Dequantize op (just a multiplication by the dequant_scale)
-    const auto dequantized_data = quantized_data * dequant_scale;
+    const auto dequantized_data = make_shared<op::v1::Multiply>(quantized_data, dequant_scale);
 
     // shift the results so that they fall into the <output_low;output_high> range
-    return {dequantized_data + output_low};
+    return {std::make_shared<op::v1::Add>(dequantized_data, output_low)};
 }
 
 shared_ptr<Node> op::FakeQuantize::clone_with_new_inputs(const OutputVector& new_args) const
diff --git a/ngraph/core/src/op/gelu.cpp b/ngraph/core/src/op/gelu.cpp
index 786f124fdf6ec1..1f9a628c841160 100644
--- a/ngraph/core/src/op/gelu.cpp
+++ b/ngraph/core/src/op/gelu.cpp
@@ -58,7 +58,11 @@ OutputVector op::Gelu::decompose_op() const
     shared_ptr<ngraph::Node> sqrt_two =
         builder::make_constant(data.get_element_type(), data.get_shape(), std::sqrt(2.0));
 
-    return {half * data * (one + make_shared<ngraph::op::Erf>(data / sqrt_two))};
+    shared_ptr<ngraph::Node> add = std::make_shared<op::v1::Add>(
+        one, make_shared<ngraph::op::Erf>(std::make_shared<op::v1::Divide>(data, sqrt_two)));
+    shared_ptr<ngraph::Node> multiply = std::make_shared<op::v1::Multiply>(half, data);
+
+    return {std::make_shared<op::v1::Multiply>(multiply, add)};
 }
 
 shared_ptr<Node> op::Gelu::clone_with_new_inputs(const OutputVector& new_args) const
diff --git a/ngraph/core/src/op/greater.cpp b/ngraph/core/src/op/greater.cpp
index ae7a0afeaa7ce3..ece748b5500cb1 100644
--- a/ngraph/core/src/op/greater.cpp
+++ b/ngraph/core/src/op/greater.cpp
@@ -24,24 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-//-------------------------------------- v0 ------------------------------------
-
-constexpr NodeTypeInfo op::v0::Greater::type_info;
-
-op::v0::Greater::Greater(const Output<Node>& arg0,
-                         const Output<Node>& arg1,
-                         const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseComparison(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Greater::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Greater>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace greaterop
 {
     template <element::Type_t ET>
@@ -88,13 +70,6 @@ namespace greaterop
     }
 }
 
-bool op::v0::Greater::evaluate(const HostTensorVector& outputs,
-                               const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Greater::evaluate");
-    return greaterop::evaluate_greater(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 //-------------------------------------- v1 ------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::Greater, "Greater", 1);
diff --git a/ngraph/core/src/op/greater_eq.cpp b/ngraph/core/src/op/greater_eq.cpp
index f3ce8cbb1801da..348f52594630f9 100644
--- a/ngraph/core/src/op/greater_eq.cpp
+++ b/ngraph/core/src/op/greater_eq.cpp
@@ -24,24 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-//---------------------------------- v0 ----------------------------------------
-
-constexpr NodeTypeInfo op::v0::GreaterEq::type_info;
-
-op::v0::GreaterEq::GreaterEq(const Output<Node>& arg0,
-                             const Output<Node>& arg1,
-                             const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseComparison(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::GreaterEq::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::GreaterEq>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace greater_equalop
 {
     template <element::Type_t ET>
@@ -88,13 +70,6 @@ namespace greater_equalop
     }
 }
 
-bool op::v0::GreaterEq::evaluate(const HostTensorVector& outputs,
-                                 const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::GreaterEq::evaluate");
-    return greater_equalop::evaluate_greater_equal(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 //---------------------------------- v1 ----------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::GreaterEqual, "GreaterEqual", 1);
diff --git a/ngraph/core/src/op/less.cpp b/ngraph/core/src/op/less.cpp
index 61ac88cba1cf96..ad0d2745aacc2e 100644
--- a/ngraph/core/src/op/less.cpp
+++ b/ngraph/core/src/op/less.cpp
@@ -24,24 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ----------------------------- v0 --------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Less::type_info;
-
-op::v0::Less::Less(const Output<Node>& arg0,
-                   const Output<Node>& arg1,
-                   const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseComparison(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Less::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Less>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace lessop
 {
     template <element::Type_t ET>
@@ -88,12 +70,6 @@ namespace lessop
     }
 }
 
-bool op::v0::Less::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Less::evaluate");
-    return lessop::evaluate_less(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ----------------------------- v1 --------------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::Less, "Less", 1);
diff --git a/ngraph/core/src/op/less_eq.cpp b/ngraph/core/src/op/less_eq.cpp
index 5aa4acf11d6ae7..26b3dbeca63d64 100644
--- a/ngraph/core/src/op/less_eq.cpp
+++ b/ngraph/core/src/op/less_eq.cpp
@@ -94,27 +94,3 @@ bool op::v1::LessEqual::evaluate(const HostTensorVector& outputs,
     OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::LessEqual::evaluate");
     return less_equalop::evaluate_less_equal(inputs[0], inputs[1], outputs[0], get_autob());
 }
-
-// ---------------------------------- v0 ---------------------------------------
-
-constexpr NodeTypeInfo op::v0::LessEq::type_info;
-
-op::v0::LessEq::LessEq(const Output<Node>& arg0,
-                       const Output<Node>& arg1,
-                       const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseComparison(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::LessEq::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<v0::LessEq>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
-bool op::v0::LessEq::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::LessEq::evaluate");
-    return less_equalop::evaluate_less_equal(inputs[0], inputs[1], outputs[0], get_autob());
-}
diff --git a/ngraph/core/src/op/maximum.cpp b/ngraph/core/src/op/maximum.cpp
index 8095847be923b2..604d527807ee50 100644
--- a/ngraph/core/src/op/maximum.cpp
+++ b/ngraph/core/src/op/maximum.cpp
@@ -32,22 +32,6 @@ using namespace ngraph;
 
 // ------------------------------------ v0 -------------------------------------
 
-constexpr NodeTypeInfo op::v0::Maximum::type_info;
-
-op::v0::Maximum::Maximum(const Output<Node>& arg0,
-                         const Output<Node>& arg1,
-                         const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Maximum::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Maximum>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace maximumop
 {
     template <element::Type_t ET>
@@ -92,13 +76,6 @@ namespace maximumop
     }
 }
 
-bool op::v0::Maximum::evaluate(const HostTensorVector& outputs,
-                               const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Maximum::evaluate");
-    return maximumop::evaluate_maximum(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ------------------------------------ v1 -------------------------------------
 
 constexpr NodeTypeInfo op::v1::Maximum::type_info;
diff --git a/ngraph/core/src/op/minimum.cpp b/ngraph/core/src/op/minimum.cpp
index 9520fc2c33c90b..8e3a89919633ad 100644
--- a/ngraph/core/src/op/minimum.cpp
+++ b/ngraph/core/src/op/minimum.cpp
@@ -30,24 +30,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ------------------------------ v0 -------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Minimum::type_info;
-
-op::v0::Minimum::Minimum(const Output<Node>& arg0,
-                         const Output<Node>& arg1,
-                         const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Minimum::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Minimum>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace minimumop
 {
     template <element::Type_t ET>
@@ -92,13 +74,6 @@ namespace minimumop
     }
 }
 
-bool op::v0::Minimum::evaluate(const HostTensorVector& outputs,
-                               const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Minimum::evaluate");
-    return minimumop::evaluate_minimum(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ------------------------------ v1 -------------------------------------------
 
 constexpr NodeTypeInfo op::v1::Minimum::type_info;
diff --git a/ngraph/core/src/op/multiply.cpp b/ngraph/core/src/op/multiply.cpp
index 4c8b4be21e8092..ea2edf4c69e238 100644
--- a/ngraph/core/src/op/multiply.cpp
+++ b/ngraph/core/src/op/multiply.cpp
@@ -24,24 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ------------------------------------ v0 -------------------------------------
-
-constexpr NodeTypeInfo op::v0::Multiply::type_info;
-
-op::v0::Multiply::Multiply(const Output<Node>& arg0,
-                           const Output<Node>& arg1,
-                           const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Multiply::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Multiply>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace multiplyop
 {
     template <element::Type_t ET>
@@ -88,6 +70,24 @@ namespace multiplyop
     }
 }
 
+// ------------------------------------ v0 -------------------------------------
+
+constexpr NodeTypeInfo op::v0::Multiply::type_info;
+
+op::v0::Multiply::Multiply(const Output<Node>& arg0,
+                           const Output<Node>& arg1,
+                           const AutoBroadcastSpec& auto_broadcast)
+    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
+{
+    constructor_validate_and_infer_types();
+}
+
+shared_ptr<Node> op::v0::Multiply::clone_with_new_inputs(const OutputVector& new_args) const
+{
+    check_new_args_count(this, new_args);
+    return make_shared<op::v0::Multiply>(new_args.at(0), new_args.at(1), this->get_autob());
+}
+
 bool op::v0::Multiply::evaluate(const HostTensorVector& outputs,
                                 const HostTensorVector& inputs) const
 {
@@ -119,10 +119,3 @@ bool op::v1::Multiply::evaluate(const HostTensorVector& outputs,
     OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Multiply::evaluate");
     return multiplyop::evaluate_multiply(inputs[0], inputs[1], outputs[0], get_autob());
 }
-
-// -----------------------------------------------------------------------------
-
-shared_ptr<Node> ngraph::operator*(const Output<Node>& arg0, const Output<Node>& arg1)
-{
-    return make_shared<op::Multiply>(arg0, arg1);
-}
diff --git a/ngraph/core/src/op/mvn.cpp b/ngraph/core/src/op/mvn.cpp
index 3b733a4cce59b0..8408e09939b2ee 100644
--- a/ngraph/core/src/op/mvn.cpp
+++ b/ngraph/core/src/op/mvn.cpp
@@ -79,8 +79,8 @@ OutputVector op::MVN::decompose_op() const
 
     // calculate mean normalization
     auto mean = builder::opset1::mean(data, m_reduction_axes);
-    auto mean_normalization =
-        data - builder::opset1::make_broadcast(mean, data_shape, m_reduction_axes);
+    auto mean_normalization = std::make_shared<op::v1::Subtract>(
+        data, builder::opset1::make_broadcast(mean, data_shape, m_reduction_axes));
 
     if (!m_normalize_variance)
     {
@@ -93,10 +93,10 @@ OutputVector op::MVN::decompose_op() const
         // add epsilon
         auto eps_node = op::Constant::create(
             data.get_element_type(), Output<Node>(variance).get_shape(), vector<double>{m_eps});
-        variance = std::make_shared<op::Sqrt>(variance + eps_node);
-
-        return OutputVector{mean_normalization / builder::opset1::make_broadcast(
-                                                     variance, data_shape, m_reduction_axes)};
+        variance = std::make_shared<op::Sqrt>(std::make_shared<op::v1::Add>(variance, eps_node));
+        return OutputVector{std::make_shared<op::v1::Divide>(
+            mean_normalization,
+            builder::opset1::make_broadcast(variance, data_shape, m_reduction_axes))};
     }
 }
 
diff --git a/ngraph/core/src/op/normalize_l2.cpp b/ngraph/core/src/op/normalize_l2.cpp
index 30fda2d47ee0c2..689810489365d7 100644
--- a/ngraph/core/src/op/normalize_l2.cpp
+++ b/ngraph/core/src/op/normalize_l2.cpp
@@ -108,7 +108,7 @@ OutputVector op::NormalizeL2::decompose_op() const
     const auto axes = input_value(1);
     Output<Node> norm = builder::opset1::l2_norm(data, axes, m_eps, builder_bias_mode, true);
 
-    data = make_shared<op::Divide>(data, norm, AutoBroadcastSpec(AutoBroadcastType::NUMPY));
+    data = make_shared<op::v1::Divide>(data, norm, AutoBroadcastSpec(AutoBroadcastType::NUMPY));
 
     return OutputVector{data};
 }
diff --git a/ngraph/core/src/op/not_equal.cpp b/ngraph/core/src/op/not_equal.cpp
index 44dae5c95cc765..0ea1b95d4a534d 100644
--- a/ngraph/core/src/op/not_equal.cpp
+++ b/ngraph/core/src/op/not_equal.cpp
@@ -24,24 +24,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ----------------------------------- v0 --------------------------------------
-
-constexpr NodeTypeInfo op::v0::NotEqual::type_info;
-
-op::v0::NotEqual::NotEqual(const Output<Node>& arg0,
-                           const Output<Node>& arg1,
-                           const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseComparison(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::NotEqual::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::NotEqual>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace not_equalop
 {
     template <element::Type_t ET>
@@ -88,13 +70,6 @@ namespace not_equalop
     }
 }
 
-bool op::v0::NotEqual::evaluate(const HostTensorVector& outputs,
-                                const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::NotEqual::evaluate");
-    return not_equalop::evaluate_not_equal(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ----------------------------------- v1 --------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::NotEqual, "NotEqual", 1);
diff --git a/ngraph/core/src/op/power.cpp b/ngraph/core/src/op/power.cpp
index 193c6ded5edf20..ff1cb9dd91b276 100644
--- a/ngraph/core/src/op/power.cpp
+++ b/ngraph/core/src/op/power.cpp
@@ -27,24 +27,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
 using namespace std;
 using namespace ngraph;
 
-// ------------------------------ v0 -------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Power::type_info;
-
-op::v0::Power::Power(const Output<Node>& arg0,
-                     const Output<Node>& arg1,
-                     const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Power::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Power>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
 namespace power
 {
     template <element::Type_t ET>
@@ -91,12 +73,6 @@ namespace power
     }
 }
 
-bool op::v0::Power::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Power::evaluate");
-    return power::evaluate_power(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ------------------------------ v1 -------------------------------------------
 
 constexpr NodeTypeInfo op::v1::Power::type_info;
diff --git a/ngraph/core/src/op/prelu.cpp b/ngraph/core/src/op/prelu.cpp
index f05d1a67a8f848..2b29c67dae4f23 100644
--- a/ngraph/core/src/op/prelu.cpp
+++ b/ngraph/core/src/op/prelu.cpp
@@ -75,14 +75,15 @@ OutputVector op::PRelu::decompose_op() const
     std::shared_ptr<ngraph::Node> zero_node = make_zero(data.get_element_type(), data.get_shape());
 
     std::shared_ptr<ngraph::Node> negative_map = std::make_shared<ngraph::op::Convert>(
-        std::make_shared<ngraph::op::Less>(data, zero_node), data.get_element_type());
+        std::make_shared<ngraph::op::v1::Less>(data, zero_node), data.get_element_type());
 
     std::shared_ptr<ngraph::Node> positive_map = std::make_shared<ngraph::op::Convert>(
-        std::make_shared<ngraph::op::Greater>(data, zero_node), data.get_element_type());
+        std::make_shared<ngraph::op::v1::Greater>(data, zero_node), data.get_element_type());
 
-    slope = negative_map * slope + positive_map;
+    slope = std::make_shared<op::v1::Multiply>(negative_map,
+                                               std::make_shared<op::v1::Add>(slope, positive_map));
 
-    return {data * slope};
+    return {std::make_shared<op::v1::Multiply>(data, slope)};
 }
 
 shared_ptr<Node> op::PRelu::clone_with_new_inputs(const OutputVector& new_args) const
diff --git a/ngraph/core/src/op/select.cpp b/ngraph/core/src/op/select.cpp
index 7352ec5be7bbc9..75e6d76d9f68f0 100644
--- a/ngraph/core/src/op/select.cpp
+++ b/ngraph/core/src/op/select.cpp
@@ -171,45 +171,3 @@ bool op::v1::Select::evaluate(const HostTensorVector& output_values,
 
     return detail::evaluate_select(output_values, input_values, autob, get_output_element_type(0));
 }
-
-constexpr NodeTypeInfo op::v0::Select::type_info;
-
-op::v0::Select::Select(const Output<Node>& arg0, const Output<Node>& arg1, const Output<Node>& arg2)
-    : Op({arg0, arg1, arg2})
-{
-    constructor_validate_and_infer_types();
-}
-
-void op::v0::Select::validate_and_infer_types()
-{
-    NODE_VALIDATION_CHECK(this,
-                          get_input_element_type(0).is_dynamic() ||
-                              get_input_element_type(0) == element::Type_t::boolean,
-                          "Argument 0 must have boolean element type (element type: ",
-                          get_input_element_type(0),
-                          ").");
-
-    PartialShape result_shape = get_input_partial_shape(0);
-
-    NODE_VALIDATION_CHECK(this,
-                          PartialShape::merge_into(result_shape, get_input_partial_shape(1)),
-                          "Argument shapes are inconsistent.");
-    NODE_VALIDATION_CHECK(this,
-                          PartialShape::merge_into(result_shape, get_input_partial_shape(2)),
-                          "Argument shapes are inconsistent.");
-
-    element::Type result_et;
-
-    NODE_VALIDATION_CHECK(
-        this,
-        element::Type::merge(result_et, get_input_element_type(1), get_input_element_type(2)),
-        "Argument 1 and 2 element types are inconsistent.");
-
-    set_output_type(0, result_et, result_shape);
-}
-
-shared_ptr<Node> op::v0::Select::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<v0::Select>(new_args.at(0), new_args.at(1), new_args.at(2));
-}
diff --git a/ngraph/core/src/op/shuffle_channels.cpp b/ngraph/core/src/op/shuffle_channels.cpp
index 9b9a23c004dd05..5f7bc350cb8457 100644
--- a/ngraph/core/src/op/shuffle_channels.cpp
+++ b/ngraph/core/src/op/shuffle_channels.cpp
@@ -13,10 +13,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //*****************************************************************************
+#include <numeric>
 
-#include "ngraph/op/shuffle_channels.hpp"
 #include "ngraph/attribute_visitor.hpp"
 #include "ngraph/builder/reshape.hpp"
+#include "ngraph/op/shuffle_channels.hpp"
+#include "ngraph/runtime/host_tensor.hpp"
+#include "ngraph/runtime/opt_kernel/reshape.hpp"
+#include "ngraph/type/element_type.hpp"
+#include "ngraph/type/element_type_traits.hpp"
 
 using namespace std;
 using namespace ngraph;
@@ -28,7 +33,7 @@ constexpr NodeTypeInfo op::ShuffleChannels::type_info;
 op::ShuffleChannels::ShuffleChannels(const Output<Node>& data,
                                      const int64_t axis,
                                      const int64_t group)
-    : FusedOp({data})
+    : Op({data})
     , m_axis(axis)
     , m_group{group}
 {
@@ -61,8 +66,9 @@ size_t op::ShuffleChannels::get_zero_based_axis() const
     }
 }
 
-void op::ShuffleChannels::pre_validate_and_infer_types()
+void op::ShuffleChannels::validate_and_infer_types()
 {
+    const auto& data_type = get_input_element_type(0);
     if (get_input_partial_shape(0).is_static())
     {
         const auto shape = get_input_shape(0);
@@ -84,18 +90,13 @@ void op::ShuffleChannels::pre_validate_and_infer_types()
             this,
             channel_dim_size % m_group == 0,
             "The channel dimension size has to be a multiple of the groups parameter value.");
+        set_output_size(1);
+        set_output_type(0, data_type, shape);
+    }
+    else
+    {
+        set_output_type(0, data_type, PartialShape::dynamic());
     }
-}
-
-OutputVector op::ShuffleChannels::decompose_op() const
-{
-    const auto data = input_value(0);
-    const auto& data_shape = data.get_shape();
-
-    const auto reshaped = builder::opset1::reshape(data, get_pre_shuffle_shape(data_shape));
-    const auto shuffled = builder::opset1::reorder_axes(reshaped, {0, 2, 1, 3});
-
-    return {builder::opset1::reshape(shuffled, data_shape)};
 }
 
 shared_ptr<Node> op::ShuffleChannels::clone_with_new_inputs(const OutputVector& new_args) const
@@ -137,3 +138,46 @@ Shape op::ShuffleChannels::get_pre_shuffle_shape(const Shape& data_shape) const
 
     return res;
 }
+
+bool op::ShuffleChannels::evaluate(const HostTensorVector& outputs,
+                                   const HostTensorVector& inputs) const
+{
+    const auto arg = inputs[0]->get_data_ptr<const char>();
+    auto out = outputs[0]->get_data_ptr<char>();
+    Shape data_shape = inputs[0]->get_shape();
+    const Shape& ds = data_shape;
+    size_t elem_size = inputs[0]->get_element_type().size();
+
+    Shape reshaped_out_shape(4, 1);
+    size_t axis_zb = m_axis >= 0 ? m_axis : m_axis + data_shape.size();
+    for (size_t i = 0; i < axis_zb; ++i)
+    {
+        reshaped_out_shape[0] *= ds[i];
+    }
+
+    reshaped_out_shape[1] = m_group;
+    reshaped_out_shape[2] = ds[axis_zb] / m_group;
+
+    for (size_t i = axis_zb + 1; i < ds.size(); ++i)
+    {
+        reshaped_out_shape[3] *= ds[i];
+    }
+    size_t data_size = shape_size(data_shape) * elem_size;
+
+    // first reshape from data_shape to reshaped_out_shape is skipped since it doesn't affect out
+    // data
+
+    Shape transpose_axes_order = {0, 2, 1, 3};
+    Shape transposed_shape(transpose_axes_order.size());
+
+    for (size_t i = 0; i < transpose_axes_order.size(); ++i)
+    {
+        transposed_shape[i] = data_shape.at(transpose_axes_order.at(i));
+    }
+    auto axis_vector = AxisVector{begin(transpose_axes_order), end(transpose_axes_order)};
+    runtime::opt_kernel::reshape(
+        arg, out, reshaped_out_shape, axis_vector, transposed_shape, elem_size);
+
+    // last reshape from transposed_shape to data_shape is skipped since it doesn't affect out data
+    return true;
+}
diff --git a/ngraph/core/src/op/space_to_batch.cpp b/ngraph/core/src/op/space_to_batch.cpp
index cc950a7cbca6de..c5aa1c583ac754 100644
--- a/ngraph/core/src/op/space_to_batch.cpp
+++ b/ngraph/core/src/op/space_to_batch.cpp
@@ -16,6 +16,7 @@
 #include <cmath>
 #include <cstddef>
 #include <memory>
+#include <numeric>
 
 #include "ngraph/builder/make_constant.hpp"
 #include "ngraph/node.hpp"
@@ -23,6 +24,9 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape.hpp"
 
+#include "ngraph/runtime/opt_kernel/reshape.hpp"
+#include "ngraph/runtime/reference/pad.hpp"
+
 using namespace std;
 using namespace ngraph;
 
@@ -135,3 +139,132 @@ bool ngraph::op::v1::SpaceToBatch::visit_attributes(ngraph::AttributeVisitor& vi
 {
     return true;
 }
+
+bool ngraph::op::v1::SpaceToBatch::evaluate(const HostTensorVector& outputs,
+                                            const HostTensorVector& inputs) const
+{
+    const auto& data = inputs[0];
+    const auto& out = outputs[0];
+    const auto& out_shape = out->get_shape();
+    size_t elem_size = data->get_element_type().size();
+
+    if (data->get_partial_shape().is_dynamic())
+    {
+        return false;
+    }
+    auto data_shape = data->get_shape();
+
+    if (!(data->get_shape().size() == 4 || data->get_shape().size() == 5))
+    {
+        return false;
+    }
+
+    size_t block_values_size = shape_size(inputs[1]->get_shape());
+    const auto* block_values = inputs[1]->get_data_ptr<int64_t>();
+    const auto* pads_begin = inputs[2]->get_data_ptr<int64_t>();
+    const auto* pads_end = inputs[3]->get_data_ptr<int64_t>();
+
+    const char* pad_value = nullptr;
+    const std::vector<char> pad_zero_value(elem_size, 0);
+    if (inputs.size() == 4)
+    {
+        pad_value = inputs[3]->get_data_ptr<char>();
+    }
+    else
+    {
+        pad_value = pad_zero_value.data();
+    }
+    CoordinateDiff pads_begin_vec(shape_size(inputs[2]->get_shape()));
+    pads_begin_vec.assign(pads_begin, pads_begin + shape_size(inputs[2]->get_shape()));
+    CoordinateDiff pads_end_vec(shape_size(inputs[2]->get_shape()));
+    pads_end_vec.assign(pads_end, pads_end + shape_size(inputs[2]->get_shape()));
+
+    Shape padded_shape(data_shape.size());
+    for (size_t i = 0; i < data_shape.size(); ++i)
+    {
+        padded_shape[i] = data_shape[i] + pads_begin_vec[i] + pads_end_vec[i];
+    }
+
+    std::vector<char> padded_data(shape_size(padded_shape) * elem_size);
+    ngraph::runtime::reference::pad(data->get_data_ptr<char>(),
+                                    pad_value,
+                                    padded_data.data(),
+                                    elem_size,
+                                    data_shape,
+                                    padded_shape,
+                                    pads_begin_vec,
+                                    pads_end_vec,
+                                    ngraph::op::PadMode::CONSTANT);
+    data_shape = padded_shape;
+
+    Shape dispersed_shape(block_values_size + 1);
+    std::vector<size_t> axes_order(block_values_size + 1);
+    Shape squeezed_shape(data_shape.begin(), data_shape.end());
+    std::vector<size_t> plain_axes_order(block_values_size + 1);
+    std::iota(plain_axes_order.begin(), plain_axes_order.end(), 0);
+
+    std::vector<char> flat_data(padded_data.begin(), padded_data.end());
+    std::vector<char> dispersed_data(shape_size(data_shape) * elem_size);
+    std::vector<char> post_transpose_data(shape_size(data_shape) * elem_size);
+
+    for (int64_t block_idx = block_values_size - 1; block_idx >= 0; --block_idx)
+    {
+        int64_t sq_shape_idx = block_values_size - 1;
+        int64_t axis_idx = axes_order.size() - 1;
+        for (int64_t shape_idx = dispersed_shape.size() - 1; shape_idx >= 0; --shape_idx)
+        {
+            if (shape_idx == (block_idx + 1))
+            {
+                dispersed_shape[shape_idx] = block_values[block_idx];
+                axes_order[0] = shape_idx;
+            }
+            else if (shape_idx == block_idx)
+            {
+                dispersed_shape[shape_idx] = squeezed_shape[sq_shape_idx] / block_values[block_idx];
+                axes_order[axis_idx] = shape_idx;
+                axis_idx--;
+                sq_shape_idx--;
+            }
+            else
+            {
+                dispersed_shape[shape_idx] = squeezed_shape[sq_shape_idx];
+                axes_order[axis_idx] = shape_idx;
+                axis_idx--;
+                sq_shape_idx--;
+            }
+        }
+
+        runtime::opt_kernel::reshape(flat_data.data(),
+                                     dispersed_data.data(),
+                                     data_shape,
+                                     plain_axes_order,
+                                     dispersed_shape,
+                                     elem_size);
+        Shape post_transpose_shape(axes_order.size());
+        for (size_t i = 0; i < axes_order.size(); ++i)
+        {
+            post_transpose_shape[i] = dispersed_shape[axes_order[i]];
+        }
+
+        runtime::opt_kernel::reshape(dispersed_data.data(),
+                                     post_transpose_data.data(),
+                                     dispersed_shape,
+                                     axes_order,
+                                     post_transpose_shape,
+                                     elem_size);
+        squeezed_shape[0] *= block_values[block_idx];
+        squeezed_shape[block_idx] /= block_values[block_idx];
+
+        runtime::opt_kernel::reshape(post_transpose_data.data(),
+                                     flat_data.data(),
+                                     post_transpose_shape,
+                                     plain_axes_order,
+                                     squeezed_shape,
+                                     elem_size);
+        data_shape = squeezed_shape;
+    }
+
+    out->write(flat_data.data(), elem_size * shape_size(out->get_shape()));
+
+    return true;
+}
\ No newline at end of file
diff --git a/ngraph/core/src/op/space_to_depth.cpp b/ngraph/core/src/op/space_to_depth.cpp
index 26a0736c04cad6..8ef7dc5d9ca4a8 100644
--- a/ngraph/core/src/op/space_to_depth.cpp
+++ b/ngraph/core/src/op/space_to_depth.cpp
@@ -16,11 +16,14 @@
 #include <cmath>
 #include <cstddef>
 #include <memory>
+#include <numeric>
 
 #include "ngraph/attribute_visitor.hpp"
 #include "ngraph/builder/reshape.hpp"
+#include "ngraph/op/space_to_depth.hpp"
 #include "ngraph/shape.hpp"
-#include "space_to_depth.hpp"
+
+#include "ngraph/runtime/opt_kernel/reshape.hpp"
 
 using namespace std;
 using namespace ngraph;
@@ -32,7 +35,7 @@ constexpr NodeTypeInfo op::SpaceToDepth::type_info;
 op::SpaceToDepth::SpaceToDepth(const Output<Node>& data,
                                const SpaceToDepthMode& mode,
                                size_t block_size)
-    : FusedOp({data})
+    : Op({data})
     , m_blocksize(block_size)
     , m_mode(mode)
 {
@@ -51,26 +54,74 @@ bool ngraph::op::v0::SpaceToDepth::visit_attributes(AttributeVisitor& visitor)
     return true;
 }
 
-OutputVector op::SpaceToDepth::decompose_op() const
+shared_ptr<Node> op::SpaceToDepth::clone_with_new_inputs(const OutputVector& new_args) const
 {
-    auto data = input_value(0);
-    auto data_shape = data.get_shape();
+    if (new_args.size() != 1)
+    {
+        throw ngraph_error("Incorrect number of new arguments");
+    }
+    return make_shared<SpaceToDepth>(new_args.at(0), m_mode, m_blocksize);
+}
+
+void ngraph::op::v0::SpaceToDepth::validate_and_infer_types()
+{
+    PartialShape data_pshape = get_input_partial_shape(0);
 
-    NODE_VALIDATION_CHECK(this,
-                          (data_shape.size() >= 3),
-                          "The input tensor with rank lower than 3 is not supported (input rank: ",
-                          data_shape.size(),
-                          ")");
+    const auto& data_type = get_input_element_type(0);
 
-    NODE_VALIDATION_CHECK(this, m_blocksize > 0, "m_blocksize must be greater than 0");
+    auto data = input_value(0);
 
-    if (data_shape.size() == 3)
+    if (data_pshape.is_static())
     {
-        // Insert batch axis
-        data_shape.insert(data_shape.begin(), 1);
-        data = builder::opset1::reshape(data, data_shape);
+        const auto& data_shape = data.get_shape();
+
+        NODE_VALIDATION_CHECK(
+            this,
+            !(data_shape.size() < 3),
+            "The input tensor with rank lower than 3 is not supported (input rank: ",
+            data_shape.size(),
+            ")");
+
+        auto multiplier = std::pow(m_blocksize, data_shape.size() - 2);
+
+        auto out_shape = data_shape;
+        out_shape[1] *= multiplier;
+        for (size_t i = 2; i < out_shape.size(); i++)
+        {
+            NODE_VALIDATION_CHECK(this,
+                                  m_blocksize > 0 && !(out_shape[i] % m_blocksize),
+                                  "The dimension on position: ",
+                                  i,
+                                  " equal to: ",
+                                  out_shape[i],
+                                  " must be a multiple of m_blocksize: ",
+                                  m_blocksize);
+
+            out_shape[i] /= m_blocksize;
+        }
+
+        set_output_size(1);
+        set_output_type(0, data_type, out_shape);
     }
+    else
+    {
+        set_output_type(0, data_type, PartialShape::dynamic());
+    }
+}
+
+bool ngraph::op::v0::SpaceToDepth::evaluate(const HostTensorVector& outputs,
+                                            const HostTensorVector& inputs) const
+{
+    const auto& data = inputs[0];
+    const auto& out = outputs[0];
+    const auto& out_shape = out->get_shape();
+    size_t elem_size = data->get_element_type().size();
 
+    if (data->get_partial_shape().is_dynamic())
+    {
+        return false;
+    }
+    auto data_shape = data->get_shape();
     const size_t n_dim = data_shape.at(0);
     const size_t c_dim = data_shape.at(1);
     const size_t spatial_dim_index = 2;
@@ -97,7 +148,15 @@ OutputVector op::SpaceToDepth::decompose_op() const
         dispersed_shape.push_back(data_shape.at(i + spatial_dim_index) / m_blocksize);
         dispersed_shape.push_back(m_blocksize);
     }
-    auto flat_node = builder::opset1::reshape(data, dispersed_shape);
+    std::vector<size_t> plain_axes_order(data_shape.size());
+    std::iota(plain_axes_order.begin(), plain_axes_order.end(), 0);
+    std::vector<char> dispersed_data(shape_size(data_shape) * elem_size);
+    runtime::opt_kernel::reshape(data->get_data_ptr<char>(),
+                                 dispersed_data.data(),
+                                 data_shape,
+                                 plain_axes_order,
+                                 dispersed_shape,
+                                 elem_size);
     // calculate axes to transpose
     // [0, 3, 5, ..., spatial_dims + (spatial_dims + 1), 2, 4, ..., K + K])
     vector<size_t> axes_order{0};
@@ -131,25 +190,37 @@ OutputVector op::SpaceToDepth::decompose_op() const
     default: { axes_order.insert(axes_order.begin() + spatial_dims + 1, 1);
     }
     }
-    flat_node = builder::opset1::reorder_axes(flat_node, axes_order);
+    std::vector<char> transposed_data(shape_size(data_shape) * elem_size);
+    Shape post_transpose_shape(axes_order.size());
+    for (size_t axis_idx = 0; axis_idx < axes_order.size(); ++axis_idx)
+    {
+        post_transpose_shape[axis_idx] = dispersed_shape[axes_order[axis_idx]];
+    }
+
+    runtime::opt_kernel::reshape(dispersed_data.data(),
+                                 transposed_data.data(),
+                                 dispersed_shape,
+                                 axes_order,
+                                 post_transpose_shape,
+                                 elem_size);
+
     Shape squeezed_shape{n_dim};
     for (int i = 0; i < spatial_dims; ++i)
     {
         squeezed_shape.push_back(data_shape.at(spatial_dim_index + i) / m_blocksize);
     }
     squeezed_shape.insert(squeezed_shape.begin() + 1, c_dim * std::pow(m_blocksize, spatial_dims));
-    flat_node = builder::opset1::reshape(flat_node, squeezed_shape);
-
-    return OutputVector{flat_node};
-}
-
-shared_ptr<Node> op::SpaceToDepth::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    if (new_args.size() != 1)
+    for (size_t i = plain_axes_order.size() - 1; i < post_transpose_shape.size() - 1; ++i)
     {
-        throw ngraph_error("Incorrect number of new arguments");
+        plain_axes_order.push_back(plain_axes_order[i] + 1);
     }
-    return make_shared<SpaceToDepth>(new_args.at(0), m_mode, m_blocksize);
+    runtime::opt_kernel::reshape(transposed_data.data(),
+                                 out->get_data_ptr<char>(),
+                                 post_transpose_shape,
+                                 plain_axes_order,
+                                 squeezed_shape,
+                                 elem_size);
+    return true;
 }
 
 namespace ngraph
diff --git a/ngraph/core/src/op/squared_difference.cpp b/ngraph/core/src/op/squared_difference.cpp
index 0e9410e4383cb9..c90ffb828b18df 100644
--- a/ngraph/core/src/op/squared_difference.cpp
+++ b/ngraph/core/src/op/squared_difference.cpp
@@ -48,9 +48,9 @@ OutputVector op::SquaredDifference::decompose_op() const
     const auto x1 = input_value(0);
     const auto x2 = input_value(1);
 
-    const auto difference = make_shared<op::Subtract>(x1, x2, m_autobroadcast);
+    const auto difference = make_shared<op::v1::Subtract>(x1, x2, m_autobroadcast);
 
-    return {difference * difference};
+    return {make_shared<op::v1::Multiply>(difference, difference)};
 }
 
 shared_ptr<Node> op::SquaredDifference::clone_with_new_inputs(const OutputVector& new_args) const
diff --git a/ngraph/core/src/op/squeeze.cpp b/ngraph/core/src/op/squeeze.cpp
index 5cf640d2932d82..a9f12d3d8e2d29 100644
--- a/ngraph/core/src/op/squeeze.cpp
+++ b/ngraph/core/src/op/squeeze.cpp
@@ -154,38 +154,6 @@ namespace squeeze
                           const HostTensorPtr& out)
     {
         auto element_type = arg0->get_element_type();
-        out->set_element_type(element_type);
-
-        auto data_shape = arg0->get_shape();
-        int64_t data_rank = static_cast<int64_t>(data_shape.size());
-        auto axes_shape = arg1->get_shape();
-        NGRAPH_CHECK(axes_shape.size() <= 1, "Axes to remove must be a vector or empty.");
-
-        auto out_shape = data_shape;
-        // Empty axes vector
-        if (axes_shape.size() == 0 || axes_shape[0] == 0)
-        {
-            out_shape.erase(std::remove(out_shape.begin(), out_shape.end(), 1), out_shape.end());
-        }
-        else
-        {
-            // Get axes
-            vector<int64_t> axes = read_index_vector(arg1);
-            // Normalize axes
-            std::transform(axes.begin(),
-                           axes.end(),
-                           axes.begin(),
-                           [data_rank](int64_t i) -> int64_t { return i < 0 ? data_rank + i : i; });
-            // Sort in decreasing order
-            std::set<int64_t, greater<int64_t>> axes_set(axes.begin(), axes.end());
-            for (int64_t axis : axes_set)
-            {
-                NGRAPH_CHECK(axis >= 0 && axis < data_rank, "Axis is out of bounds: ", axis);
-                NGRAPH_CHECK(out_shape[axis] == 1, "Only axis of size 1 can be removed.");
-                out_shape.erase(out_shape.begin() + axis);
-            }
-        }
-        out->set_shape(out_shape);
 
         bool rc = true;
         switch (element_type)
diff --git a/ngraph/core/src/op/subtract.cpp b/ngraph/core/src/op/subtract.cpp
index 3c100f2b23efe0..39e2e46dbb5c3f 100644
--- a/ngraph/core/src/op/subtract.cpp
+++ b/ngraph/core/src/op/subtract.cpp
@@ -20,34 +20,9 @@
 #include "ngraph/runtime/host_tensor.hpp"
 #include "ngraph/runtime/reference/subtract.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
-// ------------------------------- v0 ------------------------------------------
-
-constexpr NodeTypeInfo op::v0::Subtract::type_info;
-
-op::v0::Subtract::Subtract(const Output<Node>& arg0,
-                           const Output<Node>& arg1,
-                           const AutoBroadcastSpec& auto_broadcast)
-    : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast)
-{
-    constructor_validate_and_infer_types();
-}
-
-shared_ptr<Node> op::v0::Subtract::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<op::v0::Subtract>(new_args.at(0), new_args.at(1), this->get_autob());
-}
-
-shared_ptr<ngraph::Node> ngraph::operator-(const Output<Node> arg0, const Output<Node> arg1)
-{
-    return make_shared<op::v0::Subtract>(arg0, arg1);
-}
-
 namespace subtract
 {
     template <element::Type_t ET>
@@ -94,13 +69,6 @@ namespace subtract
     }
 }
 
-bool op::v0::Subtract::evaluate(const HostTensorVector& outputs,
-                                const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Subtract::evaluate");
-    return subtract::evaluate_subtract(inputs[0], inputs[1], outputs[0], get_autob());
-}
-
 // ------------------------------- v1 ------------------------------------------
 
 NGRAPH_RTTI_DEFINITION(op::v1::Subtract, "Subtract", 1, util::BinaryElementwiseArithmetic);
diff --git a/ngraph/core/src/op/util/op_types.cpp b/ngraph/core/src/op/util/op_types.cpp
index b4d55d4aa74db9..843964c0436daa 100644
--- a/ngraph/core/src/op/util/op_types.cpp
+++ b/ngraph/core/src/op/util/op_types.cpp
@@ -94,20 +94,14 @@ bool ngraph::op::is_constant(const ngraph::Node* node)
 
 bool ngraph::op::is_commutative(const ngraph::Node* node)
 {
-    return dynamic_cast<const ngraph::op::v0::Add*>(node) != nullptr ||
-           dynamic_cast<const ngraph::op::v1::Add*>(node) != nullptr ||
-           dynamic_cast<const ngraph::op::v0::Maximum*>(node) != nullptr ||
+    return dynamic_cast<const ngraph::op::v1::Add*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::Maximum*>(node) != nullptr ||
-           dynamic_cast<const ngraph::op::v0::Equal*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::Equal*>(node) != nullptr ||
-           dynamic_cast<const ngraph::op::v0::NotEqual*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::NotEqual*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::LogicalAnd*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v0::Xor*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::LogicalXor*>(node) != nullptr ||
-           dynamic_cast<const ngraph::op::v0::Minimum*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::Minimum*>(node) != nullptr ||
-           dynamic_cast<const ngraph::op::v0::Multiply*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::Multiply*>(node) != nullptr ||
            dynamic_cast<const ngraph::op::v1::LogicalOr*>(node) != nullptr;
 }
diff --git a/ngraph/core/src/validation_util.cpp b/ngraph/core/src/validation_util.cpp
index 0b5db851140b02..2fc5041d9c19e2 100644
--- a/ngraph/core/src/validation_util.cpp
+++ b/ngraph/core/src/validation_util.cpp
@@ -1145,7 +1145,6 @@ pair<bool, uint64_t> ngraph::maximum_value(const Output<Node>& value)
         {op::v0::Constant::type_info, exec_constant},
         {op::v0::Convert::type_info, exec_nop},
         {op::v1::Gather::type_info, exec_gather},
-        {op::v0::Minimum::type_info, exec_minimum},
         {op::v1::Minimum::type_info, exec_minimum},
         {op::v1::ReduceMin::type_info, exec_reduce_min},
         {op::v1::Reshape::type_info, exec_nop},
diff --git a/ngraph/frontend/onnx_import/src/op/gru.cpp b/ngraph/frontend/onnx_import/src/op/gru.cpp
index bc39a31b748b38..37b38dfedbb65c 100644
--- a/ngraph/frontend/onnx_import/src/op/gru.cpp
+++ b/ngraph/frontend/onnx_import/src/op/gru.cpp
@@ -58,8 +58,10 @@ namespace ngraph
                                     const int split_parts = 2 * 3;
                                     const auto split_bias =
                                         builder::opset1::split(bias, split_parts, 1);
-                                    const auto wr_z_bias = split_bias.at(0) + split_bias.at(3);
-                                    const auto wr_r_bias = split_bias.at(1) + split_bias.at(4);
+                                    const auto wr_z_bias = std::make_shared<ngraph::op::v1::Add>(
+                                        split_bias.at(0), split_bias.at(3));
+                                    const auto wr_r_bias = std::make_shared<ngraph::op::v1::Add>(
+                                        split_bias.at(1), split_bias.at(4));
                                     // The result has shape: [num_directions, 4 * hidden_size]
                                     // and data layout:
                                     //       [
diff --git a/ngraph/frontend/onnx_import/src/utils/recurrent.cpp b/ngraph/frontend/onnx_import/src/utils/recurrent.cpp
index 8ebd20b893c351..d4fbd62c9c60f7 100644
--- a/ngraph/frontend/onnx_import/src/utils/recurrent.cpp
+++ b/ngraph/frontend/onnx_import/src/utils/recurrent.cpp
@@ -66,7 +66,8 @@ namespace ngraph
                     auto bias = ng_inputs.at(3);
                     auto split_bias = builder::opset1::split(bias, 2, 1);
                     NGRAPH_SUPPRESS_DEPRECATED_START
-                    m_map[OpInput::B] = split_bias.at(0) + split_bias.at(1);
+                    m_map[OpInput::B] =
+                        std::make_shared<ngraph::op::v1::Add>(split_bias.at(0), split_bias.at(1));
                     NGRAPH_SUPPRESS_DEPRECATED_END
                 }
                 else
diff --git a/ngraph/python/src/pyngraph/node.cpp b/ngraph/python/src/pyngraph/node.cpp
index 9b9a4082b00ce4..d342cb2475a7f6 100644
--- a/ngraph/python/src/pyngraph/node.cpp
+++ b/ngraph/python/src/pyngraph/node.cpp
@@ -41,27 +41,27 @@ void regclass_pyngraph_Node(py::module m)
     node.doc() = "ngraph.impl.Node wraps ngraph::Node";
     node.def("__add__",
              [](const std::shared_ptr<ngraph::Node>& a, const std::shared_ptr<ngraph::Node> b) {
-                 return a + b;
+                 return std::make_shared<ngraph::op::v1::Add>(a, b);
              },
              py::is_operator());
     node.def("__sub__",
              [](const std::shared_ptr<ngraph::Node>& a, const std::shared_ptr<ngraph::Node> b) {
-                 return a - b;
+                 return std::make_shared<ngraph::op::v1::Subtract>(a, b);
              },
              py::is_operator());
     node.def("__mul__",
              [](const std::shared_ptr<ngraph::Node>& a, const std::shared_ptr<ngraph::Node> b) {
-                 return a * b;
+                 return std::make_shared<ngraph::op::v1::Multiply>(a, b);
              },
              py::is_operator());
     node.def("__div__",
              [](const std::shared_ptr<ngraph::Node>& a, const std::shared_ptr<ngraph::Node> b) {
-                 return a / b;
+                 return std::make_shared<ngraph::op::v1::Divide>(a, b);
              },
              py::is_operator());
     node.def("__truediv__",
              [](const std::shared_ptr<ngraph::Node>& a, const std::shared_ptr<ngraph::Node> b) {
-                 return a / b;
+                 return std::make_shared<ngraph::op::v1::Divide>(a, b);
              },
              py::is_operator());
 
diff --git a/ngraph/test/CMakeLists.txt b/ngraph/test/CMakeLists.txt
index 336f9f86f16cea..70b90a36596d4e 100644
--- a/ngraph/test/CMakeLists.txt
+++ b/ngraph/test/CMakeLists.txt
@@ -235,7 +235,6 @@ endif()
 
 if (NGRAPH_INTERPRETER_ENABLE)
     list(APPEND SRC
-        backend_debug_api.cpp
         builder.cpp
         backend_api.cpp)
     set(ACTIVE_BACKEND_LIST ${ACTIVE_BACKEND_LIST} INTERPRETER)
@@ -318,7 +317,6 @@ set(MULTI_TEST_SRC
     backend/pad.in.cpp
     backend/parameter_as_output.in.cpp
     backend/power.in.cpp
-    backend/quantize_dequantize.in.cpp
     backend/range.in.cpp
     backend/reduce_max.in.cpp
     backend/reduce_mean.in.cpp
diff --git a/ngraph/test/backend/abc.in.cpp b/ngraph/test/backend/abc.in.cpp
index 8ce73fe72a9c05..21f4669076fac6 100644
--- a/ngraph/test/backend/abc.in.cpp
+++ b/ngraph/test/backend/abc.in.cpp
@@ -20,8 +20,6 @@
 #include "util/test_case.hpp"
 #include "util/test_control.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -34,7 +32,8 @@ NGRAPH_TEST(${BACKEND_NAME}, abc)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>((A + B) * C, ParameterVector{A, B, C});
+    auto arg = make_shared<op::v1::Multiply>(make_shared<op::v1::Add>(A, B), C);
+    auto f = make_shared<Function>(arg, ParameterVector{A, B, C});
 
     std::vector<float> a{1, 2, 3, 4};
     std::vector<float> b{5, 6, 7, 8};
@@ -65,7 +64,8 @@ NGRAPH_TEST(${BACKEND_NAME}, abc_int64)
     auto A = make_shared<op::Parameter>(element::Type_t::i64, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i64, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::i64, shape);
-    auto f = make_shared<Function>((A + B) * C, ParameterVector{A, B, C});
+    auto arg = make_shared<op::v1::Multiply>(make_shared<op::v1::Add>(A, B), C);
+    auto f = make_shared<Function>(arg, ParameterVector{A, B, C});
 
     std::vector<int64_t> a{1, 2, 3, 4};
     std::vector<int64_t> b{5, 6, 7, 8};
diff --git a/ngraph/test/backend/add.in.cpp b/ngraph/test/backend/add.in.cpp
index e069038c609239..f479d5576976ea 100644
--- a/ngraph/test/backend/add.in.cpp
+++ b/ngraph/test/backend/add.in.cpp
@@ -37,8 +37,6 @@
 #include "util/test_case.hpp"
 #include "util/test_control.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -50,7 +48,7 @@ NGRAPH_TEST(${BACKEND_NAME}, add)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     vector<float> a{1, 2, 3, 4};
     vector<float> b{5, 6, 7, 8};
@@ -66,7 +64,7 @@ NGRAPH_TEST(${BACKEND_NAME}, add_overload)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A + B, ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     vector<float> a{1, 2, 3, 4};
     vector<float> b{5, 6, 7, 8};
@@ -82,10 +80,10 @@ NGRAPH_TEST(${BACKEND_NAME}, add_in_place)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto T = A + B;
-    auto T2 = T + T;
-    auto T3 = T2 + T2;
-    auto T4 = T3 + T3;
+    auto T = make_shared<op::v1::Add>(A, B);
+    auto T2 = make_shared<op::v1::Add>(T, T);
+    auto T3 = make_shared<op::v1::Add>(T2, T2);
+    auto T4 = make_shared<op::v1::Add>(T3, T3);
 
     auto f = make_shared<Function>(T4, ParameterVector{A, B});
 
diff --git a/ngraph/test/backend/aliased_output.in.cpp b/ngraph/test/backend/aliased_output.in.cpp
index 42baf1aef64173..3ff85d1730e574 100644
--- a/ngraph/test/backend/aliased_output.in.cpp
+++ b/ngraph/test/backend/aliased_output.in.cpp
@@ -20,8 +20,6 @@
 #include "util/test_case.hpp"
 #include "util/test_control.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -33,9 +31,9 @@ NGRAPH_TEST(${BACKEND_NAME}, aliased_output)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto C = A + B;
-    auto D = A * B;
-    auto E = op::Constant::create(element::Type_t::f32, shape, {1, 2, 3, 4});
+    auto C = make_shared<op::v1::Add>(A, B);
+    auto D = make_shared<op::v1::Multiply>(A, B);
+    auto E = op::Constant::create(element::f32, shape, {1, 2, 3, 4});
     auto f = make_shared<Function>(NodeVector{C, C, D, D, C, E, E}, ParameterVector{A, B});
 
     vector<float> a{0, 1, 2, 3};
diff --git a/ngraph/test/backend/api.in.cpp b/ngraph/test/backend/api.in.cpp
index fae7559f737b9e..d22ba34234b94d 100644
--- a/ngraph/test/backend/api.in.cpp
+++ b/ngraph/test/backend/api.in.cpp
@@ -24,8 +24,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -37,7 +35,7 @@ NGRAPH_TEST(${BACKEND_NAME}, create_tensor_1)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -63,7 +61,8 @@ NGRAPH_TEST(${BACKEND_NAME}, get_parameters_and_results)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>((A + B) * C, ParameterVector{A, B, C});
+    auto arg = make_shared<op::v1::Multiply>(make_shared<op::v1::Add>(A, B), C);
+    auto f = make_shared<Function>(arg, ParameterVector{A, B, C});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/auto_broadcast.in.cpp b/ngraph/test/backend/auto_broadcast.in.cpp
index 723dd467dcd720..ae3723269e45d8 100644
--- a/ngraph/test/backend/auto_broadcast.in.cpp
+++ b/ngraph/test/backend/auto_broadcast.in.cpp
@@ -114,7 +114,7 @@ NGRAPH_TEST(${BACKEND_NAME}, auto_bcast_binary_elementwise_pdpd_dynamic)
     auto b = make_shared<op::Parameter>(element::Type_t::f32, pshape_b);
 
     op::AutoBroadcastSpec autob = op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD, -1);
-    auto f = make_shared<Function>(make_shared<op::Add>(a, b, autob), ParameterVector{a, b});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(a, b, autob), ParameterVector{a, b});
     auto backend = runtime::Backend::create("${BACKEND_NAME}", true);
     auto ex = backend->compile(f);
 
@@ -132,7 +132,7 @@ NGRAPH_TEST(${BACKEND_NAME}, auto_bcast_binary_elementwise_pdpd_dynamic)
 
     // a shape {2, 3, 4, 5}, b shape {3, 4} axis = 1
     autob = op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD, 1);
-    f = make_shared<Function>(make_shared<op::Add>(a, b, autob), ParameterVector{a, b});
+    f = make_shared<Function>(make_shared<op::v1::Add>(a, b, autob), ParameterVector{a, b});
     ex = backend->compile(f);
     t_r = backend->create_dynamic_tensor(element::Type_t::f32, PartialShape::dynamic());
     t_a = backend->create_tensor(element::Type_t::f32, Shape{2, 3, 4, 5});
@@ -157,21 +157,21 @@ NGRAPH_TEST(${BACKEND_NAME}, auto_bcast_string_cast)
     auto a = make_shared<op::Parameter>(element::Type_t::f32, Shape{1});
     auto b = make_shared<op::Parameter>(element::Type_t::f32, Shape{1});
 
-    auto add = make_shared<op::Add>(a, b, "NUMPY");
+    auto add = make_shared<op::v1::Add>(a, b, "NUMPY");
     ASSERT_EQ(add->get_autob(), op::AutoBroadcastType::NUMPY);
 
-    add = make_shared<op::Add>(a, b, "NONE");
+    add = make_shared<op::v1::Add>(a, b, "NONE");
     ASSERT_EQ(add->get_autob(), op::AutoBroadcastType::NONE);
 
-    add = make_shared<op::Add>(a, b, "PDPD");
+    add = make_shared<op::v1::Add>(a, b, "PDPD");
     ASSERT_EQ(add->get_autob(), op::AutoBroadcastType::PDPD);
 
-    add = make_shared<op::Add>(a, b, "EXPLICIT");
+    add = make_shared<op::v1::Add>(a, b, "EXPLICIT");
     ASSERT_EQ(add->get_autob(), op::AutoBroadcastType::EXPLICIT);
 
     try
     {
-        add = make_shared<op::Add>(a, b, "UNKNOWN");
+        add = make_shared<op::v1::Add>(a, b, "UNKNOWN");
         FAIL() << "Unknown AutoBroadcastType not detected.";
     }
     catch (const ngraph_error& error)
diff --git a/ngraph/test/backend/comparison.in.cpp b/ngraph/test/backend/comparison.in.cpp
index 98a078a1048b9e..bd20b91e75d565 100644
--- a/ngraph/test/backend/comparison.in.cpp
+++ b/ngraph/test/backend/comparison.in.cpp
@@ -33,8 +33,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -45,7 +43,7 @@ NGRAPH_TEST(${BACKEND_NAME}, equal)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -66,7 +64,7 @@ NGRAPH_TEST(${BACKEND_NAME}, notequal)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::NotEqual>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::NotEqual>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -87,7 +85,7 @@ NGRAPH_TEST(${BACKEND_NAME}, greater)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Greater>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Greater>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -108,7 +106,7 @@ NGRAPH_TEST(${BACKEND_NAME}, greater_int64)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::i64, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i64, shape);
-    auto f = make_shared<Function>(make_shared<op::Greater>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Greater>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -129,7 +127,7 @@ NGRAPH_TEST(${BACKEND_NAME}, greatereq)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::GreaterEq>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::GreaterEqual>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -150,7 +148,7 @@ NGRAPH_TEST(${BACKEND_NAME}, less)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Less>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Less>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -171,7 +169,7 @@ NGRAPH_TEST(${BACKEND_NAME}, lesseq)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::LessEq>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::LessEqual>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -192,7 +190,7 @@ NGRAPH_TEST(${BACKEND_NAME}, lesseq_int32)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto f = make_shared<Function>(make_shared<op::LessEq>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::LessEqual>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -213,7 +211,7 @@ NGRAPH_TEST(${BACKEND_NAME}, lesseq_bool)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::boolean, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::boolean, shape);
-    auto f = make_shared<Function>(make_shared<op::LessEq>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::LessEqual>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/concat.in.cpp b/ngraph/test/backend/concat.in.cpp
index db8e68275b6296..92416268967330 100644
--- a/ngraph/test/backend/concat.in.cpp
+++ b/ngraph/test/backend/concat.in.cpp
@@ -291,11 +291,11 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_2d_tensor)
     Shape shape{1, 1};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add1 = make_shared<op::Add>(A, B);
+    auto add1 = make_shared<op::v1::Add>(A, B);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto D = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add2 = make_shared<op::Add>(C, D);
-    auto subtract = make_shared<op::Subtract>(C, A);
+    auto add2 = make_shared<op::v1::Add>(C, D);
+    auto subtract = make_shared<op::v1::Subtract>(C, A);
     Shape shape_r{3, 1};
     auto f = make_shared<Function>(make_shared<op::Concat>(NodeVector{add1, add2, subtract}, 0),
                                    ParameterVector{A, B, C, D});
@@ -324,12 +324,12 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_propagate_2d_tensor)
     Shape shape{1, 1};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add1 = make_shared<op::Add>(A, B);
+    auto add1 = make_shared<op::v1::Add>(A, B);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto D = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add2 = make_shared<op::Add>(C, D);
+    auto add2 = make_shared<op::v1::Add>(C, D);
     auto concat1 = make_shared<op::Concat>(NodeVector{add1, add2}, 0);
-    auto subtract = make_shared<op::Subtract>(C, A);
+    auto subtract = make_shared<op::v1::Subtract>(C, A);
     Shape shape_r{3, 1};
     auto f = make_shared<Function>(make_shared<op::Concat>(NodeVector{concat1, subtract}, 0),
                                    ParameterVector{A, B, C, D});
@@ -359,10 +359,10 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_tree_1)
     Shape shape_r{1, 4, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add1 = make_shared<op::Add>(A, B);
-    auto add2 = make_shared<op::Add>(A, B);
+    auto add1 = make_shared<op::v1::Add>(A, B);
+    auto add2 = make_shared<op::v1::Add>(A, B);
     auto concat = make_shared<op::Concat>(NodeVector{add1, add2}, 1);
-    auto f = make_shared<Function>(make_shared<op::Add>(concat, concat), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(concat, concat), ParameterVector{A, B});
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
     // Create some tensors for input/output
     auto a = backend->create_tensor(element::Type_t::f32, shape);
@@ -385,12 +385,13 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_tree_2)
     Shape shape_r{1, 8, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add1 = make_shared<op::Add>(A, B);
-    auto add2 = make_shared<op::Add>(A, B);
+    auto add1 = make_shared<op::v1::Add>(A, B);
+    auto add2 = make_shared<op::v1::Add>(A, B);
     auto concat1 = make_shared<op::Concat>(NodeVector{add1, add2}, 1);
     auto concat2 = make_shared<op::Concat>(NodeVector{add1, add2}, 1);
     auto concat12 = make_shared<op::Concat>(NodeVector{concat1, concat2}, 1);
-    auto f = make_shared<Function>(make_shared<op::Add>(concat12, concat12), ParameterVector{A, B});
+    auto f =
+        make_shared<Function>(make_shared<op::v1::Add>(concat12, concat12), ParameterVector{A, B});
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
     // Create some tensors for input/output
@@ -420,7 +421,8 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_tree_3)
     auto concat12 = make_shared<op::Concat>(NodeVector{concat1, concat2}, 1);
     auto concat34 = make_shared<op::Concat>(NodeVector{concat3, concat4}, 1);
     auto concat14 = make_shared<op::Concat>(NodeVector{concat12, concat34}, 1);
-    auto f = make_shared<Function>(make_shared<op::Add>(concat14, concat14), ParameterVector{A, B});
+    auto f =
+        make_shared<Function>(make_shared<op::v1::Add>(concat14, concat14), ParameterVector{A, B});
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
     // Create some tensors for input/output
     auto a = backend->create_tensor(element::Type_t::f32, shape);
@@ -442,10 +444,10 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_add_concat)
     Shape shape_r{4, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add1 = make_shared<op::Add>(A, B);
-    auto add2 = make_shared<op::Add>(add1, add1);
+    auto add1 = make_shared<op::v1::Add>(A, B);
+    auto add2 = make_shared<op::v1::Add>(add1, add1);
     auto concat = make_shared<op::Concat>(NodeVector{add1, add2}, 0);
-    auto add3 = make_shared<op::Add>(concat, concat);
+    auto add3 = make_shared<op::v1::Add>(concat, concat);
     auto f = make_shared<Function>(add3, ParameterVector{A, B});
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -466,17 +468,17 @@ NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_add_concat_2)
     Shape shape_r{1, 6, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add1 = make_shared<op::Add>(A, B);
-    auto add2 = make_shared<op::Add>(A, B);
-    auto add3 = make_shared<op::Add>(A, B);
-    auto add4 = make_shared<op::Add>(A, B);
-    auto add5 = make_shared<op::Add>(A, B);
+    auto add1 = make_shared<op::v1::Add>(A, B);
+    auto add2 = make_shared<op::v1::Add>(A, B);
+    auto add3 = make_shared<op::v1::Add>(A, B);
+    auto add4 = make_shared<op::v1::Add>(A, B);
+    auto add5 = make_shared<op::v1::Add>(A, B);
 
     auto concat1 = make_shared<op::Concat>(NodeVector{add1, add2, add3}, 1);
 
     auto concat2 = make_shared<op::Concat>(NodeVector{add4, add2, add5}, 1);
 
-    auto add6 = make_shared<op::Add>(concat1, concat2);
+    auto add6 = make_shared<op::v1::Add>(concat1, concat2);
     auto f = make_shared<Function>(add6, ParameterVector{A, B});
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/constant.in.cpp b/ngraph/test/backend/constant.in.cpp
index e5d872e50ad0e0..675b44267c49ad 100644
--- a/ngraph/test/backend/constant.in.cpp
+++ b/ngraph/test/backend/constant.in.cpp
@@ -175,11 +175,11 @@ NGRAPH_TEST(${BACKEND_NAME}, constant_equality_bool)
     Shape shape{4};
     // auto A = make_shared<op::Parameter>(element::Type_t::boolean, shape);
     // auto B = make_shared<op::Parameter>(element::Type_t::boolean, shape);
-    // auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{A, B});
+    // auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{A, B});
 
     auto A = op::Constant::create(element::Type_t::boolean, shape, {true, false, true, false});
     auto B = op::Constant::create(element::Type_t::boolean, shape, {true, true, true, true});
-    auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{});
+    auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/convolution.in.cpp b/ngraph/test/backend/convolution.in.cpp
index 1b4d7ef2dcf4c2..c092b80bdbde13 100644
--- a/ngraph/test/backend/convolution.in.cpp
+++ b/ngraph/test/backend/convolution.in.cpp
@@ -17,7 +17,6 @@
 #include "gtest/gtest.h"
 #include "ngraph/ngraph.hpp"
 #include "ngraph/runtime/tensor.hpp"
-#include "op/convolution.hpp"
 #include "runtime/backend.hpp"
 #include "util/all_close.hpp"
 #include "util/all_close_f.hpp"
@@ -38,20 +37,10 @@ NGRAPH_TEST(${BACKEND_NAME}, convolution_outlining)
     Shape shape_b{2, 2, 1, 1};
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape_b);
     Shape shape_r{1, 2, 2, 2};
-    auto conv1 = make_shared<op::v0::Convolution>(A,
-                                                  B,
-                                                  Strides{1, 1},
-                                                  Strides{1, 1},
-                                                  CoordinateDiff{0, 0},
-                                                  CoordinateDiff{0, 0},
-                                                  Strides{1, 1});
-    auto conv2 = make_shared<op::v0::Convolution>(conv1,
-                                                  B,
-                                                  Strides{1, 1},
-                                                  Strides{1, 1},
-                                                  CoordinateDiff{0, 0},
-                                                  CoordinateDiff{0, 0},
-                                                  Strides{1, 1});
+    auto conv1 = make_shared<op::v1::Convolution>(
+        A, B, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
+    auto conv2 = make_shared<op::v1::Convolution>(
+        conv1, B, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
     auto f = make_shared<Function>(conv2, ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -77,13 +66,8 @@ NGRAPH_TEST(${BACKEND_NAME}, convolution_simple)
     Shape shape_b{2, 2, 1, 1};
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape_b);
     Shape shape_r{1, 2, 2, 2};
-    auto conv1 = make_shared<op::v0::Convolution>(A,
-                                                  B,
-                                                  Strides{1, 1},
-                                                  Strides{1, 1},
-                                                  CoordinateDiff{0, 0},
-                                                  CoordinateDiff{0, 0},
-                                                  Strides{1, 1});
+    auto conv1 = make_shared<op::v1::Convolution>(
+        A, B, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
     auto f = make_shared<Function>(conv1, ParameterVector{A, B});
 
@@ -110,13 +94,8 @@ NGRAPH_TEST(${BACKEND_NAME}, convolution_simple_padding)
     Shape shape_b{1, 1, 1, 1};
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape_b);
     Shape shape_r{1, 1, 5, 5};
-    auto conv1 = make_shared<op::v0::Convolution>(A,
-                                                  B,
-                                                  Strides{1, 1},
-                                                  Strides{1, 1},
-                                                  CoordinateDiff{1, 1},
-                                                  CoordinateDiff{2, 2},
-                                                  Strides{1, 1});
+    auto conv1 = make_shared<op::v1::Convolution>(
+        A, B, Strides{1, 1}, CoordinateDiff{1, 1}, CoordinateDiff{2, 2}, Strides{1, 1});
 
     auto f = make_shared<Function>(conv1, ParameterVector{A, B});
 
diff --git a/ngraph/test/backend/divide.in.cpp b/ngraph/test/backend/divide.in.cpp
index 46d4faa9321e7b..0b42c9acd98e90 100644
--- a/ngraph/test/backend/divide.in.cpp
+++ b/ngraph/test/backend/divide.in.cpp
@@ -41,8 +41,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -54,7 +52,7 @@ NGRAPH_TEST(${BACKEND_NAME}, divide)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -76,7 +74,7 @@ NGRAPH_TEST(${BACKEND_NAME}, divide_int32)
 
     auto A = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -98,7 +96,7 @@ NGRAPH_TEST(${BACKEND_NAME}, divide_cpp_rounding_int32)
 
     auto A = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B, false), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B, false), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -120,7 +118,7 @@ NGRAPH_TEST(${BACKEND_NAME}, divide_python_rounding_int32)
 
     auto A = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -142,7 +140,7 @@ NGRAPH_TEST(${BACKEND_NAME}, divide_overload)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A / B, ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -164,7 +162,7 @@ NGRAPH_TEST(${BACKEND_NAME}, divide_by_zero_float32)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/dynamic.in.cpp b/ngraph/test/backend/dynamic.in.cpp
index 911d9acf649ff5..beff30261c0dc5 100644
--- a/ngraph/test/backend/dynamic.in.cpp
+++ b/ngraph/test/backend/dynamic.in.cpp
@@ -22,8 +22,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -56,7 +54,8 @@ NGRAPH_TEST(${BACKEND_NAME}, dynamic_abc)
     auto c =
         make_shared<op::Parameter>(element::Type_t::f32, PartialShape{2, Dimension::dynamic(), 3});
 
-    auto a_plus_b_times_c = (a + b) * c;
+    auto a_plus_b = make_shared<op::v1::Add>(a, b);
+    auto a_plus_b_times_c = make_shared<op::v1::Multiply>(a_plus_b, c);
 
     auto f = make_shared<Function>(NodeVector{a_plus_b_times_c}, ParameterVector{a, b, c});
 
@@ -120,7 +119,7 @@ static void axpy_test(const PartialShape& input_pshape, const std::vector<Shape>
     auto x = make_shared<op::Parameter>(element::Type_t::f32, input_pshape);
     auto y = make_shared<op::Parameter>(element::Type_t::f32, input_pshape);
 
-    auto axpy = a * x + y;
+    auto axpy = make_shared<op::v1::Add>(make_shared<op::v1::Multiply>(a, x), y);
 
     auto f = make_shared<Function>(NodeVector{axpy}, ParameterVector{a, x, y});
     auto backend = runtime::Backend::create("${BACKEND_NAME}", true);
diff --git a/ngraph/test/backend/function_name.in.cpp b/ngraph/test/backend/function_name.in.cpp
index 559d4ce901ea36..c5703859c61ea7 100644
--- a/ngraph/test/backend/function_name.in.cpp
+++ b/ngraph/test/backend/function_name.in.cpp
@@ -23,8 +23,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -35,7 +33,8 @@ NGRAPH_TEST(${BACKEND_NAME}, function_name)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A + B, ParameterVector{A, B}, "funky func name");
+    auto add = make_shared<op::v1::Add>(A, B);
+    auto f = make_shared<Function>(add, ParameterVector{A, B}, "funky func name");
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/fused_op.in.cpp b/ngraph/test/backend/fused_op.in.cpp
index 155a11f7f028b2..9b3393276c35d4 100644
--- a/ngraph/test/backend/fused_op.in.cpp
+++ b/ngraph/test/backend/fused_op.in.cpp
@@ -36,7 +36,6 @@
 #include "ngraph/opsets/opset4.hpp"
 #include "ngraph/op/util/attr_types.hpp"
 #include "ngraph/op/util/rnn_cell_base.hpp"
-#include "op/group_conv.hpp"
 #include "util/all_close.hpp"
 #include "util/all_close_f.hpp"
 #include "util/engine/test_engines.hpp"
@@ -168,218 +167,6 @@ NGRAPH_TEST(${BACKEND_NAME}, prelu_negative_slope)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, group_conv)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{1, 1},
-                                                            CoordinateDiff{0, 0},
-                                                            CoordinateDiff{0, 0},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(Shape{1, 2, 2, 2},
-                                         vector<float>{11, 14, 17, 20, 79, 86, 93, 100});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_striding)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{2, 2},
-                                                            Strides{1, 1},
-                                                            CoordinateDiff{0, 0},
-                                                            CoordinateDiff{0, 0},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(Shape{1, 2, 1, 1}, vector<float>{11, 79});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_window_dilation)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{2, 2},
-                                                            CoordinateDiff{0, 0},
-                                                            CoordinateDiff{0, 0},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(Shape{1, 2, 2, 2},
-                                         vector<float>{11, 14, 17, 20, 79, 86, 93, 100});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_data_dilation)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{1, 1},
-                                                            CoordinateDiff{0, 0},
-                                                            CoordinateDiff{0, 0},
-                                                            Strides{2, 2},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(
-        Shape{1, 2, 3, 3},
-        vector<float>{11, 0, 14, 0, 0, 0, 17, 0, 20, 79, 0, 86, 0, 0, 0, 93, 0, 100});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_padding)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{1, 1},
-                                                            CoordinateDiff{1, 0},
-                                                            CoordinateDiff{0, 1},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(
-        Shape{1, 2, 3, 3},
-        vector<float>{0, 0, 0, 11, 14, 0, 17, 20, 0, 0, 0, 0, 79, 86, 0, 93, 100, 0});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_padding_and_window_dilation)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{2, 2},
-                                                            CoordinateDiff{1, 0},
-                                                            CoordinateDiff{0, 1},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(
-        Shape{1, 2, 3, 3},
-        vector<float>{0, 0, 0, 11, 14, 0, 17, 20, 0, 0, 0, 0, 79, 86, 0, 93, 100, 0});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_input_shape_variation)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 4, 1});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{2, 2},
-                                                            CoordinateDiff{1, 0},
-                                                            CoordinateDiff{0, 1},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(
-        Shape{1, 2, 5, 2},
-        vector<float>{0, 0, 11, 0, 14, 0, 17, 0, 20, 0, 0, 0, 79, 0, 86, 0, 93, 0, 100, 0});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_input_data_variation)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 3, 3});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{2, 2},
-                                                            CoordinateDiff{1, 0},
-                                                            CoordinateDiff{0, 1},
-                                                            Strides{1, 1},
-                                                            2);
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18,
-                         19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(
-        Shape{1, 2, 4, 4},
-        vector<float>{0, 0, 0, 0, 21,  24,  27,  0, 30,  33,  36,  0, 39,  42,  45,  0,
-                      0, 0, 0, 0, 169, 176, 183, 0, 190, 197, 204, 0, 211, 218, 225, 0});
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, group_conv_groups_included_in_shape)
-{
-    auto data = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 4, 2, 2});
-    auto filters = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 1, 2, 1, 1});
-    auto group_conv = make_shared<op::v0::GroupConvolution>(data,
-                                                            filters,
-                                                            Strides{1, 1},
-                                                            Strides{1, 1},
-                                                            CoordinateDiff{0, 0},
-                                                            CoordinateDiff{0, 0},
-                                                            Strides{1, 1});
-    auto f = make_shared<Function>(NodeVector{group_conv}, ParameterVector{data, filters});
-    std::vector<float> a{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    std::vector<float> b{1, 2, 3, 4};
-
-    auto test_case = test::TestCase<TestEngine>(f);
-    test_case.add_multiple_inputs<float>({a, b});
-    test_case.add_expected_output<float>(Shape{1, 2, 2, 2},
-                                         vector<float>{11, 14, 17, 20, 79, 86, 93, 100});
-    test_case.run();
-}
-
 NGRAPH_TEST(${BACKEND_NAME}, space_to_depth_block_first)
 {
     auto A = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 4, 4});
@@ -456,8 +243,8 @@ NGRAPH_TEST(${BACKEND_NAME}, depth_to_space_depth_first)
                             7.f,  23.f, 12.f, 28.f, 14.f, 30.f, 13.f, 29.f, 15.f, 31.f});
     test_case.run();
 }
-
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_chw_4d)
+// TODO: Issue: 37521
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_chw_4d)
 {
     Shape data_shape{1, 2, 3, 4};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -485,7 +272,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_chw_4d)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_empty_axes_input)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_empty_axes_input)
 {
     Shape data_shape{1, 2, 3, 4};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -513,7 +300,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_empty_axes_input)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_h_4d)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_h_4d)
 {
     Shape data_shape{1, 2, 3, 4};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -539,7 +326,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_h_4d)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_1axis_5d)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_1axis_5d)
 {
     Shape data_shape{1, 2, 2, 2, 3};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -565,7 +352,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_1axis_5d)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_123axes_5d)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_123axes_5d)
 {
     Shape data_shape{1, 2, 2, 2, 3};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -592,7 +379,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_123axes_5d)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_c_2x2_shape)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_c_2x2_shape)
 {
     Shape data_shape{2, 2};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -616,7 +403,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_c_2x2_shape)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_c_2x4_shape)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_c_2x4_shape)
 {
     Shape data_shape{2, 4};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -647,7 +434,7 @@ NGRAPH_TEST(${BACKEND_NAME}, normalize_across_c_2x4_shape)
     test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, normalize_across_chw_4d_max_bias)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_chw_4d_max_bias)
 {
     Shape data_shape{1, 2, 3, 4};
     auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -1382,7 +1169,6 @@ NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_variance_normalization_split_channels)
 
     test_case.run();
 }
-
 NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_variance_normalization_shared_across_channel_batch_size_2)
 {
     Shape data_shape{2, 2, 5};
@@ -1453,7 +1239,7 @@ NGRAPH_TEST(${BACKEND_NAME}, grn_4d)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, grn_2d_with_bias)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_grn_2d_with_bias)
 {
     const Shape data_shape{3, 4};
     const auto data = make_shared<op::Parameter>(element::Type_t::f32, data_shape);
@@ -1599,7 +1385,8 @@ NGRAPH_TEST(${BACKEND_NAME}, squeeze_dynamic)
     EXPECT_THROW(make_shared<op::Squeeze>(data_param, axes_param), CheckFailure);
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, squared_difference)
+// TODO: Issue: 37534
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_squared_difference)
 {
     const auto x1 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2});
     const auto x2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2});
@@ -1615,7 +1402,7 @@ NGRAPH_TEST(${BACKEND_NAME}, squared_difference)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, squared_difference_broadcast)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_squared_difference_broadcast)
 {
     const auto x1 = make_shared<op::Parameter>(element::Type_t::i32, Shape{2, 2});
     const auto x2 = make_shared<op::Parameter>(element::Type_t::i32, Shape{});
@@ -1631,7 +1418,7 @@ NGRAPH_TEST(${BACKEND_NAME}, squared_difference_broadcast)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_zero_bias_peepholes)
+NGRAPH_TEST(${BACKEND_NAME}, lstm_cell__zero_bias_peepholes)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
@@ -1709,7 +1496,8 @@ NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_zero_bias_peepholes)
     ct_test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_bias_peepholes)
+// Peerholes unsupported in Ngraph
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_lstm_cell__bias_peepholes)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
@@ -1799,7 +1587,7 @@ NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_bias_peepholes)
     ct_test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_bias_peepholes_clip_input_forget)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_lstm_cell__bias_peepholes_clip_input_forget)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
@@ -1900,7 +1688,8 @@ NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_bias_peepholes_clip_input_forget)
     ct_test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_activaction_functions)
+// Hard Sigmoid is unsupprted
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_lstm_cell__activaction_functions)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
@@ -2004,7 +1793,8 @@ NGRAPH_TEST(${BACKEND_NAME}, lstm_cell_activaction_functions)
     ct_test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, fake_quantize)
+// TODO: Issue: 37511
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize)
 {
     const Shape data_shape{1, 2, 3, 4};
     const size_t levels = 4;
@@ -2047,7 +1837,7 @@ NGRAPH_TEST(${BACKEND_NAME}, fake_quantize)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, fake_quantize_with_clip)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize_with_clip)
 {
     const Shape data_shape{1, 2, 3, 4};
     const size_t levels = 5;
@@ -2087,7 +1877,7 @@ NGRAPH_TEST(${BACKEND_NAME}, fake_quantize_with_clip)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, fake_quantize_with_clip_across_channels)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize_with_clip_across_channels)
 {
     Shape data_shape{1, 2, 5, 5};
     size_t levels = 5;
@@ -2130,7 +1920,7 @@ NGRAPH_TEST(${BACKEND_NAME}, fake_quantize_with_clip_across_channels)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, fake_quantize_pdpd)
+NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize_pdpd)
 {
     Shape data_shape{1, 2, 5, 5};
     size_t levels = 5;
@@ -2179,7 +1969,7 @@ NGRAPH_TEST(${BACKEND_NAME}, fake_quantize_pdpd)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, rnn_cell_no_bias)
+NGRAPH_TEST(${BACKEND_NAME}, rnn_cell__no_bias)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
@@ -2230,7 +2020,7 @@ NGRAPH_TEST(${BACKEND_NAME}, rnn_cell_no_bias)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, rnn_cell_bias_clip)
+NGRAPH_TEST(${BACKEND_NAME}, rnn_cell__bias_clip)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
@@ -2294,7 +2084,7 @@ NGRAPH_TEST(${BACKEND_NAME}, rnn_cell_bias_clip)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, rnn_cell_activation_function)
+NGRAPH_TEST(${BACKEND_NAME}, rnn_cell__activation_function)
 {
     const size_t batch_size = 2;
     const size_t input_size = 3;
diff --git a/ngraph/test/backend/gather.in.cpp b/ngraph/test/backend/gather.in.cpp
index 4447196522264a..d42966eddcbc56 100644
--- a/ngraph/test/backend/gather.in.cpp
+++ b/ngraph/test/backend/gather.in.cpp
@@ -404,4 +404,4 @@ NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_bool)
     test_case.add_input<int64_t>({0, 1, 1, 2});
     test_case.add_expected_output<char>(out_shape, {1, 1, 1, 0, 1, 0, 0, 1});
     test_case.run(MIN_FLOAT_TOLERANCE_BITS);
-}
+}
\ No newline at end of file
diff --git a/ngraph/test/backend/group_convolution.in.cpp b/ngraph/test/backend/group_convolution.in.cpp
index 762884564f6eb7..9c213e2e4b7f87 100644
--- a/ngraph/test/backend/group_convolution.in.cpp
+++ b/ngraph/test/backend/group_convolution.in.cpp
@@ -17,7 +17,6 @@
 #include "gtest/gtest.h"
 #include "ngraph/ngraph.hpp"
 #include "ngraph/runtime/tensor.hpp"
-#include "op/group_conv.hpp"
 #include "runtime/backend.hpp"
 #include "util/all_close.hpp"
 #include "util/all_close_f.hpp"
@@ -49,8 +48,8 @@ NGRAPH_TEST(${BACKEND_NAME}, dyn_group_convolution_backprop_data)
     auto padding_end = CoordinateDiff{0, 0};
     size_t groups = 3;
 
-    auto conv_bprop_data = make_shared<op::v0::GroupConvolutionBackpropData>(
-        data_batch, filters, deltas, strides, dilations, padding_begin, padding_end, groups);
+    auto conv_bprop_data = make_shared<op::v1::GroupConvolutionBackpropData>(
+        data_batch, filters, deltas, strides, padding_begin, padding_end, dilations);
 
     auto f = make_shared<Function>(conv_bprop_data, ParameterVector{data_batch, filters, deltas});
 
diff --git a/ngraph/test/backend/maximum.in.cpp b/ngraph/test/backend/maximum.in.cpp
index fb668b3664e7a1..54388daf577046 100644
--- a/ngraph/test/backend/maximum.in.cpp
+++ b/ngraph/test/backend/maximum.in.cpp
@@ -41,8 +41,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -53,7 +51,7 @@ NGRAPH_TEST(${BACKEND_NAME}, maximum)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Maximum>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Maximum>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -75,7 +73,7 @@ NGRAPH_TEST(${BACKEND_NAME}, maximum_int32)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto f = make_shared<Function>(make_shared<op::Maximum>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Maximum>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -96,7 +94,7 @@ NGRAPH_TEST(${BACKEND_NAME}, maximum_int64)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::i64, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i64, shape);
-    auto f = make_shared<Function>(make_shared<op::Maximum>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Maximum>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/minimum.in.cpp b/ngraph/test/backend/minimum.in.cpp
index cb48daaf8b5242..1491c11be9d0b6 100644
--- a/ngraph/test/backend/minimum.in.cpp
+++ b/ngraph/test/backend/minimum.in.cpp
@@ -37,8 +37,6 @@
 #include "util/test_case.hpp"
 #include "util/test_control.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -50,7 +48,7 @@ NGRAPH_TEST(${BACKEND_NAME}, minimum)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Minimum>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
 
     std::vector<float> a{1, 8, -8, 17, -0.5, 0.5, 2, 1};
     std::vector<float> b{1, 2, 4, 8, 0, 0, 1, 1.5};
@@ -66,7 +64,7 @@ NGRAPH_TEST(${BACKEND_NAME}, minimum_int32)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto f = make_shared<Function>(make_shared<op::Minimum>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
 
     std::vector<int32_t> a{1, 8, -8, 17, -5, 67635216, 2, 1};
     std::vector<int32_t> b{1, 2, 4, 8, 0, 18448, 1, 6};
@@ -82,7 +80,7 @@ NGRAPH_TEST(${BACKEND_NAME}, minimum_int64)
     Shape shape{2, 2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::i64, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::i64, shape);
-    auto f = make_shared<Function>(make_shared<op::Minimum>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
 
     std::vector<int64_t> a{1, 8, -8, 17, -5, 67635216, 2, 17179887632};
     std::vector<int64_t> b{1, 2, 4, 8, 0, 18448, 1, 280592};
diff --git a/ngraph/test/backend/multiple_backends.in.cpp b/ngraph/test/backend/multiple_backends.in.cpp
index 515ba2cf217b37..ff4d99575b2ad2 100644
--- a/ngraph/test/backend/multiple_backends.in.cpp
+++ b/ngraph/test/backend/multiple_backends.in.cpp
@@ -25,8 +25,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -37,11 +35,13 @@ NGRAPH_TEST(${BACKEND_NAME}, multiple_backends)
     Shape shape{2, 2};
     auto A1 = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B1 = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A1 + B1, ParameterVector{A1, B1});
+    auto add = std::make_shared<op::v1::Add>(A1, B1);
+    auto f = make_shared<Function>(add, ParameterVector{A1, B1});
 
     auto A2 = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B2 = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto g = make_shared<Function>(A2 * B2, ParameterVector{A2, B2});
+    auto multiply = std::make_shared<op::v1::Multiply>(A2, B2);
+    auto g = make_shared<Function>(multiply, ParameterVector{A2, B2});
 
     auto backend1 = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/multiple_result.in.cpp b/ngraph/test/backend/multiple_result.in.cpp
index 57361900135b2b..8764aa27ad9ccd 100644
--- a/ngraph/test/backend/multiple_result.in.cpp
+++ b/ngraph/test/backend/multiple_result.in.cpp
@@ -37,8 +37,8 @@ NGRAPH_TEST(${BACKEND_NAME}, multiple_result)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto A_add_B = make_shared<op::Add>(A, B);
-    auto A_add_B_mul_C = make_shared<op::Multiply>(A_add_B, C);
+    auto A_add_B = make_shared<op::v1::Add>(A, B);
+    auto A_add_B_mul_C = make_shared<op::v1::Multiply>(A_add_B, C);
 
     auto f = make_shared<Function>(NodeVector{A_add_B, A_add_B_mul_C}, ParameterVector{A, B, C});
 
diff --git a/ngraph/test/backend/multiply.in.cpp b/ngraph/test/backend/multiply.in.cpp
index bea292e9d0efbf..7282508a190781 100644
--- a/ngraph/test/backend/multiply.in.cpp
+++ b/ngraph/test/backend/multiply.in.cpp
@@ -50,7 +50,7 @@ NGRAPH_TEST(${BACKEND_NAME}, multiply)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Multiply>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Multiply>(A, B), ParameterVector{A, B});
 
     std::vector<float> a{1, 2, 3, 4};
     std::vector<float> b{5, 6, 7, 8};
@@ -66,7 +66,7 @@ NGRAPH_TEST(${BACKEND_NAME}, multiply_overload)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A * B, ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Multiply>(A, B), ParameterVector{A, B});
 
     std::vector<float> a{1, 2, 3, 4};
     std::vector<float> b{5, 6, 7, 8};
diff --git a/ngraph/test/backend/node_name.in.cpp b/ngraph/test/backend/node_name.in.cpp
index 2e30c0b0a39833..16056f6844a435 100644
--- a/ngraph/test/backend/node_name.in.cpp
+++ b/ngraph/test/backend/node_name.in.cpp
@@ -23,8 +23,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -35,7 +33,7 @@ NGRAPH_TEST(${BACKEND_NAME}, node_name)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto C = A + B;
+    auto C = std::make_shared<ngraph::op::v1::Add>(A, B);
     C->set_friendly_name("a node name");
     auto f = make_shared<Function>(C, ParameterVector{A, B});
 
diff --git a/ngraph/test/backend/numeric.in.cpp b/ngraph/test/backend/numeric.in.cpp
index a95febf5d14a16..07edfdd0a97ccd 100644
--- a/ngraph/test/backend/numeric.in.cpp
+++ b/ngraph/test/backend/numeric.in.cpp
@@ -33,7 +33,7 @@ NGRAPH_TEST(${BACKEND_NAME}, numeric_float_nan)
     Shape shape{5};
     auto A = op::Constant::create(element::Type_t::f32, shape, {-2.5f, 25.5f, 2.25f, NAN, 6.0f});
     auto B = op::Constant::create(element::Type_t::f32, shape, {10.0f, 5.0f, 2.25f, 10.0f, NAN});
-    auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{});
+    auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{});
 
     auto test_case = test::TestCase<TestEngine>(f);
     test_case.add_expected_output<bool>(shape, {false, false, true, false, false});
@@ -45,7 +45,7 @@ NGRAPH_TEST(${BACKEND_NAME}, numeric_double_nan)
     Shape shape{5};
     auto A = op::Constant::create(element::Type_t::f64, shape, {-2.5f, 25.5f, 2.25f, NAN, 6.0f});
     auto B = op::Constant::create(element::Type_t::f64, shape, {10.0f, 5.0f, 2.25f, 10.0f, NAN});
-    auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{});
+    auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{});
 
     auto test_case = test::TestCase<TestEngine>(f);
     test_case.add_expected_output<bool>(shape, {false, false, true, false, false});
@@ -59,7 +59,7 @@ NGRAPH_TEST(${BACKEND_NAME}, numeric_float_inf)
         op::Constant::create(element::Type_t::f32, shape, {-2.5f, 25.5f, 2.25f, INFINITY, 6.0f});
     auto B =
         op::Constant::create(element::Type_t::f32, shape, {10.0f, 5.0f, 2.25f, 10.0f, -INFINITY});
-    auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{});
+    auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{});
 
     auto test_case = test::TestCase<TestEngine>(f);
     test_case.add_expected_output<bool>(shape, {false, false, true, false, false});
@@ -73,7 +73,7 @@ NGRAPH_TEST(${BACKEND_NAME}, numeric_double_inf)
         op::Constant::create(element::Type_t::f64, shape, {-2.5f, 25.5f, 2.25f, INFINITY, 6.0f});
     auto B =
         op::Constant::create(element::Type_t::f64, shape, {10.0f, 5.0f, 2.25f, 10.0f, -INFINITY});
-    auto f = make_shared<Function>(make_shared<op::Equal>(A, B), ParameterVector{});
+    auto f = make_shared<Function>(make_shared<op::v1::Equal>(A, B), ParameterVector{});
 
     auto test_case = test::TestCase<TestEngine>(f);
     test_case.add_expected_output<bool>(shape, {false, false, true, false, false});
diff --git a/ngraph/test/backend/power.in.cpp b/ngraph/test/backend/power.in.cpp
index 9c0ea5bea0d8e6..46396c618572fb 100644
--- a/ngraph/test/backend/power.in.cpp
+++ b/ngraph/test/backend/power.in.cpp
@@ -50,7 +50,7 @@ NGRAPH_TEST(${BACKEND_NAME}, power)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Power>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Power>(A, B), ParameterVector{A, B});
 
     std::vector<float> a{1, 2, 3, 5};
     std::vector<float> b{2, 0, 6, 3};
diff --git a/ngraph/test/backend/relu.in.cpp b/ngraph/test/backend/relu.in.cpp
index 00aa5d4e51d046..028f7a5dda458c 100644
--- a/ngraph/test/backend/relu.in.cpp
+++ b/ngraph/test/backend/relu.in.cpp
@@ -25,8 +25,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -97,7 +95,7 @@ NGRAPH_TEST(${BACKEND_NAME}, fuse_max_with_constant_zero_input_as_relu)
     auto shape_a = Shape{2, 5};
     auto A = op::Constant::create(element::Type_t::f32, shape_a, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape_a);
-    auto max = make_shared<op::Maximum>(A, B);
+    auto max = make_shared<op::v1::Maximum>(A, B);
     auto shape_rt = Shape{2, 5};
     auto f = make_shared<Function>(max, ParameterVector{B});
 
diff --git a/ngraph/test/backend/select.in.cpp b/ngraph/test/backend/select.in.cpp
index 9530b3fceda1da..d7e24500bf6bf4 100644
--- a/ngraph/test/backend/select.in.cpp
+++ b/ngraph/test/backend/select.in.cpp
@@ -37,7 +37,7 @@ NGRAPH_TEST(${BACKEND_NAME}, select)
     auto A = make_shared<op::Parameter>(element::Type_t::boolean, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Select>(A, B, C), ParameterVector{A, B, C});
+    auto f = make_shared<Function>(make_shared<op::v1::Select>(A, B, C), ParameterVector{A, B, C});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -87,7 +87,7 @@ NGRAPH_TEST(${BACKEND_NAME}, select_double)
     auto A = make_shared<op::Parameter>(element::Type_t::boolean, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f64, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f64, shape);
-    auto f = make_shared<Function>(make_shared<op::Select>(A, B, C), ParameterVector{A, B, C});
+    auto f = make_shared<Function>(make_shared<op::v1::Select>(A, B, C), ParameterVector{A, B, C});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/slice.in.cpp b/ngraph/test/backend/slice.in.cpp
index ba8b352a3bfe82..1eee81d551a4b8 100644
--- a/ngraph/test/backend/slice.in.cpp
+++ b/ngraph/test/backend/slice.in.cpp
@@ -101,11 +101,11 @@ NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_overlap)
     Shape shape_a{4, 4};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape_a);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape_a);
-    auto C = make_shared<op::Add>(A, B);
+    auto C = make_shared<op::v1::Add>(A, B);
     Shape shape_r{2, 4};
     auto D = make_shared<op::Slice>(C, Coordinate{0, 0}, Coordinate{2, 4});
     auto E = make_shared<op::Slice>(C, Coordinate{1, 0}, Coordinate{3, 4});
-    auto r = make_shared<op::Add>(D, E);
+    auto r = make_shared<op::v1::Add>(D, E);
     auto f = make_shared<Function>(r, ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -131,7 +131,7 @@ NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_in_place)
     Shape shape_r{2, 4};
     auto D = make_shared<op::Slice>(A, Coordinate{0, 0}, Coordinate{2, 4});
     auto E = make_shared<op::Slice>(A, Coordinate{2, 0}, Coordinate{4, 4});
-    auto r = make_shared<op::Add>(D, E);
+    auto r = make_shared<op::v1::Add>(D, E);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -156,7 +156,7 @@ NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_in_place_twice)
     auto B = make_shared<op::Slice>(A, Coordinate{0, 0}, Coordinate{2, 4});
     auto D = make_shared<op::Slice>(B, Coordinate{1, 0}, Coordinate{2, 4});
     auto E = make_shared<op::Slice>(A, Coordinate{2, 0}, Coordinate{3, 4});
-    auto r = make_shared<op::Add>(D, E);
+    auto r = make_shared<op::v1::Add>(D, E);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -180,7 +180,7 @@ NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_in_place_twice_overlap)
     auto B = make_shared<op::Slice>(A, Coordinate{1, 0}, Coordinate{5, 4});
     auto D = make_shared<op::Slice>(B, Coordinate{1, 0}, Coordinate{3, 4});
     auto E = make_shared<op::Slice>(B, Coordinate{2, 0}, Coordinate{4, 4});
-    auto r = make_shared<op::Add>(D, E);
+    auto r = make_shared<op::v1::Add>(D, E);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
diff --git a/ngraph/test/backend/subtract.in.cpp b/ngraph/test/backend/subtract.in.cpp
index ce2b205bfae909..e648d47e746104 100644
--- a/ngraph/test/backend/subtract.in.cpp
+++ b/ngraph/test/backend/subtract.in.cpp
@@ -41,8 +41,6 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -53,7 +51,7 @@ NGRAPH_TEST(${BACKEND_NAME}, subtract)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Subtract>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Subtract>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
@@ -74,7 +72,7 @@ NGRAPH_TEST(${BACKEND_NAME}, subtract_overload)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A - B, ParameterVector{A, B});
+    auto f = make_shared<Function>(std::make_shared<op::v1::Subtract>(A, B), ParameterVector{A, B});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 
diff --git a/ngraph/test/backend/validate_call.in.cpp b/ngraph/test/backend/validate_call.in.cpp
index 5630d57bfeca0c..ea245dff63e711 100644
--- a/ngraph/test/backend/validate_call.in.cpp
+++ b/ngraph/test/backend/validate_call.in.cpp
@@ -40,7 +40,7 @@ NGRAPH_TEST(${BACKEND_NAME}, validate_call_input_count)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto a = backend->create_tensor(element::Type_t::f32, shape);
     auto b = backend->create_tensor(element::Type_t::f32, shape);
@@ -57,7 +57,7 @@ NGRAPH_TEST(${BACKEND_NAME}, validate_call_input_type)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto a = backend->create_tensor(element::Type_t::i32, shape);
     auto b = backend->create_tensor(element::Type_t::f32, shape);
@@ -74,7 +74,7 @@ NGRAPH_TEST(${BACKEND_NAME}, validate_call_input_shape)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto a = backend->create_tensor(element::Type_t::f32, {2, 3});
     auto b = backend->create_tensor(element::Type_t::f32, shape);
@@ -91,7 +91,7 @@ NGRAPH_TEST(${BACKEND_NAME}, validate_call_output_count)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto a = backend->create_tensor(element::Type_t::f32, shape);
     auto b = backend->create_tensor(element::Type_t::f32, shape);
@@ -109,7 +109,7 @@ NGRAPH_TEST(${BACKEND_NAME}, validate_call_output_type)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto a = backend->create_tensor(element::Type_t::i32, shape);
     auto b = backend->create_tensor(element::Type_t::f32, shape);
@@ -126,7 +126,7 @@ NGRAPH_TEST(${BACKEND_NAME}, validate_call_output_shape)
 
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     auto a = backend->create_tensor(element::Type_t::f32, {2, 3});
     auto b = backend->create_tensor(element::Type_t::f32, shape);
diff --git a/ngraph/test/backend/zero_sized.in.cpp b/ngraph/test/backend/zero_sized.in.cpp
index dce14e91c777f9..b7608142da9c69 100644
--- a/ngraph/test/backend/zero_sized.in.cpp
+++ b/ngraph/test/backend/zero_sized.in.cpp
@@ -25,13 +25,19 @@
 #include "util/test_control.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
 static string s_manifest = "${MANIFEST}";
 
+static const std::vector<ngraph::element::Type> base_types = {
+    ngraph::element::from<float>(),
+    ngraph::element::from<int32_t>(),
+    ngraph::element::from<int64_t>(),
+    ngraph::element::from<uint32_t>(),
+    ngraph::element::from<uint64_t>(),
+};
+
 template <typename OP>
 void make_unary_empty_test(const string& backend_name)
 {
@@ -39,9 +45,9 @@ void make_unary_empty_test(const string& backend_name)
 
     ParameterVector params;
     NodeVector result_list;
-    for (size_t i = 0; i < s_known_element_types.size(); i++)
+    for (size_t i = 0; i < base_types.size(); i++)
     {
-        shared_ptr<op::Parameter> p = make_shared<op::Parameter>(s_known_element_types[i], shape);
+        shared_ptr<op::Parameter> p = make_shared<op::Parameter>(base_types[i], shape);
         params.push_back(p);
         result_list.push_back(make_shared<OP>(p));
     }
@@ -51,36 +57,26 @@ void make_unary_empty_test(const string& backend_name)
 
     vector<shared_ptr<runtime::Tensor>> inputs;
     vector<shared_ptr<runtime::Tensor>> outputs;
-    for (size_t i = 0; i < s_known_element_types.size(); i++)
+    for (size_t i = 0; i < base_types.size(); i++)
     {
-        inputs.push_back(backend->create_tensor(s_known_element_types[i], shape));
-        outputs.push_back(backend->create_tensor(s_known_element_types[i], shape));
+        inputs.push_back(backend->create_tensor(base_types[i], shape));
+        outputs.push_back(backend->create_tensor(base_types[i], shape));
     }
 
     auto handle = backend->compile(f);
     handle->call_with_validate(outputs, inputs);
 
     EXPECT_EQ(read_vector<float>(inputs[0]).size(), 0);
-    EXPECT_EQ(read_vector<double>(inputs[1]).size(), 0);
-    EXPECT_EQ(read_vector<int8_t>(inputs[2]).size(), 0);
-    EXPECT_EQ(read_vector<int16_t>(inputs[3]).size(), 0);
-    EXPECT_EQ(read_vector<int32_t>(inputs[4]).size(), 0);
-    EXPECT_EQ(read_vector<int64_t>(inputs[5]).size(), 0);
-    EXPECT_EQ(read_vector<uint8_t>(inputs[6]).size(), 0);
-    EXPECT_EQ(read_vector<uint16_t>(inputs[7]).size(), 0);
-    EXPECT_EQ(read_vector<uint32_t>(inputs[8]).size(), 0);
-    EXPECT_EQ(read_vector<uint64_t>(inputs[9]).size(), 0);
+    EXPECT_EQ(read_vector<int32_t>(inputs[1]).size(), 0);
+    EXPECT_EQ(read_vector<int64_t>(inputs[2]).size(), 0);
+    EXPECT_EQ(read_vector<uint32_t>(inputs[3]).size(), 0);
+    EXPECT_EQ(read_vector<uint64_t>(inputs[4]).size(), 0);
 
     EXPECT_EQ(read_vector<float>(outputs[0]).size(), 0);
-    EXPECT_EQ(read_vector<double>(outputs[1]).size(), 0);
-    EXPECT_EQ(read_vector<int8_t>(outputs[2]).size(), 0);
-    EXPECT_EQ(read_vector<int16_t>(outputs[3]).size(), 0);
-    EXPECT_EQ(read_vector<int32_t>(outputs[4]).size(), 0);
-    EXPECT_EQ(read_vector<int64_t>(outputs[5]).size(), 0);
-    EXPECT_EQ(read_vector<uint8_t>(outputs[6]).size(), 0);
-    EXPECT_EQ(read_vector<uint16_t>(outputs[7]).size(), 0);
-    EXPECT_EQ(read_vector<uint32_t>(outputs[8]).size(), 0);
-    EXPECT_EQ(read_vector<uint64_t>(outputs[9]).size(), 0);
+    EXPECT_EQ(read_vector<int32_t>(outputs[1]).size(), 0);
+    EXPECT_EQ(read_vector<int64_t>(outputs[2]).size(), 0);
+    EXPECT_EQ(read_vector<uint32_t>(outputs[3]).size(), 0);
+    EXPECT_EQ(read_vector<uint64_t>(outputs[4]).size(), 0);
 }
 
 template <typename OP>
@@ -88,9 +84,9 @@ void make_binary_empty_test(const string& backend_name, bool is_comparison = fal
 {
     Shape shape{0};
     ParameterVector A;
-    for (size_t i = 0; i < s_known_element_types.size(); i++)
+    for (size_t i = 0; i < base_types.size(); i++)
     {
-        A.push_back(make_shared<op::Parameter>(s_known_element_types[i], shape));
+        A.push_back(make_shared<op::Parameter>(base_types[i], shape));
     }
 
     NodeVector result_list;
@@ -104,16 +100,16 @@ void make_binary_empty_test(const string& backend_name, bool is_comparison = fal
 
     vector<shared_ptr<runtime::Tensor>> inputs;
     vector<shared_ptr<runtime::Tensor>> outputs;
-    for (size_t i = 0; i < s_known_element_types.size(); i++)
+    for (size_t i = 0; i < base_types.size(); i++)
     {
-        inputs.push_back(backend->create_tensor(s_known_element_types[i], shape));
+        inputs.push_back(backend->create_tensor(base_types[i], shape));
         if (is_comparison)
         {
             outputs.push_back(backend->create_tensor(element::from<char>(), shape));
         }
         else
         {
-            outputs.push_back(backend->create_tensor(s_known_element_types[i], shape));
+            outputs.push_back(backend->create_tensor(base_types[i], shape));
         }
     }
 
@@ -121,15 +117,10 @@ void make_binary_empty_test(const string& backend_name, bool is_comparison = fal
     handle->call_with_validate(outputs, inputs);
 
     EXPECT_EQ(read_vector<float>(inputs[0]).size(), 0);
-    EXPECT_EQ(read_vector<double>(inputs[1]).size(), 0);
-    EXPECT_EQ(read_vector<int8_t>(inputs[2]).size(), 0);
-    EXPECT_EQ(read_vector<int16_t>(inputs[3]).size(), 0);
-    EXPECT_EQ(read_vector<int32_t>(inputs[4]).size(), 0);
-    EXPECT_EQ(read_vector<int64_t>(inputs[5]).size(), 0);
-    EXPECT_EQ(read_vector<uint8_t>(inputs[6]).size(), 0);
-    EXPECT_EQ(read_vector<uint16_t>(inputs[7]).size(), 0);
-    EXPECT_EQ(read_vector<uint32_t>(inputs[8]).size(), 0);
-    EXPECT_EQ(read_vector<uint64_t>(inputs[9]).size(), 0);
+    EXPECT_EQ(read_vector<int32_t>(inputs[1]).size(), 0);
+    EXPECT_EQ(read_vector<int64_t>(inputs[2]).size(), 0);
+    EXPECT_EQ(read_vector<uint32_t>(inputs[3]).size(), 0);
+    EXPECT_EQ(read_vector<uint64_t>(inputs[4]).size(), 0);
 
     if (is_comparison)
     {
@@ -138,24 +129,14 @@ void make_binary_empty_test(const string& backend_name, bool is_comparison = fal
         EXPECT_EQ(read_vector<char>(outputs[2]).size(), 0);
         EXPECT_EQ(read_vector<char>(outputs[3]).size(), 0);
         EXPECT_EQ(read_vector<char>(outputs[4]).size(), 0);
-        EXPECT_EQ(read_vector<char>(outputs[5]).size(), 0);
-        EXPECT_EQ(read_vector<char>(outputs[6]).size(), 0);
-        EXPECT_EQ(read_vector<char>(outputs[7]).size(), 0);
-        EXPECT_EQ(read_vector<char>(outputs[8]).size(), 0);
-        EXPECT_EQ(read_vector<char>(outputs[9]).size(), 0);
     }
     else
     {
         EXPECT_EQ(read_vector<float>(outputs[0]).size(), 0);
-        EXPECT_EQ(read_vector<double>(outputs[1]).size(), 0);
-        EXPECT_EQ(read_vector<int8_t>(outputs[2]).size(), 0);
-        EXPECT_EQ(read_vector<int16_t>(outputs[3]).size(), 0);
-        EXPECT_EQ(read_vector<int32_t>(outputs[4]).size(), 0);
-        EXPECT_EQ(read_vector<int64_t>(outputs[5]).size(), 0);
-        EXPECT_EQ(read_vector<uint8_t>(outputs[6]).size(), 0);
-        EXPECT_EQ(read_vector<uint16_t>(outputs[7]).size(), 0);
-        EXPECT_EQ(read_vector<uint32_t>(outputs[8]).size(), 0);
-        EXPECT_EQ(read_vector<uint64_t>(outputs[9]).size(), 0);
+        EXPECT_EQ(read_vector<int32_t>(outputs[1]).size(), 0);
+        EXPECT_EQ(read_vector<int64_t>(outputs[2]).size(), 0);
+        EXPECT_EQ(read_vector<uint32_t>(outputs[3]).size(), 0);
+        EXPECT_EQ(read_vector<uint64_t>(outputs[4]).size(), 0);
     }
 }
 
@@ -251,65 +232,65 @@ NGRAPH_TEST(${BACKEND_NAME}, zero_sized_atan)
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_add)
 {
-    make_binary_empty_test<op::Add>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Add>("${BACKEND_NAME}");
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_divide)
 {
-    make_binary_empty_test<op::Divide>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Divide>("${BACKEND_NAME}");
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_eq)
 {
-    make_binary_empty_test<op::Equal>("${BACKEND_NAME}", true);
+    make_binary_empty_test<op::v1::Equal>("${BACKEND_NAME}", true);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_greater)
 {
-    make_binary_empty_test<op::Greater>("${BACKEND_NAME}", true);
+    make_binary_empty_test<op::v1::Greater>("${BACKEND_NAME}", true);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_greatereq)
 {
-    make_binary_empty_test<op::GreaterEq>("${BACKEND_NAME}", true);
+    make_binary_empty_test<op::v1::GreaterEqual>("${BACKEND_NAME}", true);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_less)
 {
-    make_binary_empty_test<op::Less>("${BACKEND_NAME}", true);
+    make_binary_empty_test<op::v1::Less>("${BACKEND_NAME}", true);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_lesseq)
 {
-    make_binary_empty_test<op::LessEq>("${BACKEND_NAME}", true);
+    make_binary_empty_test<op::v1::LessEqual>("${BACKEND_NAME}", true);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_maximum)
 {
-    make_binary_empty_test<op::Maximum>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Maximum>("${BACKEND_NAME}");
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_minimum)
 {
-    make_binary_empty_test<op::Minimum>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Minimum>("${BACKEND_NAME}");
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_multiply)
 {
-    make_binary_empty_test<op::Multiply>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Multiply>("${BACKEND_NAME}");
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_not_equal)
 {
-    make_binary_empty_test<op::NotEqual>("${BACKEND_NAME}", true);
+    make_binary_empty_test<op::v1::NotEqual>("${BACKEND_NAME}", true);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_power)
 {
-    make_binary_empty_test<op::Power>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Power>("${BACKEND_NAME}");
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, zero_sized_subtract)
 {
-    make_binary_empty_test<op::Subtract>("${BACKEND_NAME}");
+    make_binary_empty_test<op::v1::Subtract>("${BACKEND_NAME}");
 }
diff --git a/ngraph/test/backend_debug_api.cpp b/ngraph/test/backend_debug_api.cpp
index 5124a3c429047d..20901c782c0199 100644
--- a/ngraph/test/backend_debug_api.cpp
+++ b/ngraph/test/backend_debug_api.cpp
@@ -35,7 +35,7 @@ TEST(INTERPRETER, nan_check_input)
     Shape shape{4};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     shared_ptr<runtime::Backend> backend = runtime::Backend::create("INTERPRETER");
 
@@ -59,7 +59,7 @@ TEST(INTERPRETER, nan_check_output)
     Shape shape{4};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Divide>(A, B), ParameterVector{A, B});
 
     shared_ptr<runtime::Backend> backend = runtime::Backend::create("INTERPRETER");
 
diff --git a/ngraph/test/build_graph.cpp b/ngraph/test/build_graph.cpp
index c771382b4ec733..7da57d8940af0b 100644
--- a/ngraph/test/build_graph.cpp
+++ b/ngraph/test/build_graph.cpp
@@ -75,7 +75,7 @@ TEST(build_graph, tensor)
     auto float0 = make_shared<op::Constant>(element::Type_t::f32, shape, float_t);
     ASSERT_EQ(float0->get_element_type(), element::Type_t::f32);
     ASSERT_EQ(float0->get_shape(), shape);
-    auto d = make_shared<op::Add>(float0, float0);
+    auto d = make_shared<op::v1::Add>(float0, float0);
     ASSERT_EQ(d->input_values().at(0).get_node_shared_ptr(), float0);
     ASSERT_EQ(d->input_values().at(1).get_node_shared_ptr(), float0);
 
@@ -125,10 +125,10 @@ TEST(build_graph, no_arg_construction)
     auto arg1 = make_shared<op::Parameter>(element::Type_t::f32, Shape{7});
     auto arg2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{7});
     auto arg3 = make_shared<op::Parameter>(element::Type_t::f32, Shape{7});
-    auto add0 = make_shared<op::Add>();
+    auto add0 = make_shared<op::v1::Add>();
     auto abs0 = make_shared<op::Abs>();
     auto acos0 = make_shared<op::Acos>();
-    auto add1 = make_shared<op::Add>();
+    auto add1 = make_shared<op::v1::Add>();
     add0->set_argument(1, arg0);
     add0->set_argument(0, arg1);
     abs0->set_argument(0, add0);
diff --git a/ngraph/test/constant_folding.cpp b/ngraph/test/constant_folding.cpp
index a7b635aa20be5e..23dec3cd5c5a38 100644
--- a/ngraph/test/constant_folding.cpp
+++ b/ngraph/test/constant_folding.cpp
@@ -22,8 +22,6 @@
 #include "util/all_close_f.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace ngraph;
 using namespace std;
 
@@ -315,29 +313,30 @@ TEST(constant_folding, constant_unary_binary)
     auto h = make_shared<op::Constant>(element::Type_t::boolean, Shape{2, 2}, values_h);
     auto i = make_shared<op::Constant>(element::Type_t::boolean, Shape{2}, values_i);
 
-    auto add = a + b;
-    auto sub = a - b;
-    auto mul = a * b;
-    auto divn = a / b;
-    auto pow = make_shared<op::Power>(a, b);
-    auto min = make_shared<op::Minimum>(c, a);
-    auto max = make_shared<op::Maximum>(a, c);
+    auto add = make_shared<op::v1::Add>(a, b);
+    auto sub = make_shared<op::v1::Subtract>(a, b);
+    auto mul = make_shared<op::v1::Multiply>(a, b);
+    auto divn = make_shared<op::v1::Divide>(a, b);
+    auto pow = make_shared<op::v1::Power>(a, b);
+    auto min = make_shared<op::v1::Minimum>(c, a);
+    auto max = make_shared<op::v1::Maximum>(a, c);
     auto absn = make_shared<op::Abs>(c);
     auto neg = make_shared<op::Negative>(c);
     auto sqrt = make_shared<op::Sqrt>(d);
-    auto add_autob_numpy = make_shared<op::Add>(a, e, op::AutoBroadcastType::NUMPY);
-    auto sub_autob_numpy = make_shared<op::Subtract>(a, e, op::AutoBroadcastType::NUMPY);
-    auto mul_autob_numpy = make_shared<op::Multiply>(a, e, op::AutoBroadcastType::NUMPY);
-    auto div_autob_numpy = make_shared<op::Divide>(a, g, op::AutoBroadcastType::NUMPY);
-    auto pow_autob_numpy = make_shared<op::Power>(a, g, op::AutoBroadcastType::NUMPY);
-    auto min_autob_numpy = make_shared<op::Minimum>(a, f, op::AutoBroadcastType::NUMPY);
-    auto max_autob_numpy = make_shared<op::Maximum>(a, f, op::AutoBroadcastType::NUMPY);
-    auto equal_autob_numpy = make_shared<op::Equal>(a, g, op::AutoBroadcastType::NUMPY);
-    auto not_equal_autob_numpy = make_shared<op::NotEqual>(a, g, op::AutoBroadcastType::NUMPY);
-    auto greater_autob_numpy = make_shared<op::Greater>(a, g, op::AutoBroadcastType::NUMPY);
-    auto greater_eq_autob_numpy = make_shared<op::GreaterEq>(a, g, op::AutoBroadcastType::NUMPY);
-    auto less_autob_numpy = make_shared<op::Less>(a, g, op::AutoBroadcastType::NUMPY);
-    auto less_eq_autob_numpy = make_shared<op::LessEq>(a, g, op::AutoBroadcastType::NUMPY);
+    auto add_autob_numpy = make_shared<op::v1::Add>(a, e, op::AutoBroadcastType::NUMPY);
+    auto sub_autob_numpy = make_shared<op::v1::Subtract>(a, e, op::AutoBroadcastType::NUMPY);
+    auto mul_autob_numpy = make_shared<op::v1::Multiply>(a, e, op::AutoBroadcastType::NUMPY);
+    auto div_autob_numpy = make_shared<op::v1::Divide>(a, g, op::AutoBroadcastType::NUMPY);
+    auto pow_autob_numpy = make_shared<op::v1::Power>(a, g, op::AutoBroadcastType::NUMPY);
+    auto min_autob_numpy = make_shared<op::v1::Minimum>(a, f, op::AutoBroadcastType::NUMPY);
+    auto max_autob_numpy = make_shared<op::v1::Maximum>(a, f, op::AutoBroadcastType::NUMPY);
+    auto equal_autob_numpy = make_shared<op::v1::Equal>(a, g, op::AutoBroadcastType::NUMPY);
+    auto not_equal_autob_numpy = make_shared<op::v1::NotEqual>(a, g, op::AutoBroadcastType::NUMPY);
+    auto greater_autob_numpy = make_shared<op::v1::Greater>(a, g, op::AutoBroadcastType::NUMPY);
+    auto greater_eq_autob_numpy =
+        make_shared<op::v1::GreaterEqual>(a, g, op::AutoBroadcastType::NUMPY);
+    auto less_autob_numpy = make_shared<op::v1::Less>(a, g, op::AutoBroadcastType::NUMPY);
+    auto less_eq_autob_numpy = make_shared<op::v1::LessEqual>(a, g, op::AutoBroadcastType::NUMPY);
     auto logical_or_autob_numpy =
         make_shared<op::v1::LogicalOr>(h, i, op::AutoBroadcastType::NUMPY);
     auto logical_xor_autob_numpy = make_shared<op::Xor>(h, i, op::AutoBroadcastType::NUMPY);
@@ -1379,7 +1378,7 @@ TEST(constant_folding, const_equal)
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 3, 4, 5, 6});
     auto constant1 =
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 2, 3, 5, 6});
-    auto eq = make_shared<op::Equal>(constant0, constant1);
+    auto eq = make_shared<op::v1::Equal>(constant0, constant1);
     eq->set_friendly_name("test");
     auto f = make_shared<Function>(eq, ParameterVector{});
 
@@ -1387,7 +1386,7 @@ TEST(constant_folding, const_equal)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::Equal>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::Equal>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
@@ -1407,7 +1406,7 @@ TEST(constant_folding, const_not_equal)
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 3, 4, 5, 6});
     auto constant1 =
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 2, 3, 5, 6});
-    auto eq = make_shared<op::NotEqual>(constant0, constant1);
+    auto eq = make_shared<op::v1::NotEqual>(constant0, constant1);
     eq->set_friendly_name("test");
     auto f = make_shared<Function>(eq, ParameterVector{});
 
@@ -1415,7 +1414,7 @@ TEST(constant_folding, const_not_equal)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::NotEqual>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::NotEqual>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
@@ -1435,7 +1434,7 @@ TEST(constant_folding, const_greater)
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 3, 4, 5, 6});
     auto constant1 =
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{2, 2, 2, 5, 5, 5});
-    auto eq = make_shared<op::Greater>(constant0, constant1);
+    auto eq = make_shared<op::v1::Greater>(constant0, constant1);
     eq->set_friendly_name("test");
     auto f = make_shared<Function>(eq, ParameterVector{});
 
@@ -1443,7 +1442,7 @@ TEST(constant_folding, const_greater)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::Greater>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::Greater>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
@@ -1463,7 +1462,7 @@ TEST(constant_folding, const_greater_eq)
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 3, 4, 5, 6});
     auto constant1 =
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{2, 2, 2, 5, 5, 5});
-    auto eq = make_shared<op::GreaterEq>(constant0, constant1);
+    auto eq = make_shared<op::v1::GreaterEqual>(constant0, constant1);
     eq->set_friendly_name("test");
     auto f = make_shared<Function>(eq, ParameterVector{});
 
@@ -1471,7 +1470,7 @@ TEST(constant_folding, const_greater_eq)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::GreaterEq>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::GreaterEqual>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
@@ -1491,7 +1490,7 @@ TEST(constant_folding, const_less)
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 3, 4, 5, 6});
     auto constant1 =
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{2, 2, 2, 5, 5, 5});
-    auto eq = make_shared<op::Less>(constant0, constant1);
+    auto eq = make_shared<op::v1::Less>(constant0, constant1);
     eq->set_friendly_name("test");
     auto f = make_shared<Function>(eq, ParameterVector{});
 
@@ -1499,7 +1498,7 @@ TEST(constant_folding, const_less)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::Less>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::Less>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
@@ -1519,7 +1518,7 @@ TEST(constant_folding, const_less_eq)
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{1, 2, 3, 4, 5, 6});
     auto constant1 =
         op::Constant::create(element::Type_t::i32, Shape{2, 3}, vector<int32_t>{2, 2, 2, 5, 5, 5});
-    auto eq = make_shared<op::LessEq>(constant0, constant1);
+    auto eq = make_shared<op::v1::LessEqual>(constant0, constant1);
     eq->set_friendly_name("test");
     auto f = make_shared<Function>(eq, ParameterVector{});
 
@@ -1527,7 +1526,7 @@ TEST(constant_folding, const_less_eq)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::LessEq>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::LessEqual>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
@@ -2124,7 +2123,7 @@ TEST(constant_folding, constant_v1_select)
     pass_manager.register_pass<pass::ConstantFolding>();
     pass_manager.run_passes(f);
 
-    ASSERT_EQ(count_ops_of_type<op::Select>(f), 0);
+    ASSERT_EQ(count_ops_of_type<op::v1::Select>(f), 0);
     ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
 
     auto new_const =
diff --git a/ngraph/test/control_dependencies.cpp b/ngraph/test/control_dependencies.cpp
index 7d6e66da874615..f78710d318aabf 100644
--- a/ngraph/test/control_dependencies.cpp
+++ b/ngraph/test/control_dependencies.cpp
@@ -36,8 +36,6 @@
 #include "util/random.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace ngraph;
 using namespace std;
 
@@ -177,10 +175,10 @@ TEST(control_dependencies, replace_node)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto MUL_AB = A * B;
-    auto MUL_BA = B * A;
-    auto ADD = A + B;
-    auto SUM = MUL_AB + ADD;
+    auto MUL_AB = make_shared<op::v1::Multiply>(A, B);
+    auto MUL_BA = make_shared<op::v1::Multiply>(B, A);
+    auto ADD = make_shared<op::v1::Add>(A, B);
+    auto SUM = make_shared<op::v1::Add>(MUL_AB, ADD);
     ADD->add_control_dependency(MUL_AB);
     ASSERT_TRUE(1 == count_control_dependencies(ADD, MUL_AB));
     ASSERT_TRUE(0 == count_control_dependencies(ADD, MUL_BA));
diff --git a/ngraph/test/copy.cpp b/ngraph/test/copy.cpp
index f1c97ec4837389..05a23050c3f7b3 100644
--- a/ngraph/test/copy.cpp
+++ b/ngraph/test/copy.cpp
@@ -24,8 +24,6 @@
 #include "util/ndarray.hpp"
 #include "util/test_tools.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -69,7 +67,7 @@ TEST(copy, acos)
 
 TEST(copy, add)
 {
-    ASSERT_TRUE(check_binary<op::Add>());
+    ASSERT_TRUE(check_binary<op::v1::Add>());
 }
 
 TEST(copy, asin)
@@ -178,12 +176,12 @@ TEST(copy, cosh)
 
 TEST(copy, divide)
 {
-    ASSERT_TRUE(check_binary<op::Divide>());
+    ASSERT_TRUE(check_binary<op::v1::Divide>());
 }
 
 TEST(copy, equal)
 {
-    ASSERT_TRUE(check_binary<op::Equal>());
+    ASSERT_TRUE(check_binary<op::v1::Equal>());
 }
 
 TEST(copy, exp)
@@ -198,22 +196,22 @@ TEST(copy, floor)
 
 TEST(copy, greater_eq)
 {
-    ASSERT_TRUE(check_binary<op::GreaterEq>());
+    ASSERT_TRUE(check_binary<op::v1::GreaterEqual>());
 }
 
 TEST(copy, greater)
 {
-    ASSERT_TRUE(check_binary<op::Greater>());
+    ASSERT_TRUE(check_binary<op::v1::Greater>());
 }
 
 TEST(copy, less_eq)
 {
-    ASSERT_TRUE(check_binary<op::LessEq>());
+    ASSERT_TRUE(check_binary<op::v1::LessEqual>());
 }
 
 TEST(copy, less)
 {
-    ASSERT_TRUE(check_binary<op::Less>());
+    ASSERT_TRUE(check_binary<op::v1::Less>());
 }
 
 TEST(copy, log)
@@ -223,17 +221,17 @@ TEST(copy, log)
 
 TEST(copy, maximum)
 {
-    ASSERT_TRUE(check_binary<op::Maximum>());
+    ASSERT_TRUE(check_binary<op::v1::Maximum>());
 }
 
 TEST(copy, minimum)
 {
-    ASSERT_TRUE(check_binary<op::Minimum>());
+    ASSERT_TRUE(check_binary<op::v1::Minimum>());
 }
 
 TEST(copy, multiply)
 {
-    ASSERT_TRUE(check_binary<op::Multiply>());
+    ASSERT_TRUE(check_binary<op::v1::Multiply>());
 }
 
 TEST(copy, negative)
@@ -243,7 +241,7 @@ TEST(copy, negative)
 
 TEST(copy, not_equal)
 {
-    ASSERT_TRUE(check_binary<op::NotEqual>());
+    ASSERT_TRUE(check_binary<op::v1::NotEqual>());
 }
 
 TEST(copy, parameter)
@@ -261,7 +259,7 @@ TEST(copy, parameter)
 
 TEST(copy, power)
 {
-    ASSERT_TRUE(check_binary<op::Power>());
+    ASSERT_TRUE(check_binary<op::v1::Power>());
 }
 
 TEST(copy, reduce_sum)
@@ -316,9 +314,9 @@ TEST(copy, select)
                           make_shared<op::Parameter>(element::Type_t::f32, shape),
                           make_shared<op::Parameter>(element::Type_t::f32, shape)};
 
-    auto node = make_shared<op::Select>(arg0, arg1, arg2);
+    auto node = make_shared<op::v1::Select>(arg0, arg1, arg2);
     auto new_node = node->clone_with_new_inputs(new_args);
-    auto node_cast = as_type_ptr<op::Select>(new_node);
+    auto node_cast = as_type_ptr<op::v1::Select>(new_node);
     ASSERT_NE(node_cast, nullptr);
 
     ASSERT_TRUE(nullptr != new_node);
@@ -385,7 +383,7 @@ TEST(copy, strided_slice)
 
 TEST(copy, subtract)
 {
-    ASSERT_TRUE(check_binary<op::Subtract>());
+    ASSERT_TRUE(check_binary<op::v1::Subtract>());
 }
 
 TEST(copy, tan)
diff --git a/ngraph/test/eval.cpp b/ngraph/test/eval.cpp
index f551e39880052f..1fed4473ac16ba 100644
--- a/ngraph/test/eval.cpp
+++ b/ngraph/test/eval.cpp
@@ -132,7 +132,7 @@ TEST(eval, max_eval_minimum_constant)
 {
     auto c = op::Constant::create<int64_t>(element::Type_t::i64, Shape{}, {27});
     auto p = make_shared<op::Parameter>(element::Type_t::i64, Shape{});
-    auto m = make_shared<op::Minimum>(c, p);
+    auto m = make_shared<op::v1::Minimum>(c, p);
     auto result = maximum_value(m);
     ASSERT_TRUE(result.first);
     EXPECT_EQ(result.second, 27);
diff --git a/ngraph/test/input_output_assign.cpp b/ngraph/test/input_output_assign.cpp
index 61c125bf5f85b6..69c20a464123fc 100644
--- a/ngraph/test/input_output_assign.cpp
+++ b/ngraph/test/input_output_assign.cpp
@@ -41,7 +41,7 @@ TEST(input_output, simple_output)
 {
     auto param_0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
     auto param_1 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
-    auto add = make_shared<op::Add>(param_0, param_1);
+    auto add = make_shared<op::v1::Add>(param_0, param_1);
 
     // Sort the ops
     vector<shared_ptr<Node>> nodes;
diff --git a/ngraph/test/models/onnx/matmul_integer.prototxt b/ngraph/test/models/onnx/matmul_integer.prototxt
deleted file mode 100644
index bc44b1fcd3fa85..00000000000000
--- a/ngraph/test/models/onnx/matmul_integer.prototxt
+++ /dev/null
@@ -1,88 +0,0 @@
-ir_version: 5
-producer_name: "nGraph ONNX Importer"
-graph {
-  node {
-    input: "a"
-    input: "b"
-    input: "a_zero_point"
-    input: "b_zero_point"
-    output: "y"
-    name: "node1"
-    op_type: "MatMulInteger"
-    doc_string: "MatMulInteger"
-    domain: ""
-  }
-  name: "test"
-  input {
-    name: "a"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 4
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "b"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 2
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "a_zero_point"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-        }
-      }
-    }
-  }
-  input {
-    name: "b_zero_point"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-        }
-      }
-    }
-  }
-  output {
-    name: "y"
-    type {
-      tensor_type {
-        elem_type: 6
-        shape {
-          dim {
-            dim_value: 4
-          }
-          dim {
-            dim_value: 2
-          }
-        }
-      }
-    }
-  }
-}
-opset_import {
-  domain: ""
-  version: 10
-}
diff --git a/ngraph/test/models/onnx/matmul_integer_4d.prototxt b/ngraph/test/models/onnx/matmul_integer_4d.prototxt
deleted file mode 100644
index 61c517e3c4d6cc..00000000000000
--- a/ngraph/test/models/onnx/matmul_integer_4d.prototxt
+++ /dev/null
@@ -1,106 +0,0 @@
-ir_version: 5
-producer_name: "nGraph ONNX Importer"
-graph {
-  node {
-    input: "a"
-    input: "b"
-    input: "a_zero_point"
-    input: "b_zero_point"
-    output: "y"
-    name: "node1"
-    op_type: "MatMulInteger"
-    doc_string: "MatMulInteger"
-    domain: ""
-  }
-  name: "test"
-  input {
-    name: "a"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 2
-          }
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 4
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "b"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 2
-          }
-          dim {
-            dim_value: 4
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "a_zero_point"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-        }
-      }
-    }
-  }
-  input {
-    name: "b_zero_point"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-        }
-      }
-    }
-  }
-  output {
-    name: "y"
-    type {
-      tensor_type {
-        elem_type: 6
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 2
-          }
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-}
-opset_import {
-  domain: ""
-  version: 10
-}
diff --git a/ngraph/test/models/onnx/matmul_integer_4d_no_zero_point.prototxt b/ngraph/test/models/onnx/matmul_integer_4d_no_zero_point.prototxt
deleted file mode 100644
index c82e49f383c38e..00000000000000
--- a/ngraph/test/models/onnx/matmul_integer_4d_no_zero_point.prototxt
+++ /dev/null
@@ -1,84 +0,0 @@
-ir_version: 5
-producer_name: "nGraph ONNX Importer"
-graph {
-  node {
-    input: "a"
-    input: "b"
-    output: "y"
-    name: "node1"
-    op_type: "MatMulInteger"
-    doc_string: "MatMulInteger"
-    domain: ""
-  }
-  name: "test"
-  input {
-    name: "a"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 2
-          }
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 4
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "b"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 2
-          }
-          dim {
-            dim_value: 4
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-  output {
-    name: "y"
-    type {
-      tensor_type {
-        elem_type: 6
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 2
-          }
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-}
-opset_import {
-  domain: ""
-  version: 10
-}
diff --git a/ngraph/test/models/onnx/matmul_integer_no_zero_point.prototxt b/ngraph/test/models/onnx/matmul_integer_no_zero_point.prototxt
deleted file mode 100644
index 505f72d7f373fb..00000000000000
--- a/ngraph/test/models/onnx/matmul_integer_no_zero_point.prototxt
+++ /dev/null
@@ -1,66 +0,0 @@
-ir_version: 5
-producer_name: "nGraph ONNX Importer"
-graph {
-  node {
-    input: "a"
-    input: "b"
-    output: "y"
-    name: "node1"
-    op_type: "MatMulInteger"
-    doc_string: "MatMulInteger"
-    domain: ""
-  }
-  name: "test"
-  input {
-    name: "a"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 4
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "b"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 2
-          }
-        }
-      }
-    }
-  }
-  output {
-    name: "y"
-    type {
-      tensor_type {
-        elem_type: 6
-        shape {
-          dim {
-            dim_value: 4
-          }
-          dim {
-            dim_value: 2
-          }
-        }
-      }
-    }
-  }
-}
-opset_import {
-  domain: ""
-  version: 10
-}
diff --git a/ngraph/test/models/onnx/matmul_integer_scalar.prototxt b/ngraph/test/models/onnx/matmul_integer_scalar.prototxt
deleted file mode 100644
index 1d1900b031a35c..00000000000000
--- a/ngraph/test/models/onnx/matmul_integer_scalar.prototxt
+++ /dev/null
@@ -1,88 +0,0 @@
-ir_version: 5
-producer_name: "nGraph ONNX Importer"
-graph {
-  node {
-    input: "a"
-    input: "b"
-    input: "a_zero_point"
-    input: "b_zero_point"
-    output: "y"
-    name: "node1"
-    op_type: "MatMulInteger"
-    doc_string: "MatMulInteger"
-    domain: ""
-  }
-  name: "test"
-  input {
-    name: "a"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 1
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "b"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 1
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "a_zero_point"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-        }
-      }
-    }
-  }
-  input {
-    name: "b_zero_point"
-    type {
-      tensor_type {
-        elem_type: 2
-        shape {
-        }
-      }
-    }
-  }
-  output {
-    name: "y"
-    type {
-      tensor_type {
-        elem_type: 6
-        shape {
-          dim {
-            dim_value: 1
-          }
-          dim {
-            dim_value: 1
-          }
-        }
-      }
-    }
-  }
-}
-opset_import {
-  domain: ""
-  version: 10
-}
diff --git a/ngraph/test/models/onnx/provenance_downgrade_topk.prototxt b/ngraph/test/models/onnx/provenance_downgrade_topk.prototxt
deleted file mode 100644
index 0369588e46b7f6..00000000000000
--- a/ngraph/test/models/onnx/provenance_downgrade_topk.prototxt
+++ /dev/null
@@ -1,77 +0,0 @@
-ir_version: 4
-producer_name: "nGraph ONNX Importer"
-graph {
-  node {
-    input: "x"
-    input: "k"
-    output: "values"
-    output: "indices"
-    op_type: "TopK"
-    name: "TOPK"
-  }
-  name: "test_graph"
-  input {
-    name: "x"
-    type {
-      tensor_type {
-        elem_type: 1
-        shape {
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 4
-          }
-        }
-      }
-    }
-  }
-  input {
-    name: "k"
-    type {
-      tensor_type {
-        elem_type: 7
-        shape {
-          dim {
-            dim_value: 1
-          }
-        }
-      }
-    }
-  }
-  output {
-    name: "values"
-    type {
-      tensor_type {
-        elem_type: 1
-        shape {
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-  output {
-    name: "indices"
-    type {
-      tensor_type {
-        elem_type: 7
-        shape {
-          dim {
-            dim_value: 3
-          }
-          dim {
-            dim_value: 3
-          }
-        }
-      }
-    }
-  }
-}
-opset_import {
-  version: 10
-}
diff --git a/ngraph/test/node_input_output.cpp b/ngraph/test/node_input_output.cpp
index 4104e68166770d..473571f4208aa4 100644
--- a/ngraph/test/node_input_output.cpp
+++ b/ngraph/test/node_input_output.cpp
@@ -32,7 +32,7 @@ TEST(node_input_output, input_create)
 {
     auto x = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
     auto y = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
-    auto add = make_shared<op::Add>(x, y);
+    auto add = make_shared<op::v1::Add>(x, y);
 
     auto add_in_0 = add->input(0);
     auto add_in_1 = add->input(1);
@@ -58,7 +58,7 @@ TEST(node_input_output, input_create_const)
 {
     auto x = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
     auto y = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
-    auto add = make_shared<const op::Add>(x, y);
+    auto add = make_shared<const op::v1::Add>(x, y);
 
     auto add_in_0 = add->input(0);
     auto add_in_1 = add->input(1);
@@ -84,7 +84,7 @@ TEST(node_input_output, output_create)
 {
     auto x = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
     auto y = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
-    auto add = make_shared<op::Add>(x, y);
+    auto add = make_shared<op::v1::Add>(x, y);
 
     auto add_out_0 = add->output(0);
 
@@ -101,7 +101,7 @@ TEST(node_input_output, output_create_const)
 {
     auto x = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
     auto y = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3, 4});
-    auto add = make_shared<const op::Add>(x, y);
+    auto add = make_shared<const op::v1::Add>(x, y);
 
     auto add_out_0 = add->output(0);
 
diff --git a/ngraph/test/onnx/onnx_import.in.cpp b/ngraph/test/onnx/onnx_import.in.cpp
index 2d412e58acc180..d7844873f6b276 100644
--- a/ngraph/test/onnx/onnx_import.in.cpp
+++ b/ngraph/test/onnx/onnx_import.in.cpp
@@ -199,13 +199,13 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_override_op)
     onnx_import::register_operator(
         "FalseAdd", 1, "", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Add>(ng_inputs.at(0), ng_inputs.at(1))};
         });
 
     onnx_import::register_operator(
         "FalseAdd", 1, "", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Subtract>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Subtract>(ng_inputs.at(0), ng_inputs.at(1))};
         });
 
     auto function = onnx_import::import_onnx_model(
@@ -261,7 +261,7 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_custom_op)
     onnx_import::register_operator(
         "AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Add>(ng_inputs.at(0), ng_inputs.at(1))};
         });
 
     auto function = onnx_import::import_onnx_model(
@@ -278,7 +278,7 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_custom_op_register_unregister)
     onnx_import::register_operator(
         "AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Add>(ng_inputs.at(0), ng_inputs.at(1))};
         });
 
     auto function = onnx_import::import_onnx_model(
@@ -312,7 +312,7 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_custom_op_default_domain)
     onnx_import::register_operator(
         "AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Add>(ng_inputs.at(0), ng_inputs.at(1))};
         });
 
     auto function = onnx_import::import_onnx_model(
@@ -350,7 +350,7 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_is_op_supported)
     onnx_import::register_operator(
         "AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Add>(ng_inputs.at(0), ng_inputs.at(1))};
         });
     EXPECT_TRUE(onnx_import::is_operator_supported("AddQ", 1, "com.intel.ai"));
 }
@@ -360,7 +360,7 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_missing_op_domain)
     onnx_import::register_operator(
         "CustomAdd", 1, "custom.op", [](const onnx_import::Node& node) -> OutputVector {
             OutputVector ng_inputs{node.get_ng_inputs()};
-            return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
+            return {std::make_shared<ngraph::op::v1::Add>(ng_inputs.at(0), ng_inputs.at(1))};
         });
 
     EXPECT_TRUE(onnx_import::is_operator_supported("CustomAdd", 1, "custom.op"));
@@ -412,13 +412,13 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_missing_input)
             Output<ngraph::Node> B = ng_inputs.at(1);
             Output<ngraph::Node> C = ng_inputs.at(2);
 
-            A = A * C;
+            A = std::make_shared<op::v1::Multiply>(A, C);
             if (!ngraph::op::is_null(B))
             {
-                B = B / C;
+                B = std::make_shared<op::v1::Divide>(B, C);
             }
 
-            C = C + C;
+            C = std::make_shared<ngraph::op::v1::Add>(C, C);
             return {A, B, C};
         });
 
@@ -432,7 +432,7 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_missing_input)
             {
                 if (!ngraph::op::is_null(ng_input))
                 {
-                    result = ng_input * result;
+                    result = std::make_shared<op::v1::Multiply>(ng_input, result);
                 }
             }
 
diff --git a/ngraph/test/onnx/onnx_import_provenance.in.cpp b/ngraph/test/onnx/onnx_import_provenance.in.cpp
index 222af22be8c8a6..b06f75857d4815 100644
--- a/ngraph/test/onnx/onnx_import_provenance.in.cpp
+++ b/ngraph/test/onnx/onnx_import_provenance.in.cpp
@@ -20,9 +20,6 @@
 #include "ngraph/provenance.hpp"
 #include "onnx_import/default_opset.hpp"
 #include "onnx_import/onnx.hpp"
-#include "opset0.hpp"
-#include "pass/opset0_downgrade.hpp"
-#include "pass/opset1_downgrade.hpp"
 #include "util/provenance_enabler.hpp"
 #include "util/test_control.hpp"
 #include "util/type_prop.hpp"
@@ -115,21 +112,3 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_provenance_tagging_parameters)
         file_util::path_join(SERIALIZED_ZOO, "onnx/provenance_input_tags.prototxt"));
     test_provenance_tags<default_opset::Parameter>(function, "<ONNX Input (input_B) Shape:{}>");
 }
-
-NGRAPH_SUPPRESS_DEPRECATED_START
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_provenance_tag_downgrade_pass)
-{
-    test::ProvenanceEnabler provenance_enabler;
-
-    const auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/provenance_downgrade_topk.prototxt"));
-
-    ngraph::pass::Manager pass_manager;
-    pass_manager.register_pass<pass::Opset1Downgrade>();
-    pass_manager.register_pass<pass::Opset0Downgrade>();
-    pass_manager.run_passes(function);
-
-    test_provenance_tags<ngraph::op::v1::TopK>(function, "<ONNX TopK (TOPK -> values, indices)>");
-    test_provenance_tags<ngraph::op::v1::TopK>(function, "<Opset1_Downgrade (v3 TopK)>");
-}
diff --git a/ngraph/test/onnx/onnx_import_quant.in.cpp b/ngraph/test/onnx/onnx_import_quant.in.cpp
index 910905aa24bb9b..9af8f29b83788e 100644
--- a/ngraph/test/onnx/onnx_import_quant.in.cpp
+++ b/ngraph/test/onnx/onnx_import_quant.in.cpp
@@ -307,27 +307,6 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_quant_conv_linear_3d)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_qlinear_matmul)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/qlinear_matmul.prototxt"));
-
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{208, 236, 0, 238, 3, 214, 255, 29}); // T1
-    test_case.add_input(std::vector<float>{0.0066f});                             // a_scale
-    test_case.add_input(std::vector<uint8_t>{113});                               // a_zero_point
-    test_case.add_input(
-        std::vector<uint8_t>{152, 51, 244, 60, 26, 255, 0, 127, 246, 127, 254, 247}); // T2
-    test_case.add_input(std::vector<float>{0.00705f});                                // b_scale
-    test_case.add_input(std::vector<uint8_t>{114});   // b_zero_point
-    test_case.add_input(std::vector<float>{0.0107f}); // y_scale
-    test_case.add_input(std::vector<uint8_t>{118});   // y_zero_point
-
-    test_case.add_expected_output({2, 3}, std::vector<uint8_t>{168, 115, 255, 1, 66, 151}); // T3
-    test_case.run();
-}
-
 NGRAPH_TEST(${BACKEND_NAME}, onnx_model_qlinear_matmul_3d)
 {
     auto function = onnx_import::import_onnx_model(
@@ -410,170 +389,6 @@ NGRAPH_TEST(${BACKEND_NAME}, onnx_model_conv_integer_pads)
     test_case.run();
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{11, 7, 3, 10, 6, 2, 9, 5, 1, 8, 4, 0}); // a
-    test_case.add_input(std::vector<uint8_t>{1, 4, 2, 5, 3, 6});                     // b
-    test_case.add_input(std::vector<uint8_t>{12});                                   // a_zero_point
-    test_case.add_input(std::vector<uint8_t>{0});                                    // b_zero_point
-
-    test_case.add_expected_output(
-        {4, 2}, std::vector<int32_t>{-38, -83, -44, -98, -50, -113, -56, -128}); // y
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer_zero_point_zero)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{11, 7, 3, 10, 6, 2, 9, 5, 1, 8, 4, 0}); // a
-    test_case.add_input(std::vector<uint8_t>{1, 4, 2, 5, 3, 6});                     // b
-    test_case.add_input(std::vector<uint8_t>{0});                                    // a_zero_point
-    test_case.add_input(std::vector<uint8_t>{0});                                    // b_zero_point
-
-    test_case.add_expected_output({4, 2},
-                                  std::vector<int32_t>{34, 97, 28, 82, 22, 67, 16, 52}); // y
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer_no_zero_point)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer_no_zero_point.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{11, 7, 3, 10, 6, 2, 9, 5, 1, 8, 4, 0}); // a
-    test_case.add_input(std::vector<uint8_t>{1, 4, 2, 5, 3, 6});                     // b
-
-    test_case.add_expected_output({4, 2},
-                                  std::vector<int32_t>{34, 97, 28, 82, 22, 67, 16, 52}); // y
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer_scalar)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer_scalar.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{11}); // a
-    test_case.add_input(std::vector<uint8_t>{13}); // b
-    test_case.add_input(std::vector<uint8_t>{12}); // a_zero_point
-    test_case.add_input(std::vector<uint8_t>{12}); // b_zero_point
-
-    test_case.add_expected_output({1, 1}, std::vector<int32_t>{-1}); // y
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer_4d)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer_4d.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
-                                             12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}); // a
-    test_case.add_input(std::vector<uint8_t>{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
-                                             12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}); // b
-    test_case.add_input(std::vector<uint8_t>{0}); // a_zero_point
-    test_case.add_input(std::vector<uint8_t>{0}); // b_zero_point
-
-    test_case.add_expected_output<int32_t>(Shape{1, 2, 3, 3},
-                                           {42,
-                                            48,
-                                            54,
-                                            114,
-                                            136,
-                                            158,
-                                            186,
-                                            224,
-                                            262,
-                                            906,
-                                            960,
-                                            1014,
-                                            1170,
-                                            1240,
-                                            1310,
-                                            1434,
-                                            1520,
-                                            1606}); // y
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer_4d_zero_point)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer_4d.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
-                                             12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}); // a
-    test_case.add_input(std::vector<uint8_t>{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
-                                             12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}); // b
-    test_case.add_input(std::vector<uint8_t>{1}); // a_zero_point
-    test_case.add_input(std::vector<uint8_t>{1}); // b_zero_point
-
-    test_case.add_expected_output<int32_t>(Shape{1, 2, 3, 3},
-                                           {22,
-                                            24,
-                                            26,
-                                            78,
-                                            96,
-                                            114,
-                                            134,
-                                            168,
-                                            202,
-                                            790,
-                                            840,
-                                            890,
-                                            1038,
-                                            1104,
-                                            1170,
-                                            1286,
-                                            1368,
-                                            1450}); // y
-    test_case.run();
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, onnx_model_matmul_integer_4d_no_zero_point)
-{
-    auto function = onnx_import::import_onnx_model(
-        file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_integer_4d_no_zero_point.prototxt"));
-    auto test_case = test::TestCase<TestEngine>(function);
-
-    test_case.add_input(std::vector<uint8_t>{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
-                                             12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}); // a
-    test_case.add_input(std::vector<uint8_t>{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
-                                             12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}); // b
-
-    test_case.add_expected_output<int32_t>(Shape{1, 2, 3, 3},
-                                           {42,
-                                            48,
-                                            54,
-                                            114,
-                                            136,
-                                            158,
-                                            186,
-                                            224,
-                                            262,
-                                            906,
-                                            960,
-                                            1014,
-                                            1170,
-                                            1240,
-                                            1310,
-                                            1434,
-                                            1520,
-                                            1606}); // y
-    test_case.run();
-}
-
 NGRAPH_TEST(${BACKEND_NAME}, onnx_model_fake_quantize_import_only)
 {
     const auto function = onnx_import::import_onnx_model(file_util::path_join(
diff --git a/ngraph/test/op.cpp b/ngraph/test/op.cpp
index 380b177125d395..ffc92ea124c3a3 100644
--- a/ngraph/test/op.cpp
+++ b/ngraph/test/op.cpp
@@ -42,7 +42,7 @@ TEST(op, is_parameter)
 {
     auto arg0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{1});
     ASSERT_NE(nullptr, arg0);
-    auto t0 = make_shared<op::Add>(arg0, arg0);
+    auto t0 = make_shared<op::v1::Add>(arg0, arg0);
     ASSERT_NE(nullptr, t0);
     EXPECT_FALSE(op::is_parameter(t0));
 }
diff --git a/ngraph/test/op_is.cpp b/ngraph/test/op_is.cpp
index f8a6bf1f8bf8c5..ce65d59cc7e6ad 100644
--- a/ngraph/test/op_is.cpp
+++ b/ngraph/test/op_is.cpp
@@ -47,15 +47,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Add()
-    {
-        op::Add node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_Asin()
     {
         op::Asin node;
@@ -200,15 +191,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Divide()
-    {
-        op::Divide node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_Elu()
     {
         op::Elu node;
@@ -245,15 +227,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Equal()
-    {
-        op::Equal node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_Erf()
     {
         op::Erf node;
@@ -344,24 +317,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Greater()
-    {
-        op::Greater node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
-    void op_is_GreaterEq()
-    {
-        op::GreaterEq node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_GroupConvolution()
     {
         op::v0::GroupConvolution node;
@@ -398,24 +353,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Less()
-    {
-        op::Less node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
-    void op_is_LessEq()
-    {
-        op::LessEq node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_Log()
     {
         op::Log node;
@@ -470,38 +407,20 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_NormalizeL2()
-    {
-        op::NormalizeL2 node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
-    void op_is_Maximum()
-    {
-        op::Maximum node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
-    void op_is_Minimum()
+    void op_is_Multiply()
     {
-        op::Minimum node;
+        op::v0::Multiply node;
         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Multiply()
+    void op_is_NormalizeL2()
     {
-        op::Multiply node;
+        op::NormalizeL2 node;
         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
+        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
@@ -524,15 +443,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_NotEqual()
-    {
-        op::NotEqual node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_OneHot()
     {
         op::v1::OneHot node;
@@ -551,15 +461,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Power()
-    {
-        op::Power node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_PRelu()
     {
         op::PRelu node;
@@ -677,15 +578,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Select()
-    {
-        op::Select node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_Selu()
     {
         op::Selu node;
@@ -803,15 +695,6 @@ namespace
         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
     }
 
-    void op_is_Subtract()
-    {
-        op::Subtract node;
-        EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
-        EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
-        EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
-    }
-
     void op_is_Tan()
     {
         op::Tan node;
diff --git a/ngraph/test/pass_shape_relevance.cpp b/ngraph/test/pass_shape_relevance.cpp
index 18be6e268a3d2c..66568d0b83914d 100644
--- a/ngraph/test/pass_shape_relevance.cpp
+++ b/ngraph/test/pass_shape_relevance.cpp
@@ -34,7 +34,7 @@ TEST(shape_relevance, simple)
 {
     auto param0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{4, 6});
     auto param1 = make_shared<op::Parameter>(element::Type_t::f32, Shape{4, 6});
-    auto x = make_shared<op::Add>(param0, param1);
+    auto x = make_shared<op::v1::Add>(param0, param1);
 
     auto f = make_shared<Function>(x, ParameterVector{param0, param1});
 
diff --git a/ngraph/test/pattern.cpp b/ngraph/test/pattern.cpp
index 0ee8871b3b283d..3f862603896c37 100644
--- a/ngraph/test/pattern.cpp
+++ b/ngraph/test/pattern.cpp
@@ -60,15 +60,15 @@ static std::shared_ptr<pattern::op::Label> construct_variance_graph()
     // construct varaiance
     auto N = op::Constant::create(element::Type_t::f32, Shape{3}, {2, 2, 2});
     auto input = std::make_shared<pattern::op::Label>(element::Type_t::f32, Shape{2, 3});
-    auto input_sq = std::make_shared<op::Multiply>(input, input);
+    auto input_sq = std::make_shared<op::v1::Multiply>(input, input);
     auto sum_input = std::make_shared<op::v1::ReduceSum>(
         input, op::Constant::create(element::Type_t::i64, {1}, {0}));
-    auto square_sumed_input = std::make_shared<op::Multiply>(sum_input, sum_input);
+    auto square_sumed_input = std::make_shared<op::v1::Multiply>(sum_input, sum_input);
     auto sum_squared_input = std::make_shared<op::v1::ReduceSum>(
         input_sq, op::Constant::create(element::Type_t::i64, {1}, {0}));
-    auto avg_input_sum_sq = std::make_shared<op::Divide>(square_sumed_input, N);
-    auto xmu = std::make_shared<op::Subtract>(sum_squared_input, avg_input_sum_sq);
-    auto variance = std::make_shared<op::Divide>(xmu, N);
+    auto avg_input_sum_sq = std::make_shared<op::v1::Divide>(square_sumed_input, N);
+    auto xmu = std::make_shared<op::v1::Subtract>(sum_squared_input, avg_input_sum_sq);
+    auto variance = std::make_shared<op::v1::Divide>(xmu, N);
     auto variance_label =
         std::make_shared<pattern::op::Label>(variance, nullptr, NodeVector{variance});
 
@@ -82,7 +82,7 @@ static std::shared_ptr<pattern::op::Label> construct_mean_graph()
     auto N = op::Constant::create(element::Type_t::f32, Shape{3}, {2, 2, 2});
     auto sum_input1 = std::make_shared<op::v1::ReduceSum>(
         input, op::Constant::create(element::Type_t::i64, {1}, {0}));
-    auto mean = std::make_shared<op::Divide>(sum_input1, N);
+    auto mean = std::make_shared<op::v1::Divide>(sum_input1, N);
     auto mean_label = std::make_shared<pattern::op::Label>(mean, nullptr, NodeVector{mean});
     return mean_label;
 }
@@ -133,7 +133,7 @@ class TestGraphRewrite : public ngraph::pass::GraphRewrite
             return true;
         };
 
-        auto m = make_shared<TestMatcher>(pattern * iconst1);
+        auto m = make_shared<TestMatcher>(make_shared<op::v1::Multiply>(pattern, iconst1));
         NGRAPH_SUPPRESS_DEPRECATED_START
         this->add_matcher(m, callback);
         NGRAPH_SUPPRESS_DEPRECATED_END
@@ -182,7 +182,7 @@ class TestGraphRewrite : public ngraph::pass::GraphRewrite
             return true;
         };
 
-        auto add = pattern + iconst0;
+        auto add = make_shared<op::v1::Add>(pattern, iconst0);
         auto m = make_shared<TestMatcher>(add);
         NGRAPH_SUPPRESS_DEPRECATED_START
         this->add_matcher(m, callback);
@@ -216,8 +216,8 @@ TEST(pattern, graph_rewrite)
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto c = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst0 = construct_constant_node(0);
-        auto graph_a = a + iconst0;
-        auto graph_b = b + iconst0;
+        auto graph_a = make_shared<op::v1::Add>(a, iconst0);
+        auto graph_b = make_shared<op::v1::Add>(b, iconst0);
 
         auto f = std::make_shared<Function>(ngraph::NodeVector{a, b, graph_a, c, graph_b},
                                             ParameterVector{a, b, c});
@@ -227,15 +227,15 @@ TEST(pattern, graph_rewrite)
         ASSERT_TRUE(graph_b->get_output_target_inputs(0).empty());
 
         auto expected = ngraph::NodeVector{a, b, a, c, b};
-        ASSERT_TRUE(count_ops_of_type<op::Add>(f) == 0);
+        ASSERT_TRUE(count_ops_of_type<op::v1::Add>(f) == 0);
     }
 
     {
         auto a = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst0 = construct_constant_node(0);
-        auto sum = (a + iconst0);
-        auto graph = b + sum;
+        auto sum = make_shared<op::v1::Add>(a, iconst0);
+        auto graph = make_shared<op::v1::Add>(b, sum);
         run_passes(pass_manager, graph, {a, b});
         ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
         ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
@@ -250,8 +250,8 @@ TEST(pattern, graph_rewrite)
         auto a = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst1 = construct_constant_node(1);
-        auto mul = (a * iconst1);
-        auto graph = b + mul;
+        auto mul = make_shared<op::v1::Multiply>(a, iconst1);
+        auto graph = make_shared<op::v1::Add>(b, mul);
         run_passes(pass_manager, graph, {a, b});
         ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
         ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
@@ -266,7 +266,11 @@ TEST(pattern, graph_rewrite)
         auto a = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst1 = construct_constant_node(1);
-        auto graph = ((((a * iconst1) * iconst1) * iconst1) * iconst1) + b;
+        auto multiply =
+            make_shared<op::v1::Multiply>(make_shared<op::v1::Multiply>(a, iconst1), iconst1);
+        multiply = make_shared<op::v1::Multiply>(make_shared<op::v1::Multiply>(multiply, iconst1),
+                                                 iconst1);
+        auto graph = make_shared<op::v1::Add>(multiply, b);
         run_passes(pass_manager, graph, {a, b});
         ASSERT_EQ(graph->input_value(0).get_node_shared_ptr(), a);
         ASSERT_EQ(graph->input_value(0), a->output(0)); // graph's input points to a's output
@@ -279,7 +283,8 @@ TEST(pattern, graph_rewrite)
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst0 = construct_constant_node(0);
         auto iconst1 = construct_constant_node(1);
-        auto graph = b + (iconst0 + ((a + iconst0) * iconst1));
+        auto mul = make_shared<op::v1::Multiply>(make_shared<op::v1::Add>(a, iconst0), iconst1);
+        auto graph = make_shared<op::v1::Add>(b, make_shared<op::v1::Add>(iconst0, mul));
         run_passes(pass_manager, graph, {a, b});
         ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
         ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
@@ -291,7 +296,10 @@ TEST(pattern, graph_rewrite)
         auto a = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst1 = construct_constant_node(1);
-        auto graph = b + (iconst1 * (iconst1 * (iconst1 * (iconst1 * a))));
+        auto mul =
+            make_shared<op::v1::Multiply>(iconst1, make_shared<op::v1::Multiply>(iconst1, a));
+        mul = make_shared<op::v1::Multiply>(iconst1, make_shared<op::v1::Multiply>(iconst1, mul));
+        auto graph = make_shared<op::v1::Add>(b, mul);
         run_passes(pass_manager, graph, {a, b});
         ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
         ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
@@ -333,19 +341,19 @@ TEST(pattern, matcher)
         return op::is_binary_elementwise_arithmetic(node);
     };
     auto bea = std::make_shared<pattern::op::Any>(a, is_bea, NodeVector{a, b});
-    auto add_ab = a + b;
+    auto add_ab = std::make_shared<op::v1::Add>(a, b);
     ASSERT_TRUE(n.match(bea, add_ab));
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{add_ab, a, b}));
-    ASSERT_TRUE(n.match(bea, b + a));
+    ASSERT_TRUE(n.match(bea, std::make_shared<op::v1::Add>(b, a)));
 
     auto bea_false = std::make_shared<pattern::op::Any>(a, false_pred, NodeVector{a, b});
-    ASSERT_FALSE(n.match(bea_false, a + b));
+    ASSERT_FALSE(n.match(bea_false, std::make_shared<op::v1::Add>(a, b)));
 
-    auto add_abs_b = abs + b;
+    auto add_abs_b = std::make_shared<op::v1::Add>(abs, b);
     auto bea_any_of = std::make_shared<pattern::op::AnyOf>(a, is_bea, NodeVector{abs});
     ASSERT_TRUE(n.match(bea_any_of, add_abs_b));
 
-    auto add_b_abs = b + abs;
+    auto add_b_abs = std::make_shared<op::v1::Add>(b, abs);
     ASSERT_TRUE(n.match(bea_any_of, add_b_abs));
 
     auto bea_any_of_label =
@@ -359,102 +367,125 @@ TEST(pattern, matcher)
     ASSERT_EQ(n.get_pattern_map()[abs_label], abs);
 
     auto bea_label = std::make_shared<pattern::op::Label>(a, nullptr, NodeVector{bea});
-    auto ab = a + b;
+    auto ab = std::make_shared<op::v1::Add>(a, b);
     ASSERT_TRUE(n.match(bea_label, ab));
     ASSERT_EQ(n.get_pattern_map()[bea_label], ab);
 
     auto d = make_shared<op::Parameter>(element::Type_t::i32, shape);
     ASSERT_FALSE(n.match(d, b));
 
-    ASSERT_FALSE(n.match(abs + b, b + b));
+    ASSERT_FALSE(
+        n.match(std::make_shared<op::v1::Add>(abs, b), std::make_shared<op::v1::Add>(b, b)));
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{}));
 
-    auto add_absb = abs + b;
-    ASSERT_TRUE(n.match(any + b, add_absb));
+    auto add_absb = std::make_shared<op::v1::Add>(abs, b);
+    ASSERT_TRUE(n.match(std::make_shared<op::v1::Add>(any, b), add_absb));
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{add_absb, abs, a, b}));
 
-    ASSERT_TRUE(n.match(pattern + b, add_absb));
+    ASSERT_TRUE(n.match(std::make_shared<op::v1::Add>(pattern, b), add_absb));
     ASSERT_EQ(n.get_pattern_map()[pattern], abs);
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{add_absb, abs, b}));
 
-    ASSERT_TRUE(n.match(b + pattern, add_absb));
+    ASSERT_TRUE(n.match(std::make_shared<op::v1::Add>(b, pattern), add_absb));
     ASSERT_EQ(n.get_pattern_map()[pattern], abs);
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{add_absb, abs, b}));
 
     auto c = make_shared<op::Parameter>(element::Type_t::i32, shape);
-    auto mul_add_absb = c * (add_absb);
-    ASSERT_TRUE(n.match(c * (b + pattern), mul_add_absb));
+    auto mul_add_absb = std::make_shared<op::v1::Multiply>(c, add_absb);
+    ASSERT_TRUE(
+        n.match(std::make_shared<op::v1::Multiply>(c, std::make_shared<op::v1::Add>(b, pattern)),
+                mul_add_absb));
     ASSERT_EQ(n.get_pattern_map()[pattern], abs);
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{mul_add_absb, c, add_absb, abs, b}));
 
-    ASSERT_TRUE(n.match(c * (any + b), mul_add_absb)); // nested any
+    ASSERT_TRUE(
+        n.match(std::make_shared<op::v1::Multiply>(c, std::make_shared<op::v1::Add>(any, b)),
+                mul_add_absb)); // nested any
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{mul_add_absb, c, add_absb, abs, a, b}));
-    ASSERT_TRUE(n.match(c * (any + b), (b + abs) * c)); // permutations w/ any
-    auto mul_c_add_ab = c * add_ab;
-    ASSERT_TRUE(n.match(c * (any_false + b), c * (a + b)));  // nested any
-    ASSERT_TRUE(n.match(c * (any_false + b), mul_c_add_ab)); // permutations w/ any_false
+    ASSERT_TRUE(
+        n.match(std::make_shared<op::v1::Multiply>(c, std::make_shared<op::v1::Add>(any, b)),
+                std::make_shared<op::v1::Multiply>(std::make_shared<op::v1::Add>(b, abs),
+                                                   c))); // permutations w/ any
+    auto mul_c_add_ab = make_shared<op::v1::Multiply>(c, add_ab);
+    ASSERT_TRUE(
+        n.match(std::make_shared<op::v1::Multiply>(c, std::make_shared<op::v1::Add>(any_false, b)),
+                std::make_shared<op::v1::Multiply>(c, std::make_shared<op::v1::Add>(a, b)))); //
+    // nested any
+    ASSERT_TRUE(
+        n.match(std::make_shared<op::v1::Multiply>(c, std::make_shared<op::v1::Add>(any_false, b)),
+                mul_c_add_ab)); // permutations w/ any_false
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{mul_c_add_ab, c, add_ab, a, a, b}));
 
     auto iconst1_0 = construct_constant_node(1);
     auto iconst1_1 = construct_constant_node(1);
-    ASSERT_TRUE(n.match(pattern * iconst1_0, a * iconst1_1)); // different iconst
+    ASSERT_TRUE(n.match(make_shared<op::v1::Multiply>(pattern, iconst1_0),
+                        make_shared<op::v1::Multiply>(a, iconst1_1))); // different iconst
     ASSERT_EQ(n.get_pattern_map()[pattern], a);
     auto fconst1_0 = op::Constant::create(element::Type_t::f32, shape, {1});
     auto patternf = std::make_shared<pattern::op::Label>(fconst1_0);
-    ASSERT_TRUE(n.match(patternf * fconst1_0, a * iconst1_1)); // different iconst
+    ASSERT_TRUE(n.match(make_shared<op::v1::Multiply>(patternf, fconst1_0),
+                        make_shared<op::v1::Multiply>(a, iconst1_1))); // different iconst
 
     // Subgraph labels
-    auto add = a + b;
+    auto add = std::make_shared<op::v1::Add>(a, b);
     auto label = std::make_shared<pattern::op::Label>(add, nullptr, NodeVector{add});
     ASSERT_TRUE(n.match(label, add));
     ASSERT_EQ(n.get_pattern_map()[label], add);
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{add, add, a, b}));
 
-    ASSERT_FALSE(n.match(label, a - b));
+    ASSERT_FALSE(n.match(label, std::make_shared<op::v1::Subtract>(a, b)));
 
     ASSERT_TRUE(n.match(make_shared<op::Abs>(label), make_shared<op::Abs>(add)));
     ASSERT_EQ(n.get_pattern_map()[label], add);
 
     // Correct argument order
-    ASSERT_FALSE(n.match(b - a, a - b));
-    auto aab = a * (a - b);
-    auto paab = pattern * (pattern - b);
+    ASSERT_FALSE(n.match(make_shared<op::v1::Subtract>(b, a), make_shared<op::v1::Subtract>(a, b)));
+    auto aab = make_shared<op::v1::Multiply>(a, make_shared<op::v1::Subtract>(a, b));
+    auto paab = make_shared<op::v1::Multiply>(pattern, make_shared<op::v1::Subtract>(pattern, b));
     ASSERT_TRUE(n.match(paab, aab));
-    auto aba = a * (b - a);
+    auto aba = make_shared<op::v1::Multiply>(a, make_shared<op::v1::Subtract>(b, a));
     ASSERT_FALSE(n.match(paab, aba));
-    auto paba = pattern * (b - pattern);
+    auto paba = make_shared<op::v1::Multiply>(pattern, make_shared<op::v1::Subtract>(b, pattern));
     ASSERT_FALSE(n.match(paba, aab));
 
     // Correlations
     auto label1 = std::make_shared<pattern::op::Label>(a);
-    auto tmp = label1 + b;
+    auto tmp = std::make_shared<op::v1::Add>(label1, b);
     auto label2 = std::make_shared<pattern::op::Label>(tmp, nullptr, NodeVector{tmp});
-    auto sub_label1 = label1 - label2;
-    auto sub_add = a - add;
+    auto sub_label1 = std::make_shared<op::v1::Subtract>(label1, label2);
+    auto sub_add = std::make_shared<op::v1::Subtract>(a, add);
     ASSERT_TRUE(n.match(sub_label1, sub_add));
     ASSERT_EQ(n.get_pattern_map()[label1], a);
     ASSERT_EQ(n.get_pattern_map()[label2], add);
     ASSERT_EQ(n.get_matched_nodes(), (NodeVector{sub_add, a, add, add, a, b}));
 
-    ASSERT_FALSE(n.match(sub_label1, add - a));
+    ASSERT_FALSE(n.match(sub_label1, std::make_shared<op::v1::Subtract>(add, a)));
 
-    auto add_label1 = label1 + label2;
-    ASSERT_TRUE(n.match(add_label1, add + a));
+    auto add_label1 = std::make_shared<op::v1::Add>(label1, label2);
+    ASSERT_TRUE(n.match(add_label1, std::make_shared<op::v1::Add>(add, a)));
     ASSERT_EQ(n.get_pattern_map()[label1], a);
     ASSERT_EQ(n.get_pattern_map()[label2], add);
 
     // Or
-    ASSERT_TRUE(n.match(std::make_shared<pattern::op::Or>(OutputVector{a + b, a - b}), a + b));
-    ASSERT_TRUE(n.match(std::make_shared<pattern::op::Or>(OutputVector{a + b, a - b}), a - b));
+    ASSERT_TRUE(
+        n.match(std::make_shared<pattern::op::Or>(OutputVector{
+                    std::make_shared<op::v1::Add>(a, b), std::make_shared<op::v1::Subtract>(a, b)}),
+                std::make_shared<op::v1::Add>(a, b)));
+    ASSERT_TRUE(
+        n.match(std::make_shared<pattern::op::Or>(OutputVector{
+                    std::make_shared<op::v1::Add>(a, b), std::make_shared<op::v1::Subtract>(a, b)}),
+                std::make_shared<op::v1::Subtract>(a, b)));
 
     // Branch
     {
         auto branch = std::make_shared<pattern::op::Branch>();
         auto star = std::make_shared<pattern::op::Or>(
             OutputVector{branch, std::make_shared<pattern::op::True>()});
-        auto pattern = star + star;
+        auto pattern = std::make_shared<op::v1::Add>(star, star);
         branch->set_destination(pattern);
-        ASSERT_TRUE(n.match(pattern, ((a + b) + (b + a) + a)));
+        auto arg = std::make_shared<op::v1::Add>(std::make_shared<op::v1::Add>(a, b),
+                                                 std::make_shared<op::v1::Add>(b, a));
+        ASSERT_TRUE(n.match(pattern, std::make_shared<op::v1::Add>(arg, a)));
         ASSERT_EQ(n.get_matched_nodes().size(), 4);
     }
 
@@ -491,7 +522,7 @@ TEST(pattern, mean)
     auto N = op::Constant::create(element::Type_t::f32, Shape{3}, {2, 2, 2});
     auto sum_input1 = std::make_shared<op::v1::ReduceSum>(
         input, op::Constant::create(element::Type_t::i64, {1}, {0}));
-    auto mean = std::make_shared<op::Divide>(sum_input1, N);
+    auto mean = std::make_shared<op::v1::Divide>(sum_input1, N);
 
     auto mean_graph = construct_mean_graph();
     ASSERT_TRUE(n.match(mean_graph, mean));
@@ -504,15 +535,15 @@ TEST(pattern, variance)
     TestMatcher n;
     auto N = op::Constant::create(element::Type_t::f32, Shape{3}, {2, 2, 2});
     auto input = std::make_shared<pattern::op::Label>(element::Type_t::f32, Shape{2, 3});
-    auto input_sq = std::make_shared<op::Multiply>(input, input);
+    auto input_sq = std::make_shared<op::v1::Multiply>(input, input);
     auto sum_input = std::make_shared<op::v1::ReduceSum>(
         input, op::Constant::create(element::Type_t::i64, {1}, {0}));
-    auto square_sumed_input = std::make_shared<op::Multiply>(sum_input, sum_input);
+    auto square_sumed_input = std::make_shared<op::v1::Multiply>(sum_input, sum_input);
     auto sum_squared_input = std::make_shared<op::v1::ReduceSum>(
         input_sq, op::Constant::create(element::Type_t::i64, {1}, {0}));
-    auto avg_input_sum_sq = std::make_shared<op::Divide>(square_sumed_input, N);
-    auto xmu = std::make_shared<op::Subtract>(sum_squared_input, avg_input_sum_sq);
-    auto variance = std::make_shared<op::Divide>(xmu, N);
+    auto avg_input_sum_sq = std::make_shared<op::v1::Divide>(square_sumed_input, N);
+    auto xmu = std::make_shared<op::v1::Subtract>(sum_squared_input, avg_input_sum_sq);
+    auto variance = std::make_shared<op::v1::Divide>(xmu, N);
 
     auto var_graph = construct_variance_graph();
     ASSERT_TRUE(n.match(var_graph, variance));
@@ -528,15 +559,15 @@ TEST(pattern, previous_matches)
     auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto pattern = std::make_shared<pattern::op::Label>(b);
     auto abs = make_shared<op::Abs>(a);
-    auto add = abs + b;
+    auto add = make_shared<op::v1::Add>(abs, b);
     {
-        Matcher n(pattern + b);
+        Matcher n(make_shared<op::v1::Add>(pattern, b));
         ASSERT_TRUE(n.match(add, previous_matches));
         ASSERT_EQ(n.get_pattern_map()[pattern], abs);
     }
 
     {
-        Matcher n(pattern + b);
+        Matcher n(make_shared<op::v1::Add>(pattern, b));
         previous_matches.insert(std::make_pair(pattern, a));
         ASSERT_FALSE(n.match(add, previous_matches));
     }
@@ -551,14 +582,14 @@ TEST(pattern, test_sort)
     auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto abs1 = make_shared<op::Abs>(a);
     auto abs2 = make_shared<op::Abs>(b);
-    auto add = abs1 + abs2;
+    shared_ptr<Node> add = make_shared<op::v1::Add>(abs1, abs2);
 
     auto pa = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto pb = make_shared<op::Parameter>(element::Type_t::i32, shape);
     auto pabs1 = make_shared<op::Abs>(pa);
     auto pabs1_label = std::make_shared<pattern::op::Label>(pabs1);
     auto pabs2 = make_shared<op::Abs>(b);
-    auto padd = pabs1_label + pabs2;
+    shared_ptr<Node> padd = make_shared<op::v1::Add>(pabs1_label, pabs2);
 
     {
         Matcher n1(padd);
@@ -579,10 +610,10 @@ TEST(pattern, recurrent_pattern)
     auto rpattern = std::make_shared<pattern::op::Label>(b);
     auto iconst0 = construct_constant_node(0);
     auto abs = make_shared<op::Abs>(a);
-    auto add1 = iconst0 + b;
-    auto add2 = iconst0 + add1;
-    auto add3 = iconst0 + add2;
-    auto padd = iconst0 + rpattern;
+    auto add1 = make_shared<op::v1::Add>(iconst0, b);
+    auto add2 = make_shared<op::v1::Add>(iconst0, add1);
+    auto add3 = make_shared<op::v1::Add>(iconst0, add2);
+    auto padd = make_shared<op::v1::Add>(iconst0, rpattern);
     std::set<std::shared_ptr<pattern::op::Label>> empty_correlated_matches;
     RecurrentMatcher rm(padd, rpattern, empty_correlated_matches);
     ASSERT_TRUE(rm.match(add3));
@@ -595,9 +626,9 @@ TEST(pattern, recurrent_pattern)
     // Multiple labels in a reccuring pattern
     auto iconst1 = construct_constant_node(1);
     auto iconst_label = std::make_shared<pattern::op::Label>(iconst1, nullptr, NodeVector{iconst1});
-    auto add2_2 = iconst1 + add1;
-    auto add3_2 = iconst0 + add2_2;
-    auto padd2 = iconst_label + rpattern;
+    auto add2_2 = make_shared<op::v1::Add>(iconst1, add1);
+    auto add3_2 = make_shared<op::v1::Add>(iconst0, add2_2);
+    auto padd2 = make_shared<op::v1::Add>(iconst_label, rpattern);
     RecurrentMatcher rm2(padd2, rpattern, empty_correlated_matches);
     ASSERT_TRUE(rm2.match(add3_2));
     ASSERT_EQ(rm2.get_number_of_bound_labels(), 4);
@@ -644,7 +675,7 @@ class TestRecurrentGraphRewrite : public ngraph::pass::RecurrentGraphRewrite
         auto iconst_label =
             std::make_shared<pattern::op::Label>(iconst0, nullptr, NodeVector{iconst0});
         auto rpattern = std::make_shared<pattern::op::Label>(element::Type_t::i32, shape);
-        auto padd = iconst_label + rpattern;
+        auto padd = make_shared<op::v1::Add>(iconst_label, rpattern);
 
         auto callback = [iconst_label, rpattern](pattern::RecurrentMatcher& rm) {
             NGRAPH_DEBUG << "In a callback for construct_recurrent_add against "
@@ -699,17 +730,17 @@ TEST(pattern, recurrent_graph_rewrite)
     {
         auto a = make_shared<op::Parameter>(element::Type_t::i32, shape);
         auto iconst0 = construct_constant_node(0);
-        auto add_a1 = a + iconst0;
-        auto add_a2 = add_a1 + iconst0;
-        auto add_a3 = add_a2 + iconst0;
+        auto add_a1 = make_shared<op::v1::Add>(a, iconst0);
+        auto add_a2 = make_shared<op::v1::Add>(add_a1, iconst0);
+        auto add_a3 = make_shared<op::v1::Add>(add_a2, iconst0);
         auto abs_add_a3 = std::make_shared<op::Abs>(add_a3);
 
         auto b = make_shared<op::Parameter>(element::Type_t::i32, shape);
-        auto add_b1 = b + iconst0;
-        auto add_b2 = add_b1 + iconst0;
+        auto add_b1 = make_shared<op::v1::Add>(b, iconst0);
+        auto add_b2 = make_shared<op::v1::Add>(add_b1, iconst0);
         auto abs_add_b2 = std::make_shared<op::Abs>(add_b2);
 
-        auto graph = abs_add_a3 * abs_add_b2;
+        auto graph = make_shared<op::v1::Multiply>(abs_add_a3, abs_add_b2);
 
         auto f = std::make_shared<Function>(ngraph::NodeVector{graph}, ParameterVector{a, b});
         pass_manager.run_passes(f);
@@ -744,11 +775,11 @@ TEST(pattern, label_on_skip)
         OutputVector{const_label, shape_const, axes_const}, bcst_pred);
     auto bcst_label = std::make_shared<pattern::op::Label>(bcst, nullptr, NodeVector{bcst});
     auto matcher = std::make_shared<pattern::Matcher>(
-        std::make_shared<op::Multiply>(label, bcst_label), "label_on_skip");
+        std::make_shared<op::v1::Multiply>(label, bcst_label), "label_on_skip");
 
     auto const_broadcast = make_shared<op::v1::Broadcast>(iconst, shape_const);
-    auto mul = a * const_broadcast;
-    auto mul_scalar = b * iconst;
+    std::shared_ptr<Node> mul = std::make_shared<op::v1::Multiply>(a, const_broadcast);
+    std::shared_ptr<Node> mul_scalar = std::make_shared<op::v1::Multiply>(b, iconst);
     ASSERT_TRUE(matcher->match(mul));
     ASSERT_EQ(matcher->get_pattern_map()[bcst_label], const_broadcast);
     ASSERT_EQ(matcher->get_pattern_map()[const_label], iconst);
diff --git a/ngraph/test/provenance.cpp b/ngraph/test/provenance.cpp
index 6ac66b39b68c8e..62d23911a93b0f 100644
--- a/ngraph/test/provenance.cpp
+++ b/ngraph/test/provenance.cpp
@@ -28,16 +28,12 @@
 #include "ngraph/pass/manager.hpp"
 #include "ngraph/provenance.hpp"
 #include "pass/fused_op_decomposition.hpp"
-#include "pass/opset0_downgrade.hpp"
-#include "pass/opset1_upgrade.hpp"
 #include "util/provenance_enabler.hpp"
 
 using namespace std;
 using namespace ngraph;
 using ::testing::Return;
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using ProvSet = std::unordered_set<std::string>;
 
 TEST(provenance, provenance)
@@ -72,16 +68,16 @@ TEST(provenance, provenance)
         auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
         auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-        auto a = make_shared<op::Add>(x, y);
+        auto a = make_shared<op::v1::Add>(x, y);
         a->add_provenance_tag("tag_a");
-        auto b = make_shared<op::Multiply>(y, x);
+        auto b = make_shared<op::v1::Multiply>(y, x);
         b->add_provenance_tag("tag_b");
-        auto c = make_shared<op::Subtract>(a, b);
+        auto c = make_shared<op::v1::Subtract>(a, b);
         c->add_provenance_tag("tag_c");
 
         auto f = make_shared<Function>(c, ParameterVector{x, y});
 
-        auto new_c = make_shared<op::Subtract>(a, b);
+        auto new_c = make_shared<op::v1::Subtract>(a, b);
         replace_node(c, new_c);
 
         EXPECT_EQ(new_c->get_provenance_tags(), ProvSet{"tag_c"});
@@ -117,16 +113,16 @@ TEST(provenance, provenance)
         auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
         auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-        auto a = make_shared<op::Add>(x, y);
+        auto a = make_shared<op::v1::Add>(x, y);
         a->add_provenance_tag("tag_a");
-        auto b = make_shared<op::Multiply>(y, x);
+        auto b = make_shared<op::v1::Multiply>(y, x);
         b->add_provenance_tag("tag_b");
-        auto c = make_shared<op::Subtract>(a, b);
+        auto c = make_shared<op::v1::Subtract>(a, b);
         c->add_provenance_tag("tag_c");
 
         auto f = make_shared<Function>(c, ParameterVector{x, y});
 
-        auto d = make_shared<op::Subtract>(a, b);
+        auto d = make_shared<op::v1::Subtract>(a, b);
         d->add_provenance_tag("tag_d");
         replace_node(c, d);
 
@@ -155,11 +151,11 @@ TEST(provenance, provenance)
         auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
         auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-        auto a = make_shared<op::Add>(x, y);
+        auto a = make_shared<op::v1::Add>(x, y);
         a->add_provenance_tag("tag_a");
-        auto b = make_shared<op::Multiply>(y, x);
+        auto b = make_shared<op::v1::Multiply>(y, x);
         b->add_provenance_tag("tag_b");
-        auto c = make_shared<op::Subtract>(a, b);
+        auto c = make_shared<op::v1::Subtract>(a, b);
         c->add_provenance_tag("tag_c");
 
         auto f = make_shared<Function>(c, ParameterVector{x, y});
@@ -193,11 +189,11 @@ TEST(provenance, provenance)
         auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
         auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-        auto a = make_shared<op::Add>(x, y);
+        auto a = make_shared<op::v1::Add>(x, y);
         a->add_provenance_tag("tag_a");
-        auto b = make_shared<op::Multiply>(y, x);
+        auto b = make_shared<op::v1::Multiply>(y, x);
         b->add_provenance_tag("tag_b");
-        auto c = make_shared<op::Subtract>(a, b);
+        auto c = make_shared<op::v1::Subtract>(a, b);
         c->add_provenance_tag("tag_c");
 
         auto f = make_shared<Function>(c, ParameterVector{x, y});
@@ -240,17 +236,17 @@ TEST(provenance, provenance)
         auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
         auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-        auto a = make_shared<op::Add>(x, y);
+        auto a = make_shared<op::v1::Add>(x, y);
         a->add_provenance_tag("tag_a");
-        auto b = make_shared<op::Multiply>(y, x);
+        auto b = make_shared<op::v1::Multiply>(y, x);
         b->add_provenance_tag("tag_b");
-        auto c = make_shared<op::Subtract>(a, b);
+        auto c = make_shared<op::v1::Subtract>(a, b);
         c->add_provenance_tag("tag_c");
 
         auto f = make_shared<Function>(c, ParameterVector{x, y});
 
-        auto e = make_shared<op::Subtract>(a, x);
-        auto d = make_shared<op::Subtract>(e, b);
+        auto e = make_shared<op::v1::Subtract>(a, x);
+        auto d = make_shared<op::v1::Subtract>(e, b);
         d->add_provenance_tag("tag_d");
 
         replace_node(c, d);
@@ -291,18 +287,18 @@ TEST(provenance, provenance)
         auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
         auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-        auto a = make_shared<op::Add>(x, y);
+        auto a = make_shared<op::v1::Add>(x, y);
         a->add_provenance_tag("tag_a");
-        auto b = make_shared<op::Multiply>(y, x);
+        auto b = make_shared<op::v1::Multiply>(y, x);
         b->add_provenance_tag("tag_b");
-        auto c = make_shared<op::Subtract>(a, b);
+        auto c = make_shared<op::v1::Subtract>(a, b);
         c->add_provenance_tag("tag_c");
 
         auto f = make_shared<Function>(c, ParameterVector{x, y});
 
-        auto e = make_shared<op::Subtract>(a, x);
+        auto e = make_shared<op::v1::Subtract>(a, x);
         e->add_provenance_tag("tag_e");
-        auto d = make_shared<op::Subtract>(e, b);
+        auto d = make_shared<op::v1::Subtract>(e, b);
         d->add_provenance_tag("tag_d");
 
         replace_node(c, d);
@@ -318,8 +314,8 @@ TEST(provenance, add_group_above)
     p1->add_provenance_tag("P1");
     auto p2 = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
     p2->add_provenance_tag("P2");
-    auto a1 = p1 + p2;
-    auto m1 = (a1 * a1)->add_provenance_group_members_above({p1, p2});
+    auto a1 = make_shared<op::v1::Add>(p1, p2);
+    auto m1 = make_shared<op::v1::Multiply>(a1, a1)->add_provenance_group_members_above({p1, p2});
     m1->add_provenance_tag("m1");
     EXPECT_EQ(p1->get_provenance_tags(), (ProvSet{"P1"}));
     EXPECT_EQ(p2->get_provenance_tags(), (ProvSet{"P2"}));
@@ -332,9 +328,9 @@ TEST(provenance, add_tags_above)
     auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
     auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
 
-    auto a = make_shared<op::Add>(x, y);
-    auto b = make_shared<op::Multiply>(x, y);
-    auto c = make_shared<op::Subtract>(a, b);
+    auto a = make_shared<op::v1::Add>(x, y);
+    auto b = make_shared<op::v1::Multiply>(x, y);
+    auto c = make_shared<op::v1::Subtract>(a, b);
     auto d = make_shared<op::Abs>(c);
 
     // Add tags to Subtract and all nodes until Parameters (all above c, until params x, y)
@@ -471,90 +467,4 @@ TEST(provenance, empty_group)
             EXPECT_EQ(node->get_provenance_tags(), (ProvSet{"abs"}));
         }
     }
-}
-
-TEST(provenance, opset1_upgrade_pass_graph)
-{
-    test::ProvenanceEnabler provenance_enabler;
-
-    auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
-    auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
-
-    auto a = make_shared<op::v0::Add>(x, y);
-    auto b = make_shared<op::v0::Subtract>(x, y);
-    auto c = make_shared<op::v0::Abs>(b);
-    auto d = make_shared<op::v0::Multiply>(a, b);
-
-    auto f = make_shared<Function>(d, ParameterVector{x, y});
-
-    ngraph::pass::Manager pass_manager;
-    pass_manager.register_pass<pass::Opset1Upgrade>();
-    pass_manager.run_passes(f);
-
-    for (auto node : f->get_ordered_ops())
-    {
-        auto tags = node->get_provenance_tags();
-        if (as_type_ptr<op::v1::Add>(node))
-        {
-            EXPECT_EQ(tags.size(), 1);
-            EXPECT_TRUE(tags.find("<Opset1_Upgrade (v0 Add)>") != tags.end());
-        }
-        else if (as_type_ptr<op::v1::Multiply>(node))
-        {
-            EXPECT_EQ(tags.size(), 1);
-            EXPECT_TRUE(tags.find("<Opset1_Upgrade (v0 Multiply)>") != tags.end());
-        }
-        else if (as_type_ptr<op::v1::Subtract>(node))
-        {
-            EXPECT_EQ(tags.size(), 1);
-            EXPECT_TRUE(tags.find("<Opset1_Upgrade (v0 Subtract)>") != tags.end());
-        }
-        else if (as_type_ptr<op::v0::Abs>(node))
-        {
-            EXPECT_TRUE(tags.empty());
-        }
-    }
-}
-
-TEST(provenance, opset0_downgrade_pass_graph)
-{
-    test::ProvenanceEnabler provenance_enabler;
-
-    auto x = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
-    auto y = make_shared<op::Parameter>(element::Type_t::i32, PartialShape{2, 3, 4});
-
-    auto a = make_shared<op::v1::Add>(x, y);
-    auto b = make_shared<op::v1::Subtract>(x, y);
-    auto c = make_shared<op::v0::Abs>(b);
-    auto d = make_shared<op::v1::Multiply>(a, b);
-
-    auto f = make_shared<Function>(d, ParameterVector{x, y});
-
-    ngraph::pass::Manager pass_manager;
-    pass_manager.register_pass<pass::Opset0Downgrade>();
-    pass_manager.run_passes(f);
-
-    for (auto node : f->get_ordered_ops())
-    {
-        auto tags = node->get_provenance_tags();
-        if (as_type_ptr<op::v0::Add>(node))
-        {
-            EXPECT_EQ(tags.size(), 1);
-            EXPECT_TRUE(tags.find("<Opset0_Downgrade (v1 Add)>") != tags.end());
-        }
-        else if (as_type_ptr<op::v0::Multiply>(node))
-        {
-            EXPECT_EQ(tags.size(), 1);
-            EXPECT_TRUE(tags.find("<Opset0_Downgrade (v1 Multiply)>") != tags.end());
-        }
-        else if (as_type_ptr<op::v0::Subtract>(node))
-        {
-            EXPECT_EQ(tags.size(), 1);
-            EXPECT_TRUE(tags.find("<Opset0_Downgrade (v1 Subtract)>") != tags.end());
-        }
-        else if (as_type_ptr<op::v0::Abs>(node))
-        {
-            EXPECT_TRUE(tags.empty());
-        }
-    }
-}
+}
\ No newline at end of file
diff --git a/ngraph/test/replace_node.cpp b/ngraph/test/replace_node.cpp
index 816f1f8356920a..69903ac1df8a0f 100644
--- a/ngraph/test/replace_node.cpp
+++ b/ngraph/test/replace_node.cpp
@@ -19,8 +19,6 @@
 
 #include "ngraph/ngraph.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -67,10 +65,10 @@ TEST(replace_node, replace_nodes)
     auto y = make_shared<op::Parameter>(element::Type_t::f32, Shape{2});
     auto z = make_shared<op::Parameter>(element::Type_t::f32, Shape{2});
 
-    auto add = x + y;
+    auto add = make_shared<op::v1::Add>(x, y);
     auto k = make_shared<op::Constant>(element::Type_t::f32, Shape{2}, vector<float>{1, 2});
-    auto mul = add * k;
-    auto sub = mul - z;
+    auto mul = make_shared<op::v1::Multiply>(add, k);
+    auto sub = make_shared<op::v1::Subtract>(mul, z);
 
     auto f = make_shared<Function>(NodeVector{sub}, ParameterVector{x, y, z});
 
@@ -83,7 +81,7 @@ TEST(replace_node, replace_nodes)
         make_shared<op::Constant>(element::Type_t::f32, Shape{2}, vector<float>{3, 4});
     auto k_replacement =
         make_shared<op::Constant>(element::Type_t::f32, Shape{2}, vector<float>{5, 6});
-    auto z_replacement = x_replacement + mul;
+    auto z_replacement = make_shared<op::v1::Add>(x_replacement, mul);
     body_replacement_map[y] = y_replacement;
     body_replacement_map[k] = k_replacement;
     body_replacement_map[z] = z_replacement;
diff --git a/ngraph/test/runtime/backend.cpp b/ngraph/test/runtime/backend.cpp
index 2a2444a4208944..94b3466f463fdf 100644
--- a/ngraph/test/runtime/backend.cpp
+++ b/ngraph/test/runtime/backend.cpp
@@ -88,6 +88,7 @@ std::shared_ptr<runtime::Backend> runtime::Backend::create(const string& t,
     {
         return make_shared<runtime::dynamic::DynamicBackend>(inner_backend);
     }
+    return inner_backend;
 }
 
 vector<string> runtime::Backend::get_registered_devices()
diff --git a/ngraph/test/runtime/ie/unit_test.manifest b/ngraph/test/runtime/ie/unit_test.manifest
index af9e7f51121fad..b2893af79a014b 100644
--- a/ngraph/test/runtime/ie/unit_test.manifest
+++ b/ngraph/test/runtime/ie/unit_test.manifest
@@ -1121,12 +1121,12 @@ IE_CPU.onnx_resize11_up_sizes_cubic_half_pixel_dynamic_sizes
 # Input data precision not supported. Expected float.
 ctc_greedy_decoder_f16
 
-# Next nine tests fails in CPU for the following reason. The nGraph function
-# for NMS-5 are passed to the method compile() of the backend, but this
-# method doesn't apply any nGraph transformations to the passed function,
-# and the plugin backend gets CNNNetwork with NMS-5, NMS-5 has dynamic shapes
-# for two of three outputs, and results of these two outputs are interpreted
-# as scalars. If we apply all needed nGraph transformations to the nGraph
+# RNN/LSTM Cells should be converted to IE representation
+IE_CPU.lstm_cell__zero_bias_peepholes
+IE_CPU.rnn_cell__no_bias
+IE_CPU.rnn_cell__bias_clip
+IE_CPU.rnn_cell__activation_function
+
 # function with NMS-5 to get the nGraph function with NMSIE3 (internal
 # operation, similar with NMS-5, but with all static output shapes), before
 # the method compile() call, then tests for INTERPRETER backend for NMS-5 will
diff --git a/ngraph/test/runtime/interpreter/CMakeLists.txt b/ngraph/test/runtime/interpreter/CMakeLists.txt
index ee8116de6fc583..40593ff663fe97 100644
--- a/ngraph/test/runtime/interpreter/CMakeLists.txt
+++ b/ngraph/test/runtime/interpreter/CMakeLists.txt
@@ -15,12 +15,17 @@
 # ******************************************************************************
 
 if (NGRAPH_INTERPRETER_ENABLE)
-    add_library(interpreter_backend SHARED int_backend.cpp int_executable.cpp)
+    add_library(interpreter_backend SHARED int_backend.cpp int_executable.cpp evaluates_map.cpp)
 
     if(COMMAND ie_faster_build)
         ie_faster_build(interpreter_backend
             UNITY
         )
+        endif()
+
+    if(COMMAND ie_add_vs_version_file)
+        ie_add_vs_version_file(NAME interpreter_backend
+                               FILEDESCRIPTION "nGraph interpreter backend library")
     endif()
 
     if(COMMAND ie_add_vs_version_file)
diff --git a/ngraph/test/runtime/interpreter/evaluates_map.cpp b/ngraph/test/runtime/interpreter/evaluates_map.cpp
new file mode 100644
index 00000000000000..32505a58e6dc2f
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/evaluates_map.cpp
@@ -0,0 +1,1704 @@
+//*****************************************************************************
+// Copyright 2017-2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#include "evaluates_map.hpp"
+
+#include "backend.hpp"
+#include "ngraph/ops.hpp"
+
+#include <interpreter/reference/mod.hpp>
+#include <ngraph/runtime/reference/abs.hpp>
+#include <ngraph/runtime/reference/batch_norm.hpp>
+#include <ngraph/runtime/reference/ceiling.hpp>
+#include <ngraph/runtime/reference/convert.hpp>
+#include <ngraph/runtime/reference/extract_image_patches.hpp>
+#include <ngraph/runtime/reference/gather_nd.hpp>
+#include <ngraph/runtime/reference/gru_cell.hpp>
+#include <ngraph/runtime/reference/lstm_cell.hpp>
+#include <ngraph/runtime/reference/non_max_suppression.hpp>
+#include <ngraph/runtime/reference/one_hot.hpp>
+#include <ngraph/runtime/reference/pad.hpp>
+#include <ngraph/runtime/reference/prior_box.hpp>
+#include <ngraph/runtime/reference/region_yolo.hpp>
+#include <ngraph/runtime/reference/reorg_yolo.hpp>
+#include <ngraph/runtime/reference/reverse_sequence.hpp>
+#include <ngraph/runtime/reference/rnn_cell.hpp>
+#include <ngraph/runtime/reference/select.hpp>
+#include <ngraph/runtime/reference/sequences.hpp>
+#include <ngraph/runtime/reference/sign.hpp>
+#include <ngraph/runtime/reference/tensor_iterator.hpp>
+#include "ngraph/runtime/reference/avg_pool.hpp"
+#include "ngraph/runtime/reference/convolution.hpp"
+#include "ngraph/runtime/reference/ctc_greedy_decoder.hpp"
+#include "ngraph/runtime/reference/ctc_loss.hpp"
+#include "ngraph/runtime/reference/cum_sum.hpp"
+#include "ngraph/runtime/reference/detection_output.hpp"
+#include "ngraph/runtime/reference/embedding_bag_offsets_sum.hpp"
+#include "ngraph/runtime/reference/embedding_bag_packed_sum.hpp"
+#include "ngraph/runtime/reference/embedding_segments_sum.hpp"
+#include "ngraph/runtime/reference/fake_quantize.hpp"
+#include "ngraph/runtime/reference/gather_tree.hpp"
+#include "ngraph/runtime/reference/hard_sigmoid.hpp"
+#include "ngraph/runtime/reference/log_softmax.hpp"
+#include "ngraph/runtime/reference/lrn.hpp"
+#include "ngraph/runtime/reference/mvn.hpp"
+#include "ngraph/runtime/reference/normalize_l2.hpp"
+#include "ngraph/runtime/reference/region_yolo.hpp"
+#include "ngraph/runtime/reference/roi_pooling.hpp"
+#include "ngraph/runtime/reference/scatter_nd_update.hpp"
+#include "ngraph/runtime/reference/squared_difference.hpp"
+#include "reference/elu.hpp"
+#include "reference/gelu.hpp"
+#include "reference/grn.hpp"
+#include "reference/selu.hpp"
+
+using namespace ngraph;
+using namespace std;
+
+namespace
+{
+    template <element::Type_t ET>
+    bool evaluate(shared_ptr<Node> op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        return false;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::Convolution>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        const auto filter_data = inputs[1]->get_data_ptr<ET>();
+        auto out_data_ptr = outputs[0]->get_data_ptr<ET>();
+        const auto in_data_ptr = inputs[0]->get_data_ptr<ET>();
+        const auto& out_shape = outputs[0]->get_shape();
+        const auto& in_shape = inputs[0]->get_shape();
+        const auto& filter_shape = inputs[1]->get_shape();
+        Strides in_dilation(std::vector<size_t>(in_shape.size() - 2));
+        std::fill(in_dilation.begin(), in_dilation.end(), 1);
+        runtime::reference::convolution<typename element_type_traits<ET>::value_type>(
+            in_data_ptr,
+            filter_data,
+            out_data_ptr,
+            in_shape,
+            filter_shape,
+            out_shape,
+            op->get_strides(),
+            op->get_dilations(),
+            op->get_pads_begin(),
+            op->get_pads_end(),
+            in_dilation);
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::ConvolutionBackpropData>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        const auto filter_data = inputs[1]->get_data_ptr<ET>();
+        auto out_data_ptr = outputs[0]->get_data_ptr<ET>();
+        const auto in_data_ptr = inputs[0]->get_data_ptr<ET>();
+        const auto& out_shape = outputs[0]->get_shape();
+        const auto& in_shape = inputs[0]->get_shape();
+        const auto& filter_shape = inputs[1]->get_shape();
+        Strides in_dilation(std::vector<size_t>(in_shape.size() - 2));
+        std::fill(in_dilation.begin(), in_dilation.end(), 1);
+        runtime::reference::convolution_backprop_in<typename element_type_traits<ET>::value_type>(
+            in_data_ptr,
+            filter_data,
+            out_data_ptr,
+            in_shape,
+            filter_shape,
+            out_shape,
+            in_dilation,
+            op->get_dilations(),
+            op->get_pads_begin(),
+            op->get_pads_end(),
+            op->get_strides());
+        return true;
+    }
+
+    namespace cum_sum_v0
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v0::CumSum>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::cumsum<T1, T2>(inputs[0]->get_data_ptr<T1>(),
+                                               inputs[1]->get_data_ptr<T2>(),
+                                               outputs[0]->get_data_ptr<T1>(),
+                                               inputs[0]->get_shape(),
+                                               op->is_exclusive(),
+                                               op->is_reverse());
+        }
+    } // namespace cum_sum_v0
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::CumSum>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[1]->get_element_type())
+        {
+        case element::Type_t::i64:
+            cum_sum_v0::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        default: cum_sum_v0::evaluate<ET, element::Type_t::i32>(op, outputs, inputs); break;
+        }
+        return true;
+    }
+
+    namespace embedding_offsets_sum_v3
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v3::EmbeddingSegmentsSum>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::embeddingSegmentsSum<T1, T2>(
+                inputs[0]->get_data_ptr<T1>(),
+                inputs[1]->get_data_ptr<T2>(),
+                inputs[2]->get_data_ptr<T2>(),
+                inputs.size() > 4 ? inputs[4]->get_data_ptr<T2>() : nullptr,
+                inputs.size() > 5 ? inputs[5]->get_data_ptr<T1>() : nullptr,
+                outputs[0]->get_data_ptr<T1>(),
+                inputs[0]->get_shape(),
+                inputs[1]->get_shape(),
+                outputs[0]->get_shape());
+        }
+    } // namespace embedding_offsets_sum_v3
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v3::EmbeddingSegmentsSum>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[1]->get_element_type())
+        {
+        case element::Type_t::i32:
+            embedding_offsets_sum_v3::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        case element::Type_t::i64:
+            embedding_offsets_sum_v3::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+        return true;
+    }
+
+    namespace embedding_bag_offsets_sum_v3
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v3::EmbeddingBagOffsetsSum>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::embeddingBagOffsetsSum<T1, T2>(
+                inputs[0]->get_data_ptr<T1>(),
+                inputs[1]->get_data_ptr<T2>(),
+                inputs[2]->get_data_ptr<T2>(),
+                inputs.size() > 3 ? inputs[3]->get_data_ptr<T2>() : nullptr,
+                inputs.size() > 4 ? inputs[4]->get_data_ptr<T1>() : nullptr,
+                outputs[0]->get_data_ptr<T1>(),
+                shape_size(inputs[1]->get_shape()),
+                outputs[0]->get_shape());
+        }
+    } // namespace embedding_bag_offsets_sum_v3
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v3::EmbeddingBagOffsetsSum>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[1]->get_element_type())
+        {
+        case element::Type_t::i32:
+            embedding_bag_offsets_sum_v3::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        case element::Type_t::i64:
+            embedding_bag_offsets_sum_v3::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+        return true;
+    }
+
+    namespace embedding_bag_packed_sum_v3
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v3::EmbeddingBagPackedSum>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::embeddingBagPackedSum<T1, T2>(
+                inputs[0]->get_data_ptr<T1>(),
+                inputs[1]->get_data_ptr<T2>(),
+                inputs.size() > 2 ? inputs[2]->get_data_ptr<T1>() : nullptr,
+                outputs[0]->get_data_ptr<T1>(),
+                inputs[1]->get_shape(),
+                outputs[0]->get_shape());
+        }
+    } // namespace embedding_bag_packed_sum_v3
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v3::EmbeddingBagPackedSum>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[1]->get_element_type())
+        {
+        case element::Type_t::i32:
+            embedding_bag_packed_sum_v3::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        case element::Type_t::i64:
+            embedding_bag_packed_sum_v3::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::MVN>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::mvn<T>(inputs[0]->get_data_ptr<ET>(),
+                                   outputs[0]->get_data_ptr<ET>(),
+                                   inputs[0]->get_shape(),
+                                   op->get_normalize_variance(),
+                                   op->get_reduction_axes(),
+                                   op->get_eps());
+        return true;
+    }
+
+    namespace nms_v5
+    {
+        using V5BoxEncoding = op::v5::NonMaxSuppression::BoxEncodingType;
+
+        struct InfoForNMS5
+        {
+            int64_t max_output_boxes_per_class;
+            float iou_threshold;
+            float score_threshold;
+            float soft_nms_sigma;
+            Shape out_shape;
+            Shape boxes_shape;
+            Shape scores_shape;
+            std::vector<float> boxes_data;
+            std::vector<float> scores_data;
+            size_t out_shape_size;
+            bool sort_result_descending;
+            ngraph::element::Type output_type;
+        };
+
+        constexpr size_t boxes_port = 0;
+        constexpr size_t scores_port = 1;
+        constexpr size_t max_output_boxes_port = 2;
+        constexpr size_t iou_threshold_port = 3;
+        constexpr size_t score_threshold_port = 4;
+        constexpr size_t soft_nms_sigma_port = 5;
+
+        PartialShape
+            infer_selected_indices_shape(const std::vector<std::shared_ptr<HostTensor>>& inputs,
+                                         int64_t max_output_boxes_per_class)
+        {
+            const auto boxes_ps = inputs[boxes_port]->get_partial_shape();
+            const auto scores_ps = inputs[scores_port]->get_partial_shape();
+
+            // NonMaxSuppression produces triplets
+            // that have the following format: [batch_index, class_index, box_index]
+            PartialShape result = {Dimension::dynamic(), 3};
+
+            if (boxes_ps.rank().is_static() && scores_ps.rank().is_static())
+            {
+                const auto num_boxes_boxes = boxes_ps[1];
+                if (num_boxes_boxes.is_static() && scores_ps[0].is_static() &&
+                    scores_ps[1].is_static())
+                {
+                    const auto num_boxes = num_boxes_boxes.get_length();
+                    const auto num_classes = scores_ps[1].get_length();
+
+                    result[0] = std::min(num_boxes, max_output_boxes_per_class) * num_classes *
+                                scores_ps[0].get_length();
+                }
+            }
+
+            return result;
+        }
+
+        std::vector<float> get_floats(const std::shared_ptr<HostTensor>& input, const Shape& shape)
+        {
+            size_t input_size = shape_size(shape);
+            std::vector<float> result(input_size);
+
+            switch (input->get_element_type())
+            {
+            case element::Type_t::bf16:
+            {
+                bfloat16* p = input->get_data_ptr<bfloat16>();
+                for (size_t i = 0; i < input_size; ++i)
+                {
+                    result[i] = float(p[i]);
+                }
+            }
+            break;
+            case element::Type_t::f16:
+            {
+                float16* p = input->get_data_ptr<float16>();
+                for (size_t i = 0; i < input_size; ++i)
+                {
+                    result[i] = float(p[i]);
+                }
+            }
+            break;
+            case element::Type_t::f32:
+            {
+                float* p = input->get_data_ptr<float>();
+                memcpy(result.data(), p, input_size * sizeof(float));
+            }
+            break;
+            default:
+                throw std::runtime_error("Unsupported data type in op NonMaxSuppression-5");
+                break;
+            }
+
+            return result;
+        }
+
+        void normalize_corner(float* boxes, const Shape& boxes_shape)
+        {
+            size_t total_num_of_boxes = shape_size(boxes_shape) / 4;
+            for (size_t i = 0; i < total_num_of_boxes; ++i)
+            {
+                float* current_box = boxes + 4 * i;
+
+                float y1 = current_box[0];
+                float x1 = current_box[1];
+                float y2 = current_box[2];
+                float x2 = current_box[3];
+
+                float ymin = std::min(y1, y2);
+                float ymax = std::max(y1, y2);
+                float xmin = std::min(x1, x2);
+                float xmax = std::max(x1, x2);
+
+                current_box[0] = ymin;
+                current_box[1] = xmin;
+                current_box[2] = ymax;
+                current_box[3] = xmax;
+            }
+        }
+
+        void normalize_center(float* boxes, const Shape& boxes_shape)
+        {
+            size_t total_num_of_boxes = shape_size(boxes_shape) / 4;
+            for (size_t i = 0; i < total_num_of_boxes; ++i)
+            {
+                float* current_box = boxes + 4 * i;
+
+                float x_center = current_box[0];
+                float y_center = current_box[1];
+                float width = current_box[2];
+                float height = current_box[3];
+
+                float y1 = y_center - height / 2.0;
+                float x1 = x_center - width / 2.0;
+                float y2 = y_center + height / 2.0;
+                float x2 = x_center + width / 2.0;
+
+                current_box[0] = y1;
+                current_box[1] = x1;
+                current_box[2] = y2;
+                current_box[3] = x2;
+            }
+        }
+
+        void normalize_box_encoding(float* boxes,
+                                    const Shape& boxes_shape,
+                                    const V5BoxEncoding box_encoding)
+        {
+            if (box_encoding == V5BoxEncoding::CORNER)
+            {
+                normalize_corner(boxes, boxes_shape);
+            }
+            else
+            {
+                normalize_center(boxes, boxes_shape);
+            }
+        }
+
+        std::vector<float> prepare_boxes_data(const std::shared_ptr<HostTensor>& boxes,
+                                              const Shape& boxes_shape,
+                                              const V5BoxEncoding box_encoding)
+        {
+            auto result = get_floats(boxes, boxes_shape);
+            normalize_box_encoding(result.data(), boxes_shape, box_encoding);
+            return result;
+        }
+
+        std::vector<float> prepare_scores_data(const std::shared_ptr<HostTensor>& scores,
+                                               const Shape& scores_shape)
+        {
+            auto result = get_floats(scores, scores_shape);
+            return result;
+        }
+
+        InfoForNMS5 get_info_for_nms5_eval(const std::shared_ptr<op::v5::NonMaxSuppression>& nms5,
+                                           const std::vector<std::shared_ptr<HostTensor>>& inputs)
+        {
+            InfoForNMS5 result;
+
+            result.max_output_boxes_per_class = nms5->max_boxes_output_from_input();
+            result.iou_threshold = nms5->iou_threshold_from_input();
+            result.score_threshold = nms5->score_threshold_from_input();
+            result.soft_nms_sigma = nms5->soft_nms_sigma_from_input();
+
+            auto selected_indices_shape =
+                infer_selected_indices_shape(inputs, result.max_output_boxes_per_class);
+            result.out_shape = selected_indices_shape.to_shape();
+
+            result.boxes_shape = inputs[boxes_port]->get_shape();
+            result.scores_shape = inputs[scores_port]->get_shape();
+
+            result.boxes_data = prepare_boxes_data(
+                inputs[boxes_port], result.boxes_shape, nms5->get_box_encoding());
+            result.scores_data = prepare_scores_data(inputs[scores_port], result.scores_shape);
+
+            result.out_shape_size = shape_size(result.out_shape);
+
+            result.sort_result_descending = nms5->get_sort_result_descending();
+
+            result.output_type = nms5->get_output_type();
+
+            return result;
+        }
+
+    } // namespace nms_v5
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::NonMaxSuppression>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        auto info = nms_v5::get_info_for_nms5_eval(op, inputs);
+
+        std::vector<int64_t> selected_indices(info.out_shape_size);
+        std::vector<float> selected_scores(info.out_shape_size);
+        int64_t valid_outputs = 0;
+
+        runtime::reference::non_max_suppression(info.boxes_data.data(),
+                                                info.boxes_shape,
+                                                info.scores_data.data(),
+                                                info.scores_shape,
+                                                info.max_output_boxes_per_class,
+                                                info.iou_threshold,
+                                                info.score_threshold,
+                                                info.soft_nms_sigma,
+                                                selected_indices.data(),
+                                                info.out_shape,
+                                                selected_scores.data(),
+                                                info.out_shape,
+                                                &valid_outputs,
+                                                info.sort_result_descending);
+
+        auto selected_scores_type =
+            (inputs.size() < 4) ? element::f32 : inputs[3]->get_element_type();
+
+        runtime::reference::nms5_postprocessing(outputs,
+                                                info.output_type,
+                                                selected_indices,
+                                                selected_scores,
+                                                valid_outputs,
+                                                selected_scores_type);
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::LRN>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::lrn<T>(inputs[0]->get_data_ptr<ET>(),
+                                   op->get_reduction_axes(),
+                                   outputs[0]->get_data_ptr<ET>(),
+                                   inputs[0]->get_shape(),
+                                   op->get_alpha(),
+                                   op->get_beta(),
+                                   op->get_bias(),
+                                   op->get_nsize());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::GRN>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::grn<T>(inputs[0]->get_data_ptr<ET>(),
+                                   outputs[0]->get_data_ptr<ET>(),
+                                   op->get_bias(),
+                                   inputs[0]->get_shape());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::DetectionOutput>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::referenceDetectionOutput<T> refDetOut(
+            op->get_attrs(), op->get_input_shape(0), op->get_input_shape(2));
+        if (op->get_input_size() == 3)
+        {
+            refDetOut.run(inputs[0]->get_data_ptr<const T>(),
+                          inputs[1]->get_data_ptr<const T>(),
+                          inputs[2]->get_data_ptr<const T>(),
+                          nullptr,
+                          nullptr,
+                          outputs[0]->get_data_ptr<T>());
+        }
+        else if (op->get_input_size() == 5)
+        {
+            refDetOut.run(inputs[0]->get_data_ptr<const T>(),
+                          inputs[1]->get_data_ptr<const T>(),
+                          inputs[2]->get_data_ptr<const T>(),
+                          inputs[3]->get_data_ptr<const T>(),
+                          inputs[4]->get_data_ptr<const T>(),
+                          outputs[0]->get_data_ptr<T>());
+        }
+        else
+        {
+            throw ngraph_error("DetectionOutput layer supports only 3 or 5 inputs");
+        }
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v3::ScatterNDUpdate>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        auto idxType = op->get_input_element_type(1);
+        if (idxType == element::i32)
+        {
+            runtime::reference::scatterNdUpdate<T, int32_t>(
+                inputs[0]->get_data_ptr<const T>(),
+                inputs[1]->get_data_ptr<const int32_t>(),
+                inputs[2]->get_data_ptr<const T>(),
+                outputs[0]->get_data_ptr<T>(),
+                op->get_input_shape(0),
+                op->get_input_shape(1),
+                op->get_input_shape(2));
+        }
+        else if (idxType == element::i64)
+        {
+            runtime::reference::scatterNdUpdate<T, int64_t>(
+                inputs[0]->get_data_ptr<const T>(),
+                inputs[1]->get_data_ptr<const int64_t>(),
+                inputs[2]->get_data_ptr<const T>(),
+                outputs[0]->get_data_ptr<T>(),
+                op->get_input_shape(0),
+                op->get_input_shape(1),
+                op->get_input_shape(2));
+        }
+        else
+        {
+            throw ngraph_error(
+                "ScatterNDUpdate layer support only i32 and i64 'indices' input precision!");
+        }
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::Select>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+
+        runtime::reference::select<T>(inputs[0]->get_data_ptr<const char>(),
+                                      inputs[1]->get_data_ptr<const T>(),
+                                      inputs[2]->get_data_ptr<const T>(),
+                                      outputs[0]->get_data_ptr<T>(),
+                                      op->get_input_shape(0),
+                                      op->get_input_shape(1),
+                                      op->get_input_shape(2),
+                                      op->get_auto_broadcast());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::AvgPool>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::avg_pool<T>(inputs[0]->get_data_ptr<T>(),
+                                        outputs[0]->get_data_ptr<T>(),
+                                        inputs[0]->get_shape(),
+                                        op->get_output_shape(0),
+                                        op->get_kernel(),
+                                        op->get_strides(),
+                                        op->get_pads_begin(),
+                                        op->get_pads_end(),
+                                        !op->get_exclude_pad());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::HardSigmoid>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::hard_sigmoid<T>(inputs[0]->get_data_ptr<T>(),
+                                            inputs[1]->get_data_ptr<const T>()[0],
+                                            inputs[2]->get_data_ptr<const T>()[0],
+                                            outputs[0]->get_data_ptr<T>(),
+                                            shape_size(outputs[0]->get_shape()));
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Elu>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::elu<T>(inputs[0]->get_data_ptr<T>(),
+                                   outputs[0]->get_data_ptr<T>(),
+                                   shape_size(inputs[0]->get_shape()),
+                                   op->get_alpha());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::PriorBox>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::prior_box<T>(inputs[0]->get_data_ptr<T>(),
+                                         inputs[1]->get_data_ptr<T>(),
+                                         outputs[0]->get_data_ptr<float>(),
+                                         outputs[0]->get_shape(),
+                                         op->get_attrs());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::Mod>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::mod<T>(inputs[0]->get_data_ptr<T>(),
+                                   inputs[1]->get_data_ptr<T>(),
+                                   outputs[0]->get_data_ptr<T>(),
+                                   inputs[0]->get_shape(),
+                                   inputs[1]->get_shape(),
+                                   op->get_auto_broadcast());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Selu>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::selu<T>(inputs[0]->get_data_ptr<T>(),
+                                    inputs[1]->get_data_ptr<T>(),
+                                    inputs[2]->get_data_ptr<T>(),
+                                    outputs[0]->get_data_ptr<T>(),
+                                    shape_size(inputs[0]->get_shape()),
+                                    shape_size(inputs[1]->get_shape()),
+                                    shape_size(inputs[2]->get_shape()));
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Ceiling>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::ceiling<T>(inputs[0]->get_data_ptr<T>(),
+                                       outputs[0]->get_data_ptr<T>(),
+                                       shape_size(inputs[0]->get_shape()));
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Gelu>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::gelu<T>(inputs[0]->get_data_ptr<T>(),
+                                    outputs[0]->get_data_ptr<T>(),
+                                    shape_size(inputs[0]->get_shape()));
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Relu>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::relu<T>(inputs[0]->get_data_ptr<T>(),
+                                    outputs[0]->get_data_ptr<T>(),
+                                    shape_size(inputs[0]->get_shape()));
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Sign>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::sign<T>(inputs[0]->get_data_ptr<T>(),
+                                    outputs[0]->get_data_ptr<T>(),
+                                    shape_size(inputs[0]->get_shape()));
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::Abs>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::abs<T>(inputs[0]->get_data_ptr<T>(),
+                                   outputs[0]->get_data_ptr<T>(),
+                                   shape_size(inputs[0]->get_shape()));
+        return true;
+    }
+
+    namespace ctc_loss_v4
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v4::CTCLoss>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::CTCLoss<T1, T2>(inputs[0]->get_data_ptr<T1>(),
+                                                inputs[0]->get_shape(),
+                                                inputs[1]->get_data_ptr<T2>(),
+                                                inputs[2]->get_data_ptr<T2>(),
+                                                inputs[3]->get_data_ptr<T2>(),
+                                                inputs[4]->get_data_ptr<T2>(),
+                                                op->get_preprocess_collapse_repeated(),
+                                                op->get_ctc_merge_repeated(),
+                                                op->get_unique(),
+                                                outputs[0]->get_data_ptr<T1>());
+        }
+    } // namespace ctc_loss_v4
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v4::CTCLoss>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[1]->get_element_type())
+        {
+        case element::Type_t::i32:
+            ctc_loss_v4::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        case element::Type_t::i64:
+            ctc_loss_v4::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::BatchNormInference>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::batch_norm_inference<T>(op->get_eps_value(),
+                                                    inputs[0]->get_data_ptr<T>(),
+                                                    inputs[1]->get_data_ptr<T>(),
+                                                    inputs[2]->get_data_ptr<T>(),
+                                                    inputs[3]->get_data_ptr<T>(),
+                                                    inputs[4]->get_data_ptr<T>(),
+                                                    outputs[0]->get_data_ptr<T>(),
+                                                    inputs[2]->get_shape());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::BatchNormInference>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::batch_norm_inference<T>(op->get_eps_value(),
+                                                    inputs[1]->get_data_ptr<const T>(),
+                                                    inputs[2]->get_data_ptr<const T>(),
+                                                    inputs[0]->get_data_ptr<const T>(),
+                                                    inputs[3]->get_data_ptr<const T>(),
+                                                    inputs[4]->get_data_ptr<const T>(),
+                                                    outputs[0]->get_data_ptr<T>(),
+                                                    op->get_input_shape(0));
+        return true;
+    }
+
+    namespace reverse_sequence_v0
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v0::ReverseSequence>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::reverse_sequence<T1, T2>(inputs[0]->get_data_ptr<T1>(),
+                                                         outputs[0]->get_data_ptr<T1>(),
+                                                         inputs[0]->get_shape(),
+                                                         op->get_batch_axis(),
+                                                         op->get_sequence_axis(),
+                                                         inputs[1]->get_data_ptr<T2>());
+        }
+    } // namespace reverse_sequence_v0
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::ReverseSequence>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[1]->get_element_type())
+        {
+        case element::Type_t::boolean:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::boolean>(op, outputs, inputs);
+            break;
+        case element::Type_t::i8:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::i8>(op, outputs, inputs);
+            break;
+        case element::Type_t::i16:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::i16>(op, outputs, inputs);
+            break;
+        case element::Type_t::i32:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        case element::Type_t::i64:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        case element::Type_t::u8:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::u8>(op, outputs, inputs);
+            break;
+        case element::Type_t::u16:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::u16>(op, outputs, inputs);
+            break;
+        case element::Type_t::u32:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::u32>(op, outputs, inputs);
+            break;
+        case element::Type_t::u64:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::u64>(op, outputs, inputs);
+            break;
+        case element::Type_t::f16:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::f16>(op, outputs, inputs);
+            break;
+        case element::Type_t::f32:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::f32>(op, outputs, inputs);
+            break;
+        case element::Type_t::f64:
+            reverse_sequence_v0::evaluate<ET, element::Type_t::f64>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+#undef REF_CALL
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v3::ExtractImagePatches>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::extract_image_patches<T>(op,
+                                                     inputs[0]->get_data_ptr<T>(),
+                                                     outputs[0]->get_data_ptr<T>(),
+                                                     inputs[0]->get_shape(),
+                                                     outputs[0]->get_shape());
+        return true;
+    }
+
+    namespace convert_v0
+    {
+        template <element::Type_t ET>
+        inline void evaluate_bool(const shared_ptr<op::v0::Convert>& op,
+                                  const HostTensorVector& outputs,
+                                  const HostTensorVector& inputs)
+        {
+            using T = typename element_type_traits<ET>::value_type;
+            runtime::reference::convert_to_bool<T>(inputs[0]->get_data_ptr<T>(),
+                                                   outputs[0]->get_data_ptr<char>(),
+                                                   shape_size(inputs[0]->get_shape()));
+        }
+        template <element::Type_t ti, element::Type_t to>
+        inline void evaluate(const shared_ptr<op::v0::Convert>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using TI = typename element_type_traits<ti>::value_type;
+            using TO = typename element_type_traits<to>::value_type;
+            runtime::reference::convert<TI, TO>(inputs[0]->get_data_ptr<TI>(),
+                                                outputs[0]->get_data_ptr<TO>(),
+                                                shape_size(inputs[0]->get_shape()));
+        }
+    } // namespace convert_v0
+
+    template <element::Type_t OUT_ET>
+    bool evaluate(const shared_ptr<op::v0::Convert>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        if (OUT_ET == element::Type_t::boolean)
+        {
+            switch (inputs[0]->get_element_type())
+            {
+            case element::Type_t::boolean:
+                convert_v0::evaluate_bool<element::Type_t::boolean>(op, outputs, inputs);
+                break;
+            case element::Type_t::i8:
+                convert_v0::evaluate_bool<element::Type_t::i8>(op, outputs, inputs);
+                break;
+            case element::Type_t::i16:
+                convert_v0::evaluate_bool<element::Type_t::i16>(op, outputs, inputs);
+                break;
+            case element::Type_t::i32:
+                convert_v0::evaluate_bool<element::Type_t::i32>(op, outputs, inputs);
+                break;
+            case element::Type_t::i64:
+                convert_v0::evaluate_bool<element::Type_t::i64>(op, outputs, inputs);
+                break;
+            case element::Type_t::u8:
+                convert_v0::evaluate_bool<element::Type_t::u8>(op, outputs, inputs);
+                break;
+            case element::Type_t::u16:
+                convert_v0::evaluate_bool<element::Type_t::u16>(op, outputs, inputs);
+                break;
+            case element::Type_t::u32:
+                convert_v0::evaluate_bool<element::Type_t::u32>(op, outputs, inputs);
+                break;
+            case element::Type_t::u64:
+                convert_v0::evaluate_bool<element::Type_t::u64>(op, outputs, inputs);
+                break;
+            case element::Type_t::f16:
+                convert_v0::evaluate_bool<element::Type_t::f16>(op, outputs, inputs);
+                break;
+            case element::Type_t::f32:
+                convert_v0::evaluate_bool<element::Type_t::f32>(op, outputs, inputs);
+                break;
+            case element::Type_t::f64:
+                convert_v0::evaluate_bool<element::Type_t::f64>(op, outputs, inputs);
+                break;
+            default: return false;
+            }
+        }
+        else
+        {
+            switch (inputs[0]->get_element_type())
+            {
+            case element::Type_t::boolean:
+                convert_v0::evaluate<element::Type_t::boolean, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::i8:
+                convert_v0::evaluate<element::Type_t::i8, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::i16:
+                convert_v0::evaluate<element::Type_t::i16, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::i32:
+                convert_v0::evaluate<element::Type_t::i32, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::i64:
+                convert_v0::evaluate<element::Type_t::i64, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::u8:
+                convert_v0::evaluate<element::Type_t::u8, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::u16:
+                convert_v0::evaluate<element::Type_t::u16, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::u32:
+                convert_v0::evaluate<element::Type_t::u32, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::u64:
+                convert_v0::evaluate<element::Type_t::u64, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::f16:
+                convert_v0::evaluate<element::Type_t::f16, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::f32:
+                convert_v0::evaluate<element::Type_t::f32, OUT_ET>(op, outputs, inputs);
+                break;
+            case element::Type_t::f64:
+                convert_v0::evaluate<element::Type_t::f64, OUT_ET>(op, outputs, inputs);
+                break;
+            default: return false;
+            }
+        }
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::OneHot>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        switch (inputs[0]->get_element_type())
+        {
+        case element::Type_t::i32:
+            runtime::reference::
+                one_hot<typename element_type_traits<element::Type_t::i32>::value_type, T>(
+                    inputs[0]->get_data_ptr<element::Type_t::i32>(),
+                    outputs[0]->get_data_ptr<T>(),
+                    inputs[0]->get_shape(),
+                    outputs[0]->get_shape(),
+                    op->get_axis(),
+                    inputs[2]->get_data_ptr<T>()[0],
+                    inputs[3]->get_data_ptr<T>()[0]);
+            break;
+        case element::Type_t::i64:
+            runtime::reference::
+                one_hot<typename element_type_traits<element::Type_t::i64>::value_type, T>(
+                    inputs[0]->get_data_ptr<element::Type_t::i64>(),
+                    outputs[0]->get_data_ptr<T>(),
+                    inputs[0]->get_shape(),
+                    outputs[0]->get_shape(),
+                    op->get_axis(),
+                    inputs[2]->get_data_ptr<T>()[0],
+                    inputs[3]->get_data_ptr<T>()[0]);
+            break;
+        default:
+            std::stringstream ss;
+            ss << "Unhandled input precision " << inputs[0]->get_element_type().get_type_name()
+               << " in v1::OneHot evaluate call";
+            throw ngraph_error(ss.str());
+        }
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::RNNCell>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::rnn_cell<T>(inputs[0]->get_data_ptr<ET>(),
+                                        inputs[0]->get_shape(),
+                                        inputs[1]->get_data_ptr<ET>(),
+                                        inputs[1]->get_shape(),
+                                        inputs[2]->get_data_ptr<ET>(),
+                                        inputs[2]->get_shape(),
+                                        inputs[3]->get_data_ptr<ET>(),
+                                        inputs[3]->get_shape(),
+                                        inputs[4]->get_data_ptr<ET>(),
+                                        inputs[4]->get_shape(),
+                                        outputs[0]->get_data_ptr<ET>(),
+                                        op->get_activations().front(),
+                                        op->get_clip());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v4::LSTMCell>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::lstm_cell<T>(inputs[0]->get_data_ptr<ET>(),
+                                         inputs[0]->get_shape(),
+                                         inputs[1]->get_data_ptr<ET>(),
+                                         inputs[1]->get_shape(),
+                                         inputs[2]->get_data_ptr<ET>(),
+                                         inputs[2]->get_shape(),
+                                         inputs[3]->get_data_ptr<ET>(),
+                                         inputs[3]->get_shape(),
+                                         inputs[4]->get_data_ptr<ET>(),
+                                         inputs[4]->get_shape(),
+                                         inputs[5]->get_data_ptr<ET>(),
+                                         inputs[5]->get_shape(),
+                                         outputs[0]->get_data_ptr<ET>(),
+                                         outputs[1]->get_data_ptr<ET>(),
+                                         op->get_activations()[0],
+                                         op->get_activations()[1],
+                                         op->get_activations()[2],
+                                         op->get_clip());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v3::GRUCell>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::gru_cell<T>(inputs[0]->get_data_ptr<ET>(),
+                                        inputs[0]->get_shape(),
+                                        inputs[1]->get_data_ptr<ET>(),
+                                        inputs[1]->get_shape(),
+                                        inputs[2]->get_data_ptr<ET>(),
+                                        inputs[2]->get_shape(),
+                                        inputs[3]->get_data_ptr<ET>(),
+                                        inputs[3]->get_shape(),
+                                        inputs[4]->get_data_ptr<ET>(),
+                                        inputs[4]->get_shape(),
+                                        outputs[0]->get_data_ptr<ET>(),
+                                        op->get_activations()[0],
+                                        op->get_activations()[1],
+                                        op->get_clip(),
+                                        op->get_linear_before_reset());
+        return true;
+    }
+
+    namespace rnn_seq_v5
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v5::RNNSequence>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::rnn_sequence<T1, T2>(inputs[0]->get_data_ptr<char>(),
+                                                     inputs[0]->get_shape(),
+                                                     inputs[1]->get_data_ptr<char>(),
+                                                     inputs[1]->get_shape(),
+                                                     inputs[2]->get_data_ptr<char>(),
+                                                     inputs[2]->get_shape(),
+                                                     inputs[3]->get_data_ptr<char>(),
+                                                     inputs[3]->get_shape(),
+                                                     inputs[4]->get_data_ptr<char>(),
+                                                     inputs[4]->get_shape(),
+                                                     inputs[5]->get_data_ptr<char>(),
+                                                     inputs[5]->get_shape(),
+                                                     outputs[0]->get_data_ptr<char>(),
+                                                     outputs[1]->get_data_ptr<char>(),
+                                                     op->get_activations()[0],
+                                                     op->get_clip(),
+                                                     op->get_direction());
+        }
+    } // namespace rnn_seq_v5
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::RNNSequence>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[2]->get_element_type())
+        {
+        case element::Type_t::i64:
+        case element::Type_t::u64:
+            rnn_seq_v5::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        case element::Type_t::i32:
+        case element::Type_t::u32:
+            rnn_seq_v5::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+        return true;
+    }
+
+    namespace lstm_seq_v5
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v5::LSTMSequence>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::lstm_sequence<T1, T2>(inputs[0]->get_data_ptr<char>(),
+                                                      inputs[0]->get_shape(),
+                                                      inputs[1]->get_data_ptr<char>(),
+                                                      inputs[1]->get_shape(),
+                                                      inputs[2]->get_data_ptr<char>(),
+                                                      inputs[2]->get_shape(),
+                                                      inputs[3]->get_data_ptr<char>(),
+                                                      inputs[3]->get_shape(),
+                                                      inputs[4]->get_data_ptr<char>(),
+                                                      inputs[4]->get_shape(),
+                                                      inputs[5]->get_data_ptr<char>(),
+                                                      inputs[5]->get_shape(),
+                                                      inputs[6]->get_data_ptr<char>(),
+                                                      inputs[6]->get_shape(),
+                                                      outputs[0]->get_data_ptr<char>(),
+                                                      outputs[1]->get_data_ptr<char>(),
+                                                      outputs[2]->get_data_ptr<char>(),
+                                                      op->get_activations()[0],
+                                                      op->get_activations()[1],
+                                                      op->get_activations()[2],
+                                                      op->get_clip(),
+                                                      op->get_direction());
+        }
+    } // namespace lstm_seq_v5
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::LSTMSequence>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[3]->get_element_type())
+        {
+        case element::Type_t::i64:
+        case element::Type_t::u64:
+            lstm_seq_v5::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        case element::Type_t::i32:
+        case element::Type_t::u32:
+            lstm_seq_v5::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+        return true;
+    }
+
+    namespace ti_v0
+    {
+        runtime::reference::custom_evaluate_function evaluate =
+            [](const std::shared_ptr<ngraph::Function>& function,
+               const HostTensorVector& inputs,
+               HostTensorVector& outputs) -> void {
+            const auto& parameters = function->get_parameters();
+            const auto& parametersNumber = parameters.size();
+            const auto& inputsNumber = inputs.size();
+            NGRAPH_CHECK(parametersNumber == inputsNumber,
+                         "Got function (",
+                         function->get_friendly_name(),
+                         ") with ",
+                         parametersNumber,
+                         " parameters, but ",
+                         inputsNumber,
+                         " input blobs");
+
+            auto inputTensors = std::vector<std::shared_ptr<runtime::Tensor>>{};
+            for (const auto& parameter : parameters)
+            {
+                const auto& parameterIndex = function->get_parameter_index(parameter);
+                const auto& parameterShape = parameter->get_shape();
+                const auto& parameterType = parameter->get_element_type();
+                const auto& parameterSize = shape_size(parameterShape) * parameterType.size();
+
+                const auto& input = inputs[parameterIndex];
+                const auto& inputSize = input->get_size_in_bytes();
+                NGRAPH_CHECK(parameterSize == inputSize,
+                             "Got parameter (",
+                             parameter->get_friendly_name(),
+                             ") of size ",
+                             parameterSize,
+                             " bytes, but corresponding input with index ",
+                             parameterIndex,
+                             " has ",
+                             inputSize,
+                             " bytes");
+
+                auto tensor = std::make_shared<runtime::HostTensor>(parameterType, parameterShape);
+                tensor->write(input->get_data_ptr(), parameterSize);
+                inputTensors.push_back(tensor);
+            }
+
+            const auto& results = function->get_results();
+            std::vector<std::shared_ptr<ngraph::runtime::Tensor>> outputTensors;
+            outputTensors.reserve(results.size());
+            for (size_t i = 0; i < results.size(); ++i)
+            {
+                outputTensors.push_back(std::make_shared<HostTensor>());
+            }
+            runtime::Backend::set_backend_shared_library_search_directory("");
+            auto backend = runtime::Backend::create("INTERPRETER");
+            auto handle = backend->compile(function);
+            handle->call_with_validate(outputTensors, inputTensors);
+
+            outputs.reserve(outputTensors.size());
+            for (const auto& tensor : outputTensors)
+            {
+                auto host_tensor = static_pointer_cast<runtime::HostTensor>(tensor);
+                outputs.push_back(host_tensor);
+            }
+        };
+    } // namespace ti_v0
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::TensorIterator>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        runtime::reference::tensor_iterator(op->get_num_iterations(),
+                                            op->get_function(),
+                                            op->get_output_descriptions(),
+                                            op->get_input_descriptions(),
+                                            outputs,
+                                            inputs,
+                                            ti_v0::evaluate);
+        return true;
+    }
+
+    namespace gru_seq_v5
+    {
+        template <element::Type_t t1, element::Type_t t2>
+        inline void evaluate(const shared_ptr<op::v5::GRUSequence>& op,
+                             const HostTensorVector& outputs,
+                             const HostTensorVector& inputs)
+        {
+            using T1 = typename element_type_traits<t1>::value_type;
+            using T2 = typename element_type_traits<t2>::value_type;
+            runtime::reference::gru_sequence<T1, T2>(inputs[0]->get_data_ptr<char>(),
+                                                     inputs[0]->get_shape(),
+                                                     inputs[1]->get_data_ptr<char>(),
+                                                     inputs[1]->get_shape(),
+                                                     inputs[2]->get_data_ptr<char>(),
+                                                     inputs[2]->get_shape(),
+                                                     inputs[3]->get_data_ptr<char>(),
+                                                     inputs[3]->get_shape(),
+                                                     inputs[4]->get_data_ptr<char>(),
+                                                     inputs[4]->get_shape(),
+                                                     inputs[5]->get_data_ptr<char>(),
+                                                     inputs[5]->get_shape(),
+                                                     outputs[0]->get_data_ptr<char>(),
+                                                     outputs[1]->get_data_ptr<char>(),
+                                                     op->get_activations()[0],
+                                                     op->get_activations()[1],
+                                                     op->get_clip(),
+                                                     op->get_direction(),
+                                                     op->get_linear_before_reset());
+        }
+    } // namespace gru_seq_v5
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::GRUSequence>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        switch (inputs[2]->get_element_type())
+        {
+        case element::Type_t::i64:
+        case element::Type_t::u64:
+            gru_seq_v5::evaluate<ET, element::Type_t::i64>(op, outputs, inputs);
+            break;
+        case element::Type_t::i32:
+        case element::Type_t::u32:
+            gru_seq_v5::evaluate<ET, element::Type_t::i32>(op, outputs, inputs);
+            break;
+        default: return false;
+        }
+        return true;
+    }
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::ROIPooling>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::roi_pooling<T>(inputs[0]->get_data_ptr<const T>(),
+                                           inputs[1]->get_data_ptr<const T>(),
+                                           outputs[0]->get_data_ptr<T>(),
+                                           op->get_input_shape(0),
+                                           op->get_input_shape(1),
+                                           op->get_output_shape(0),
+                                           op->get_spatial_scale(),
+                                           op->get_method());
+        return true;
+    }
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::ReorgYolo>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        runtime::reference::reorg_yolo(inputs[0]->get_data_ptr<char>(),
+                                       outputs[0]->get_data_ptr<char>(),
+                                       inputs[0]->get_shape(),
+                                       op->get_strides().at(0),
+                                       inputs[0]->get_element_type().size());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::RegionYolo>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::region_yolo<T>(inputs[0]->get_data_ptr<const T>(),
+                                           outputs[0]->get_data_ptr<T>(),
+                                           inputs[0]->get_shape(),
+                                           op->get_num_coords(),
+                                           op->get_num_classes(),
+                                           op->get_num_regions(),
+                                           op->get_do_softmax(),
+                                           op->get_mask());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::Pad>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::pad(inputs[0]->get_data_ptr<char>(),
+                                inputs[1]->get_data_ptr<char>(),
+                                outputs[0]->get_data_ptr<char>(),
+                                shape_size(inputs[0]->get_shape()),
+                                inputs[1]->get_shape(),
+                                outputs[0]->get_shape(),
+                                op->get_pads_end(),
+                                op->get_pads_begin(),
+                                op->get_pad_mode());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v1::GatherTree>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::gather_tree(inputs[0]->get_data_ptr<const char>(),
+                                        inputs[1]->get_data_ptr<const char>(),
+                                        inputs[2]->get_data_ptr<const char>(),
+                                        inputs[3]->get_data_ptr<const char>(),
+                                        outputs[0]->get_data_ptr<char>(),
+                                        op->get_input_shape(0),
+                                        op->get_input_shape(1),
+                                        op->get_input_shape(2),
+                                        op->get_input_shape(3),
+                                        inputs[1]->get_element_type());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::FakeQuantize>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::fake_quantize<T>(inputs[0]->get_data_ptr<const T>(),
+                                             inputs[1]->get_data_ptr<const T>(),
+                                             inputs[2]->get_data_ptr<const T>(),
+                                             inputs[3]->get_data_ptr<const T>(),
+                                             inputs[4]->get_data_ptr<const T>(),
+                                             outputs[0]->get_data_ptr<T>(),
+                                             op->get_input_shape(0),
+                                             op->get_input_shape(1),
+                                             op->get_input_shape(2),
+                                             op->get_input_shape(3),
+                                             op->get_input_shape(4),
+                                             op->get_levels());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::NormalizeL2>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::normalize_l2<T>(inputs[0]->get_data_ptr<const T>(),
+                                            outputs[0]->get_data_ptr<T>(),
+                                            op->get_input_shape(0),
+                                            op->get_reduction_axes(),
+                                            op->get_eps(),
+                                            op->get_eps_mode());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::CTCGreedyDecoder>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::ctc_greedy_decoder<T>(inputs[0]->get_data_ptr<const T>(),
+                                                  inputs[1]->get_data_ptr<const T>(),
+                                                  outputs[0]->get_data_ptr<T>(),
+                                                  inputs[0]->get_shape(),
+                                                  inputs[1]->get_shape(),
+                                                  outputs[0]->get_shape(),
+                                                  op->get_ctc_merge_repeated());
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v0::SquaredDifference>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        runtime::reference::squared_difference<T>(inputs[0]->get_data_ptr<const T>(),
+                                                  inputs[1]->get_data_ptr<const T>(),
+                                                  outputs[0]->get_data_ptr<T>(),
+                                                  inputs[0]->get_shape(),
+                                                  inputs[1]->get_shape(),
+                                                  ngraph::op::AutoBroadcastSpec::NUMPY);
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::GatherND>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        if (op->get_input_element_type(1) == element::i64)
+        {
+            runtime::reference::gather_nd<T, int64_t>(inputs[0]->get_data_ptr<T>(),
+                                                      inputs[1]->get_data_ptr<int64_t>(),
+                                                      outputs[0]->get_data_ptr<T>(),
+                                                      op->get_input_shape(0),
+                                                      op->get_input_shape(1),
+                                                      op->get_output_shape(0),
+                                                      op->get_batch_dims());
+        }
+        else if (op->get_input_element_type(1) == element::i32)
+        {
+            runtime::reference::gather_nd<T, int32_t>(inputs[0]->get_data_ptr<T>(),
+                                                      inputs[1]->get_data_ptr<int32_t>(),
+                                                      outputs[0]->get_data_ptr<T>(),
+                                                      op->get_input_shape(0),
+                                                      op->get_input_shape(1),
+                                                      op->get_output_shape(0),
+                                                      op->get_batch_dims());
+        }
+        else
+        {
+            throw ngraph_error("Unexpected indices type for GatherND operation");
+        }
+        return true;
+    }
+
+    template <element::Type_t ET>
+    bool evaluate(const shared_ptr<op::v5::LogSoftmax>& op,
+                  const HostTensorVector& outputs,
+                  const HostTensorVector& inputs)
+    {
+        using T = typename element_type_traits<ET>::value_type;
+        int64_t i_axis = op->get_axis();
+        if (i_axis < 0)
+        {
+            i_axis += inputs[0]->get_partial_shape().rank().get_length();
+        }
+        runtime::reference::log_softmax<T>(inputs[0]->get_data_ptr<const T>(),
+                                           outputs[0]->get_data_ptr<T>(),
+                                           op->get_output_shape(0),
+                                           AxisSet{(size_t)i_axis});
+        return true;
+    }
+
+    template <typename T>
+    bool evaluate_node(std::shared_ptr<Node> node,
+                       const HostTensorVector& outputs,
+                       const HostTensorVector& inputs)
+    {
+        auto element_type = node->get_output_element_type(0);
+        if (is_type<op::v1::Select>(node))
+        {
+            element_type = node->get_input_element_type(1);
+        }
+        else if (is_type<op::v0::PriorBox>(node))
+        {
+            element_type = node->get_input_element_type(0);
+        }
+        for (size_t i = 1; i < node->outputs().size(); i++)
+        {
+            if (is_type<op::v5::NonMaxSuppression>(node) && i == 1)
+            {
+                continue;
+            }
+            if (element_type != node->get_output_element_type(i))
+            {
+                throw std::logic_error("Output node element types is not equal");
+            }
+        }
+        switch (element_type)
+        {
+        case element::Type_t::boolean:
+            return evaluate<element::Type_t::boolean>(as_type_ptr<T>(node), outputs, inputs);
+            ;
+        //            case element::Type_t::bf16:
+        //                break;
+        case element::Type_t::f16:
+            return evaluate<element::Type_t::f16>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::f64:
+            return evaluate<element::Type_t::f64>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::f32:
+            return evaluate<element::Type_t::f32>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::i8:
+            return evaluate<element::Type_t::i8>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::i16:
+            return evaluate<element::Type_t::i16>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::i32:
+            return evaluate<element::Type_t::i32>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::i64:
+            return evaluate<element::Type_t::i64>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::u8:
+            return evaluate<element::Type_t::u8>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::u16:
+            return evaluate<element::Type_t::u16>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::u32:
+            return evaluate<element::Type_t::u32>(as_type_ptr<T>(node), outputs, inputs);
+        case element::Type_t::u64:
+            return evaluate<element::Type_t::u64>(as_type_ptr<T>(node), outputs, inputs);
+        default:
+            throw ngraph_error(std::string("Unhandled data type ") +
+                               node->get_element_type().get_type_name() +
+                               std::string("in evaluate_node()"));
+        }
+    }
+} // namespace
+
+runtime::interpreter::EvaluatorsMap& runtime::interpreter::get_evaluators_map()
+{
+    static runtime::interpreter::EvaluatorsMap evaluatorsMap{
+#define NGRAPH_OP(NAME, NAMESPACE) {NAMESPACE::NAME::type_info, evaluate_node<NAMESPACE::NAME>},
+
+#include "opset_int_tbl.hpp"
+
+#undef NGRAPH_OP
+    };
+    return evaluatorsMap;
+}
\ No newline at end of file
diff --git a/ngraph/test/runtime/interpreter/evaluates_map.hpp b/ngraph/test/runtime/interpreter/evaluates_map.hpp
new file mode 100644
index 00000000000000..8d211b00f73cb4
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/evaluates_map.hpp
@@ -0,0 +1,34 @@
+//*****************************************************************************
+// Copyright 2017-2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+#pragma once
+#include "int_backend_visibility.hpp"
+#include "ngraph/node.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace interpreter
+        {
+            using EvaluatorsMap =
+                std::map<ngraph::NodeTypeInfo,
+                         std::function<bool(const std::shared_ptr<ngraph::Node>& node,
+                                            const ngraph::HostTensorVector& outputs,
+                                            const ngraph::HostTensorVector& inputs)>>;
+            EvaluatorsMap& get_evaluators_map();
+        }
+    }
+}
diff --git a/ngraph/test/runtime/interpreter/int_backend.hpp b/ngraph/test/runtime/interpreter/int_backend.hpp
index f4309694a19542..36270345a24d14 100644
--- a/ngraph/test/runtime/interpreter/int_backend.hpp
+++ b/ngraph/test/runtime/interpreter/int_backend.hpp
@@ -36,7 +36,6 @@ namespace ngraph
         {
             class INTBackend;
             class INTExecutable;
-            class INTBackendConstructor;
         }
     }
 }
diff --git a/ngraph/test/runtime/interpreter/int_executable.cpp b/ngraph/test/runtime/interpreter/int_executable.cpp
index 88506e6117b880..9fe7b5eeb40ec4 100644
--- a/ngraph/test/runtime/interpreter/int_executable.cpp
+++ b/ngraph/test/runtime/interpreter/int_executable.cpp
@@ -17,259 +17,95 @@
 #include "int_executable.hpp"
 #include <cstring>
 #include "backend_manager.hpp"
+#include "evaluates_map.hpp"
 #include "ngraph/chrome_trace.hpp"
 #include "ngraph/except.hpp"
-#include "ngraph/op/util/op_types.hpp"
 #include "ngraph/ops.hpp"
-#include "ngraph/pass/manager.hpp"
 #include "ngraph/type/bfloat16.hpp"
 #include "ngraph/type/float16.hpp"
 #include "ngraph/util.hpp"
-#include "pass/fused_op_decomposition.hpp"
-#include "pass/liveness.hpp"
-#include "pass/opset0_downgrade.hpp"
-#include "pass/opset1_downgrade.hpp"
 
 using namespace std;
 using namespace ngraph;
 
 NGRAPH_SUPPRESS_DEPRECATED_START
 
-using V5BoxEncoding = op::v5::NonMaxSuppression::BoxEncodingType;
-
-namespace
+runtime::interpreter::INTExecutable::INTExecutable(const shared_ptr<Function>& function,
+                                                   bool enable_performance_collection)
+    : m_is_compiled{true}
+    , m_performance_counters_enabled{enable_performance_collection}
 {
-    constexpr size_t boxes_port = 0;
-    constexpr size_t scores_port = 1;
-    constexpr size_t max_output_boxes_port = 2;
-    constexpr size_t iou_threshold_port = 3;
-    constexpr size_t score_threshold_port = 4;
-    constexpr size_t soft_nms_sigma_port = 5;
-
-    PartialShape
-        infer_selected_indices_shape(const std::vector<std::shared_ptr<HostTensor>>& inputs,
-                                     int64_t max_output_boxes_per_class)
-    {
-        const auto boxes_ps = inputs[boxes_port]->get_partial_shape();
-        const auto scores_ps = inputs[scores_port]->get_partial_shape();
-
-        // NonMaxSuppression produces triplets
-        // that have the following format: [batch_index, class_index, box_index]
-        PartialShape result = {Dimension::dynamic(), 3};
-
-        if (boxes_ps.rank().is_static() && scores_ps.rank().is_static())
-        {
-            const auto num_boxes_boxes = boxes_ps[1];
-            if (num_boxes_boxes.is_static() && scores_ps[0].is_static() && scores_ps[1].is_static())
-            {
-                const auto num_boxes = num_boxes_boxes.get_length();
-                const auto num_classes = scores_ps[1].get_length();
-
-                result[0] = std::min(num_boxes, max_output_boxes_per_class) * num_classes *
-                            scores_ps[0].get_length();
-            }
-        }
-
-        return result;
-    }
-
-    void normalize_corner(float* boxes, const Shape& boxes_shape)
-    {
-        size_t total_num_of_boxes = shape_size(boxes_shape) / 4;
-        for (size_t i = 0; i < total_num_of_boxes; ++i)
-        {
-            float* current_box = boxes + 4 * i;
-
-            float y1 = current_box[0];
-            float x1 = current_box[1];
-            float y2 = current_box[2];
-            float x2 = current_box[3];
-
-            float ymin = std::min(y1, y2);
-            float ymax = std::max(y1, y2);
-            float xmin = std::min(x1, x2);
-            float xmax = std::max(x1, x2);
-
-            current_box[0] = ymin;
-            current_box[1] = xmin;
-            current_box[2] = ymax;
-            current_box[3] = xmax;
-        }
-    }
-
-    void normalize_center(float* boxes, const Shape& boxes_shape)
-    {
-        size_t total_num_of_boxes = shape_size(boxes_shape) / 4;
-        for (size_t i = 0; i < total_num_of_boxes; ++i)
-        {
-            float* current_box = boxes + 4 * i;
-
-            float x_center = current_box[0];
-            float y_center = current_box[1];
-            float width = current_box[2];
-            float height = current_box[3];
-
-            float y1 = y_center - height / 2.0;
-            float x1 = x_center - width / 2.0;
-            float y2 = y_center + height / 2.0;
-            float x2 = x_center + width / 2.0;
-
-            current_box[0] = y1;
-            current_box[1] = x1;
-            current_box[2] = y2;
-            current_box[3] = x2;
-        }
-    }
-
-    void normalize_box_encoding(float* boxes,
-                                const Shape& boxes_shape,
-                                const V5BoxEncoding box_encoding)
-    {
-        if (box_encoding == V5BoxEncoding::CORNER)
-        {
-            normalize_corner(boxes, boxes_shape);
-        }
-        else
-        {
-            normalize_center(boxes, boxes_shape);
-        }
-    }
-
-    std::vector<float> get_floats(const std::shared_ptr<HostTensor>& input, const Shape& shape)
+    m_function = clone_function(*function);
+    for (const auto& node : m_function->get_ordered_ops())
     {
-        size_t input_size = shape_size(shape);
-        std::vector<float> result(input_size);
-
-        switch (input->get_element_type())
+        // TODO: WA because of references mismatch for the operation
+        if (is_type<op::v1::GroupConvolutionBackpropData>(node))
         {
-        case element::Type_t::bf16:
-        {
-            bfloat16* p = input->get_data_ptr<bfloat16>();
-            for (size_t i = 0; i < input_size; ++i)
+            auto gr_conv_bp_data = dynamic_pointer_cast<op::v1::GroupConvolutionBackpropData>(node);
+            auto num_groups = gr_conv_bp_data->input_value(1).get_shape()[0];
+            auto split_filter_axis = std::make_shared<op::Constant>(
+                ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<uint64_t>{0});
+            auto sliced_filter = std::make_shared<op::v1::Split>(
+                gr_conv_bp_data->input_value(1), split_filter_axis, num_groups);
+            auto split_data_axis = std::make_shared<op::Constant>(
+                ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<uint64_t>{1});
+            auto sliced_data = std::make_shared<op::v1::Split>(
+                gr_conv_bp_data->input_value(0), split_data_axis, num_groups);
+
+            NodeVector convs;
+            auto squeeze_filter_axis = std::make_shared<op::Constant>(
+                ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<uint64_t>{0});
+            for (size_t i = 0; i < num_groups; ++i)
             {
-                result[i] = float(p[i]);
+                auto squeezed_filter = std::make_shared<op::v0::Squeeze>(sliced_filter->output(i),
+                                                                         squeeze_filter_axis);
+                auto conv = std::make_shared<op::v1::ConvolutionBackpropData>(
+                    sliced_data->output(i),
+                    squeezed_filter,
+                    gr_conv_bp_data->get_strides(),
+                    gr_conv_bp_data->get_pads_begin(),
+                    gr_conv_bp_data->get_pads_end(),
+                    gr_conv_bp_data->get_dilations(),
+                    gr_conv_bp_data->get_auto_pad(),
+                    gr_conv_bp_data->get_output_padding());
+                convs.push_back(conv);
             }
+            auto concat = std::make_shared<op::Concat>(convs, 1);
+            replace_node(node, concat);
         }
-        break;
-        case element::Type_t::f16:
+        else if (is_type<op::v1::GroupConvolution>(node))
         {
-            float16* p = input->get_data_ptr<float16>();
-            for (size_t i = 0; i < input_size; ++i)
+            auto gr_conv = dynamic_pointer_cast<op::v1::GroupConvolution>(node);
+            auto num_groups = gr_conv->input_value(1).get_shape()[0];
+            auto split_filter_axis = std::make_shared<op::Constant>(
+                ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<uint64_t>{0});
+            auto sliced_filter = std::make_shared<op::v1::Split>(
+                gr_conv->input_value(1), split_filter_axis, num_groups);
+            auto split_data_axis = std::make_shared<op::Constant>(
+                ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<uint64_t>{1});
+            auto sliced_data = std::make_shared<op::v1::Split>(
+                gr_conv->input_value(0), split_data_axis, num_groups);
+
+            NodeVector convs;
+            auto squeeze_filter_axis = std::make_shared<op::Constant>(
+                ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<uint64_t>{0});
+            for (size_t i = 0; i < num_groups; ++i)
             {
-                result[i] = float(p[i]);
+                auto squeezed_filter = std::make_shared<op::v0::Squeeze>(sliced_filter->output(i),
+                                                                         squeeze_filter_axis);
+                auto conv = std::make_shared<op::v1::Convolution>(sliced_data->output(i),
+                                                                  squeezed_filter,
+                                                                  gr_conv->get_strides(),
+                                                                  gr_conv->get_pads_begin(),
+                                                                  gr_conv->get_pads_end(),
+                                                                  gr_conv->get_dilations(),
+                                                                  gr_conv->get_auto_pad());
+                convs.push_back(conv);
             }
+            auto concat = std::make_shared<op::Concat>(convs, 1);
+            replace_node(node, concat);
         }
-        break;
-        case element::Type_t::f32:
-        {
-            float* p = input->get_data_ptr<float>();
-            memcpy(result.data(), p, input_size * sizeof(float));
-        }
-        break;
-        default: throw std::runtime_error("Unsupported data type in op NonMaxSuppression-5"); break;
-        }
-
-        return result;
-    }
-
-    std::vector<float> prepare_boxes_data(const std::shared_ptr<HostTensor>& boxes,
-                                          const Shape& boxes_shape,
-                                          const V5BoxEncoding box_encoding)
-    {
-        auto result = get_floats(boxes, boxes_shape);
-        normalize_box_encoding(result.data(), boxes_shape, box_encoding);
-        return result;
     }
-
-    std::vector<float> prepare_scores_data(const std::shared_ptr<HostTensor>& scores,
-                                           const Shape& scores_shape)
-    {
-        auto result = get_floats(scores, scores_shape);
-        return result;
-    }
-}
-
-runtime::interpreter::INTExecutable::InfoForNMS5
-    runtime::interpreter::INTExecutable::get_info_for_nms5_eval(
-        const op::v5::NonMaxSuppression* nms5,
-        const std::vector<std::shared_ptr<HostTensor>>& inputs)
-{
-    InfoForNMS5 result;
-
-    result.max_output_boxes_per_class = nms5->max_boxes_output_from_input();
-    result.iou_threshold = nms5->iou_threshold_from_input();
-    result.score_threshold = nms5->score_threshold_from_input();
-    result.soft_nms_sigma = nms5->soft_nms_sigma_from_input();
-
-    auto selected_indices_shape =
-        infer_selected_indices_shape(inputs, result.max_output_boxes_per_class);
-    result.out_shape = selected_indices_shape.to_shape();
-
-    result.boxes_shape = inputs[boxes_port]->get_shape();
-    result.scores_shape = inputs[scores_port]->get_shape();
-
-    result.boxes_data =
-        prepare_boxes_data(inputs[boxes_port], result.boxes_shape, nms5->get_box_encoding());
-    result.scores_data = prepare_scores_data(inputs[scores_port], result.scores_shape);
-
-    result.out_shape_size = shape_size(result.out_shape);
-
-    result.sort_result_descending = nms5->get_sort_result_descending();
-
-    result.output_type = nms5->get_output_type();
-
-    return result;
-}
-
-runtime::interpreter::OP_TYPEID runtime::interpreter::INTExecutable::get_typeid(const Node& node)
-{
-    const NodeTypeInfo& type_info = node.get_type_info();
-    // This expands the op list in op_tbl.hpp into a list of enumerations that look like this:
-    // {Abs::type_info, OP_TYPEID::Abs},
-    // {Acos::type_info, OP_TYPEID::Acos},
-    // ...
-    static const map<NodeTypeInfo, OP_TYPEID> type_info_map{
-#define NGRAPH_OP(NAME, NAMESPACE) {NAMESPACE::NAME::type_info, OP_TYPEID::ID_SUFFIX(NAME)},
-#include "opset_int_tbl.hpp"
-#undef NGRAPH_OP
-    };
-    OP_TYPEID rc = OP_TYPEID::UnknownOp;
-
-    auto it = type_info_map.find(type_info);
-    if (it != type_info_map.end())
-    {
-        rc = it->second;
-    }
-    return rc;
-}
-
-runtime::interpreter::INTExecutable::INTExecutable(const shared_ptr<Function>& function,
-                                                   bool enable_performance_collection)
-    : m_is_compiled{true}
-    , m_performance_counters_enabled{enable_performance_collection}
-{
-    m_function = clone_function(*function);
-    auto is_supported = [](const Node& node) {
-        bool retval = false;
-        switch (INTExecutable::get_typeid(node))
-        {
-        case OP_TYPEID::Clamp:
-        case OP_TYPEID::MatMul:
-        case OP_TYPEID::NormalizeL2:
-        case OP_TYPEID::PRelu:
-        case OP_TYPEID::Squeeze:
-        case OP_TYPEID::Unsqueeze: retval = true; break;
-        default: break;
-        }
-        return retval;
-    };
-    pass::Manager pass_manager;
-    pass_manager.register_pass<pass::FusedOpDecomposition>(is_supported);
-    pass_manager.register_pass<pass::Opset1Downgrade>();
-    pass_manager.register_pass<pass::Opset0Downgrade>();
-    // Need to decompose any v0 fused ops, which were produced by the downgrade pass
-    pass_manager.register_pass<pass::FusedOpDecomposition>(is_supported);
-    pass_manager.run_passes(m_function);
     for (auto node : m_function->get_ordered_ops())
     {
         m_nodes.push_back(node);
@@ -330,7 +166,7 @@ bool runtime::interpreter::INTExecutable::call(const vector<shared_ptr<runtime::
     for (const auto& op : m_nodes)
     {
         event::Duration d2(op->description(), "Interpreter");
-        if (op::is_parameter(op))
+        if (dynamic_pointer_cast<op::Parameter>(op) != nullptr)
         {
             continue;
         }
@@ -368,8 +204,9 @@ bool runtime::interpreter::INTExecutable::call(const vector<shared_ptr<runtime::
         {
             type = op->get_input_element_type(0);
         }
-        else if (is_type<op::Equal>(op) || is_type<op::Greater>(op) || is_type<op::GreaterEq>(op) ||
-                 is_type<op::Less>(op) || is_type<op::LessEq>(op) || is_type<op::NotEqual>(op))
+        else if (is_type<op::v1::Equal>(op) || is_type<op::v1::Greater>(op) ||
+                 is_type<op::v1::GreaterEqual>(op) || is_type<op::v1::Less>(op) ||
+                 is_type<op::v1::LessEqual>(op) || is_type<op::v1::NotEqual>(op))
         {
             // Get the type of the second input, not the first
             // All BinaryElementwiseComparision ops have the same type for inputs
@@ -387,7 +224,7 @@ bool runtime::interpreter::INTExecutable::call(const vector<shared_ptr<runtime::
         }
         if (!op->evaluate(op_outputs, op_inputs))
         {
-            generate_calls(type, *op, op_outputs, op_inputs);
+            evaluate_node(op, op_outputs, op_inputs);
         }
         if (m_performance_counters_enabled)
         {
@@ -402,40 +239,6 @@ bool runtime::interpreter::INTExecutable::call(const vector<shared_ptr<runtime::
     return true;
 }
 
-void runtime::interpreter::INTExecutable::generate_calls(const element::Type& type,
-                                                         const Node& op,
-                                                         const vector<shared_ptr<HostTensor>>& out,
-                                                         const vector<shared_ptr<HostTensor>>& in)
-{
-    stringstream ss;
-    switch (type)
-    {
-    case element::Type_t::boolean: op_engine<char>(op, out, in); break;
-    case element::Type_t::f32: op_engine<float>(op, out, in); break;
-    case element::Type_t::f64: op_engine<double>(op, out, in); break;
-    case element::Type_t::i8: op_engine<int8_t>(op, out, in); break;
-    case element::Type_t::i16: op_engine<int16_t>(op, out, in); break;
-    case element::Type_t::i32: op_engine<int32_t>(op, out, in); break;
-    case element::Type_t::i64: op_engine<int64_t>(op, out, in); break;
-    case element::Type_t::u8: op_engine<uint8_t>(op, out, in); break;
-    case element::Type_t::u16: op_engine<uint16_t>(op, out, in); break;
-    case element::Type_t::u32: op_engine<uint32_t>(op, out, in); break;
-    case element::Type_t::u64: op_engine<uint64_t>(op, out, in); break;
-    case element::Type_t::undefined:
-    case element::Type_t::dynamic:
-    case element::Type_t::u1:
-    case element::Type_t::bf16:
-    case element::Type_t::f16:
-        ss << "unsupported element type " << type << " op " << op.get_name();
-        throw ngraph_error(ss.str());
-    }
-}
-
-void runtime::interpreter::INTExecutable::set_nan_check(bool enable)
-{
-    m_nan_check_enabled = enable;
-}
-
 vector<runtime::PerformanceCounter>
     runtime::interpreter::INTExecutable::get_performance_data() const
 {
@@ -566,3 +369,28 @@ vector<shared_ptr<runtime::Tensor>>
     }
     return result_tensors;
 }
+
+bool runtime::interpreter::INTExecutable::evaluate_node(const std::shared_ptr<Node>& node,
+                                                        const HostTensorVector& outputs,
+                                                        const HostTensorVector& inputs) const
+{
+    auto& map = runtime::interpreter::get_evaluators_map();
+    auto it = map.find(node->get_type_info());
+    bool res = false;
+    if (it != map.end())
+    {
+        res = it->second(node, outputs, inputs);
+        if (!res)
+        {
+            throw ngraph_error(std::string("Running evaluate method for OP ") +
+                               node->get_type_info().name + std::string(" failed!"));
+        }
+    }
+    else
+    {
+        throw unsupported_op(
+            std::string("Interpreter backend doesn't implement evaluate method for OP ") +
+            node->get_type_info().name);
+    }
+    return res;
+}
\ No newline at end of file
diff --git a/ngraph/test/runtime/interpreter/int_executable.hpp b/ngraph/test/runtime/interpreter/int_executable.hpp
index 8d01ec56477727..24ddafaf894eab 100644
--- a/ngraph/test/runtime/interpreter/int_executable.hpp
+++ b/ngraph/test/runtime/interpreter/int_executable.hpp
@@ -28,85 +28,12 @@
 #include "int_backend_visibility.hpp"
 #include "ngraph/ops.hpp"
 #include "ngraph/runtime/aligned_buffer.hpp"
-#include "ngraph/runtime/reference/abs.hpp"
-#include "ngraph/runtime/reference/acos.hpp"
-#include "ngraph/runtime/reference/asin.hpp"
-#include "ngraph/runtime/reference/atan.hpp"
-#include "ngraph/runtime/reference/atan2.hpp"
-#include "ngraph/runtime/reference/avg_pool.hpp"
-#include "ngraph/runtime/reference/batch_norm.hpp"
-#include "ngraph/runtime/reference/broadcast.hpp"
-#include "ngraph/runtime/reference/ceiling.hpp"
-#include "ngraph/runtime/reference/concat.hpp"
-#include "ngraph/runtime/reference/constant.hpp"
-#include "ngraph/runtime/reference/convert.hpp"
-#include "ngraph/runtime/reference/convolution.hpp"
-#include "ngraph/runtime/reference/cos.hpp"
-#include "ngraph/runtime/reference/cosh.hpp"
-#include "ngraph/runtime/reference/ctc_greedy_decoder.hpp"
-#include "ngraph/runtime/reference/ctc_loss.hpp"
-#include "ngraph/runtime/reference/cum_sum.hpp"
-#include "ngraph/runtime/reference/detection_output.hpp"
-#include "ngraph/runtime/reference/elu.hpp"
-#include "ngraph/runtime/reference/embedding_bag_offsets_sum.hpp"
-#include "ngraph/runtime/reference/embedding_bag_packed_sum.hpp"
-#include "ngraph/runtime/reference/embedding_segments_sum.hpp"
-#include "ngraph/runtime/reference/erf.hpp"
-#include "ngraph/runtime/reference/exp.hpp"
-#include "ngraph/runtime/reference/extract_image_patches.hpp"
-#include "ngraph/runtime/reference/floor.hpp"
-#include "ngraph/runtime/reference/gather.hpp"
-#include "ngraph/runtime/reference/gather_nd.hpp"
-#include "ngraph/runtime/reference/gather_tree.hpp"
-#include "ngraph/runtime/reference/gru_cell.hpp"
 #include "ngraph/runtime/reference/hard_sigmoid.hpp"
-#include "ngraph/runtime/reference/log.hpp"
-#include "ngraph/runtime/reference/log_softmax.hpp"
-#include "ngraph/runtime/reference/lrn.hpp"
-#include "ngraph/runtime/reference/lstm_cell.hpp"
-#include "ngraph/runtime/reference/matmul.hpp"
-#include "ngraph/runtime/reference/max.hpp"
-#include "ngraph/runtime/reference/max_pool.hpp"
-#include "ngraph/runtime/reference/min.hpp"
-#include "ngraph/runtime/reference/negate.hpp"
 #include "ngraph/runtime/reference/non_max_suppression.hpp"
-#include "ngraph/runtime/reference/normalize_l2.hpp"
-#include "ngraph/runtime/reference/not.hpp"
-#include "ngraph/runtime/reference/one_hot.hpp"
-#include "ngraph/runtime/reference/pad.hpp"
-#include "ngraph/runtime/reference/prior_box.hpp"
-#include "ngraph/runtime/reference/product.hpp"
-#include "ngraph/runtime/reference/quantize.hpp"
-#include "ngraph/runtime/reference/region_yolo.hpp"
-#include "ngraph/runtime/reference/relu.hpp"
 #include "ngraph/runtime/reference/reorg_yolo.hpp"
-#include "ngraph/runtime/reference/reshape.hpp"
-#include "ngraph/runtime/reference/result.hpp"
-#include "ngraph/runtime/reference/reverse.hpp"
-#include "ngraph/runtime/reference/reverse_sequence.hpp"
-#include "ngraph/runtime/reference/rnn_cell.hpp"
-#include "ngraph/runtime/reference/roi_pooling.hpp"
-#include "ngraph/runtime/reference/round.hpp"
-#include "ngraph/runtime/reference/scatter_nd_update.hpp"
-#include "ngraph/runtime/reference/select.hpp"
-#include "ngraph/runtime/reference/sequences.hpp"
-#include "ngraph/runtime/reference/sigmoid.hpp"
-#include "ngraph/runtime/reference/sign.hpp"
-#include "ngraph/runtime/reference/sin.hpp"
-#include "ngraph/runtime/reference/sinh.hpp"
-#include "ngraph/runtime/reference/softmax.hpp"
-#include "ngraph/runtime/reference/sqrt.hpp"
-#include "ngraph/runtime/reference/sum.hpp"
-#include "ngraph/runtime/reference/tan.hpp"
-#include "ngraph/runtime/reference/tanh.hpp"
 #include "ngraph/runtime/reference/tensor_iterator.hpp"
-#include "ngraph/runtime/reference/topk.hpp"
 #include "ngraph/runtime/tensor.hpp"
 #include "op/avg_pool.hpp"
-#include "op/convolution.hpp"
-#include "op/group_conv.hpp"
-
-NGRAPH_SUPPRESS_DEPRECATED_START
 
 namespace ngraph
 {
@@ -116,19 +43,6 @@ namespace ngraph
         {
             class INTBackend;
             class INTExecutable;
-
-            // This expands the op list in op_tbl.hpp into a list of enumerations that look like
-            // this:
-            // Abs,
-            // Acos,
-            // ...
-            enum class OP_TYPEID
-            {
-#define NGRAPH_OP(NAME, NAMESPACE) ID_SUFFIX(NAME),
-#include "opset_int_tbl.hpp"
-#undef NGRAPH_OP
-                UnknownOp
-            };
         } // namespace interpreter
     }     // namespace runtime
 } // namespace ngraph
@@ -161,25 +75,18 @@ class INTERPRETER_BACKEND_API ngraph::runtime::interpreter::INTExecutable : publ
 protected:
     std::shared_ptr<ngraph::op::Parameter> get_parameter(size_t index) const;
     std::shared_ptr<ngraph::op::Result> get_result(size_t index) const;
-    int get_alignment() const { return 64; }
+    bool evaluate_node(const std::shared_ptr<Node>& node,
+                       const HostTensorVector& outputs,
+                       const HostTensorVector& inputs) const;
     bool m_is_compiled = false;
     bool m_nan_check_enabled = false;
     bool m_performance_counters_enabled = false;
     std::shared_ptr<Function> m_function;
     std::unordered_map<std::shared_ptr<const Node>, stopwatch> m_timer_map;
     std::vector<std::shared_ptr<Node>> m_nodes;
-    std::set<std::string> m_unsupported_op_name_list;
-
-    static OP_TYPEID get_typeid(const Node& node);
 
     static void perform_nan_check(const std::vector<std::shared_ptr<HostTensor>>&,
                                   const Node* op = nullptr);
-
-    virtual void generate_calls(const element::Type& type,
-                                const Node& op,
-                                const std::vector<std::shared_ptr<HostTensor>>& outputs,
-                                const std::vector<std::shared_ptr<HostTensor>>& inputs);
-
     struct InfoForNMS5
     {
         int64_t max_output_boxes_per_class;
@@ -198,1339 +105,4 @@ class INTERPRETER_BACKEND_API ngraph::runtime::interpreter::INTExecutable : publ
 
     InfoForNMS5 get_info_for_nms5_eval(const op::v5::NonMaxSuppression* nms5,
                                        const std::vector<std::shared_ptr<HostTensor>>& inputs);
-
-    template <typename T>
-    void op_engine(const Node& node,
-                   const std::vector<std::shared_ptr<HostTensor>>& out,
-                   const std::vector<std::shared_ptr<HostTensor>>& args)
-    {
-// We want to check that every OP_TYPEID enumeration is included in the list.
-// These GCC flags enable compile-time checking so that if an enumeration
-// is not in the list an error is generated.
-#if defined(__GNUC__) && !(__GNUC__ == 4 && __GNUC_MINOR__ == 8)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic error "-Wswitch"
-#pragma GCC diagnostic error "-Wswitch-enum"
-#endif
-        switch (get_typeid(node))
-        {
-        case OP_TYPEID::Abs:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::abs<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Acos:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::acos<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Asin:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::asin<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Atan:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::atan<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Elu:
-        {
-            const op::Elu* elu_node = static_cast<const op::Elu*>(&node);
-
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::elu<T>(args[0]->get_data_ptr<const T>(),
-                              out[0]->get_data_ptr<T>(),
-                              element_count,
-                              elu_node->get_alpha());
-            break;
-        }
-        case OP_TYPEID::AvgPool:
-        {
-            const op::v0::AvgPool* avg_pool = static_cast<const op::v0::AvgPool*>(&node);
-
-            reference::avg_pool<T>(args[0]->get_data_ptr<const T>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   avg_pool->get_window_shape(),
-                                   avg_pool->get_window_movement_strides(),
-                                   avg_pool->get_padding_below(),
-                                   avg_pool->get_padding_above(),
-                                   avg_pool->get_include_padding_in_avg_computation());
-            break;
-        }
-        case OP_TYPEID::BatchNormInference:
-        {
-            const ngraph::op::v0::BatchNormInference* bn =
-                static_cast<const ngraph::op::v0::BatchNormInference*>(&node);
-            reference::batch_norm_inference<T>(bn->get_eps_value(),
-                                               args[0]->get_data_ptr<const T>(),
-                                               args[1]->get_data_ptr<const T>(),
-                                               args[2]->get_data_ptr<const T>(),
-                                               args[3]->get_data_ptr<const T>(),
-                                               args[4]->get_data_ptr<const T>(),
-                                               out[0]->get_data_ptr<T>(),
-                                               node.get_input_shape(2));
-            break;
-        }
-        case OP_TYPEID::BatchNormInference_v5:
-        {
-            const ngraph::op::v5::BatchNormInference* bn =
-                static_cast<const ngraph::op::v5::BatchNormInference*>(&node);
-            reference::batch_norm_inference<T>(bn->get_eps_value(),
-                                               args[1]->get_data_ptr<const T>(),
-                                               args[2]->get_data_ptr<const T>(),
-                                               args[0]->get_data_ptr<const T>(),
-                                               args[3]->get_data_ptr<const T>(),
-                                               args[4]->get_data_ptr<const T>(),
-                                               out[0]->get_data_ptr<T>(),
-                                               node.get_input_shape(0));
-            break;
-        }
-        case OP_TYPEID::Ceiling:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::ceiling<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Convert:
-        {
-            // const op::Convert* c = static_cast<const op::Convert*>(&node);
-            element::Type type = node.get_element_type();
-            std::stringstream ss;
-            size_t element_count = shape_size(node.get_output_shape(0));
-            switch (type)
-            {
-            case element::Type_t::boolean:
-                reference::convert_to_bool<T>(
-                    args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<char>(), element_count);
-                break;
-            case element::Type_t::f32:
-                reference::convert<T>(
-                    args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<float>(), element_count);
-                break;
-            case element::Type_t::f64:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<double>(),
-                                      element_count);
-                break;
-            case element::Type_t::i8:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<int8_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::i16:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<int16_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::i32:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<int32_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::i64:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<int64_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::u8:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<uint8_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::u16:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<uint16_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::u32:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<uint32_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::u64:
-                reference::convert<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<uint64_t>(),
-                                      element_count);
-                break;
-            case element::Type_t::undefined:
-            case element::Type_t::dynamic:
-            case element::Type_t::u1:
-            case element::Type_t::bf16:
-            case element::Type_t::f16:
-                ss << "unsupported element type " << type << " op Convert";
-                throw std::runtime_error(ss.str());
-            }
-            break;
-        }
-        case OP_TYPEID::Convolution:
-        {
-            const op::v0::Convolution* c = static_cast<const op::v0::Convolution*>(&node);
-            reference::convolution<T>(args[0]->get_data_ptr<const T>(),
-                                      args[1]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<T>(),
-                                      node.get_input_shape(0),
-                                      node.get_input_shape(1),
-                                      node.get_output_shape(0),
-                                      c->get_window_movement_strides(),
-                                      c->get_window_dilation_strides(),
-                                      c->get_padding_below(),
-                                      c->get_padding_above(),
-                                      c->get_data_dilation_strides());
-
-            break;
-        }
-        case OP_TYPEID::ConvolutionBackpropData:
-        {
-            // Note that args[1] and args[0] are switched here from the usual order.
-            const op::v0::ConvolutionBackpropData* c =
-                static_cast<const op::v0::ConvolutionBackpropData*>(&node);
-            reference::convolution_backprop_in<T>(args[1]->get_data_ptr<const T>(),
-                                                  args[0]->get_data_ptr<const T>(),
-                                                  out[0]->get_data_ptr<T>(),
-                                                  c->get_input_shape(1),
-                                                  c->get_input_shape(0),
-                                                  c->get_data_batch_shape(),
-                                                  c->get_data_dilation_strides_forward(),
-                                                  c->get_window_dilation_strides_forward(),
-                                                  c->compute_backward_delta_out_pad_below(),
-                                                  c->compute_backward_delta_out_pad_above(),
-                                                  c->get_window_movement_strides_forward());
-            break;
-        }
-        case OP_TYPEID::Cos:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::cos<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Cosh:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::cosh<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::CTCGreedyDecoder_v0:
-        {
-            const auto ctc_greedy_dec = static_cast<const op::v0::CTCGreedyDecoder*>(&node);
-            reference::ctc_greedy_decoder<T>(args[0]->get_data_ptr<const T>(),
-                                             args[1]->get_data_ptr<const T>(),
-                                             out[0]->get_data_ptr<T>(),
-                                             args[0]->get_shape(),
-                                             args[1]->get_shape(),
-                                             out[0]->get_shape(),
-                                             ctc_greedy_dec->get_ctc_merge_repeated());
-            break;
-        }
-        case OP_TYPEID::CTCLoss_v4:
-        {
-            const op::v4::CTCLoss* ctc_loss = static_cast<const op::v4::CTCLoss*>(&node);
-            auto t_int = node.get_input_element_type(1);
-            if (t_int == element::Type_t::i32)
-            {
-                reference::CTCLoss<T, int32_t>(
-                    args[0]->get_data_ptr<const T>(),
-                    ctc_loss->get_input_shape(0),
-                    args[1]->get_data_ptr<const int32_t>(),
-                    args[2]->get_data_ptr<const int32_t>(),
-                    args[3]->get_data_ptr<const int32_t>(),
-                    args.size() > 4 ? args[4]->get_data_ptr<const int32_t>() : nullptr,
-                    ctc_loss->get_preprocess_collapse_repeated(),
-                    ctc_loss->get_ctc_merge_repeated(),
-                    ctc_loss->get_unique(),
-                    out[0]->get_data_ptr<T>());
-            }
-            else if (t_int == element::Type_t::i64)
-            {
-                reference::CTCLoss<T, int64_t>(
-                    args[0]->get_data_ptr<const T>(),
-                    ctc_loss->get_input_shape(0),
-                    args[1]->get_data_ptr<const int64_t>(),
-                    args[2]->get_data_ptr<const int64_t>(),
-                    args[3]->get_data_ptr<const int64_t>(),
-                    args.size() > 4 ? args[4]->get_data_ptr<const int64_t>() : nullptr,
-                    ctc_loss->get_preprocess_collapse_repeated(),
-                    ctc_loss->get_ctc_merge_repeated(),
-                    ctc_loss->get_unique(),
-                    out[0]->get_data_ptr<T>());
-            }
-            break;
-        }
-        case OP_TYPEID::CumSum:
-        {
-            const op::CumSum* cumsum = static_cast<const op::CumSum*>(&node);
-            auto axis_et = node.get_input_element_type(1);
-            if (axis_et == element::Type_t::i32)
-            {
-                reference::cumsum<T, int32_t>(args[0]->get_data_ptr<const T>(),
-                                              args[1]->get_data_ptr<const int32_t>(),
-                                              out[0]->get_data_ptr<T>(),
-                                              node.get_input_shape(0),
-                                              cumsum->is_exclusive(),
-                                              cumsum->is_reverse());
-            }
-            else if (axis_et == element::Type_t::i64)
-            {
-                reference::cumsum<T, int64_t>(args[0]->get_data_ptr<const T>(),
-                                              args[1]->get_data_ptr<const int64_t>(),
-                                              out[0]->get_data_ptr<T>(),
-                                              node.get_input_shape(0),
-                                              cumsum->is_exclusive(),
-                                              cumsum->is_reverse());
-            }
-            break;
-        }
-        case OP_TYPEID::EmbeddingBagOffsetsSum_v3:
-        {
-            const op::EmbeddingBagOffsetsSum* embed =
-                static_cast<const op::EmbeddingBagOffsetsSum*>(&node);
-            auto indicesType = embed->input(1).get_element_type();
-            size_t indices_num = shape_size(embed->get_input_shape(1));
-
-            if (indicesType == element::Type_t::u64 || indicesType == element::Type_t::i64)
-            {
-                reference::embeddingBagOffsetsSum<T, size_t>(
-                    args[0]->get_data_ptr<const T>(),
-                    args[1]->get_data_ptr<const size_t>(),
-                    args[2]->get_data_ptr<const size_t>(),
-                    args.size() > 3 ? args[3]->get_data_ptr<const size_t>() : nullptr,
-                    args.size() > 4 ? args[4]->get_data_ptr<const T>() : nullptr,
-                    out[0]->get_data_ptr<T>(),
-                    indices_num,
-                    embed->get_shape());
-            }
-            else if (indicesType == element::Type_t::u32 || indicesType == element::Type_t::i32)
-            {
-                reference::embeddingBagOffsetsSum<T, unsigned>(
-                    args[0]->get_data_ptr<const T>(),
-                    args[1]->get_data_ptr<const unsigned>(),
-                    args[2]->get_data_ptr<const unsigned>(),
-                    args.size() > 3 ? args[3]->get_data_ptr<const unsigned>() : nullptr,
-                    args.size() > 4 ? args[4]->get_data_ptr<const T>() : nullptr,
-                    out[0]->get_data_ptr<T>(),
-                    indices_num,
-                    embed->get_shape());
-            }
-            else
-            {
-                throw ngraph_error(std::string("Unsupported index type ") +
-                                   indicesType.c_type_string() +
-                                   std::string(" in EmbeddingBagOffsetsSum"));
-            }
-            break;
-        }
-        case OP_TYPEID::EmbeddingBagPackedSum_v3:
-        {
-            const op::EmbeddingBagPackedSum* embed =
-                static_cast<const op::EmbeddingBagPackedSum*>(&node);
-            auto indicesType = embed->input(1).get_element_type();
-
-            if (indicesType == element::Type_t::u64 || indicesType == element::Type_t::i64)
-            {
-                reference::embeddingBagPackedSum<T, size_t>(
-                    args[0]->get_data_ptr<const T>(),
-                    args[1]->get_data_ptr<const size_t>(),
-                    args.size() > 2 ? args[2]->get_data_ptr<const T>() : nullptr,
-                    out[0]->get_data_ptr<T>(),
-                    embed->get_input_shape(1),
-                    embed->get_shape());
-            }
-            else if (indicesType == element::Type_t::u32 || indicesType == element::Type_t::i32)
-            {
-                reference::embeddingBagPackedSum<T, unsigned>(
-                    args[0]->get_data_ptr<const T>(),
-                    args[1]->get_data_ptr<const unsigned>(),
-                    args.size() > 2 ? args[2]->get_data_ptr<const T>() : nullptr,
-                    out[0]->get_data_ptr<T>(),
-                    embed->get_input_shape(1),
-                    embed->get_shape());
-            }
-            else
-            {
-                throw ngraph_error(std::string("Unsupported index type ") +
-                                   indicesType.c_type_string() +
-                                   std::string(" in EmbeddingBagPackedSum"));
-            }
-            break;
-        }
-        case OP_TYPEID::EmbeddingSegmentsSum_v3:
-        {
-            const op::EmbeddingSegmentsSum* embed =
-                static_cast<const op::EmbeddingSegmentsSum*>(&node);
-            auto indicesType = embed->input(1).get_element_type();
-            size_t indices_num = shape_size(embed->get_input_shape(1));
-
-            if (indicesType == element::Type_t::u64 || indicesType == element::Type_t::i64)
-            {
-                reference::embeddingSegmentsSum<T, size_t>(
-                    args[0]->get_data_ptr<const T>(),
-                    args[1]->get_data_ptr<const size_t>(),
-                    args[2]->get_data_ptr<const size_t>(),
-                    args.size() > 4 ? args[4]->get_data_ptr<const size_t>() : nullptr,
-                    args.size() > 5 ? args[5]->get_data_ptr<const T>() : nullptr,
-                    out[0]->get_data_ptr<T>(),
-                    embed->get_input_shape(0),
-                    embed->get_input_shape(1),
-                    embed->get_shape());
-            }
-            else if (indicesType == element::Type_t::u32 || indicesType == element::Type_t::i32)
-            {
-                reference::embeddingSegmentsSum<T, unsigned>(
-                    args[0]->get_data_ptr<const T>(),
-                    args[1]->get_data_ptr<const unsigned>(),
-                    args[2]->get_data_ptr<const unsigned>(),
-                    args.size() > 4 ? args[4]->get_data_ptr<const unsigned>() : nullptr,
-                    args.size() > 5 ? args[5]->get_data_ptr<const T>() : nullptr,
-                    out[0]->get_data_ptr<T>(),
-                    embed->get_input_shape(0),
-                    embed->get_input_shape(1),
-                    embed->get_shape());
-            }
-            else
-            {
-                throw ngraph_error(std::string("Unsupported index type ") +
-                                   indicesType.c_type_string() +
-                                   std::string(" in EmbeddingSegmentsSum"));
-            }
-            break;
-        }
-        case OP_TYPEID::Erf:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::erf<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::ExtractImagePatches_v3:
-        {
-            const op::ExtractImagePatches* extImgPatches =
-                static_cast<const op::ExtractImagePatches*>(&node);
-            reference::extractImagePatches<T, size_t>(extImgPatches,
-                                                      args[0]->get_data_ptr<const T>(),
-                                                      out[0]->get_data_ptr<T>(),
-                                                      extImgPatches->get_input_shape(0),
-                                                      extImgPatches->get_shape());
-            break;
-        }
-        case OP_TYPEID::Exp:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::exp<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-#ifdef INTERPRETER_USE_HYBRID
-        case OP_TYPEID::FunctionCall:
-        {
-            auto f = static_cast<const runtime::hybrid::op::FunctionCall*>(&node);
-            auto backend = f->get_backend();
-            auto executable = f->get_executable();
-
-            std::vector<std::shared_ptr<Tensor>> outputs;
-            std::vector<std::shared_ptr<Tensor>> inputs;
-            for (const std::shared_ptr<HostTensor>& t : out)
-            {
-                auto backend_tensor = backend->create_tensor(
-                    t->get_element_type(), t->get_shape(), t->get_data_ptr());
-                outputs.push_back(backend_tensor);
-            }
-            for (const std::shared_ptr<HostTensor>& t : args)
-            {
-                auto backend_tensor = backend->create_tensor(
-                    t->get_element_type(), t->get_shape(), t->get_data_ptr());
-                inputs.push_back(backend_tensor);
-            }
-            executable->call(outputs, inputs);
-            break;
-        }
-#endif
-        case OP_TYPEID::Floor:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::floor<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::GatherND_v5:
-        {
-            const op::v5::GatherND* gatherNDNode = static_cast<const op::v5::GatherND*>(&node);
-            if (node.get_input_element_type(1) == element::Type_t::i64)
-            {
-                reference::gather_nd<T, int64_t>(args[0]->get_data_ptr<T>(),
-                                                 args[1]->get_data_ptr<int64_t>(),
-                                                 out[0]->get_data_ptr<T>(),
-                                                 node.get_input_shape(0),
-                                                 node.get_input_shape(1),
-                                                 node.get_output_shape(0),
-                                                 gatherNDNode->get_batch_dims());
-            }
-            else if (node.get_input_element_type(1) == element::Type_t::i32)
-            {
-                reference::gather_nd<T, int32_t>(args[0]->get_data_ptr<T>(),
-                                                 args[1]->get_data_ptr<int32_t>(),
-                                                 out[0]->get_data_ptr<T>(),
-                                                 node.get_input_shape(0),
-                                                 node.get_input_shape(1),
-                                                 node.get_output_shape(0),
-                                                 gatherNDNode->get_batch_dims());
-            }
-            else
-            {
-                throw ngraph_error("Unexpected type");
-            }
-            break;
-        }
-        case OP_TYPEID::GRUCell_v3:
-        {
-            const op::v3::GRUCell* gru_cell = static_cast<const op::v3::GRUCell*>(&node);
-            runtime::reference::gru_cell(args[0]->get_data_ptr<T>(),
-                                         args[0]->get_shape(),
-                                         args[1]->get_data_ptr<T>(),
-                                         args[1]->get_shape(),
-                                         args[2]->get_data_ptr<T>(),
-                                         args[2]->get_shape(),
-                                         args[3]->get_data_ptr<T>(),
-                                         args[3]->get_shape(),
-                                         args[4]->get_data_ptr<T>(),
-                                         args[4]->get_shape(),
-                                         out[0]->get_data_ptr<T>(),
-                                         gru_cell->get_activations()[0],
-                                         gru_cell->get_activations()[1],
-                                         gru_cell->get_clip(),
-                                         gru_cell->get_linear_before_reset());
-            break;
-        }
-        case OP_TYPEID::LSTMCell_v0:
-        case OP_TYPEID::LSTMCell_v4:
-        {
-            const op::v4::LSTMCell* lstm_cell = static_cast<const op::v4::LSTMCell*>(&node);
-            runtime::reference::lstm_cell(args[0]->get_data_ptr<T>(),
-                                          args[0]->get_shape(),
-                                          args[1]->get_data_ptr<T>(),
-                                          args[1]->get_shape(),
-                                          args[2]->get_data_ptr<T>(),
-                                          args[2]->get_shape(),
-                                          args[3]->get_data_ptr<T>(),
-                                          args[3]->get_shape(),
-                                          args[4]->get_data_ptr<T>(),
-                                          args[4]->get_shape(),
-                                          args[5]->get_data_ptr<T>(),
-                                          args[5]->get_shape(),
-                                          out[0]->get_data_ptr<T>(),
-                                          out[1]->get_data_ptr<T>(),
-                                          lstm_cell->get_activations()[0],
-                                          lstm_cell->get_activations()[1],
-                                          lstm_cell->get_activations()[2],
-                                          lstm_cell->get_clip());
-            break;
-        }
-        case OP_TYPEID::RNNCell_v0:
-        {
-            const op::v0::RNNCell* rnn_cell = static_cast<const op::v0::RNNCell*>(&node);
-            runtime::reference::rnn_cell(args[0]->get_data_ptr<T>(),
-                                         args[0]->get_shape(),
-                                         args[1]->get_data_ptr<T>(),
-                                         args[1]->get_shape(),
-                                         args[2]->get_data_ptr<T>(),
-                                         args[2]->get_shape(),
-                                         args[3]->get_data_ptr<T>(),
-                                         args[3]->get_shape(),
-                                         args[4]->get_data_ptr<T>(),
-                                         args[4]->get_shape(),
-                                         out[0]->get_data_ptr<T>(),
-                                         rnn_cell->get_activations()[0],
-                                         rnn_cell->get_clip());
-            break;
-        }
-        case OP_TYPEID::LSTMSequence:
-        case OP_TYPEID::LSTMSequence_v5:
-        {
-            auto lstm_seq = static_cast<const op::v5::LSTMSequence*>(&node);
-            auto type = args[3]->get_element_type();
-            if (type == element::Type_t::i64 || type == element::Type_t::u64)
-            {
-                runtime::reference::lstm_sequence<T, int64_t>(args[0]->get_data_ptr<char>(),
-                                                              args[0]->get_shape(),
-                                                              args[1]->get_data_ptr<char>(),
-                                                              args[1]->get_shape(),
-                                                              args[2]->get_data_ptr<char>(),
-                                                              args[2]->get_shape(),
-                                                              args[3]->get_data_ptr<char>(),
-                                                              args[3]->get_shape(),
-                                                              args[4]->get_data_ptr<char>(),
-                                                              args[4]->get_shape(),
-                                                              args[5]->get_data_ptr<char>(),
-                                                              args[5]->get_shape(),
-                                                              args[6]->get_data_ptr<char>(),
-                                                              args[6]->get_shape(),
-                                                              out[0]->get_data_ptr<char>(),
-                                                              out[1]->get_data_ptr<char>(),
-                                                              out[2]->get_data_ptr<char>(),
-                                                              lstm_seq->get_activations()[0],
-                                                              lstm_seq->get_activations()[1],
-                                                              lstm_seq->get_activations()[2],
-                                                              lstm_seq->get_clip(),
-                                                              lstm_seq->get_direction());
-            }
-            else if (type == element::Type_t::i32 || type == element::Type_t::u32)
-            {
-                runtime::reference::lstm_sequence<T, int32_t>(args[0]->get_data_ptr<char>(),
-                                                              args[0]->get_shape(),
-                                                              args[1]->get_data_ptr<char>(),
-                                                              args[1]->get_shape(),
-                                                              args[2]->get_data_ptr<char>(),
-                                                              args[2]->get_shape(),
-                                                              args[3]->get_data_ptr<char>(),
-                                                              args[3]->get_shape(),
-                                                              args[4]->get_data_ptr<char>(),
-                                                              args[4]->get_shape(),
-                                                              args[5]->get_data_ptr<char>(),
-                                                              args[5]->get_shape(),
-                                                              args[6]->get_data_ptr<char>(),
-                                                              args[6]->get_shape(),
-                                                              out[0]->get_data_ptr<char>(),
-                                                              out[1]->get_data_ptr<char>(),
-                                                              out[2]->get_data_ptr<char>(),
-                                                              lstm_seq->get_activations()[0],
-                                                              lstm_seq->get_activations()[1],
-                                                              lstm_seq->get_activations()[2],
-                                                              lstm_seq->get_clip(),
-                                                              lstm_seq->get_direction());
-            }
-            else
-            {
-                std::stringstream ss;
-                ss << "unsupported element type " << type << " op LSTMSequence";
-                throw std::runtime_error(ss.str());
-            }
-            break;
-        }
-        case OP_TYPEID::GRUSequence_v5:
-        {
-            auto gru_seq = static_cast<const op::v5::GRUSequence*>(&node);
-            auto type = args[2]->get_element_type();
-            if (type == element::Type_t::i64 || type == element::Type_t::u64)
-            {
-                runtime::reference::gru_sequence<T, int64_t>(args[0]->get_data_ptr<char>(),
-                                                             args[0]->get_shape(),
-                                                             args[1]->get_data_ptr<char>(),
-                                                             args[1]->get_shape(),
-                                                             args[2]->get_data_ptr<char>(),
-                                                             args[2]->get_shape(),
-                                                             args[3]->get_data_ptr<char>(),
-                                                             args[3]->get_shape(),
-                                                             args[4]->get_data_ptr<char>(),
-                                                             args[4]->get_shape(),
-                                                             args[5]->get_data_ptr<char>(),
-                                                             args[5]->get_shape(),
-                                                             out[0]->get_data_ptr<char>(),
-                                                             out[1]->get_data_ptr<char>(),
-                                                             gru_seq->get_activations()[0],
-                                                             gru_seq->get_activations()[1],
-                                                             gru_seq->get_clip(),
-                                                             gru_seq->get_direction(),
-                                                             gru_seq->get_linear_before_reset());
-            }
-            else if (type == element::Type_t::i32 || type == element::Type_t::u32)
-            {
-                runtime::reference::gru_sequence<T, int32_t>(args[0]->get_data_ptr<char>(),
-                                                             args[0]->get_shape(),
-                                                             args[1]->get_data_ptr<char>(),
-                                                             args[1]->get_shape(),
-                                                             args[2]->get_data_ptr<char>(),
-                                                             args[2]->get_shape(),
-                                                             args[3]->get_data_ptr<char>(),
-                                                             args[3]->get_shape(),
-                                                             args[4]->get_data_ptr<char>(),
-                                                             args[4]->get_shape(),
-                                                             args[5]->get_data_ptr<char>(),
-                                                             args[5]->get_shape(),
-                                                             out[0]->get_data_ptr<char>(),
-                                                             out[1]->get_data_ptr<char>(),
-                                                             gru_seq->get_activations()[0],
-                                                             gru_seq->get_activations()[1],
-                                                             gru_seq->get_clip(),
-                                                             gru_seq->get_direction(),
-                                                             gru_seq->get_linear_before_reset());
-            }
-            else
-            {
-                std::stringstream ss;
-                ss << "unsupported element type " << type << " op GRUSequence";
-                throw std::runtime_error(ss.str());
-            }
-            break;
-        }
-        case OP_TYPEID::HardSigmoid:
-        {
-            size_t element_cout = shape_size(node.get_output_shape(0));
-            const T alpha = args[1]->get_data_ptr<const T>()[0];
-            const T beta = args[2]->get_data_ptr<const T>()[0];
-            runtime::reference::hard_sigmoid<T>(args[0]->get_data_ptr<const T>(),
-                                                alpha,
-                                                beta,
-                                                out[0]->get_data_ptr<T>(),
-                                                element_cout);
-            break;
-        }
-
-        case OP_TYPEID::RNNSequence_v5:
-        {
-            auto rnn_seq = static_cast<const op::v5::RNNSequence*>(&node);
-            auto type = args[2]->get_element_type();
-            if (type == element::Type_t::i64 || type == element::Type_t::u64)
-            {
-                runtime::reference::rnn_sequence<T, int64_t>(args[0]->get_data_ptr<char>(),
-                                                             args[0]->get_shape(),
-                                                             args[1]->get_data_ptr<char>(),
-                                                             args[1]->get_shape(),
-                                                             args[2]->get_data_ptr<char>(),
-                                                             args[2]->get_shape(),
-                                                             args[3]->get_data_ptr<char>(),
-                                                             args[3]->get_shape(),
-                                                             args[4]->get_data_ptr<char>(),
-                                                             args[4]->get_shape(),
-                                                             args[5]->get_data_ptr<char>(),
-                                                             args[5]->get_shape(),
-                                                             out[0]->get_data_ptr<char>(),
-                                                             out[1]->get_data_ptr<char>(),
-                                                             rnn_seq->get_activations()[0],
-                                                             rnn_seq->get_clip(),
-                                                             rnn_seq->get_direction());
-            }
-            else if (type == element::Type_t::i32 || type == element::Type_t::u32)
-            {
-                runtime::reference::rnn_sequence<T, int32_t>(args[0]->get_data_ptr<char>(),
-                                                             args[0]->get_shape(),
-                                                             args[1]->get_data_ptr<char>(),
-                                                             args[1]->get_shape(),
-                                                             args[2]->get_data_ptr<char>(),
-                                                             args[2]->get_shape(),
-                                                             args[3]->get_data_ptr<char>(),
-                                                             args[3]->get_shape(),
-                                                             args[4]->get_data_ptr<char>(),
-                                                             args[4]->get_shape(),
-                                                             args[5]->get_data_ptr<char>(),
-                                                             args[5]->get_shape(),
-                                                             out[0]->get_data_ptr<char>(),
-                                                             out[1]->get_data_ptr<char>(),
-                                                             rnn_seq->get_activations()[0],
-                                                             rnn_seq->get_clip(),
-                                                             rnn_seq->get_direction());
-            }
-            else
-            {
-                std::stringstream ss;
-                ss << "unsupported element type " << type << " op RNNSequence";
-                throw std::runtime_error(ss.str());
-            }
-            break;
-        }
-        case OP_TYPEID::Log:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::log<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::LogSoftmax_v5:
-        {
-            const op::v5::LogSoftmax* log_softmax = static_cast<const op::v5::LogSoftmax*>(&node);
-            int64_t i_axis = log_softmax->get_axis();
-            if (i_axis < 0)
-            {
-                i_axis += args[0]->get_partial_shape().rank().get_length();
-            }
-            reference::log_softmax<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<T>(),
-                                      node.get_output_shape(0),
-                                      AxisSet{(size_t)i_axis});
-            break;
-        }
-        case OP_TYPEID::LRN:
-        {
-            const op::LRN* lrn = static_cast<const op::LRN*>(&node);
-            reference::lrn<T>(args[0]->get_data_ptr<const T>(),
-                              lrn->get_reduction_axes(),
-                              out[0]->get_data_ptr<T>(),
-                              node.get_input_shape(0),
-                              lrn->get_alpha(),
-                              lrn->get_beta(),
-                              lrn->get_bias(),
-                              lrn->get_nsize());
-            break;
-        }
-        case OP_TYPEID::Negative:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::negate<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::LogicalNot_v1:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::logical_not(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::OneHot_v1:
-        {
-            const op::v1::OneHot* oh = static_cast<const op::v1::OneHot*>(&node);
-            T on_value = args[2]->get_data_ptr<T>()[0];
-            T off_value = args[3]->get_data_ptr<T>()[0];
-
-            switch (args[0]->get_element_type())
-            {
-            case element::Type_t::i8:
-                reference::one_hot(args[0]->get_data_ptr<const int8_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::i16:
-                reference::one_hot(args[0]->get_data_ptr<const int16_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::i32:
-                reference::one_hot(args[0]->get_data_ptr<const int32_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::i64:
-                reference::one_hot(args[0]->get_data_ptr<const int64_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::u8:
-                reference::one_hot(args[0]->get_data_ptr<const uint8_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::u16:
-                reference::one_hot(args[0]->get_data_ptr<const uint16_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::u32:
-                reference::one_hot(args[0]->get_data_ptr<const uint32_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::u64:
-                reference::one_hot(args[0]->get_data_ptr<const uint64_t>(),
-                                   out[0]->get_data_ptr<T>(),
-                                   node.get_input_shape(0),
-                                   node.get_output_shape(0),
-                                   oh->get_axis(),
-                                   on_value,
-                                   off_value);
-                break;
-            case element::Type_t::undefined:
-            case element::Type_t::dynamic:
-            case element::Type_t::u1:
-            case element::Type_t::boolean:
-            case element::Type_t::bf16:
-            case element::Type_t::f16:
-            case element::Type_t::f32:
-            case element::Type_t::f64:
-            default: NGRAPH_CHECK(false, "Indices input element type must be integer");
-            }
-
-            break;
-        }
-        case OP_TYPEID::Parameter: break;
-        case OP_TYPEID::PriorBox:
-        {
-            const op::PriorBox* pbox = static_cast<const op::PriorBox*>(&node);
-            runtime::reference::prior_box<T>(args[0]->get_data_ptr<T>(),
-                                             args[1]->get_data_ptr<T>(),
-                                             out[0]->get_data_ptr<float>(),
-                                             out[0]->get_shape(),
-                                             pbox->get_attrs());
-            break;
-        }
-        case OP_TYPEID::ReorgYolo_v0:
-        {
-            const op::v0::ReorgYolo* reorg_yolo = static_cast<const op::v0::ReorgYolo*>(&node);
-            runtime::reference::reorg_yolo(args[0]->get_data_ptr<char>(),
-                                           out[0]->get_data_ptr<char>(),
-                                           args[0]->get_shape(),
-                                           reorg_yolo->get_strides().at(0),
-                                           args[0]->get_element_type().size());
-            break;
-        }
-        case OP_TYPEID::Quantize:
-        {
-            const op::Quantize* quantize = static_cast<const op::Quantize*>(&node);
-            auto type = quantize->get_element_type();
-
-            if (type == element::Type_t::u8)
-            {
-                reference::quantize<T>(args[0]->get_data_ptr<const T>(),
-                                       args[1]->get_data_ptr<const T>(),
-                                       args[2]->get_data_ptr<const uint8_t>(),
-                                       out[0]->get_data_ptr<uint8_t>(),
-                                       node.get_input_shape(0),
-                                       node.get_input_shape(1),
-                                       quantize->get_axes(),
-                                       quantize->get_round_mode());
-            }
-            else if (type == element::Type_t::i8)
-            {
-                reference::quantize<T>(args[0]->get_data_ptr<const T>(),
-                                       args[1]->get_data_ptr<const T>(),
-                                       args[2]->get_data_ptr<const int8_t>(),
-                                       out[0]->get_data_ptr<int8_t>(),
-                                       node.get_input_shape(0),
-                                       node.get_input_shape(1),
-                                       quantize->get_axes(),
-                                       quantize->get_round_mode());
-            }
-            else if (type == element::Type_t::i32)
-            {
-                reference::quantize<T>(args[0]->get_data_ptr<const T>(),
-                                       args[1]->get_data_ptr<const T>(),
-                                       args[2]->get_data_ptr<const int32_t>(),
-                                       out[0]->get_data_ptr<int32_t>(),
-                                       node.get_input_shape(0),
-                                       node.get_input_shape(1),
-                                       quantize->get_axes(),
-                                       quantize->get_round_mode());
-            }
-            else
-            {
-                std::stringstream ss;
-                ss << "unsupported element type " << type << " op Quantize";
-                throw std::runtime_error(ss.str());
-            }
-
-            break;
-        }
-        case OP_TYPEID::RegionYolo_v0:
-        {
-            const op::RegionYolo* region_yolo = static_cast<const op::RegionYolo*>(&node);
-            reference::region_yolo<T>(args[0]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<T>(),
-                                      args[0]->get_shape(),
-                                      region_yolo->get_num_coords(),
-                                      region_yolo->get_num_classes(),
-                                      region_yolo->get_num_regions(),
-                                      region_yolo->get_do_softmax(),
-                                      region_yolo->get_mask());
-            break;
-        }
-        case OP_TYPEID::Relu:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::relu<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::ReverseSequence:
-        {
-            const op::ReverseSequence* reverse = static_cast<const op::ReverseSequence*>(&node);
-
-            if (node.get_input_element_type(1) == element::Type_t::i32)
-            {
-                reference::reverse_sequence<T, int32_t>(args[0]->get_data_ptr<const T>(),
-                                                        out[0]->get_data_ptr<T>(),
-                                                        node.get_input_shape(0),
-                                                        reverse->get_batch_axis(),
-                                                        reverse->get_sequence_axis(),
-                                                        args[1]->get_data_ptr<const int32_t>());
-            }
-            else if (node.get_input_element_type(1) == element::Type_t::i64)
-            {
-                reference::reverse_sequence<T, int64_t>(args[0]->get_data_ptr<const T>(),
-                                                        out[0]->get_data_ptr<T>(),
-                                                        node.get_input_shape(0),
-                                                        reverse->get_batch_axis(),
-                                                        reverse->get_sequence_axis(),
-                                                        args[1]->get_data_ptr<const int64_t>());
-            }
-            else
-            {
-                throw ngraph_error("only int32 indices are supported");
-            }
-            break;
-        }
-        case OP_TYPEID::ROIPooling_v0:
-        {
-            const op::ROIPooling* roi_pooling = static_cast<const op::ROIPooling*>(&node);
-            reference::roi_pooling<T>(args[0]->get_data_ptr<const T>(),
-                                      args[1]->get_data_ptr<const T>(),
-                                      out[0]->get_data_ptr<T>(),
-                                      node.get_input_shape(0),
-                                      node.get_input_shape(1),
-                                      node.get_output_shape(0),
-                                      roi_pooling->get_spatial_scale(),
-                                      roi_pooling->get_method());
-            break;
-        }
-        case OP_TYPEID::Select:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::select<T>(args[0]->get_data_ptr<const char>(),
-                                 args[1]->get_data_ptr<const T>(),
-                                 args[2]->get_data_ptr<const T>(),
-                                 out[0]->get_data_ptr<T>(),
-                                 element_count);
-            break;
-        }
-        case OP_TYPEID::Sigmoid:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::sigmoid<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Sign:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::sign<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Sin:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::sin<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Sinh:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::sinh<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Sqrt:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::sqrt<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Tan:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::tan<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::Tanh:
-        {
-            size_t element_count = shape_size(node.get_output_shape(0));
-            reference::tanh<T>(
-                args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
-            break;
-        }
-        case OP_TYPEID::TensorIterator:
-        {
-            auto ti = dynamic_cast<const op::v0::TensorIterator&>(node);
-
-            reference::custom_evaluate_function evaluate =
-                [](const std::shared_ptr<ngraph::Function>& function,
-                   const HostTensorVector& inputs,
-                   HostTensorVector& outputs) -> void {
-                const auto& parameters = function->get_parameters();
-                const auto& parametersNumber = parameters.size();
-                const auto& inputsNumber = inputs.size();
-                NGRAPH_CHECK(parametersNumber == inputsNumber,
-                             "Got function (",
-                             function->get_friendly_name(),
-                             ") with ",
-                             parametersNumber,
-                             " parameters, but ",
-                             inputsNumber,
-                             " input blobs");
-
-                auto inputTensors = std::vector<std::shared_ptr<runtime::Tensor>>{};
-                for (const auto& parameter : parameters)
-                {
-                    const auto& parameterIndex = function->get_parameter_index(parameter);
-                    const auto& parameterShape = parameter->get_shape();
-                    const auto& parameterType = parameter->get_element_type();
-                    const auto& parameterSize = shape_size(parameterShape) * parameterType.size();
-
-                    const auto& input = inputs[parameterIndex];
-                    const auto& inputSize = input->get_size_in_bytes();
-                    NGRAPH_CHECK(parameterSize == inputSize,
-                                 "Got parameter (",
-                                 parameter->get_friendly_name(),
-                                 ") of size ",
-                                 parameterSize,
-                                 " bytes, but corresponding input with index ",
-                                 parameterIndex,
-                                 " has ",
-                                 inputSize,
-                                 " bytes");
-
-                    auto tensor =
-                        std::make_shared<runtime::HostTensor>(parameterType, parameterShape);
-                    tensor->write(input->get_data_ptr(), parameterSize);
-                    inputTensors.push_back(tensor);
-                }
-
-                const auto& results = function->get_results();
-                std::vector<std::shared_ptr<ngraph::runtime::Tensor>> outputTensors;
-                outputTensors.reserve(results.size());
-                for (size_t i = 0; i < results.size(); ++i)
-                {
-                    outputTensors.push_back(std::make_shared<HostTensor>());
-                }
-                runtime::Backend::set_backend_shared_library_search_directory("");
-                auto backend = runtime::Backend::create("INTERPRETER");
-                auto handle = backend->compile(function);
-                handle->call_with_validate(outputTensors, inputTensors);
-
-                outputs.reserve(outputTensors.size());
-                for (const auto& tensor : outputTensors)
-                {
-                    auto host_tensor = static_pointer_cast<runtime::HostTensor>(tensor);
-                    outputs.push_back(host_tensor);
-                }
-            };
-            reference::tensor_iterator(ti.get_num_iterations(),
-                                       ti.get_function(),
-                                       ti.get_output_descriptions(),
-                                       ti.get_input_descriptions(),
-                                       out,
-                                       args,
-                                       evaluate);
-            break;
-        }
-        case OP_TYPEID::DetectionOutput_v0:
-        {
-            const op::DetectionOutput* detOut = static_cast<const op::DetectionOutput*>(&node);
-            reference::referenceDetectionOutput<T> refDetOut(
-                detOut->get_attrs(), node.get_input_shape(0), node.get_input_shape(2));
-            if (node.get_input_size() == 3)
-            {
-                refDetOut.run(args[0]->get_data_ptr<const T>(),
-                              args[1]->get_data_ptr<const T>(),
-                              args[2]->get_data_ptr<const T>(),
-                              nullptr,
-                              nullptr,
-                              out[0]->get_data_ptr<T>());
-            }
-            else if (node.get_input_size() == 5)
-            {
-                refDetOut.run(args[0]->get_data_ptr<const T>(),
-                              args[1]->get_data_ptr<const T>(),
-                              args[2]->get_data_ptr<const T>(),
-                              args[3]->get_data_ptr<const T>(),
-                              args[4]->get_data_ptr<const T>(),
-                              out[0]->get_data_ptr<T>());
-            }
-            else
-            {
-                throw ngraph_error("DetectionOutput layer supports only 3 or 5 inputs");
-            }
-
-            break;
-        }
-        case OP_TYPEID::ScatterNDUpdate_v3:
-        {
-            const op::ScatterNDUpdate* scatterNDUpd =
-                static_cast<const op::v3::ScatterNDUpdate*>(&node);
-            auto idxType = scatterNDUpd->get_input_element_type(1);
-            if (idxType == element::Type_t::i32)
-            {
-                reference::scatterNdUpdate<T, int32_t>(args[0]->get_data_ptr<const T>(),
-                                                       args[1]->get_data_ptr<const int32_t>(),
-                                                       args[2]->get_data_ptr<const T>(),
-                                                       out[0]->get_data_ptr<T>(),
-                                                       node.get_input_shape(0),
-                                                       node.get_input_shape(1),
-                                                       node.get_input_shape(2));
-            }
-            else if (idxType == element::Type_t::i64)
-            {
-                reference::scatterNdUpdate<T, int64_t>(args[0]->get_data_ptr<const T>(),
-                                                       args[1]->get_data_ptr<const int64_t>(),
-                                                       args[2]->get_data_ptr<const T>(),
-                                                       out[0]->get_data_ptr<T>(),
-                                                       node.get_input_shape(0),
-                                                       node.get_input_shape(1),
-                                                       node.get_input_shape(2));
-            }
-            else
-            {
-                throw ngraph_error(
-                    "ScatterNDUpdate layer support only i32 and i64 'indices' input precision!");
-            }
-
-            break;
-        }
-        case OP_TYPEID::GatherTree_v1:
-        {
-            reference::gather_tree(args[0]->get_data_ptr<const char>(),
-                                   args[1]->get_data_ptr<const char>(),
-                                   args[2]->get_data_ptr<const char>(),
-                                   args[3]->get_data_ptr<const char>(),
-                                   out[0]->get_data_ptr<char>(),
-                                   node.get_input_shape(0),
-                                   node.get_input_shape(1),
-                                   node.get_input_shape(2),
-                                   node.get_input_shape(3),
-                                   args[1]->get_element_type());
-            break;
-        }
-        case OP_TYPEID::NormalizeL2:
-        {
-            const op::NormalizeL2* norm = static_cast<const op::NormalizeL2*>(&node);
-            reference::normalize_l2<T>(args[0]->get_data_ptr<const T>(),
-                                       out[0]->get_data_ptr<T>(),
-                                       node.get_input_shape(0),
-                                       norm->get_reduction_axes(),
-                                       norm->get_eps(),
-                                       norm->get_eps_mode());
-            break;
-        }
-        case OP_TYPEID::NonMaxSuppression_v5:
-        {
-            const op::v5::NonMaxSuppression* nms =
-                static_cast<const op::v5::NonMaxSuppression*>(&node);
-
-            auto info = get_info_for_nms5_eval(nms, args);
-
-            std::vector<int64_t> selected_indices(info.out_shape_size);
-            std::vector<float> selected_scores(info.out_shape_size);
-            int64_t valid_outputs = 0;
-
-            reference::non_max_suppression(info.boxes_data.data(),
-                                           info.boxes_shape,
-                                           info.scores_data.data(),
-                                           info.scores_shape,
-                                           info.max_output_boxes_per_class,
-                                           info.iou_threshold,
-                                           info.score_threshold,
-                                           info.soft_nms_sigma,
-                                           selected_indices.data(),
-                                           info.out_shape,
-                                           selected_scores.data(),
-                                           info.out_shape,
-                                           &valid_outputs,
-                                           info.sort_result_descending);
-
-            auto selected_scores_type = (args.size() < 4) ? element::Type(element::Type_t::f32)
-                                                          : args[3]->get_element_type();
-
-            reference::nms5_postprocessing(out,
-                                           info.output_type,
-                                           selected_indices,
-                                           selected_scores,
-                                           valid_outputs,
-                                           selected_scores_type);
-            break;
-        }
-
-        // Fused Ops are not supported in interpreter. They need to be decomposed before execution
-        case OP_TYPEID::DepthToSpace:
-        case OP_TYPEID::FakeQuantize:
-        case OP_TYPEID::Gather:
-        case OP_TYPEID::Gelu:
-        case OP_TYPEID::GRN:
-        case OP_TYPEID::GroupConvolution:
-        case OP_TYPEID::GroupConvolutionBackpropData:
-        case OP_TYPEID::Interpolate:
-        case OP_TYPEID::MVN:
-        case OP_TYPEID::PRelu:
-        case OP_TYPEID::ScatterUpdate_v3:
-        case OP_TYPEID::Selu:
-        case OP_TYPEID::ShuffleChannels:
-        case OP_TYPEID::SpaceToDepth:
-        case OP_TYPEID::SquaredDifference:
-        case OP_TYPEID::Tile:
-        case OP_TYPEID::UnknownOp:
-            throw unsupported_op("Unsupported op '" + node.description() + "'");
-        case OP_TYPEID::Add:
-        case OP_TYPEID::Broadcast:
-        case OP_TYPEID::Clamp:
-        case OP_TYPEID::Concat:
-        case OP_TYPEID::Constant:
-        case OP_TYPEID::Divide:
-        case OP_TYPEID::Equal:
-        case OP_TYPEID::Greater:
-        case OP_TYPEID::GreaterEq:
-        case OP_TYPEID::Less:
-        case OP_TYPEID::LessEq:
-        case OP_TYPEID::LessEqual_v1:
-        case OP_TYPEID::LogicalAnd_v1:
-        case OP_TYPEID::LogicalOr_v1:
-        case OP_TYPEID::LogicalXor_v1:
-        case OP_TYPEID::Loop_v5:
-        case OP_TYPEID::MatMul:
-        case OP_TYPEID::Maximum:
-        case OP_TYPEID::Minimum:
-        case OP_TYPEID::Multiply:
-        case OP_TYPEID::NonZero_v3:
-        case OP_TYPEID::NotEqual:
-        case OP_TYPEID::Power:
-        case OP_TYPEID::Range:
-        case OP_TYPEID::Reshape_v1:
-        case OP_TYPEID::Result:
-        case OP_TYPEID::Reverse_v1:
-        case OP_TYPEID::Round_v5:
-        case OP_TYPEID::ShapeOf_v3:
-        case OP_TYPEID::ShapeOf:
-        case OP_TYPEID::Softmax_v1:
-        case OP_TYPEID::Split_v1:
-        case OP_TYPEID::Squeeze:
-        case OP_TYPEID::Subtract:
-        case OP_TYPEID::Unsqueeze:
-        case OP_TYPEID::Xor:
-            // These ops are handled by op evaluators so nothing to do
-            break;
-#if defined(__GNUC__) && !(__GNUC__ == 4 && __GNUC_MINOR__ == 8)
-#pragma GCC diagnostic pop
-#endif
-        }
-    }
 };
-
-NGRAPH_SUPPRESS_DEPRECATED_END
diff --git a/ngraph/test/runtime/interpreter/opset_int_tbl.hpp b/ngraph/test/runtime/interpreter/opset_int_tbl.hpp
index 985070bc251a46..85d25805282e42 100644
--- a/ngraph/test/runtime/interpreter/opset_int_tbl.hpp
+++ b/ngraph/test/runtime/interpreter/opset_int_tbl.hpp
@@ -14,59 +14,74 @@
 // limitations under the License.
 //*****************************************************************************
 
-#define ID_SUFFIX(NAME) NAME
-#include "opset0_tbl.hpp"
-#undef ID_SUFFIX
+#ifndef NGRAPH_OP
+#warning "NGRAPH_OP not defined"
+#define NGRAPH_OP(x, y)
+#endif
 
-#define ID_SUFFIX(NAME) NAME##_v0
-NGRAPH_OP(CTCGreedyDecoder, ngraph::op::v0)
+NGRAPH_OP(Abs, op::v0)
+NGRAPH_OP(BatchNormInference, op::v0)
+NGRAPH_OP(Ceiling, op::v0)
+NGRAPH_OP(Convert, op::v0)
+NGRAPH_OP(CTCGreedyDecoder, op::v0)
+NGRAPH_OP(CumSum, ngraph::op::v0)
 NGRAPH_OP(DetectionOutput, op::v0)
-NGRAPH_OP(LSTMCell, op::v0)
+NGRAPH_OP(Elu, op::v0)
+NGRAPH_OP(FakeQuantize, op::v0)
+NGRAPH_OP(Gelu, op::v0)
+NGRAPH_OP(GRN, op::v0)
+NGRAPH_OP(HardSigmoid, op::v0)
+NGRAPH_OP(LRN, ngraph::op::v0)
+NGRAPH_OP(MVN, ngraph::op::v0)
+NGRAPH_OP(NormalizeL2, op::v0)
+NGRAPH_OP(PriorBox, ngraph::op::v0)
 NGRAPH_OP(RegionYolo, op::v0)
+NGRAPH_OP(Relu, op::v0)
 NGRAPH_OP(ReorgYolo, op::v0)
+NGRAPH_OP(ReverseSequence, op::v0)
 NGRAPH_OP(RNNCell, op::v0)
+NGRAPH_OP(Selu, op::v0)
+NGRAPH_OP(Sign, op::v0)
+NGRAPH_OP(SquaredDifference, op::v0)
+NGRAPH_OP(TensorIterator, op::v0)
 NGRAPH_OP(ROIPooling, op::v0)
-#undef ID_SUFFIX
 
-#define ID_SUFFIX(NAME) NAME##_v1
+NGRAPH_OP(AvgPool, op::v1)
+NGRAPH_OP(Convolution, ngraph::op::v1)
+NGRAPH_OP(ConvolutionBackpropData, ngraph::op::v1)
 NGRAPH_OP(LessEqual, op::v1)
 NGRAPH_OP(LogicalAnd, op::v1)
 NGRAPH_OP(LogicalOr, op::v1)
 NGRAPH_OP(LogicalXor, op::v1)
 NGRAPH_OP(LogicalNot, op::v1)
-NGRAPH_OP(GatherTree, op::v1)
+NGRAPH_OP(MaxPool, op::v1)
+NGRAPH_OP(Mod, op::v1)
 NGRAPH_OP(OneHot, op::v1)
-NGRAPH_OP(Softmax, op::v1)
+NGRAPH_OP(Pad, op::v1)
 NGRAPH_OP(Split, op::v1)
 NGRAPH_OP(Reshape, op::v1)
-NGRAPH_OP(Reverse, op::v1)
-#undef ID_SUFFIX
+NGRAPH_OP(Select, op::v1)
+NGRAPH_OP(GatherTree, op::v1)
 
-#define ID_SUFFIX(NAME) NAME##_v3
-NGRAPH_OP(GRUCell, op::v3)
-NGRAPH_OP(EmbeddingBagOffsetsSum, op::v3)
-NGRAPH_OP(EmbeddingBagPackedSum, op::v3)
-NGRAPH_OP(EmbeddingSegmentsSum, op::v3)
+NGRAPH_OP(EmbeddingBagOffsetsSum, ngraph::op::v3)
+NGRAPH_OP(EmbeddingBagPackedSum, ngraph::op::v3)
 NGRAPH_OP(ExtractImagePatches, op::v3)
-NGRAPH_OP(ShapeOf, op::v3)
+NGRAPH_OP(EmbeddingSegmentsSum, ngraph::op::v3)
+NGRAPH_OP(GRUCell, ngraph::op::v3)
 NGRAPH_OP(NonZero, op::v3)
 NGRAPH_OP(ScatterNDUpdate, op::v3)
-NGRAPH_OP(ScatterUpdate, op::v3)
-#undef ID_SUFFIX
+NGRAPH_OP(ShapeOf, op::v3)
 
-#define ID_SUFFIX(NAME) NAME##_v4
 NGRAPH_OP(CTCLoss, op::v4)
 NGRAPH_OP(LSTMCell, op::v4)
-#undef ID_SUFFIX
 
-#define ID_SUFFIX(NAME) NAME##_v5
+NGRAPH_OP(BatchNormInference, op::v5)
 NGRAPH_OP(GatherND, op::v5)
 NGRAPH_OP(GRUSequence, op::v5)
-NGRAPH_OP(BatchNormInference, op::v5)
 NGRAPH_OP(LogSoftmax, op::v5)
+NGRAPH_OP(LSTMSequence, op::v5)
 NGRAPH_OP(Loop, op::v5)
 NGRAPH_OP(LSTMSequence, op::v5)
 NGRAPH_OP(NonMaxSuppression, op::v5)
 NGRAPH_OP(RNNSequence, op::v5)
 NGRAPH_OP(Round, op::v5)
-#undef ID_SUFFIX
diff --git a/ngraph/test/runtime/opset0.hpp b/ngraph/test/runtime/interpreter/reference/elu.hpp
similarity index 65%
rename from ngraph/test/runtime/opset0.hpp
rename to ngraph/test/runtime/interpreter/reference/elu.hpp
index 727daad8023167..d04b4c3a88abdc 100644
--- a/ngraph/test/runtime/opset0.hpp
+++ b/ngraph/test/runtime/interpreter/reference/elu.hpp
@@ -16,23 +16,23 @@
 
 #pragma once
 
-#include "ngraph/ops.hpp"
-#include "op/avg_pool.hpp"
-#include "op/convolution.hpp"
-#include "op/group_conv.hpp"
+#include <cmath>
+#include <cstddef>
 
 namespace ngraph
 {
-    NGRAPH_SUPPRESS_DEPRECATED_START
-    namespace opset0
+    namespace runtime
     {
-#ifdef NGRAPH_OP
-#include "opset0_tbl.hpp"
-#else
-#define NGRAPH_OP(a, b) using b::a;
-#include "opset0_tbl.hpp"
-#undef NGRAPH_OP
-#endif
+        namespace reference
+        {
+            template <typename T>
+            void elu(const T* arg, T* out, size_t count, double alpha)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = arg[i] < T(0) ? T(alpha * (std::exp(arg[i]) - 1.0)) : arg[i];
+                }
+            }
+        }
     }
-    NGRAPH_SUPPRESS_DEPRECATED_END
-}
+}
\ No newline at end of file
diff --git a/ngraph/test/runtime/interpreter/reference/gelu.hpp b/ngraph/test/runtime/interpreter/reference/gelu.hpp
new file mode 100644
index 00000000000000..0d879b61b2969a
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/reference/gelu.hpp
@@ -0,0 +1,38 @@
+//*****************************************************************************
+// Copyright 2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T>
+            void gelu(const T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = 0.5 * arg[i] * (1 + erf(arg[i] / std::sqrt(2)));
+                }
+            }
+        }
+    }
+}
diff --git a/ngraph/test/runtime/interpreter/reference/grn.hpp b/ngraph/test/runtime/interpreter/reference/grn.hpp
new file mode 100644
index 00000000000000..31db5cc39217e0
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/reference/grn.hpp
@@ -0,0 +1,34 @@
+//*****************************************************************************
+// Copyright 2017-2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include "ngraph/runtime/reference/normalize_l2.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T>
+            void grn(const T* data, T* out, float bias, const Shape& data_shape)
+            {
+                normalize_l2(data, out, data_shape, {1}, bias, op::EpsMode::ADD);
+            }
+        } // namespace reference
+    }     // namespace runtime
+} // namespace ngraph
diff --git a/ngraph/test/runtime/interpreter/reference/mod.hpp b/ngraph/test/runtime/interpreter/reference/mod.hpp
new file mode 100644
index 00000000000000..134e052fbc8c46
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/reference/mod.hpp
@@ -0,0 +1,45 @@
+//*****************************************************************************
+// Copyright 2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+
+#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T>
+            void mod(const T* arg0,
+                     const T* arg1,
+                     T* out,
+                     const Shape& arg_shape0,
+                     const Shape& arg_shape1,
+                     const op::AutoBroadcastSpec& broadcast_spec)
+            {
+                autobroadcast_binop(
+                    arg0, arg1, out, arg_shape0, arg_shape1, broadcast_spec, [](T x, T y) -> T {
+                        return T(x - std::truncf(x / y) * y);
+                    });
+            }
+        }
+    }
+}
diff --git a/ngraph/test/runtime/interpreter/reference/selu.hpp b/ngraph/test/runtime/interpreter/reference/selu.hpp
new file mode 100644
index 00000000000000..a91e67727bd446
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/reference/selu.hpp
@@ -0,0 +1,46 @@
+//*****************************************************************************
+// Copyright 2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T>
+            void selu(const T* arg,
+                      const T* alpha,
+                      const T* lambda,
+                      T* out,
+                      size_t size_arg,
+                      size_t size_alpha,
+                      size_t size_lambda)
+            {
+                for (size_t i = 0; i < size_arg; ++i)
+                {
+                    out[i] = arg[i] > T(0) ? T(lambda[i % size_lambda] * arg[i])
+                                           : T(alpha[i % size_alpha] * lambda[i % size_lambda] *
+                                               (std::exp(arg[i]) - 1));
+                }
+            }
+        }
+    }
+}
diff --git a/ngraph/test/runtime/interpreter/reference/transpose.hpp b/ngraph/test/runtime/interpreter/reference/transpose.hpp
new file mode 100644
index 00000000000000..51b7a4c44d9ff7
--- /dev/null
+++ b/ngraph/test/runtime/interpreter/reference/transpose.hpp
@@ -0,0 +1,63 @@
+//*****************************************************************************
+// Copyright 2020 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include <cfenv>
+#include <cmath>
+#include <numeric>
+#include <stdexcept>
+#include <vector>
+
+#include "ngraph/axis_vector.hpp"
+#include "ngraph/coordinate_transform.hpp"
+#include "ngraph/shape.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace reference
+        {
+            template <typename T, typename U>
+            void transpose(const T* arg, T* out, Shape arg_size, const U* axes_order = nullptr)
+            {
+                std::vector<size_t> range_vector;
+                if (axes_order == nullptr)
+                {
+                    range_vector.resize(arg_size.size());
+                    std::iota(range_vector.begin(), range_vector.end(), 0);
+                    std::reverse(range_vector.begin(), range_vector.end());
+                    axes_order = range_vector.data();
+                }
+                size_t cnt = 0;
+                for (size_t i = 0; i < arg_size.size(); ++i)
+                {
+                    size_t axes = axes_order[i];
+                    size_t start = 0;
+                    for (size_t j = 0; j < axes; ++j)
+                    {
+                        start += shape_size(arg_size[j]);
+                    }
+                    for (size_t j = start; j < start + shape_size(arg_size[axes]); ++j)
+                    {
+                        out[cnt++] = arg[j];
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/ngraph/test/runtime/interpreter/unit_test.manifest b/ngraph/test/runtime/interpreter/unit_test.manifest
index 62535f2beb75e5..dedf6c6fe8869e 100644
--- a/ngraph/test/runtime/interpreter/unit_test.manifest
+++ b/ngraph/test/runtime/interpreter/unit_test.manifest
@@ -74,6 +74,15 @@ INTERPRETER.fused_clamp_bfloat16
 INTERPRETER.auto_bcast_binary_elementwise
 INTERPRETER.auto_bcast_binary_elementwise_pdpd
 
+# Revise reference implementation
+onnx_dyn_model_hardmax
+onnx_model_one_hot_with_axis
+onnx_model_one_hot_with_axis
+onnx_model_quantize_linear_const_scale_const_zero_p
+onnx_model_quantize_linear
+onnx_model_quantize_linear_axis_zero
+onnx_model_quantize_linear_axis_negative
+
 # Backward conv
 INTERPRETER.convolution_2d_1item
 INTERPRETER.convolution_2d_1item_padded_1_1x1_1
@@ -118,12 +127,22 @@ onnx_model_lstm_bdir_short_input_seq_peepholes
 lstm_cell_bias_peepholes
 lstm_cell_bias_peepholes_clip_input_forget
 
+
+# Check 'n_data_channels % groups == 0' failed
+dyn_group_convolution_backprop_data
+
+# Check 'num_dyn_nodes_this_pass < num_dyn_nodes_last_pass' failed
+dyn_convolution_backprop_data
+
 # unsupported element type f16
 INTERPRETER.ctc_greedy_decoder_f16
 
+# Issue 37473. Fails on ia32 platforms only
+onnx_model_softmax_axis_0
+onnx_model_reshape_negative_dim
+
 # LogSoftmax's reference implementation doesn't handle scalar input properly
 onnx_model_logsoftmax_0D
-
 # Input body shape is changed during Loop iterations
 # Exception is throw during Loop shape inference
 onnx_controlflow_loop_concat_values
@@ -138,4 +157,4 @@ onnx_controlflow_loop_power
 
 # The test fails in CI on Ubuntu i386
 # There's an overflow of some kind: 2147483647 is not close to -2147483648 at index 2
-quantize_clamp_int32
+quantize_clamp_int32
\ No newline at end of file
diff --git a/ngraph/test/runtime/op/convolution.hpp b/ngraph/test/runtime/op/convolution.hpp
index 15161b55ed6f01..07e796a7e21fdc 100644
--- a/ngraph/test/runtime/op/convolution.hpp
+++ b/ngraph/test/runtime/op/convolution.hpp
@@ -69,7 +69,7 @@ namespace ngraph
                 /// \brief Constructs a batched convolution operation with no data dilation (i.e.,
                 /// all
                 ///        data dilation strides are 1).
-                ///
+                /// ngraph/test/runtime/interpreter/unit_test.manifest
                 /// \param data_batch The node producing the input data batch tensor.<br>
                 /// `[N, C_IN, D1, ... Df]`
                 /// \param filters The node producing the filters tensor.<br>
diff --git a/ngraph/test/runtime/opset0_tbl.hpp b/ngraph/test/runtime/opset0_tbl.hpp
index 35cbb2e86f0244..e5f7e81055fc89 100644
--- a/ngraph/test/runtime/opset0_tbl.hpp
+++ b/ngraph/test/runtime/opset0_tbl.hpp
@@ -52,7 +52,6 @@
 
 NGRAPH_OP(Abs, ngraph::op)
 NGRAPH_OP(Acos, ngraph::op)
-NGRAPH_OP(Add, ngraph::op)
 NGRAPH_OP(Asin, ngraph::op)
 NGRAPH_OP(Atan, ngraph::op)
 NGRAPH_OP(AvgPool, ngraph::op::v0)
@@ -69,9 +68,7 @@ NGRAPH_OP(Cos, ngraph::op)
 NGRAPH_OP(Cosh, ngraph::op)
 NGRAPH_OP(CumSum, ngraph::op::v0)
 NGRAPH_OP(DepthToSpace, ngraph::op)
-NGRAPH_OP(Divide, ngraph::op)
 NGRAPH_OP(Elu, ngraph::op)
-NGRAPH_OP(Equal, ngraph::op)
 NGRAPH_OP(Erf, ngraph::op)
 NGRAPH_OP(Exp, ngraph::op)
 NGRAPH_OP(FakeQuantize, ngraph::op)
@@ -79,27 +76,19 @@ NGRAPH_OP(Floor, ngraph::op)
 NGRAPH_OP(GRN, ngraph::op)
 NGRAPH_OP(Gather, ngraph::op::v1)
 NGRAPH_OP(Gelu, ngraph::op)
-NGRAPH_OP(Greater, ngraph::op)
-NGRAPH_OP(GreaterEq, ngraph::op)
 NGRAPH_OP(GroupConvolution, ngraph::op::v0)
 NGRAPH_OP(GroupConvolutionBackpropData, ngraph::op::v0)
 NGRAPH_OP(HardSigmoid, ngraph::op)
 NGRAPH_OP(Interpolate, ngraph::op::v0)
-NGRAPH_OP(Less, ngraph::op)
-NGRAPH_OP(LessEq, ngraph::op)
 NGRAPH_OP(Log, ngraph::op)
 NGRAPH_OP(LRN, ngraph::op)
 NGRAPH_OP(LSTMSequence, ngraph::op::v0)
 NGRAPH_OP(MatMul, ngraph::op)
-NGRAPH_OP(NormalizeL2, ngraph::op)
-NGRAPH_OP(Maximum, ngraph::op)
-NGRAPH_OP(Minimum, ngraph::op)
-NGRAPH_OP(Multiply, ngraph::op)
+NGRAPH_OP(Multiply, ngraph::op::v0)
 NGRAPH_OP(MVN, ngraph::op)
 NGRAPH_OP(Negative, ngraph::op)
-NGRAPH_OP(NotEqual, ngraph::op)
+NGRAPH_OP(NormalizeL2, ngraph::op)
 NGRAPH_OP(Parameter, ngraph::op)
-NGRAPH_OP(Power, ngraph::op)
 NGRAPH_OP(PRelu, ngraph::op)
 NGRAPH_OP(PriorBox, ngraph::op)
 NGRAPH_OP(Quantize, ngraph::op)
@@ -107,7 +96,6 @@ NGRAPH_OP(Range, ngraph::op)
 NGRAPH_OP(Relu, ngraph::op)
 NGRAPH_OP(Result, ngraph::op)
 NGRAPH_OP(ReverseSequence, ngraph::op)
-NGRAPH_OP(Select, ngraph::op)
 NGRAPH_OP(Selu, ngraph::op)
 NGRAPH_OP(ShapeOf, ngraph::op)
 NGRAPH_OP(ShuffleChannels, ngraph::op)
@@ -119,7 +107,6 @@ NGRAPH_OP(SpaceToDepth, ngraph::op)
 NGRAPH_OP(Sqrt, ngraph::op)
 NGRAPH_OP(SquaredDifference, ngraph::op)
 NGRAPH_OP(Squeeze, ngraph::op)
-NGRAPH_OP(Subtract, ngraph::op)
 NGRAPH_OP(Tan, ngraph::op)
 NGRAPH_OP(Tanh, ngraph::op)
 NGRAPH_OP(TensorIterator, ngraph::op)
diff --git a/ngraph/test/runtime/pass/opset0_downgrade.cpp b/ngraph/test/runtime/pass/opset0_downgrade.cpp
index bd7ca068162df6..d19b594710e3b5 100644
--- a/ngraph/test/runtime/pass/opset0_downgrade.cpp
+++ b/ngraph/test/runtime/pass/opset0_downgrade.cpp
@@ -31,8 +31,6 @@
 #include "ngraph/type.hpp"
 #include "ngraph/validation_util.hpp"
 #include "op/avg_pool.hpp"
-#include "op/convolution.hpp"
-#include "op/group_conv.hpp"
 #include "pass/implicit_broadcast_elimination.hpp"
 #include "pass/opset0_downgrade.hpp"
 
@@ -98,232 +96,11 @@ namespace opset0_downgrade
 
     // Default is that we did nothing
     shared_ptr<Node> op_cast(shared_ptr<Node> node) { return nullptr; }
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Add> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Add, op::v1::Add>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::AvgPool> node)
-    {
-        auto const input_arg = node->input_value(0);
-        const auto ceil_mode = static_cast<bool>(node->get_rounding_type());
-        const auto include_padding_in_avg_computation = !node->get_exclude_pad();
-        const auto pad_type = node->get_auto_pad();
-        const auto padding_below = node->get_pads_begin();
-        const auto padding_above = node->get_pads_end();
-        const auto window_movement_strides = node->get_strides();
-        const auto window_shape = node->get_kernel();
-
-        auto replacement_node = make_shared<op::v0::AvgPool>(input_arg,
-                                                             window_shape,
-                                                             window_movement_strides,
-                                                             padding_below,
-                                                             padding_above,
-                                                             include_padding_in_avg_computation,
-                                                             pad_type,
-                                                             ceil_mode);
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Convolution> node)
-    {
-        const auto data_arg = node->input_value(0);
-        const auto filters_arg = node->input_value(1);
-        const auto strides = node->get_strides();
-        const size_t num_spatial_dims = strides.size();
-        auto replacement_node = make_shared<op::v0::Convolution>(data_arg,
-                                                                 filters_arg,
-                                                                 node->get_strides(),
-                                                                 node->get_dilations(),
-                                                                 node->get_pads_begin(),
-                                                                 node->get_pads_end(),
-                                                                 Strides(num_spatial_dims, 1),
-                                                                 node->get_auto_pad());
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::ConvolutionBackpropData> node)
-    {
-        const auto data_arg = node->input_value(0);
-        const auto filters_arg = node->input_value(1);
-
-        auto data_pshape = data_arg.get_partial_shape();
-        auto filters_pshape = filters_arg.get_partial_shape();
-
-        NGRAPH_CHECK(data_pshape.rank().is_static() && data_pshape[0].is_static() &&
-                         filters_pshape.rank().is_static() && filters_pshape[1].is_static(),
-                     "Unable to convert ConvolutionBackpropData:v1 to ConvolutionBackpropData:v0 "
-                     "if data shape N and filters shape C dimensions are not static. Node: ",
-                     *node);
-
-        const size_t num_spatial_dims = data_pshape.rank().get_length() - 2;
-
-        const PartialShape output_pshape{node->get_output_partial_shape(0)};
-        NGRAPH_CHECK(output_pshape.is_static(),
-                     "Unable to convert ConvolutionBackpropData:v1 to ConvolutionBackpropData:v0 "
-                     "if output shape is dynamic. Node: ",
-                     *node);
-        Shape output_shape = output_pshape.to_shape();
-
-        auto replacement_node =
-            make_shared<op::v0::ConvolutionBackpropData>(output_shape,
-                                                         filters_arg,
-                                                         data_arg,
-                                                         node->get_strides(),
-                                                         node->get_dilations(),
-                                                         node->get_pads_begin(),
-                                                         node->get_pads_end(),
-                                                         Strides(num_spatial_dims, 1));
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Divide> node)
-    {
-        const auto input_arg0 = node->input_value(0);
-        const auto input_arg1 = node->input_value(1);
-        const auto autob = node->get_autob();
-        const bool pydiv = node->is_pythondiv();
-        auto replacement_node = make_shared<op::v0::Divide>(input_arg0, input_arg1, pydiv, autob);
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Equal> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Equal, op::v1::Equal>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Greater> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Greater, op::v1::Greater>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::GreaterEqual> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::GreaterEq, op::v1::GreaterEqual>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::GroupConvolution> node)
-    {
-        const auto data_arg = node->input_value(0);
-        const auto filters_arg = node->input_value(1);
-        const auto strides = node->get_strides();
-        const size_t num_spatial_dims = strides.size();
-        auto replacement_node = make_shared<op::v0::GroupConvolution>(data_arg,
-                                                                      filters_arg,
-                                                                      node->get_strides(),
-                                                                      node->get_dilations(),
-                                                                      node->get_pads_begin(),
-                                                                      node->get_pads_end(),
-                                                                      Strides(num_spatial_dims, 1),
-                                                                      node->get_auto_pad());
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::GroupConvolutionBackpropData> node)
-    {
-        const auto data_arg = node->input_value(0);
-        const auto filters_arg = node->input_value(1);
-
-        NGRAPH_CHECK(data_arg.get_partial_shape().is_static(),
-                     "Unable to convert GroupConvolutionBackpropData:1 to "
-                     "GroupConvolutionBackpropData:0 with dynamic data shape. Node: ",
-                     *node);
-
-        NGRAPH_CHECK(filters_arg.get_partial_shape().is_static(),
-                     "Unable to convert GroupConvolutionBackpropData:1 to "
-                     "GroupConvolutionBackpropData:0 with dynamic filters shape. Node: ",
-                     *node);
-
-        auto filters_shape = filters_arg.get_shape();
-        const size_t groups = filters_shape.at(0);
-
-        const PartialShape output_pshape{node->get_output_partial_shape(0)};
-        NGRAPH_CHECK(output_pshape.is_static(),
-                     "Unable to convert GroupConvolutionBackpropData:v1 to "
-                     "GroupConvolutionBackpropData:v0 "
-                     "if output_shape is dynamic. Node: ",
-                     *node);
-        Shape output_shape = output_pshape.to_shape();
-
-        // Convert filters data layout from [GROUPS, C_INPUT, C_OUTPUT, K_D, ..., K_1]
-        // into [C x M/group x k1 x k2 x ... x kn]
-        filters_shape.erase(filters_shape.begin());
-        filters_shape[0] *= groups;
-
-        auto reshaped_filters = builder::opset1::reshape(node->input_value(1), filters_shape);
-
-        auto replacement_node = make_shared<op::v0::GroupConvolutionBackpropData>(
-            op::Constant::create(data_arg.get_element_type(), output_shape, {0}),
-            reshaped_filters,
-            data_arg,
-            node->get_strides(),
-            node->get_dilations(),
-            node->get_pads_begin(),
-            node->get_pads_end(),
-            groups);
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Less> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Less, op::v1::Less>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::LessEqual> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::LessEq, op::v1::LessEqual>(node);
-    }
-
     shared_ptr<Node> op_cast(shared_ptr<op::v1::LogicalXor> node)
     {
         return op_cast_binary_elementwise_node<op::v0::Xor, op::v1::LogicalXor>(node);
     }
 
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Maximum> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Maximum, op::v1::Maximum>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Minimum> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Minimum, op::v1::Minimum>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Multiply> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Multiply, op::v1::Multiply>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::NotEqual> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::NotEqual, op::v1::NotEqual>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Power> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Power, op::v1::Power>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Select> node)
-    {
-        ngraph::pass::ImplicitBroadcastElimination().run_on_node(node);
-        auto replacement_node = make_shared<op::v0::Select>(
-            node->input_value(0), node->input_value(1), node->input_value(2));
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Subtract> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Subtract, op::v1::Subtract>(node);
-    }
-
     using DispatchMap = map<NodeTypeInfo, std::function<bool(shared_ptr<Node> node)>>;
 
     template <typename T>
diff --git a/ngraph/test/runtime/pass/opset1_upgrade.cpp b/ngraph/test/runtime/pass/opset1_upgrade.cpp
index 4258eaea3ac621..c18acccab3105b 100644
--- a/ngraph/test/runtime/pass/opset1_upgrade.cpp
+++ b/ngraph/test/runtime/pass/opset1_upgrade.cpp
@@ -49,38 +49,9 @@ namespace opset1_upgrade
 
     // Default is that we didn nothing
     shared_ptr<Node> op_cast(shared_ptr<Node> node) { return nullptr; }
-    shared_ptr<Node> op_cast(shared_ptr<op::Add> node)
+    shared_ptr<Node> op_cast(shared_ptr<op::v0::Multiply> node)
     {
-        return op_cast_binary_elementwise_node<op::v0::Add, op::v1::Add>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::v0::Convolution> node)
-    {
-        auto strides = node->get_window_movement_strides();
-        auto dilations = node->get_window_dilation_strides();
-        auto pads_begin = node->get_padding_below();
-        auto pads_end = node->get_padding_above();
-        auto data_dilation_strides = node->get_data_dilation_strides();
-        auto auto_pad = node->get_pad_type();
-
-        bool is_dds_valid = all_of(data_dilation_strides.begin(),
-                                   data_dilation_strides.end(),
-                                   [](size_t value) { return value == 1; });
-
-        NGRAPH_CHECK(is_dds_valid,
-                     "Unable to convert Convolution:0 to Convolution:1 with data dilation strides "
-                     "other than `1`. Node: ",
-                     *node);
-
-        auto replacement_node = make_shared<op::v1::Convolution>(node->input_value(0),
-                                                                 node->input_value(1),
-                                                                 strides,
-                                                                 pads_begin,
-                                                                 pads_end,
-                                                                 dilations,
-                                                                 auto_pad);
-        replace_node(node, replacement_node);
-        return replacement_node;
+        return op_cast_binary_elementwise_node<op::v0::Multiply, op::v1::Multiply>(node);
     }
 
     shared_ptr<Node> op_cast(shared_ptr<op::v0::ConvolutionBackpropData> node)
@@ -117,31 +88,6 @@ namespace opset1_upgrade
         return replacement_node;
     }
 
-    shared_ptr<Node> op_cast(shared_ptr<op::Divide> node)
-    {
-        const auto autob = node->get_autob();
-        const bool pydiv = node->is_pythondiv();
-        auto replacement_node =
-            make_shared<op::v1::Divide>(node->input_value(0), node->input_value(1), pydiv, autob);
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Equal> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Equal, op::v1::Equal>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Greater> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Greater, op::v1::Greater>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::GreaterEq> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::GreaterEq, op::v1::GreaterEqual>(node);
-    }
-
     shared_ptr<Node> op_cast(shared_ptr<op::v0::GroupConvolution> node)
     {
         auto strides = node->get_window_movement_strides();
@@ -240,56 +186,6 @@ namespace opset1_upgrade
         return replacement_node;
     }
 
-    shared_ptr<Node> op_cast(shared_ptr<op::Less> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Less, op::v1::Less>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::LessEq> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::LessEq, op::v1::LessEqual>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Maximum> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Maximum, op::v1::Maximum>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Minimum> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Minimum, op::v1::Minimum>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Multiply> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Multiply, op::v1::Multiply>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::NotEqual> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::NotEqual, op::v1::NotEqual>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Power> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Power, op::v1::Power>(node);
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Select> node)
-    {
-        auto replacement_node = make_shared<op::v1::Select>(node->input_value(0),
-                                                            node->input_value(1),
-                                                            node->input_value(2),
-                                                            op::AutoBroadcastSpec());
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
-    shared_ptr<Node> op_cast(shared_ptr<op::Subtract> node)
-    {
-        return op_cast_binary_elementwise_node<op::v0::Subtract, op::v1::Subtract>(node);
-    }
-
     shared_ptr<Node> op_cast(shared_ptr<op::Xor> node)
     {
         auto replacement_node = make_shared<op::v1::LogicalXor>(
diff --git a/ngraph/test/specialize_function.cpp b/ngraph/test/specialize_function.cpp
index fe09800a1b5b2d..c292ec9a6ec0f7 100644
--- a/ngraph/test/specialize_function.cpp
+++ b/ngraph/test/specialize_function.cpp
@@ -19,8 +19,6 @@
 #include "ngraph/ngraph.hpp"
 #include "ngraph/specialize_function.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace ngraph;
 
 // Simple case: create a function with static parameter shapes and "specialize" them to the same
@@ -31,7 +29,7 @@ TEST(specialize_function, et_shape_static)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, Shape{1, 2, 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -53,7 +51,7 @@ TEST(specialize_function, et_dynamic_shape_static)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::dynamic, Shape{1, 2, 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -75,7 +73,7 @@ TEST(specialize_function, et_static_shape_rank_dynamic)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape::dynamic());
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -97,7 +95,7 @@ TEST(specialize_function, et_static_shape_rank_static_dynamic)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape::dynamic(3));
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -119,7 +117,7 @@ TEST(specialize_function, et_static_shape_rank_static_dynamic_subst_val)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape::dynamic(3));
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -136,7 +134,7 @@ TEST(specialize_function, et_static_shape_rank_static_dynamic_subst_val)
     ASSERT_EQ(g->get_output_element_type(0), element::Type_t::f32);
 
     auto plus_node =
-        as_type_ptr<op::Add>(g->get_results().at(0)->input_value(0).get_node_shared_ptr());
+        as_type_ptr<op::v1::Add>(g->get_results().at(0)->input_value(0).get_node_shared_ptr());
     ASSERT_TRUE(plus_node);
     auto convert_node = as_type_ptr<op::Convert>(plus_node->input_value(1).get_node_shared_ptr());
     ASSERT_TRUE(convert_node);
@@ -157,7 +155,7 @@ TEST(specialize_function, et_static_shape_rank_dynamic_validation_fails)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape::dynamic());
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -182,7 +180,7 @@ TEST(specialize_function, et_dynamic_shape_static_validation_fails)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::dynamic, Shape{1, 2, 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -210,7 +208,7 @@ TEST(specialize_function, et_static_shape_rank_static_dynamic_rank_mismatch)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape::dynamic(3));
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -239,7 +237,7 @@ TEST(specialize_function, et_static_shape_rank_static_dynamic_dim_mismatch)
                                               PartialShape{1, Dimension::dynamic(), 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -262,7 +260,7 @@ TEST(specialize_function, et_count_wrong)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape{1, 2, 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -285,7 +283,7 @@ TEST(specialize_function, shape_count_wrong)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape{1, 2, 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
@@ -309,7 +307,7 @@ TEST(specialize_function, value_count_wrong)
     auto p1 = std::make_shared<op::Parameter>(element::Type_t::i32, PartialShape{1, 2, 3});
 
     auto k = std::make_shared<op::Convert>(p1, element::Type_t::f32);
-    auto a = p0 + k;
+    auto a = std::make_shared<op::v1::Add>(p0, k);
 
     auto f = std::make_shared<Function>(a, ParameterVector{p0, p1});
 
diff --git a/ngraph/test/tensor.cpp b/ngraph/test/tensor.cpp
index 0eab2f21e1dfb3..08ff4840370292 100644
--- a/ngraph/test/tensor.cpp
+++ b/ngraph/test/tensor.cpp
@@ -40,7 +40,7 @@ TEST(tensor, size)
 
     {
         auto arg0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 3});
-        auto add = make_shared<op::Add>(arg0, arg0);
+        auto add = make_shared<op::v1::Add>(arg0, arg0);
         auto f0 = make_shared<Function>(add, ParameterVector{arg0});
 
         pass_manager.run_passes(f0);
@@ -52,7 +52,7 @@ TEST(tensor, size)
 
     {
         auto arg0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{});
-        auto add = make_shared<op::Add>(arg0, arg0);
+        auto add = make_shared<op::v1::Add>(arg0, arg0);
         auto f0 = make_shared<Function>(add, ParameterVector{arg0});
 
         pass_manager.run_passes(f0);
@@ -64,7 +64,7 @@ TEST(tensor, size)
 
     {
         auto arg0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{1});
-        auto add = make_shared<op::Add>(arg0, arg0);
+        auto add = make_shared<op::v1::Add>(arg0, arg0);
         auto f0 = make_shared<Function>(add, ParameterVector{arg0});
 
         pass_manager.run_passes(f0);
@@ -81,7 +81,7 @@ TEST(tensor, output_flag)
     pass_manager.register_pass<pass::Liveness>();
 
     auto arg0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{1});
-    auto add = make_shared<op::Add>(arg0, arg0);
+    auto add = make_shared<op::v1::Add>(arg0, arg0);
     auto f0 = make_shared<Function>(add, ParameterVector{arg0});
 
     pass_manager.run_passes(f0);
diff --git a/ngraph/test/type_prop/binary_elementwise.cpp b/ngraph/test/type_prop/binary_elementwise.cpp
index a3eba00c806476..eaf84df8da6e9a 100644
--- a/ngraph/test/type_prop/binary_elementwise.cpp
+++ b/ngraph/test/type_prop/binary_elementwise.cpp
@@ -18,8 +18,6 @@
 #include "ngraph/ngraph.hpp"
 #include "util/type_prop.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -86,7 +84,7 @@ TEST(type_prop, add_bad_arguments)
 {
     test_binary("Add",
                 [](const shared_ptr<Node>& x, const shared_ptr<Node>& y) -> shared_ptr<Node> {
-                    return make_shared<op::Add>(x, y);
+                    return make_shared<op::v1::Add>(x, y);
                 });
 }
 
@@ -94,7 +92,7 @@ TEST(type_prop, divide_bad_arguments)
 {
     test_binary("Divide",
                 [](const shared_ptr<Node>& x, const shared_ptr<Node>& y) -> shared_ptr<Node> {
-                    return make_shared<op::Divide>(x, y);
+                    return make_shared<op::v1::Divide>(x, y);
                 });
 }
 
@@ -102,7 +100,7 @@ TEST(type_prop, multiply_bad_arguments)
 {
     test_binary("Multiply",
                 [](const shared_ptr<Node>& x, const shared_ptr<Node>& y) -> shared_ptr<Node> {
-                    return make_shared<op::Multiply>(x, y);
+                    return make_shared<op::v1::Multiply>(x, y);
                 });
 }
 
@@ -110,7 +108,7 @@ TEST(type_prop, subtract_bad_arguments)
 {
     test_binary("Subtract",
                 [](const shared_ptr<Node>& x, const shared_ptr<Node>& y) -> shared_ptr<Node> {
-                    return make_shared<op::Subtract>(x, y);
+                    return make_shared<op::v1::Subtract>(x, y);
                 });
 }
 
@@ -230,20 +228,22 @@ void test_binary_eltwise_numpy(const element::Type& et, const op::AutoBroadcastS
 TEST(type_prop, eltwise_auto_bcast)
 {
     test_binary_eltwise_numpy<op::v1::Add>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Divide>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Equal>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Greater>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::GreaterEq>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Less>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::LessEq>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Maximum>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Minimum>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Multiply>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::NotEqual>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Divide>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Equal>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Greater>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::GreaterEqual>(element::Type_t::f32,
+                                                    op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Less>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::LessEqual>(element::Type_t::f32,
+                                                 op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Maximum>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Minimum>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Multiply>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::NotEqual>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
     test_binary_eltwise_numpy<op::v1::LogicalOr>(element::Type_t::boolean,
                                                  op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Power>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
-    test_binary_eltwise_numpy<op::Subtract>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Power>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
+    test_binary_eltwise_numpy<op::v1::Subtract>(element::Type_t::f32, op::AutoBroadcastType::NUMPY);
     test_binary_eltwise_numpy<op::Xor>(element::Type_t::boolean, op::AutoBroadcastType::NUMPY);
 }
 
@@ -251,7 +251,7 @@ TEST(type_prop, comparison_good)
 {
     auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
     auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
-    auto eq = make_shared<op::Equal>(tv0_2_4_param_0, tv0_2_4_param_1);
+    auto eq = make_shared<op::v1::Equal>(tv0_2_4_param_0, tv0_2_4_param_1);
     EXPECT_EQ(eq->get_element_type(), element::Type_t::boolean);
     EXPECT_EQ(eq->get_shape(), (Shape{2, 4}));
 }
@@ -262,7 +262,7 @@ TEST(type_prop, binary_arithmetic_bad_argument_element_types)
     auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::Type_t::boolean, Shape{2, 4});
     try
     {
-        auto bc = make_shared<op::Add>(tv0_2_4_param_0, tv0_2_4_param_1);
+        auto bc = make_shared<op::v1::Add>(tv0_2_4_param_0, tv0_2_4_param_1);
         // Should have thrown, so fail if it didn't
         FAIL() << "Did not detect incorrect element types for arithmetic operator";
     }
@@ -281,57 +281,11 @@ TEST(type_prop, binary_elementwise_arithmetic_both_dynamic)
 {
     auto a = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
     auto b = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_TRUE(add->get_output_partial_shape(0).rank().is_dynamic());
 }
 
-TEST(type_prop, binary_elementwise_arithmetic_left_rank_dynamic_right_static)
-{
-    auto a = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto b = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3});
-    auto add = make_shared<op::Add>(a, b);
-
-    ASSERT_TRUE(add->get_output_partial_shape(0).is_static());
-    ASSERT_EQ(add->get_shape(), (Shape{1, 2, 3}));
-}
-
-TEST(type_prop, binary_elementwise_arithmetic_left_static_right_rank_dynamic)
-{
-    auto a = make_shared<op::Parameter>(element::Type_t::f32, Shape{1, 2, 3});
-    auto b = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto add = make_shared<op::Add>(a, b);
-
-    ASSERT_TRUE(add->get_output_partial_shape(0).is_static());
-    ASSERT_EQ(add->get_shape(), (Shape{1, 2, 3}));
-}
-
-TEST(type_prop, binary_elementwise_arithmetic_left_rank_static_dynamic_right_rank_dynamic)
-{
-    auto a =
-        make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, Dimension::dynamic(), 3});
-    auto b = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto add = make_shared<op::Add>(a, b);
-
-    ASSERT_TRUE(add->get_output_partial_shape(0).rank().is_static());
-    ASSERT_TRUE(add->get_output_partial_shape(0).is_dynamic());
-    ASSERT_TRUE(
-        add->get_output_partial_shape(0).same_scheme(PartialShape{1, Dimension::dynamic(), 3}));
-}
-
-TEST(type_prop, binary_elementwise_arithmetic_left_rank_dynamic_right_rank_static_dynamic)
-{
-    auto a = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto b =
-        make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, Dimension::dynamic(), 3});
-    auto add = make_shared<op::Add>(a, b);
-
-    ASSERT_TRUE(add->get_output_partial_shape(0).rank().is_static());
-    ASSERT_TRUE(add->get_output_partial_shape(0).is_dynamic());
-    ASSERT_TRUE(
-        add->get_output_partial_shape(0).same_scheme(PartialShape{1, Dimension::dynamic(), 3}));
-}
-
 TEST(type_prop,
      binary_elementwise_arithmetic_left_rank_static_dynamic_right_rank_static_dynamic_result_static)
 {
@@ -339,7 +293,7 @@ TEST(type_prop,
         make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, Dimension::dynamic(), 3});
     auto b =
         make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, 2, Dimension::dynamic()});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_TRUE(add->get_output_partial_shape(0).is_static());
     ASSERT_EQ(add->get_shape(), (Shape{1, 2, 3}));
@@ -353,7 +307,7 @@ TEST(
         element::Type_t::f32, PartialShape{1, Dimension::dynamic(), Dimension::dynamic()});
     auto b =
         make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, 2, Dimension::dynamic()});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_TRUE(add->get_output_partial_shape(0).rank().is_static());
     ASSERT_TRUE(add->get_output_partial_shape(0).is_dynamic());
@@ -366,7 +320,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_static_right_rank_static_dyna
     auto a = make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, 2, 3});
     auto b =
         make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, 2, Dimension::dynamic()});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_TRUE(add->get_output_partial_shape(0).is_static());
     ASSERT_EQ(add->get_shape(), (Shape{1, 2, 3}));
@@ -377,7 +331,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_rank_static_dynamic_right_sta
     auto a =
         make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, 2, Dimension::dynamic()});
     auto b = make_shared<op::Parameter>(element::Type_t::f32, PartialShape{1, 2, 3});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_TRUE(add->get_output_partial_shape(0).is_static());
     ASSERT_EQ(add->get_shape(), (Shape{1, 2, 3}));
@@ -391,7 +345,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_rank_static_dynamic_inconsist
 
     try
     {
-        auto add = make_shared<op::Add>(a, b);
+        auto add = make_shared<op::v1::Add>(a, b);
         FAIL() << "Inconsistent partial shapes not detected";
     }
     catch (const NodeValidationFailure& error)
@@ -412,7 +366,7 @@ TEST(type_prop, binary_elementwise_arithmetic_right_rank_static_dynamic_inconsis
 
     try
     {
-        auto add = make_shared<op::Add>(a, b);
+        auto add = make_shared<op::v1::Add>(a, b);
         FAIL() << "Inconsistent partial shapes not detected";
     }
     catch (const NodeValidationFailure& error)
@@ -434,7 +388,7 @@ TEST(type_prop, binary_elementwise_arithmetic_both_rank_static_dynamic_inconsist
 
     try
     {
-        auto add = make_shared<op::Add>(a, b);
+        auto add = make_shared<op::v1::Add>(a, b);
         FAIL() << "Inconsistent partial shapes not detected";
     }
     catch (const NodeValidationFailure& error)
@@ -455,7 +409,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_rank_static_dynamic_different
 
     try
     {
-        auto add = make_shared<op::Add>(a, b);
+        auto add = make_shared<op::v1::Add>(a, b);
         FAIL() << "Inconsistent partial shapes not detected";
     }
     catch (const NodeValidationFailure& error)
@@ -476,7 +430,7 @@ TEST(type_prop, binary_elementwise_arithmetic_right_rank_static_dynamic_differen
 
     try
     {
-        auto add = make_shared<op::Add>(a, b);
+        auto add = make_shared<op::v1::Add>(a, b);
         FAIL() << "Inconsistent partial shapes not detected";
     }
     catch (const NodeValidationFailure& error)
@@ -498,7 +452,7 @@ TEST(type_prop, binary_elementwise_arithmetic_both_rank_static_dynamic_different
 
     try
     {
-        auto add = make_shared<op::Add>(a, b);
+        auto add = make_shared<op::v1::Add>(a, b);
         FAIL() << "Inconsistent partial shapes not detected";
     }
     catch (const NodeValidationFailure& error)
@@ -515,7 +469,7 @@ TEST(type_prop, binary_elementwise_arithmetic_both_et_dynamic)
 {
     auto a = make_shared<op::Parameter>(element::Type_t::dynamic, Shape{1, 2, 3, 4});
     auto b = make_shared<op::Parameter>(element::Type_t::dynamic, Shape{1, 2, 3, 4});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_TRUE(add->get_output_element_type(0).is_dynamic());
 }
@@ -524,7 +478,7 @@ TEST(type_prop, binary_elementwise_arithmetic_left_et_dynamic)
 {
     auto a = make_shared<op::Parameter>(element::Type_t::dynamic, Shape{1, 2, 3, 4});
     auto b = make_shared<op::Parameter>(element::Type_t::u32, Shape{1, 2, 3, 4});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_EQ(add->get_output_element_type(0), element::Type_t::u32);
 }
@@ -533,7 +487,7 @@ TEST(type_prop, binary_elementwise_arithmetic_right_et_dynamic)
 {
     auto a = make_shared<op::Parameter>(element::Type_t::i64, Shape{1, 2, 3, 4});
     auto b = make_shared<op::Parameter>(element::Type_t::dynamic, Shape{1, 2, 3, 4});
-    auto add = make_shared<op::Add>(a, b);
+    auto add = make_shared<op::v1::Add>(a, b);
 
     ASSERT_EQ(add->get_output_element_type(0), element::Type_t::i64);
 }
@@ -543,13 +497,13 @@ TEST(type_prop, logic_arith_compare_partial_et)
     auto test_arith = [](element::Type et0, element::Type et1) -> std::shared_ptr<Node> {
         auto param0 = std::make_shared<op::Parameter>(et0, Shape{1, 2, 3});
         auto param1 = std::make_shared<op::Parameter>(et1, Shape{1, 2, 3});
-        return std::make_shared<op::Add>(param0, param1);
+        return std::make_shared<op::v1::Add>(param0, param1);
     };
 
     auto test_compare = [](element::Type et0, element::Type et1) -> std::shared_ptr<Node> {
         auto param0 = std::make_shared<op::Parameter>(et0, Shape{1, 2, 3});
         auto param1 = std::make_shared<op::Parameter>(et1, Shape{1, 2, 3});
-        return std::make_shared<op::Greater>(param0, param1);
+        return std::make_shared<op::v1::Greater>(param0, param1);
     };
 
     auto test_logical_not = [](element::Type et) -> std::shared_ptr<Node> {
diff --git a/ngraph/test/type_prop/select.cpp b/ngraph/test/type_prop/select.cpp
index c98f2e6dc711fa..0b9c4f46f70659 100644
--- a/ngraph/test/type_prop/select.cpp
+++ b/ngraph/test/type_prop/select.cpp
@@ -28,7 +28,7 @@ TEST(type_prop, select_deduce)
     auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::Type_t::boolean, Shape{2, 4});
     auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
     auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
-    auto bc = make_shared<op::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
+    auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
     ASSERT_EQ(bc->get_element_type(), element::Type_t::f32);
     ASSERT_EQ(bc->get_shape(), (Shape{2, 4}));
 }
@@ -40,7 +40,7 @@ TEST(type_prop, select_shape_mismatch_a)
     auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
     try
     {
-        auto bc = make_shared<op::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
+        auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
         // Should have thrown, so fail if it didn't
         FAIL() << "Did not detect incorrect element types for arithmetic operator";
     }
@@ -61,7 +61,7 @@ TEST(type_prop, select_shape_mismatch_b)
     auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
     try
     {
-        auto bc = make_shared<op::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
+        auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
         // Should have thrown, so fail if it didn't
         FAIL() << "Did not detect incorrect element types for arithmetic operator";
     }
@@ -82,7 +82,7 @@ TEST(type_prop, select_shape_mismatch_c)
     auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{3, 5});
     try
     {
-        auto bc = make_shared<op::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
+        auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
         // Should have thrown, so fail if it didn't
         FAIL() << "Did not detect incorrect element types for arithmetic operator";
     }
@@ -103,7 +103,7 @@ TEST(type_prop, select_elem_mismatch_a)
     auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 4});
     try
     {
-        auto bc = make_shared<op::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
+        auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
         // Should have thrown, so fail if it didn't
         FAIL() << "Did not detect incorrect element types for arithmetic operator";
     }
@@ -125,14 +125,14 @@ TEST(type_prop, select_elem_mismatch_bc)
     auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::Type_t::i32, Shape{2, 4});
     try
     {
-        auto bc = make_shared<op::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
+        auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
         // Should have thrown, so fail if it didn't
         FAIL() << "Did not detect incorrect element types for arithmetic operator";
     }
     catch (const NodeValidationFailure& error)
     {
         EXPECT_HAS_SUBSTRING(error.what(),
-                             std::string("Argument 1 and 2 element types are inconsistent"));
+                             std::string("Argument 1 and 2 element types must match"));
     }
     catch (...)
     {
@@ -146,7 +146,7 @@ TEST(type_prop, select_partial_all_rank_dynamic)
     auto param1 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
     auto param2 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
 
-    auto sel = make_shared<op::Select>(param0, param1, param2);
+    auto sel = make_shared<op::v1::Select>(param0, param1, param2);
 
     ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
     ASSERT_TRUE(sel->get_output_partial_shape(0).rank().is_dynamic());
@@ -160,14 +160,14 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_et_dynamic_arg1_arg2_et_mis
 
     try
     {
-        auto sel = make_shared<op::Select>(param0, param1, param2);
+        auto sel = make_shared<op::v1::Select>(param0, param1, param2);
         FAIL() << "Did not detect mismatched element types for args 1 and 2 (element type-dynamic "
                   "arg0)";
     }
     catch (const NodeValidationFailure& error)
     {
         EXPECT_HAS_SUBSTRING(error.what(),
-                             std::string("Argument 1 and 2 element types are inconsistent"));
+                             std::string("Argument 1 and 2 element types must match"));
     }
     catch (...)
     {
@@ -181,7 +181,7 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg1_et_dynamic)
     auto param1 = make_shared<op::Parameter>(element::Type_t::dynamic, PartialShape::dynamic());
     auto param2 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
 
-    auto sel = make_shared<op::Select>(param0, param1, param2);
+    auto sel = make_shared<op::v1::Select>(param0, param1, param2);
 
     ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
     ASSERT_TRUE(sel->get_output_partial_shape(0).rank().is_dynamic());
@@ -193,7 +193,7 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg2_et_dynamic)
     auto param1 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
     auto param2 = make_shared<op::Parameter>(element::Type_t::dynamic, PartialShape::dynamic());
 
-    auto sel = make_shared<op::Select>(param0, param1, param2);
+    auto sel = make_shared<op::v1::Select>(param0, param1, param2);
 
     ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
     ASSERT_TRUE(sel->get_output_partial_shape(0).rank().is_dynamic());
@@ -205,54 +205,12 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg1_arg2_et_dynamic)
     auto param1 = make_shared<op::Parameter>(element::Type_t::dynamic, PartialShape::dynamic());
     auto param2 = make_shared<op::Parameter>(element::Type_t::dynamic, PartialShape::dynamic());
 
-    auto sel = make_shared<op::Select>(param0, param1, param2);
+    auto sel = make_shared<op::v1::Select>(param0, param1, param2);
 
     ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::dynamic);
     ASSERT_TRUE(sel->get_output_partial_shape(0).rank().is_dynamic());
 }
 
-TEST(type_prop, select_partial_arg0_rank_dynamic_static_arg1_arg2_rank_dynamic_ok)
-{
-    auto param0 = make_shared<op::Parameter>(element::Type_t::boolean,
-                                             PartialShape{2, Dimension::dynamic(), 3});
-    auto param1 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto param2 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-
-    auto sel = make_shared<op::Select>(param0, param1, param2);
-
-    ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
-    ASSERT_TRUE(
-        sel->get_output_partial_shape(0).same_scheme(PartialShape{2, Dimension::dynamic(), 3}));
-}
-
-TEST(type_prop, select_partial_arg1_rank_dynamic_static_arg0_arg2_rank_dynamic_ok)
-{
-    auto param0 = make_shared<op::Parameter>(element::Type_t::boolean, PartialShape::dynamic());
-    auto param1 =
-        make_shared<op::Parameter>(element::Type_t::f32, PartialShape{2, Dimension::dynamic(), 3});
-    auto param2 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-
-    auto sel = make_shared<op::Select>(param0, param1, param2);
-
-    ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
-    ASSERT_TRUE(
-        sel->get_output_partial_shape(0).same_scheme(PartialShape{2, Dimension::dynamic(), 3}));
-}
-
-TEST(type_prop, select_partial_arg2_rank_dynamic_static_arg0_arg1_rank_dynamic_ok)
-{
-    auto param0 = make_shared<op::Parameter>(element::Type_t::boolean, PartialShape::dynamic());
-    auto param1 = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
-    auto param2 =
-        make_shared<op::Parameter>(element::Type_t::f32, PartialShape{2, Dimension::dynamic(), 3});
-
-    auto sel = make_shared<op::Select>(param0, param1, param2);
-
-    ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
-    ASSERT_TRUE(
-        sel->get_output_partial_shape(0).same_scheme(PartialShape{2, Dimension::dynamic(), 3}));
-}
-
 TEST(type_prop, select_partial_all_rank_static_dynamic_ok)
 {
     auto param0 = make_shared<op::Parameter>(
@@ -262,7 +220,7 @@ TEST(type_prop, select_partial_all_rank_static_dynamic_ok)
     auto param2 = make_shared<op::Parameter>(
         element::Type_t::f32, PartialShape{Dimension::dynamic(), Dimension::dynamic(), 3});
 
-    auto sel = make_shared<op::Select>(param0, param1, param2);
+    auto sel = make_shared<op::v1::Select>(param0, param1, param2);
 
     ASSERT_EQ(sel->get_output_element_type(0), element::Type_t::f32);
     ASSERT_TRUE(sel->get_output_partial_shape(0).is_static());
@@ -280,7 +238,7 @@ TEST(type_prop, select_partial_all_rank_static_intransitive_incompatibility)
 
     try
     {
-        auto sel = make_shared<op::Select>(param0, param1, param2);
+        auto sel = make_shared<op::v1::Select>(param0, param1, param2);
         FAIL() << "Did not detect intransitive partial-shape incompatibility";
     }
     catch (const NodeValidationFailure& error)
diff --git a/ngraph/test/type_prop/ti.cpp b/ngraph/test/type_prop/ti.cpp
index c2c26b51587bd8..102da20f465a18 100644
--- a/ngraph/test/type_prop/ti.cpp
+++ b/ngraph/test/type_prop/ti.cpp
@@ -88,7 +88,7 @@ TEST(type_prop, tensor_iterator_2_slice_inputs_part_size_2)
     auto M_body = make_shared<op::Parameter>(element::Type_t::f32, Shape{32, 2, 10});
 
     // Body
-    auto Zo = (Xi + Yi) * M_body;
+    auto Zo = std::make_shared<op::v1::Multiply>(std::make_shared<op::v1::Add>(Xi, Yi), M_body);
     auto body = make_shared<ngraph::Function>(OutputVector{Zo}, ParameterVector{Xi, Yi, M_body});
 
     auto tensor_iterator = make_shared<op::TensorIterator>();
@@ -132,7 +132,7 @@ TEST(type_prop, tensor_iterator_2_slice_inputs_part_size_2_dynamic)
     auto M_body = make_shared<op::Parameter>(element::Type_t::f32, PartialShape::dynamic());
 
     // Body
-    auto Zo = (Xi + Yi) * M_body;
+    auto Zo = std::make_shared<op::v1::Multiply>(std::make_shared<op::v1::Add>(Xi, Yi), M_body);
     auto body = make_shared<ngraph::Function>(OutputVector{Zo}, ParameterVector{Xi, Yi, M_body});
 
     auto tensor_iterator = make_shared<op::TensorIterator>();
diff --git a/ngraph/test/util.cpp b/ngraph/test/util.cpp
index d24bafd31dfe80..311f0385145a21 100644
--- a/ngraph/test/util.cpp
+++ b/ngraph/test/util.cpp
@@ -31,8 +31,6 @@
 #include "util/all_close.hpp"
 #include "util/ndarray.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -174,8 +172,8 @@ class CloneTest : public ::testing::Test
     std::shared_ptr<op::Parameter> A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     std::shared_ptr<op::Parameter> B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     std::shared_ptr<op::Parameter> C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    std::shared_ptr<Node> AplusB = A + B;
-    std::shared_ptr<Node> AplusBtimesC = AplusB * C;
+    std::shared_ptr<Node> AplusB = make_shared<op::v1::Add>(A, B);
+    std::shared_ptr<Node> AplusBtimesC = make_shared<op::v1::Multiply>(AplusB, C);
 
     NodeMap node_map;
     std::vector<std::shared_ptr<ngraph::Node>> nodes;
@@ -222,8 +220,8 @@ TEST_F(CloneTest, clone_nodes_full)
     ASSERT_NE(nullptr, as_type_ptr<op::Parameter>(node_map.at(A.get())));
     ASSERT_NE(nullptr, as_type_ptr<op::Parameter>(node_map.at(B.get())));
     ASSERT_NE(nullptr, as_type_ptr<op::Parameter>(node_map.at(C.get())));
-    ASSERT_NE(nullptr, as_type_ptr<op::Add>(node_map.at(AplusB.get())));
-    ASSERT_NE(nullptr, as_type_ptr<op::Multiply>(node_map.at(AplusBtimesC.get())));
+    ASSERT_NE(nullptr, as_type_ptr<op::v1::Add>(node_map.at(AplusB.get())));
+    ASSERT_NE(nullptr, as_type_ptr<op::v1::Multiply>(node_map.at(AplusBtimesC.get())));
 
     auto sorted_nodes = topological_sort(nodes);
     auto sorted_cloned_nodes = topological_sort(cloned_nodes);
@@ -255,8 +253,8 @@ TEST(graph_util, clone_multiple_results)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto A_add_B = make_shared<op::Add>(A, B);
-    auto A_add_B_mul_C = make_shared<op::Multiply>(A_add_B, C);
+    auto A_add_B = make_shared<op::v1::Add>(A, B);
+    auto A_add_B_mul_C = make_shared<op::v1::Multiply>(A_add_B, C);
 
     auto f = make_shared<Function>(NodeVector{A_add_B, A_add_B_mul_C}, ParameterVector{A, B, C});
 
@@ -321,7 +319,7 @@ TEST(graph_util, get_subgraph_outputs_trivial_tests)
     outputs = ngraph::get_subgraph_outputs(NodeVector{B, abs_b, abs_b_neg}, NodeVector{});
     ASSERT_EQ(outputs, (NodeVector{B}));
 
-    auto add_b = make_shared<op::Add>(neg_b, abs_b_neg);
+    auto add_b = make_shared<op::v1::Add>(neg_b, abs_b_neg);
     outputs =
         ngraph::get_subgraph_outputs(NodeVector{B, abs_b, neg_b, abs_b_neg, add_b}, NodeVector{});
     ASSERT_EQ(outputs, (NodeVector{}));
@@ -337,8 +335,8 @@ TEST(graph_util, test_subgraph_topological_sort)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto add = A + B;
-    auto mul = C * add;
+    auto add = make_shared<op::v1::Add>(A, B);
+    auto mul = make_shared<op::v1::Multiply>(C, add);
     auto result = make_shared<op::Result>(mul);
     auto sorted = ngraph::subgraph_topological_sort(NodeVector{mul, add, A});
     std::vector<std::shared_ptr<Node>> expected{A, add, mul};
@@ -353,10 +351,10 @@ TEST(graph_util, test_subgraph_topological_sort_control_dependencies)
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto D = make_shared<op::Abs>(A);
     auto E = make_shared<op::Abs>(B);
-    auto add = A + B;
+    auto add = make_shared<op::v1::Add>(A, B);
     add->add_control_dependency(D);
     add->add_control_dependency(E);
-    auto mul = C * add;
+    auto mul = make_shared<op::v1::Multiply>(C, add);
     auto result = make_shared<op::Result>(mul);
     auto sorted = ngraph::subgraph_topological_sort(NodeVector{mul, add, A, D});
     std::vector<std::shared_ptr<Node>> expected{A, D, add, mul};
@@ -604,7 +602,7 @@ TEST(util, clone_function_friendly_name)
     Shape shape{2, 2};
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(A, B), ParameterVector{A, B});
 
     A->set_friendly_name("A");
     B->set_friendly_name("B");
@@ -628,7 +626,8 @@ TEST(util, clone_function_op_annotations)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A + B + C, ParameterVector{A, B, C});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(make_shared<op::v1::Add>(A, B), C),
+                                   ParameterVector{A, B, C});
 
     auto cacheable_op_annotation = std::make_shared<op::util::OpAnnotations>();
     cacheable_op_annotation->set_cacheable(true);
@@ -666,7 +665,8 @@ TEST(util, topological_sort_replace)
     auto A = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto B = make_shared<op::Parameter>(element::Type_t::f32, shape);
     auto C = make_shared<op::Parameter>(element::Type_t::f32, shape);
-    auto f = make_shared<Function>(A + B + C, ParameterVector{A, B, C});
+    auto f = make_shared<Function>(make_shared<op::v1::Add>(make_shared<op::v1::Add>(A, B), C),
+                                   ParameterVector{A, B, C});
     bool custom_sorter_used = false;
 
     f->set_topological_sort(
diff --git a/ngraph/test/util/known_element_types.hpp b/ngraph/test/util/known_element_types.hpp
index 9003321e674b08..e3ef39b6b64d13 100644
--- a/ngraph/test/util/known_element_types.hpp
+++ b/ngraph/test/util/known_element_types.hpp
@@ -30,4 +30,5 @@ static const std::vector<ngraph::element::Type> s_known_element_types = {
     ngraph::element::from<uint8_t>(),
     ngraph::element::from<uint16_t>(),
     ngraph::element::from<uint32_t>(),
-    ngraph::element::from<uint64_t>()};
+    ngraph::element::from<uint64_t>(),
+};
diff --git a/ngraph/test/util/test_tools.cpp b/ngraph/test/util/test_tools.cpp
index 168fa8f975d3ea..75e8705b781701 100644
--- a/ngraph/test/util/test_tools.cpp
+++ b/ngraph/test/util/test_tools.cpp
@@ -69,14 +69,14 @@ shared_ptr<Function> make_test_graph()
     auto arg_4 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2});
     auto arg_5 = make_shared<op::Parameter>(element::Type_t::f32, Shape{2, 2});
 
-    auto t0 = make_shared<op::Add>(arg_0, arg_1);
+    auto t0 = make_shared<op::v1::Add>(arg_0, arg_1);
     auto t1 = make_shared<op::MatMul>(t0, arg_2);
-    auto t2 = make_shared<op::Multiply>(t0, arg_3);
+    auto t2 = make_shared<op::v1::Multiply>(t0, arg_3);
 
-    auto t3 = make_shared<op::Add>(t1, arg_4);
-    auto t4 = make_shared<op::Add>(t2, arg_5);
+    auto t3 = make_shared<op::v1::Add>(t1, arg_4);
+    auto t4 = make_shared<op::v1::Add>(t2, arg_5);
 
-    auto r0 = make_shared<op::Add>(t3, t4);
+    auto r0 = make_shared<op::v1::Add>(t3, t4);
 
     auto f0 = make_shared<Function>(r0, ParameterVector{arg_0, arg_1, arg_2, arg_3, arg_4, arg_5});