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

Remove makeParams (#19306)

This commit is contained in:
Oleg Pipikin 2023-08-23 09:39:05 +02:00 committed by GitHub
parent f4cc3bf7d3
commit 7aa51d6775
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
248 changed files with 564 additions and 430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/core/tests/visitors/op/prior_box.cpp
View File

@ -152,7 +152,9 @@ TEST(attributes, prior_box_v8_op) {
TEST(attributes, prior_box_v8_op2) {
NodeBuilder::get_ops().register_factory<opset8::PriorBox>();
auto params = ngraph::builder::makeParams(ov::element::Type_t::i32, {{128, 128}, {32, 32}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{128, 128}),
std::make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{32, 32})};
auto shape_of_1 = std::make_shared<ngraph::opset3::ShapeOf>(params[0]);
auto shape_of_2 = std::make_shared<ngraph::opset3::ShapeOf>(params[1]);

2
src/plugins/intel_cpu/tests/functional/behavior/export_import.cpp
View File

@ -23,7 +23,7 @@ std::shared_ptr<ov::Model> MakeMatMulModel() {
const ov::Shape input_shape = {1, 4096};
const ov::element::Type precision = ov::element::f32;
auto params = ngraph::builder::makeParams(precision, {input_shape});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(precision, ov::Shape(input_shape))};
auto matmul_const = ngraph::builder::makeConstant(precision, {4096, 1024}, std::vector<float>{}, true);
auto matmul = ngraph::builder::makeMatMul(params[0], matmul_const);

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

@ -26,7 +26,7 @@ std::shared_ptr<ngraph::Function> getFunction1() {
const std::vector<size_t> inputShape = {1, 4, 20, 20};
const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
@ -45,7 +45,7 @@ std::shared_ptr<ngraph::Function> getFunction2() {
const std::vector<size_t> inputShape = {1, 4, 20, 20};
const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);

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

@ -56,8 +56,7 @@ protected:
auto ngInputsPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(Precision::BOOL); // Because ngraph supports only boolean input for logical ops
configuration.insert(additional_config.begin(), additional_config.end());
auto inputs = ngraph::builder::makeParams(ngInputsPrc, {inputShapes.first});
ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(ngInputsPrc, ov::Shape(inputShapes.first))};
std::shared_ptr<ngraph::Node> logicalNode;
if (logicalOpType != ngraph::helpers::LogicalTypes::LOGICAL_NOT) {
auto secondInput = ngraph::builder::makeInputLayer(ngInputsPrc, secondInputType, inputShapes.second);

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

@ -87,7 +87,7 @@ protected:
ngraph::Shape proposalShape = { proposal.size() / 5, 5 };
auto coords = ngraph::builder::makeConstant<float>(ngraph::element::f32, proposalShape, proposal);
auto params = ngraph::builder::makeParams(ngraph::element::f32, {featureMapShape});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, ov::Shape(featureMapShape))};
auto psroi = std::make_shared<ngraph::op::v0::PSROIPooling>(params[0], coords, outputDim, groupSize,
spatialScale, spatialBinsX, spatialBinsY, mode);

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

@ -27,7 +27,7 @@ public:
ASSERT_EQ(ngraph::shape_size(indicesShape), indices.size())
<< "Indices vector size and provided indices shape doesn't fit each other";
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto paramOuts = ngraph::helpers::convert2OutputVector(
ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
auto indicesNode = ngraph::opset3::Constant::create(secondConstantType, ngraph::Shape(indicesShape), indices);

4
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/align_matmul_input_ranks.cpp
View File

@ -54,7 +54,9 @@ protected:
std::tie(postOpMgrPtr, fusedOps) = fusingParams;
const auto ngPrec = element::f32;
auto inputParams = builder::makeParams(ngPrec, {inShapes.first, inShapes.second});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(inShapes.first)),
std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(inShapes.second))};
const auto outputNodes = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(inputParams));
const auto matMul = builder::makeMatMul(outputNodes[0], outputNodes[1], false, false);

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

@ -43,7 +43,7 @@ public:
configuration.insert({ PluginConfigParams::KEY_ENFORCE_BF16, PluginConfigParams::NO });
const std::vector<size_t> inputShape = {1, 3, 3, 11};
auto inputParams = ngraph::builder::makeParams(ngraph::element::f32, {inputShape});
ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, ov::Shape(inputShape))};
auto transposeOrder = ngraph::opset8::Constant::create(ngraph::element::i32, {4}, {0, 3, 2, 1});
auto transpose = std::make_shared<ngraph::opset8::Transpose>(inputParams[0], transposeOrder);

4
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/concat_conv_sum_inplace.cpp
View File

@ -49,8 +49,8 @@ public:
const auto targetFormat = with_cpu_x86_avx512_core() ? nChw16c : nChw8c;
auto inputParams = ngraph::builder::makeParams(ngraph::element::f32, {inputShape, inputShape});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape(inputShape))};
auto Relu1 = std::make_shared<ngraph::opset3::Relu>(inputParams[0]);
Relu1->get_rt_info() = CPUTestsBase::makeCPUInfo({targetFormat}, {targetFormat}, {});
auto Relu2 = std::make_shared<ngraph::opset3::Relu>(inputParams[1]);

3
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/concat_reorder_inplace.cpp
View File

@ -34,7 +34,8 @@ class ConcatReorderInPlaceTest : virtual public LayerTestsUtils::LayerTestsCommo
public:
void SetUp() override {
const std::vector<size_t> inputShape = {1, 100, 1, 1};
auto inputParams = ngraph::builder::makeParams(ngraph::element::f32, {inputShape, inputShape});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape(inputShape))};
auto concat = ngraph::builder::makeConcat(ngraph::OutputVector{inputParams[0], inputParams[1]}, 1);
const auto targetFormat = nhwc;
auto mul1 = std::make_shared<ngraph::opset8::Multiply>(

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

@ -41,7 +41,7 @@ protected:
cpuNodeType = nodeType2PluginType(convType);
auto inputParams = builder::makeParams(element::f32, {Shape{1, 1024, 64}});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 1024, 64})};
auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(inputParams));
std::shared_ptr<Node> conv;

3
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_concat.cpp
View File

@ -64,7 +64,8 @@ void ConvConcatSubgraphTest::SetUp() {
selectedType += "_FP32";
auto inputParams = ngraph::builder::makeParams(ngraph::element::f32, {inputShapes, inputShapes});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape(inputShapes)),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape(inputShapes))};
auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(inputParams));
std::vector<std::shared_ptr<ngraph::Node>> convolutionNodes(2);

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

@ -32,7 +32,7 @@ protected:
fusingSpecificParams fusingParams = this->GetParam();
std::tie(postOpMgrPtr, fusedOps) = fusingParams;
auto inputParams = builder::makeParams(element::f32, {Shape{1, 3, 40, 40}});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 40, 40})};
auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(inputParams));
std::shared_ptr<Node> conv;

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

@ -40,7 +40,7 @@ void ConvWithZeroPointFuseSubgraphTest::SetUp() {
selectedType = ".*_I8";
auto inputParams = ngraph::builder::makeParams(ngraph::element::f32, {inputShapes});
ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, ov::Shape(inputShapes))};
const auto fq = ngraph::builder::makeFakeQuantize(
inputParams[0],
ov::element::f32,

3
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convs_and_sums.cpp
View File

@ -36,7 +36,8 @@ protected:
targetDevice = ov::test::utils::DEVICE_CPU;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {{1, 512, 32}, {1, 128, 32}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 512, 32}),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 128, 32})};
auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
auto FQ = ngraph::builder::makeFakeQuantize(paramOuts[1], ngPrc, 256, {}, {-2.8215785026550293}, {2.799535036087036},

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

@ -62,7 +62,7 @@ void SetUp() override {
const auto elemsCount = shape_size(inpShape);
const auto rtPrc = ov::element::f32;
auto params = ngraph::builder::makeParams(rtPrc, {inpShape});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(rtPrc, ov::Shape(inpShape))};
pConstStorage.reset(new AlignedBufferWrapper<float>(elemsCount, alignment));
auto constTensor = std::make_shared<ov::HostTensor>(rtPrc, inpShape, pConstStorage->get_ptr());

4
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fq_fused_with_ss.cpp
View File

@ -33,7 +33,7 @@ protected:
netPrecision = this->GetParam();
const auto ngPrec = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
std::vector<SizeVector> mmShape{{25, 14, 14, 768}};
ov::Shape mmShape{25, 14, 14, 768};
SizeVector mmShape2{768, 2304};
SizeVector sumShape{1, 1, 1, 2304};
@ -46,7 +46,7 @@ protected:
auto constShift = ngraph::opset5::Constant::create(ngraph::element::f32, sumShape, sumConstData);
auto mmConst = ngraph::opset5::Constant::create(ngraph::element::f32, mmShape2, mmInData);
auto mmParams = builder::makeParams(ngPrec, {mmShape});
ov::ParameterVector mmParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, mmShape)};
const auto mmOutputNodes = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(mmParams));
const auto mm = builder::makeMatMul(mmOutputNodes[0], mmConst, false, false);

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

@ -46,7 +46,7 @@ protected:
SizeVector splitShape{2, 16};
if (rank == 3) bcastTo3D(splitShape);
auto params = builder::makeParams(ngPrec, {splitShape});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(splitShape))};
const auto splitOutputNodes = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(params));
const auto splitAxis = rank == 3 ? 1 : 0;

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

@ -27,7 +27,7 @@ public:
auto in_shapes = static_shapes_to_test_representation({input_static_shape});
init_input_shapes({in_shapes});
auto input_params = builder::makeParams(precision, {input_static_shape});
ov::ParameterVector input_params {std::make_shared<ov::op::v0::Parameter>(precision, ov::Shape(input_static_shape))};
auto shared_il = opset1::Constant::create(precision, {1, 1, 1, 1}, {0.f});
auto shared_ih = opset1::Constant::create(precision, {1, 1, 1, 1}, {12.5f});

13
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fuse_muladd_ewsimple.cpp
View File

@ -42,7 +42,9 @@ void FuseMulAddAndEwSimpleTest1::CreateGraph() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto mulSecondInput = inputShape;
mulSecondInput[0] = 1;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape, mulSecondInput});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(mulSecondInput))};
auto clamp = ngraph::builder::makeActivation(params[0], ngPrc, ActivationTypes::Clamp, inputShape, {0, 100});
auto tanh = ngraph::builder::makeActivation(clamp, ngPrc, ActivationTypes::Tanh);
@ -63,7 +65,9 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseMulAddAndEwSimpleTest1, mulAddAndEwSim
// Fused EltwiseAndSimple comes on the 2nd input into MulAdd
void FuseMulAddAndEwSimpleTest2::CreateGraph() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape, inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto clamp1 = ngraph::builder::makeActivation(params[0], ngPrc, ActivationTypes::Clamp, inputShape, {0, 100});
auto tanh1 = ngraph::builder::makeActivation(clamp1, ngPrc, ActivationTypes::Tanh);
@ -86,7 +90,10 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseMulAddAndEwSimpleTest2, mulAddAndEwSim
// Fused MulAdd with more than 3 inputs
void FuseMulAddAndEwSimpleTest3::CreateGraph() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape, inputShape, inputShape, inputShape});
ov::ParameterVector params;
for (auto&& shape : {inputShape, inputShape, inputShape, inputShape, inputShape}) {
params.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape)));
}
auto mul1 = ngraph::builder::makeEltwise(params[0], params[1], EltwiseTypes::MULTIPLY);
auto add1 = ngraph::builder::makeEltwise(mul1, params[2], EltwiseTypes::ADD);

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

@ -21,16 +21,16 @@ class FuseNon0OuputPort : public SubgraphBaseTest {
ngraph::ParameterVector params(3);
targetStaticShapes = {{x_shape, y_shape, z_shape}};
targetDevice = ov::test::utils::DEVICE_CPU;
params[0] = ngraph::builder::makeParams(ov::element::f32, {x_shape})[0];
params[1] = ngraph::builder::makeParams(ov::element::i32, {y_shape})[0];
params[2] = ngraph::builder::makeParams(ov::element::i32, {z_shape})[0];
params[0] = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, x_shape);
params[1] = std::make_shared<ov::op::v0::Parameter>(ov::element::i32, y_shape);
params[2] = std::make_shared<ov::op::v0::Parameter>(ov::element::i32, z_shape);
// make a sub function
const auto cond = ov::op::v0::Constant::create(ov::element::boolean, {1}, {true});
ngraph::ParameterVector sub_params(3);
sub_params[0] = ngraph::builder::makeParams(ov::element::f32, {x_shape})[0];
sub_params[1] = ngraph::builder::makeParams(ov::element::i32, {y_shape})[0];
sub_params[2] = ngraph::builder::makeParams(ov::element::boolean, {y_shape})[0];
sub_params[0] = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, x_shape);
sub_params[1] = std::make_shared<ov::op::v0::Parameter>(ov::element::i32, y_shape);
sub_params[2] = std::make_shared<ov::op::v0::Parameter>(ov::element::boolean, y_shape);
ngraph::ResultVector sub_results(3);
sub_results[0] = std::make_shared<ngraph::opset1::Result>(sub_params[0]);
sub_results[1] = std::make_shared<ngraph::opset1::Result>(sub_params[1]);

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

@ -77,7 +77,7 @@ const auto fuseTransposeAndReorderCommonParams = ::testing::Combine(
void FuseTransposeAndReorderTest::CreateGraph() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto order = inputShape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1};
auto memFmt = inputShape.size() == 5 ? ndhwc : nhwc;
@ -136,7 +136,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest, fuseTranspose
void FuseTransposeAndReorderTest1::CreateGraph() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto order = inputShape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1};
@ -204,8 +204,8 @@ void FuseTransposeAndReorderTest2::CreateGraph() {
auto inputShape2(inputShape);
inputShape2[inputShape2.size() - 1] *= 2;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape2});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape2))};
auto order = inputShape.size() == 5 ? std::vector<int64_t>{0, 4, 1, 2, 3} : std::vector<int64_t>{0, 3, 1, 2};
auto constOrder1 = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order);
@ -258,7 +258,7 @@ void FuseTransposeAndReorderTest3::CreateGraph() {
std::vector<ptrdiff_t> padBegin{0, 0}, padEnd{0, 0};
size_t convOutChannels = 32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
IE_ASSERT(inputShape[1] >= 8 && (inputShape[1] % 8 == 0));
auto convolutionNode = ngraph::builder::makeConvolution(params.front(), ngPrc, kernel, stride, padBegin,
@ -317,7 +317,7 @@ void FuseTransposeAndReorderTest4::CreateGraph() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto memFmt = nhwc;
auto inputParams = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
const auto relu = std::make_shared<ov::op::v0::Relu>(inputParams[0]);
const auto transposeOrder = ov::op::v0::Constant::create(ov::element::i32, {4}, {0, 3, 1, 2});
const auto transpose1 = std::make_shared<ov::op::v1::Transpose>(relu, transposeOrder);

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

@ -27,7 +27,7 @@ protected:
auto secondaryInputType = ngraph::helpers::InputLayerType::CONSTANT;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto input = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector input {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
std::shared_ptr<ngraph::Node> secondaryInput = ngraph::builder::makeInputLayer(ngPrc, secondaryInputType, inputShape);
auto eltwise = ngraph::builder::makeEltwise(input[0], secondaryInput, eltwiseType);

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

@ -62,7 +62,7 @@ protected:
std::tie(inShapes, isFC, inType, outType, cpuParams) = this->GetParam();
std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
const auto ngPrec = element::f32;
auto inputParams = builder::makeParams(ngPrec, {inShapes});
ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(inShapes))};
std::shared_ptr<Node> fq1;
std::shared_ptr<Node> matMul;

9
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/matmul_strided_inputs_outputs.cpp
View File

@ -35,19 +35,20 @@ protected:
const auto ngPrec = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
SizeVector splitShape{1, 2, 1, 16};
auto splitInputParams = builder::makeParams(ngPrec, {splitShape});
ov::ParameterVector splitInputParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(splitShape))};
const auto splitOutputNodes = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(splitInputParams));
const auto split = builder::makeSplit(splitOutputNodes[0], ngPrec, 2 /* splits */, 1 /* 2nd axis */);
std::vector<SizeVector> concatShapes{{1, 1, 8, 8}, {1, 1, 8, 8}};
auto concatInputParams = builder::makeParams(ngPrec, {concatShapes});
std::vector<ov::Shape> concatShapes{{1, 1, 8, 8}, {1, 1, 8, 8}};
ov::ParameterVector concatInputParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, concatShapes[0]),
std::make_shared<ov::op::v0::Parameter>(ngPrec, concatShapes[1])};
const auto concatOutputNodes = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(concatInputParams));
const auto concat = builder::makeConcat(concatOutputNodes, 2);
const auto matMul1 = builder::makeMatMul(split->output(0), concat, false, false);
SizeVector matmulShape{1, 1, 16, 8};
auto matmulInputParams = builder::makeParams(ngPrec, {matmulShape});
ov::ParameterVector matmulInputParams {std::make_shared<ov::op::v0::Parameter>(ngPrec, ov::Shape(matmulShape))};
const auto matmulOutputNodes = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(matmulInputParams));
const auto matMul2 = builder::makeMatMul(split->output(1), matmulOutputNodes[0], false, false);

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

@ -36,7 +36,10 @@ TEST_F(EdgeWithSameNameInTwoModels, smoke_CompareWithRef) {
// first model
const std::vector<std::vector<size_t>> shapes1{{1, 16, 720, 1280}};
auto params1 = ngraph::builder::makeParams(type, shapes1);
ov::ParameterVector params1;
for (auto&& shape : shapes1) {
params1.push_back(std::make_shared<ov::op::v0::Parameter>(type, ov::Shape(shape)));
}
const size_t convOutCh1 = 32;
auto conv1 = ngraph::builder::makeConvolution(params1.front(), type, kernel, strides, padsBegin, padsEnd, dilations, autoPad, convOutCh1);
conv1->set_friendly_name(convName);
@ -45,7 +48,10 @@ TEST_F(EdgeWithSameNameInTwoModels, smoke_CompareWithRef) {
// second model
const std::vector<std::vector<size_t>> shapes2{{1, 32, 24, 24}};
auto params2 = ngraph::builder::makeParams(type, shapes2);
ov::ParameterVector params2;
for (auto&& shape : shapes2) {
params2.push_back(std::make_shared<ov::op::v0::Parameter>(type, ov::Shape(shape)));
}
const size_t convOutCh2 = 16;
auto conv2 = ngraph::builder::makeConvolution(params2.front(), type, kernel, strides, padsBegin, padsEnd, dilations, autoPad, convOutCh2);
conv2->set_friendly_name(convName);

3
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/not_fused_conv_simple_op.cpp
View File

@ -15,7 +15,8 @@ protected:
void SetUp() override {
targetDevice = ov::test::utils::DEVICE_CPU;
auto inputParams = builder::makeParams(element::f32, {{1, 3, 12, 9}, {1, 16, 12, 9}});
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 12, 9}),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 16, 12, 9})};
auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(inputParams));
std::shared_ptr<Node> conv;

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

@ -41,11 +41,10 @@ protected:
const auto rtPrc = ov::element::f32;
const ov::Shape inpShape = {21660, 4};
const ov::Shape secShape = {4};
ngraph::ParameterVector params(2);
targetStaticShapes = {{inpShape, secShape}};
targetDevice = ov::test::utils::DEVICE_CPU;
params[0] = ngraph::builder::makeParams(rtPrc, {inpShape})[0];
params[1] = ngraph::builder::makeParams(ov::element::i32, {secShape})[0];
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(rtPrc, inpShape),
std::make_shared<ov::op::v0::Parameter>(ov::element::i32, secShape)};
auto shape = std::make_shared<ov::op::v3::ShapeOf>(params[0]);
auto c = ngraph::builder::makeConstant<float>(rtPrc, {}, {1.0f});
auto broadcast = std::make_shared<ov::op::v3::Broadcast>(c, shape);

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

@ -16,7 +16,7 @@ protected:
targetDevice = ov::test::utils::DEVICE_CPU;
auto ngPrc = element::f32;
auto inputParams = builder::makeParams(ngPrc, {{1, 3, 12, 9}});
ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 3, 12, 9})};
auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<op::Parameter>(inputParams));
auto tile = ngraph::builder::makeTile(paramOuts[0], std::vector<int64_t>{1, 2, 1, 1});

2
src/plugins/intel_gna/tests/functional/Import_export_tests/import_export_act_conv_act.cpp
View File

@ -118,7 +118,7 @@ protected:
std::tie(inputShape, netPrecision, targetDevice, exportConfiguration, importConfiguration) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto relu1 = std::make_shared<ngraph::opset1::Relu>(params[0]);
size_t num_out_channels = 8;

2
src/plugins/intel_gna/tests/functional/Import_export_tests/import_export_batch_size.cpp
View File

@ -30,7 +30,7 @@ protected:
this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto mul_const_1 = ngraph::builder::makeConstant<float>(
ngPrc,

2
src/plugins/intel_gna/tests/functional/Import_export_tests/import_export_memory_layer.cpp
View File

@ -101,7 +101,7 @@ protected:
std::tie(netPrecision, targetDevice, exportConfiguration, importConfiguration, withReset) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {{1, 336}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 336})};
auto mem_c = ngraph::builder::makeConstant(ngPrc, {1, 336}, std::vector<size_t>{1});
auto mem_r = std::make_shared<ngraph::opset3::ReadValue>(mem_c, "id");

3
src/plugins/intel_gna/tests/functional/Import_export_tests/import_export_multi_inputs.cpp
View File

@ -22,7 +22,8 @@ protected:
this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto input = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto mul1 = ngraph::builder::makeEltwise(input[0], input[1], ngraph::helpers::EltwiseTypes::ADD);
auto result = std::make_shared<ngraph::opset7::Result>(mul1);

2
src/plugins/intel_gna/tests/functional/Import_export_tests/import_reshape_permute_conv.cpp
View File

@ -16,7 +16,7 @@ protected:
this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
std::vector<size_t> outFormShapes1 = {1, 1, 168, 2};
auto pattern1 =

5
src/plugins/intel_gna/tests/functional/limitations/layers_limit.cpp
View File

@ -50,7 +50,10 @@ protected:
configuration.insert(common_conf.begin(), common_conf.end());
configuration.insert(conf.begin(), conf.end());
auto params = ngraph::builder::makeParams(net_type, shapes);
ov::ParameterVector params;
for (auto&& shape : shapes) {
params.push_back(std::make_shared<ov::op::v0::Parameter>(net_type, ov::Shape(shape)));
}
auto add_const = ngraph::builder::makeConstant(net_type, ov::Shape{1}, std::vector<float>{0.01f});
ov::ResultVector results;

6
src/plugins/intel_gna/tests/functional/pass_tests/4d_eltwise.cpp
View File

@ -53,7 +53,7 @@ protected:
outPrc = InferenceEngine::Precision::FP32;
auto params = ngraph::builder::makeParams(ngPrc, {{1, 72}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 72})};
std::vector<size_t> outFormShapes1 = {1, 1, 6, 12};
auto pattern1 =
@ -102,8 +102,8 @@ protected:
outPrc = InferenceEngine::Precision::FP32;
auto params = ngraph::builder::makeParams(ngPrc, {{1, 72}, {1, 72}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 72}),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 72})};
std::vector<size_t> outFormShapes1 = {1, 1, 6, 12};
auto pattern1 =
std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{4}, outFormShapes1);

2
src/plugins/intel_gna/tests/functional/pass_tests/act_maxpool_reordering.cpp
View File

@ -72,7 +72,7 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape, addBiases, actType) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto inputVector = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector inputVector{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
size_t num_out_channels = 12;
size_t kernal_size = 8;

2
src/plugins/intel_gna/tests/functional/pass_tests/broadcast_const_with_fq.cpp
View File

@ -55,7 +55,7 @@ protected:
std::vector<size_t> inputShape2;
std::tie(netPrecision, inputShape1, inputShape2, level, configuration, targetDevice) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape1});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape1))};
auto fakeQuantize1 =
ngraph::builder::makeFakeQuantize(params[0], ngPrc, level, {}, {-0.5}, {0.5}, {-0.5}, {0.5});
auto constant = ngraph::builder::makeConstant<float>(ngPrc, inputShape2, {}, true);

2
src/plugins/intel_gna/tests/functional/pass_tests/concat_memory_param.cpp
View File

@ -66,7 +66,7 @@ protected:
auto ng_prc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(net_prc);
size_t in_total_dims_size = ov::shape_size(input_shape);
auto params = ngraph::builder::makeParams(ng_prc, {{1, in_total_dims_size}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ng_prc, ov::Shape{1, in_total_dims_size})};
auto reshape_pattern =
std::make_shared<ngraph::opset9::Constant>(ov::element::Type_t::i64, ov::Shape{2}, input_shape);
auto reshape = std::make_shared<ngraph::opset9::Reshape>(params[0], reshape_pattern, false);

16
src/plugins/intel_gna/tests/functional/pass_tests/concat_restrictions.cpp
View File

@ -55,7 +55,7 @@ struct ReLUConcatAxis {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::OutputVector concatInputs;
ov::ParameterVector params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto relu = ngraph::builder::makeActivation(params[0], ngPrc, ngraph::helpers::ActivationTypes::Relu);
concatInputs.push_back(relu);
size_t totalSize = ov::shape_size(inputShape);
@ -81,7 +81,7 @@ struct MatmulConcatAxis {
const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::OutputVector concatInputs;
ov::ParameterVector params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
ov::Shape mulConstShape;
switch (inputShape.size()) {
@ -127,7 +127,7 @@ struct ConvNCHWConcatAxis {
const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::OutputVector concatInputs;
ov::ParameterVector params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
size_t numOutChannels = 8;
size_t kernelSize = 1;
@ -169,7 +169,7 @@ struct ConvNHWCConcatAxis {
const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::OutputVector concatInputs;
ov::ParameterVector params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto transposeInOrder = ov::opset10::Constant::create(ov::element::i64, ov::Shape{4}, {0, 3, 1, 2});
auto transposeIn = std::make_shared<ov::opset10::Transpose>(params[0], transposeInOrder);
@ -215,7 +215,7 @@ struct ConvConcatNHWCAxis {
const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::OutputVector concatInputs;
ov::ParameterVector params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto transposeInOrder = ov::opset10::Constant::create(ov::element::i64, ov::Shape{4}, {0, 3, 1, 2});
auto transposeIn1 = std::make_shared<ov::opset10::Transpose>(params[0], transposeInOrder);
@ -273,7 +273,7 @@ struct ConvConcatConcatNHWCAxis {
const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::OutputVector concat1Inputs, concat2Inputs;
ov::ParameterVector params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto transposeInOrder = ov::opset10::Constant::create(ov::element::i64, ov::Shape{4}, {0, 3, 1, 2});
auto transposeIn1 = std::make_shared<ov::opset10::Transpose>(params[0], transposeInOrder);
@ -385,8 +385,8 @@ struct TransposeTransposeConcat {
vector<size_t> conv_input_shape = {1, input_channels, 1, input_shapes[0] / input_channels};
auto ng_prc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(net_precision);
auto inputs = makeParams(ng_prc, {{1, input_shapes[0]}, {1, input_shapes[1]}});
ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(ng_prc, ov::Shape{1, input_shapes[0]}),
std::make_shared<ov::op::v0::Parameter>(ng_prc, ov::Shape{1, input_shapes[1]})};
// 1st concat input
auto reshape_l1_const = make_shared<Constant>(i64, Shape{conv_input_shape.size()}, conv_input_shape);
auto reshape_l1 = make_shared<Reshape>(inputs[0], reshape_l1_const, false);

6
src/plugins/intel_gna/tests/functional/pass_tests/concat_transpose.cpp
View File

@ -65,8 +65,10 @@ protected:
void init_test_model() {
std::vector<std::vector<size_t>> input_shapes = {{10, 1}};
auto params = ngraph::builder::makeParams(m_net_type, input_shapes);
ov::ParameterVector params;
for (auto&& shape : input_shapes) {
params.push_back(std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(shape)));
}
std::vector<size_t> shape_1 = {10, 128};
std::vector<size_t> shape_2 = {10, 192};
std::vector<size_t> shape_3 = {10, 256};

2
src/plugins/intel_gna/tests/functional/pass_tests/convert_dwsc_to_scaleshifts.cpp
View File

@ -98,7 +98,7 @@ protected:
std::tie(filter, stride, padBegin, padEnd, dilation, padType, numOutChannels, numGroups, bias) = params;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto input = builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto transposeInOrder = op::Constant::create(element::i64, Shape{4}, {0, 3, 1, 2});
auto transposeIn = std::make_shared<Transpose>(input[0], transposeInOrder);
auto filterSize = std::accumulate(std::begin(filter), std::end(filter), 1ull, std::multiplies<size_t>());

6
src/plugins/intel_gna/tests/functional/pass_tests/convert_matmul_to_fullyconnected.cpp
View File

@ -61,7 +61,7 @@ protected:
std::tie(inputShape, netPrecision, targetDevice, configuration) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape[1]});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape[1]))};
std::vector<float> weights =
ov::test::utils::generate_float_numbers(inputShape[0][0] * inputShape[0][1], -0.2f, 0.2f);
auto const_mult2 = ngraph::builder::makeConstant<float>(ngPrc, inputShape[0], weights);
@ -114,8 +114,8 @@ protected:
std::tie(inputShape, netPrecision, targetDevice, configuration) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {{1, inputShape[1][0] * inputShape[1][1]}});
ov::ParameterVector params{
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape({1, inputShape[1][0] * inputShape[1][1]}))};
auto reshape1 = std::make_shared<ngraph::opset1::Reshape>(
params[0],
ngraph::builder::makeConstant(ngraph::element::i64, {inputShape[1].size()}, inputShape[1]),

4
src/plugins/intel_gna/tests/functional/pass_tests/convert_matmul_to_pointwise_conv.cpp
View File

@ -74,7 +74,7 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
size_t batch = inputShape[inputShape.size() - 2];
size_t elemNum = inputShape[inputShape.size() - 1];
@ -139,7 +139,7 @@ protected:
std::tie(inputDataMin, inputDataMax) = inputMinMax;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto inputLowNode =
ngraph::builder::makeConstant(ngPrc, std::vector<size_t>{1}, std::vector<float>{inputDataMin});

2
src/plugins/intel_gna/tests/functional/pass_tests/convert_padded_to_valid_conv.cpp
View File

@ -130,7 +130,7 @@ protected:
Shape maxpoolShape{maxpoolPool};
Strides maxpoolStrides{maxpoolStride};
auto input = builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto transposeInOrder = op::Constant::create(element::i64, Shape{4}, {0, 3, 1, 2});
auto transposeIn = std::make_shared<Transpose>(input[0], transposeInOrder);
auto filterSize = std::accumulate(std::begin(kernel), std::end(kernel), 1ull, std::multiplies<size_t>());

2
src/plugins/intel_gna/tests/functional/pass_tests/convolution_align_filter.cpp
View File

@ -66,7 +66,7 @@ protected:
size_t in_total_dims_size =
std::accumulate(std::begin(splitInputShape), std::end(splitInputShape), 1, std::multiplies<size_t>());
auto params = ngraph::builder::makeParams(ngPrc, {{1, in_total_dims_size}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, in_total_dims_size})};
auto pattern1 =
std::make_shared<ngraph::opset8::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{2}, splitInputShape);
auto reshape1 = std::make_shared<ngraph::opset8::Reshape>(params[0], pattern1, false);

2
src/plugins/intel_gna/tests/functional/pass_tests/convolution_crop_axis_h.cpp
View File

@ -54,7 +54,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto reshape_pattern_size = ngraph::Shape{inputShape.size()};
auto reshape_pattern = ngraph::builder::makeConstant(ov::element::i64, reshape_pattern_size, inputShape);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto input_reshape = std::make_shared<ngraph::opset9::Reshape>(params[0], reshape_pattern, false);
const std::vector<size_t> filterSize{1, 1};

2
src/plugins/intel_gna/tests/functional/pass_tests/decompose_2d_conv.cpp
View File

@ -129,7 +129,7 @@ protected:
Shape maxpoolShape{maxpoolPool};
Strides maxpoolStrides{maxpoolStride};
auto input = builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto transposeInOrder = opset7::Constant::create(element::i64, Shape{4}, {0, 3, 1, 2});
auto transposeIn = std::make_shared<Transpose>(input[0], transposeInOrder);
auto filterSize = std::accumulate(std::begin(kernel), std::end(kernel), 1ull, std::multiplies<size_t>());

2
src/plugins/intel_gna/tests/functional/pass_tests/decompose_mvn.cpp
View File

@ -79,7 +79,7 @@ protected:
bool normalizeVariance, acrossChannels, mvnVersion6;
std::tie(normalizeVariance, eps, epsMode, acrossChannels, mvnVersion6) = mvnParams;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto input = builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
InferenceEngine::SizeVector axes(inputShape.size() - 2);
std::iota(axes.begin(), axes.end(), 2);
std::shared_ptr<ngraph::Node> mvn;

4
src/plugins/intel_gna/tests/functional/pass_tests/diagonal_insertion_test.cpp
View File

@ -65,7 +65,7 @@ class DiagonalInsertionTest : public testing::WithParamInterface<DiagonalInserti
}
ParameterVector CreateInputVector(const Type& type, const vector<std::size_t>& shapes) {
return makeParams(type, {shapes});
return ov::ParameterVector{std::make_shared<ov::op::v0::Parameter>(type, ov::Shape(shapes))};
}
shared_ptr<FakeQuantize> CreateFQNode(const Type& type,
@ -128,7 +128,7 @@ protected:
// Create network
auto input_vect = makeParams(precision, {input_shape});
ov::ParameterVector input_vect{std::make_shared<ov::op::v0::Parameter>(precision, ov::Shape(input_shape))};
auto input_fq = CreateFQNode(precision, input_vect[0], fq_min_max[0][0], fq_min_max[0][1], fq_levels);
auto reshape = CreateReshapeNode(ngraph::element::Type_t::i32, input_fq, {width, 1});

2
src/plugins/intel_gna/tests/functional/pass_tests/eltwise_split_over_channels_pass.cpp
View File

@ -49,7 +49,7 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto const_mult2 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, {-1.0f});
auto mul = ngraph::builder::makeEltwise(params[0], const_mult2, ngraph::helpers::EltwiseTypes::MULTIPLY);

2
src/plugins/intel_gna/tests/functional/pass_tests/fq_activation.cpp
View File

@ -76,7 +76,7 @@ protected:
auto inputLowNode = ngraph::builder::makeConstant<float>(ngPrc, {1}, {inputMinMax.first});
auto inputHighNode = ngraph::builder::makeConstant<float>(ngPrc, {1}, {inputMinMax.second});
auto inputVector = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector inputVector{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto inputFQNode = std::make_shared<ngraph::opset1::FakeQuantize>(inputVector[0],
inputLowNode,
inputHighNode,

3
src/plugins/intel_gna/tests/functional/pass_tests/fq_fusion_with_multiple_weights.cpp
View File

@ -62,7 +62,8 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape, weightsMinMax, levels) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
const size_t outChannels = 8;
const size_t kernelSize = 8;

2
src/plugins/intel_gna/tests/functional/pass_tests/fq_fusion_with_sigmoid.cpp
View File

@ -32,7 +32,7 @@ protected:
configuration.insert(config.begin(), config.end());
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto input = ngraph::builder::makeParams(ngPrc, {{1, inputSize}});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, inputSize})};
auto constant = ngraph::builder::makeConstant(ngPrc, {1, inputSize}, std::vector<size_t>{1});
auto mul1 = ngraph::builder::makeEltwise(input[0], constant, ngraph::helpers::EltwiseTypes::ADD);
auto sigmoid1 = std::make_shared<ngraph::opset1::Sigmoid>(mul1);

2
src/plugins/intel_gna/tests/functional/pass_tests/fq_maxpool_reordering.cpp
View File

@ -92,7 +92,7 @@ protected:
auto inputLowNode2 = ngraph::builder::makeConstant<float>(ngPrc, {1}, {inputDataMin2});
auto inputHighNode2 = ngraph::builder::makeConstant<float>(ngPrc, {1}, {inputDataMax2});
auto inputVector = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector inputVector{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto inputFQ = std::make_shared<ngraph::opset1::FakeQuantize>(inputVector[0],
inputLowNode1,

2
src/plugins/intel_gna/tests/functional/pass_tests/fq_outputs_activation_.cpp
View File

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

2
src/plugins/intel_gna/tests/functional/pass_tests/fq_with_multiple_out_connections.cpp
View File

@ -51,7 +51,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
const ngraph::Shape shape = {1, 128};
auto params = ngraph::builder::makeParams(ngPrc, {shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape))};
auto pattern1 = std::make_shared<ngraph::opset8::Constant>(ngraph::element::Type_t::i64,
ngraph::Shape{3},

2
src/plugins/intel_gna/tests/functional/pass_tests/insert_copy_layer_before_self_concat.cpp
View File

@ -83,7 +83,7 @@ protected:
outLayout,
targetDevice) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
ngraph::OutputVector concatInputs;
for (int i = 0; i < inputsNum; ++i) {
concatInputs.push_back(params[0]);

4
src/plugins/intel_gna/tests/functional/pass_tests/insert_transpose_before_matmul.cpp
View File

@ -68,7 +68,7 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape, firstInConst) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {{1, inputShape}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, inputShape})};
auto matmul_in_shape = firstInConst ? ngraph::Shape{inputShape / 8, 8} : ngraph::Shape{8, inputShape / 8};
auto pattern =
@ -161,7 +161,7 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape, firstInConst) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {{1, inputShape}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, inputShape})};
auto matmul_in_shape = ngraph::Shape{inputShape / 8, 8};
auto pattern =
std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{2}, matmul_in_shape);

4
src/plugins/intel_gna/tests/functional/pass_tests/insert_transpose_between_convs.cpp
View File

@ -65,7 +65,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ngraph::Shape inputShape_2d = {inputShape[0], inputShape[1] * inputShape[2] * inputShape[3]};
auto params = ngraph::builder::makeParams(ngPrc, {inputShape_2d});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape_2d))};
auto pattern1 =
std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{4}, inputShape);
@ -161,7 +161,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ngraph::Shape inputShape_2d = {inputShape[0], inputShape[1] * inputShape[2] * inputShape[3]};
auto params = ngraph::builder::makeParams(ngPrc, {inputShape_2d});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape_2d))};
auto pattern1 =
std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{4}, inputShape);

4
src/plugins/intel_gna/tests/functional/pass_tests/layers_restrictions.cpp
View File

@ -28,7 +28,7 @@ struct FullyConnectedBatchSizeMoreThan8 {
static std::shared_ptr<ngraph::Function> createTopology(const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
std::vector<size_t> inputShape = {9, 1};
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto weights = ov::test::utils::generate_float_numbers(inputShape[1] * inputShape[1], -0.0001f, 0.0001f);
auto fullyConnected = ngraph::builder::makeFullyConnected(params[0], ngPrc, inputShape[1], false, {}, weights);
ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(fullyConnected)};
@ -46,7 +46,7 @@ struct FullyConnectedBatchSizeLessThanOrEqual8 {
static std::shared_ptr<ngraph::Function> createTopology(const InferenceEngine::Precision& netPrecision) {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
std::vector<size_t> inputShape = {7, 1};
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto weights = ov::test::utils::generate_float_numbers(inputShape[1] * inputShape[1], -0.0001f, 0.0001f);
auto fullyConnected = ngraph::builder::makeFullyConnected(params[0], ngPrc, inputShape[1], false, {}, weights);
ngraph::ResultVector results{std::make_shared<ngraph::opset1::Result>(fullyConnected)};

14
src/plugins/intel_gna/tests/functional/pass_tests/remove_permutations_NHWC_to_NCHW_pass.cpp
View File

@ -171,7 +171,7 @@ protected:
ASSERT_LT(shape_size, 5);
size_t in_total_dims_size =
std::accumulate(std::begin(inputShape), std::end(inputShape), 1, std::multiplies<double>());
auto params = ngraph::builder::makeParams(ngPrc, {{1, in_total_dims_size}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, in_total_dims_size})};
auto pattern1 = std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64,
ngraph::Shape{shape_size},
@ -232,7 +232,7 @@ protected:
ASSERT_GT(shape_size, 2);
ASSERT_LT(shape_size, 5);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto permute1 = CreateTranspose(params[0], shape_size, true);
auto conv = CreateConvolution(permute1, ngPrc, inputShape);
auto permute2 = CreateTranspose(conv, shape_size, false);
@ -309,7 +309,7 @@ protected:
size_t in_total_dims_size =
std::accumulate(std::begin(inputShape), std::end(inputShape), 1, std::multiplies<double>());
auto params = ngraph::builder::makeParams(ngPrc, {{1, in_total_dims_size}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, in_total_dims_size})};
auto pattern1 = std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64,
ngraph::Shape{shape_size},
@ -396,7 +396,7 @@ protected:
size_t in_total_dims_size =
std::accumulate(std::begin(inputShape), std::end(inputShape), 1, std::multiplies<double>());
auto params = ngraph::builder::makeParams(ngPrc, {{1, in_total_dims_size}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, in_total_dims_size})};
auto pattern1 = std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64,
ngraph::Shape{shape_size},
@ -479,7 +479,8 @@ protected:
size_t in_total_dims_size =
std::accumulate(std::begin(inputShape), std::end(inputShape), 1, std::multiplies<double>());
auto params = ngraph::builder::makeParams(ngPrc, {{1, 2 * in_total_dims_size}});
ov::ParameterVector params{
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, 2 * in_total_dims_size})};
auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
auto pattern1 = std::make_shared<ngraph::opset1::Constant>(ngraph::element::Type_t::i64,
@ -576,7 +577,8 @@ protected:
size_t in_total_dims_size =
std::accumulate(std::begin(inputShape), std::end(inputShape), 1, std::multiplies<double>());
auto params = ngraph::builder::makeParams(ngPrc, {{1, splits_num * in_total_dims_size}});
ov::ParameterVector params{
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, splits_num * in_total_dims_size})};
auto multipleInputShape = inputShape;
size_t mul_dim = inputShape.size() == 4 && inputShape[1] > 1 ? 1 : (inputShape.size() - 2);

2
src/plugins/intel_gna/tests/functional/preprocess_tests/gather_transpose_cpu.cpp
View File

@ -120,7 +120,7 @@ protected:
}
void init_test_model() {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
std::shared_ptr<ov::Node> pre_node = params[0];

4
src/plugins/intel_gna/tests/functional/preprocess_tests/gather_transpose_merge.cpp
View File

@ -103,7 +103,7 @@ protected:
class TransposeGatherTest : public GatherTransposeMergeTest {
protected:
void init_test_model() {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
std::vector<size_t> transpose_order = make_transpose_order(m_input_shape);
@ -133,7 +133,7 @@ protected:
class GatherTransposeTest : public GatherTransposeMergeTest {
protected:
void init_test_model() {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
std::vector<int8_t> shape_in = {1, -1};

3
src/plugins/intel_gna/tests/functional/scale_factors_tests/add_overload_correction.cpp
View File

@ -67,7 +67,8 @@ protected:
std::tie(netPrecision, targetDevice, configuration, inputShape) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape, inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params[0]->set_friendly_name("input1");
params[1]->set_friendly_name("input2");

2
src/plugins/intel_gna/tests/functional/scale_factors_tests/const_input_add.cpp
View File

@ -65,7 +65,7 @@ protected:
std::tie(inputMin, inputMax) = inputRange;
ngraph::Shape shape = {1, 72};
auto params = ngraph::builder::makeParams(ngPrc, {shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape))};
auto constant =
ngraph::builder::makeConstant<float>(ngPrc, shape, {}, true, constRange.second, constRange.first);

2
src/plugins/intel_gna/tests/functional/scale_factors_tests/eltwise_act_fq.cpp
View File

@ -87,7 +87,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
const ngraph::Shape shape = {1, 128};
auto params = ngraph::builder::makeParams(ngPrc, {shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape))};
auto lowNodeIn = ngraph::builder::makeConstant<float>(ngPrc, {1}, {100 * -inputDataMax});
auto highNodeIn = ngraph::builder::makeConstant<float>(ngPrc, {1}, {100 * inputDataMax});

2
src/plugins/intel_gna/tests/functional/scale_factors_tests/matmul_overload_correction.cpp
View File

@ -66,7 +66,7 @@ protected:
const ngraph::Shape shape1 = inputShape;
const ngraph::Shape shape2 = {1, inputShape[1] * inputShape[1]};
const float maxInputValue = 10.0f;
auto params = ngraph::builder::makeParams(ngPrc, {shape1});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape1))};
auto relu = std::make_shared<ngraph::opset8::Relu>(params[0]);
std::shared_ptr<ngraph::Node> input2;

2
src/plugins/intel_gna/tests/functional/scale_factors_tests/perchannel_quant_test.cpp
View File

@ -57,7 +57,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
const ngraph::Shape constShape = {inputShape.back(), inputShape.back()};
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
std::vector<float> weights;
std::vector<float> weightsMin, weightsMax;

2
src/plugins/intel_gna/tests/functional/scale_factors_tests/test_fq_scale_factors.cpp
View File

@ -90,7 +90,7 @@ protected:
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
const ngraph::Shape shape = {1, 1, 128};
auto params = ngraph::builder::makeParams(ngPrc, {shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape))};
std::shared_ptr<ov::Node> test_node = params[0];
switch (m_non_func_layer) {
case NonFunctionalLayer::RESHAPE:

2
src/plugins/intel_gna/tests/functional/scale_factors_tests/weighable_layer_without_fq.cpp
View File

@ -54,7 +54,7 @@ protected:
configuration.insert(config.begin(), config.end());
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto relu = std::make_shared<ngraph::opset8::Relu>(params[0]);
auto fq1 = std::make_shared<ngraph::opset8::FakeQuantize>(
relu,

2
src/plugins/intel_gna/tests/functional/shared_tests_instances/single_layer_tests/activation.cpp
View File

@ -25,7 +25,7 @@ protected:
activationType = activationDecl.first;
const auto& constantsValue = activationDecl.second;
const auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputDims});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputDims))};
params[0]->set_friendly_name("Input");
// TODO: remove after integer inference output support

2
src/plugins/intel_gna/tests/functional/shared_tests_instances/single_layer_tests/conv_low_precision.cpp
View File

@ -72,7 +72,7 @@ public:
}
ParameterVector createInputVector(const Type& type, const vector<std::size_t>& shapes) {
return makeParams(type, {shapes});
return ov::ParameterVector{std::make_shared<ov::op::v0::Parameter>(type, ov::Shape(shapes))};
}
shared_ptr<FakeQuantize> createFQNode(const Type& type,

2
src/plugins/intel_gna/tests/functional/shared_tests_instances/single_layer_tests/convolution.cpp
View File

@ -102,7 +102,7 @@ void ConvolutionLayerTestFixture::SetUp() {
size_t convOutChannels;
std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType) = convParams;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<Parameter>(params));
std::vector<float> filter_weights;

3
src/plugins/intel_gna/tests/functional/shared_tests_instances/single_layer_tests/gru_cell.cpp
View File

@ -55,7 +55,8 @@ protected:
ASSERT_EQ(InputLayerType::CONSTANT, BType);
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1]))};
std::vector<ngraph::Shape> WRB = {inputShapes[2], inputShapes[3], inputShapes[4]};
auto in = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params));
std::vector<float> weights_vals =

3
src/plugins/intel_gna/tests/functional/shared_tests_instances/single_layer_tests/gru_sequence.cpp
View File

@ -57,7 +57,8 @@ protected:
};
m_max_seq_len = seq_lengths;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1]))};
std::vector<ngraph::Shape> WRB = {inputShapes[3], inputShapes[4], inputShapes[5], inputShapes[2]};

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

@ -56,7 +56,10 @@ protected:
{num_directions, 4 * hidden_size}},
};
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1], inputShapes[2]});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[2]))};
std::vector<ngraph::Shape> WRB = {inputShapes[4], inputShapes[5], inputShapes[6], inputShapes[3]};
auto in = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params));

2
src/plugins/intel_gna/tests/functional/shared_tests_instances/single_layer_tests/memory.cpp
View File

@ -29,7 +29,7 @@ protected:
};
void MemoryTestGna::CreateCommonFunc() {
auto param = builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector param{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
const auto variable_info = VariableInfo{PartialShape::dynamic(), element::dynamic, "v0"};
auto variable = std::make_shared<Variable>(variable_info);

2
src/plugins/intel_gna/tests/unit/gna_export_import_test.cpp
View File

@ -106,7 +106,7 @@ protected:
std::shared_ptr<ngraph::Function> getFunction() {
auto ngPrc = ngraph::element::f32;
size_t shape = 10;
auto params = ngraph::builder::makeParams(ngPrc, {{1, shape}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, shape})};
auto mul_const =
ngraph::builder::makeConstant<float>(ngPrc,
{shape, shape},

2
src/plugins/intel_gna/tests/unit/gna_infer_request_test.cpp
View File

@ -41,7 +41,7 @@ protected:
std::shared_ptr<ngraph::Function> GetFunction() {
auto ngPrc = ngraph::element::f32;
std::vector<size_t> shape = {1, 10};
auto params = ngraph::builder::makeParams(ngPrc, {shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape))};
auto shape_size = ov::shape_size(shape);
auto add_const =
ngraph::builder::makeConstant<float>(ngPrc,

8
src/plugins/intel_gna/tests/unit/transformations/gather_transpose_merge.cpp
View File

@ -105,7 +105,7 @@ protected:
class TransposeGatherTest : public GatherTransposeMergeBase {
public:
void init_test_model() override {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
std::vector<size_t> transpose_order = make_transpose_order(m_input_shape);
@ -137,7 +137,7 @@ public:
}
void init_ref_model() override {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
ov::Shape shape_in = {1, input_shape_size};
@ -162,7 +162,7 @@ public:
class GatherTransposeTest : public GatherTransposeMergeBase {
public:
void init_test_model() override {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
ov::Shape shape_in = {1, input_shape_size};
@ -196,7 +196,7 @@ public:
}
void init_ref_model() override {
auto params = ngraph::builder::makeParams(m_net_type, {m_input_shape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(m_net_type, ov::Shape(m_input_shape))};
const size_t input_shape_size = ov::shape_size(params[0]->get_shape());
ov::Shape shape_in = {1, input_shape_size};

6
src/plugins/intel_gna/tests/unit/transformations/gna_insert_identity_layer.cpp
View File

@ -634,7 +634,8 @@ public:
void SetUp() override {
InsertIdentityLayerTest::SetUp();
{
auto inputs = makeParams(f32, {{m_input_shape}, {m_input_shape}});
ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, m_input_shape),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, m_input_shape)};
auto fq = create_fq(f32, inputs[0], -1, 1, 256);
auto relu = make_shared<Relu>(fq);
auto reshape_const = make_shared<Constant>(i64, Shape{1}, m_input_shape);
@ -645,7 +646,8 @@ public:
}
{
auto inputs = makeParams(f32, {{m_input_shape}, {m_input_shape}});
ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, m_input_shape),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, m_input_shape)};
auto fq = create_fq(f32, inputs[0], -1, 1, 256);
auto relu = make_shared<Relu>(fq);
auto reshape_const = make_shared<Constant>(i64, Shape{1}, m_input_shape);

32
src/plugins/intel_gna/tests/unit/transformations/gna_remove_convert.cpp
View File

@ -207,7 +207,9 @@ public:
// test function
{
auto input = ngraph::builder::makeParams(target_precision_, {input_shape, input_shape, input_shape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(target_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(target_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(target_precision_, input_shape)};
auto convert1 =
ngraph::builder::makeConversion(input[0], net_precision_, ngraph::helpers::ConversionTypes::CONVERT);
auto convert2 =
@ -222,7 +224,9 @@ public:
// ref function
{
auto input = ngraph::builder::makeParams(net_precision_, {input_shape, input_shape, input_shape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape)};
auto mul1 = ngraph::builder::makeEltwise(input[0], input[1], ngraph::helpers::EltwiseTypes::ADD);
auto mul2 = ngraph::builder::makeEltwise(input[2], mul1, ngraph::helpers::EltwiseTypes::ADD);
auto result = std::make_shared<ngraph::opset8::Result>(mul2);
@ -242,8 +246,10 @@ public:
const ngraph::Shape input_shape{1, 10};
// test function
{
auto input =
ngraph::builder::makeParams(net_precision_, {input_shape, input_shape, input_shape, input_shape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape)};
auto mul1 = ngraph::builder::makeEltwise(input[0], input[1], ngraph::helpers::EltwiseTypes::ADD);
auto mul2 = ngraph::builder::makeEltwise(input[2], input[3], ngraph::helpers::EltwiseTypes::ADD);
auto convert1 =
@ -259,8 +265,10 @@ public:
// ref function
{
auto input =
ngraph::builder::makeParams(net_precision_, {input_shape, input_shape, input_shape, input_shape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape)};
auto mul1 = ngraph::builder::makeEltwise(input[0], input[1], ngraph::helpers::EltwiseTypes::ADD);
auto mul2 = ngraph::builder::makeEltwise(input[2], input[3], ngraph::helpers::EltwiseTypes::ADD);
auto result1 = std::make_shared<ngraph::opset8::Result>(mul1);
@ -282,8 +290,10 @@ public:
const ngraph::Shape input_shape{1, 10};
// test function
{
auto input =
ngraph::builder::makeParams(net_precision_, {input_shape, input_shape, input_shape, input_shape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape)};
auto mul1 = ngraph::builder::makeEltwise(input[0], input[1], ngraph::helpers::EltwiseTypes::ADD);
auto mul2 = ngraph::builder::makeEltwise(input[2], input[3], ngraph::helpers::EltwiseTypes::ADD);
auto mul3 = ngraph::builder::makeEltwise(mul1, mul2, ngraph::helpers::EltwiseTypes::ADD);
@ -304,8 +314,10 @@ public:
// ref function
{
auto input =
ngraph::builder::makeParams(net_precision_, {input_shape, input_shape, input_shape, input_shape});
ov::ParameterVector input{std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape),
std::make_shared<ov::op::v0::Parameter>(net_precision_, input_shape)};
auto mul1 = ngraph::builder::makeEltwise(input[0], input[1], ngraph::helpers::EltwiseTypes::ADD);
auto mul2 = ngraph::builder::makeEltwise(input[2], input[3], ngraph::helpers::EltwiseTypes::ADD);
auto mul3 = ngraph::builder::makeEltwise(mul1, mul2, ngraph::helpers::EltwiseTypes::ADD);

5
src/plugins/intel_gpu/tests/functional/behavior/infer_request.cpp
View File

@ -78,7 +78,7 @@ void InferRequestIOPrecision::SetUp() {
float clamp_max = 5.0f;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {shape});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape))};
params[0]->set_friendly_name("Input");
auto activation = ngraph::builder::makeActivation(params[0],
@ -139,8 +139,7 @@ TEST(TensorTest, smoke_canSetShapeForPreallocatedTensor) {
}
TEST(TensorTest, smoke_canSetScalarTensor) {
std::vector<std::vector<size_t>> scalar_shape = {{}};
auto params = ngraph::builder::makeParams(ngraph::element::f64, scalar_shape);
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f64, ov::Shape{})};
params.front()->set_friendly_name("Scalar_1");
params.front()->output(0).get_tensor().set_names({"scalar1"});

4
src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp
View File

@ -28,7 +28,7 @@ std::shared_ptr<ngraph::Function> getFunction1() {
const std::vector<size_t> inputShape = {1, 4, 20, 20};
const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
@ -42,7 +42,7 @@ std::shared_ptr<ngraph::Function> getFunction2() {
const std::vector<size_t> inputShape = {1, 4, 20, 20};
const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);

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

@ -73,7 +73,7 @@ void TopKLayerTestGPU::SetUp() {
this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto paramIn = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
auto k = std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{}, &keepK);

20
src/plugins/intel_gpu/tests/functional/single_layer_tests/tensor_iterator.cpp
View File

@ -132,11 +132,15 @@ protected:
// swap batch and seq_lengths
std::swap(inputShapes[0][0], inputShapes[0][1]);
}
auto outer_params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1], inputShapes[2]});
ov::ParameterVector outer_params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[2]))};
// 1. Create TensorIterator body.
inputShapes[0][sequence_axis] = 1; // sliced dimension
auto body_params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1], inputShapes[2]});
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[2]))};
auto squeeze = std::make_shared<ngraph::opset5::Squeeze>(body_params[0], axis);
std::vector<ngraph::Shape> WRB = {inputShapes[3], inputShapes[4], inputShapes[5]};
ngraph::OutputVector out_vector = {squeeze, body_params[1], body_params[2]};
@ -178,11 +182,13 @@ protected:
// swap batch and seq_lengths
std::swap(inputShapes[0][0], inputShapes[0][1]);
}
auto outer_params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]});
ov::ParameterVector outer_params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1]))};
// 1. Create TensorIterator body.
inputShapes[0][sequence_axis] = 1; // sliced dimension
auto body_params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]});
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1]))};
std::vector<ngraph::Shape> WRB = {inputShapes[2], inputShapes[3], inputShapes[4]};
auto squeeze = std::make_shared<ngraph::opset5::Squeeze>(body_params[0], axis);
ngraph::OutputVector out_vector = {squeeze, body_params[1]};
@ -222,11 +228,13 @@ protected:
// swap batch and seq_lengths
std::swap(inputShapes[0][0], inputShapes[0][1]);
}
auto outer_params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]});
ov::ParameterVector outer_params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1]))};
// 1. Create TensorIterator body.
inputShapes[0][sequence_axis] = 1; // sliced dimension
auto body_params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]});
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[0])),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes[1]))};
std::vector<ngraph::Shape> WRB = {inputShapes[2], inputShapes[3], inputShapes[4]};
auto squeeze = std::make_shared<ngraph::opset5::Squeeze>(body_params[0], axis);
ngraph::OutputVector out_vector = {squeeze, body_params[1]};

21
src/plugins/template/tests/functional/op_reference/tensor_iterator.cpp
View File

@ -266,11 +266,15 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
// swap params.batchSize and params.seqLength
std::swap(inputShapes[0][0], inputShapes[0][1]);
}
auto outer_params = ngraph::builder::makeParams(params.iType, {inputShapes[0], inputShapes[1], inputShapes[2]});
ov::ParameterVector outer_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[2])};
// 1. Create TensorIterator body.
inputShapes[0][params.sequenceAxis] = 1; // sliced dimension
auto body_params = ngraph::builder::makeParams(params.iType, {inputShapes[0], inputShapes[1], inputShapes[2]});
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[2])};
auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
ov::OutputVector out_vector = {squeeze, body_params[1], body_params[2]};
@ -329,11 +333,14 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
// swap params.batchSize and params.seqLength
std::swap(inputShapes[0][0], inputShapes[0][1]);
}
auto outer_params = ngraph::builder::makeParams(params.iType, {inputShapes[0], inputShapes[1]});
ov::ParameterVector outer_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
// 1. Create TensorIterator body.
inputShapes[0][params.sequenceAxis] = 1; // sliced dimension
auto body_params = ngraph::builder::makeParams(params.iType, {inputShapes[0], inputShapes[1]});
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
ngraph::OutputVector out_vector = {squeeze, body_params[1]};
@ -388,11 +395,13 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
// swap params.batchSize and params.seqLength
std::swap(inputShapes[0][0], inputShapes[0][1]);
}
auto outer_params = ngraph::builder::makeParams(params.iType, {inputShapes[0], inputShapes[1]});
ov::ParameterVector outer_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
// 1. Create TensorIterator body.
inputShapes[0][params.sequenceAxis] = 1; // sliced dimension
auto body_params = ngraph::builder::makeParams(params.iType, {inputShapes[0], inputShapes[1]});
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
ngraph::OutputVector out_vector = {squeeze, body_params[1]};

4
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/infer_request_dynamic.cpp
View File

@ -16,7 +16,7 @@ std::shared_ptr<ngraph::Function> ovGetFunction1() {
const std::vector<size_t> inputShape = {1, 4, 20, 20};
const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
@ -35,7 +35,7 @@ std::shared_ptr<ngraph::Function> ovGetFunction2() {
const std::vector<size_t> inputShape = {1, 4, 20, 20};
const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32;
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);

10
src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp
View File

@ -871,14 +871,18 @@ std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::RandomUnif
}
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Range> &node) {
const auto params = ngraph::builder::makeParams(ov::element::f32, {std::vector<size_t>(), std::vector<size_t>(), std::vector<size_t>()});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape()),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape()),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape())};
auto Node = std::make_shared<ov::op::v0::Range>(params.at(0), params.at(1), params.at(2));
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
return std::make_shared<ov::Model>(results, params, "RangeGraph");
}
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Range> &node) {
const auto params = ngraph::builder::makeParams(ov::element::f32, {std::vector<size_t>(), std::vector<size_t>(), std::vector<size_t>()});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape()),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape()),
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape())};
auto Node = std::make_shared<ov::op::v4::Range>(params.at(0), params.at(1), params.at(2), ov::element::f32);
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
return std::make_shared<ov::Model>(results, params, "RangeGraph");
@ -907,7 +911,7 @@ std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Reshape> &
}
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Result> &node) {
const auto params = ngraph::builder::makeParams(ov::element::f32, {{2, 2}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2})};
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(params.at(0))};
return std::make_shared<ov::Model>(results, params, "ResultGraph");
}

2
src/tests/functional/plugin/shared/include/behavior/plugin/preprocessing.hpp
View File

@ -86,7 +86,7 @@ public:
auto make_ngraph = [&](bool with_extra_conv) {
auto in_prec = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(with_extra_conv ? inPrc : decltype(inPrc)(InferenceEngine::Precision::FP32));
auto paramsIn = ngraph::builder::makeParams(in_prec, {inputShape});
ov::ParameterVector paramsIn {std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(inputShape))};
auto paramIn = ngraph::helpers::convert2OutputVector(
ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(paramsIn));

4
src/tests/functional/plugin/shared/include/subgraph_tests/basic_lstm.hpp
View File

@ -27,8 +27,8 @@ TEST_P(Basic_LSTM_S, CompareWithRefImpl_LowLatencyTransformation) {
InferenceEngine::SizeVector({1, hidden_size}),
InferenceEngine::Layout::NC);
// Reshape
auto params = ngraph::builder::makeParams(function->get_parameters().at(0)->get_element_type(), { {1, third_dim} });
function->replace_parameter(0, params[0]);
auto params = std::make_shared<ov::op::v0::Parameter>(function->get_parameters().at(0)->get_element_type(), ov::Shape{1, third_dim});
function->replace_parameter(0, params);
// todo: it is better to modify the model -> use ShapeOf() and Gather()
std::vector<uint64_t> outFormShapes1 = { 1, 1, third_dim };

2
src/tests/functional/plugin/shared/src/behavior/executable_network/exec_graph_info.cpp
View File

@ -462,7 +462,7 @@ void ExecGraphUniqueNodeNames::SetUp() {
APIBaseTest::SetUp();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1);
auto concat = std::make_shared<ngraph::opset1::Concat>(split->outputs(), 1);

2
src/tests/functional/plugin/shared/src/behavior/infer_request/set_io_blob_precision.cpp
View File

@ -104,7 +104,7 @@ void SetBlobTest::SetUp() {
outPrc = precNet;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(precNg);
auto params = ngraph::builder::makeParams(ngPrc, {IS});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(IS))};
auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
auto axisNode = std::make_shared<ngraph::op::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{}, std::vector<int64_t>{-1})->output(0);
auto cumSum = std::dynamic_pointer_cast<ngraph::opset4::CumSum>(ngraph::builder::makeCumSum(paramOuts[0], axisNode, false, false));

2
src/tests/functional/plugin/shared/src/execution_graph_tests/num_inputs_fusing_bin_conv.cpp
View File

@ -32,7 +32,7 @@ void ExecGraphInputsFusingBinConv::SetUp() {
const float padValue = 1.0;
targetDevice = this->GetParam();
auto params = ngraph::builder::makeParams(ngraph::element::f32, {inputShapes});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, ov::Shape(inputShapes))};
auto binConv = ngraph::builder::makeBinaryConvolution(params[0], binConvKernelSize, strides, padsBegin, padsEnd, dilations, paddingType, numOutChannels,
padValue);
auto conv = ngraph::builder::makeGroupConvolution(binConv, ngraph::element::f32, convKernelSize, strides, padsBegin, padsEnd, dilations, paddingType,

11
src/tests/functional/plugin/shared/src/execution_graph_tests/runtime_precision.cpp
View File

@ -26,7 +26,8 @@ namespace ExecutionGraphTests {
std::shared_ptr<ngraph::Function> makeEltwiseFunction(const std::vector<InferenceEngine::Precision>& inputPrecisions) {
IE_ASSERT(inputPrecisions.size() == 2);
auto inputs = ngraph::builder::makeParams(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), {{1, 16, 5, 4}});
ov::ParameterVector inputs{
std::make_shared<ov::op::v0::Parameter>(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), ov::Shape{1, 16, 5, 4})};
auto secondaryInput = ngraph::builder::makeInputLayer(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[1]),
ngraph::helpers::InputLayerType::PARAMETER, {{1, 16, 5, 4}});
inputs.push_back(std::dynamic_pointer_cast<ngraph::opset3::Parameter>(secondaryInput));
@ -41,8 +42,8 @@ std::shared_ptr<ngraph::Function> makeEltwiseFunction(const std::vector<Inferenc
std::shared_ptr<ngraph::Function> makeFakeQuantizeReluFunction(const std::vector<InferenceEngine::Precision>& inputPrecisions) {
IE_ASSERT(inputPrecisions.size() == 1);
auto inputs = ngraph::builder::makeParams(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), {{1, 16, 5, 4}});
ov::ParameterVector inputs{
std::make_shared<ov::op::v0::Parameter>(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), ov::Shape{1, 16, 5, 4})};
auto inputLowNode = ngraph::builder::makeConstant<float>(ngraph::element::f32, {1, 1, 1, 1}, {0});
auto inputHighNode = ngraph::builder::makeConstant<float>(ngraph::element::f32, {1, 1, 1, 1}, {255});
auto outputLowNode = ngraph::builder::makeConstant<float>(ngraph::element::f32, {1, 1, 1, 1}, {0});
@ -60,8 +61,8 @@ std::shared_ptr<ngraph::Function> makeFakeQuantizeReluFunction(const std::vector
std::shared_ptr<ngraph::Function> makeFakeQuantizeBinaryConvolutionFunction(const std::vector<InferenceEngine::Precision> &inputPrecisions) {
IE_ASSERT(inputPrecisions.size() == 1);
auto inputs = ngraph::builder::makeParams(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), {{1, 16, 5, 4}});
ov::ParameterVector inputs{
std::make_shared<ov::op::v0::Parameter>(FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inputPrecisions[0]), ov::Shape{1, 16, 5, 4})};
auto inputLowNode = ngraph::builder::makeConstant<float>(ngraph::element::f32, {1, 1, 1, 1}, {1});
auto inputHighNode = ngraph::builder::makeConstant<float>(ngraph::element::f32, {1, 1, 1, 1}, {1});
auto outputLowNode = ngraph::builder::makeConstant<float>(ngraph::element::f32, {1, 1, 1, 1}, {0});

5
src/tests/functional/plugin/shared/src/single_layer_tests/invalid_cases/proposal.cpp
View File

@ -69,7 +69,10 @@ void ProposalBehTest::SetUp() {
std::vector<size_t> imageInfoShape = {3};
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(InferenceEngine::Precision::FP16);
auto params = ngraph::builder::makeParams(ngPrc, {{"scores", scoresShape}, {"boxes", boxesShape}});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(scoresShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(boxesShape))};
params[0]->set_friendly_name("scores");
params[1]->set_friendly_name("boxes");
auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ngraph::op::Parameter>(params));
auto proposal = std::dynamic_pointer_cast<ngraph::opset1::Proposal>(

14
src/tests/functional/shared_test_classes/src/single_layer/activation.cpp
View File

@ -39,7 +39,7 @@ void ActivationLayerTest::SetUp() {
activationType = activationDecl.first;
auto constantsValue = activationDecl.second;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {shapes.first});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shapes.first))};
params[0]->set_friendly_name("Input");
if (activationType == ngraph::helpers::ActivationTypes::PReLu && constantsValue.empty()) {
@ -152,23 +152,25 @@ InferenceEngine::Blob::Ptr ActivationLayerTest::GenerateInput(const InferenceEng
ngraph::ParameterVector ActivationParamLayerTest::createActivationParams(ngraph::element::Type ngPrc, std::vector<size_t> inShape) {
switch (activationType) {
case ngraph::helpers::ActivationTypes::PReLu: {
auto negativeSlopeParam = ngraph::builder::makeParams(ngPrc, {inShape});
ov::ParameterVector negativeSlopeParam {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inShape))};
negativeSlopeParam[0]->set_friendly_name("negativeSlope");
return negativeSlopeParam;
}
case ngraph::helpers::ActivationTypes::LeakyRelu: {
auto leakySlopeParam = ngraph::builder::makeParams(ngPrc, {inShape});
ov::ParameterVector leakySlopeParam {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inShape))};
leakySlopeParam[0]->set_friendly_name("leakySlope");
return leakySlopeParam;
}
case ngraph::helpers::ActivationTypes::HardSigmoid: {
auto hardSigmoidParam = ngraph::builder::makeParams(ngPrc, {inShape, inShape});
ov::ParameterVector hardSigmoidParam {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inShape))};
hardSigmoidParam[0]->set_friendly_name("alpha");
hardSigmoidParam[1]->set_friendly_name("beta");
return hardSigmoidParam;
}
case ngraph::helpers::ActivationTypes::Selu: {
auto seluParam = ngraph::builder::makeParams(ngPrc, {inShape, inShape});
ov::ParameterVector seluParam {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inShape)),
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inShape))};
seluParam[0]->set_friendly_name("alpha");
seluParam[1]->set_friendly_name("lambda");
return seluParam;
@ -209,7 +211,7 @@ void ActivationParamLayerTest::SetUp() {
activationType = activationDecl.first;
constantsValue = activationDecl.second;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {shapes.first});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shapes.first))};
auto activationParams = createActivationParams(ngPrc, shapes.second);
params[0]->set_friendly_name("Input");

2
src/tests/functional/shared_test_classes/src/single_layer/adaptive_pooling.cpp
View File

@ -39,7 +39,7 @@ void AdaPoolLayerTest::SetUp() {
std::tie(inputShape, pooledSpatialShape, poolingMode, netPrecision, targetDevice) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
ngraph::Shape pooledShape = {pooledSpatialShape.size() };
auto pooledParam = ngraph::builder::makeConstant<int32_t>(ngraph::element::i32, pooledShape, pooledSpatialShape);

2
src/tests/functional/shared_test_classes/src/single_layer/batch_norm.cpp
View File

@ -37,7 +37,7 @@ void BatchNormLayerTest::SetUp() {
std::tie(epsilon, netPrecision, inPrc, outPrc, inLayout, outLayout, inputShapes, targetDevice) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShapes});
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapes))};
auto paramOuts = ngraph::helpers::convert2OutputVector(
ngraph::helpers::castOps2Nodes<ngraph::opset4::Parameter>(params));

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