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

Rework makeConstant builder (#21319)

Browse Source 
* Rework make_constant node builder

* Fix

* Apply comments

* Apply comments

* Fix

---------

Co-authored-by: Pavel Durandin <pavel.durandin@intel.com>
This commit is contained in:
Oleg Pipikin 2023-12-22 14:57:05 +01:00 committed by GitHub
parent b0feb2f632
commit 26576b0a30
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
141 changed files with 911 additions and 645 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/common/transformations/tests/common_optimizations/nop_elimination.cpp
View File

@ -12,6 +12,7 @@
#include <string>
#include "common_test_utils/common_utils.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_test_utils.hpp"
#include "common_test_utils/test_common.hpp"
#include "openvino/core/model.hpp"
@ -20,7 +21,6 @@
#include "openvino/opsets/opset9.hpp"
#include "openvino/pass/constant_folding.hpp"
#include "openvino/pass/manager.hpp"
#include "ov_models/builders.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "transformations/init_node_info.hpp"
#include "transformations/rt_info/fused_names_attribute.hpp"
@ -1013,7 +1013,12 @@ TEST_P(EliminateEltwiseTests, eliminate_eltwise) {
constant = op::v0::Constant::create(constant_type, shape2, {1});
break;
case ConstantKind::RANDOM:
constant = ngraph::builder::makeConstant(constant_type, shape2, {}, true, 20 /* upTo */, 2 /* startFrom */);
constant = ov::test::utils::deprecated::make_constant(constant_type,
shape2,
{},
true,
20 /* upTo */,
2 /* startFrom */);
break;
}

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

@ -6,6 +6,7 @@
#include <vector>
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
using namespace ov::test::behavior;
@ -24,11 +25,11 @@ std::shared_ptr<ov::Model> getFunction2() {
std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto in2add = ov::test::utils::deprecated::make_constant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto add = ov::test::utils::make_eltwise(split->output(0), in2add, ov::test::utils::EltwiseTypes::ADD);
auto relu1 = std::make_shared<ov::op::v0::Relu>(add);
auto in2mult = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto in2mult = ov::test::utils::deprecated::make_constant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto mult = ov::test::utils::make_eltwise(split->output(1), in2mult, ov::test::utils::EltwiseTypes::MULTIPLY);
auto relu2 = std::make_shared<ov::op::v0::Relu>(mult);

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

@ -7,6 +7,7 @@
#include "common_test_utils/test_common.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include <openvino/opsets/opset9.hpp>
@ -21,10 +22,10 @@ std::shared_ptr<ov::Model> MakeMatMulModel() {
const ov::element::Type precision = ov::element::f32;
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_const = ov::test::utils::deprecated::make_constant(precision, {4096, 1024}, std::vector<float>{}, true);
auto matmul = std::make_shared<ov::op::v0::MatMul>(params[0], matmul_const);
auto add_const = ngraph::builder::makeConstant(precision, {1, 1024}, std::vector<float>{}, true);
auto add_const = ov::test::utils::deprecated::make_constant(precision, {1, 1024}, std::vector<float>{}, true);
auto add = ov::test::utils::make_eltwise(matmul, add_const, ov::test::utils::EltwiseTypes::ADD);
auto softmax = std::make_shared<ov::opset9::Softmax>(add);

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

@ -7,6 +7,8 @@
#include "behavior/ov_infer_request/infer_request_dynamic.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
using namespace ov::test::behavior;
namespace {
@ -28,7 +30,7 @@ std::shared_ptr<ngraph::Function> getFunction1() {
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 4, 1, 1}, std::vector<float>{}, true);
auto in2add = ov::test::utils::deprecated::make_constant(ngPrc, {1, 4, 1, 1}, std::vector<float>{}, true);
auto add = ov::test::utils::make_eltwise(params[0], in2add, ngraph::helpers::EltwiseTypes::ADD);
auto relu1 = std::make_shared<ov::op::v0::Relu>(add->output(0));
relu1->get_output_tensor(0).set_names({"relu1"});
@ -50,11 +52,11 @@ std::shared_ptr<ngraph::Function> getFunction2() {
auto split = std::make_shared<ov::op::v1::Split>(params[0], split_axis_op, 2);
auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto in2add = ov::test::utils::deprecated::make_constant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto add = ov::test::utils::make_eltwise(split->output(0), in2add, ngraph::helpers::EltwiseTypes::ADD);
auto relu1 = std::make_shared<ov::op::v0::Relu>(add);
auto in2mult = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto in2mult = ov::test::utils::deprecated::make_constant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto mult = ov::test::utils::make_eltwise(split->output(1), in2mult, ngraph::helpers::EltwiseTypes::MULTIPLY);
auto relu2 = std::make_shared<ov::op::v0::Relu>(mult);

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

@ -5,6 +5,7 @@
#include "eltwise.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "gtest/gtest.h"
#include "internal_properties.hpp"
#include "openvino/core/type/element_type.hpp"
@ -188,23 +189,23 @@ void EltwiseLayerCPUTest::SetUp() {
if ((netType == ElementType::i8) || (netType == ElementType::u8)) {
auto data_ptr = reinterpret_cast<uint8_t*>(data_tensor.data());
std::vector<uint8_t> data(data_ptr, data_ptr + ov::shape_size(shape));
secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
secondaryInput = ov::test::utils::deprecated::make_constant(netType, shape, data);
} else if ((netType == ElementType::i16) || (netType == ElementType::u16)) {
auto data_ptr = reinterpret_cast<uint16_t*>(data_tensor.data());
std::vector<uint16_t> data(data_ptr, data_ptr + ov::shape_size(shape));
secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
secondaryInput = ov::test::utils::deprecated::make_constant(netType, shape, data);
} else if ((netType == ElementType::i32) || (netType == ElementType::u32)) {
auto data_ptr = reinterpret_cast<uint32_t*>(data_tensor.data());
std::vector<uint32_t> data(data_ptr, data_ptr + ov::shape_size(shape));
secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
secondaryInput = ov::test::utils::deprecated::make_constant(netType, shape, data);
} else if (netType == ElementType::f16) {
auto data_ptr = reinterpret_cast<ov::float16*>(data_tensor.data());
std::vector<ov::float16> data(data_ptr, data_ptr + ov::shape_size(shape));
secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
secondaryInput = ov::test::utils::deprecated::make_constant(netType, shape, data);
} else {
auto data_ptr = reinterpret_cast<float*>(data_tensor.data());
std::vector<float> data(data_ptr, data_ptr + ov::shape_size(shape));
secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
secondaryInput = ov::test::utils::deprecated::make_constant(netType, shape, data);
}
break;
}

8
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/random_uniform.cpp
View File

@ -3,7 +3,7 @@
//
#include "random_uniform.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
using namespace CPUTestUtils;
@ -97,7 +97,7 @@ void RandomUniformLayerTestCPU::SetUp() {
in_params.back()->set_friendly_name("shape");
inputs.push_back(in_params.back());
} else {
inputs.push_back(ngraph::builder::makeConstant(shape_prc, {m_output_shape.size()}, m_output_shape));
inputs.push_back(ov::test::utils::deprecated::make_constant(shape_prc, {m_output_shape.size()}, m_output_shape));
}
if (!const_in_2) {
in_shapes.push_back({{}, {{1}}});
@ -105,7 +105,7 @@ void RandomUniformLayerTestCPU::SetUp() {
in_params.back()->set_friendly_name("minval");
inputs.push_back(in_params.back());
} else {
inputs.push_back(ngraph::builder::makeConstant(output_prc, {1}, std::vector<double>{m_min_val}));
inputs.push_back(ov::test::utils::deprecated::make_constant(output_prc, {1}, std::vector<double>{m_min_val}));
}
if (!const_in_3) {
in_shapes.push_back({{}, {{1}}});
@ -113,7 +113,7 @@ void RandomUniformLayerTestCPU::SetUp() {
in_params.back()->set_friendly_name("maxval");
inputs.push_back(in_params.back());
} else {
inputs.push_back(ngraph::builder::makeConstant(output_prc, {1}, std::vector<double>{m_max_val}));
inputs.push_back(ov::test::utils::deprecated::make_constant(output_prc, {1}, std::vector<double>{m_max_val}));
}
init_input_shapes(in_shapes);

4
src/plugins/intel_cpu/tests/functional/single_layer_tests/convert_to_plugin_specific_node.cpp
View File

@ -3,7 +3,7 @@
//
#include "common_test_utils/node_builders/eltwise.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -55,7 +55,7 @@ protected:
OPENVINO_ASSERT(shape_size(constShape) == 1);
const auto param = std::make_shared<ov::op::v0::Parameter>(prc, ov::Shape(nonConstShape));
const auto constNode = ngraph::builder::makeConstant(prc, constShape, std::vector<float>{}, true);
const auto constNode = ov::test::utils::deprecated::make_constant(prc, constShape, std::vector<float>{}, true);
OutputVector inputs(2);
inputs[port] = constNode;
inputs[1 - port] = param;

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

@ -3,7 +3,7 @@
//
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -110,10 +110,10 @@ protected:
for (auto&& shape : inputDynamicShapes)
params.push_back(std::make_shared<ov::op::v0::Parameter>(inPrec, shape));
auto il = ngraph::builder::makeConstant(inPrec, ranges[0], rangesBounds[0], rangesBounds[0].empty());
auto ih = ngraph::builder::makeConstant(inPrec, ranges[1], rangesBounds[1], rangesBounds[1].empty());
auto ol = ngraph::builder::makeConstant(inPrec, ranges[2], rangesBounds[2], rangesBounds[2].empty());
auto oh = ngraph::builder::makeConstant(inPrec, ranges[3], rangesBounds[3], rangesBounds[3].empty());
auto il = ov::test::utils::deprecated::make_constant(inPrec, ranges[0], rangesBounds[0], rangesBounds[0].empty());
auto ih = ov::test::utils::deprecated::make_constant(inPrec, ranges[1], rangesBounds[1], rangesBounds[1].empty());
auto ol = ov::test::utils::deprecated::make_constant(inPrec, ranges[2], rangesBounds[2], rangesBounds[2].empty());
auto oh = ov::test::utils::deprecated::make_constant(inPrec, ranges[3], rangesBounds[3], rangesBounds[3].empty());
auto fq = std::make_shared<ov::op::v0::FakeQuantize>(params[0], il, ih, ol, oh, levels);
layerName = shouldBeDecomposed ? "" : "FakeQuantize";

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

@ -2,8 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -95,13 +95,13 @@ protected:
auto maxBeamIndex = inputShape.second.front().at(2) - 1;
inp2 =
ngraph::builder::makeConstant<float>(netPrecision, inputShape.second.front(), {}, true, maxBeamIndex);
inp3 = ngraph::builder::makeConstant<float>(netPrecision,
ov::test::utils::deprecated::make_constant<float>(netPrecision, inputShape.second.front(), {}, true, maxBeamIndex);
inp3 = ov::test::utils::deprecated::make_constant<float>(netPrecision,
{inputShape.second.front().at(1)},
{},
true,
maxBeamIndex);
inp4 = ngraph::builder::makeConstant<float>(netPrecision, {}, {}, true, maxBeamIndex);
inp4 = ov::test::utils::deprecated::make_constant<float>(netPrecision, {}, {}, true, maxBeamIndex);
} else {
throw std::runtime_error("Unsupported inputType");
}

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

@ -3,8 +3,9 @@
//
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "common_test_utils/test_enums.hpp"
using namespace ov::test::utils;
@ -287,7 +288,7 @@ protected:
auto axesNode = std::make_shared<ov::op::v0::Constant>(ov::element::i64, constShape, std::vector<int64_t>{1});
auto s = std::make_shared<ov::op::v8::Slice>(body_params[0], beginNode, endNode, strideNode, axesNode);
auto constant = ngraph::builder::makeConstant(inType, std::vector<size_t>{1}, std::vector<float>{0.5});
auto constant = ov::test::utils::deprecated::make_constant(inType, std::vector<size_t>{1}, std::vector<float>{0.5});
auto eltwise = std::make_shared<ov::op::v1::Add>(body_params[0], constant);
auto body = std::make_shared<ov::Model>(ov::OutputVector{body_condition_const, s, eltwise}, body_params);
@ -356,7 +357,7 @@ protected:
}
// Body
auto constant = ngraph::builder::makeConstant(inType, std::vector<size_t>{1}, std::vector<float>{10});
auto constant = ov::test::utils::deprecated::make_constant(inType, std::vector<size_t>{1}, std::vector<float>{10});
auto add = std::make_shared<ov::op::v1::Add>(body_params[0], constant);
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{body_params[1], add}, 0);

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

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "cpu/cpu_config.hpp"
#include "openvino/runtime/intel_cpu/properties.hpp"
#include "ov_models/builders.hpp"
#include "ov_ops/type_relaxed.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "shared_test_classes/base/utils/generate_inputs.hpp"
@ -133,7 +133,7 @@ protected:
ov::op::v0::MatMul(inputParamsFP32, matrixBFP32, transpose_a, transpose_b),
element::f32);
auto matrixB = ngraph::builder::makeConstant<int8_t>(weiType, inShapeB.get_shape(), weiData);
auto matrixB = ov::test::utils::deprecated::make_constant<int8_t>(weiType, inShapeB.get_shape(), weiData);
auto matMul = matMulRelaxed->copy_with_new_inputs({A, matrixB});

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

@ -2,8 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "shared_test_classes/base/utils/ranges.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -157,12 +157,12 @@ protected:
params[1]->set_friendly_name("param_3");
maxOutBoxesPerClassNode = params.back();
} else {
maxOutBoxesPerClassNode = ngraph::builder::makeConstant(maxBoxPrec, ov::Shape{}, std::vector<int32_t>{maxOutBoxesPerClass});
maxOutBoxesPerClassNode = ov::test::utils::deprecated::make_constant(maxBoxPrec, ov::Shape{}, std::vector<int32_t>{maxOutBoxesPerClass});
}
auto iouThrNode = ngraph::builder::makeConstant(thrPrec, ov::Shape{}, std::vector<float>{iouThr})->output(0);
auto scoreThrNode = ngraph::builder::makeConstant(thrPrec, ov::Shape{}, std::vector<float>{scoreThr})->output(0);
auto softNmsSigmaNode = ngraph::builder::makeConstant(thrPrec, ov::Shape{}, std::vector<float>{softNmsSigma})->output(0);
auto iouThrNode = ov::test::utils::deprecated::make_constant(thrPrec, ov::Shape{}, std::vector<float>{iouThr})->output(0);
auto scoreThrNode = ov::test::utils::deprecated::make_constant(thrPrec, ov::Shape{}, std::vector<float>{scoreThr})->output(0);
auto softNmsSigmaNode = ov::test::utils::deprecated::make_constant(thrPrec, ov::Shape{}, std::vector<float>{softNmsSigma})->output(0);
auto nms = std::make_shared<ov::op::v9::NonMaxSuppression>(params[0], params[1], maxOutBoxesPerClassNode, iouThrNode, scoreThrNode,
softNmsSigmaNode, boxEncoding, sortResDescend, outType);

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

@ -4,7 +4,7 @@
#include "test_utils/cpu_test_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
using namespace InferenceEngine;
@ -86,7 +86,7 @@ protected:
ngraph::Shape proposalShape = { proposal.size() / 5, 5 };
auto coords = ngraph::builder::makeConstant<float>(ngraph::element::f32, proposalShape, proposal);
auto coords = ov::test::utils::deprecated::make_constant<float>(ngraph::element::f32, proposalShape, proposal);
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, ov::Shape(featureMapShape))};
auto psroi = std::make_shared<ov::op::v0::PSROIPooling>(params[0], coords, outputDim, groupSize,

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

@ -2,8 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -80,7 +80,7 @@ protected:
paramsIn.push_back(param);
} else {
const auto maxSeqLength = dataInputShape.second.front().at(seqAxisIndex);
seqLengthsInput = ngraph::builder::makeConstant<float>(seqLengthsPrc, seqLengthsShape.second.front(), {}, true, maxSeqLength);
seqLengthsInput = ov::test::utils::deprecated::make_constant<float>(seqLengthsPrc, seqLengthsShape.second.front(), {}, true, maxSeqLength);
}
const auto reverse = std::make_shared<ov::op::v0::ReverseSequence>(paramsIn.front(), seqLengthsInput, batchAxisIndex, seqAxisIndex);

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

@ -2,8 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -167,7 +167,7 @@ protected:
secondaryInput = param;
inputs.push_back(param);
} else {
secondaryInput = ngraph::builder::makeConstant(secondInPrc, {inpDesc.data[0].size()}, inpDesc.data[0]);
secondaryInput = ov::test::utils::deprecated::make_constant(secondInPrc, {inpDesc.data[0].size()}, inpDesc.data[0]);
}
std::shared_ptr<ov::Node> shapeOps;

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

@ -2,8 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "ov_models/builders.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -67,7 +67,7 @@ public:
dilation,
ov::op::PadType::AUTO,
convOutChannels);
auto bias = ngraph::builder::makeConstant<float>(ov::element::Type_t::f32,
auto bias = ov::test::utils::deprecated::make_constant<float>(ov::element::Type_t::f32,
ov::Shape({1, convOutChannels, 1, 1}),
{},
true);

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

@ -4,7 +4,7 @@
#include <ngraph/opsets/opset8.hpp>
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -40,15 +40,15 @@ public:
const auto targetFormat = nhwc;
auto mul1 = std::make_shared<ov::op::v1::Multiply>(
concat,
ngraph::builder::makeConstant(ov::element::f32, Shape{1}, std::vector<float>{4}));
ov::test::utils::deprecated::make_constant(ov::element::f32, Shape{1}, std::vector<float>{4}));
mul1->get_rt_info() = CPUTestsBase::makeCPUInfo({targetFormat}, {targetFormat}, {});
auto mul2 = std::make_shared<ov::op::v1::Multiply>(
concat,
ngraph::builder::makeConstant(ov::element::f32, Shape{1}, std::vector<float>{5}));
ov::test::utils::deprecated::make_constant(ov::element::f32, Shape{1}, std::vector<float>{5}));
mul2->get_rt_info() = CPUTestsBase::makeCPUInfo({targetFormat}, {targetFormat}, {});
auto mul3 = std::make_shared<ov::op::v1::Multiply>(
concat,
ngraph::builder::makeConstant(ov::element::f32, Shape{1}, std::vector<float>{6}));
ov::test::utils::deprecated::make_constant(ov::element::f32, Shape{1}, std::vector<float>{6}));
mul3->get_rt_info() = CPUTestsBase::makeCPUInfo({targetFormat}, {targetFormat}, {});
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(mul1),

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

@ -4,7 +4,7 @@
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
/*This test runs the following subgraph:
@ -84,7 +84,7 @@ public:
for (size_t i = 0; i < number_of_params; ++i) {
auto soft_max = std::make_shared<ov::op::v1::Softmax>(input_params[i], softmax_axis);
auto reshape_param = ngraph::builder::makeConstant<int>(ov::element::i32, {1}, {0});
auto reshape_param = ov::test::utils::deprecated::make_constant<int>(ov::element::i32, {1}, {0});
auto reshape = std::make_shared<ov::op::v0::Unsqueeze>(soft_max, reshape_param);
first_level_reshapes.push_back(reshape);
}
@ -96,7 +96,7 @@ public:
ov::NodeVector first_level_concats = {concat1, concat2};
for (size_t i = 0; i < number_of_params / 2; ++i) {
auto reshape_param = ngraph::builder::makeConstant<int>(ov::element::i32, {1}, {0});
auto reshape_param = ov::test::utils::deprecated::make_constant<int>(ov::element::i32, {1}, {0});
auto reshape = std::make_shared<ov::op::v0::Unsqueeze>(first_level_concats[i], reshape_param);
second_level_reshapes.push_back(reshape);
}

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

@ -2,13 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/group_convolution.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "test_utils/cpu_test_utils.hpp"
#include "shared_test_classes/base/layer_test_utils.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/group_convolution.hpp"
namespace ov {
namespace test {
@ -26,7 +26,7 @@ protected:
for (auto&& shape : inputDynamicShapes) {
params.push_back(std::make_shared<ov::op::v0::Parameter>(precision, shape));
}
auto conv_weights = ngraph::builder::makeConstant(precision, std::vector<size_t>{32, 32, 1, 1}, std::vector<float>{}, true);
auto conv_weights = ov::test::utils::deprecated::make_constant(precision, std::vector<size_t>{32, 32, 1, 1}, std::vector<float>{}, true);
auto conv = ov::test::utils::make_convolution(params[0],
conv_weights,
precision,
@ -39,7 +39,7 @@ protected:
32,
true);
auto dw_conv_weights = ngraph::builder::makeConstant(precision, std::vector<size_t>{32, 1, 1, 3, 3}, std::vector<float>{}, true);
auto dw_conv_weights = ov::test::utils::deprecated::make_constant(precision, std::vector<size_t>{32, 1, 1, 3, 3}, std::vector<float>{}, true);
auto dw_conv = ov::test::utils::make_group_convolution(conv,
dw_conv_weights,
precision,
@ -48,7 +48,7 @@ protected:
ov::CoordinateDiff{1, 1},
std::vector<size_t>{1, 1},
ov::op::PadType::EXPLICIT);
auto bias_const = ngraph::builder::makeConstant(precision, {1, 32 , 1, 1}, std::vector<float>{}, true);
auto bias_const = ov::test::utils::deprecated::make_constant(precision, {1, 32 , 1, 1}, std::vector<float>{}, true);
auto bias = std::make_shared<ov::opset10::Add>(dw_conv, bias_const);
function = std::make_shared<ov::Model>(bias, params, "ConvDWConv");
}

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

@ -3,6 +3,7 @@
//
#include "common_test_utils/node_builders/activation.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "internal_properties.hpp"
#include "ov_models/builders.hpp"
@ -110,7 +111,7 @@ public:
auto conv = makeConv(inputParams);
if (bias) {
auto biasNode = ngraph::builder::makeConstant<float>(ov::element::Type_t::f32, ov::Shape({1, _convOutChannels, 1, 1}), {}, true);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(ov::element::Type_t::f32, ov::Shape({1, _convOutChannels, 1, 1}), {}, true);
conv = std::make_shared<ov::op::v1::Add>(conv, biasNode);
}
@ -219,7 +220,7 @@ public:
auto inpShape = inputParams.front()->get_partial_shape();
Shape filterShape = {_convOutChannels, static_cast<size_t>(inpShape[1].get_length())};
filterShape.insert(filterShape.end(), _kernel.begin(), _kernel.end());
auto filterWeightsNode = ngraph::builder::makeConstant<int8_t>(ov::element::i8, filterShape, {}, true);
auto filterWeightsNode = ov::test::utils::deprecated::make_constant<int8_t>(ov::element::i8, filterShape, {}, true);
auto conv = convolutionNodeRelaxed->copy_with_new_inputs({inputParams.front(), filterWeightsNode});
@ -283,12 +284,12 @@ namespace {
const auto fusingMulAddFQMullAdd = fusingSpecificParams{ std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"},
{[](postNodeConfig& cfg){
@ -298,24 +299,24 @@ const auto fusingMulAddFQMullAdd = fusingSpecificParams{ std::make_shared<postNo
}, "FakeQuantize(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"}}), {"Add"} };
const auto fusingDivSubFQ = fusingSpecificParams{ std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape = generatePerChannelShape(cfg.input);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Divide>(cfg.input, secondMultInput);
}, "Divide(PerChannel)"},
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape = generatePerChannelShape(cfg.input);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Subtract>(cfg.input, secondMultInput);
}, "Subtract(PerChannel)"},
{[](postNodeConfig& cfg){

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

@ -4,6 +4,7 @@
#include "subgraph_tests/include/conv_with_zero_point_fuse.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/group_convolution.hpp"
#include "test_utils/convolution_params.hpp"
@ -71,13 +72,13 @@ void ConvWithZeroPointFuseSubgraphTest::SetUp() {
const ov::Shape weights_const_shape = {numOutChannels, inputShapes[1], kernelSize[0], kernelSize[1]};
const auto weights_const_values = std::vector<int>(ov::shape_size(weights_const_shape), 1);
const auto weights_const =
ngraph::builder::makeConstant(ov::element::i8, weights_const_shape, weights_const_values);
ov::test::utils::deprecated::make_constant(ov::element::i8, weights_const_shape, weights_const_values);
const auto weights_convert = std::make_shared<ov::op::v0::Convert>(weights_const, ov::element::f32);
const auto weights_multiply = std::make_shared<ov::opset10::Multiply>(
weights_convert,
ngraph::builder::makeConstant(ov::element::f32,
ov::test::utils::deprecated::make_constant(ov::element::f32,
{numOutChannels, 1, 1, 1},
std::vector<float>(numOutChannels, 1.0)));
@ -100,7 +101,7 @@ void ConvWithZeroPointFuseSubgraphTest::SetUp() {
fq_conv_data,
std::make_shared<ov::opset10::Reshape>(
weights_multiply,
ngraph::builder::makeConstant(
ov::test::utils::deprecated::make_constant(
ov::element::i32,
{5},
std::vector<size_t>{1, numOutChannels, inputShapes[1], kernelSize[0], kernelSize[1]}),

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

@ -3,6 +3,7 @@
//
#include "common_test_utils/common_utils.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "openvino/core/node.hpp"
#include "openvino/core/type/element_type.hpp"
@ -130,12 +131,12 @@ protected:
if (quantizedHiddenState) {
H = makeDataFQ(inputParams[1]);
} else {
H = ngraph::builder::makeConstant(ov::element::f32, inputDynamicShapes[1].get_shape(), {}, true, 1.f, -1.f);
H = ov::test::utils::deprecated::make_constant(ov::element::f32, inputDynamicShapes[1].get_shape(), {}, true, 1.f, -1.f);
}
auto W = ngraph::builder::makeConstant(ov::element::f32, {numDirections, numOfGates * hiddenSize, inputSize}, {}, true, 1.f, -1.f);
auto R = ngraph::builder::makeConstant(ov::element::f32, {numDirections, numOfGates * hiddenSize, hiddenSize}, {}, true, 1.f, -1.f);
auto B = ngraph::builder::makeConstant(ov::element::f32, {numDirections, numOfBiasGates * hiddenSize}, {}, true, 0.1f, -0.1f);
auto W = ov::test::utils::deprecated::make_constant(ov::element::f32, {numDirections, numOfGates * hiddenSize, inputSize}, {}, true, 1.f, -1.f);
auto R = ov::test::utils::deprecated::make_constant(ov::element::f32, {numDirections, numOfGates * hiddenSize, hiddenSize}, {}, true, 1.f, -1.f);
auto B = ov::test::utils::deprecated::make_constant(ov::element::f32, {numDirections, numOfBiasGates * hiddenSize}, {}, true, 0.1f, -0.1f);
auto makeWeightsFQ = [](const std::shared_ptr<Node> weight) {
const auto fqLevelsW = 255;

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

@ -5,6 +5,7 @@
#include "common_test_utils/node_builders/activation.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -68,7 +69,7 @@ protected:
{2.106050491333008});
auto Const =
ngraph::builder::makeConstant(netPrecision, {128, 512, 1}, std::vector<float>{-0.0512377955019474}, false);
ov::test::utils::deprecated::make_constant(netPrecision, {128, 512, 1}, std::vector<float>{-0.0512377955019474}, false);
auto FQ_2 = ngraph::builder::makeFakeQuantize(Const,
netPrecision,
255,
@ -96,7 +97,7 @@ protected:
{-3.2050728797912598},
{3.1800332069396973});
auto Const_ = ngraph::builder::makeConstant(netPrecision,
auto Const_ = ov::test::utils::deprecated::make_constant(netPrecision,
{128, 512, 1},
std::vector<float>{-0.001183388871140778},
false);

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

@ -38,6 +38,7 @@
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include <memory>
#include <string>
@ -177,7 +178,7 @@ protected:
256, fqInputShapes[1]);
}
if (needReshape) {
auto reshapeConstNode = ngraph::builder::makeConstant(ov::element::Type(ov::element::Type_t::i32),
auto reshapeConstNode = ov::test::utils::deprecated::make_constant(ov::element::Type(ov::element::Type_t::i32),
{reshapeShape.size()}, reshapeShape);
lastNode1 = std::make_shared<ov::op::v1::Reshape>(lastNode1, reshapeConstNode, false);
}

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

@ -8,6 +8,7 @@
#include <memory>
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/common_utils.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
@ -104,7 +105,7 @@ protected:
for (size_t i = 1; i < inputPrecisions.size(); i++) {
std::vector<float> input1Data(ov::shape_size(targetStaticShapes[0][i]));
inputNodes.push_back(
ngraph::builder::makeConstant(inputPrecisions[i], targetStaticShapes[0][i], input1Data, true));
ov::test::utils::deprecated::make_constant(inputPrecisions[i], targetStaticShapes[0][i], input1Data, true));
}
}

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

@ -28,7 +28,7 @@
// --------
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "test_utils/cpu_test_utils.hpp"
#include "internal_properties.hpp"
@ -169,13 +169,13 @@ protected:
auto ranges = rangesVec[i];
auto il = ngraph::builder::makeConstant(ngInPrec, ranges[0], extendData(rangesBounds[0],
auto il = ov::test::utils::deprecated::make_constant(ngInPrec, ranges[0], extendData(rangesBounds[0],
std::accumulate(ranges[0].begin(), ranges[0].end(), 1, std::multiplies<size_t>())));
auto ih = ngraph::builder::makeConstant(ngInPrec, ranges[1], extendData(rangesBounds[1],
auto ih = ov::test::utils::deprecated::make_constant(ngInPrec, ranges[1], extendData(rangesBounds[1],
std::accumulate(ranges[1].begin(), ranges[1].end(), 1, std::multiplies<size_t>())));
auto ol = ngraph::builder::makeConstant(ngInPrec, ranges[2], extendData(rangesBounds[2],
auto ol = ov::test::utils::deprecated::make_constant(ngInPrec, ranges[2], extendData(rangesBounds[2],
std::accumulate(ranges[2].begin(), ranges[2].end(), 1, std::multiplies<size_t>())));
auto oh = ngraph::builder::makeConstant(ngInPrec, ranges[3], extendData(rangesBounds[3],
auto oh = ov::test::utils::deprecated::make_constant(ngInPrec, ranges[3], extendData(rangesBounds[3],
std::accumulate(ranges[3].begin(), ranges[3].end(), 1, std::multiplies<size_t>())));
auto fqNode = std::make_shared<ov::op::v0::FakeQuantize>(paramVect[i], il, ih, ol, oh, levels);
@ -188,7 +188,7 @@ protected:
if (!reshapeShape.empty()) {
auto reshapeConstNode =
ngraph::builder::makeConstant(ov::element::i32, {reshapeShape.size()}, reshapeShape);
ov::test::utils::deprecated::make_constant(ov::element::i32, {reshapeShape.size()}, reshapeShape);
lastNode1 = std::make_shared<ov::op::v1::Reshape>(lastNode1, reshapeConstNode, false);
}
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{lastNode0, lastNode1}, 0);

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

@ -3,8 +3,8 @@
//
#include "subgraph_tests/include/fuse_transpose_reorder.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "ov_models/builders.hpp"
#include "ov_models/preprocess/preprocess_builders.hpp"
#include "openvino/openvino.hpp"
@ -82,7 +82,7 @@ void FuseTransposeAndReorderTest::create_model() {
auto order = input_shape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1};
auto memFmt = input_shape.size() == 5 ? ndhwc : nhwc;
auto constOrder = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto constOrder = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, order);
auto transpose = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder);
transpose->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});
@ -138,22 +138,22 @@ void FuseTransposeAndReorderTest1::create_model() {
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape))};
auto order = input_shape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1};
auto constOrder1 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto constOrder1 = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, order);
auto transpose1 = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder1);
auto memFmt1 = input_shape.size() == 5 ? ndhwc : nhwc;
transpose1->get_rt_info() = makeCPUInfo({memFmt1}, {memFmt1}, {});
auto constOrder2 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto constOrder2 = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, order);
auto transpose2 = std::make_shared<ov::op::v1::Transpose>(transpose1, constOrder2);
auto memFmt2 = input_shape.size() == 5 ? ndhwc : nhwc;
transpose2->get_rt_info() = makeCPUInfo({memFmt2}, {memFmt2}, {});
auto constOrder3 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto constOrder3 = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, order);
auto transpose3 = std::make_shared<ov::op::v1::Transpose>(transpose2, constOrder3);
auto memFmt3 = input_shape.size() == 5 ? ncdhw : nchw;
transpose3->get_rt_info() = makeCPUInfo({memFmt3}, {memFmt3}, {});
auto shape = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, transpose3->get_output_shape(0));
auto shape = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, transpose3->get_output_shape(0));
auto reshape = std::make_shared<ov::op::v1::Reshape>(transpose1, shape, false);
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{transpose3, reshape}, 1);
@ -204,12 +204,12 @@ void FuseTransposeAndReorderTest2::create_model() {
std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape2))};
auto order = input_shape.size() == 5 ? std::vector<int64_t>{0, 4, 1, 2, 3} : std::vector<int64_t>{0, 3, 1, 2};
auto constOrder1 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto constOrder1 = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, order);
auto transpose1 = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder1);
auto memFmt1 = input_shape.size() == 5 ? ndhwc : nhwc;
transpose1->get_rt_info() = makeCPUInfo({memFmt1}, {memFmt1}, {});
auto constOrder2 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto constOrder2 = ov::test::utils::deprecated::make_constant(ov::element::i64, {input_shape.size()}, order);
auto transpose2 = std::make_shared<ov::op::v1::Transpose>(params[1], constOrder2);
auto memFmt2 = input_shape.size() == 5 ? ncdhw : nchw;
transpose2->get_rt_info() = makeCPUInfo({memFmt2}, {memFmt2}, {});
@ -270,7 +270,7 @@ void FuseTransposeAndReorderTest3::create_model() {
auto add = std::make_shared<ov::op::v1::Add>(convolutionNode->output(0), sndAddIn);
auto order = std::vector<int64_t>{0, 2, 3, 1};
auto constOrder = ngraph::builder::makeConstant(ov::element::i64, {order.size()}, order);
auto constOrder = ov::test::utils::deprecated::make_constant(ov::element::i64, {order.size()}, order);
auto transpose = std::make_shared<ov::op::v1::Transpose>(add, constOrder);
transpose->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});

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

@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/fusing_test_utils.hpp"
#include "transformations/rt_info/decompression.hpp"
@ -211,7 +211,7 @@ protected:
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(inType, inShapeA)};
std::shared_ptr<ov::Node> inputB =
ngraph::builder::makeConstant<float>(weiConstElemType, inShapeB.get_shape(), {}, true);
ov::test::utils::deprecated::make_constant<float>(weiConstElemType, inShapeB.get_shape(), {}, true);
if (weiConstElemType == ElementType::f16) {
inputB = std::make_shared<ov::op::v0::Convert>(inputB, convertOutType);
mark_as_decompression(inputB);
@ -484,7 +484,7 @@ protected:
params.push_back(std::make_shared<ov::op::v0::Parameter>(inType, shape));
}
std::shared_ptr<ov::Node> inputWeights =
ngraph::builder::makeConstant<float>(weiConstElemType, inShapeWeights.get_shape(), {}, true);
ov::test::utils::deprecated::make_constant<float>(weiConstElemType, inShapeWeights.get_shape(), {}, true);
if (weiConstElemType == ElementType::f16) {
inputWeights = std::make_shared<ov::op::v0::Convert>(inputWeights, convertOutType);
mark_as_decompression(inputWeights);

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

@ -5,6 +5,7 @@
#include "test_utils/cpu_test_utils.hpp"
#include "test_utils/fusing_test_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/common_utils.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
@ -76,12 +77,12 @@ protected:
if (isFC) {
ov::Shape weightShape = inShapes;
std::swap(weightShape[0], weightShape[1]);
auto weightsNode = ngraph::builder::makeConstant(ngPrec, weightShape, std::vector<float>{0.0f}, true);
auto weightsNode = ov::test::utils::deprecated::make_constant(ngPrec, weightShape, std::vector<float>{0.0f}, true);
auto fq2 = ngraph::builder::makeFakeQuantize(weightsNode, ngPrec, 256, {}, {-1.28f}, {1.27f}, {-1.28f}, {1.27f});
auto fc = std::make_shared<ov::op::v0::MatMul>(fq1, fq2, false, false);
fc->get_rt_info() = getCPUInfo();
fc->set_friendly_name(nameMatmul);
auto biasWeightsNode = ngraph::builder::makeConstant(ngPrec, {}, std::vector<float>{0.0f}, true);
auto biasWeightsNode = ov::test::utils::deprecated::make_constant(ngPrec, {}, std::vector<float>{0.0f}, true);
matMul = std::make_shared<ov::op::v1::Add>(fc, biasWeightsNode);
} else {
auto fq2 = ngraph::builder::makeFakeQuantize(inputParams[0], ngPrec, 256, {}, {-1.28f}, {1.27f}, {-1.28f}, {1.27f});
@ -98,7 +99,7 @@ protected:
// matmul->fq->matmul can cover x8*s8->x8 case
auto filterWeightsShape = matMul->get_output_shape(0);
auto filterWeightsNode = ngraph::builder::makeConstant(ov::element::f32, filterWeightsShape, std::vector<float>{}, true);
auto filterWeightsNode = ov::test::utils::deprecated::make_constant(ov::element::f32, filterWeightsShape, std::vector<float>{}, true);
auto fq3 = ngraph::builder::makeFakeQuantize(filterWeightsNode, ngPrec, 256, {}, {-1.28f}, {1.27f}, {-1.28f}, {1.27f});
// only matmul avx2 support s8*s8 input
auto matMul2 = std::make_shared<ov::op::v0::MatMul>(nodeBeforeConv, fq3, false, false);

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

@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/fusing_test_utils.hpp"
#include "transformations/rt_info/decompression.hpp"
@ -165,7 +165,7 @@ protected:
}
auto up_to = weights_precision == ov::element::i4 ? 7 : 15;
auto weights = ngraph::builder::makeConstant<int8_t>(weights_precision, transformed_weights_shape, {}, true, up_to);
auto weights = ov::test::utils::deprecated::make_constant<int8_t>(weights_precision, transformed_weights_shape, {}, true, up_to);
weights->set_friendly_name("Compressed_weights");
auto weights_convert = std::make_shared<ov::op::v0::Convert>(weights, decompression_precision);
@ -188,7 +188,7 @@ protected:
scaleshift_const_shape.erase(std::remove(scaleshift_const_shape.begin(), scaleshift_const_shape.end(), 1), scaleshift_const_shape.end());
if (decompression_subtract_type != DecompressionSubtractType::empty) {
auto subtract_shape = decompression_subtract_type == DecompressionSubtractType::full ? scaleshift_const_shape : Shape({});
auto shift_const = ngraph::builder::makeConstant<uint8_t>(weights_precision, subtract_shape, {}, true, up_to);
auto shift_const = ov::test::utils::deprecated::make_constant<uint8_t>(weights_precision, subtract_shape, {}, true, up_to);
std::shared_ptr<ov::Node> shift_convert = std::make_shared<ov::op::v0::Convert>(shift_const, decompression_precision);
if (reshape_on_decompression_constant) {
auto subtract_target_shape = decompression_subtract_type == DecompressionSubtractType::full
@ -200,7 +200,7 @@ protected:
mul_parent = std::make_shared<ov::opset10::Subtract>(weights_convert, shift_convert);
}
std::shared_ptr<ov::Node> scale_const = ngraph::builder::makeConstant<float>(decompression_precision, scaleshift_const_shape, {}, true);
std::shared_ptr<ov::Node> scale_const = ov::test::utils::deprecated::make_constant<float>(decompression_precision, scaleshift_const_shape, {}, true);
if (reshape_on_decompression_constant) {
auto scale_reshape_const = ov::opset10::Constant::create(ov::element::i32, {scaleshift_target_shape.size()}, scaleshift_target_shape);
auto scale_reshape = std::make_shared<ov::opset10::Reshape>(scale_const, scale_reshape_const, false);

45
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/mha.cpp
View File

@ -4,6 +4,7 @@
#include "common_test_utils/common_utils.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "functional_test_utils/skip_tests_config.hpp"
#include "internal_properties.hpp"
#include "ov_models/builders.hpp"
@ -51,31 +52,31 @@ static std::shared_ptr<ov::Model> initMHASubgraph0(std::vector<ov::PartialShape>
constantShapes.push_back(ov::Shape({inputDynamicShapes[0].get_shape().size()}));
std::vector<int64_t> transpose0ConstData = {0, 2, 1, 3};
auto transpose0Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[0], transpose0ConstData);
auto transpose0Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[0], transpose0ConstData);
std::vector<int64_t> transpose1ConstData = {0, 2, 3, 1};
auto transpose1Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[1], transpose1ConstData);
auto transpose1Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[1], transpose1ConstData);
std::vector<float> mulConstData(ov::shape_size(constantShapes[2]));
auto mulConst = ngraph::builder::makeConstant(inputPrecisions[0], constantShapes[2], mulConstData, true);
auto mulConst = ov::test::utils::deprecated::make_constant(inputPrecisions[0], constantShapes[2], mulConstData, true);
std::vector<int64_t> reshape0ConstData = {
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[0] * inputDynamicShapes[0].get_shape()[1] *
inputDynamicShapes[0].get_shape()[2]),
-1};
auto reshape0Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[3], reshape0ConstData);
auto reshape0Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[3], reshape0ConstData);
std::vector<int64_t> reshape1ConstData = {static_cast<int64_t>(inputDynamicShapes[0].get_shape()[0]),
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[2]),
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[1]),
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[1])};
auto reshape1Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[4], reshape1ConstData);
auto reshape1Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[4], reshape1ConstData);
std::vector<int64_t> transpose2ConstData = {0, 2, 1, 3};
auto transpose2Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[5], transpose2ConstData);
auto transpose2Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[5], transpose2ConstData);
std::vector<int64_t> transpose3ConstData = {0, 2, 1, 3};
auto transpose3Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[6], transpose3ConstData);
auto transpose3Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[6], transpose3ConstData);
float transA = false;
float transB = false;
@ -121,16 +122,16 @@ static std::shared_ptr<ov::Model> initMHASubgraph1(std::vector<ov::PartialShape>
constantShapes.push_back(ov::Shape({inputDynamicShapes[0].get_shape().size()}));
std::vector<int64_t> transpose0ConstData = {0, 2, 1, 3};
auto transpose0Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[0], transpose0ConstData);
auto transpose0Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[0], transpose0ConstData);
std::vector<int64_t> transpose1ConstData = {0, 2, 3, 1};
auto transpose1Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[1], transpose1ConstData);
auto transpose1Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[1], transpose1ConstData);
std::vector<int64_t> transpose2ConstData = {0, 2, 1, 3};
auto transpose2Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[0], transpose2ConstData);
auto transpose2Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[0], transpose2ConstData);
std::vector<int64_t> transpose3ConstData = {0, 2, 1, 3};
auto transpose3Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[1], transpose3ConstData);
auto transpose3Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[1], transpose3ConstData);
float transA = false;
float transB = false;
@ -336,28 +337,28 @@ static std::shared_ptr<ov::Model> initMHAQuantSubgraph0(std::vector<ov::PartialS
constantShapes.push_back(ov::Shape({inputDynamicShapes[0].get_shape().size()}));
std::vector<int64_t> transpose0ConstData = {0, 2, 1, 3};
auto transpose0Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[0], transpose0ConstData);
auto transpose0Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[0], transpose0ConstData);
std::vector<int64_t> transpose1ConstData = {0, 2, 3, 1};
auto transpose1Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[1], transpose1ConstData);
auto transpose1Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[1], transpose1ConstData);
std::vector<int64_t> reshape0ConstData = {
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[0] * inputDynamicShapes[0].get_shape()[1] *
inputDynamicShapes[0].get_shape()[2]),
-1};
auto reshape0Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[2], reshape0ConstData);
auto reshape0Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[2], reshape0ConstData);
std::vector<int64_t> reshape1ConstData = {static_cast<int64_t>(inputDynamicShapes[0].get_shape()[0]),
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[2]),
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[1]),
static_cast<int64_t>(inputDynamicShapes[0].get_shape()[1])};
auto reshape1Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[3], reshape1ConstData);
auto reshape1Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[3], reshape1ConstData);
std::vector<int64_t> transpose2ConstData = {0, 2, 1, 3};
auto transpose2Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[4], transpose2ConstData);
auto transpose2Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[4], transpose2ConstData);
std::vector<int64_t> transpose3ConstData = {0, 2, 1, 3};
auto transpose3Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[5], transpose3ConstData);
auto transpose3Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[5], transpose3ConstData);
float transA = false;
float transB = false;
@ -464,19 +465,19 @@ static std::shared_ptr<ov::Model> initMHAQuantSubgraph1(const std::vector<ov::Pa
constantShapes.push_back(ov::Shape({1}));
std::vector<int64_t> transpose0ConstData = {0, 2, 1, 3};
auto transpose0Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[0], transpose0ConstData);
auto transpose0Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[0], transpose0ConstData);
std::vector<int64_t> transpose1ConstData = {0, 2, 3, 1};
auto transpose1Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[1], transpose1ConstData);
auto transpose1Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[1], transpose1ConstData);
std::vector<int64_t> transpose2ConstData = {0, 2, 1, 3};
auto transpose2Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[2], transpose2ConstData);
auto transpose2Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[2], transpose2ConstData);
std::vector<int64_t> transpose3ConstData = {0, 2, 1, 3};
auto transpose3Const = ngraph::builder::makeConstant(ElementType::i64, constantShapes[3], transpose3ConstData);
auto transpose3Const = ov::test::utils::deprecated::make_constant(ElementType::i64, constantShapes[3], transpose3ConstData);
std::vector<float> mulConstData(ov::shape_size(constantShapes[4]));
auto mulConst = ngraph::builder::makeConstant(inputPrecisions[0], constantShapes[4], mulConstData, true);
auto mulConst = ov::test::utils::deprecated::make_constant(inputPrecisions[0], constantShapes[4], mulConstData, true);
float transA = false;
float transB = false;

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

@ -2,9 +2,9 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -39,9 +39,8 @@ protected:
paddingType,
numOutChannels);
}
const auto sharedNode = ngraph::builder::makeConstant(element::f32, {1, 16, 1, 1}, std::vector<float>{}, true);
const auto sharedNode = ov::test::utils::deprecated::make_constant(element::f32, {1, 16, 1, 1}, std::vector<float>{}, true);
const auto postOpCandidate = ov::test::utils::make_eltwise(conv, sharedNode, utils::EltwiseTypes::ADD);
const auto secondConsumpt = ov::test::utils::make_eltwise(inputParams[1], sharedNode, utils::EltwiseTypes::ADD);
NodeVector results{postOpCandidate, secondConsumpt};

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

@ -3,6 +3,7 @@
//
#include "common_test_utils/node_builders/activation.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
#include "test_utils/fusing_test_utils.hpp"
@ -40,9 +41,9 @@ public:
init_input_shapes({inputShape});
auto input_params = std::make_shared<ov::op::v0::Parameter>(inType, inputShape.first);
auto convert = std::make_shared<ov::op::v0::Convert>(input_params, element::f32);
auto begin = ngraph::builder::makeConstant(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 0, 0, 0});
auto end = ngraph::builder::makeConstant(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 0, 16, 0});
auto stride = ngraph::builder::makeConstant(element::i64, ov::Shape{4}, std::vector<int64_t>{1, 1, 1, 1});
auto begin = ov::test::utils::deprecated::make_constant(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 0, 0, 0});
auto end = ov::test::utils::deprecated::make_constant(element::i64, ov::Shape{4}, std::vector<int64_t>{0, 0, 16, 0});
auto stride = ov::test::utils::deprecated::make_constant(element::i64, ov::Shape{4}, std::vector<int64_t>{1, 1, 1, 1});
auto slice = std::make_shared<ov::op::v1::StridedSlice>(convert,
begin,
end,
@ -82,9 +83,9 @@ public:
// Such complicated graph is necessary to cover the case when Convert has several children and connected to non
// zero output
const auto split_axis = ngraph::builder::makeConstant(element::i64, ov::Shape{}, std::vector<int64_t>{1});
const auto split_axis = ov::test::utils::deprecated::make_constant(element::i64, ov::Shape{}, std::vector<int64_t>{1});
const auto split_lengths =
ngraph::builder::makeConstant(element::i64, ov::Shape{2}, std::vector<int64_t>{-1, 1});
ov::test::utils::deprecated::make_constant(element::i64, ov::Shape{2}, std::vector<int64_t>{-1, 1});
const auto split = std::make_shared<ov::op::v1::VariadicSplit>(input_params, split_axis, split_lengths);
auto convert = std::make_shared<ov::op::v0::Convert>(split->output(1), inType);
auto relu = ov::test::utils::make_activation(convert, inType, ov::test::utils::ActivationTypes::Relu);

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

@ -3,8 +3,8 @@
//
#include "common_test_utils/common_utils.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "functional_test_utils/skip_tests_config.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
namespace ov {
@ -23,13 +23,13 @@ class ReshapeChain : public SubgraphBaseTest {
for (auto&& shape : inputDynamicShapes) {
inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, shape));
}
auto reshapeParam1 = ngraph::builder::makeConstant<int>(secondInPrc, {3}, {0, 0, -1});
auto reshapeParam1 = ov::test::utils::deprecated::make_constant<int>(secondInPrc, {3}, {0, 0, -1});
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(inputParams.front(), reshapeParam1, true);
auto reshapeParam2 = ngraph::builder::makeConstant<int>(secondInPrc, {2}, {0, -1});
auto reshapeParam2 = ov::test::utils::deprecated::make_constant<int>(secondInPrc, {2}, {0, -1});
auto reshape2 = std::make_shared<ov::op::v1::Reshape>(reshape1, reshapeParam2, true);
auto reshapeParam3 = ngraph::builder::makeConstant<int>(secondInPrc, {1}, {-1});
auto reshapeParam3 = ov::test::utils::deprecated::make_constant<int>(secondInPrc, {1}, {-1});
auto reshape3 = std::make_shared<ov::op::v1::Reshape>(reshape2, reshapeParam3, true);
auto reshapeParam4 = ngraph::builder::makeConstant<int>(secondInPrc, {2}, {4, -1});
auto reshapeParam4 = ov::test::utils::deprecated::make_constant<int>(secondInPrc, {2}, {4, -1});
auto reshape4 = std::make_shared<ov::op::v1::Reshape>(reshape3, reshapeParam4, true);
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(reshape4)};

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

@ -2,9 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <common_test_utils/ov_tensor_utils.hpp>
#include "ov_models/builders.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/fusing_test_utils.hpp"
@ -83,7 +82,7 @@ protected:
init_input_shapes(shapes);
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(prc, inputDynamicShapes.front())};
auto reshapeData = ngraph::builder::makeConstant(ElementType::i32, {data.size()}, data);
auto reshapeData = ov::test::utils::deprecated::make_constant(ElementType::i32, {data.size()}, data);
auto reshape = std::make_shared<ov::op::v1::Reshape>(params[0], reshapeData, true);
auto tensor = ov::test::utils::create_and_fill_tensor(prc, inputDynamicShapes.back().to_shape());

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

@ -3,7 +3,7 @@
//
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
@ -43,7 +43,7 @@ protected:
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 c = ov::test::utils::deprecated::make_constant<float>(rtPrc, {}, {1.0f});
auto broadcast = std::make_shared<ov::op::v3::Broadcast>(c, shape);
auto reshape = std::make_shared<ov::op::v1::Reshape>(broadcast, params[1], false);
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(reshape->output(0))};

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

@ -3,7 +3,7 @@
//
#include "common_test_utils/node_builders/eltwise.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
@ -48,7 +48,7 @@ protected:
auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
auto split = std::make_shared<ov::op::v1::Split>(params.front(), split_axis_op, 3);
auto add_const = ngraph::builder::makeConstant(precision, {1}, std::vector<float>({1.0f}));
auto add_const = ov::test::utils::deprecated::make_constant(precision, {1}, std::vector<float>({1.0f}));
auto add_1 = utils::make_eltwise(split->output(0), add_const, utils::EltwiseTypes::ADD);
auto result_add_1 = std::make_shared<ov::op::v0::Result>(add_1);
auto add_2 = utils::make_eltwise(split->output(1), add_const, utils::EltwiseTypes::ADD);

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

@ -4,6 +4,7 @@
#include "test_utils/fusing_test_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
using namespace CPUTestUtils;
@ -105,7 +106,7 @@ protected:
const auto& inShapeB = inputDynamicShapes[1];
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ElementType::f32, inShapeA)};
std::shared_ptr<Node> inputB = ngraph::builder::makeConstant<float>(ElementType::f32, inShapeB.get_shape(), {}, true);
std::shared_ptr<Node> inputB = ov::test::utils::deprecated::make_constant<float>(ElementType::f32, inShapeB.get_shape(), {}, true);
auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{}, std::vector<int64_t>{0});
auto num_split = std::make_shared<ov::op::v0::Constant>(ov::element::u64, ov::Shape{2}, std::vector<size_t>{1, 1});

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

@ -3,7 +3,7 @@
//
#include "common_test_utils/ov_tensor_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
namespace ov {
@ -30,7 +30,7 @@ protected:
auto relu1 = std::make_shared<ov::op::v0::Relu>(varSplit->output(0));
auto numInRoi = ngraph::builder::makeConstant(ngPrc, {0}, std::vector<float>{}, false);
auto numInRoi = ov::test::utils::deprecated::make_constant(ngPrc, {0}, std::vector<float>{}, false);
auto expDet = std::make_shared<ov::op::v6::ExperimentalDetectronTopKROIs>(varSplit->output(1), numInRoi, 10);
auto relu2 = std::make_shared<ov::op::v0::Relu>(expDet);

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

@ -4,7 +4,7 @@
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "ov_models/utils/ov_helpers.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace ov {
namespace test {
@ -37,10 +37,10 @@ public:
for (auto&& shape : inputDynamicShapes) {
inputParams.push_back(std::make_shared<ov::op::v0::Parameter>(ov::element::f32, shape));
}
auto end = ngraph::builder::makeConstant(element::i64, {1}, std::vector<int64_t>{2147483647});
auto stride = ngraph::builder::makeConstant(element::i64, {1}, std::vector<int64_t>{1});
auto indices = ngraph::builder::makeConstant(element::i64, {1}, std::vector<int64_t>{1});
auto axes = ngraph::builder::makeConstant(element::i64, {1}, std::vector<int64_t>{0});
auto end = ov::test::utils::deprecated::make_constant(element::i64, {1}, std::vector<int64_t>{2147483647});
auto stride = ov::test::utils::deprecated::make_constant(element::i64, {1}, std::vector<int64_t>{1});
auto indices = ov::test::utils::deprecated::make_constant(element::i64, {1}, std::vector<int64_t>{1});
auto axes = ov::test::utils::deprecated::make_constant(element::i64, {1}, std::vector<int64_t>{0});
auto shapeOf = std::make_shared<ov::op::v3::ShapeOf>(inputParams[1]);
auto gather = std::make_shared<ov::op::v8::Gather>(shapeOf, indices, axes);
auto strided_slice = std::make_shared<ov::op::v1::StridedSlice>(inputParams.front(),

8
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/subgraph_with_blocked_format.cpp
View File

@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
#include "openvino/opsets/opset8.hpp"
@ -18,7 +18,7 @@ protected:
auto type = element::f32;
auto param = std::make_shared<ov::opset8::Parameter>(type, Shape{1, 32, 64, 32});
auto weights = ngraph::builder::makeConstant(type, Shape{32, 32, 1, 1}, std::vector<float>{}, true);
auto weights = ov::test::utils::deprecated::make_constant(type, Shape{32, 32, 1, 1}, std::vector<float>{}, true);
auto conv = std::make_shared<ov::opset8::Convolution>(param,
weights,
Strides{1, 1},
@ -42,10 +42,10 @@ protected:
std::make_shared<ov::op::v1::Reshape>(mvn, std::make_shared<ov::op::v3::ShapeOf>(mean), false);
auto mul = std::make_shared<ov::opset8::Multiply>(
reshape_after,
ngraph::builder::makeConstant(type, Shape{32, 1, 1}, std::vector<float>{}, true));
ov::test::utils::deprecated::make_constant(type, Shape{32, 1, 1}, std::vector<float>{}, true));
auto add = std::make_shared<ov::opset8::Add>(
mul,
ngraph::builder::makeConstant(type, Shape{32, 1, 1}, std::vector<float>{}, true));
ov::test::utils::deprecated::make_constant(type, Shape{32, 1, 1}, std::vector<float>{}, true));
auto sigmoid = std::make_shared<ov::opset8::Sigmoid>(add);
auto mul2 = std::make_shared<ov::opset8::Multiply>(conv, sigmoid);

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

@ -2,8 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "test_utils/cpu_test_utils.hpp"
@ -22,8 +22,8 @@ protected:
auto repeatsNode = std::make_shared<ov::op::v0::Constant>(ov::element::i64, std::vector<size_t>{repeats.size()}, repeats);
auto tile = std::make_shared<ov::op::v0::Tile>(inputParams[0], repeatsNode);
const auto const1 = ngraph::builder::makeConstant(ngPrc, std::vector<size_t>{1, 6, 1, 1}, std::vector<float>{}, true);
const auto const2 = ngraph::builder::makeConstant(ngPrc, std::vector<size_t>{1, 6, 1, 1}, std::vector<float>{}, true);
const auto const1 = ov::test::utils::deprecated::make_constant(ngPrc, std::vector<size_t>{1, 6, 1, 1}, std::vector<float>{}, true);
const auto const2 = ov::test::utils::deprecated::make_constant(ngPrc, std::vector<size_t>{1, 6, 1, 1}, std::vector<float>{}, true);
const auto add1 = utils::make_eltwise(tile->output(0), const1, utils::EltwiseTypes::ADD);
const auto add2 = utils::make_eltwise(tile->output(0), const2, utils::EltwiseTypes::ADD);

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

@ -5,6 +5,7 @@
#pragma once
#include "common_test_utils/node_builders/activation.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "cpu_test_utils.hpp"
#include "openvino/runtime/system_conf.hpp"
#include "ov_models/builders.hpp"
@ -217,7 +218,7 @@ const auto fusingReluAdd = fusingSpecificParams{std::make_shared<postNodesMgr>(s
}, "Relu"},
{[](postNodeConfig& cfg){
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"}}), {"Relu", "Add"}};
@ -227,24 +228,24 @@ const auto fusingReluScaleShift = fusingSpecificParams{std::make_shared<postNode
}, "Relu"},
{[](postNodeConfig& cfg){
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg){
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"}}), {"Relu", "Add"}};
const auto fusingScaleShift = fusingSpecificParams{ std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"}}), {"Add"} };
@ -257,7 +258,7 @@ const auto fusingClampRoundAddRelu = fusingSpecificParams{ std::make_shared<post
}, "RoundHalfToEven"},
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape(1, 1);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, secondMultInput);
}, "AddPerTensor"},
{[](postNodeConfig& cfg){
@ -267,12 +268,12 @@ const auto fusingClampRoundAddRelu = fusingSpecificParams{ std::make_shared<post
const auto fusingScaleShiftAndFakeQuantizePerChannel = fusingSpecificParams{ std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.target);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"},
{[](postNodeConfig& cfg){
@ -388,68 +389,68 @@ const auto fusingSumEluFQ = fusingSpecificParams{std::make_shared<postNodesMgr>(
const auto fusingMultiplyPerTensor = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape(1, 1);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, secondMultInput);
}, "Multiply(PerTensor)"}}), {"Multiply"}};
const auto fusingMultiplyPerChannel = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape = generatePerChannelShape(cfg.target);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, secondMultInput);
}, "Multiply(PerChannel)"}}), {"Multiply"}};
const auto fusingMultiplyAddPerChannel = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"}}), {"Add"} };
const auto fusingAddPerTensor = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape(1, 1);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, secondMultInput);
}, "Add(PerTensor)"}}), {"Add"}};
const auto fusingAddPerChannel = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape = generatePerChannelShape(cfg.target);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, secondMultInput);
}, "Add(PerChannel)"}}), {"Add"}};
const auto fusingSubtractPerTensor = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape(1, 1);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Subtract>(cfg.input, secondMultInput);
}, "Subtract(PerTensor)"}}), {"Subtract"}};
const auto fusingSubtractPerChannel = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape = generatePerChannelShape(cfg.target);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Subtract>(cfg.input, secondMultInput);
}, "Subtract(PerChannel)"}}), {"Subtract"}};
const auto fusingDividePerTensor = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape(1, 1);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Divide>(cfg.input, secondMultInput);
}, "Divide(PerTensor)"}}), {"Divide"}};
const auto fusingDividePerChannel = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg){
ov::Shape secondMultInShape = generatePerChannelShape(cfg.target);
auto secondMultInput = ngraph::builder::makeConstant(cfg.type, secondMultInShape, std::vector<float>{}, true);
auto secondMultInput = ov::test::utils::deprecated::make_constant(cfg.type, secondMultInShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Divide>(cfg.input, secondMultInput);
}, "Divide(PerChannel)"}}), {"Divide"}};
@ -470,19 +471,19 @@ const auto fusingPRelu1DScaleShift = fusingSpecificParams{std::make_shared<postN
}, "PRelu1D"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Multiply>(cfg.input, constNode);
}, "Multiply(PerChannel)"},
{[](postNodeConfig& cfg) {
ov::Shape newShape = generatePerChannelShape(cfg.input);
auto constNode = ngraph::builder::makeConstant(cfg.type, newShape, std::vector<float>{}, true);
auto constNode = ov::test::utils::deprecated::make_constant(cfg.type, newShape, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, constNode);
}, "Add(PerChannel)"}}), {"Add"} };
const auto fusingBias = fusingSpecificParams{std::make_shared<postNodesMgr>(std::vector<postNodeBuilder>{
{[](postNodeConfig& cfg) {
size_t last_dim = cfg.input->get_output_partial_shape(0).rbegin()->get_length();
auto bias = ngraph::builder::makeConstant(cfg.type, ov::Shape{last_dim}, std::vector<float>{}, true);
auto bias = ov::test::utils::deprecated::make_constant(cfg.type, ov::Shape{last_dim}, std::vector<float>{}, true);
return std::make_shared<ov::op::v1::Add>(cfg.input, bias);
}, "fusingBias"}}), {"Add"}};

4
src/plugins/intel_cpu/tests/unit/graph/merge_transpose_reorder_test.cpp
View File

@ -8,7 +8,7 @@
#include "nodes/input.h"
#include "nodes/transpose.h"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
using namespace ov::intel_cpu;
@ -68,7 +68,7 @@ protected:
// ov::Model with only a transpose node
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(testPrec, ov::Shape(testShape))};
auto order = std::vector<int32_t>{0, 3, 1, 2};
auto constOrder = ngraph::builder::makeConstant(ov::element::i32, {order.size()}, order);
auto constOrder = ov::test::utils::deprecated::make_constant(ov::element::i32, {order.size()}, order);
auto transpose = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder);
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(transpose)};

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

@ -7,6 +7,7 @@
#include "common_test_utils/node_builders/eltwise.hpp"
#include "behavior/ov_infer_request/infer_request_dynamic.hpp"
#include "ov_api_conformance_helpers.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace {
using namespace ov::test::behavior;
@ -20,7 +21,7 @@ std::shared_ptr<ov::Model> ovGetFunction1() {
params.front()->set_friendly_name("Param_1");
params.front()->get_output_tensor(0).set_names({"input_tensor"});
auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 4, 1, 1}, std::vector<float>{}, true);
auto in2add = ov::test::utils::deprecated::make_constant(ngPrc, {1, 4, 1, 1}, std::vector<float>{}, true);
auto add = ov::test::utils::make_eltwise(params[0], in2add, ov::test::utils::EltwiseTypes::ADD);
auto relu1 = std::make_shared<ov::op::v0::Relu>(add->output(0));
relu1->get_output_tensor(0).set_names({"relu1"});
@ -41,11 +42,11 @@ std::shared_ptr<ov::Model> ovGetFunction2() {
auto splitAxisOp = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
auto split = std::make_shared<ov::op::v1::Split>(params[0], splitAxisOp, 2);
auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto in2add = ov::test::utils::deprecated::make_constant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto add = ov::test::utils::make_eltwise(split->output(0), in2add, ov::test::utils::EltwiseTypes::ADD);
auto relu1 = std::make_shared<ov::op::v0::Relu>(add);
auto in2mult = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto in2mult = ov::test::utils::deprecated::make_constant(ngPrc, {1, 2, 1, 1}, std::vector<float>{}, true);
auto mult = ov::test::utils::make_eltwise(split->output(1), in2mult, ov::test::utils::EltwiseTypes::MULTIPLY);
auto relu2 = std::make_shared<ov::op::v0::Relu>(mult);

16
src/tests/functional/plugin/shared/src/behavior/ov_infer_request/infer_correctness.cpp
View File

@ -2,11 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/infer_consistency.hpp"
#include "ov_models/builders.hpp"
#include <gtest/gtest.h>
#include <iostream>
#include <thread>
#include "behavior/ov_infer_request/infer_consistency.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace ov {
namespace test {
namespace behavior {
@ -15,17 +17,17 @@ std::shared_ptr<ngraph::Function> GetDefaultGraph() {
size_t spatialDims = 2;
std::vector<ptrdiff_t> padBegin(spatialDims, 0), padEnd(spatialDims, 0);
ngraph::Shape strides(spatialDims, 1);
auto weights = ngraph::builder::makeConstant<float>(ov::element::f32, {64, 3, 7, 7}, {},
auto weights = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {64, 3, 7, 7}, {},
true);
auto conv1 = std::make_shared<ov::op::v1::Convolution>(input, weights, strides,
padBegin, padEnd, strides);
auto gamma = ngraph::builder::makeConstant<float>(ov::element::f32, {64}, {},
auto gamma = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {64}, {},
true);
auto beta = ngraph::builder::makeConstant<float>(ov::element::f32, {64}, {},
auto beta = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {64}, {},
true);
auto mean = ngraph::builder::makeConstant<float>(ov::element::f32, {64}, {},
auto mean = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {64}, {},
true);
auto variance = ngraph::builder::makeConstant<float>(ov::element::f32, {64}, {},
auto variance = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {64}, {},
true);
auto batchNorm1 = std::make_shared<ov::op::v0::BatchNormInference>(conv1, gamma,
beta, mean, variance, 1e-5);

5
src/tests/functional/plugin/shared/src/behavior/ov_infer_request/iteration_chaining.cpp
View File

@ -21,6 +21,7 @@
#include "openvino/op/parameter.hpp"
#include "openvino/core/model.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "openvino/runtime/infer_request.hpp"
#include "openvino/runtime/tensor.hpp"
#include "behavior/ov_infer_request/iteration_chaining.hpp"
@ -38,9 +39,9 @@ std::shared_ptr<ov::Model> OVIterationChaining::getIterativeFunction() {
auto params = std::make_shared<ov::op::v0::Parameter>(element::Type_t::f32, pshape);
params->get_output_tensor(0).set_names({"input_tensor_0"});
params->set_friendly_name("param_0");
auto concat_const = ngraph::builder::makeConstant(element::Type_t::f32, {1, 16}, std::vector<float>{}, true);
auto concat_const = ov::test::utils::deprecated::make_constant(element::Type_t::f32, {1, 16}, std::vector<float>{}, true);
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{params, concat_const}, 0 /*axis*/);
auto eltwise_const = ngraph::builder::makeConstant(element::Type_t::f32, {1, 16}, std::vector<float>{}, true);
auto eltwise_const = ov::test::utils::deprecated::make_constant(element::Type_t::f32, {1, 16}, std::vector<float>{}, true);
auto eltwise = ov::test::utils::make_eltwise(concat, eltwise_const, ngraph::helpers::EltwiseTypes::ADD);
concat->get_output_tensor(0).set_names({"result_tensor_0"});
concat->set_friendly_name("result_0");

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

@ -16,6 +16,7 @@
#include "functional_test_utils/skip_tests_config.hpp"
#include "common_test_utils/node_builders/binary_convolution.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "execution_graph_tests/runtime_precision.hpp"
@ -39,12 +40,11 @@ std::shared_ptr<ov::Model> makeEltwiseFunction(const std::vector<ov::element::Ty
std::shared_ptr<ov::Model> makeFakeQuantizeReluFunction(const std::vector<ov::element::Type>& inputPrecisions) {
IE_ASSERT(inputPrecisions.size() == 1);
ov::ParameterVector inputs{
std::make_shared<ov::op::v0::Parameter>(inputPrecisions[0], ov::Shape{1, 16, 5, 4})};
auto inputLowNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {0});
auto inputHighNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {255});
auto outputLowNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {0});
auto outputHighNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {255});
ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(inputPrecisions[0], ov::Shape{1, 16, 5, 4})};
auto inputLowNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {0});
auto inputHighNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {255});
auto outputLowNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {0});
auto outputHighNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {255});
auto fakeQuantize = std::make_shared<ov::op::v0::FakeQuantize>(inputs[0], inputLowNode, inputHighNode, outputLowNode, outputHighNode, 256);
fakeQuantize->set_friendly_name("FakeQuantize");
@ -58,12 +58,11 @@ std::shared_ptr<ov::Model> makeFakeQuantizeReluFunction(const std::vector<ov::el
std::shared_ptr<ov::Model> makeFakeQuantizeBinaryConvolutionFunction(const std::vector<ov::element::Type> &inputPrecisions) {
IE_ASSERT(inputPrecisions.size() == 1);
ov::ParameterVector inputs{
std::make_shared<ov::op::v0::Parameter>(inputPrecisions[0], ov::Shape{1, 16, 5, 4})};
auto inputLowNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {1});
auto inputHighNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {1});
auto outputLowNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {0});
auto outputHighNode = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 1, 1, 1}, {1});
ov::ParameterVector inputs{std::make_shared<ov::op::v0::Parameter>(inputPrecisions[0], ov::Shape{1, 16, 5, 4})};
auto inputLowNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {1});
auto inputHighNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {1});
auto outputLowNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {0});
auto outputHighNode = ov::test::utils::deprecated::make_constant<float>(ov::element::f32, {1, 1, 1, 1}, {1});
auto fakeQuantize = std::make_shared<ov::op::v0::FakeQuantize>(inputs[0], inputLowNode, inputHighNode, outputLowNode, outputHighNode, 2);
fakeQuantize->set_friendly_name("FakeQuantize");

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

@ -5,6 +5,7 @@
#include <ngraph/opsets/opset8.hpp>
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/single_layer/adaptive_pooling.hpp"
using namespace InferenceEngine;
@ -42,7 +43,7 @@ void AdaPoolLayerTest::SetUp() {
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);
auto pooledParam = ov::test::utils::deprecated::make_constant<int32_t>(ngraph::element::i32, pooledShape, pooledSpatialShape);
// we cannot create abstract Op to use polymorphism
auto adapoolMax = std::make_shared<ov::op::v8::AdaptiveMaxPool>(params[0], pooledParam, ngraph::element::i32);

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

@ -4,6 +4,8 @@
#include "shared_test_classes/single_layer/batch_norm.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
std::string BatchNormLayerTest::getTestCaseName(const testing::TestParamInfo<BatchNormLayerTestParams>& obj) {
InferenceEngine::Precision netPrecision;
@ -42,9 +44,9 @@ void BatchNormLayerTest::SetUp() {
size_t C = inputShapes.at(1);
bool random = true;
std::vector<float> values(C);
auto gamma = ngraph::builder::makeConstant(ngPrc, ov::Shape{C}, values, random, 1.f, 0.f);
auto beta = ngraph::builder::makeConstant(ngPrc, ov::Shape{C}, values, random, 1.f, 0.f);
auto mean = ngraph::builder::makeConstant(ngPrc, ov::Shape{C}, values, random, 1.f, 0.f);
auto gamma = ov::test::utils::deprecated::make_constant(ngPrc, ov::Shape{C}, values, random, 1.f, 0.f);
auto beta = ov::test::utils::deprecated::make_constant(ngPrc, ov::Shape{C}, values, random, 1.f, 0.f);
auto mean = ov::test::utils::deprecated::make_constant(ngPrc, ov::Shape{C}, values, random, 1.f, 0.f);
// Fill the vector for variance with positive values
std::default_random_engine gen;
@ -52,7 +54,7 @@ void BatchNormLayerTest::SetUp() {
std::generate(values.begin(), values.end(), [&dis, &gen]() {
return dis(gen);
});
auto variance = ngraph::builder::makeConstant(ngPrc, ov::Shape{C}, values, !random);
auto variance = ov::test::utils::deprecated::make_constant(ngPrc, ov::Shape{C}, values, !random);
auto batchNorm = std::make_shared<ov::op::v5::BatchNormInference>(params[0], gamma, beta, mean, variance, epsilon);
ngraph::ResultVector results{std::make_shared<ov::op::v0::Result>(batchNorm)};

3
src/tests/functional/shared_test_classes/src/single_layer/ctc_greedy_decoder_seq_len.cpp
View File

@ -8,6 +8,7 @@
#include "shared_test_classes/single_layer/ctc_greedy_decoder_seq_len.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
std::string CTCGreedyDecoderSeqLenLayerTest::getTestCaseName(
@ -73,7 +74,7 @@ void CTCGreedyDecoderSeqLenLayerTest::SetUp() {
sequenceLenData[b] = len;
}
return ngraph::builder::makeConstant(ngIdxPrc, {B}, sequenceLenData);
return ov::test::utils::deprecated::make_constant(ngIdxPrc, {B}, sequenceLenData);
}();
// Cap blank index up to C - 1

7
src/tests/functional/shared_test_classes/src/single_layer/eltwise.cpp
View File

@ -3,6 +3,7 @@
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include <common_test_utils/ov_tensor_utils.hpp>
#include "shared_test_classes/single_layer/eltwise.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
@ -111,14 +112,14 @@ void EltwiseLayerTest::SetUp() {
case ngraph::helpers::EltwiseTypes::MOD:
case ngraph::helpers::EltwiseTypes::FLOOR_MOD: {
std::vector<float> data = NGraphFunctions::Utils::generateVector<ngraph::element::Type_t::f32>(ngraph::shape_size(shape), 10, 2);
secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
secondaryInput = ov::test::utils::deprecated::make_constant(netType, shape, data);
break;
}
case ngraph::helpers::EltwiseTypes::POWER:
secondaryInput = ngraph::builder::makeConstant<float>(netType, shape, {}, true, 3);
secondaryInput = ov::test::utils::deprecated::make_constant<float>(netType, shape, {}, true, 3);
break;
default:
secondaryInput = ngraph::builder::makeConstant<float>(netType, shape, {}, true);
secondaryInput = ov::test::utils::deprecated::make_constant<float>(netType, shape, {}, true);
}
}

8
src/tests/functional/shared_test_classes/src/single_layer/gather.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/single_layer/gather.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
void GatherLayerTestBase::SetUp(const gatherParamsTuple& params) {
@ -83,7 +85,7 @@ void Gather7LayerTest::SetUp() {
int batchIdx = std::get<1>(axis_batchIdx);
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::ParameterVector functionParams {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto indicesNode = ngraph::builder::makeConstant<int>(ngraph::element::i64, indicesShape, {}, true,
auto indicesNode = ov::test::utils::deprecated::make_constant<int>(ngraph::element::i64, indicesShape, {}, true,
inputShape[axis < 0 ? axis + inputShape.size() : axis] - 1, 0);
auto axisNode = ov::op::v0::Constant::create(ngraph::element::i64, ngraph::Shape({}), { axis });
auto gather = std::make_shared<ov::op::v7::Gather>(functionParams[0], indicesNode, axisNode, batchIdx);
@ -124,7 +126,7 @@ void Gather8LayerTest::SetUp() {
int batchIdx = std::get<1>(axis_batchIdx);
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::ParameterVector functionParams {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto indicesNode = ngraph::builder::makeConstant<int>(ngraph::element::i64, indicesShape, {}, true,
auto indicesNode = ov::test::utils::deprecated::make_constant<int>(ngraph::element::i64, indicesShape, {}, true,
inputShape[axis < 0 ? axis + inputShape.size() : axis] - 1,
-static_cast<int>(inputShape[axis < 0 ? axis + inputShape.size() : axis]));
auto axisNode = ov::op::v0::Constant::create(ngraph::element::i64, ngraph::Shape({}), { axis });
@ -218,7 +220,7 @@ void Gather8withIndicesDataLayerTest::SetUp() {
int batchIdx = std::get<1>(axis_batchIdx);
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::ParameterVector functionParams {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto indicesNode = ngraph::builder::makeConstant<int>(ngraph::element::i64, indicesShape, indicesData);
auto indicesNode = ov::test::utils::deprecated::make_constant<int>(ngraph::element::i64, indicesShape, indicesData);
auto axisNode = ov::op::v0::Constant::create(ngraph::element::i64, ngraph::Shape({}), { axis });
auto gather = std::make_shared<ov::op::v8::Gather>(functionParams[0], indicesNode, axisNode, batchIdx);
ngraph::ResultVector results{ std::make_shared<ov::op::v0::Result>(gather) };

8
src/tests/functional/shared_test_classes/src/single_layer/gather_tree.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/single_layer/gather_tree.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
std::string GatherTreeLayerTest::getTestCaseName(const testing::TestParamInfo<GatherTreeParamsTuple> &obj) {
std::vector<size_t> inputShape;
@ -53,9 +55,9 @@ void GatherTreeLayerTest::SetUp() {
} else if (ngraph::helpers::InputLayerType::CONSTANT == secondaryInputType) {
auto maxBeamIndex = inputShape.at(2) - 1;
inp2 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, {}, true, maxBeamIndex);
inp3 = ngraph::builder::makeConstant<float>(ngPrc, {inputShape.at(1)}, {}, true, maxBeamIndex);
inp4 = ngraph::builder::makeConstant<float>(ngPrc, {}, {}, true, maxBeamIndex);
inp2 = ov::test::utils::deprecated::make_constant<float>(ngPrc, inputShape, {}, true, maxBeamIndex);
inp3 = ov::test::utils::deprecated::make_constant<float>(ngPrc, {inputShape.at(1)}, {}, true, maxBeamIndex);
inp4 = ov::test::utils::deprecated::make_constant<float>(ngPrc, {}, {}, true, maxBeamIndex);
} else {
throw std::runtime_error("Unsupported inputType");
}

7
src/tests/functional/shared_test_classes/src/single_layer/gru_cell.cpp
View File

@ -4,6 +4,7 @@
#include <transformations/op_conversions/gru_cell_decomposition.hpp>
#include "shared_test_classes/single_layer/gru_cell.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -81,7 +82,7 @@ void GRUCellTest::SetUp() {
W = param;
params.push_back(param);
} else {
W = ngraph::builder::makeConstant<float>(ngPrc, WRB[0], {}, true);
W = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[0], {}, true);
}
std::shared_ptr<ov::Node> R;
@ -90,7 +91,7 @@ void GRUCellTest::SetUp() {
R = param;
params.push_back(param);
} else {
R = ngraph::builder::makeConstant<float>(ngPrc, WRB[1], {}, true);
R = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[1], {}, true);
}
std::shared_ptr<ov::Node> B;
@ -99,7 +100,7 @@ void GRUCellTest::SetUp() {
B = param;
params.push_back(param);
} else {
B = ngraph::builder::makeConstant<float>(ngPrc, WRB[2], {}, true);
B = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[2], {}, true);
}
auto gru_cell = std::make_shared<ov::op::v3::GRUCell>(params[0], params[1], W, R, B, hidden_size, activations,

11
src/tests/functional/shared_test_classes/src/single_layer/gru_sequence.cpp
View File

@ -7,6 +7,7 @@
#include "transformations/op_conversions/convert_sequences_to_tensor_iterator.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "common_test_utils/test_enums.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -89,11 +90,11 @@ namespace LayerTestsDefinitions {
seq_lengths_node = param;
} else if (m_mode == ngraph::helpers::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST ||
m_mode == ngraph::helpers::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) {
seq_lengths_node = ngraph::builder::makeConstant<int64_t>(ov::element::i64, inputShapes[2], {}, true,
seq_lengths_node = ov::test::utils::deprecated::make_constant<int64_t>(ov::element::i64, inputShapes[2], {}, true,
static_cast<int64_t>(seq_lengths), 0.f);
} else {
std::vector<int64_t> lengths(batch, seq_lengths);
seq_lengths_node = ngraph::builder::makeConstant(ov::element::i64, inputShapes[2], lengths, false);
seq_lengths_node = ov::test::utils::deprecated::make_constant(ov::element::i64, inputShapes[2], lengths, false);
}
std::shared_ptr<ov::Node> W, R, B;
@ -108,9 +109,9 @@ namespace LayerTestsDefinitions {
params.push_back(R_param);
params.push_back(B_param);
} else {
W = ngraph::builder::makeConstant<float>(ngPrc, W_shape, {}, true);
R = ngraph::builder::makeConstant<float>(ngPrc, R_shape, {}, true);
B = ngraph::builder::makeConstant<float>(ngPrc, B_shape, {}, true);
W = ov::test::utils::deprecated::make_constant<float>(ngPrc, W_shape, {}, true);
R = ov::test::utils::deprecated::make_constant<float>(ngPrc, R_shape, {}, true);
B = ov::test::utils::deprecated::make_constant<float>(ngPrc, B_shape, {}, true);
}
auto gru_sequence = std::make_shared<ov::op::v5::GRUSequence>(params[0], params[1], seq_lengths_node, W, R, B, hidden_size, direction,

9
src/tests/functional/shared_test_classes/src/single_layer/low_precision.cpp
View File

@ -4,6 +4,7 @@
#include "shared_test_classes/single_layer/low_precision.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LowPrecisionTestDefinitions {
@ -39,13 +40,13 @@ void LowPrecisionTest::SetUp() {
weights1Data[i * 17] = 10.0f + i;
}
auto weights1 = ngraph::builder::makeConstant<float>(ngPrc, weights1Shape, weights1Data);
auto weights1 = ov::test::utils::deprecated::make_constant<float>(ngPrc, weights1Shape, weights1Data);
auto fc1 = std::make_shared<ov::op::v0::MatMul>(input, weights1);
fc1->set_friendly_name("FullyConnected_1");
// bias 1
std::vector<float> bias1Data(ngraph::shape_size(inputShape), 0.0f);
auto bias1 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, bias1Data);
auto bias1 = ov::test::utils::deprecated::make_constant<float>(ngPrc, inputShape, bias1Data);
auto add1 = std::make_shared<ov::op::v1::Add>(fc1, bias1);
add1->set_friendly_name("Add_1");
#if 0
@ -56,13 +57,13 @@ void LowPrecisionTest::SetUp() {
//// fully connected 2
std::vector<float> weights2Data(ngraph::shape_size(weights2Shape), 0.0f);
std::fill(weights2Data.begin(), weights2Data.end(), 0.0001f);
auto weights2 = ngraph::builder::makeConstant<float>(ngPrc, weights2Shape, weights2Data);
auto weights2 = ov::test::utils::deprecated::make_constant<float>(ngPrc, weights2Shape, weights2Data);
auto fc2 = std::make_shared<ov::op::v0::MatMul>(relu1, weights2);
fc2->set_friendly_name("FullyConnected_2");
//// bias 2
std::vector<float> bias2Data(ngraph::shape_size(weights2Shape), 0.0f);
auto bias2 = ngraph::builder::makeConstant<float>(ngPrc, weights2Shape, bias2Data);
auto bias2 = ov::test::utils::deprecated::make_constant<float>(ngPrc, weights2Shape, bias2Data);
auto add2 = std::make_shared<ov::op::v1::Add>(fc2, bias2);
add2->set_friendly_name("Add_2");

7
src/tests/functional/shared_test_classes/src/single_layer/lstm_cell.cpp
View File

@ -4,6 +4,7 @@
#include "transformations/op_conversions/lstm_cell_decomposition.hpp"
#include "shared_test_classes/single_layer/lstm_cell.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -77,7 +78,7 @@ void LSTMCellTest::SetUp() {
W = param;
params.push_back(param);
} else {
W = ngraph::builder::makeConstant<float>(ngPrc, WRB[0], {}, true);
W = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[0], {}, true);
}
std::shared_ptr<ov::Node> R;
@ -86,7 +87,7 @@ void LSTMCellTest::SetUp() {
R = param;
params.push_back(param);
} else {
R = ngraph::builder::makeConstant<float>(ngPrc, WRB[1], {}, true);
R = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[1], {}, true);
}
std::shared_ptr<ov::Node> B;
@ -95,7 +96,7 @@ void LSTMCellTest::SetUp() {
B = param;
params.push_back(param);
} else {
B = ngraph::builder::makeConstant<float>(ngPrc, WRB[2], {}, true);
B = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[2], {}, true);
}
auto lstm_cell = std::make_shared<ov::op::v4::LSTMCell>(params[0], params[1], params[2], W, R, B, hidden_size, activations,

11
src/tests/functional/shared_test_classes/src/single_layer/lstm_sequence.cpp
View File

@ -6,6 +6,7 @@
#include "transformations/op_conversions/bidirectional_sequences_decomposition.hpp"
#include "transformations/op_conversions/convert_sequences_to_tensor_iterator.hpp"
#include "ngraph/pass/visualize_tree.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -90,11 +91,11 @@ namespace LayerTestsDefinitions {
params.push_back(param);
} else if (m_mode == ngraph::helpers::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST ||
m_mode == ngraph::helpers::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) {
seq_lengths_node = ngraph::builder::makeConstant<int64_t>(ov::element::i64, inputShapes[3], {}, true,
seq_lengths_node = ov::test::utils::deprecated::make_constant<int64_t>(ov::element::i64, inputShapes[3], {}, true,
static_cast<int64_t>(seq_lengths), 0.f);
} else {
std::vector<int64_t> lengths(inputShapes[3][0], seq_lengths);
seq_lengths_node = ngraph::builder::makeConstant(ov::element::i64, inputShapes[3], lengths, false);
seq_lengths_node = ov::test::utils::deprecated::make_constant(ov::element::i64, inputShapes[3], lengths, false);
}
std::shared_ptr<ov::Node> W, R, B;
@ -109,9 +110,9 @@ namespace LayerTestsDefinitions {
params.push_back(R_param);
params.push_back(B_param);
} else {
W = ngraph::builder::makeConstant<float>(ngPrc, W_shape, {}, true);
R = ngraph::builder::makeConstant<float>(ngPrc, R_shape, {}, true);
B = ngraph::builder::makeConstant<float>(ngPrc, B_shape, {}, true);
W = ov::test::utils::deprecated::make_constant<float>(ngPrc, W_shape, {}, true);
R = ov::test::utils::deprecated::make_constant<float>(ngPrc, R_shape, {}, true);
B = ov::test::utils::deprecated::make_constant<float>(ngPrc, B_shape, {}, true);
}
auto lstm_sequence = std::make_shared<ov::op::v5::LSTMSequence>(params[0], params[1], params[2], seq_lengths_node, W, R, B, hidden_size, direction,

3
src/tests/functional/shared_test_classes/src/single_layer/mvn.cpp
View File

@ -4,6 +4,7 @@
#include "shared_test_classes/single_layer/mvn.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -83,7 +84,7 @@ void Mvn6LayerTest::SetUp() {
auto axesType = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(axesPrecision);
ov::ParameterVector param {std::make_shared<ov::op::v0::Parameter>(dataType, ov::Shape(inputShapes))};
auto axesNode = ngraph::builder::makeConstant(axesType, ngraph::Shape{axes.size()}, axes);
auto axesNode = ov::test::utils::deprecated::make_constant(axesType, ngraph::Shape{axes.size()}, axes);
OPENVINO_SUPPRESS_DEPRECATED_START
auto mvn = ngraph::builder::makeMVN6(param[0], axesNode, normalizeVariance, eps, epsMode);
OPENVINO_SUPPRESS_DEPRECATED_END

7
src/tests/functional/shared_test_classes/src/single_layer/rnn_cell.cpp
View File

@ -4,6 +4,7 @@
#include "transformations/op_conversions/rnn_cell_decomposition.hpp"
#include "shared_test_classes/single_layer/rnn_cell.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -69,7 +70,7 @@ void RNNCellTest::SetUp() {
W = param;
params.push_back(param);
} else {
W = ngraph::builder::makeConstant<float>(ngPrc, WRB[0], {}, true);
W = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[0], {}, true);
}
std::shared_ptr<ov::Node> R;
@ -78,7 +79,7 @@ void RNNCellTest::SetUp() {
R = param;
params.push_back(param);
} else {
R = ngraph::builder::makeConstant<float>(ngPrc, WRB[1], {}, true);
R = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[1], {}, true);
}
std::shared_ptr<ov::Node> B;
@ -87,7 +88,7 @@ void RNNCellTest::SetUp() {
B = param;
params.push_back(param);
} else {
B = ngraph::builder::makeConstant<float>(ngPrc, WRB[2], {}, true);
B = ov::test::utils::deprecated::make_constant<float>(ngPrc, WRB[2], {}, true);
}
auto rnn_cell = std::make_shared<ov::op::v0::RNNCell>(params[0], params[1], W, R, B, hidden_size, activations,

11
src/tests/functional/shared_test_classes/src/single_layer/rnn_sequence.cpp
View File

@ -5,6 +5,7 @@
#include "transformations/op_conversions/bidirectional_sequences_decomposition.hpp"
#include "transformations/op_conversions/convert_sequences_to_tensor_iterator.hpp"
#include "shared_test_classes/single_layer/rnn_sequence.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace LayerTestsDefinitions {
@ -80,11 +81,11 @@ namespace LayerTestsDefinitions {
seq_lengths_node = param;
} else if (m_mode == ngraph::helpers::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST ||
m_mode == ngraph::helpers::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) {
seq_lengths_node = ngraph::builder::makeConstant(ov::element::i64, inputShapes[2], {}, true,
seq_lengths_node = ov::test::utils::deprecated::make_constant(ov::element::i64, inputShapes[2], {}, true,
static_cast<float>(seq_lengths), 0.f);
} else {
std::vector<float> lengths(batch, seq_lengths);
seq_lengths_node = ngraph::builder::makeConstant(ov::element::i64, inputShapes[2], lengths, false);
seq_lengths_node = ov::test::utils::deprecated::make_constant(ov::element::i64, inputShapes[2], lengths, false);
}
const auto& W_shape = inputShapes[3];
@ -103,9 +104,9 @@ namespace LayerTestsDefinitions {
params.push_back(R_param);
params.push_back(B_param);
} else {
W = ngraph::builder::makeConstant<float>(ngPrc, W_shape, {}, true);
R = ngraph::builder::makeConstant<float>(ngPrc, R_shape, {}, true);
B = ngraph::builder::makeConstant<float>(ngPrc, B_shape, {}, true);
W = ov::test::utils::deprecated::make_constant<float>(ngPrc, W_shape, {}, true);
R = ov::test::utils::deprecated::make_constant<float>(ngPrc, R_shape, {}, true);
B = ov::test::utils::deprecated::make_constant<float>(ngPrc, B_shape, {}, true);
}
auto rnn_sequence = std::make_shared<ov::op::v5::RNNSequence>(params[0], params[1], seq_lengths_node, W, R, B, hidden_size, direction,

5
src/tests/functional/shared_test_classes/src/single_op/nms_rotated.cpp
View File

@ -3,7 +3,8 @@
//
#include "shared_test_classes/single_op/nms_rotated.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/data_utils.hpp"
#include "openvino/op/nms_rotated.hpp"
@ -85,7 +86,7 @@ void NmsRotatedOpTest::SetUp() {
#define CONST_CASE(P, S, H, L) \
case P: \
inputs.push_back(ngraph::builder::makeConstant(P, S, std::vector<ov::element_type_traits<P>::value_type>{}, true, \
inputs.push_back(ov::test::utils::deprecated::make_constant(P, S, std::vector<ov::element_type_traits<P>::value_type>{}, true, \
ov::element_type_traits<P>::value_type(H), ov::element_type_traits<P>::value_type(L))); \
break;

5
src/tests/functional/shared_test_classes/src/subgraph/activation_concats_eltwise.cpp
View File

@ -3,6 +3,7 @@
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/subgraph/activation_concats_eltwise.hpp"
#include "common_test_utils/node_builders/activation.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
@ -46,8 +47,8 @@ void ActivationConcatsEltwise::SetUp() {
auto concat_vals_1 = ov::test::utils::generate_float_numbers(concatSize, 14, 14);
auto concat_vals_2 = ov::test::utils::generate_float_numbers(concatSize, 14, 14);
auto concat_const_1 = ngraph::builder::makeConstant(ngPrc, {1, concatSize}, concat_vals_1);
auto concat_const_2 = ngraph::builder::makeConstant(ngPrc, {1, concatSize}, concat_vals_2);
auto concat_const_1 = ov::test::utils::deprecated::make_constant(ngPrc, {1, concatSize}, concat_vals_1);
auto concat_const_2 = ov::test::utils::deprecated::make_constant(ngPrc, {1, concatSize}, concat_vals_2);
auto concat_1 = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{concat_const_1, relu}, 1);
auto concat_2 = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{concat_const_2, relu}, 1);

10
src/tests/functional/shared_test_classes/src/subgraph/basic_lstm.cpp
View File

@ -6,6 +6,7 @@
#include <transformations/op_conversions/lstm_cell_decomposition.hpp>
#include "shared_test_classes/subgraph/basic_lstm.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -72,8 +73,8 @@ std::shared_ptr<ngraph::Function> Basic_LSTM_S::GetNetwork(size_t thirdDimOut,
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(params[0], pattern1, false);
auto reshape1_shape = reshape1->output(0).get_shape();
auto H_init = ngraph::builder::makeConstant<float>(ngPrc, { batch_size, hiddenSize }, {}, true, weights_range.second, weights_range.first);
auto C_init = ngraph::builder::makeConstant<float>(ngPrc, { batch_size, hiddenSize }, {}, true, weights_range.second, weights_range.first);
auto H_init = ov::test::utils::deprecated::make_constant<float>(ngPrc, { batch_size, hiddenSize }, {}, true, weights_range.second, weights_range.first);
auto C_init = ov::test::utils::deprecated::make_constant<float>(ngPrc, { batch_size, hiddenSize }, {}, true, weights_range.second, weights_range.first);
if (hidden_memory_init_out != nullptr) {
*hidden_memory_init_out = std::static_pointer_cast<ov::op::v0::Constant>(H_init)->cast_vector<float>();
}
@ -86,8 +87,9 @@ std::shared_ptr<ngraph::Function> Basic_LSTM_S::GetNetwork(size_t thirdDimOut,
C_t->set_friendly_name("cell_state_1");
//Body
auto X = std::make_shared<ov::op::v0::Parameter>(ngPrc, ngraph::Shape{ batch_size, 1, reshape1_shape[2] });
auto weightsNode = ngraph::builder::makeConstant<float>(ngPrc, { 4 * hiddenSize, reshape1_shape[2] }, {}, true, weights_range.second, weights_range.first);
auto reccurrenceWeightsNode = ngraph::builder::makeConstant<float>(ngPrc, { 4 * hiddenSize, hiddenSize }, {}, true, weights_range.second,
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(
ngPrc, { 4 * hiddenSize, reshape1_shape[2] }, {}, true, weights_range.second, weights_range.first);
auto reccurrenceWeightsNode = ov::test::utils::deprecated::make_constant<float>(ngPrc, { 4 * hiddenSize, hiddenSize }, {}, true, weights_range.second,
weights_range.first);
//lstm [1, 10], [1, 118], [1, 118] -> [1, 118], [1, 118]

3
src/tests/functional/shared_test_classes/src/subgraph/broadcast_power.cpp
View File

@ -5,6 +5,7 @@
#include "shared_test_classes/subgraph/broadcast_power.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string BroadcastPowerTest::getTestCaseName(const testing::TestParamInfo<BroadCastPowerTuple>& obj) {
@ -35,7 +36,7 @@ void BroadcastPowerTest::SetUp() {
inputs_shapes[1]);
auto reshape = std::make_shared<ov::op::v1::Reshape>(params[0], reshape_pattern, false);
auto const_mult2 = ngraph::builder::makeConstant<float>(ngPrc, {}, {-1.0f});
auto const_mult2 = ov::test::utils::deprecated::make_constant<float>(ngPrc, {}, {-1.0f});
auto sum = ov::test::utils::make_eltwise(reshape, const_mult2, ngraph::helpers::EltwiseTypes::MULTIPLY);
auto reshape_pattern_2 = std::make_shared<ov::op::v0::Constant>(ngraph::element::i64, ngraph::Shape{inputs_shapes[0].size()},

8
src/tests/functional/shared_test_classes/src/subgraph/cascade_concat.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/cascade_concat.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string CascadeConcat::getTestCaseName(const testing::TestParamInfo<CascadeConcatTuple> &obj) {
@ -53,7 +55,7 @@ void CascadeConcat::SetUp() {
1);
ngraph::ResultVector results;
if (multioutput) {
auto const_mult = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{1, input1[0][1]+input2[0][1]},
auto const_mult = ov::test::utils::deprecated::make_constant(ngPrc, ngraph::Shape{1, input1[0][1]+input2[0][1]},
std::vector<float>{1.01f});
auto mult = std::make_shared<ov::op::v1::Multiply>(concat, const_mult);
results = ngraph::ResultVector{std::make_shared<ov::op::v0::Result>(concat2),
@ -109,7 +111,7 @@ void CascadeConcatWithMultiConnReshape::SetUp() {
inputShapeSqueezed.insert(std::begin(inputShapeSqueezed), 1);
ov::ParameterVector input {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShapeSqueezed))};
auto relu = std::make_shared<ov::op::v0::Relu>(input[0]);
auto const1 = ngraph::builder::makeConstant(ngPrc, inputShapeSqueezed, std::vector<float>{}, true);
auto const1 = ov::test::utils::deprecated::make_constant(ngPrc, inputShapeSqueezed, std::vector<float>{}, true);
auto concat1 = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{relu, const1}, inputShapeSqueezed.size() - 1);
auto squeeze_constant = std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{1}, std::vector<int64_t>{0});
@ -120,7 +122,7 @@ void CascadeConcatWithMultiConnReshape::SetUp() {
auto unsqueeze1_constant = std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{1}, std::vector<int64_t>{0});
auto unsqueeze1 = std::make_shared<ov::op::v0::Unsqueeze>(relu1, unsqueeze1_constant);
auto const2 = ngraph::builder::makeConstant(ngPrc, inputShape, std::vector<float>{}, true);
auto const2 = ov::test::utils::deprecated::make_constant(ngPrc, inputShape, std::vector<float>{}, true);
auto concat2 = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{squeeze, const2}, 1);
// Change concat name to make it the second connection in the map of squeeze output connections
concat2->set_friendly_name("XConcat");

3
src/tests/functional/shared_test_classes/src/subgraph/concat_conv.cpp
View File

@ -5,6 +5,7 @@
#include "shared_test_classes/subgraph/concat_conv.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -66,7 +67,7 @@ void ConcatConvTest::SetUp() {
auto relu1 = std::make_shared<ov::op::v0::Relu>(params[0]);
auto const_values = ov::test::utils::generate_float_numbers(inputShape[1], -2.0f, 2.0f);
auto constant = ngraph::builder::makeConstant(ngPrc, inputShape, const_values);
auto constant = ov::test::utils::deprecated::make_constant(ngPrc, inputShape, const_values);
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{constant, relu1}, 1);
std::vector<size_t> convInputShape = {1, inputChannels, 1, 2 * inputShape[0] * inputShape[1] / inputChannels};

4
src/tests/functional/shared_test_classes/src/subgraph/concat_multi_input.cpp
View File

@ -5,6 +5,8 @@
#include "shared_test_classes/subgraph/concat_multi_input.hpp"
#include "common_test_utils/node_builders/activation.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string ConcatMultiInput::getTestCaseName(const testing::TestParamInfo<concatMultiParams>& obj) {
@ -98,7 +100,7 @@ void ConcatMultiInput::GenerateConstOnlyModel() {
} else {
auto min_max = (i % 2 == 0) ? 2 : 30;
auto const_values = generateFloatNumbers(total_size, -min_max, min_max);
auto const_node = ngraph::builder::makeConstant(ngPrc, {1, total_size}, const_values);
auto const_node = ov::test::utils::deprecated::make_constant(ngPrc, {1, total_size}, const_values);
concatInputs.push_back(const_node);
}
}

4
src/tests/functional/shared_test_classes/src/subgraph/concat_qunatization.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/concat_quantization.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string ConcatQuantization::getTestCaseName(const testing::TestParamInfo<concatQuantizationParams>& obj) {
@ -40,7 +42,7 @@ void ConcatQuantization::SetUp() {
std::vector<size_t> outFormShapes2 = { 1, 160 };
auto pattern2 = std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{ 2 }, outFormShapes2);
auto reshape2 = std::make_shared<ov::op::v1::Reshape>(tanh, pattern2, false);
auto scale = ngraph::builder::makeConstant<float>(ngPrc, outFormShapes2, {}, true);
auto scale = ov::test::utils::deprecated::make_constant<float>(ngPrc, outFormShapes2, {}, true);
//For ov::op::v0::ScaleShift: Cannot cast ngraph node ScaleShift to CNNLayer!
auto scale_shift = std::make_shared<ov::op::v1::Multiply>(reshape2, scale);

6
src/tests/functional/shared_test_classes/src/subgraph/connect_split_concat_concat.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/connect_split_concat_concat.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string SplitConcatConcatTest::getTestCaseName(const testing::TestParamInfo<SplitConcatConcatParams> &obj) {
InferenceEngine::Precision netPrecision;
@ -30,8 +32,8 @@ void SplitConcatConcatTest::SetUp() {
auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
auto split = std::make_shared<ov::op::v1::Split>(relu_start, split_axis_op, 2);
auto const_concat = ngraph::builder::makeConstant(ngPrc, {1, 96}, std::vector<float>{0});
auto const_concat_2 = ngraph::builder::makeConstant(ngPrc, {1, 96}, std::vector<float>{0});
auto const_concat = ov::test::utils::deprecated::make_constant(ngPrc, {1, 96}, std::vector<float>{0});
auto const_concat_2 = ov::test::utils::deprecated::make_constant(ngPrc, {1, 96}, std::vector<float>{0});
auto concat = std::make_shared<ov::op::v0::Concat>(ngraph::OutputVector{split->output(0), const_concat}, 1);
auto concat_2 = std::make_shared<ov::op::v0::Concat>(ngraph::OutputVector{concat, const_concat_2},
1);

3
src/tests/functional/shared_test_classes/src/subgraph/const_conv_concat.cpp
View File

@ -5,6 +5,7 @@
#include "shared_test_classes/subgraph/const_conv_concat.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -81,7 +82,7 @@ void ConstConvConcatTest::SetUp() {
std::vector<size_t> outFormShapes = {1, outputChannels * widthAfterConv };
auto const_values = ov::test::utils::generate_float_numbers(outputChannels * widthAfterConv, -0.2f, 0.2f);
auto constant = ngraph::builder::makeConstant(ngPrc, {1, outputChannels, 1, widthAfterConv}, const_values);
auto constant = ov::test::utils::deprecated::make_constant(ngPrc, {1, outputChannels, 1, widthAfterConv}, const_values);
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{constant, conv}, 3);
auto reshapePattern2 = std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{ 2 },

5
src/tests/functional/shared_test_classes/src/subgraph/const_strided_slice_concat.cpp
View File

@ -3,7 +3,8 @@
//
#include "shared_test_classes/subgraph/const_strided_slice_concat.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -97,7 +98,7 @@ void ConstStridedSliceConcatTest::SetUp() {
const auto totalConstantSize = constSlices * constSliceSize;
auto constantValues = ov::test::utils::generate_float_numbers(totalConstantSize, -0.2f, 0.2f);
auto constant = ngraph::builder::makeConstant(ngPrc, { 1, totalConstantSize }, constantValues);
auto constant = ov::test::utils::deprecated::make_constant(ngPrc, { 1, totalConstantSize }, constantValues);
std::vector<ngraph::Output<ngraph::Node>> allToConcat;
appendSlices(allToConcat, params[0], inputSliceSize, totalInputSize, ngPrc);

14
src/tests/functional/shared_test_classes/src/subgraph/constant_result.cpp
View File

@ -4,7 +4,7 @@
#include "shared_test_classes/subgraph/constant_result.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "openvino/op/result.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
@ -47,14 +47,14 @@ void ConstantResultSubgraphTest::createGraph(const ConstantSubgraphType& type,
ResultVector results;
switch (type) {
case ConstantSubgraphType::SINGLE_COMPONENT: {
auto input = ngraph::builder::makeConstant<float>(input_type, input_shape, {}, true);
auto input = ov::test::utils::deprecated::make_constant<float>(input_type, input_shape, {}, true);
results.push_back(std::make_shared<ov::op::v0::Result>(input));
break;
}
case ConstantSubgraphType::SEVERAL_COMPONENT: {
auto input1 = ngraph::builder::makeConstant<float>(input_type, input_shape, {}, true);
auto input1 = ov::test::utils::deprecated::make_constant<float>(input_type, input_shape, {}, true);
results.push_back(std::make_shared<ov::op::v0::Result>(input1));
auto input2 = ngraph::builder::makeConstant<float>(input_type, input_shape, {}, true);
auto input2 = ov::test::utils::deprecated::make_constant<float>(input_type, input_shape, {}, true);
results.push_back(std::make_shared<ov::op::v0::Result>(input2));
break;
}
@ -102,14 +102,14 @@ void ConstantResultSubgraphTest::createGraph(const ConstantSubgraphType& type,
ov::ResultVector results;
switch (type) {
case ConstantSubgraphType::SINGLE_COMPONENT: {
auto input = ngraph::builder::makeConstant<float>(ngPrc, inputShape, {}, true);
auto input = ov::test::utils::deprecated::make_constant<float>(ngPrc, inputShape, {}, true);
results.push_back(std::make_shared<ov::op::v0::Result>(input));
break;
}
case ConstantSubgraphType::SEVERAL_COMPONENT: {
auto input1 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, {}, true);
auto input1 = ov::test::utils::deprecated::make_constant<float>(ngPrc, inputShape, {}, true);
results.push_back(std::make_shared<ov::op::v0::Result>(input1));
auto input2 = ngraph::builder::makeConstant<float>(ngPrc, inputShape, {}, true);
auto input2 = ov::test::utils::deprecated::make_constant<float>(ngPrc, inputShape, {}, true);
results.push_back(std::make_shared<ov::op::v0::Result>(input2));
break;
}

8
src/tests/functional/shared_test_classes/src/subgraph/conv_eltwise_fusion.cpp
View File

@ -8,7 +8,7 @@
#include "openvino/core/node.hpp"
#include "openvino/pass/constant_folding.hpp"
#include "openvino/pass/manager.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "transformations/common_optimizations/conv_mul_fusion.hpp"
@ -58,10 +58,10 @@ void ConvEltwiseFusion::SetUp() {
Shape strides(spatial_dims, 1);
std::vector<ptrdiff_t> pad_begin(spatial_dims, 0), pad_end(spatial_dims, 0);
auto weights = ngraph::builder::makeConstant<float>(precision,
auto weights = ov::test::utils::deprecated::make_constant<float>(precision,
weights_shape,
std::vector<float>(shape_size(weights_shape), 2));
auto eltwise_const = ngraph::builder::makeConstant<float>(precision,
auto eltwise_const = ov::test::utils::deprecated::make_constant<float>(precision,
const_shape,
std::vector<float>(shape_size(const_shape), 3));
std::shared_ptr<Node> conv;
@ -143,7 +143,7 @@ void ConvEltwiseFusion::SetUp() {
Shape strides(spatial_dims, 1);
std::vector<ptrdiff_t> pad_begin(spatial_dims, 0), pad_end(spatial_dims, 0);
auto weights = ngraph::builder::makeConstant<float>(precision,
auto weights = ov::test::utils::deprecated::make_constant<float>(precision,
weights_shape,
std::vector<float>(shape_size(weights_shape), 6));
std::shared_ptr<Node> conv;

16
src/tests/functional/shared_test_classes/src/subgraph/conv_fq_eltwise.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/conv_fq_eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string ConvFqEltwiseTest::getTestCaseName(const testing::TestParamInfo<ConvFqEltwiseTestParamsSet>& obj) {
@ -81,32 +83,32 @@ void ConvFqEltwiseTest::SetUp() {
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(params[0], reshapePattern1, false);
float weightVal = 0.2;
auto filterWeightsNode = ngraph::builder::makeConstant<float>(ngPrc, {outputChannels, inputChannels, kernelShape[0], kernelShape[1]},
auto filterWeightsNode = ov::test::utils::deprecated::make_constant<float>(ngPrc, {outputChannels, inputChannels, kernelShape[0], kernelShape[1]},
{ weightVal });
auto convLowNode =
ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{-convFQValue});
ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{-convFQValue});
auto convHighNode =
ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{convFQValue});
ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{convFQValue});
auto convWeightsFQNode = std::make_shared<ov::op::v0::FakeQuantize>(filterWeightsNode,
convLowNode, convHighNode, convLowNode, convHighNode, levels);
auto convWeightsFQ = std::dynamic_pointer_cast<ov::op::v0::FakeQuantize>(convWeightsFQNode);
auto conv = std::make_shared<ov::op::v1::Convolution>(reshape1, convWeightsFQ, strides, std::vector<ptrdiff_t>{ 0, 0 },
std::vector<ptrdiff_t>{ 0, 0 }, std::vector<size_t>{ 1, 1 },
ov::op::PadType::VALID);
auto biasesWeightsNode = ngraph::builder::makeConstant(ngPrc, {}, std::vector<float>{ 0.0f });
auto biasesWeightsNode = ov::test::utils::deprecated::make_constant(ngPrc, {}, std::vector<float>{ 0.0f });
auto add_1 = std::make_shared<ov::op::v1::Add>(conv, biasesWeightsNode);
auto widthAfterConv = (convInputShape[3] - kernelShape[1]) / strides[1] + 1;
auto heightAfterConv = (convInputShape[2] - kernelShape[0]) / strides[0] + 1;
std::vector<size_t> outFormShapes = {1, outputChannels * widthAfterConv * heightAfterConv };
auto lowNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 },
auto lowNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 },
std::vector<float>{inputDataMin * weightVal * kernelShape[1] * 1.5f});
auto highNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 },
auto highNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 },
std::vector<float>{inputDataMax * weightVal * kernelShape[1] * 1.5f});
auto fq = std::make_shared<ov::op::v0::FakeQuantize>(add_1, lowNode, highNode, lowNode, highNode, levels);
auto constNode = ngraph::builder::makeConstant(ngPrc, {}, std::vector<float>{ 0.5f });
auto constNode = ov::test::utils::deprecated::make_constant(ngPrc, {}, std::vector<float>{ 0.5f });
auto add_2 = std::make_shared<ov::op::v1::Add>(fq, constNode);
auto reshapePattern2 = std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{ 2 }, outFormShapes);

14
src/tests/functional/shared_test_classes/src/subgraph/conv_fq_relu.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/conv_fq_relu.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string ConvFqReluTest::getTestCaseName(const testing::TestParamInfo<ConvFqReluTestParamsSet>& obj) {
@ -81,28 +83,28 @@ void ConvFqReluTest::SetUp() {
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(params[0], reshapePattern1, false);
float weightVal = 0.2;
auto filterWeightsNode = ngraph::builder::makeConstant<float>(ngPrc, {outputChannels, inputChannels, kernelShape[0], kernelShape[1]},
auto filterWeightsNode = ov::test::utils::deprecated::make_constant<float>(ngPrc, {outputChannels, inputChannels, kernelShape[0], kernelShape[1]},
{ weightVal });
auto convLowNode =
ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{-convFQValue});
ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{-convFQValue});
auto convHighNode =
ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{convFQValue});
ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{1}, std::vector<float>{convFQValue});
auto convWeightsFQNode = std::make_shared<ov::op::v0::FakeQuantize>(filterWeightsNode,
convLowNode, convHighNode, convLowNode, convHighNode, levels);
auto convWeightsFQ = std::dynamic_pointer_cast<ov::op::v0::FakeQuantize>(convWeightsFQNode);
auto conv = std::make_shared<ov::op::v1::Convolution>(reshape1, convWeightsFQ, strides, std::vector<ptrdiff_t>{ 0, 0 },
std::vector<ptrdiff_t>{ 0, 0 }, std::vector<size_t>{ 1, 1 },
ov::op::PadType::VALID);
auto biasesWeightsNode = ngraph::builder::makeConstant(ngPrc, {}, std::vector<float>{ 0.0f });
auto biasesWeightsNode = ov::test::utils::deprecated::make_constant(ngPrc, {}, std::vector<float>{ 0.0f });
auto add_1 = std::make_shared<ov::op::v1::Add>(conv, biasesWeightsNode);
auto widthAfterConv = (convInputShape[3] - kernelShape[1]) / strides[1] + 1;
auto heightAfterConv = (convInputShape[2] - kernelShape[0]) / strides[0] + 1;
std::vector<size_t> outFormShapes = {1, outputChannels * widthAfterConv * heightAfterConv };
auto lowNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 },
auto lowNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 },
std::vector<float>{inputDataMin * weightVal * kernelShape[1] * 1.5f});
auto highNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 },
auto highNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 },
std::vector<float>{inputDataMax * weightVal * kernelShape[1] * 1.5f});
auto fq = std::make_shared<ov::op::v0::FakeQuantize>(add_1, lowNode, highNode, lowNode, highNode, levels);

6
src/tests/functional/shared_test_classes/src/subgraph/conv_strides_opt.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/conv_strides_opt.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace ov {
namespace test {
@ -26,14 +28,14 @@ void ConvStridesOpt::SetUp() {
std::tie(input_shape, pad_type, targetDevice) = this->GetParam();
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, input_shape);
auto C = input_shape[1];
auto weights1 = ngraph::builder::makeConstant<float>(element::f32, {C, C, 3, 3}, {}, true);
auto weights1 = ov::test::utils::deprecated::make_constant<float>(element::f32, {C, C, 3, 3}, {}, true);
auto spatial_dims = input_shape.size() - 2;
Strides strides1(spatial_dims, 1);
Strides dilations(spatial_dims, 1);
CoordinateDiff pad_begin1(spatial_dims, 1), pad_end1(spatial_dims, 1);
auto conv1 =
std::make_shared<ov::op::v1::Convolution>(param, weights1, strides1, pad_begin1, pad_end1, dilations, pad_type);
auto weights2 = ngraph::builder::makeConstant<float>(element::f32, {C, C, 1, 1}, {}, true);
auto weights2 = ov::test::utils::deprecated::make_constant<float>(element::f32, {C, C, 1, 1}, {}, true);
CoordinateDiff pad_begin2(spatial_dims, 0), pad_end2(spatial_dims, 0);
Strides strides2(spatial_dims, 2);
auto conv2 = std::make_shared<ov::op::v1::Convolution>(conv1, weights2, strides2, pad_begin2, pad_end2, dilations);

18
src/tests/functional/shared_test_classes/src/subgraph/delayed_copy_layer.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/delayed_copy_layer.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
void DelayedCopyTestBase::InitMemory() {
auto states = inferRequest.QueryState();
@ -140,21 +142,21 @@ namespace SubgraphTestsDefinitions {
memory_init = ov::test::utils::generate_float_numbers(memory_size, -0.2f, 0.2f);
auto mem_c = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{8, memory_size / 8}, memory_init);
auto mem_c = ov::test::utils::deprecated::make_constant(ngPrc, ngraph::Shape{8, memory_size / 8}, memory_init);
auto mem_r = std::make_shared<ov::op::v3::ReadValue>(mem_c, "id");
auto reshape_pattern1 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape_pattern1 = ov::test::utils::deprecated::make_constant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(mem_r, reshape_pattern1, false);
auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
auto split = std::make_shared<ov::op::v1::Split>(reshape1, split_axis_op, 2);
auto concat = std::make_shared<ov::op::v0::Concat>(ngraph::OutputVector{split->output(0), input[0]}, 1);
auto reshape_pattern2 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{8, memory_size / 8});
auto reshape_pattern2 = ov::test::utils::deprecated::make_constant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{8, memory_size / 8});
auto reshape2 = std::make_shared<ov::op::v1::Reshape>(concat, reshape_pattern2, false);
auto mem_w = std::make_shared<ov::op::v3::Assign>(reshape2, "id");
auto relu = std::make_shared<ov::op::v0::Sigmoid>(reshape2);
auto reshape_pattern3 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape_pattern3 = ov::test::utils::deprecated::make_constant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape3 = std::make_shared<ov::op::v1::Reshape>(relu, reshape_pattern3, false);
mem_w->add_control_dependency(mem_r);
@ -175,18 +177,18 @@ namespace SubgraphTestsDefinitions {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
ov::ParameterVector input {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{1, memory_size / 2})};
auto mem_c = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{1, memory_size}, memory_init);
auto reshape_pattern1 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto mem_c = ov::test::utils::deprecated::make_constant(ngPrc, ngraph::Shape{1, memory_size}, memory_init);
auto reshape_pattern1 = ov::test::utils::deprecated::make_constant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(mem_c, reshape_pattern1, false);
auto split_axis_op = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{}, std::vector<int64_t>{1});
auto split = std::make_shared<ov::op::v1::Split>(reshape1, split_axis_op, 2);
auto concat = std::make_shared<ov::op::v0::Concat>(ngraph::OutputVector{split->output(0), input[0]}, 1);
auto reshape_pattern2 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{8, memory_size / 8});
auto reshape_pattern2 = ov::test::utils::deprecated::make_constant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{8, memory_size / 8});
auto reshape2 = std::make_shared<ov::op::v1::Reshape>(concat, reshape_pattern2, false);
auto relu = std::make_shared<ov::op::v0::Sigmoid>(reshape2);
auto reshape_pattern3 = ngraph::builder::makeConstant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape_pattern3 = ov::test::utils::deprecated::make_constant(ngraph::element::i64, ngraph::Shape{2}, ngraph::Shape{1, memory_size});
auto reshape3 = std::make_shared<ov::op::v1::Reshape>(relu, reshape_pattern3, false);
function = std::make_shared<ngraph::Function>(reshape3, input, "delayed_copy_layer_reshape_nonmemory");

3
src/tests/functional/shared_test_classes/src/subgraph/first_connect_input_concat.cpp
View File

@ -4,6 +4,7 @@
#include "shared_test_classes/subgraph/first_connect_input_concat.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -34,7 +35,7 @@ void ConcatFirstInputTest::SetUp() {
for (auto&& shape : inputShapes) {
params.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape)));
}
auto const_second_param = ngraph::builder::makeConstant(ngPrc, {1, 8}, std::vector<float>{-1.0f});
auto const_second_param = ov::test::utils::deprecated::make_constant(ngPrc, {1, 8}, std::vector<float>{-1.0f});
auto concat = std::make_shared<ov::op::v0::Concat>(ngraph::OutputVector{params[0], const_second_param}, 1);
auto relu = std::make_shared<ov::op::v0::Relu>(concat);

16
src/tests/functional/shared_test_classes/src/subgraph/fq_conv_fq_affine.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/fq_conv_fq_affine.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string FqConvFqAffineTest::getTestCaseName(const testing::TestParamInfo<FqConvFqAffineTestParamsSet>& obj) {
@ -84,11 +86,11 @@ void FqConvFqAffineTest::SetUp() {
auto reshapePattern1 = std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{ 4 }, convInputShape);
auto reshape1 = std::make_shared<ov::op::v1::Reshape>(inputFQ, reshapePattern1, false);
auto filterWeightsNode = ngraph::builder::makeConstant<float>(ngPrc, {outputChannels, inputChannels, kernelShape[0], kernelShape[1]},
auto filterWeightsNode = ov::test::utils::deprecated::make_constant<float>(ngPrc, {outputChannels, inputChannels, kernelShape[0], kernelShape[1]},
{ 1.0f });
auto convLowNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMin});
auto convHighNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMax});
auto convLowNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMin});
auto convHighNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMax});
auto convWeightsFQNode = std::make_shared<ov::op::v0::FakeQuantize>(filterWeightsNode,
convLowNode, convHighNode, convLowNode, convHighNode, levels[1]);
auto convWeightsFQ = std::dynamic_pointer_cast<ov::op::v0::FakeQuantize>(convWeightsFQNode);
@ -96,7 +98,7 @@ void FqConvFqAffineTest::SetUp() {
auto conv = std::make_shared<ov::op::v1::Convolution>(reshape1, convWeightsFQ, strides, std::vector<ptrdiff_t>{ 0, 0 },
std::vector<ptrdiff_t>{ 0, 0 }, std::vector<size_t>{ 1, 1 },
ov::op::PadType::VALID);
auto biasesWeightsNode = ngraph::builder::makeConstant(ngPrc, {}, std::vector<float>{ 0.0f });
auto biasesWeightsNode = ov::test::utils::deprecated::make_constant(ngPrc, {}, std::vector<float>{ 0.0f });
auto add = std::make_shared<ov::op::v1::Add>(conv, biasesWeightsNode);
auto widthAfterConv = (convInputShape[3] - kernelShape[1]) / strides[1] + 1;
@ -117,9 +119,9 @@ void FqConvFqAffineTest::SetUp() {
auto reshapePattern2 = std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{ 2 }, outFormShapes);
auto reshape2 = std::make_shared<ov::op::v1::Reshape>(nodeBeforeReshape, reshapePattern2, false);
auto matMulWeightsNode = ngraph::builder::makeConstant<float>(ngPrc, {outFormShapes[1], outFormShapes[1]}, { 1.0f });
auto matMulLowNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMin});
auto matMulHighNode = ngraph::builder::makeConstant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMax});
auto matMulWeightsNode = ov::test::utils::deprecated::make_constant<float>(ngPrc, {outFormShapes[1], outFormShapes[1]}, { 1.0f });
auto matMulLowNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMin});
auto matMulHighNode = ov::test::utils::deprecated::make_constant(ngraph::element::f32, std::vector<size_t>{ 1 }, std::vector<float>{inputDataMax});
auto matMulWeightsFQNode = std::make_shared<ov::op::v0::FakeQuantize>(matMulWeightsNode,
matMulLowNode, matMulHighNode, matMulLowNode, matMulHighNode, levels[1]);
auto matMulWeightsFQ = std::dynamic_pointer_cast<ov::op::v0::FakeQuantize>(matMulWeightsFQNode);

3
src/tests/functional/shared_test_classes/src/subgraph/fq_with_mixed_levels.cpp
View File

@ -5,6 +5,7 @@
#include "shared_test_classes/subgraph/fq_with_mixed_levels.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -42,7 +43,7 @@ void FqWithMixedLevelsTest::SetUp() {
auto constant = std::make_shared<ov::op::v0::Constant>(ngPrc, ngraph::Shape{shapes[1][0], shapes[1][1]}, weights);
auto fake2 = ngraph::builder::makeFakeQuantize(constant, ngPrc, level2, { 1 }, data2[0], data2[1], data2[2], data2[3]);
auto matmul = std::make_shared<ov::op::v0::MatMul>(fake1, fake2, false, true);
auto bias = ngraph::builder::makeConstant(ngPrc, std::vector<size_t>{shapes[0][0], shapes[1][0]}, std::vector<float>{ 1.0 });
auto bias = ov::test::utils::deprecated::make_constant(ngPrc, std::vector<size_t>{shapes[0][0], shapes[1][0]}, std::vector<float>{ 1.0 });
auto add = ov::test::utils::make_eltwise(matmul, bias, ngraph::helpers::EltwiseTypes::ADD);
return ngraph::builder::makeFakeQuantize(add, ngPrc, level3, { 1 }, data3[0], data3[1], data3[2], data3[3]);
};

4
src/tests/functional/shared_test_classes/src/subgraph/input_split_concat.cpp
View File

@ -3,7 +3,7 @@
//
#include "shared_test_classes/subgraph/input_split_concat.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
@ -39,7 +39,7 @@ void InputSplitConcatTest::SetUp() {
auto relu1 = std::make_shared<ov::op::v0::Relu>(split->output(0));
auto const_vals = ov::test::utils::generate_float_numbers(inputShape[1], -5.0f, 5.0f);
auto constant = ngraph::builder::makeConstant(ngPrc, inputShape, const_vals);
auto constant = ov::test::utils::deprecated::make_constant(ngPrc, inputShape, const_vals);
auto concat = std::make_shared<ov::op::v0::Concat>(ngraph::OutputVector{constant, split->output(1)}, 1);
auto relu2 = std::make_shared<ov::op::v0::Relu>(concat);

4
src/tests/functional/shared_test_classes/src/subgraph/matmul_act_add.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/matmul_act_add.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string MatMulActAddTest::getTestCaseName(const testing::TestParamInfo<MatMulActAddParams> &obj) {
InferenceEngine::Precision netPrecision;
@ -34,7 +36,7 @@ void MatMulActAddTest::SetUp() {
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape{ 1, inputSize })};
auto mul_const = ngraph::builder::makeConstant<float>(ngPrc, { outFormShapes[1], inputSize },
auto mul_const = ov::test::utils::deprecated::make_constant<float>(ngPrc, { outFormShapes[1], inputSize },
ov::test::utils::generate_float_numbers(outFormShapes[1] * inputSize, -0.5f, 0.5f), false);
auto matmul = std::make_shared<ov::op::v0::MatMul>(params[0], mul_const, false, true);

1
src/tests/functional/shared_test_classes/src/subgraph/matmul_const_transposes_extraction.cpp
View File

@ -8,7 +8,6 @@
#include "functional_test_utils/skip_tests_config.hpp"
#include "openvino/pass/manager.hpp"
#include "openvino/runtime/exec_model_info.hpp"
#include "ov_models/builders.hpp"
#include "shared_test_classes/subgraph/matmul_const_transposes_extraction.hpp"
namespace ov {

6
src/tests/functional/shared_test_classes/src/subgraph/matmul_squeeze_add.cpp
View File

@ -5,7 +5,7 @@
#include "shared_test_classes/subgraph/matmul_squeeze_add.hpp"
#include "common_test_utils/data_utils.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace ov {
namespace test {
@ -40,7 +40,7 @@ void MatmulSqueezeAddTest::SetUp() {
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(inputShape))};
auto constant_0 = ngraph::builder::makeConstant<float>(
auto constant_0 = ov::test::utils::deprecated::make_constant<float>(
element_type,
{outputSize, inputShape[1]},
ov::test::utils::generate_float_numbers(outputSize * inputShape[1], 0, 1, seed),
@ -51,7 +51,7 @@ void MatmulSqueezeAddTest::SetUp() {
std::make_shared<ov::op::v0::Constant>(ngraph::element::Type_t::i64, ngraph::Shape{1}, std::vector<size_t>{0});
auto unsqueeze_0 = std::make_shared<ov::op::v0::Unsqueeze>(matmul_0, constant_1);
auto constant_2 = ngraph::builder::makeConstant<float>(
auto constant_2 = ov::test::utils::deprecated::make_constant<float>(
element_type,
{1, inputShape[0], outputSize},
ov::test::utils::generate_float_numbers(inputShape[0] * outputSize, 0, 1, seed),

44
src/tests/functional/shared_test_classes/src/subgraph/memory_LSTMCell.cpp
View File

@ -3,6 +3,8 @@
//
#include "shared_test_classes/subgraph/memory_LSTMCell.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
#include "functional_test_utils/core_config.hpp"
#include "common_test_utils/data_utils.hpp"
@ -61,10 +63,10 @@ void MemoryLSTMCellTest::SetUp() {
ov::ParameterVector input_parameter{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(input_dims))};
input_parameter[0]->set_friendly_name("Parameter_1");
auto input_add_const = ngraph::builder::makeConstant(element_type, input_dims, input_bias);
auto input_add_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_bias);
auto add = ov::test::utils::make_eltwise(input_parameter[0], input_add_const, ov::test::utils::EltwiseTypes::ADD);
auto input_mul_const = ngraph::builder::makeConstant(element_type, input_dims, input_weights);
auto input_mul_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_weights);
auto mul = ov::test::utils::make_eltwise(add, input_mul_const, ov::test::utils::EltwiseTypes::MULTIPLY);
auto unsqueeze_input_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
@ -73,7 +75,7 @@ void MemoryLSTMCellTest::SetUp() {
auto permute_in_params = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{3}, Shape{{1, 0, 2}});
auto permute_in = std::make_shared<ov::op::v1::Transpose>(unsqueeze_input, permute_in_params);
auto cell_memory_constant = ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_constant = ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto var_cell =
std::make_shared<Variable>(VariableInfo{PartialShape(cell_memory_dims), element_type, "cell_state_1"});
auto var_hidden =
@ -81,7 +83,7 @@ void MemoryLSTMCellTest::SetUp() {
auto cell_memory_read = std::make_shared<ov::op::v6::ReadValue>(cell_memory_constant, var_cell);
auto hidden_memory_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
auto hidden_memory_read = std::make_shared<ov::op::v6::ReadValue>(hidden_memory_constant, var_hidden);
// Body - inputs
@ -92,10 +94,10 @@ void MemoryLSTMCellTest::SetUp() {
auto squeeze_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(X, squeeze_const);
auto weightsNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto reccurrenceWeightsNode =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm = std::make_shared<ov::op::v0::LSTMCell>(squeeze,
H_t,
C_t,
@ -158,28 +160,28 @@ void MemoryLSTMCellTest::switch_to_friendly_model() {
ov::ParameterVector input_parameter{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(input_dims))};
input_parameter[0]->set_friendly_name("Parameter_1");
auto input_add_const = ngraph::builder::makeConstant(element_type, input_dims, input_bias);
auto input_add_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_bias);
auto add = ov::test::utils::make_eltwise(input_parameter[0], input_add_const, ov::test::utils::EltwiseTypes::ADD);
auto input_mul_const = ngraph::builder::makeConstant(element_type, input_dims, input_weights);
auto input_mul_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_weights);
auto mul = ov::test::utils::make_eltwise(add, input_mul_const, ov::test::utils::EltwiseTypes::MULTIPLY);
auto unsqueeze_input_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto unsqueeze_input = std::make_shared<ov::op::v0::Unsqueeze>(mul, unsqueeze_input_const);
auto cell_memory_constant = ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_constant = ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto hidden_memory_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
// Body - layers
auto squeeze_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(unsqueeze_input, squeeze_const);
auto weightsNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto reccurrenceWeightsNode =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm = std::make_shared<ov::op::v0::LSTMCell>(squeeze,
hidden_memory_constant,
cell_memory_constant,
@ -214,10 +216,10 @@ void MemoryLSTMCellTest::create_pure_tensor_iterator_model() {
ov::ParameterVector input_parameter{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(input_dims))};
input_parameter[0]->set_friendly_name("Parameter_1");
auto input_add_const = ngraph::builder::makeConstant(element_type, input_dims, input_bias);
auto input_add_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_bias);
auto add = ov::test::utils::make_eltwise(input_parameter[0], input_add_const, ov::test::utils::EltwiseTypes::ADD);
auto input_mul_const = ngraph::builder::makeConstant(element_type, input_dims, input_weights);
auto input_mul_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_weights);
auto mul = ov::test::utils::make_eltwise(add, input_mul_const, ov::test::utils::EltwiseTypes::MULTIPLY);
auto unsqueeze_input_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
@ -226,10 +228,10 @@ void MemoryLSTMCellTest::create_pure_tensor_iterator_model() {
auto permute_in_params = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{3}, Shape{{1, 0, 2}});
auto permute_in = std::make_shared<ov::op::v1::Transpose>(unsqueeze_input, permute_in_params);
auto cell_memory_constant = ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_constant = ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto hidden_memory_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
// Body - inputs
auto X = std::make_shared<ov::op::v0::Parameter>(element_type, Shape{1, 1, inputSize});
@ -241,10 +243,10 @@ void MemoryLSTMCellTest::create_pure_tensor_iterator_model() {
auto squeeze_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(X, squeeze_const);
auto weightsNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto reccurrenceWeightsNode =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm = std::make_shared<ov::op::v0::LSTMCell>(squeeze,
H_t,
C_t,

9
src/tests/functional/shared_test_classes/src/subgraph/memory_eltwise_reshape_concat.cpp
View File

@ -5,6 +5,7 @@
#include <transformations/op_conversions/lstm_cell_decomposition.hpp>
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/subgraph/memory_eltwise_reshape_concat.hpp"
#include "common_test_utils/node_builders/eltwise.hpp"
@ -54,7 +55,7 @@ void MemoryEltwiseReshapeConcatTest::initTestModel() {
InferenceEngine::SizeVector input_dims = {1, inputSize * concatSize};
ov::ParameterVector input_parameter {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(input_dims))};
auto memory_constant = ngraph::builder::makeConstant<float>(ngPrc, input_dims, memory_init);
auto memory_constant = ov::test::utils::deprecated::make_constant<float>(ngPrc, input_dims, memory_init);
memory_constant->set_friendly_name("memory_constant");
auto memory_read = std::make_shared<ov::op::v3::ReadValue>(memory_constant, "memory");
memory_read->set_friendly_name("memory_read");
@ -70,7 +71,7 @@ void MemoryEltwiseReshapeConcatTest::initTestModel() {
auto reshape_1 = std::make_shared<ov::op::v1::Reshape>(mul, reshape_1_pattern, false);
reshape_1->set_friendly_name("reshape");
auto concat_constant = ngraph::builder::makeConstant(ngPrc, {1, concatSize}, concat_vals);
auto concat_constant = ov::test::utils::deprecated::make_constant(ngPrc, {1, concatSize}, concat_vals);
concat_constant->set_friendly_name("concat_constant");
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{concat_constant, reshape_1}, 0);
@ -89,7 +90,7 @@ void MemoryEltwiseReshapeConcatTest::initNgraphFriendlyModel() {
InferenceEngine::SizeVector input_dims = {1, inputSize * concatSize};
ov::ParameterVector input_parameter {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(input_dims))};
auto memory_constant = ngraph::builder::makeConstant<float>(ngPrc, input_dims, memory_init);
auto memory_constant = ov::test::utils::deprecated::make_constant<float>(ngPrc, input_dims, memory_init);
memory_constant->set_friendly_name("memory_constant");
auto mul = ov::test::utils::make_eltwise(input_parameter[0], memory_constant, ngraph::helpers::EltwiseTypes::MULTIPLY);
@ -105,7 +106,7 @@ void MemoryEltwiseReshapeConcatTest::initNgraphFriendlyModel() {
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(reshape, squeeze_const);
squeeze->set_friendly_name("squeeze");
auto concat_constant = ngraph::builder::makeConstant(ngPrc, {1, concatSize}, concat_vals);
auto concat_constant = ov::test::utils::deprecated::make_constant(ngPrc, {1, concatSize}, concat_vals);
concat_constant->set_friendly_name("concat_constant");
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{concat_constant, squeeze}, 0);

6
src/tests/functional/shared_test_classes/src/subgraph/memory_fq_concat_prelu.cpp
View File

@ -5,6 +5,8 @@
#include "shared_test_classes/subgraph/memory_fq_concat_prelu.hpp"
#include <type_traits>
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
template<typename T>
@ -97,9 +99,9 @@ void MemoryFqConcatPrelu::SetUp() {
for (auto&& shape : inputs) {
input.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape)));
}
auto memory_read = ngraph::builder::makeConstant<size_t>(ngPrc, {inputs[0]}, {0});
auto memory_read = ov::test::utils::deprecated::make_constant<size_t>(ngPrc, {inputs[0]}, {0});
auto read = std::make_shared<ov::op::v3::ReadValue>(memory_read, "variable1");
auto fake_constatnt = ngraph::builder::makeConstant<size_t>(ngPrc, {inputs[0]}, {0});
auto fake_constatnt = ov::test::utils::deprecated::make_constant<size_t>(ngPrc, {inputs[0]}, {0});
auto fake = ngraph::builder::makeFakeQuantize(fake_constatnt, ngPrc,
std::get<0>(fake_quantize_params),
std::get<1>(fake_quantize_params),

6
src/tests/functional/shared_test_classes/src/subgraph/mul_conv_fusion.cpp
View File

@ -7,7 +7,7 @@
#include "common_test_utils/graph_comparator.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/pass/manager.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "transformations/common_optimizations/mul_conv_fusion.hpp"
namespace ov {
@ -40,11 +40,11 @@ void MulConvFusion::SetUp() {
auto param = std::make_shared<ov::op::v0::Parameter>(precision, input_shape);
auto spatial_dims = input_shape.size() - 2;
auto mul_const = ngraph::builder::makeConstant<float>(precision, const_shape, {}, true);
auto mul_const = ov::test::utils::deprecated::make_constant<float>(precision, const_shape, {}, true);
auto mul = std::make_shared<ov::op::v1::Multiply>(param, mul_const);
ov::Shape strides(spatial_dims, 1);
std::vector<ptrdiff_t> pad_begin(spatial_dims, 0), pad_end(spatial_dims, 0);
auto weights = ngraph::builder::makeConstant<float>(precision, weights_shape, {}, true);
auto weights = ov::test::utils::deprecated::make_constant<float>(precision, weights_shape, {}, true);
std::shared_ptr<ov::Node> conv;
if (conv_type == ov::op::v1::Convolution::get_type_info_static()) {
conv = std::make_shared<ov::op::v1::Convolution>(mul, weights, strides, pad_begin, pad_end, strides);

1
src/tests/functional/shared_test_classes/src/subgraph/multi_crops_to_concat.cpp
View File

@ -3,7 +3,6 @@
//
#include "shared_test_classes/subgraph/multi_crops_to_concat.hpp"
#include "ov_models/builders.hpp"
namespace SubgraphTestsDefinitions {

8
src/tests/functional/shared_test_classes/src/subgraph/multioutput_eltwise_squeeze_eltwise.cpp
View File

@ -4,6 +4,8 @@
#include "shared_test_classes/subgraph/multioutput_eltwise_squeeze_eltwise.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace SubgraphTestsDefinitions {
std::string MultioutputEltwiseReshapeEltwise::getTestCaseName(const testing::TestParamInfo<MultioutputEltwiseReshapeEltwiseTuple> &obj) {
std::vector<std::vector<size_t>> input;
@ -33,7 +35,7 @@ namespace SubgraphTestsDefinitions {
for (auto&& shape : inputs) {
input.push_back(std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(shape)));
}
auto eltwise_const = ngraph::builder::makeConstant(ngPrc,
auto eltwise_const = ov::test::utils::deprecated::make_constant(ngPrc,
ngraph::Shape{input[0]->get_shape()},
std::vector<float>{-1.0f});
auto eltwise = std::make_shared<ov::op::v1::Multiply>(input[0], eltwise_const);
@ -43,8 +45,8 @@ namespace SubgraphTestsDefinitions {
auto unsqueeze_constant = std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{1}, std::vector<int64_t>{0});
auto unsqueeze = std::make_shared<ov::op::v0::Squeeze>(squeeze, unsqueeze_constant);
auto eltwise_const2 = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{1}, std::vector<float>{1.01f});
auto eltwise_const3 = ngraph::builder::makeConstant(ngPrc, ngraph::Shape{1}, std::vector<float>{1.01f});
auto eltwise_const2 = ov::test::utils::deprecated::make_constant(ngPrc, ngraph::Shape{1}, std::vector<float>{1.01f});
auto eltwise_const3 = ov::test::utils::deprecated::make_constant(ngPrc, ngraph::Shape{1}, std::vector<float>{1.01f});
auto eltwise2 = std::make_shared<ov::op::v1::Multiply>(eltwise, eltwise_const2);
auto eltwise3 = std::make_shared<ov::op::v1::Multiply>(unsqueeze, eltwise_const3);
ngraph::ResultVector results{std::make_shared<ov::op::v0::Result>(eltwise2),

75
src/tests/functional/shared_test_classes/src/subgraph/multiple_LSTMCell.cpp
View File

@ -8,7 +8,8 @@
#include "functional_test_utils/skip_tests_config.hpp"
#include "openvino/pass/low_latency.hpp"
#include "openvino/pass/manager.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
namespace ov {
namespace test {
@ -56,10 +57,10 @@ void MultipleLSTMCellTest::SetUp() {
ov::ParameterVector input_parameter{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(input_dims))};
input_parameter[0]->set_friendly_name("Parameter_1");
auto input_add_const = ngraph::builder::makeConstant(element_type, input_dims, input_bias);
auto input_add_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_bias);
auto add = ov::test::utils::make_eltwise(input_parameter[0], input_add_const, ov::test::utils::EltwiseTypes::ADD);
auto input_mul_const = ngraph::builder::makeConstant(element_type, input_dims, input_weights);
auto input_mul_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_weights);
auto mul = ov::test::utils::make_eltwise(add, input_mul_const, ov::test::utils::EltwiseTypes::MULTIPLY);
auto unsqueeze_input_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
@ -68,7 +69,7 @@ void MultipleLSTMCellTest::SetUp() {
auto permute_in_params = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{3}, Shape{{1, 0, 2}});
auto permute_in = std::make_shared<ov::op::v1::Transpose>(unsqueeze_input, permute_in_params);
auto cell_memory_constant = ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_constant = ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto var_cell = std::make_shared<ov::op::util::Variable>(
ov::op::util::VariableInfo{PartialShape::dynamic(), element::dynamic, "cell_state_1"});
auto var_hidden = std::make_shared<ov::op::util::Variable>(
@ -77,7 +78,7 @@ void MultipleLSTMCellTest::SetUp() {
cell_memory_read->set_friendly_name("cell_memory");
auto hidden_memory_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
auto hidden_memory_read = std::make_shared<ov::op::v6::ReadValue>(hidden_memory_constant, var_hidden);
hidden_memory_read->set_friendly_name("hidden_memory");
@ -89,10 +90,10 @@ void MultipleLSTMCellTest::SetUp() {
auto squeeze_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(X, squeeze_const);
auto weightsNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto reccurrenceWeightsNode =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm = std::make_shared<ov::op::v0::LSTMCell>(squeeze,
H_t,
C_t,
@ -141,12 +142,12 @@ void MultipleLSTMCellTest::SetUp() {
auto var_hidden_2 = std::make_shared<ov::op::util::Variable>(
ov::op::util::VariableInfo{PartialShape::dynamic(), element::dynamic, "hidden_state_2"});
auto cell_memory_2_constant =
ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_2_read = std::make_shared<ov::op::v6::ReadValue>(cell_memory_2_constant, var_cell_2);
cell_memory_2_read->set_friendly_name("cell_memory_2");
auto hidden_memory_2_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
auto hidden_memory_2_read = std::make_shared<ov::op::v6::ReadValue>(hidden_memory_2_constant, var_hidden_2);
hidden_memory_2_read->set_friendly_name("hidden_memory_2");
@ -159,10 +160,10 @@ void MultipleLSTMCellTest::SetUp() {
auto squeeze_2 = std::make_shared<ov::op::v0::Squeeze>(X_2, squeeze_2_const);
auto weightsNode_2 =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, weights_2_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, weights_2_vals);
auto reccurrenceWeightsNode_2 =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode_2 = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode_2 = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm_2 = std::make_shared<ov::op::v0::LSTMCell>(squeeze_2,
H_t_2,
C_t_2,
@ -229,28 +230,28 @@ void MultipleLSTMCellTest::switch_to_friendly_model() {
ov::ParameterVector input_parameter{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(input_dims))};
input_parameter[0]->set_friendly_name("Parameter_1");
auto input_add_const = ngraph::builder::makeConstant(element_type, input_dims, input_bias);
auto input_add_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_bias);
auto add = ov::test::utils::make_eltwise(input_parameter[0], input_add_const, ov::test::utils::EltwiseTypes::ADD);
auto input_mul_const = ngraph::builder::makeConstant(element_type, input_dims, input_weights);
auto input_mul_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_weights);
auto mul = ov::test::utils::make_eltwise(add, input_mul_const, ov::test::utils::EltwiseTypes::MULTIPLY);
auto unsqueeze_input_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto unsqueeze_input = std::make_shared<ov::op::v0::Unsqueeze>(mul, unsqueeze_input_const);
// Body 1 - layers
auto cell_memory_constant = ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_constant = ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto hidden_memory_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
auto squeeze_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(unsqueeze_input, squeeze_const);
auto weightsNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto reccurrenceWeightsNode =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm = std::make_shared<ov::op::v0::LSTMCell>(squeeze,
hidden_memory_constant,
cell_memory_constant,
@ -273,19 +274,19 @@ void MultipleLSTMCellTest::switch_to_friendly_model() {
// Body 2 - layers
auto cell_memory_2_constant =
ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto hidden_memory_2_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
auto squeeze_2_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze_2 = std::make_shared<ov::op::v0::Squeeze>(inbetween_squeeze, squeeze_2_const);
auto weightsNode_2 =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, weights_2_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, weights_2_vals);
auto reccurrenceWeightsNode_2 =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode_2 = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode_2 = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm_2 = std::make_shared<ov::op::v0::LSTMCell>(squeeze_2,
hidden_memory_2_constant,
cell_memory_2_constant,
@ -321,10 +322,10 @@ void MultipleLSTMCellTest::create_pure_tensor_iterator_model() {
ov::ParameterVector input_parameter{std::make_shared<ov::op::v0::Parameter>(element_type, ov::Shape(input_dims))};
input_parameter[0]->set_friendly_name("Parameter_1");
auto input_add_const = ngraph::builder::makeConstant(element_type, input_dims, input_bias);
auto input_add_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_bias);
auto add = ov::test::utils::make_eltwise(input_parameter[0], input_add_const, ov::test::utils::EltwiseTypes::ADD);
auto input_mul_const = ngraph::builder::makeConstant(element_type, input_dims, input_weights);
auto input_mul_const = ov::test::utils::deprecated::make_constant(element_type, input_dims, input_weights);
auto mul = ov::test::utils::make_eltwise(add, input_mul_const, ov::test::utils::EltwiseTypes::MULTIPLY);
auto unsqueeze_input_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
@ -333,10 +334,10 @@ void MultipleLSTMCellTest::create_pure_tensor_iterator_model() {
auto permute_in_params = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{3}, Shape{{1, 0, 2}});
auto permute_in = std::make_shared<ov::op::v1::Transpose>(unsqueeze_input, permute_in_params);
auto cell_memory_constant = ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
auto cell_memory_constant = ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto hidden_memory_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
// Body - inputs
auto X = std::make_shared<ov::op::v0::Parameter>(element_type, Shape{1, 1, inputSize});
@ -348,10 +349,10 @@ void MultipleLSTMCellTest::create_pure_tensor_iterator_model() {
auto squeeze_const = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, squeeze_axes);
auto squeeze = std::make_shared<ov::op::v0::Squeeze>(X, squeeze_const);
auto weightsNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto weightsNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, inputSize}, weights_vals);
auto reccurrenceWeightsNode =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm = std::make_shared<ov::op::v0::LSTMCell>(squeeze,
H_t,
C_t,
@ -394,10 +395,10 @@ void MultipleLSTMCellTest::create_pure_tensor_iterator_model() {
// Second TI
auto cell_memory_2_constant =
ngraph::builder::makeConstant<float>(element_type, cell_memory_dims, cell_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, cell_memory_dims, cell_memory_init);
auto hidden_memory_2_constant =
ngraph::builder::makeConstant<float>(element_type, hidden_memory_dims, hidden_memory_init);
ov::test::utils::deprecated::make_constant<float>(element_type, hidden_memory_dims, hidden_memory_init);
// Body - inputs
auto X_2 = std::make_shared<ov::op::v0::Parameter>(element_type, Shape{1, 1, hiddenSize});
@ -410,10 +411,10 @@ void MultipleLSTMCellTest::create_pure_tensor_iterator_model() {
auto squeeze_2 = std::make_shared<ov::op::v0::Squeeze>(X_2, squeeze_2_const);
auto weightsNode_2 =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, weights_2_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, weights_2_vals);
auto reccurrenceWeightsNode_2 =
ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode_2 = ngraph::builder::makeConstant<float>(element_type, {4 * hiddenSize}, bias_vals);
ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize, hiddenSize}, reccurrenceWeights_vals);
auto biasNode_2 = ov::test::utils::deprecated::make_constant<float>(element_type, {4 * hiddenSize}, bias_vals);
auto lstm_2 = std::make_shared<ov::op::v0::LSTMCell>(squeeze_2,
H_t_2,
C_t_2,

5
src/tests/functional/shared_test_classes/src/subgraph/multiple_concat.cpp
View File

@ -3,6 +3,7 @@
//
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "shared_test_classes/subgraph/multiple_concat.hpp"
#include "common_test_utils/node_builders/activation.hpp"
@ -44,10 +45,10 @@ void MultipleConcatTest::SetUp() {
ov::ParameterVector input_parameter {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(input_dims))};
auto const_1 = ngraph::builder::makeConstant(ngPrc, constant_dims, concat_1_vals);
auto const_1 = ov::test::utils::deprecated::make_constant(ngPrc, constant_dims, concat_1_vals);
auto concat_1 = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{const_1, input_parameter[0]}, 1);
auto const_2 = ngraph::builder::makeConstant(ngPrc, constant_dims, concat_1_vals);
auto const_2 = ov::test::utils::deprecated::make_constant(ngPrc, constant_dims, concat_1_vals);
auto concat_2 = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{concat_1, const_2}, 1);
auto act = ov::test::utils::make_activation(concat_2, ngPrc, ngraph::helpers::ActivationTypes::Relu);

6
src/tests/functional/shared_test_classes/src/subgraph/multiply_add.cpp
View File

@ -4,7 +4,7 @@
#include "shared_test_classes/subgraph/multiply_add.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
namespace ov {
@ -32,9 +32,9 @@ void MultiplyAddLayerTest::SetUp() {
std::vector<size_t> constShape(inputShape.size(), 1);
constShape[1] = inputShape[1];
auto const_mul = ngraph::builder::makeConstant<float>(element_type, constShape, {}, true);
auto const_mul = ov::test::utils::deprecated::make_constant<float>(element_type, constShape, {}, true);
auto mul = std::make_shared<ov::op::v1::Multiply>(params[0], const_mul);
auto const_add = ngraph::builder::makeConstant<float>(element_type, constShape, {}, true);
auto const_add = ov::test::utils::deprecated::make_constant<float>(element_type, constShape, {}, true);
auto add = std::make_shared<ov::op::v1::Add>(mul, const_add);
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(add)};
function = std::make_shared<ov::Model>(results, params, "multiplyAdd");

8
src/tests/functional/shared_test_classes/src/subgraph/mvn_multiply_add.cpp
View File

@ -4,7 +4,7 @@
#include "shared_test_classes/subgraph/mvn_multiply_add.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
namespace ov {
@ -46,15 +46,15 @@ void MVNMultiplyAdd::SetUp() {
std::tie(inputShapes, constantShapes) = shapes;
ov::ParameterVector param{std::make_shared<ov::op::v0::Parameter>(dataType, ov::Shape(inputShapes))};
auto axesNode = ngraph::builder::makeConstant(axesType, ov::Shape{axes.size()}, axes);
auto axesNode = ov::test::utils::deprecated::make_constant(axesType, ov::Shape{axes.size()}, axes);
ov::op::MVNEpsMode nEpsMode = ov::op::MVNEpsMode::INSIDE_SQRT;
if (epsMode == "outside_sqrt")
nEpsMode = ov::op::MVNEpsMode::OUTSIDE_SQRT;
auto mvn = std::make_shared<ov::op::v6::MVN>(param[0], axesNode, normalizeVariance, eps, nEpsMode);
auto gamma = ngraph::builder::makeConstant<float>(dataType, constantShapes, {}, true);
auto gamma = ov::test::utils::deprecated::make_constant<float>(dataType, constantShapes, {}, true);
auto mul = std::make_shared<ov::op::v1::Multiply>(mvn, gamma);
auto beta = ngraph::builder::makeConstant<float>(dataType, constantShapes, {}, true);
auto beta = ov::test::utils::deprecated::make_constant<float>(dataType, constantShapes, {}, true);
auto add = std::make_shared<ov::op::v1::Add>(mul, beta);
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(add)};

3
src/tests/functional/shared_test_classes/src/subgraph/perm_conv_perm_concat.cpp
View File

@ -8,6 +8,7 @@
#include "functional_test_utils/skip_tests_config.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/convolution.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace ov {
namespace test {
@ -82,7 +83,7 @@ void PermConvPermConcat::SetUp() {
auto permute_out_shape = permute_out->get_output_shape(0);
auto concat_const =
ngraph::builder::makeConstant(element_type,
ov::test::utils::deprecated::make_constant(element_type,
{1, 1, 1, permute_out_shape[3]},
ov::test::utils::generate_float_numbers(permute_out_shape[3], -10, 10));

2
src/tests/functional/shared_test_classes/src/subgraph/permute_concat_permute.cpp
View File

@ -10,8 +10,6 @@
#include <ctime>
#include <iterator>
#include "ov_models/builders.hpp"
namespace SubgraphTestsDefinitions {
std::string PermuteConcatPermute::getTestCaseName(const testing::TestParamInfo<PermuteConcatPermuteTuple>& obj) {
std::vector<std::vector<size_t>> input;

3
src/tests/functional/shared_test_classes/src/subgraph/quantized_convolution_backprop_data.cpp
View File

@ -5,6 +5,7 @@
#include "shared_test_classes/subgraph/quantized_convolution_backprop_data.hpp"
#include "common_test_utils/node_builders/convolution_backprop_data.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
#include "ov_models/utils/ov_helpers.hpp"
namespace ov {
@ -63,7 +64,7 @@ void QuantConvBackpropDataLayerTest::SetUp() {
weightsShapes.insert(weightsShapes.end(), kernel.begin(), kernel.end());
std::vector<float> weightsData;
auto weightsNode = ngraph::builder::makeConstant(element_type, weightsShapes, weightsData, weightsData.empty());
auto weightsNode = ov::test::utils::deprecated::make_constant(element_type, weightsShapes, weightsData, weightsData.empty());
std::vector<size_t> weightsFqConstShapes(weightsShapes.size(), 1);
if (quantGranularity == ov::test::utils::QuantizationGranularity::Perchannel)

12
src/tests/functional/shared_test_classes/src/subgraph/quantized_convolution_batch_norm.cpp
View File

@ -5,7 +5,7 @@
#include "shared_test_classes/subgraph/quantized_convolution_batch_norm.hpp"
#include "functional_test_utils/skip_tests_config.hpp"
#include "openvino/runtime/exec_model_info.hpp"
#include "ov_models/builders.hpp"
#include "common_test_utils/node_builders/constant.hpp"
namespace ov {
namespace test {
@ -98,7 +98,7 @@ void QuantizedConvolutionBatchNorm::SetUp() {
auto low_weights = ov::op::v0::Constant::create(element::f32, weights_intervals_shape, {-0.72519057});
auto high_weights = ov::op::v0::Constant::create(element::f32, weights_intervals_shape, {0.72519057});
std::shared_ptr<Node> activations = nullptr;
std::shared_ptr<Node> weights = ngraph::builder::makeConstant(element::f32, weights_shape, {}, true, 0.5f, -0.5f);
std::shared_ptr<Node> weights = ov::test::utils::deprecated::make_constant(element::f32, weights_shape, {}, true, 0.5f, -0.5f);
if (quantize_type == QuantizeType::FAKE_QUANTIZE) {
activations = std::make_shared< ov::op::v0::FakeQuantize>(parameter, low_act, high_act, low_act, high_act, 256);
weights = std::make_shared< ov::op::v0::FakeQuantize>(weights, low_weights, high_weights, low_weights, high_weights, 255);
@ -158,10 +158,10 @@ void QuantizedConvolutionBatchNorm::SetUp() {
conv = std::make_shared<ov::op::v1::ConvolutionBackpropData>(activations, weights, Strides{1, 1},
CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
}
auto gamma = ngraph::builder::makeConstant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto beta = ngraph::builder::makeConstant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto mean = ngraph::builder::makeConstant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto var = ngraph::builder::makeConstant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto gamma = ov::test::utils::deprecated::make_constant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto beta = ov::test::utils::deprecated::make_constant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto mean = ov::test::utils::deprecated::make_constant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto var = ov::test::utils::deprecated::make_constant(element::f32, Shape{output_channels}, {}, true, 1.0f, 0.1f);
auto batch_norm = std::make_shared<ov::op::v5::BatchNormInference>(conv, gamma, beta, mean, var, 0.00001);
function = std::make_shared<ov::Model>(batch_norm, ParameterVector{parameter});
}

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