Refactor ngraph builders (#20998)

* Remove makeInputLayer builders

* Refactor makeBroadcast builder

* Deprecated makeCTC builders

* Fix for broadcast builder

* Remove and deprecate makeSplit builder

* fix

* Fix

src/plugins/auto/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp

@@ -18,7 +18,9 @@ std::shared_ptr<ngraph::Function> getFunction2() {
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     params.front()->set_friendly_name("Param_1");
     params.front()->get_output_tensor(0).set_names({"input_tensor"});
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
     auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
     auto add = ngraph::builder::makeEltwise(split->output(0), in2add, ngraph::helpers::EltwiseTypes::ADD);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp

@@ -45,7 +45,9 @@ std::shared_ptr<ngraph::Function> getFunction2() {
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     params.front()->set_friendly_name("Param_1");
     params.front()->get_output_tensor(0).set_names({"input_tensor"});
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
+
 
     auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
     auto add = ngraph::builder::makeEltwise(split->output(0), in2add, ngraph::helpers::EltwiseTypes::ADD);

src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/matmul.cpp

@@ -8,6 +8,7 @@
 #include "openvino/runtime/properties.hpp"
 #include "test_utils/cpu_test_utils.hpp"
 #include "cpp_interfaces/interface/ie_internal_plugin_config.hpp"
+#include "common_test_utils/ov_tensor_utils.hpp"
 
 using namespace InferenceEngine;
 using namespace CPUTestUtils;
@@ -128,9 +129,15 @@ void MatMulLayerCPUTest::SetUp() {
 
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netType, inShapeA)};
 
-    auto matrixB = builder::makeDynamicInputLayer(netType, secondaryInputType, inShapeB);
+    std::shared_ptr<ov::Node> matrixB;
     if (secondaryInputType == helpers::InputLayerType::PARAMETER) {
-        params.push_back(std::dynamic_pointer_cast<opset1::Parameter>(matrixB));
+        auto param = std::make_shared<ov::op::v0::Parameter>(netType, inShapeB);
+        matrixB = param;
+        params.push_back(param);
+    } else {
+        ASSERT_TRUE(inShapeB.is_static());
+        auto tensor = ov::test::utils::create_and_fill_tensor(netType, inShapeB.to_shape());
+        matrixB = std::make_shared<ov::op::v0::Constant>(tensor);
     }
     auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset1::Parameter>(params));
     auto matMul = std::make_shared<ov::op::v0::MatMul>(paramOuts[0], matrixB, transpA, transpB);

src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp

@@ -88,13 +88,16 @@ protected:
 
         ov::ParameterVector paramsIn{std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[0])};
         if (ngraph::helpers::InputLayerType::PARAMETER == secondaryInputType) {
-            inp2 = ngraph::builder::makeDynamicInputLayer(netPrecision, secondaryInputType, inputDynamicShapes[1]);
-            inp3 = ngraph::builder::makeDynamicInputLayer(netPrecision, secondaryInputType, inputDynamicShapes[2]);
-            inp4 = ngraph::builder::makeDynamicInputLayer(netPrecision, secondaryInputType, inputDynamicShapes[3]);
+            auto param2 = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[1]);
+            auto param3 = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[2]);
+            auto param4 = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[3]);
+            inp2 = param2;
+            inp3 = param3;
+            inp4 = param4;
 
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset1::Parameter>(inp2));
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset1::Parameter>(inp3));
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset1::Parameter>(inp4));
+            paramsIn.push_back(param2);
+            paramsIn.push_back(param3);
+            paramsIn.push_back(param4);
         } else if (ngraph::helpers::InputLayerType::CONSTANT == secondaryInputType) {
             auto maxBeamIndex = inputShape.second.front().at(2) - 1;
 

src/plugins/intel_cpu/tests/functional/single_layer_tests/logical.cpp

@@ -5,6 +5,7 @@
 #include <shared_test_classes/single_layer/logical.hpp>
 #include "ov_models/builders.hpp"
 #include "test_utils/cpu_test_utils.hpp"
+#include "common_test_utils/ov_tensor_utils.hpp"
 
 using namespace InferenceEngine;
 using namespace CPUTestUtils;
@@ -59,9 +60,14 @@ protected:
         ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(ngInputsPrc, ov::Shape(inputShapes.first))};
         std::shared_ptr<ngraph::Node> logicalNode;
         if (logicalOpType != ngraph::helpers::LogicalTypes::LOGICAL_NOT) {
-            auto secondInput = ngraph::builder::makeInputLayer(ngInputsPrc, secondInputType, inputShapes.second);
+            std::shared_ptr<ov::Node> secondInput;
             if (secondInputType == ngraph::helpers::InputLayerType::PARAMETER) {
-                inputs.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondInput));
+                auto param = std::make_shared<ov::op::v0::Parameter>(ngInputsPrc, ov::Shape(inputShapes.second));
+                secondInput = param;
+                inputs.push_back(param);
+            } else {
+                auto tensor = ov::test::utils::create_and_fill_tensor(ngInputsPrc, ov::Shape(inputShapes.second));
+                secondInput = std::make_shared<ov::op::v0::Constant>(tensor);
             }
             logicalNode = ngraph::builder::makeLogical(inputs[0], secondInput, logicalOpType);
         } else {

src/plugins/intel_cpu/tests/functional/single_layer_tests/matmul_sparse.cpp

@@ -11,6 +11,7 @@
 #include <ov_ops/type_relaxed.hpp>
 #include "shared_test_classes/base/utils/generate_inputs.hpp"
 #include "cpu/cpu_config.hpp"
+#include "common_test_utils/ov_tensor_utils.hpp"
 
 using namespace ngraph;
 using namespace InferenceEngine;
@@ -130,7 +131,8 @@ protected:
                                             const std::vector<int8_t>& weiData) {
         using namespace ngraph;
         auto inputParamsFP32 = std::make_shared<ov::op::v0::Parameter>(element::f32, A.get_partial_shape());
-        auto matrixBFP32 = builder::makeDynamicInputLayer(element::f32, helpers::InputLayerType::CONSTANT, inShapeB);
+        auto tensor = ov::test::utils::create_and_fill_tensor(element::f32, inShapeB.to_shape());
+        auto matrixBFP32 = std::make_shared<ov::op::v0::Constant>(tensor);
 
         auto matMulRelaxed = std::make_shared<ov::op::TypeRelaxed<opset3::MatMul>>(
             ov::op::v0::MatMul(inputParamsFP32, matrixBFP32, transpose_a, transpose_b),
@@ -191,7 +193,8 @@ protected:
 
         ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(inType, inShapeA)};
 
-        auto matrixB = builder::makeDynamicInputLayer(element::f32, helpers::InputLayerType::CONSTANT, inShapeB);
+        auto tensor = ov::test::utils::create_and_fill_tensor(element::f32, inShapeB.to_shape());
+        auto matrixB = std::make_shared<ov::op::v0::Constant>(tensor);
 
         auto weiData = generateSparseVector(ngraph::shape_size(inShapeB.get_shape()), weiSparseRate);
         auto matMul = makeMatMulRelaxed(params[0], inShapeB, weiType, transpA, transpB, weiData);

src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp

@@ -76,8 +76,9 @@ protected:
         std::shared_ptr<ngraph::Node> seqLengthsInput;
 
         if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
-            seqLengthsInput = ngraph::builder::makeDynamicInputLayer(seqLengthsPrc, secondaryInputType, inputDynamicShapes[1]);
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(seqLengthsInput));
+            auto param = std::make_shared<ov::op::v0::Parameter>(seqLengthsPrc, inputDynamicShapes[1]);
+            seqLengthsInput = param;
+            paramsIn.push_back(param);
         } else {
             const auto maxSeqLength = dataInputShape.second.front().at(seqAxisIndex);
             seqLengthsInput = ngraph::builder::makeConstant<float>(seqLengthsPrc, seqLengthsShape.second.front(), {}, true, maxSeqLength);

src/plugins/intel_cpu/tests/functional/single_layer_tests/split.cpp

@@ -53,7 +53,8 @@ protected:
     void SetUp() override {
         targetDevice = ov::test::utils::DEVICE_CPU;
 
-        size_t axis, numSplits;
+        size_t numSplits;
+        int axis;
         ElementType netPrecision;
         InputShape inputShapes;
         InferenceEngine::SizeVector outIndices;
@@ -74,8 +75,9 @@ protected:
         for (auto&& shape : inputDynamicShapes)
             params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
 
-        auto split = std::dynamic_pointer_cast<ngraph::opset5::Split>(ngraph::builder::makeSplit(params[0],
-                                                                                                 netPrecision, numSplits, axis));
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{axis});
+        auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, numSplits);
+
         ngraph::ResultVector results;
 
         for (size_t i = 0; i < outIndices.size(); i++) {

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fullyconnected_strided_inputs_outputs.cpp

@@ -5,6 +5,7 @@
 #include "openvino/core/partial_shape.hpp"
 #include "test_utils/cpu_test_utils.hpp"
 #include "ov_models/builders.hpp"
+#include "common_test_utils/ov_tensor_utils.hpp"
 
 using namespace ngraph;
 using namespace InferenceEngine;
@@ -49,15 +50,18 @@ protected:
         ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(splitShape))};
 
         const auto splitAxis = rank == 3 ? 1 : 0;
-        const auto split = builder::makeSplit(params[0], ngPrec, 2 /* splits */, splitAxis);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{splitAxis});
+        auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
         SizeVector fcWeightsShape{16, 8};
         if (rank == 3) bcastTo3D(fcWeightsShape);
 
-        auto fc1secondInput = builder::makeInputLayer(ngPrec, helpers::InputLayerType::CONSTANT, fcWeightsShape);
+        auto tensor = ov::test::utils::create_and_fill_tensor(ngPrec, fcWeightsShape);
+        auto fc1secondInput = std::make_shared<ov::op::v0::Constant>(tensor);
         const auto fc1 = std::make_shared<ov::op::v0::MatMul>(split->output(0), fc1secondInput, false, false);
 
-        auto fc2secondInputB = builder::makeInputLayer(ngPrec, helpers::InputLayerType::CONSTANT, fcWeightsShape);
+        auto tensorB = ov::test::utils::create_and_fill_tensor(ngPrec, fcWeightsShape);
+        auto fc2secondInputB = std::make_shared<ov::op::v0::Constant>(tensorB);
         const auto fc2 = std::make_shared<ov::op::v0::MatMul>(split->output(1), fc2secondInputB, false, false);
 
         const auto fcConcatAxis = rank == 3 ? 1 : 0;

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fuse_split_concat_pair_to_interpolate.cpp

@@ -54,7 +54,8 @@ protected:
         size_t num_of_concat_inputs = num_splits * scale_factor;
 
         const auto param = std::make_shared<opset6::Parameter>(inputPrecision, inputShape);
-        const auto split = builder::makeSplit(param, inputPrecision, num_splits, static_cast<int64_t>(axis));
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{axis});
+        auto split = std::make_shared<ov::op::v1::Split>(param, split_axis_op, num_splits);
 
         ngraph::OutputVector concat_inputs_vec(num_of_concat_inputs);
         for (size_t split_output_port = 0; split_output_port < num_splits; ++split_output_port) {

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/input_noreorder_eltwise_bf16.cpp

@@ -6,6 +6,7 @@
 #include "ie_common.h"
 #include "ov_models/utils/ov_helpers.hpp"
 #include "test_utils/cpu_test_utils.hpp"
+#include "common_test_utils/ov_tensor_utils.hpp"
 
 using namespace InferenceEngine;
 using namespace CPUTestUtils;
@@ -24,11 +25,13 @@ protected:
 
         std::vector<size_t> inputShape {2, 4, 4, 1};
         auto eltwiseType = ngraph::helpers::EltwiseTypes::ADD;
-        auto secondaryInputType = ngraph::helpers::InputLayerType::CONSTANT;
 
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
         ov::ParameterVector input {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
-        std::shared_ptr<ngraph::Node> secondaryInput = ngraph::builder::makeInputLayer(ngPrc, secondaryInputType, inputShape);
+
+        auto tensor = ov::test::utils::create_and_fill_tensor(ngPrc, inputShape);
+        auto secondaryInput = std::make_shared<ov::op::v0::Constant>(tensor);
+
         auto eltwise = ngraph::builder::makeEltwise(input[0], secondaryInput, eltwiseType);
 
         function = makeNgraphFunction(ngPrc, input, eltwise, "Eltwise");

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/matmul_strided_inputs_outputs.cpp

@@ -36,7 +36,8 @@ protected:
 
         SizeVector splitShape{1, 2, 1, 16};
         ov::ParameterVector splitInputParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(splitShape))};
-        const auto split = builder::makeSplit(splitInputParams[0], ngPrec, 2 /* splits */, 1 /* 2nd axis */);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(splitInputParams[0], split_axis_op, 2);
 
         std::vector<ov::Shape> concatShapes{{1, 1, 8, 8}, {1, 1, 8, 8}};
         ov::ParameterVector concatInputParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, concatShapes[0]),

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_fc.cpp

@@ -85,7 +85,8 @@ protected:
         auto reshapeData = ngraph::builder::makeConstant(ElementType::i32, {data.size()}, data);
         auto reshape = std::make_shared<ngraph::opset1::Reshape>(params[0], reshapeData, true);
 
-        auto weight = ngraph::builder::makeDynamicInputLayer(prc, ngraph::helpers::InputLayerType::CONSTANT, inputDynamicShapes.back());
+        auto tensor = ov::test::utils::create_and_fill_tensor(prc, inputDynamicShapes.back().to_shape());
+        auto weight = std::make_shared<ov::op::v0::Constant>(tensor);
         auto matMul = std::make_shared<ov::op::v0::MatMul>(reshape, weight, false, false);
 
         function = makeNgraphFunction(prc, params, matMul, "ReshapeFcModel");

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/split_concat_add.cpp

@@ -46,7 +46,9 @@ protected:
         for (auto&& shape : inputDynamicShapes) {
             params.push_back(std::make_shared<ov::op::v0::Parameter>(precision, shape));
         }
-        auto split = ngraph::builder::makeSplit(params.front(), precision, 3, 1);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(params.front(), split_axis_op, 3);
+
         auto add_const = ngraph::builder::makeConstant(precision, {1}, std::vector<float>({1.0f}));
         auto add_1 = ngraph::builder::makeEltwise(split->output(0), add_const, ngraph::helpers::EltwiseTypes::ADD);
         auto result_add_1 = std::make_shared<ngraph::opset3::Result>(add_1);

src/plugins/intel_gna/tests/functional/pass_tests/concat_memory_param.cpp

@@ -92,7 +92,9 @@ protected:
         auto etlwise_result_node = std::make_shared<ngraph::opset9::Multiply>(concat, etlwise_node);
 
         ov::ResultVector results{std::make_shared<ngraph::opset9::Result>(etlwise_result_node)};
-        auto split_node = ngraph::builder::makeSplit(concat, ng_prc, 2, axis);
+        auto split_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{axis});
+        auto split_node = std::make_shared<ov::op::v1::Split>(concat, split_axis_op, 2);
 
         auto assign_node = std::make_shared<ngraph::opset9::Assign>(split_node->output(1), var);
         ngraph::SinkVector sinks{assign_node};

src/plugins/intel_gna/tests/functional/pass_tests/convolution_align_filter.cpp

@@ -70,7 +70,9 @@ protected:
         auto pattern1 =
             std::make_shared<ngraph::opset8::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{2}, splitInputShape);
         auto reshape1 = std::make_shared<ngraph::opset8::Reshape>(params[0], pattern1, false);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(reshape1, ngPrc, 2, 0);
+        OPENVINO_SUPPRESS_DEPRECATED_END
 
         auto relu1 = std::make_shared<ngraph::opset8::Relu>(split->output(0));
         auto relu2 = std::make_shared<ngraph::opset8::Relu>(split->output(1));

src/plugins/intel_gna/tests/functional/pass_tests/fq_outputs_activation_.cpp

@@ -80,7 +80,9 @@ protected:
         auto inputLowNode = ngraph::builder::makeConstant<float>(ngPrc, {1}, {inputMinMax.first});
         auto inputHighNode = ngraph::builder::makeConstant<float>(ngPrc, {1}, {inputMinMax.second});
         ov::ParameterVector inputVector{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(inputVector[0], ngPrc, outputCount, 1);
+        OPENVINO_SUPPRESS_DEPRECATED_END
 
         ngraph::ResultVector results;
         for (size_t i = 0; i < outputCount; ++i) {

src/plugins/intel_gna/tests/functional/pass_tests/remove_permutations_NHWC_to_NCHW_pass.cpp

@@ -483,7 +483,9 @@ protected:
             std::accumulate(std::begin(inputShape), std::end(inputShape), 1, std::multiplies<double>());
         ov::ParameterVector params{
             std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 2 * in_total_dims_size})};
-        auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+        auto split_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
         auto pattern1 = std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64,
                                                                    ngraph::Shape{shape_size},
@@ -590,11 +592,13 @@ protected:
                                                                   multipleInputShape);
         auto reshape = std::make_shared<ngraph::opset1::Reshape>(params[0], pattern, false);
         auto permute = CreateTranspose(reshape, shape_size, true);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(
             permute,
             ngPrc,
             splits_num,
             inputShape.size() == 4 && inputShape[1] > 1 ? inputShape.size() - 2 : inputShape.size() - 1);
+        OPENVINO_SUPPRESS_DEPRECATED_END
 
         auto conv1 = CreateConvolution(split->output(0), ngPrc, inputShape);
         auto permute1 = CreateTranspose(conv1, conv1->get_output_shape(0).size(), false);

src/plugins/intel_gna/tests/functional/scale_factors_tests/matmul_overload_correction.cpp

@@ -76,7 +76,7 @@ protected:
                 ngraph::Shape{shape1[1], shape1[1]},
                 ov::test::utils::generate_float_numbers(shape2[1], 0.0f, maxInputValue));
         } else {
-            input2 = ngraph::builder::makeInputLayer(ngPrc, ngraph::helpers::InputLayerType::PARAMETER, shape2);
+            input2 = std::make_shared<ov::op::v0::Parameter>(ngPrc, shape2);
             params.push_back(std::dynamic_pointer_cast<ngraph::opset8::Parameter>(input2));
         }
 

src/plugins/intel_gna/tests/unit/transformations/gna_insert_copy_layer.cpp

@@ -142,7 +142,9 @@ public:
 
         {
             auto params = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, input_shape);
+            OPENVINO_SUPPRESS_DEPRECATED_START
             auto split = ngraph::builder::makeSplit(params, ngraph::element::i64, m_inputs_num, m_axis);
+            OPENVINO_SUPPRESS_DEPRECATED_END
 
             ngraph::OutputVector concat_inputs;
             for (int i = 0; i < m_inputs_num; ++i) {
@@ -157,7 +159,9 @@ public:
 
         {
             auto params = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, input_shape);
+            OPENVINO_SUPPRESS_DEPRECATED_START
             auto split = ngraph::builder::makeSplit(params, ngraph::element::i64, m_inputs_num, m_axis);
+            OPENVINO_SUPPRESS_DEPRECATED_END
 
             ngraph::OutputVector concat_inputs;
             int copy_layer_interval =
@@ -1181,7 +1185,9 @@ TEST_P(InsertCopyLayerSplitMemoryTest, CompareWithRefs) {
         auto variable = std::make_shared<ngraph::Variable>(
             ov::op::util::VariableInfo{out_shape, ngraph::element::i64, variable_name});
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, in_shape);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(input, ngraph::element::i64, 1, axis);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         auto init_value = ngraph::builder::makeConstant(ngraph::element::i64, out_shape, std::vector<size_t>{0});
         auto read_value = std::make_shared<ngraph::opset8::ReadValue>(init_value, variable);
         auto assign = std::make_shared<ngraph::opset8::Assign>(split, variable);
@@ -1199,7 +1205,9 @@ TEST_P(InsertCopyLayerSplitMemoryTest, CompareWithRefs) {
         auto variable = std::make_shared<ngraph::Variable>(
             ov::op::util::VariableInfo{out_shape, ngraph::element::i64, variable_name});
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, in_shape);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(input, ngraph::element::i64, 1, axis);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         auto copy = std::make_shared<ov::intel_gna::op::Copy>(split);
         auto init_value = ngraph::builder::makeConstant(ngraph::element::i64, out_shape, std::vector<size_t>{0});
         auto read_value = std::make_shared<ngraph::opset8::ReadValue>(init_value, variable);
@@ -1249,7 +1257,9 @@ TEST_P(InsertCopyLayerSplitNFLMemoryTest, CompareWithRefs) {
         auto variable = std::make_shared<ngraph::Variable>(
             ov::op::util::VariableInfo{out_shape, ngraph::element::i64, variable_name});
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, in_shape);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(input, ngraph::element::i64, 2, axis);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         auto reshape = ov::op::util::reshapeTo(split, shape);
         auto init_value = ngraph::builder::makeConstant(ngraph::element::i64, out_shape, std::vector<size_t>{0});
         auto read_value = std::make_shared<ngraph::opset8::ReadValue>(init_value, variable);
@@ -1268,7 +1278,9 @@ TEST_P(InsertCopyLayerSplitNFLMemoryTest, CompareWithRefs) {
         auto variable = std::make_shared<ngraph::Variable>(
             ov::op::util::VariableInfo{out_shape, ngraph::element::i64, variable_name});
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, in_shape);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(input, ngraph::element::i64, 2, axis);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         auto reshape = ov::op::util::reshapeTo(split, shape);
         auto copy = std::make_shared<ov::intel_gna::op::Copy>(reshape);
         auto init_value = ngraph::builder::makeConstant(ngraph::element::i64, out_shape, std::vector<size_t>{0});
@@ -1644,7 +1656,9 @@ TEST_P(InsertCopyLayerSplitNFLConcatTest, CompareWithRefs) {
 
     {
         auto params = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, input_shape);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(params, ngraph::element::i64, 1, axis);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         auto reshape = ov::op::util::reshapeTo(split->output(0), shape);
         auto const_value = ngraph::builder::makeConstant(ngraph::element::i64, shape, std::vector<size_t>{1});
         auto concat = std::make_shared<ngraph::opset8::Concat>(ngraph::OutputVector{reshape, const_value}, axis);
@@ -1654,7 +1668,9 @@ TEST_P(InsertCopyLayerSplitNFLConcatTest, CompareWithRefs) {
     }
     {
         auto params = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i64, input_shape);
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto split = ngraph::builder::makeSplit(params, ngraph::element::i64, 1, axis);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         auto reshape = ov::op::util::reshapeTo(split->output(0), shape);
         auto copy = std::make_shared<ov::intel_gna::op::Copy>(reshape);
         auto const_value = ngraph::builder::makeConstant(ngraph::element::i64, shape, std::vector<size_t>{1});

src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_tree.cpp

@@ -79,13 +79,16 @@ protected:
 
         ov::ParameterVector paramsIn{std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[0])};
         if (ngraph::helpers::InputLayerType::PARAMETER == secondaryInputType) {
-            inp2 = ngraph::builder::makeDynamicInputLayer(netPrecision, secondaryInputType, inputDynamicShapes[1]);
-            inp3 = ngraph::builder::makeDynamicInputLayer(netPrecision, secondaryInputType, inputDynamicShapes[2]);
-            inp4 = ngraph::builder::makeDynamicInputLayer(netPrecision, secondaryInputType, inputDynamicShapes[3]);
+            auto param2 = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[1]);
+            auto param3 = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[2]);
+            auto param4 = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[3]);
+            inp2 = param2;
+            inp3 = param3;
+            inp4 = param4;
 
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset1::Parameter>(inp2));
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset1::Parameter>(inp3));
-            paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset1::Parameter>(inp4));
+            paramsIn.push_back(param2);
+            paramsIn.push_back(param3);
+            paramsIn.push_back(param4);
         } else if (ngraph::helpers::InputLayerType::CONSTANT == secondaryInputType) {
             auto maxBeamIndex = inputShape.second.front().at(2) - 1;
 

src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/matmul.cpp

@@ -7,6 +7,7 @@
 #include "ie_precision.hpp"
 #include "ov_models/builders.hpp"
 #include <string>
+#include "common_test_utils/ov_tensor_utils.hpp"
 
 using namespace ngraph;
 using namespace InferenceEngine;
@@ -118,10 +119,17 @@ protected:
 
         ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netType, inShapeA)};
 
-        auto matrixB = builder::makeDynamicInputLayer(netType, secondaryInputType, inShapeB);
+        std::shared_ptr<ov::Node> matrixB;
         if (secondaryInputType == helpers::InputLayerType::PARAMETER) {
-            params.push_back(std::dynamic_pointer_cast<opset1::Parameter>(matrixB));
+            auto param = std::make_shared<ov::op::v0::Parameter>(netType, inShapeB);
+            matrixB = param;
+            params.push_back(param);
+        } else {
+            ASSERT_TRUE(inShapeB.is_static());
+            auto tensor = ov::test::utils::create_and_fill_tensor(netType, inShapeB.to_shape());
+            matrixB = std::make_shared<ov::op::v0::Constant>(tensor);
         }
+
         auto matMul = std::make_shared<ov::op::v0::MatMul>(params[0], matrixB, transpA, transpB);
         auto makeFunction = [](const ngraph::element::Type &ngPrc, ngraph::ParameterVector &params, const std::shared_ptr<ngraph::Node> &lastNode) {
             ngraph::ResultVector results;

src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/split.cpp

@@ -66,8 +66,9 @@ protected:
         }
         init_input_shapes({inputShape});
         ov::ParameterVector dyn_params{std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[0])};
-        auto split = std::dynamic_pointer_cast<ngraph::opset5::Split>(
-                     ngraph::builder::makeSplit(dyn_params[0], netPrecision, numSplits, axis));
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{axis});
+        auto split = std::make_shared<ov::op::v1::Split>(dyn_params[0], split_axis_op, numSplits);
+
         ngraph::ResultVector results;
         for (size_t i = 0; i < outIndices.size(); i++) {
             results.push_back(std::make_shared<ngraph::opset1::Result>(split->output(outIndices[i])));

src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/ov_infer_request/infer_request_dynamic.cpp

@@ -38,7 +38,8 @@ std::shared_ptr<ngraph::Function> ovGetFunction2() {
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     params.front()->set_friendly_name("Param_1");
     params.front()->get_output_tensor(0).set_names({"input_tensor"});
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto splitAxisOp = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], splitAxisOp, 2);
 
     auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
     auto add = ngraph::builder::makeEltwise(split->output(0), in2add, ngraph::helpers::EltwiseTypes::ADD);

src/tests/functional/plugin/shared/src/behavior/executable_network/exec_graph_info.cpp

@@ -463,7 +463,9 @@ void ExecGraphUniqueNodeNames::SetUp() {
 
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
+
     auto concat = std::make_shared<ngraph::opset1::Concat>(split->outputs(), 1);
 
     ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(concat)};

src/tests/functional/plugin/shared/src/execution_graph_tests/runtime_precision.cpp

@@ -26,13 +26,12 @@ namespace ExecutionGraphTests {
 std::shared_ptr<ngraph::Function> makeEltwiseFunction(const std::vector<InferenceEngine::Precision>& inputPrecisions) {
     IE_ASSERT(inputPrecisions.size() == 2);
 
-    ov::ParameterVector inputs{
-        std::make_shared<ov::op::v0::Parameter>(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), ov::Shape{1, 16, 5, 4})};
-    auto secondaryInput = ngraph::builder::makeInputLayer(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[1]),
-            ngraph::helpers::InputLayerType::PARAMETER, {{1, 16, 5, 4}});
-    inputs.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
+    ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]),
+                                                                       ov::Shape{1, 16, 5, 4}),
+                               std::make_shared<ov::op::v0::Parameter>(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[1]),
+                                                                       ov::Shape{1, 16, 5, 4})};
 
-    auto eltwise = ngraph::builder::makeEltwise(inputs[0], secondaryInput, ngraph::helpers::EltwiseTypes::ADD);
+    auto eltwise = ngraph::builder::makeEltwise(inputs[0], inputs[1], ngraph::helpers::EltwiseTypes::ADD);
     eltwise->set_friendly_name("Eltwise");
 
     auto function = std::make_shared<ngraph::Function>(eltwise, inputs, "EltwiseWithTwoDynamicInputs");

src/tests/functional/shared_test_classes/src/single_layer/broadcast.cpp

@@ -38,7 +38,13 @@ void BroadcastLayerTest::SetUp() {
     auto target_shape_const = ov::op::v0::Constant::create(ov::element::i64, {targetShape.size()}, targetShape);
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
-    auto broadcast = ngraph::builder::makeBroadcast(params[0], target_shape_const, mode, axesMapping);
+    std::shared_ptr<ov::Node> broadcast;
+    if (mode == ov::op::BroadcastType::NONE) {
+        auto axisSetConst = ov::op::v0::Constant::create(ov::element::i64, {axesMapping.size()}, axesMapping.to_vector());
+        broadcast = std::make_shared<ov::op::v3::Broadcast>(params[0], target_shape_const, axisSetConst, mode);
+    } else {  // numpy/bidirectional modes
+        broadcast = std::make_shared<ov::op::v3::Broadcast>(params[0], target_shape_const, mode);
+    }
     ov::ResultVector results{std::make_shared<ov::op::v0::Result>(broadcast)};
     function = std::make_shared<ov::Model>(results, params, "BroadcastInference");
 }

src/tests/functional/shared_test_classes/src/single_layer/comparison.cpp

@@ -68,7 +68,9 @@ void ComparisonLayerTest::SetUp() {
 
     ov::ParameterVector inputs {std::make_shared<ov::op::v0::Parameter>(ngInputsPrc, ov::Shape(inputShapes.first))};
 
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto secondInput = ngraph::builder::makeInputLayer(ngInputsPrc, secondInputType, inputShapes.second);
+    OPENVINO_SUPPRESS_DEPRECATED_END
     if (secondInputType == InputLayerType::PARAMETER) {
         inputs.push_back(std::dynamic_pointer_cast<ov::op::v0::Parameter>(secondInput));
     }

src/tests/functional/shared_test_classes/src/single_layer/ctc_greedy_decoder.cpp

@@ -46,8 +46,10 @@ void CTCGreedyDecoderLayerTest::SetUp() {
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     ov::ParameterVector paramsIn {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes))};
 
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto ctcGreedyDecoder = std::dynamic_pointer_cast<ngraph::opset1::CTCGreedyDecoder>(
             ngraph::builder::makeCTCGreedyDecoder(paramsIn[0], mergeRepeated));
+    OPENVINO_SUPPRESS_DEPRECATED_END
 
     ngraph::ResultVector results{ std::make_shared<ngraph::opset1::Result>(ctcGreedyDecoder) };
     function = std::make_shared<ngraph::Function>(results, paramsIn, "CTCGreedyDecoder");

src/tests/functional/shared_test_classes/src/single_layer/ctc_greedy_decoder_seq_len.cpp

@@ -80,9 +80,11 @@ void CTCGreedyDecoderSeqLenLayerTest::SetUp() {
     int C = inputShape.at(2);
     blankIndex = std::min(blankIndex, C - 1);
 
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto ctcGreedyDecoderSeqLen = std::dynamic_pointer_cast<ngraph::op::v6::CTCGreedyDecoderSeqLen>(
             ngraph::builder::makeCTCGreedyDecoderSeqLen(paramsIn[0], sequenceLenNode,
                                                         blankIndex, mergeRepeated, ngIdxPrc));
+    OPENVINO_SUPPRESS_DEPRECATED_END
 
     ngraph::ResultVector results;
     for (int i = 0; i < ctcGreedyDecoderSeqLen->get_output_size(); i++) {

src/tests/functional/shared_test_classes/src/single_layer/ctc_loss.cpp

@@ -51,9 +51,12 @@ void CTCLossLayerTest::SetUp() {
     auto ngIntPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(intPrecision);
 
     ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngFpPrc, ov::Shape(logitsShapes))};
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto ctcLoss = std::dynamic_pointer_cast<ngraph::opset4::CTCLoss>(
             ngraph::builder::makeCTCLoss(params[0], logitsLength, labels, labelsLength, blankIndex,
                 ngFpPrc, ngIntPrc, preprocessCollapseRepeated, ctcMergeRepeated, unique));
+    OPENVINO_SUPPRESS_DEPRECATED_END
+
     ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(ctcLoss)};
     function = std::make_shared<ngraph::Function>(results, params, "CTCLoss");
 }

src/tests/functional/shared_test_classes/src/single_layer/logical.cpp

@@ -68,7 +68,9 @@ void LogicalLayerTest::SetUp() {
 
     std::shared_ptr<ngraph::Node> logicalNode;
     if (logicalOpType != ngraph::helpers::LogicalTypes::LOGICAL_NOT) {
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto secondInput = ngraph::builder::makeInputLayer(ngInputsPrc, secondInputType, inputShapes.second);
+        OPENVINO_SUPPRESS_DEPRECATED_END
         if (secondInputType == ngraph::helpers::InputLayerType::PARAMETER) {
             inputs.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondInput));
         }

src/tests/functional/shared_test_classes/src/single_layer/mat_mul.cpp

@@ -63,7 +63,9 @@ void MatMulTest::SetUp() {
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shapeRelatedParams.input1.first))};
 
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto secondaryInput = ngraph::builder::makeInputLayer(ngPrc, secondaryInputType, shapeRelatedParams.input2.first);
+    OPENVINO_SUPPRESS_DEPRECATED_END
     if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
         params.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
     }

src/tests/functional/shared_test_classes/src/single_layer/minimum_maximum.cpp

@@ -39,7 +39,9 @@ namespace LayerTestsDefinitions {
         }
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
         ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0]))};
+        OPENVINO_SUPPRESS_DEPRECATED_START
         auto secondaryInput = ngraph::builder::makeInputLayer(ngPrc, inputType, {inputShapes[1]});
+        OPENVINO_SUPPRESS_DEPRECATED_END
         if (inputType == ngraph::helpers::InputLayerType::PARAMETER) {
             input.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
         }

src/tests/functional/shared_test_classes/src/single_layer/reverse_sequence.cpp

@@ -41,7 +41,9 @@ void ReverseSequenceLayerTest::SetUp() {
     ov::ParameterVector paramsIn {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
     auto secondPrc = ngraph::element::Type_t::i32; //according to the specification
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto secondaryInput = ngraph::builder::makeInputLayer(secondPrc, secondaryInputType, secondInputShape);
+    OPENVINO_SUPPRESS_DEPRECATED_END
     if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
         paramsIn.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
     }

src/tests/functional/shared_test_classes/src/single_layer/split.cpp

@@ -44,8 +44,10 @@ void SplitLayerTest::SetUp() {
     }
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
+    OPENVINO_SUPPRESS_DEPRECATED_START
     auto split = std::dynamic_pointer_cast<ngraph::opset5::Split>(ngraph::builder::makeSplit(params[0],
                                                                                              ngPrc, numSplits, axis));
+    OPENVINO_SUPPRESS_DEPRECATED_END
     ngraph::ResultVector results;
     for (int i = 0; i < outIndices.size(); i++) {
         results.push_back(std::make_shared<ngraph::opset5::Result>(split->output(outIndices[i])));

src/tests/functional/shared_test_classes/src/subgraph/concat_quantization_during_memory_requantization.cpp

@@ -57,7 +57,9 @@ namespace SubgraphTestsDefinitions {
         auto concat_2 = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{ mem_2_read, mul }, 1);
         // Revert concat names to set the needed order of scale factors calculation
         concat_2->set_friendly_name("concat1");
-        auto split_2 = ngraph::builder::makeSplit(concat_2, ngPrc, 2, 1);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split_2 = std::make_shared<ov::op::v1::Split>(concat_2, split_axis_op, 2);
+
         auto mem_2_write = std::make_shared<ngraph::opset3::Assign>(split_2->output(0), "memory_2");
         auto sigm = std::make_shared<ngraph::opset1::Sigmoid>(split_2->output(1));
 
@@ -93,7 +95,9 @@ namespace SubgraphTestsDefinitions {
 
         auto mem_2_const = std::make_shared<ngraph::op::Constant>(ngPrc, ngraph::Shape{ 1, hiddenSize }, memory_2_init);
         auto concat_2 = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{ mem_2_const, mul }, 1);
-        auto split_2 = ngraph::builder::makeSplit(concat_2, ngPrc, 2, 1);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split_2 = std::make_shared<ov::op::v1::Split>(concat_2, split_axis_op, 2);
+
         auto sigm = std::make_shared<ngraph::opset1::Sigmoid>(split_2->output(1));
 
         function = std::make_shared<ngraph::Function>(sigm, input, "concat_quant_during_memory_requant_nomemory");

src/tests/functional/shared_test_classes/src/subgraph/connect_split_concat_concat.cpp

@@ -27,7 +27,9 @@ void SplitConcatConcatTest::SetUp() {
 
     ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 256})};
     auto relu_start = std::make_shared<ngraph::opset1::Relu>(params[0]);
-    auto split = ngraph::builder::makeSplit(relu_start, ngPrc, 2, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(relu_start, split_axis_op, 2);
+
     auto const_concat = ngraph::builder::makeConstant(ngPrc, {1, 96}, std::vector<float>{0});
     auto const_concat_2 = ngraph::builder::makeConstant(ngPrc, {1, 96}, std::vector<float>{0});
     auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{split->output(0), const_concat}, 1);

src/tests/functional/shared_test_classes/src/subgraph/delayed_copy_layer.cpp

@@ -129,7 +129,8 @@ namespace SubgraphTestsDefinitions {
         auto mem_r = std::make_shared<ngraph::opset3::ReadValue>(mem_c, "id");
         auto reshape_pattern1 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
         auto reshape1 = std::make_shared<ngraph::opset1::Reshape>(mem_r, reshape_pattern1, false);
-        auto split = ngraph::builder::makeSplit(reshape1, ngPrc, 2, 1);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(reshape1, split_axis_op, 2);
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{split->output(0), input[0]}, 1);
         auto reshape_pattern2 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{8, memory_size / 8});
@@ -162,7 +163,8 @@ namespace SubgraphTestsDefinitions {
         auto mem_c = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{1, memory_size}, memory_init);
         auto reshape_pattern1 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
         auto reshape1 = std::make_shared<ngraph::opset1::Reshape>(mem_c, reshape_pattern1, false);
-        auto split = ngraph::builder::makeSplit(reshape1, ngPrc, 2, 1);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(reshape1, split_axis_op, 2);
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{split->output(0), input[0]}, 1);
         auto reshape_pattern2 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{8, memory_size / 8});

src/tests/functional/shared_test_classes/src/subgraph/input_split_concat.cpp

@@ -33,7 +33,9 @@ void InputSplitConcatTest::SetUp() {
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
+
     auto relu1 = std::make_shared<ngraph::opset3::Relu>(split->output(0));
 
     auto const_vals = ov::test::utils::generate_float_numbers(inputShape[1], -5.0f, 5.0f);

src/tests/functional/shared_test_classes/src/subgraph/multiple_connect_split_concat.cpp

@@ -27,7 +27,9 @@ void MultipleConnectSplitConcatTest::SetUp() {
 
     ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 256})};
     auto relu_start = std::make_shared<ngraph::opset1::Relu>(params[0]);
-    auto split = ngraph::builder::makeSplit(relu_start, ngPrc, 1, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(relu_start, split_axis_op, 1);
+
     auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{split->output(0), split->output(0)}, 1);
     auto concat_2 = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{split->output(0), split->output(0)},
                                                              1);

src/tests/functional/shared_test_classes/src/subgraph/relu_split_reshape.cpp

@@ -36,7 +36,9 @@ void ReluSplitReshape::SetUp() {
 
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     auto relu = std::make_shared<ngraph::opset1::Relu>(params[0]);
-    auto split = ngraph::builder::makeSplit(relu, ngPrc, splitNum, splitAxis);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{static_cast<int64_t>(splitAxis)});
+    auto split = std::make_shared<ov::op::v1::Split>(relu, split_axis_op, splitNum);
 
     auto shape = split->get_output_shape(0);
     shape[shape.size() - 2] *= 2;

src/tests/functional/shared_test_classes/src/subgraph/simple_if.cpp

@@ -303,10 +303,12 @@ void SimpleIfNotConstConditionUnusedOutputPortsTest::SetUp() {
 
     const size_t axis = 1;
     const size_t dim = inputDynamicShapes[0][axis].get_length();  // should be static for this test suit
-    auto thenOp = ngraph::builder::makeSplit(p1, inType, dim, axis);
+    auto thenOp_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{axis});
+    auto thenOp = std::make_shared<ov::op::v1::Split>(p1, thenOp_axis_op, dim);
     auto thenRes = std::make_shared<ov::op::v0::Result>(thenOp->output(dim / 2));
 
-    auto elseOp = ngraph::builder::makeSplit(p2, inType, dim, axis);
+    auto elseOp_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{axis});
+    auto elseOp = std::make_shared<ov::op::v1::Split>(p2, elseOp_axis_op, dim);
     auto elseRes = std::make_shared<ov::op::v0::Result>(elseOp->output(dim - 1));
 
     auto thenBody = std::make_shared<ov::Model>(ov::OutputVector{thenRes}, ov::ParameterVector{p1});

src/tests/functional/shared_test_classes/src/subgraph/split_concat_multi_inputs.cpp

@@ -40,7 +40,9 @@ void SplitConcatMultiInputsTest::SetUp() {
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, splitsNum, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, splitsNum);
+
     ngraph::OutputVector concatInputs = split->outputs();
 
     auto concat = std::make_shared<ngraph::opset7::Concat>(concatInputs, 1);

src/tests/functional/shared_test_classes/src/subgraph/split_conv.cpp

@@ -64,7 +64,9 @@ void SplitConvTest::SetUp() {
     ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     const auto splitsNum = 2;
     const auto splitAxis = 1;
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, splitsNum, splitAxis);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{splitAxis});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, splitsNum);
+
     auto relu1 = std::make_shared<ngraph::opset1::Relu>(split->output(0));
 
     auto relu2 = std::make_shared<ngraph::opset1::Relu>(split->output(1));

src/tests/functional/shared_test_classes/src/subgraph/split_conv_concat.cpp

@@ -37,7 +37,8 @@ void SplitConvConcatBase::configure_test(const ov::test::BasicParams& param) {
 
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(inputShape))};
 
-    auto split = ngraph::builder::makeSplit(params[0], element_type, 2, 1);
+    auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
     std::vector<float> filterWeights1;
     std::vector<float> filterWeights2;

src/tests/functional/shared_test_classes/src/subgraph/split_relu.cpp

@@ -33,7 +33,8 @@ namespace SubgraphTestsDefinitions {
         for (auto&& shape : inputs) {
             input.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape)));
         }
-        auto split = ngraph::builder::makeSplit(input[0], ngPrc, 4, 1);
+        auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(input[0], split_axis_op, 4);
         ngraph::ResultVector results;
 
         for (size_t i : connect_index) {

src/tests/functional/shared_test_classes/src/subgraph/split_trivial_permute_concat.cpp

@@ -34,7 +34,9 @@ namespace SubgraphTestsDefinitions {
         configuration.insert(config.begin(), config.end());
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
         ov::ParameterVector input {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
-        auto split = ngraph::builder::makeSplit(input[0], ngPrc, 2, splitAxis);
+        auto split_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{static_cast<int64_t>(splitAxis)});
+        auto split = std::make_shared<ov::op::v1::Split>(input[0], split_axis_op, 2);
 
         auto permute_in_params = std::make_shared<ngraph::opset1::Constant>(ngraph::element::i64,
                                                                             ngraph::Shape{ 4 },

src/tests/ov_helpers/ov_models/include/ov_models/builders.hpp

@@ -80,19 +80,11 @@ std::shared_ptr<ov::Node> makeConstant(const ov::element::Type& type,
     return weightsNode;
 }
 
+OPENVINO_DEPRECATED("This function is deprecated and will be removed soon.")
 std::shared_ptr<ov::Node> makeInputLayer(const element::Type& type,
                                          ov::test::utils::InputLayerType inputType,
                                          const std::vector<size_t>& shape);
 
-std::shared_ptr<ov::Node> makeDynamicInputLayer(const element::Type& type,
-                                                ov::test::utils::InputLayerType inputType,
-                                                const ov::PartialShape& shape);
-
-std::shared_ptr<ov::Node> makeBroadcast(const ov::Output<Node>& in,
-                                        const ov::Output<Node>& target_shape,
-                                        const ov::op::BroadcastType& mode,
-                                        const ov::AxisSet& axis_set = {});
-
 std::shared_ptr<ov::Node> makeConvolution(const ov::Output<Node>& in,
                                           const element::Type& type,
                                           const std::vector<size_t>& filterSize,
@@ -185,19 +177,23 @@ std::shared_ptr<ov::Node> makeConvolutionBackpropData(const ov::Output<Node>& in
                                                       const std::vector<float>& filterWeights = {},
                                                       const std::vector<float>& biasesWeights = {});
 
+OPENVINO_DEPRECATED("This function is deprecated and will be removed soon.")
 std::shared_ptr<ov::Node> makeCTCGreedyDecoder(const ov::Output<Node>& inputData, const bool mergeRepeated);
 
+OPENVINO_DEPRECATED("This function is deprecated and will be removed soon.")
 std::shared_ptr<ov::Node> makeCTCGreedyDecoderSeqLen(const ov::Output<Node>& inputData,
                                                      const ov::Output<Node>& sequenceLength,
                                                      int blankIndex,
                                                      bool mergeRepeated,
                                                      const element::Type& idxPrecision = element::i32);
 
+OPENVINO_DEPRECATED("This function is deprecated and will be removed soon.")
 std::shared_ptr<ov::Node> makeCTCGreedyDecoderSeqLen(const ov::Output<Node>& inputData,
                                                      int blankIndex,
                                                      bool mergeRepeated,
                                                      const element::Type& idxPrecision = element::i32);
 
+OPENVINO_DEPRECATED("This function is deprecated and will be removed soon.")
 std::shared_ptr<ov::Node> makeCTCLoss(const ov::Output<Node>& logitsNode,
                                       std::vector<int>& logitsLength,
                                       std::vector<std::vector<int>>& labels,
@@ -263,6 +259,7 @@ std::shared_ptr<ov::Node> makeBinaryConvolution(const ov::Output<Node>& in,
                                                 float padValue,
                                                 const std::vector<int8_t>& filterWeihgts = {});
 
+OPENVINO_DEPRECATED("This function is deprecated and will be removed soon.")
 std::shared_ptr<ov::Node> makeSplit(const ov::Output<Node>& in,
                                     const element::Type& type,
                                     size_t numSplits,

src/tests/ov_helpers/ov_models/src/broadcast.cpp

@@ -1,26 +0,0 @@
-// Copyright (C) 2018-2023 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#include "openvino/op/broadcast.hpp"
-
-#include <memory>
-#include <vector>
-
-#include "ov_models/builders.hpp"
-
-namespace ngraph {
-namespace builder {
-std::shared_ptr<ov::Node> makeBroadcast(const ov::Output<Node>& in,
-                                        const ov::Output<Node>& target_shape,
-                                        const ov::op::BroadcastType& mode,
-                                        const ov::AxisSet& axisSet) {
-    if (mode == ov::op::BroadcastType::NONE) {
-        auto axisSetConst = ov::op::v0::Constant::create(ov::element::i64, {axisSet.size()}, axisSet.to_vector());
-        return std::make_shared<ov::op::v3::Broadcast>(in, target_shape, axisSetConst, mode);
-    } else {  // numpy/bidirectional modes
-        return std::make_shared<ov::op::v3::Broadcast>(in, target_shape, mode);
-    }
-}
-}  // namespace builder
-}  // namespace ngraph

src/tests/ov_helpers/ov_models/src/input_layer.cpp

@@ -29,19 +29,5 @@ std::shared_ptr<ov::Node> makeInputLayer(const element::Type& type,
     }
     return input;
 }
-
-std::shared_ptr<ov::Node> makeDynamicInputLayer(const element::Type& type,
-                                                ov::test::utils::InputLayerType inputType,
-                                                const PartialShape& shape) {
-    if (shape.is_static()) {
-        return makeInputLayer(type, inputType, shape.get_shape());
-    }
-
-    if (inputType == ov::test::utils::InputLayerType::PARAMETER) {
-        return std::make_shared<ov::op::v0::Parameter>(type, shape);
-    }
-
-    throw std::runtime_error("Could not make input layer. Unsupported inputType for dynamic shape");
-}
 }  // namespace builder
 }  // namespace ngraph

src/tests/ov_helpers/ov_models/src/subgraph_builders.cpp

@@ -237,7 +237,9 @@ std::shared_ptr<ov::Model> makeSplitConvConcat(std::vector<size_t> inputShape, o
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     params.front()->set_friendly_name("Param_1");
     params.front()->get_output_tensor(0).set_names({"input_tensor"});
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
     auto conv1 = ngraph::builder::makeConvolution(split->output(0),
                                                   ngPrc,
@@ -299,7 +301,9 @@ std::shared_ptr<ov::Model> makeSplitMultiConvConcat(std::vector<size_t> inputSha
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     params.front()->set_friendly_name("Param_1");
     params.front()->get_output_tensor(0).set_names({"input_tensor"});
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
     auto conv1_0 = ngraph::builder::makeConvolution(split->output(0),
                                                     ngPrc,
@@ -696,7 +700,9 @@ std::shared_ptr<ov::Model> makeNestedBranchConvConcat(std::vector<size_t> inputS
 
 std::shared_ptr<ov::Model> makeNestedSplitConvConcat(std::vector<size_t> inputShape, ov::element::Type ngPrc) {
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
     auto conv1 = ngraph::builder::makeConvolution(split->output(0),
                                                   ngPrc,
@@ -720,7 +726,9 @@ std::shared_ptr<ov::Model> makeNestedSplitConvConcat(std::vector<size_t> inputSh
                                                   10);
     auto relu2 = std::make_shared<ov::op::v0::Relu>(conv2);
 
-    auto split2 = ngraph::builder::makeSplit(relu2, ngPrc, 2, 1);
+    auto split2_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split2 = std::make_shared<ov::op::v1::Split>(relu2, split2_axis_op, 2);
 
     auto conv3 = ngraph::builder::makeConvolution(split2->output(0),
                                                   ngPrc,
@@ -756,7 +764,9 @@ std::shared_ptr<ov::Model> makeNestedSplitConvConcat(std::vector<size_t> inputSh
 std::shared_ptr<ov::Model> makeSplitConvConcatInputInBranch(std::vector<size_t> inputShape, ov::element::Type ngPrc) {
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
                                std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
 
     auto conv1 = ngraph::builder::makeConvolution(split->output(0),
                                                   ngPrc,
@@ -816,7 +826,10 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranch(std::vector<size_t>
                                std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     int localId = 0;
 #define SET_NAME(node) node->set_friendly_name(#node + std::to_string(localId++));
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
+
     SET_NAME(split);
 
     auto conv1 = ngraph::builder::makeConvolution(split->output(0),
@@ -846,7 +859,10 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranch(std::vector<size_t>
     SET_NAME(relu2);
 
     auto nestedSubgraph = [&] {
-        auto split = ngraph::builder::makeSplit(params[1], ngPrc, 2, 1);
+        auto split_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(params[1], split_axis_op, 2);
+
         SET_NAME(split);
 
         auto conv1 = ngraph::builder::makeConvolution(split->output(0),
@@ -875,7 +891,10 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranch(std::vector<size_t>
         auto relu2 = std::make_shared<ov::op::v0::Relu>(conv2);
         SET_NAME(relu2);
 
-        auto split2 = ngraph::builder::makeSplit(relu2, ngPrc, 2, 1);
+        auto split2_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split2 = std::make_shared<ov::op::v1::Split>(relu2, split2_axis_op, 2);
+
         SET_NAME(split2);
 
         auto conv3 = ngraph::builder::makeConvolution(split2->output(0),
@@ -956,7 +975,10 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranchNestedOut(std::vecto
                                std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
     int localId = 0;
 #define SET_NAME(node) node->set_friendly_name(#node + std::to_string(localId++));
-    auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
+    auto split_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
+
     SET_NAME(split);
 
     auto conv1 = ngraph::builder::makeConvolution(split->output(0),
@@ -985,7 +1007,9 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranchNestedOut(std::vecto
     auto relu2 = std::make_shared<ov::op::v0::Relu>(conv2);
     SET_NAME(relu2);
 
-    auto split3 = ngraph::builder::makeSplit(relu2, ngPrc, 2, 1);
+    auto split3_axis_op =
+        std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+    auto split3 = std::make_shared<ov::op::v1::Split>(relu2, split3_axis_op, 2);
     SET_NAME(split3);
 
     auto conv32 = ngraph::builder::makeConvolution(split3->output(1),
@@ -1002,7 +1026,9 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranchNestedOut(std::vecto
     SET_NAME(relu32);
 
     auto nestedSubgraph = [&] {
-        auto split = ngraph::builder::makeSplit(params[1], ngPrc, 2, 1);
+        auto split_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(params[1], split_axis_op, 2);
         SET_NAME(split);
 
         auto conv1 = ngraph::builder::makeConvolution(split->output(0),
@@ -1031,7 +1057,9 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranchNestedOut(std::vecto
         auto relu2 = std::make_shared<ov::op::v0::Relu>(conv2);
         SET_NAME(relu2);
 
-        auto split2 = ngraph::builder::makeSplit(relu2, ngPrc, 2, 1);
+        auto split2_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split2 = std::make_shared<ov::op::v1::Split>(relu2, split2_axis_op, 2);
         SET_NAME(split2);
 
         auto conv3 = ngraph::builder::makeConvolution(split2->output(0),
@@ -1083,7 +1111,9 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranchNestedOut(std::vecto
     }();
 
     auto nestedSubgraph1 = [&] {
-        auto split = ngraph::builder::makeSplit(relu32, ngPrc, 2, 1);
+        auto split_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split = std::make_shared<ov::op::v1::Split>(relu32, split_axis_op, 2);
         SET_NAME(split);
 
         auto conv1 = ngraph::builder::makeConvolution(split->output(0),
@@ -1112,7 +1142,9 @@ std::shared_ptr<ov::Model> makeSplitConvConcatNestedInBranchNestedOut(std::vecto
         auto relu2 = std::make_shared<ov::op::v0::Relu>(conv2);
         SET_NAME(relu2);
 
-        auto split2 = ngraph::builder::makeSplit(relu2, ngPrc, 2, 1);
+        auto split2_axis_op =
+            std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
+        auto split2 = std::make_shared<ov::op::v1::Split>(relu2, split2_axis_op, 2);
         SET_NAME(split2);
 
         auto conv3 = ngraph::builder::makeConvolution(split2->output(0),

src/tests/ov_helpers/ov_snippets_models/src/subgraph_mha.cpp

@@ -376,8 +376,7 @@ std::shared_ptr<ov::Model> MHASelectFunction::initOriginal() const {
     if (add->get_output_partial_shape(0) != input_shapes[3]) {
         const auto broadcast_shape = ngraph::builder::makeConstant(ngraph::element::i64, constantShapes[5],
                                                                    add->get_output_shape(0));
-        const auto broadcast = ngraph::builder::makeBroadcast(selectCond, broadcast_shape,
-                                                              ngraph::op::BroadcastType::NUMPY);
+        const auto broadcast = std::make_shared<ov::op::v3::Broadcast>(selectCond, broadcast_shape, ov::op::BroadcastType::NUMPY);
         selectCond = broadcast;
     }
     const auto select = std::make_shared<ngraph::opset1::Select>(selectCond, selectConst, add,