Remove makeDynamicParams (#19226)

* Remove makeDynamicParams

* Apply comments

* Fix1

* Fix2

* Fix3

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

@@ -102,7 +102,7 @@ protected:
     }
 
     std::shared_ptr<ngraph::Function> createFunction(bool secondInputConst) {
-        auto params = ngraph::builder::makeDynamicParams(ngraph::element::f32, { inputDynamicShapes[0] });
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, inputDynamicShapes[0])};
         params.front()->set_friendly_name("ParamsInput");
         std::shared_ptr<ov::Node> secondInput;
         if (secondInputConst) {

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

@@ -93,7 +93,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         std::vector<ngraph::Shape> WRB = {{3 * hiddenSize, inputSize}, {3 * hiddenSize, hiddenSize}, {(linearBeforeReset ? 4 : 3) * hiddenSize}};
         auto augruCellOp = ngraph::builder::makeAUGRU(
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params)), WRB, hiddenSize/*, activations, {}, {}, clip, linearBeforeReset*/);

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

@@ -104,7 +104,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         const size_t batchSize = inputDynamicShapes[0][0].is_static() ? inputDynamicShapes[0][0].get_length() :
             inputDynamicShapes[1][0].is_static() ? inputDynamicShapes[1][0].get_length() :
             inputDynamicShapes.size() > 2 && inputDynamicShapes[2][0].is_static() ? inputDynamicShapes[2][0].get_length() :

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

@@ -109,7 +109,7 @@ protected:
         else
             selectedType = std::string("ref_any_") + netPrecision.name();
 
-        auto params = ngraph::builder::makeDynamicParams(ngPrec, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrec, inputDynamicShapes.front())};
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         paramShape = {paramOuts[0].get_partial_shape().size()};
 

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

@@ -121,10 +121,10 @@ void ActivationLayerCPUTest::SetUp() {
     init_input_shapes(inputShapes);
 
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-    auto params = ngraph::builder::makeDynamicParams(ngPrc, {inputDynamicShapes.front()});
+    auto params = std::make_shared<ov::op::v0::Parameter>(ngPrc, inputDynamicShapes.front());
-    auto activation = ngraph::builder::makeActivation(params[0], ngPrc, activationType, activationShapes, constantsValue);
+    auto activation = ngraph::builder::makeActivation(params, ngPrc, activationType, activationShapes, constantsValue);
     activation->get_rt_info() = getCPUInfo();
-    function = std::make_shared<ngraph::Function>(ngraph::NodeVector{activation}, params, "Activation");
+    function = std::make_shared<ngraph::Function>(ngraph::NodeVector{activation}, ov::ParameterVector{params}, "Activation");
 }
 
 TEST_P(ActivationLayerCPUTest, CompareWithRefs) {

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

@@ -79,7 +79,10 @@ void ConvertCPULayerTest::SetUp() {
 
     auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrc);
     auto targetPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(outPrc);
-    ParameterVector params = builder::makeDynamicParams(ngPrc, inputDynamicShapes);
+    ov::ParameterVector params;
+    for (auto&& shape : inputDynamicShapes) {
+        params.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
+    }
     auto conversion = ngraph::builder::makeConversion(params.front(), targetPrc, helpers::ConversionTypes::CONVERT);
 
     function = makeNgraphFunction(ngPrc, params, conversion, "ConversionCPU");

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

@@ -126,11 +126,12 @@ void EltwiseLayerCPUTest::SetUp() {
     }
 #endif
 
-    auto parameters = ngraph::builder::makeDynamicParams(netType, {inputDynamicShapes.front()});
+    ov::ParameterVector parameters{std::make_shared<ov::op::v0::Parameter>(netType, inputDynamicShapes.front())};
     std::shared_ptr<ngraph::Node> secondaryInput;
     if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
-        secondaryInput = ngraph::builder::makeDynamicParams(netType, {inputDynamicShapes.back()}).front();
+        auto param = std::make_shared<ov::op::v0::Parameter>(netType, inputDynamicShapes.back());
-        parameters.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
+        secondaryInput = param;
+        parameters.push_back(param);
     } else {
         auto pShape = inputDynamicShapes.back();
         ngraph::Shape shape;

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

@@ -99,9 +99,12 @@ void MvnLayerCPUTest::SetUp() {
 
     init_input_shapes({inputShapes});
 
-    auto param = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+    ov::ParameterVector params;
+    for (auto&& shape : inputDynamicShapes) {
+        params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+    }
     auto paramOuts =
-        ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(param));
+        ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
     auto mvn = ngraph::builder::makeMVN(paramOuts[0], acrossChanels, normalizeVariance, eps);
     if (!axes.empty()) {
         mvn = ngraph::builder::makeMVN(paramOuts[0], axes, normalizeVariance, eps);
@@ -116,7 +119,7 @@ void MvnLayerCPUTest::SetUp() {
     configuration.insert(additionalConfig.begin(), additionalConfig.end());
     updateSelectedType(getPrimitiveType(), netPrecision, configuration);
 
-    function = makeNgraphFunction(netPrecision, param, mvn, "mvn");
+    function = makeNgraphFunction(netPrecision, params, mvn, "mvn");
 }
 
 TEST_P(MvnLayerCPUTest, CompareWithRefs) {

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

@@ -94,7 +94,10 @@ void ReduceCPULayerTest::SetUp() {
 
     init_input_shapes(inputShapes);
 
-    auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+    ov::ParameterVector params;
+    for (auto&& shape : inputDynamicShapes) {
+        params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+    }
     auto paramOuts =
         ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
 

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

@@ -59,15 +59,15 @@ void TransposeLayerCPUTest::SetUp() {
 
     init_input_shapes({inputShapes});
 
-    auto params = ngraph::builder::makeDynamicParams(inType, {inputDynamicShapes[0]});
+    auto params = std::make_shared<ov::op::v0::Parameter>(inType, inputDynamicShapes[0]);
 
     const auto inputOrderOp =
         std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape({inputOrder.size()}), inputOrder);
-    const auto transpose = std::make_shared<ov::op::v1::Transpose>(params[0], inputOrderOp);
+    const auto transpose = std::make_shared<ov::op::v1::Transpose>(params, inputOrderOp);
     transpose->get_rt_info() = getCPUInfo();
     const ov::ResultVector results{std::make_shared<ov::op::v0::Result>(transpose)};
 
-    function = std::make_shared<ngraph::Function>(results, params, "TransposeLayerCPUTest");
+    function = std::make_shared<ngraph::Function>(results, ov::ParameterVector{params}, "TransposeLayerCPUTest");
     functionRefs = ngraph::clone_function(*function);
 }
 

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

@@ -78,7 +78,10 @@ protected:
 
         init_input_shapes(inputShape);
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(
                 ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         auto concat = std::make_shared<ngraph::opset1::Concat>(paramOuts, axis);

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

@@ -199,7 +199,10 @@ protected:
         size_t convOutChannels;
         std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType) = convParams;
 
-        auto inputParams = ngraph::builder::makeDynamicParams(ngraph::element::f32, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ov::element::f32, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
 
         auto convolutionNode = ngraph::builder::makeConvolution(paramOuts.front(), netType, kernel, stride, padBegin,

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

@@ -168,7 +168,7 @@ public:
     }
 
     std::shared_ptr<ov::Model> createGraph(const std::vector<ov::PartialShape>& inShapes, ngraph::helpers::InputLayerType outShapeType) {
-        auto params = ngraph::builder::makeDynamicParams(prec, {inShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(prec, inShapes.front())};
         std::shared_ptr<ov::Node> outShapeNode;
         if (!outShapeData.empty()) {
             if (outShapeType == ngraph::helpers::InputLayerType::PARAMETER) {

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

@@ -82,7 +82,10 @@ protected:
             targetStaticShapes.push_back({{T, N, C}, {T, N}});
         }
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto ctcGreedyDecoder = std::make_shared<ov::op::v0::CTCGreedyDecoder>(params[0], params[1], mergeRepeated);
 
         ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(ctcGreedyDecoder)};

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

@@ -33,16 +33,6 @@ using CTCGreedyDecoderSeqLenLayerCPUTestParams = std::tuple<InputShapeParams,
                                                             ElementType,         // Index Type
                                                             bool                 // mergeRepeated
                                                             >;
-inline ngraph::ParameterVector makeDynamicParams(const std::vector<ElementType>& types,
-                                          const std::vector<ov::PartialShape>& shapes) {
-    ngraph::ParameterVector outs;
-    NGRAPH_CHECK(types.size() == shapes.size());
-    for (size_t i = 0; i < types.size(); i++) {
-        auto paramNode = std::make_shared<ov::op::v0::Parameter>(types[i], shapes[i]);
-        outs.push_back(paramNode);
-    }
-    return outs;
-}
 
 class CTCGreedyDecoderSeqLenLayerCPUTest : public testing::WithParamInterface<CTCGreedyDecoderSeqLenLayerCPUTestParams>,
                                            virtual public SubgraphBaseTest,
@@ -95,6 +85,7 @@ protected:
         inputDynamicShapes = {ov::PartialShape{in_dyn_N, in_dyn_T, in_dyc_C},
                               ov::PartialShape{in_dyn_N},
                               blank_rank == 0 ? ov::PartialShape{} : ov::PartialShape{1}};
+        OPENVINO_ASSERT(inType.size() == inputDynamicShapes.size());
 
         for (auto& shape : shapes.second) {
             size_t N;
@@ -107,7 +98,11 @@ protected:
                 targetStaticShapes.push_back({{N, T, C}, {N}, {1}});
         }
 
-        auto params = makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (size_t i = 0; i < inType.size(); i++) {
+            auto param_node = std::make_shared<ov::op::v0::Parameter>(inType[i], inputDynamicShapes[i]);
+            params.push_back(param_node);
+        }
         auto ctcGreedyDecoderSeqLen = std::make_shared<ov::op::v6::CTCGreedyDecoderSeqLen>(params[0],
                                                                                            params[1],
                                                                                            params[2],

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

@@ -96,7 +96,11 @@ protected:
         std::vector<ngraph::element::Type> types{fPrecision, iPrecision, iPrecision, iPrecision};
         std::vector<ov::PartialShape> partialShapes{inputDynamicShapesValues, shapeN, shapeNT, shapeN};
 
-        auto params = ngraph::builder::makeDynamicParams(types, partialShapes);
+        ov::ParameterVector params;
+        for (size_t i = 0; i < types.size(); i++) {
+            auto param_node = std::make_shared<ov::op::v0::Parameter>(types[i], partialShapes[i]);
+            params.push_back(param_node);
+        }
         auto bankNode = ngraph::op::Constant::create(ngraph::element::i64, ngraph::Shape{ }, {blank});
 
         auto ctcLoss = std::make_shared<ngraph::opset4::CTCLoss>(params[0], params[1], params[2],

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

@@ -57,7 +57,10 @@ protected:
         selectedType = makeSelectedTypeStr("ref_any", inType);
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto axisNode = ngraph::opset1::Constant::create(ngraph::element::i32, ngraph::Shape{}, std::vector<int64_t>{axis})->output(0);
         auto cumSum = ngraph::builder::makeCumSum(params[0], axisNode, exclusive, reverse);
 

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

@@ -85,8 +85,11 @@ protected:
         InputShape inputShapes{{-1, -1, -1}, {{10, 5, 3}, {16, 24, 16}, {4, 8, 12}}};
 
         init_input_shapes({inputShapes});
-        auto ngPrc = ngraph::element::f32;
+        ov::ParameterVector inputParams;
-        auto inputParams = ngraph::builder::makeDynamicParams(ngPrc, inputDynamicShapes);
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, shape));
+        }
+
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
         auto customOp = std::make_shared<CustomOp>(paramOuts);
         auto shapeOf = std::make_shared<ov::opset10::ShapeOf>(customOp->output(1));

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

@@ -156,8 +156,10 @@ protected:
         bool withBilinearInterpolationPad, withModulation;
         std::tie(withBilinearInterpolationPad, withModulation, offsetType) = dcSpecificParams;
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        auto inputParams = ngraph::builder::makeDynamicParams(ngPrc, inputDynamicShapes);
+        ov::ParameterVector inputParams;
-
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
+        }
         auto data = inputParams[0];
         data->set_friendly_name("a_data");
         auto offset_vals = inputParams[1];

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

@@ -71,7 +71,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto d2s = ngraph::builder::makeDepthToSpace(params[0], mode, blockSize);
         function = makeNgraphFunction(inType, params, d2s, "DepthToSpace");
     }

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

@@ -199,7 +199,10 @@ public:
 
         init_input_shapes({ inShapes });
 
-        auto params = ngraph::builder::makeDynamicParams(ngraph::element::f32, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(ov::element::f32, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::opset3::Parameter>(params));
         auto detOut = ngraph::builder::makeDetectionOutput(paramOuts, attrs);
         ngraph::ResultVector results{std::make_shared<ngraph::opset3::Result>(detOut)};

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

@@ -60,7 +60,10 @@ protected:
 
         init_input_shapes({ inputShapes });
 
-        auto params = ngraph::builder::makeDynamicParams(inputPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
         auto extImgPatches = std::make_shared<ngraph::opset3::ExtractImagePatches>(params[0], kernelSize, strides, rates, padType);
         function = makeNgraphFunction(inputPrecision, params, extImgPatches, "ExtractImagePatches");
     }

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

@@ -84,7 +84,10 @@ protected:
     }
 
     std::shared_ptr<ngraph::Function> createFunction() {
-        auto inputParams = ngraph::builder::makeDynamicParams(ngraph::element::i32, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ov::element::i32, shape));
+        }
         auto rowsPar = inputParams[0];
         rowsPar->set_friendly_name("rows");
         auto colsPar = inputParams[1];

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

@@ -111,7 +111,10 @@ protected:
         std::tie(inDataLowBounds, inDataHighBounds, rangesBounds[2], rangesBounds[3], levels) = fqParams;
 
         auto ngInPrec = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
-        ParameterVector params = builder::makeDynamicParams(ngInPrec, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(ngInPrec, shape));
+        }
         auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset5::Parameter>(params));
 
         auto il = builder::makeConstant(ngInPrec, ranges[0], rangesBounds[0], rangesBounds[0].empty());

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

@@ -55,7 +55,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(dataElementType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(dataElementType, shape));
+        }
         auto indexes_node = ngraph::opset3::Constant::create(idxElementType, indexes.first, indexes.second);
         auto gather_nd = std::make_shared<ngraph::opset5::GatherND>(params[0], indexes_node, batchDims);
         ngraph::ResultVector results{std::make_shared<ngraph::opset3::Result>(gather_nd)};
@@ -81,7 +84,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(dataElementType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(dataElementType, shape));
+        }
         auto indexes_node = ngraph::opset3::Constant::create(idxElementType, indexes.first, indexes.second);
         auto gather_nd = std::make_shared<ngraph::opset8::GatherND>(params[0], indexes_node, batchDims);
         ngraph::ResultVector results{std::make_shared<ngraph::opset3::Result>(gather_nd)};

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

@@ -86,7 +86,7 @@ protected:
         std::shared_ptr<ngraph::Node> inp3;
         std::shared_ptr<ngraph::Node> inp4;
 
-        auto paramsIn = ngraph::builder::makeDynamicParams(netPrecision, {inputDynamicShapes[0]});
+        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]);

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

@@ -99,7 +99,8 @@ protected:
             rel_threshold = 0.01f;
         }
 
-        auto params = ngraph::builder::makeDynamicParams({dataPrecision, gridPrecision}, inputDynamicShapes);
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(dataPrecision, inputDynamicShapes[0]),
+                                   std::make_shared<ov::op::v0::Parameter>(gridPrecision, inputDynamicShapes[1])};
         params[0]->set_friendly_name("data");
         params[1]->set_friendly_name("grid");
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));

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

@@ -67,8 +67,10 @@ protected:
 
         init_input_shapes({inputShape});
 
-        const auto paramsIn = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector paramsIn;
-
+        for (auto&& shape : inputDynamicShapes) {
+            paramsIn.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         const auto paramsOut = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(paramsIn));
         const auto grn = std::make_shared<ngraph::opset1::GRN>(paramsOut[0], bias);
         const ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(grn)};

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

@@ -192,7 +192,10 @@ protected:
         size_t convOutChannels, numGroups;
         std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, numGroups, padType) = groupConvParams;
 
-        auto params = ngraph::builder::makeDynamicParams(netType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netType, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(
                 ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         auto groupConv = std::dynamic_pointer_cast<ngraph::opset1::GroupConvolution>(

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

@@ -167,7 +167,7 @@ public:
     }
 
     std::shared_ptr<ov::Model> createGraph(const std::vector<ov::PartialShape>& inShapes, ngraph::helpers::InputLayerType outShapeType) {
-        auto params = ngraph::builder::makeDynamicParams(prec, {inShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(prec, inShapes.front())};
         std::shared_ptr<ov::Node> outShapeNode;
         if (!outShapeData.empty()) {
             if (outShapeType == ngraph::helpers::InputLayerType::PARAMETER) {

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

@@ -93,7 +93,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         std::vector<ngraph::Shape> WRB = {{3 * hiddenSize, inputSize}, {3 * hiddenSize, hiddenSize}, {(linearBeforeReset ? 4 : 3) * hiddenSize}};
         auto gruCellOp = ngraph::builder::makeGRU(
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params)), WRB, hiddenSize, activations, {}, {}, clip, linearBeforeReset);

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

@@ -104,7 +104,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         const size_t batchSize = inputDynamicShapes[0][0].is_static() ? inputDynamicShapes[0][0].get_length() :
             inputDynamicShapes[1][0].is_static() ? inputDynamicShapes[1][0].get_length() :
             inputDynamicShapes.size() > 2 && inputDynamicShapes[2][0].is_static() ? inputDynamicShapes[2][0].get_length() :

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

@@ -214,8 +214,7 @@ protected:
 
         init_input_shapes(inputShapes);
 
-        auto params = ngraph::builder::makeDynamicParams(ngPrc, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, inputDynamicShapes.front())};
-
         std::shared_ptr<ov::Node> sizesInput, scalesInput;
         if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) {
             if (shapeInputType == ngraph::helpers::InputLayerType::PARAMETER) {

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

@@ -64,7 +64,7 @@ protected:
         selectedType = std::string("unknown_") + netPrecision.name();
         init_input_shapes(inputShapes);
 
-        const auto params = ngraph::builder::makeDynamicParams(ngPrc, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, inputDynamicShapes.front())};
         const auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         const auto logSoftmax = std::make_shared<ngraph::op::v5::LogSoftmax>(paramOuts[0], axis);
         const ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(logSoftmax)};

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

@@ -95,8 +95,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes(shapes);
 
-        auto params = ngraph::builder::makeDynamicParams(netType, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netType, shape));
+        }
         // Set up the cell body, a function from (Xi, Yi) -> (Zo)
         // Body parameters
         const std::vector<ngraph::PartialShape> body_params_shapes(shapes.size(), ngraph::PartialShape::dynamic());
@@ -177,8 +179,10 @@ protected:
         for (auto& target : targetStaticShapes)
             target.insert(target.begin(), ngraph::Shape{});
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         // Body parameters
         const std::vector<ngraph::PartialShape> body_params_shapes(shapes.size(), ngraph::PartialShape::dynamic());
         ngraph::ParameterVector body_params = { std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i64, ngraph::Shape{}) };
@@ -246,8 +250,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes(shapes);
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         // Set up the cell body, a function from (Xi, Yi) -> (Zo)
         // Body parameters
         const std::vector<ngraph::PartialShape> body_params_shapes(shapes.size(), ngraph::PartialShape::dynamic());
@@ -317,12 +323,16 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes(shapes);
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         // Body parameters
         const std::vector<ngraph::PartialShape> body_params_shapes(shapes.size(), ngraph::PartialShape::dynamic());
-        auto body_params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector body_params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            body_params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto body_condition_const = std::make_shared<ngraph::opset5::Constant>(ngraph::element::boolean, ngraph::Shape{1}, true);
         auto exec_condition = std::make_shared<ngraph::opset5::Constant>(ngraph::element::boolean, ngraph::Shape{1}, exec_cond);
         std::shared_ptr<ngraph::Node> trip_count_input;

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

@@ -55,7 +55,10 @@ protected:
         init_input_shapes({ inputShapes });
         selectedType = makeSelectedTypeStr("ref_any", inputPrecision);
 
-        auto params = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes });
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
         auto axesNode = ngraph::opset1::Constant::create(ngraph::element::i32, { axes.size() }, axes);
         auto lrn = std::make_shared<ngraph::opset3::LRN>(params[0], axesNode, alpha, beta, bias, size);
         function = makeNgraphFunction(inputPrecision, params, lrn, "LRN");

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

@@ -92,7 +92,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         auto paramsOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
         std::vector<ngraph::Shape> WRB = {{4 * hiddenSize, inputSize}, {4 * hiddenSize, hiddenSize}, {4 * hiddenSize}};
         auto lstmCellOp = ngraph::builder::makeLSTM(paramsOuts, WRB, hiddenSize, activations, {}, {}, clip);

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

@@ -111,7 +111,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         const size_t batchSize = inputDynamicShapes[0][0].is_static() ? inputDynamicShapes[0][0].get_length() :
             inputDynamicShapes[1][0].is_static() ? inputDynamicShapes[1][0].get_length() :
             inputDynamicShapes[2][0].is_static() ? inputDynamicShapes[2][0].get_length() :

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

@@ -158,7 +158,7 @@ protected:
         cpuNodeType = nodeType == MatMulNodeType::MatMul ? "MatMul" : "FullyConnected";
         selectedType = makeSelectedTypeStr(selectedType, outType);
 
-        auto params = builder::makeDynamicParams(netType, {inShapeA});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netType, inShapeA)};
 
         auto matrixB = builder::makeDynamicInputLayer(netType, secondaryInputType, inShapeB);
         if (secondaryInputType == helpers::InputLayerType::PARAMETER) {

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

@@ -129,11 +129,11 @@ protected:
                                             bool transpose_b,
                                             const std::vector<int8_t>& weiData) {
         using namespace ngraph;
-        auto inputParamsFP32 = builder::makeDynamicParams(element::f32, {A.get_partial_shape()});
+        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 matMulRelaxed = std::make_shared<ov::op::TypeRelaxed<opset3::MatMul>>(
-            *as_type_ptr<opset3::MatMul>(builder::makeMatMul(inputParamsFP32[0], matrixBFP32, transpose_a, transpose_b)),
+            *as_type_ptr<opset3::MatMul>(builder::makeMatMul(inputParamsFP32, matrixBFP32, transpose_a, transpose_b)),
             element::f32);
 
         auto matrixB = ngraph::builder::makeConstant<int8_t>(weiType, inShapeB.get_shape(), weiData);
@@ -189,7 +189,7 @@ protected:
         cpuNodeType = "FullyConnected";
         selectedType = makeSelectedTypeStr(selectedType, element::i8);
 
-        auto params = builder::makeDynamicParams(inType, {inShapeA});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(inType, inShapeA)};
         auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset1::Parameter>(params));
 
         auto matrixB = builder::makeDynamicInputLayer(element::f32, helpers::InputLayerType::CONSTANT, inShapeB);

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

@@ -147,7 +147,10 @@ protected:
         }
 
         std::shared_ptr<ngraph::Node> maxOutBoxesPerClassNode;
-        auto params = ngraph::builder::makeDynamicParams(paramsPrec, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(paramsPrec, shape));
+        }
         params[0]->set_friendly_name("param_1");
         params[1]->set_friendly_name("param_2");
 

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

@@ -82,7 +82,10 @@ protected:
         std::tie(startFrom, range) = genData;
 
         init_input_shapes({inputShape});
-        auto inputParams = ngraph::builder::makeDynamicParams(netType, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(netType, shape));
+        }
 
         auto nonZero = std::make_shared<ngraph::opset3::NonZero>(inputParams[0]);
         // I8 was used as a special placeholder during calculating of primitive type if input was U8,

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

@@ -74,7 +74,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto normalize = builder::makeNormalizeL2(params[0], axes, eps, epsMode);
         function = makeNgraphFunction(inType, params, normalize, "Normalize");
     }

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

@@ -129,7 +129,7 @@ protected:
         compare(expectedOutputs, actualOutputs);
     }
     std::shared_ptr<ngraph::Function> createFunction(bool depthConst) {
-        auto params = ngraph::builder::makeDynamicParams(ngraph::element::i32, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngraph::element::i32, inputDynamicShapes.front())};
         params.front()->set_friendly_name("ParamsIndices");
         std::shared_ptr<ov::Node> depth;
         if (depthConst) {

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

@@ -94,7 +94,10 @@ protected:
             targetShapes.push_back({padsEnd.size()});
             targetShapes.push_back({});
         }
-        auto params = ngraph::builder::makeDynamicParams(dataType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(dataType, shape));
+        }
         std::shared_ptr<ov::Node> pad;
         if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
             ov::Shape inShape = {padsBegin.size()};

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

@@ -108,8 +108,10 @@ protected:
 
         init_input_shapes({inputShapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inPrc, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inPrc, shape));
+        }
         std::shared_ptr<ngraph::Node> poolInput = params[0];
         if (isInt8) {
             ov::Shape newShape(poolInput->get_output_partial_shape(0).size(), 1);
@@ -194,7 +196,10 @@ protected:
 
         init_input_shapes({inputShapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inPrc, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inPrc, shape));
+        }
         std::shared_ptr<ngraph::Node> pooling = ngraph::builder::makeMaxPoolingV8(params[0], stride, dilation, padBegin, padEnd,
                                                                                   kernel, roundingType, padType,
                                                                                   indexElementType, axis);

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

@@ -137,8 +137,10 @@ protected:
             attributes.variance,
             attributes.scale_all_sizes) = specParams;
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         auto shape_of_1 = std::make_shared<ngraph::opset3::ShapeOf>(params[0]);
         auto shape_of_2 = std::make_shared<ngraph::opset3::ShapeOf>(params[1]);
         auto priorBox = std::make_shared<ngraph::op::PriorBox>(

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

@@ -124,8 +124,10 @@ protected:
             attributes.offset,
             attributes.variances) = specParams;
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, { inputShapes.first, imageShapes.first });
+        ov::ParameterVector params;
-
+        for (auto&& shape : { inputShapes.first, imageShapes.first }) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         auto shape_of_1 = std::make_shared<ngraph::opset3::ShapeOf>(params[0]);
         auto shape_of_2 = std::make_shared<ngraph::opset3::ShapeOf>(params[1]);
         auto priorBoxClustered = std::make_shared<ngraph::op::PriorBoxClustered>(

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

@@ -139,7 +139,10 @@ protected:
         init_input_shapes(inputShapes);
 
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        auto params = ngraph::builder::makeDynamicParams(ngPrc, {inputDynamicShapes[0], inputDynamicShapes[1], inputDynamicShapes[2]});
+        ov::ParameterVector params;
+        for (auto&& shape : {inputDynamicShapes[0], inputDynamicShapes[1], inputDynamicShapes[2]}) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
 
         ngraph::op::ProposalAttrs attrs;

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

@@ -79,8 +79,10 @@ protected:
         configuration.insert(additionalConfig.begin(), additionalConfig.end());
 
         selectedType = getPrimitiveType() + "_" + InferenceEngine::details::convertPrecision(inPrc).name();
-        auto paramRegionYolo = ngraph::builder::makeDynamicParams(inPrc, inputDynamicShapes);
+        ov::ParameterVector paramRegionYolo;
-
+        for (auto&& shape : inputDynamicShapes) {
+            paramRegionYolo.push_back(std::make_shared<ov::op::v0::Parameter>(inPrc, shape));
+        }
         const auto region_yolo = std::make_shared<ngraph::op::v0::RegionYolo>(paramRegionYolo[0],
                                                                               attributes.coordinates, attributes.classes, attributes.num_regions,
                                                                               attributes.do_softmax, mask, attributes.start_axis, attributes.end_axis);

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

@@ -70,7 +70,7 @@ protected:
         init_input_shapes({dataInputShape, seqLengthsShape});
 
         const auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        auto paramsIn = ngraph::builder::makeDynamicParams(ngPrc, {inputDynamicShapes[0]});
+        ov::ParameterVector paramsIn{std::make_shared<ov::op::v0::Parameter>(ngPrc, inputDynamicShapes[0])};
 
         constexpr auto seqLengthsPrc = ngraph::element::Type_t::i32; //according to the specification
         std::shared_ptr<ngraph::Node> seqLengthsInput;

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

@@ -88,7 +88,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, netPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         auto paramsOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
         std::vector<ov::Shape> WRB = {{hiddenSize, inputSize}, {hiddenSize, hiddenSize}, {hiddenSize}};
         auto rnnCellOp = ngraph::builder::makeRNN(paramsOuts, WRB, hiddenSize, activations, {}, {}, clip);

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

@@ -106,7 +106,10 @@ protected:
             rel_threshold = 1e-4;
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+            ov::ParameterVector params;
+            for (auto&& shape : inputDynamicShapes) {
+                params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+            }
         const size_t batchSize = inputDynamicShapes[0][0].is_static() ? inputDynamicShapes[0][0].get_length() :
             inputDynamicShapes[1][0].is_static() ? inputDynamicShapes[1][0].get_length() :
             inputDynamicShapes.size() > 2 && inputDynamicShapes[2][0].is_static() ? inputDynamicShapes[2][0].get_length() :

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

@@ -205,7 +205,10 @@ protected:
         init_input_shapes(inputShapes);
 
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        auto params = ngraph::builder::makeDynamicParams(ngPrc, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(
             ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
 

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

@@ -147,12 +147,15 @@ protected:
 
         init_input_shapes(inputShapes);
 
-        auto float_params = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes[0], inputDynamicShapes[1] });
+        ov::ParameterVector float_params;
-        auto int_params = ngraph::builder::makeDynamicParams(ngraph::element::i32, { inputDynamicShapes[2] });
+        for (auto&& shape : { inputDynamicShapes[0], inputDynamicShapes[1] }) {
+            float_params.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
+        auto int_param = std::make_shared<ov::op::v0::Parameter>(ngraph::element::i32, inputDynamicShapes[2]);
         auto pooling_mode = ngraph::EnumNames<ngraph::opset9::ROIAlign::PoolingMode>::as_enum(mode);
         auto aligned_mode = ngraph::EnumNames<ngraph::opset9::ROIAlign::AlignedMode>::as_enum(alignedMode);
 
-        auto roialign = std::make_shared<ngraph::opset9::ROIAlign>(float_params[0], float_params[1], int_params[0], pooledH, pooledW,
+        auto roialign = std::make_shared<ngraph::opset9::ROIAlign>(float_params[0], float_params[1], int_param, pooledH, pooledW,
                                                                    samplingRatio, spatialScale, pooling_mode, aligned_mode);
 
         selectedType = makeSelectedTypeStr(selectedType, inputPrecision);
@@ -160,7 +163,7 @@ protected:
             rel_threshold = 1e-2;
         }
 
-        ngraph::ParameterVector params{ float_params[0], float_params[1], int_params[0] };
+        ngraph::ParameterVector params{ float_params[0], float_params[1], int_param };
         function = makeNgraphFunction(inputPrecision, params, roialign, "ROIAlign");
     }
 };

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

@@ -54,8 +54,10 @@ protected:
 
         init_input_shapes({inputShape});
 
-        const auto paramsIn = ngraph::builder::makeDynamicParams(inputPrecision, inputDynamicShapes);
+        ov::ParameterVector paramsIn;
-
+        for (auto&& shape : inputDynamicShapes) {
+            paramsIn.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
         auto shiftNode = std::make_shared<ngraph::op::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{shift.size()}, shift)->output(0);
         auto axesNode = std::make_shared<ngraph::op::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{axes.size()}, axes)->output(0);
 

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

@@ -101,15 +101,18 @@ protected:
         init_input_shapes(inputShapes);
         selectedType = makeSelectedTypeStr("unknown", inputPrecision);
 
-        auto dataParams = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes[0], inputDynamicShapes[2] });
+        ov::ParameterVector dataParams;
-        auto indicesParam = ngraph::builder::makeDynamicParams(idxPrecision, { inputDynamicShapes[1] });
+        for (auto&& shape : { inputDynamicShapes[0], inputDynamicShapes[2] }) {
+            dataParams.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
+        auto indicesParam = std::make_shared<ov::op::v0::Parameter>(idxPrecision, inputDynamicShapes[1]);
         dataParams[0]->set_friendly_name("Param_1");
-        indicesParam[0]->set_friendly_name("Param_2");
+        indicesParam->set_friendly_name("Param_2");
         dataParams[1]->set_friendly_name("Param_3");
 
-        auto scatter = std::make_shared<ngraph::opset4::ScatterNDUpdate>(dataParams[0], indicesParam[0], dataParams[1]);
+        auto scatter = std::make_shared<ngraph::opset4::ScatterNDUpdate>(dataParams[0], indicesParam, dataParams[1]);
 
-        ngraph::ParameterVector allParams{ dataParams[0], indicesParam[0], dataParams[1] };
+        ngraph::ParameterVector allParams{ dataParams[0], indicesParam, dataParams[1] };
         function = makeNgraphFunction(inputPrecision, allParams, scatter, "ScatterNDUpdateLayerCPUTest");
     }
 };

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

@@ -105,16 +105,19 @@ protected:
         init_input_shapes(inputShapes);
         selectedType = makeSelectedTypeStr("unknown", inputPrecision);
 
-        auto dataParams = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes[0], inputDynamicShapes[2] });
+        ov::ParameterVector dataParams;
-        auto indicesParam = ngraph::builder::makeDynamicParams(idxPrecision, { inputDynamicShapes[1] });
+        for (auto&& shape : { inputDynamicShapes[0], inputDynamicShapes[2] }) {
+            dataParams.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
+        auto indicesParam = std::make_shared<ov::op::v0::Parameter>(idxPrecision, inputDynamicShapes[1]);
         dataParams[0]->set_friendly_name("Param_1");
-        indicesParam[0]->set_friendly_name("Param_2");
+        indicesParam->set_friendly_name("Param_2");
         dataParams[1]->set_friendly_name("Param_3");
 
         auto axisNode = ngraph::opset3::Constant::create(idxPrecision, {}, { axis });
-        auto scatter = std::make_shared<ngraph::opset3::ScatterElementsUpdate>(dataParams[0], indicesParam[0], dataParams[1], axisNode);
+        auto scatter = std::make_shared<ngraph::opset3::ScatterElementsUpdate>(dataParams[0], indicesParam, dataParams[1], axisNode);
 
-        ngraph::ParameterVector allParams{ dataParams[0], indicesParam[0], dataParams[1] };
+        ngraph::ParameterVector allParams{ dataParams[0], indicesParam, dataParams[1] };
         function = makeNgraphFunction(inputPrecision, allParams, scatter, "ScatterElementsUpdateLayerCPUTest");
     }
 };

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

@@ -70,7 +70,10 @@ protected:
         init_input_shapes(inputShapes);
         selectedType = makeSelectedTypeStr("unknown", inputPrecision);
 
-        auto params = ngraph::builder::makeDynamicParams(inputPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inputPrecision, shape));
+        }
         auto indicesNode = ngraph::opset1::Constant::create(idxPrecision, indicesDescr.first, indicesDescr.second);
         auto axis_node = ngraph::opset1::Constant::create(idxPrecision, {}, { axis });
         auto scatter = std::make_shared<ngraph::opset3::ScatterUpdate>(params[0], indicesNode, params[1], axis_node);

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

@@ -60,7 +60,12 @@ protected:
         std::tie(inFmts, outFmts, priority, selectedType) = emptyCPUSpec;
         selectedType = makeSelectedTypeStr(getPrimitiveType(), ov::element::i8);
 
-        auto parameters = ngraph::builder::makeDynamicParams(ov::element::TypeVector{ov::element::boolean, precision, precision}, inputDynamicShapes);
+        ov::element::TypeVector types{ov::element::boolean, precision, precision};
+        ov::ParameterVector parameters;
+        for (size_t i = 0; i < types.size(); i++) {
+            auto param_node = std::make_shared<ov::op::v0::Parameter>(types[i], inputDynamicShapes[i]);
+            parameters.push_back(param_node);
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(parameters));
         auto select = ngraph::builder::makeSelect(paramOuts, broadcast);
 

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

@@ -159,14 +159,15 @@ protected:
         init_input_shapes(inputShapes);
 
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(prc);
-        auto inputs = ngraph::builder::makeDynamicParams(ngPrc, {inputDynamicShapes.front()});
+        ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(ngPrc, inputDynamicShapes.front())};
         auto dataInput = inputs.front();
         dataInput->set_friendly_name("param_1");
         std::shared_ptr<ngraph::Node> secondaryInput;
         if (secondType == ngraph::helpers::InputLayerType::PARAMETER) {
-            secondaryInput = ngraph::builder::makeDynamicParams(secondInPrc, {inputDynamicShapes.back()}).front();
+            auto param = std::make_shared<ov::op::v0::Parameter>(secondInPrc, inputDynamicShapes.back());
-            secondaryInput->set_friendly_name("param_2");
+            param->set_friendly_name("param_2");
-            inputs.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
+            secondaryInput = param;
+            inputs.push_back(param);
         } else {
             secondaryInput = ngraph::builder::makeConstant(secondInPrc, {inpDesc.data[0].size()}, inpDesc.data[0]);
         }

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

@@ -68,7 +68,10 @@ protected:
         outType = ElementType::i32;
         selectedType = makeSelectedTypeStr("ref", inType);
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::opset3::Parameter>(params));
         auto shapeOf = std::make_shared<ngraph::opset3::ShapeOf>(paramOuts[0], ngraph::element::i32);
 

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

@@ -65,7 +65,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto shuffleChannels = std::dynamic_pointer_cast<ngraph::opset3::ShuffleChannels>(
                 ngraph::builder::makeShuffleChannels(params[0], axis, group));
         function = makeNgraphFunction(inType, params, shuffleChannels, "ShuffleChannels");

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

@@ -98,7 +98,10 @@ protected:
                 targetShapes.push_back({sliceParams.axes.size()});
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         std::shared_ptr<ngraph::Node> sliceNode;
         if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
             // Slice start, stop, step, axes are parameters.

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

@@ -68,8 +68,10 @@ protected:
         }
         selectedType = makeSelectedTypeStr(selectedType, inType);
         init_input_shapes({config.inputShape});
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         const auto paramOuts =
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
 

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

@@ -106,7 +106,7 @@ protected:
         else
             selectedType = std::string("ref_any_") + netPrecision.name();
 
-        auto params = ngraph::builder::makeDynamicParams(ngPrec, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrec, inputDynamicShapes.front())};
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
         paramShape = {paramOuts[0].get_partial_shape().size()};
 

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

@@ -72,7 +72,10 @@ protected:
         targetDevice = ov::test::utils::DEVICE_CPU;
         init_input_shapes({shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto d2s = ngraph::builder::makeSpaceToDepth(params[0], mode, blockSize);
         function = makeNgraphFunction(inType, params, d2s, "SpaceToDepthCPU");
     }

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

@@ -70,7 +70,10 @@ protected:
 
         init_input_shapes({inputShapes});
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrecision, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(
                 ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         auto split = std::dynamic_pointer_cast<ngraph::opset5::Split>(ngraph::builder::makeSplit(paramOuts[0],

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

@@ -103,7 +103,10 @@ protected:
             targetShapes.push_back({ssParams.strides.size()});
         }
 
-        auto params = ngraph::builder::makeDynamicParams(dataType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(dataType, shape));
+        }
         std::shared_ptr<ngraph::Node> ss;
         if (secondaryInputType == ngraph::helpers::InputLayerType::PARAMETER) {
             ov::Shape inShape = {ssParams.begin.size()};

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

@@ -54,7 +54,10 @@ protected:
 
         const size_t sequence_axis = 1;
         auto tensor_iterator = std::make_shared<ngraph::opset5::TensorIterator>();
-        auto params = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
 
         ngraph::ParameterVector body_params;
         for (size_t i = 0; i < shapes.size(); i++) {

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

@@ -116,7 +116,7 @@ protected:
             }
         }
 
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, {inputDynamicShapes[0]});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[0])};
 
         // static shape need specific const k to test different sorting algorithms, dynamic shape tests random param k
         std::shared_ptr<ov::op::v11::TopK> topk;

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

@@ -94,7 +94,10 @@ protected:
             selectedType = makeSelectedTypeStr(selectedType, dataPrecision);
         }
 
-        auto params = ngraph::builder::makeDynamicParams(dataPrecision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(dataPrecision, shape));
+        }
         params[0]->set_friendly_name("data");
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
         std::shared_ptr<ov::Node> uniqueNode;

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

@@ -74,7 +74,7 @@ protected:
         }
 
         init_input_shapes(shapesToInit);
-        auto params = ngraph::builder::makeDynamicParams(netPrecision, {inputDynamicShapes[0]});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes[0])};
 
         std::shared_ptr<ov::Node> splitLengthsOp;
         if (lengthsType == ngraph::helpers::InputLayerType::PARAMETER) {

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/arm/convert_group_conv.cpp

@@ -58,7 +58,10 @@ protected:
         const size_t numOutChannels = 30;
         const op::PadType paddingType = op::PadType::EXPLICIT;
 
-        auto inputParams = ngraph::builder::makeDynamicParams(ngraph::element::f32, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
         conv = builder::makeGroupConvolution(paramOuts.front(), element::f32, kernelSize, strides, padBegin, padEnd, dilation,
                                              paddingType, numOutChannels, numOfGroups);

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/arm/convert_group_conv1d.cpp

@@ -63,7 +63,10 @@ protected:
         const size_t numOfGroups = 2;
         const op::PadType paddingType = op::PadType::EXPLICIT;
 
-        auto inputParams = ngraph::builder::makeDynamicParams(ngraph::element::f32, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
         switch (convType) {
             case nodeType::convolution : {

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/arm/convert_reduce_multi_axis.cpp

@@ -63,7 +63,10 @@ protected:
 
         init_input_shapes(inputShapes);
 
-        auto params = ngraph::builder::makeDynamicParams(ngraph::element::f32, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         std::vector<size_t> shapeAxes;
         shapeAxes.push_back(axes.size());

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

@@ -53,7 +53,11 @@ protected:
         init_input_shapes(input_shapes);
 
         ov::element::TypeVector input_precisions{input_precision, ov::element::i64};
-        const auto params = ngraph::builder::makeDynamicParams(input_precisions, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (size_t i = 0; i < input_precisions.size(); i++) {
+            auto param_node = std::make_shared<ov::op::v0::Parameter>(input_precisions[i], inputDynamicShapes[i]);
+            params.push_back(param_node);
+        }
         const auto bcast_data = ov::opset10::Constant::create(input_precision, {}, {1.f});
         const auto bcast = std::make_shared<ov::opset10::Broadcast>(bcast_data, params[1]);
         const auto add = std::make_shared<ov::opset10::Add>(params[0], bcast);

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

@@ -79,8 +79,10 @@ public:
         auto& InputShapes = this->GetParam();
         ASSERT_EQ(InputShapes.size(), number_of_params) << "Unexpected number of input shapes";
         init_input_shapes(InputShapes);
-        auto input_params = ngraph::builder::makeDynamicParams(netPrc, inputDynamicShapes);
+        ov::ParameterVector input_params;
-
+        for (auto&& shape : inputDynamicShapes) {
+            input_params.push_back(std::make_shared<ov::op::v0::Parameter>(netPrc, shape));
+        }
         ov::NodeVector first_level_reshapes;
 
         for (size_t i = 0; i < number_of_params; ++i) {

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

@@ -19,7 +19,10 @@ protected:
         init_input_shapes({input_shape});
 
 
-        auto params = ngraph::builder::makeDynamicParams(precision, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(precision, shape));
+        }
         auto conv_weights = ngraph::builder::makeConstant(precision, std::vector<size_t>{32, 32, 1, 1}, std::vector<float>{}, true);
         auto conv = ngraph::builder::makeConvolution(params[0],
                                                      conv_weights,

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

@@ -61,7 +61,11 @@ public:
     }
 
     virtual ngraph::ParameterVector makeParams() {
-        return ngraph::builder::makeDynamicParams(ngraph::element::f32, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, shape));
+        }
+        return params;
     }
 
     virtual std::shared_ptr<ngraph::Node> makeConv(const ngraph::ParameterVector& inputParams) {
@@ -188,10 +192,10 @@ public:
 
     std::shared_ptr<ngraph::Node> makeConv(const ngraph::ParameterVector& inputParams) override {
         using namespace ngraph;
-        auto inputParamsFP32 = builder::makeDynamicParams(element::f32, { inputParams.front()->get_partial_shape() });
+        auto inputParamsFP32 = std::make_shared<ov::op::v0::Parameter>(element::f32, inputParams.front()->get_partial_shape());
 
         auto convolutionNodeRelaxed = std::make_shared<ov::op::TypeRelaxed<opset1::Convolution>>(
-                *as_type_ptr<opset1::Convolution>(builder::makeConvolution(inputParamsFP32.front(), element::f32, _kernel, _stride, _padBegin,
+                *as_type_ptr<opset1::Convolution>(builder::makeConvolution(inputParamsFP32, element::f32, _kernel, _stride, _padBegin,
                                                                           _padEnd, _dilation, ngraph::op::PadType::EXPLICIT, _convOutChannels)),
                 element::f32);
 

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

@@ -110,10 +110,12 @@ protected:
         const size_t numOfBiasGates = rnnType == "LBRGRUSequence" ? numOfGates + 1 : numOfGates;
 
         const auto ngPrec = element::f32;
-        ngraph::ParameterVector inputParams;
         std::shared_ptr<Node> H;
 
-        inputParams = ngraph::builder::makeDynamicParams(ngPrec, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrec, shape));
+        }
 
         const auto outputNodes = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(inputParams));
 

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

@@ -101,7 +101,10 @@ protected:
         std::tie(inType, inputShape) = this->GetParam();
 
         init_input_shapes({inputShape});
-        auto inputParams = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(inputParams));
         auto customOp = std::make_shared<CustomOpI64>(paramOuts);
 

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

@@ -97,7 +97,7 @@ protected:
                 ngraphInputs.push_back(ngraphParam.back());
             }
         } else {
-            ngraphParam = ngraph::builder::makeDynamicParams(inputPrecisions[0], {inputDynamicShapes.front()});
+            ngraphParam = ov::ParameterVector {std::make_shared<ov::op::v0::Parameter>(inputPrecisions[0], inputDynamicShapes.front())};
             for (size_t i = 1; i < inputPrecisions.size(); i++) {
                 std::vector<float> ngraphInput1Data(ngraph::shape_size(targetStaticShapes[0][i]));
                 ngraphInputs.push_back(ngraph::builder::makeConstant(inputPrecisions[i], targetStaticShapes[0][i],

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

@@ -208,7 +208,7 @@ protected:
         std::string cpuNodeType = "FullyConnected";
         selectedType = makeSelectedTypeStr(selectedType, outType);
 
-        auto params = builder::makeDynamicParams(inType, {inShapeA});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(inType, inShapeA)};
         auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset1::Parameter>(params));
         std::shared_ptr<Node> inputB = builder::makeConstant<float>(weiConstElemType, inShapeB.get_shape(), {}, true);
         if (weiConstElemType == ElementType::f16) {
@@ -490,7 +490,10 @@ protected:
         std::string cpuNodeType = "FullyConnected";
         selectedType = makeSelectedTypeStr(selectedType, outType);
 
-        auto params = builder::makeDynamicParams(inType, {inShapeFC0, inShapeFC1});
+        ov::ParameterVector params;
+        for (auto&& shape : {inShapeFC0, inShapeFC1}) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset1::Parameter>(params));
         std::shared_ptr<Node> inputWeights = builder::makeConstant<float>(weiConstElemType, inShapeWeights.get_shape(), {}, true);
         if (weiConstElemType == ElementType::f16) {

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

@@ -100,7 +100,7 @@ protected:
                                                 const bool transpose_weights,
                                                 const bool add_subtract,
                                                 const bool reshape_on_decompression) {
-        auto params = builder::makeDynamicParams(data_precision, {inputShapes[0]});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(data_precision, inputShapes[0])};
         auto transpose_if_necessary = [&](const ov::Shape& shape) {
             if (!transpose_weights)
                 return shape;

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

@@ -52,8 +52,11 @@ static std::shared_ptr<ov::Model> initNgram(std::vector<ov::PartialShape>& input
     const size_t mid_idx = left_pad;
 
     ov::element::TypeVector input_precisions{data_et, idces_et};
-    auto params = ngraph::builder::makeDynamicParams(input_precisions, input_shapes);
+    ov::ParameterVector params;
-
+    for (size_t i = 0; i < input_precisions.size(); i++) {
+        auto param_node = std::make_shared<ov::op::v0::Parameter>(input_precisions[i], input_shapes[i]);
+        params.push_back(param_node);
+    }
     auto shape_of = std::make_shared<ov::opset10::ShapeOf>(params[0], idces_et);
     auto shape_ss_begin = ov::opset1::Constant::create(idces_et, {1}, {0});
     auto shape_ss_end = ov::opset1::Constant::create(idces_et, {1}, {1});

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

@@ -42,8 +42,8 @@ public:
         std::tie(inFmts, outFmts, priority, selectedType) =
             CPUSpecificParams{{}, {}, {}, makeSelectedTypeStr("ref", inType)};
         init_input_shapes({inputShape});
-        auto input_params = builder::makeDynamicParams(inType, {inputShape.first});
+        auto input_params = std::make_shared<ov::op::v0::Parameter>(inType, inputShape.first);
-        auto convert = builder::makeConversion(input_params[0], element::f32, ::helpers::ConversionTypes::CONVERT);
+        auto convert = builder::makeConversion(input_params, element::f32, ::helpers::ConversionTypes::CONVERT);
         auto begin = builder::makeConstant(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 0, 0, 0});
         auto end = builder::makeConstant(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 0, 16, 0});
         auto stride = builder::makeConstant(element::i64, ov::Shape{4}, std::vector<int64_t>{1, 1, 1, 1});
@@ -58,7 +58,7 @@ public:
                                                {},
                                                {});
         auto convert2 = builder::makeConversion(slice, inType, ::helpers::ConversionTypes::CONVERT);
-        function = std::make_shared<ov::Model>(convert2, input_params, "remove_convert");
+        function = std::make_shared<ov::Model>(convert2, ov::ParameterVector{input_params}, "remove_convert");
     };
 };
 
@@ -83,12 +83,12 @@ public:
         targetDevice = ov::test::utils::DEVICE_CPU;
 
         init_input_shapes({inputShape});
-        auto input_params = builder::makeDynamicParams(inType, {inputShape.first});
+        auto input_params = std::make_shared<ov::op::v0::Parameter>(inType, inputShape.first);
 
         // Such complicated graph is necessary to cover the case when Convert has several children and connected to non zero output
         const auto split_axis = builder::makeConstant(element::i64, ov::Shape{}, std::vector<int64_t>{1});
         const auto split_lengths = builder::makeConstant(element::i64, ov::Shape{2}, std::vector<int64_t>{-1, 1});
-        const auto split = std::make_shared<ov::opset10::VariadicSplit>(input_params[0], split_axis, split_lengths);
+        const auto split = std::make_shared<ov::opset10::VariadicSplit>(input_params, split_axis, split_lengths);
         auto convert = builder::makeConversion(split->output(1), inType, ::helpers::ConversionTypes::CONVERT);
         auto relu = builder::makeActivation(convert, inType, ::helpers::ActivationTypes::Relu);
 
@@ -98,7 +98,7 @@ public:
             std::make_shared<ov::opset10::Result>(relu),
         };
 
-        function = std::make_shared<ov::Model>(results, input_params, "remove_convert");
+        function = std::make_shared<ov::Model>(results, ov::ParameterVector{input_params}, "remove_convert");
     };
 };
 

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

@@ -21,7 +21,10 @@ class ReshapeChain : public SubgraphBaseTest {
         init_input_shapes({inputShapes});
         auto ngPrc = ngraph::element::f32;
         const auto secondInPrc = ngraph::element::Type_t::i32;
-        auto inputParams = ngraph::builder::makeDynamicParams(ngPrc, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
+        }
         auto reshapeParam1 = ngraph::builder::makeConstant<int>(secondInPrc, {3}, {0, 0, -1});
         auto reshape1 = std::make_shared<ngraph::opset1::Reshape>(inputParams.front(), reshapeParam1, true);
         auto reshapeParam2 = ngraph::builder::makeConstant<int>(secondInPrc, {2}, {0, -1});

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

@@ -81,7 +81,7 @@ protected:
 
         init_input_shapes(shapes);
 
-        auto params = ngraph::builder::makeDynamicParams(prc, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(prc, inputDynamicShapes.front())};
         auto reshapeData = ngraph::builder::makeConstant(ElementType::i32, {data.size()}, data);
         auto reshape = std::make_shared<ngraph::opset1::Reshape>(params[0], reshapeData, true);
 

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

@@ -171,8 +171,11 @@ protected:
         if (seqInType == ngraph::helpers::InputLayerType::PARAMETER) {
             types.back() = ElementType::i64;
         }
-        auto params = ngraph::builder::makeDynamicParams(types, inputDynamicShapes);
+        ov::ParameterVector params;
-
+        for (size_t i = 0; i < types.size(); i++) {
+            auto param_node = std::make_shared<ov::op::v0::Parameter>(types[i], inputDynamicShapes[i]);
+            params.push_back(param_node);
+        }
         std::vector<int64_t> order_ref_before = {1, 0, 2};
         const auto order_before = std::make_shared<ov::op::v0::Constant>(ov::element::i64,
                                                                          ov::Shape({order_ref_before.size()}),

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

@@ -42,7 +42,10 @@ protected:
         ov::test::InputShape input_shape{{}, {{1, 3, 3, 3}}};
         init_input_shapes({input_shape});
 
-        auto params = ngraph::builder::makeDynamicParams(precision, inputDynamicShapes);
+        ov::ParameterVector params;
+        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 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);

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

@@ -106,7 +106,7 @@ protected:
         const auto& inShapeA = inputDynamicShapes[0];
         const auto& inShapeB = inputDynamicShapes[1];
 
-        auto params = builder::makeDynamicParams(ElementType::f32, {inShapeA});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ElementType::f32, inShapeA)};
         auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset1::Parameter>(params));
         std::shared_ptr<Node> inputB = builder::makeConstant<float>(ElementType::f32, inShapeB.get_shape(), {}, true);
 

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

@@ -21,8 +21,10 @@ protected:
         init_input_shapes({inputShapes});
 
         auto ngPrc = ngraph::element::f32;
-        auto inputParams = ngraph::builder::makeDynamicParams(ngPrc, inputDynamicShapes);
+        ov::ParameterVector inputParams;
-
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
+        }
         auto splitAxisOp = std::make_shared<ngraph::opset3::Constant>(ngraph::element::i64, ngraph::Shape{}, std::vector<int64_t>{0});
         std::vector<int> splitLenght = {1, 0, 6};
         auto splitLengthsOp = std::make_shared<ngraph::opset3::Constant>(ngraph::element::i32, ngraph::Shape{splitLenght.size()}, splitLenght);

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

@@ -36,7 +36,10 @@ public:
         InputShape inpShape0 = {{}, {{56}}};
         InputShape inpShape1 = {{-1, -1, 768}, {{1, 544, 768}}};
         init_input_shapes({inpShape0, inpShape1});
-        auto inputParams = builder::makeDynamicParams(element::f32, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ov::element::f32, shape));
+        }
         auto end = builder::makeConstant(element::i64, {1}, std::vector<int64_t>{2147483647});
         auto stride  = builder::makeConstant(element::i64, {1}, std::vector<int64_t>{1});
         auto indices = builder::makeConstant(element::i64, {1}, std::vector<int64_t>{1});

src/plugins/intel_cpu/tests/functional/test_utils/fusing_test_utils.hpp

@@ -360,7 +360,7 @@ const auto fusingFakeQuantizePerTensorRelu = fusingSpecificParams{std::make_shar
 const auto fusingSum = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
             {[](postNodeConfig& cfg){
                 auto shape = cfg.input->get_output_partial_shape(0);
-                ngraph::ParameterVector newParams = ngraph::builder::makeDynamicParams(cfg.type, {shape});
+                ov::ParameterVector newParams{std::make_shared<ov::op::v0::Parameter>(cfg.type, shape)};
                 cfg.params.insert(cfg.params.end(), newParams.begin(), newParams.end());
                 auto newParamOuts = ngraph::helpers::convert2OutputVector(
                      ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(newParams));
@@ -370,7 +370,7 @@ const auto fusingSum = fusingSpecificParams{std::make_shared<postNodesMgr>(std::
 const auto fusingSumEluFQ = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
         {[](postNodeConfig& cfg){
             auto shape = cfg.input->get_output_partial_shape(0);
-            ngraph::ParameterVector newParams = ngraph::builder::makeDynamicParams(cfg.type, {shape});
+            ov::ParameterVector newParams{std::make_shared<ov::op::v0::Parameter>(cfg.type, shape)};
             cfg.params.insert(cfg.params.end(), newParams.begin(), newParams.end());
             auto newParamOuts = ngraph::helpers::convert2OutputVector(
                     ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(newParams));

src/plugins/intel_gna/tests/functional/preprocess_tests/precision_convert.cpp

@@ -54,7 +54,10 @@ protected:
 
         init_input_shapes({input_shapes});
 
-        auto params = ngraph::builder::makeDynamicParams(net_type, inputDynamicShapes);
+        ov::ParameterVector params;
+        for (auto&& shape : inputDynamicShapes) {
+            params.push_back(std::make_shared<ov::op::v0::Parameter>(net_type, shape));
+        }
         auto paramOuts =
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
         auto concat = std::make_shared<ngraph::opset8::Concat>(paramOuts, 1);

src/plugins/intel_gpu/tests/functional/behavior/memory_dyn_batch.cpp

@@ -54,14 +54,14 @@ public:
     }
 
     static std::shared_ptr<ov::Model> buildModel(ElementType precision, const ov::PartialShape& shape) {
-        auto param = builder::makeDynamicParams(precision, { shape });
+        auto param = std::make_shared<ov::op::v0::Parameter>(precision, shape);
         const VariableInfo variable_info { shape, precision, "v0" };
         auto variable = std::make_shared<Variable>(variable_info);
-        auto read_value = std::make_shared<ReadValue>(param.at(0), variable);
+        auto read_value = std::make_shared<ReadValue>(param, variable);
-        auto add = std::make_shared<Add>(read_value, param.at(0));
+        auto add = std::make_shared<Add>(read_value, param);
         auto assign = std::make_shared<Assign>(add, variable);
         auto res = std::make_shared<Result>(add);
-        return std::make_shared<ov::Model>(ResultVector { res }, SinkVector { assign }, param,
+        return std::make_shared<ov::Model>(ResultVector { res }, SinkVector { assign }, ov::ParameterVector{param},
             "MemoryDynamicBatchTest");
     }
 

src/plugins/intel_gpu/tests/functional/single_layer_tests/convolution.cpp

@@ -84,7 +84,10 @@ protected:
         size_t convOutChannels;
         std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType) = convParams;
 
-        auto inputParams = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
 
         auto convolutionNode = ngraph::builder::makeConvolution(paramOuts.front(), netType, kernel, stride, padBegin,

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

@@ -120,7 +120,7 @@ protected:
 
         init_input_shapes(inputShapes);
 
-        auto params = ngraph::builder::makeDynamicParams(inType, {inputDynamicShapes.front()});
+        ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(inType, inputDynamicShapes.front())};
         std::shared_ptr<ov::Node> blockInput, beginInput, endInput;
         if (restInputType == ngraph::helpers::InputLayerType::PARAMETER) {
             auto blockNode = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::Type_t::i64, ov::Shape{block.size()});

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

@@ -84,7 +84,10 @@ protected:
         size_t convOutChannels;
         std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType) = convParams;
 
-        auto inputParams = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        ov::ParameterVector inputParams;
+        for (auto&& shape : inputDynamicShapes) {
+            inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
+        }
         auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
 
         auto convolutionNode = ngraph::builder::makeConvolution(paramOuts.front(), netType, kernel, stride, padBegin,