IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove makeDynamicParams (#19226)

Browse Source 
* Remove makeDynamicParams

* Apply comments

* Fix1

* Fix2

* Fix3
This commit is contained in:
Oleg Pipikin 2023-08-23 18:57:29 +02:00 committed by GitHub
parent 22fe12fe9b
commit ab900606cd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
154 changed files with 822 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/adaptive_pooling.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/augru_cell.cpp
View File

@ -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*/);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/augru_sequence.cpp
View File

@ -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() :

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/batch_to_space.cpp
View File

@ -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()};

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/activation.cpp
View File

@ -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 activation = ngraph::builder::makeActivation(params[0], ngPrc, activationType, activationShapes, constantsValue);
auto params = std::make_shared<ov::op::v0::Parameter>(ngPrc, inputDynamicShapes.front());
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) {

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/conversion.cpp
View File

@ -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");

7
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/eltwise.cpp
View File

@ -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();
parameters.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
auto param = std::make_shared<ov::op::v0::Parameter>(netType, inputDynamicShapes.back());
secondaryInput = param;
parameters.push_back(param);
} else {
auto pShape = inputDynamicShapes.back();
ngraph::Shape shape;

9
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/mvn.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/reduce.cpp
View File

@ -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));

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/transpose.cpp
View File

@ -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);
}

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/concat.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution.cpp
View File

@ -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,

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution_backprop_data.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder.cpp
View File

@ -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)};

17
src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder_seq_len.cpp
View File

@ -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],

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_loss.cpp
View File

@ -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],

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/cum_sum.cpp
View File

@ -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);

7
src/plugins/intel_cpu/tests/functional/single_layer_tests/custom_op_internal_dyn.cpp
View File

@ -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;
auto inputParams = ngraph::builder::makeDynamicParams(ngPrc, 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));
auto customOp = std::make_shared<CustomOp>(paramOuts);
auto shapeOf = std::make_shared<ov::opset10::ShapeOf>(customOp->output(1));

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/deformable_convolution.cpp
View File

@ -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];

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/depth_to_space.cpp
View File

@ -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");
}

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/detection_output.cpp
View File

@ -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)};

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/extract_image_patches.cpp
View File

@ -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");
}

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/eye.cpp
View File

@ -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];

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/fake_quantize.cpp
View File

@ -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());

10
src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_nd.cpp
View File

@ -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)};

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp
View File

@ -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]);

3
src/plugins/intel_cpu/tests/functional/single_layer_tests/grid_sample.cpp
View File

@ -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));

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/grn.cpp
View File

@ -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)};

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution.cpp
View File

@ -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>(

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution_backprop_data.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/gru_cell.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/gru_sequence.cpp
View File

@ -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() :

3
src/plugins/intel_cpu/tests/functional/single_layer_tests/interpolate.cpp
View File

@ -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) {

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/log_softmax.cpp
View File

@ -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)};

30
src/plugins/intel_cpu/tests/functional/single_layer_tests/loop.cpp
View File

@ -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;

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/lrn.cpp
View File

@ -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");

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/lstm_cell.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/lstm_sequence.cpp
View File

@ -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() :

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/matmul.cpp
View File

@ -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) {

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/matmul_sparse.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/non_max_suppression.cpp
View File

@ -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");

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/nonzero.cpp
View File

@ -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,

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/normalize.cpp
View File

@ -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");
}

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/one_hot.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/pad.cpp
View File

@ -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()};

11
src/plugins/intel_cpu/tests/functional/single_layer_tests/pooling.cpp
View File

@ -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);

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/prior_box.cpp
View File

@ -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>(

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/prior_box_clustered.cpp
View File

@ -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>(

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/proposal.cpp
View File

@ -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;

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/region_yolo.cpp
View File

@ -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);

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp
View File

@ -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;

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/rnn_cell.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/rnn_sequence.cpp
View File

@ -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() :

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/roi_pooling.cpp
View File

@ -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));

11
src/plugins/intel_cpu/tests/functional/single_layer_tests/roialign.cpp
View File

@ -147,12 +147,15 @@ protected:
init_input_shapes(inputShapes);
auto float_params = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes[0], inputDynamicShapes[1] });
auto int_params = ngraph::builder::makeDynamicParams(ngraph::element::i32, { inputDynamicShapes[2] });
ov::ParameterVector float_params;
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");
}
};

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/roll.cpp
View File

@ -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);

13
src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_ND_update.cpp
View File

@ -101,15 +101,18 @@ protected:
init_input_shapes(inputShapes);
selectedType = makeSelectedTypeStr("unknown", inputPrecision);
auto dataParams = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes[0], inputDynamicShapes[2] });
auto indicesParam = ngraph::builder::makeDynamicParams(idxPrecision, { inputDynamicShapes[1] });
ov::ParameterVector dataParams;
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");
}
};

13
src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_elements_update.cpp
View File

@ -105,16 +105,19 @@ protected:
init_input_shapes(inputShapes);
selectedType = makeSelectedTypeStr("unknown", inputPrecision);
auto dataParams = ngraph::builder::makeDynamicParams(inputPrecision, { inputDynamicShapes[0], inputDynamicShapes[2] });
auto indicesParam = ngraph::builder::makeDynamicParams(idxPrecision, { inputDynamicShapes[1] });
ov::ParameterVector dataParams;
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");
}
};

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_update.cpp
View File

@ -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);

7
src/plugins/intel_cpu/tests/functional/single_layer_tests/select.cpp
View File

@ -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);

9
src/plugins/intel_cpu/tests/functional/single_layer_tests/shape_ops.cpp
View File

@ -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();
secondaryInput->set_friendly_name("param_2");
inputs.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
auto param = std::make_shared<ov::op::v0::Parameter>(secondInPrc, inputDynamicShapes.back());
param->set_friendly_name("param_2");
secondaryInput = param;
inputs.push_back(param);
} else {
secondaryInput = ngraph::builder::makeConstant(secondInPrc, {inpDesc.data[0].size()}, inpDesc.data[0]);
}

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/shapeof.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/shuffle_channels.cpp
View File

@ -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");

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/slice.cpp
View File

@ -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.

6
src/plugins/intel_cpu/tests/functional/single_layer_tests/softmax.cpp
View File

@ -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));

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_batch.cpp
View File

@ -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()};

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_depth.cpp
View File

@ -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");
}

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/split.cpp
View File

@ -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],

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/strided_slice.cpp
View File

@ -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()};

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/tensor_iterator.cpp
View File

@ -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++) {

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/topk.cpp
View File

@ -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;

5
src/plugins/intel_cpu/tests/functional/single_layer_tests/unique.cpp
View File

@ -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;

2
src/plugins/intel_cpu/tests/functional/single_layer_tests/variadic_split.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/arm/convert_group_conv.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/arm/convert_group_conv1d.cpp
View File

@ -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 : {

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/arm/convert_reduce_multi_axis.cpp
View File

@ -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());

6
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/broadcast_eltwise.cpp
View File

@ -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);

6
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/concat_reshape_concat.cpp
View File

@ -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) {

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_dw_conv.cpp
View File

@ -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,

10
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_sum_broadcast.cpp
View File

@ -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);

6
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convert_fq_rnn_to_quantized_rnn.cpp
View File

@ -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));

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/custom_op_insert_convert_i64.cpp
View File

@ -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);

2
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_chain.cpp
View File

@ -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],

7
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/matmul_decompress_convert.cpp
View File

@ -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) {

2
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/matmul_weights_decompression.cpp
View File

@ -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;

7
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/ngram.cpp
View File

@ -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});

12
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/remove_convert.cpp
View File

@ -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 convert = builder::makeConversion(input_params[0], element::f32, ::helpers::ConversionTypes::CONVERT);
auto input_params = std::make_shared<ov::op::v0::Parameter>(inType, inputShape.first);
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");
};
};

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_chain.cpp
View File

@ -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});

2
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_fc.cpp
View File

@ -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);

7
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/seq_native_order.cpp
View File

@ -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()}),

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/split_concat_add.cpp
View File

@ -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);

2
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/split_matmul_concat.cpp
View File

@ -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);

6
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/static_zero_dims.cpp
View File

@ -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);

5
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/strided_slice_zero_dims.cpp
View File

@ -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});

4
src/plugins/intel_cpu/tests/functional/test_utils/fusing_test_utils.hpp
View File

@ -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));

5
src/plugins/intel_gna/tests/functional/preprocess_tests/precision_convert.cpp
View File

@ -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);

8
src/plugins/intel_gpu/tests/functional/behavior/memory_dyn_batch.cpp
View File

@ -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 add = std::make_shared<Add>(read_value, param.at(0));
auto read_value = std::make_shared<ReadValue>(param, variable);
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");
}

5
src/plugins/intel_gpu/tests/functional/single_layer_tests/convolution.cpp
View File

@ -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,

2
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/batch_to_space.cpp
View File

@ -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()});

5
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/convolution.cpp
View File

@ -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,

Some files were not shown because too many files have changed in this diff Show More