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

Update create_and_fill_tensor to work with InputGenerateData (#20008)

Browse Source 
* Update create_and_fill_tensor to work with InputGenerateData
This commit is contained in:
Oleg Pipikin
2023-12-13 15:21:23 +01:00
committed by GitHub
parent 20ad8b43a1
commit d18d8a457f
98 changed files with 862 additions and 545 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plugins/intel_cpu/tests/functional/single_layer_tests/adaptive_pooling.cpp
+5 -5
View File
@@ -159,11 +159,11 @@ protected:
dataPtr[i] = pooledVector[i];
}
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
2560,
0,
256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/batch_to_space.cpp
+5 -1
View File
@@ -66,7 +66,11 @@ public:
const auto& static_shape = targetInputStaticShapes[i];
switch (i) {
case 0: {
tensor = ov::test::utils::create_and_fill_tensor(param_type, static_shape, 2560, 0, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(param_type, static_shape, in_data);
break;
}
case 1: {
src/plugins/intel_cpu/tests/functional/single_layer_tests/broadcast.cpp
+5 -5
View File
@@ -171,11 +171,11 @@ protected:
}
} else {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
0,
1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i]);
src/plugins/intel_cpu/tests/functional/single_layer_tests/bucketize.cpp
+6 -7
View File
@@ -58,13 +58,12 @@ public:
const auto& funcInputs = function->inputs();
auto data_size = shape_size(targetInputStaticShapes[0]);
ov::Tensor tensorData = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(),
targetInputStaticShapes[0],
data_size * 5,
0,
10,
7235346);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = data_size * 5;
in_data.resolution = 10;
in_data.seed = 7235346;
ov::Tensor tensorData = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), targetInputStaticShapes[0], in_data);
ov::Tensor tensorBucket =
ov::test::utils::create_and_fill_tensor_unique_sequence(funcInputs[1].get_element_type(),
targetInputStaticShapes[1],
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/activation.cpp
+5 -2
View File
@@ -78,8 +78,11 @@ void ActivationLayerCPUTest::generate_inputs(const std::vector<ov::Shape>& targe
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i],
range, startFrom, resolution);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = startFrom;
in_data.range = range;
in_data.resolution = resolution;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/conversion.cpp
+5 -1
View File
@@ -98,7 +98,11 @@ void ConvertCPULayerTest::generate_inputs(const std::vector<ov::Shape>& targetIn
auto shape = targetInputStaticShapes.front();
size_t size = shape_size(shape);
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shape, 2 * size);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2 * size;
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shape, in_data);
if (inPrc == ov::element::f32) {
auto* rawBlobDataPtr = static_cast<float*>(tensor.data());
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/eltwise.cpp
+5 -1
View File
@@ -85,7 +85,11 @@ ov::Tensor EltwiseLayerCPUTest::generate_eltwise_input(const ov::element::Type&
break;
}
}
return ov::test::utils::create_and_fill_tensor(type, shape, params.range, params.start_from, params.resolution);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = params.start_from;
in_data.range = params.range;
in_data.resolution = params.resolution;
return ov::test::utils::create_and_fill_tensor(type, shape, in_data);
}
void EltwiseLayerCPUTest::generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) {
src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/reduce.cpp
+5 -5
View File
@@ -145,11 +145,11 @@ void ReduceCPULayerTest::generate_inputs(const std::vector<ov::Shape>& targetInp
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (reductionType == utils::ReductionType::Prod) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
5);
if (reductionType == ngraph::helpers::ReductionType::Prod) {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 5;
in_data.range = 10;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
if (netPrecision == ElementType::f32) {
auto* rawBlobDataPtr = static_cast<float*>(tensor.data());
for (size_t i = 0; i < tensor.get_size(); ++i) {
src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution_backprop_data.cpp
+5 -5
View File
@@ -109,11 +109,11 @@ public:
targetInputStaticShapes[i],
outShapeData[inferRequestNum].data());
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
2560,
0,
256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder.cpp
+6 -7
View File
@@ -92,14 +92,13 @@ protected:
ov::Tensor tensor;
if (i == 0) {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
0,
1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i]);
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
} else {
auto T = targetInputStaticShapes[i][0];
src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder_seq_len.cpp
+10 -11
View File
@@ -116,14 +116,13 @@ protected:
ov::Tensor tensor;
if (i == 0) {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
0,
1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i]);
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
} else if (i == 1) {
const auto seqLen = dataShape[1];
@@ -147,10 +146,10 @@ protected:
} else if (i == 2) {
// blank should be valid class type
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
dataShape[2],
0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = dataShape[2];
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_loss.cpp
+5 -1
View File
@@ -134,7 +134,11 @@ protected:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (i == 0) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), dataShape, 10, 0, 10);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 10;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), dataShape, in_data);
} else if (i == 1) {
tensor = ov::Tensor{funcInput.get_element_type(), {shapeN}};
if (funcInput.get_element_type() == ElementType::i32) {
src/plugins/intel_cpu/tests/functional/single_layer_tests/deformable_convolution.cpp
+29 -10
View File
@@ -101,29 +101,48 @@ protected:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
if (i == 0) { // "a_data"
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), inShape, 2, -1, 100);
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 100;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), inShape, in_data);
} else if (i == 1) { // "b_offset_vals"
if (offsetType == OffsetType::NATURAL) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 10, 0, 1);
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1;
} else if (offsetType == OffsetType::ZERO) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 1, 0, 1);
in_data.start_from = 0;
in_data.range = 1;
in_data.resolution = 1;
} else if (offsetType == OffsetType::REAL_POSITIVE) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 2, 0, 100);
in_data.start_from = 0;
in_data.range = 2;
in_data.resolution = 100;
} else if (offsetType == OffsetType::REAL_NEGATIVE) {
tensor =
ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 2, -2, 100);
in_data.start_from = -2;
in_data.range = 2;
in_data.resolution = 100;
} else if (offsetType == OffsetType::REAL_MISC) {
tensor =
ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 4, -2, 100);
in_data.start_from = -2;
in_data.range = 4;
in_data.resolution = 100;
} else {
OPENVINO_THROW("Unexpected offset type");
}
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, in_data);
} else if (i == 2) { // "c_filter_vals"
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), filtShape, 2, -1, 100);
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 100;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), filtShape, in_data);
} else if (i == 3) { // "c_modulation_scalars"
auto modShape = targetInputStaticShapes[3];
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), modShape, 1, 0, 100);
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 100;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), modShape, in_data);
} else {
OPENVINO_THROW("Unknown input of DeformableConvolution");
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/eye.cpp
+5 -4
View File
@@ -120,10 +120,11 @@ protected:
batchShapePtr[j] = outBatchShape[j];
}
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
1,
(i == 0 ? rowNum : (i == 1 ? colNum : shift)));
ov::test::utils::InputGenerateData in_data;
in_data.start_from = i == 0 ? rowNum : (i == 1 ? colNum : 6);
in_data.range = 1;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/fake_quantize.cpp
+4 -4
View File
@@ -131,10 +131,10 @@ protected:
ASSERT_EQ(funcInputs.size(), 1);
const auto& funcInput = funcInputs[0];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[0],
inDataHighBounds - inDataLowBounds,
inDataLowBounds);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = inDataLowBounds;
in_data.range = inDataHighBounds - inDataLowBounds;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/gather.cpp
+10 -12
View File
@@ -129,23 +129,21 @@ protected:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::runtime::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
if (funcInput.get_node()->get_friendly_name() == "data") {
const auto dataTypeSize = funcInput.get_element_type().size();
const uint32_t range = dataTypeSize == 4 ? 0x7FFFFFFF : dataTypeSize == 2 ? 0xFFFF : 0xFF;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[0],
range,
0,
1);
in_data.start_from = 0;
in_data.range = dataTypeSize == 4 ? 0x7FFFFFFF : dataTypeSize == 2 ? 0xFFFF : 0xFF;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data);
} else if (funcInput.get_node()->get_friendly_name() == "indices") {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[1],
axisDim * 2,
-axisDim,
1);
in_data.start_from = -axisDim;
in_data.range = axisDim * 2;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[1], in_data);
} else if (funcInput.get_node()->get_friendly_name() == "axis") {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), {1}, 1, axis, 1);
in_data.start_from = axis;
in_data.range = 1;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), {1}, in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_elements.cpp
+5 -6
View File
@@ -68,12 +68,11 @@ public:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
15,
0,
32768);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 15;
in_data.resolution = 32768;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp
+4 -4
View File
@@ -118,10 +118,10 @@ protected:
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
auto tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(),
targetInputStaticShapes[i],
maxBeamIndex,
(i == 2 || i == 3) ? maxBeamIndex / 2 : 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = (i == 2 || i == 3) ? maxBeamIndex / 2 : 0;
in_data.range = maxBeamIndex;
auto tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/grid_sample.cpp
+9 -15
View File
@@ -137,25 +137,19 @@ protected:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::runtime::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
if (funcInput.get_node()->get_friendly_name() == "data") {
int32_t range = std::accumulate(targetInputStaticShapes[0].begin(),
targetInputStaticShapes[0].end(),
1u,
std::multiplies<uint32_t>());
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[0],
range,
-range / 2,
1);
int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), targetInputStaticShapes[0].end(), 1u, std::multiplies<uint32_t>());
in_data.start_from = -range / 2;
in_data.range = range;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data);
} else if (funcInput.get_node()->get_friendly_name() == "grid") {
int32_t range = std::max(targetInputStaticShapes[0][2], targetInputStaticShapes[0][3]) + 2;
int32_t resolution = range / 2;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[1],
range,
-1,
resolution == 0 ? 1 : resolution);
in_data.start_from = -1;
in_data.range = range;
in_data.resolution = range / 2;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[1], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution_backprop_data.cpp
+6 -5
View File
@@ -110,11 +110,12 @@ public:
targetInputStaticShapes[i],
outShapeData[inferRequestNum].data());
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
2560,
0,
256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
src/plugins/intel_cpu/tests/functional/single_layer_tests/interpolate.cpp
+5 -1
View File
@@ -120,7 +120,11 @@ public:
tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], scales[inferRequestNum].data());
}
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
src/plugins/intel_cpu/tests/functional/single_layer_tests/loop.cpp
+14 -5
View File
@@ -66,8 +66,10 @@ protected:
size_t i = 0;
if (funcInputs[i].get_node_shared_ptr()->get_friendly_name() == "trip_count") {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
funcInput.get_shape(), 10, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = 10;
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), funcInput.get_shape(), in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
i++;
}
@@ -75,8 +77,11 @@ protected:
// parameters for body
for (; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i], 15, 0, 32768);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 15;
in_data.resolution = 32768;
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
@@ -425,7 +430,11 @@ class StaticLoopDynamicSubgraphCPUTest : public SubgraphBaseTest {
auto* dataPtr = tensor.data<bool>();
*dataPtr = true;
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/nonzero.cpp
+4 -1
View File
@@ -55,7 +55,10 @@ public:
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], range, startFrom);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = startFrom;
in_data.range = range;
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/normalize.cpp
+6 -2
View File
@@ -90,8 +90,12 @@ protected:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(
funcInput.get_element_type(), targetInputStaticShapes[i], 10, -5, 7, 222);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -5;
in_data.range = 10;
in_data.resolution = 7;
in_data.seed = 222;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/pad.cpp
+4 -1
View File
@@ -67,7 +67,10 @@ protected:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (i == 0) {
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 1, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = 10;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
if (funcInput.get_node()->get_friendly_name() == "pad_value")
tensor = ov::Tensor{funcInput.get_element_type(), ov::Shape{}, &padValue};
src/plugins/intel_cpu/tests/functional/single_layer_tests/proposal.cpp
+5 -1
View File
@@ -180,7 +180,11 @@ protected:
dataPtr[2] = 1.0f;
if (tensor.get_size() == 4) dataPtr[3] = 1.0f;
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp
+4 -3
View File
@@ -99,10 +99,11 @@ protected:
if (funcInputs.size() != 1) {
const auto maxSeqLength = targetInputStaticShapes.front().at(m_seqAxisIndex);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = maxSeqLength;
const auto seqLengthsTensor =
ov::test::utils::create_and_fill_tensor(funcInputs[1].get_element_type(),
targetInputStaticShapes[1],
maxSeqLength, 1);
ov::test::utils::create_and_fill_tensor(funcInputs[1].get_element_type(), targetInputStaticShapes[1], in_data);
inputs.insert({funcInputs[1].get_node_shared_ptr(), seqLengthsTensor});
}
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/roi_pooling.cpp
+5 -1
View File
@@ -161,7 +161,11 @@ protected:
}
}
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({ funcInput.get_node_shared_ptr(), tensor });
src/plugins/intel_cpu/tests/functional/single_layer_tests/roialign.cpp
+5 -1
View File
@@ -85,7 +85,11 @@ protected:
ov::Tensor data_tensor;
const auto& dataPrecision = funcInputs[0].get_element_type();
const auto& dataShape = targetInputStaticShapes.front();
data_tensor = ov::test::utils::create_and_fill_tensor(dataPrecision, dataShape, 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
data_tensor = ov::test::utils::create_and_fill_tensor(dataPrecision, dataShape, in_data);
const auto& coordsET = funcInputs[1].get_element_type();
auto coordsTensor = ov::Tensor{ coordsET, targetInputStaticShapes[1] };
src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_ND_update.cpp
+5 -1
View File
@@ -77,7 +77,11 @@ protected:
}
} else {
if (inputPrecision.is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, ov::test::utils::InputGenerateData(0, 10, 1000));
} else {
tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape);
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_elements_update.cpp
+5 -1
View File
@@ -80,7 +80,11 @@ protected:
}
} else {
if (inputPrecision.is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape);
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/select.cpp
+15 -15
View File
@@ -71,21 +71,21 @@ protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& modelInputs = function->inputs();
auto condTensor = ov::test::utils::create_and_fill_tensor(modelInputs[0].get_element_type(),
targetInputStaticShapes[0],
3,
-1,
2);
auto thenTensor = ov::test::utils::create_and_fill_tensor(modelInputs[1].get_element_type(),
targetInputStaticShapes[1],
10,
-10,
2);
auto elseTensor = ov::test::utils::create_and_fill_tensor(modelInputs[2].get_element_type(),
targetInputStaticShapes[2],
10,
0,
2);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -1;
in_data.range = 3;
in_data.resolution = 2;
auto condTensor = ov::test::utils::create_and_fill_tensor(modelInputs[0].get_element_type(), targetInputStaticShapes[0], in_data);
in_data.start_from = -10;
in_data.range = 10;
in_data.resolution = 2;
auto thenTensor = ov::test::utils::create_and_fill_tensor(modelInputs[1].get_element_type(), targetInputStaticShapes[1], in_data);
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 2;
auto elseTensor = ov::test::utils::create_and_fill_tensor(modelInputs[2].get_element_type(), targetInputStaticShapes[2], in_data);
inputs.insert({modelInputs[0].get_node_shared_ptr(), condTensor});
inputs.insert({modelInputs[1].get_node_shared_ptr(), thenTensor});
inputs.insert({modelInputs[2].get_node_shared_ptr(), elseTensor});
src/plugins/intel_cpu/tests/functional/single_layer_tests/shape_ops.cpp
+9 -9
View File
@@ -103,20 +103,20 @@ protected:
#undef RESHAPE_TEST_CASE
}
} else {
ov::test::utils::InputGenerateData in_data;
if (isWithNonZero) {
// fill tensor with all zero, so the NonZero op will create 0 shape as the input of reshape op
tensor =
utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 1, 0);
in_data.start_from = 0;
in_data.range = 1;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
if (funcInput.get_element_type().is_real()) {
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
0,
1000);
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor =
utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
}
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/slice.cpp
+7 -7
View File
@@ -71,16 +71,16 @@ protected:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (i == 0u)
if (i == 0u) {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = 10;
// Fill the slice input0 tensor with random data.
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
1,
1);
else
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
// Fill the slice input1~input4 with specified data.
tensor = ov::Tensor{ov::element::i64, targetInputStaticShapes[i], inputValues[i - 1]};
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_batch.cpp
+5 -5
View File
@@ -63,11 +63,11 @@ public:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (i == 0U) {
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
2560,
0,
256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else if (i == 1U) {
tensor = ov::Tensor(funcInput.get_element_type(), paramShape);
auto* dataPtr = tensor.data<int64_t>();
src/plugins/intel_cpu/tests/functional/single_layer_tests/strided_slice.cpp
+5 -5
View File
@@ -76,11 +76,11 @@ protected:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (i == 0) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
1,
1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = 10;
in_data.resolution = 1;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::Tensor{ov::element::i64, targetInputStaticShapes[i], inputValues[i - 1]};
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/tile.cpp
+5 -5
View File
@@ -121,11 +121,11 @@ protected:
}
} else {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
0,
1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i]);
src/plugins/intel_cpu/tests/functional/single_layer_tests/topk.cpp
+5 -4
View File
@@ -215,10 +215,11 @@ private:
const auto& kPrecision = funcInputs[1].get_element_type();
const auto& kShape = targetInputStaticShapes[1];
const size_t startFrom = 1;
const size_t range = targetInputStaticShapes[0][axis];
const size_t seed = inferRequestNum++;
const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, range, startFrom, 1, seed);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = targetInputStaticShapes[0][axis];
in_data.seed = inferRequestNum++;;
const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, in_data);
inputs.insert({funcInputs[1].get_node_shared_ptr(), kTensor});
}
src/plugins/intel_cpu/tests/functional/single_layer_tests/unique.cpp
+5 -9
View File
@@ -123,15 +123,11 @@ protected:
ov::runtime::Tensor tensor;
if (funcInput.get_node()->get_friendly_name() == "data") {
int32_t range = std::accumulate(targetInputStaticShapes[0].begin(),
targetInputStaticShapes[0].end(),
1,
std::multiplies<size_t>());
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[0],
range,
-range / 2,
1);
int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), targetInputStaticShapes[0].end(), 1, std::multiplies<size_t>());
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -range / 2;
in_data.range = range;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convert_fq_rnn_to_quantized_rnn.cpp
+11 -3
View File
@@ -69,15 +69,23 @@ protected:
const auto& shapeX = targetInputStaticShapes[0];
const auto& shapeH = targetInputStaticShapes[1];
ov::Tensor tensorX = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shapeX, 1, 0, 16);
ov::Tensor tensorH = utils::create_and_fill_tensor(funcInputs[1].get_element_type(), shapeH, 1, 0, 16);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 1;
in_data.resolution = 16;
ov::Tensor tensorX = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shapeX, in_data);
ov::Tensor tensorH = utils::create_and_fill_tensor(funcInputs[1].get_element_type(), shapeH, in_data);
inputs.insert({funcInputs[0].get_node_shared_ptr(), tensorX});
inputs.insert({funcInputs[1].get_node_shared_ptr(), tensorH});
if (hasCell) {
const auto& shapeC = targetInputStaticShapes[cellIdx];
ov::Tensor tensorC = utils::create_and_fill_tensor(funcInputs[cellIdx].get_element_type(), shapeC, 2, -1, 128, 2);
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 128;
in_data.seed = 2;
ov::Tensor tensorC = utils::create_and_fill_tensor(funcInputs[cellIdx].get_element_type(), shapeC, in_data);
inputs.insert({funcInputs[cellIdx].get_node_shared_ptr(), tensorC});
}
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_caching.cpp
+4 -1
View File
@@ -128,7 +128,10 @@ public:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 1, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = 10;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_chain.cpp
+4 -1
View File
@@ -71,7 +71,10 @@ public:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 1, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = 10;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fq_caching.cpp
+4 -4
View File
@@ -206,10 +206,10 @@ protected:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
inDataHighBounds - inDataLowBounds,
inDataLowBounds);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = inDataLowBounds;
in_data.range = inDataHighBounds - inDataLowBounds;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/interaction.cpp
+5 -5
View File
@@ -134,11 +134,11 @@ public:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
15,
0,
32768);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 15;
in_data.resolution = 32768;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/mha.cpp
+18 -22
View File
@@ -189,17 +189,15 @@ public:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (funcInput.get_element_type() == ov::element::bf16)
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
2,
-1,
256);
else
tensor = ov::test::utils::create_and_fill_tensor_unique_sequence(funcInput.get_element_type(),
targetInputStaticShapes[i],
-1,
5);
if (funcInput.get_element_type() == ov::element::bf16) {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor_unique_sequence(funcInput.get_element_type(), targetInputStaticShapes[i], -1, 5);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
@@ -576,17 +574,15 @@ public:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
if (funcInput.get_element_type().is_real())
tensor = ov::test::utils::create_and_fill_tensor_normal_distribution(funcInput.get_element_type(),
targetInputStaticShapes[i],
0.0f,
1.5f);
else
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
255,
0,
1);
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor_normal_distribution(funcInput.get_element_type(), targetInputStaticShapes[i], 0.0f, 1.5f);
} else {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 255;
in_data.resolution = 1;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/ngram.cpp
+4 -1
View File
@@ -177,7 +177,10 @@ public:
const auto& indices_et = model_inputs[1].get_element_type();
const auto& indices_shape = targetInputStaticShapes[1];
const size_t batch_size = data_shape[0];
auto indices_tensor = ov::test::utils::create_and_fill_tensor(indices_et, indices_shape, batch_size, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = batch_size;
auto indices_tensor = ov::test::utils::create_and_fill_tensor(indices_et, indices_shape, in_data);
if (indices_et == ov::element::i32) {
auto* indices_data = indices_tensor.data<int32_t>();
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_inplace.cpp
+5 -5
View File
@@ -64,11 +64,11 @@ protected:
}
} else {
if (funcInput.get_element_type().is_real()) {
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
0,
1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/rotary_pos_emb.cpp
+5 -2
View File
@@ -149,8 +149,11 @@ public:
auto& input_shape = targetInputStaticShapes[0];
auto seq_length = input_shape[1];
ov::Tensor t_input =
utils::create_and_fill_tensor(funcInputs[0].get_element_type(), input_shape, 2, -1.0f, 32768);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 32768;
ov::Tensor t_input = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), input_shape, in_data);
ov::Tensor t_position_id_end = create_i32_tensor(ov::Shape({}), position_id_start + seq_length);
ov::Tensor t_position_ids = create_i32_tensor(ov::Shape({1, seq_length}), position_id_start);
src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp
+54 -17
View File
@@ -1262,7 +1262,10 @@ TEST_F(OVRemoteTensor_Test, NV12toGray) {
// ------------------------------------------------------
// Prepare input data
ov::Tensor fake_image = ov::test::utils::create_and_fill_tensor(ov::element::i8, {1, height, width, feature}, 50, 0, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
ov::Tensor fake_image = ov::test::utils::create_and_fill_tensor(ov::element::i8, {1, height, width, feature}, in_data);
ov::Tensor fake_image_regular = ov::test::utils::create_and_fill_tensor(ov::element::f32, {1, height, width, feature });
auto image_ptr = static_cast<uint8_t*>(fake_image.data());
@@ -1364,8 +1367,12 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_image_ConvertTranspose) {
// ------------------------------------------------------
// Prepare input data
ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1);
ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data);
in_data.range = 256;
ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data);
auto ie = ov::Core();
@@ -1475,7 +1482,10 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_image_single_plane) {
// ------------------------------------------------------
// Prepare input data
ov::Tensor fake_image_data_yuv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height * 3 / 2, width, 1}, 50);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
ov::Tensor fake_image_data_yuv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height * 3 / 2, width, 1}, in_data);
auto ie = ov::Core();
@@ -1565,8 +1575,12 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_image_two_planes) {
// ------------------------------------------------------
// Prepare input data
ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1);
ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data);
in_data.range = 256;
ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data);
auto ie = ov::Core();
@@ -1674,8 +1688,12 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_buffer) {
// ------------------------------------------------------
// Prepare input data
ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1);
ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data);
in_data.range = 256;
ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data);
auto ie = ov::Core();
@@ -1776,8 +1794,12 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toBGR_image_single_plane) {
// Prepare input data
std::vector<ov::Tensor> fake_image_data_yuv;
for (size_t i = 0; i < num_batch; i++) {
fake_image_data_yuv.push_back(ov::test::utils::create_and_fill_tensor(
ov::element::u8, {1, height * 3 / 2, width, 1}, 50, 0, 1, static_cast<int32_t>(i)));
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
in_data.resolution = 1;
in_data.seed = static_cast<int>(i);
fake_image_data_yuv.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height * 3 / 2, width, 1}, in_data));
}
auto ie = ov::Core();
@@ -1883,9 +1905,14 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toBGR_image_two_planes) {
// Prepare input data
std::vector<ov::Tensor> fake_image_data_y, fake_image_data_uv;
for (size_t i = 0; i < num_batch; i++) {
fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1, static_cast<int32_t>(i)));
fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor(
ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1, static_cast<int32_t>(i)));
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
in_data.resolution = 1;
in_data.seed = static_cast<int>(i);
fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data));
in_data.range = 256;
fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data));
}
auto ie = ov::Core();
@@ -2011,7 +2038,12 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toGray) {
std::vector<ov::Tensor> fake_image;
std::vector<ov::Tensor> fake_image_regular;
for (size_t i = 0; i < num_batch; i++) {
auto tensor_image = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, feature}, 50, 0, 1, static_cast<int32_t>(i));
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
in_data.resolution = 1;
in_data.seed = static_cast<int>(i);
auto tensor_image = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, feature}, in_data);
auto tensor_regular = ov::test::utils::create_and_fill_tensor(ov::element::f32, {1, feature, height, width });
auto image_ptr = static_cast<uint8_t*>(tensor_image.data());
auto image_ptr_regular = static_cast<float*>(tensor_regular.data());
@@ -2127,9 +2159,14 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toBGR_buffer) {
// Prepare input data
std::vector<ov::Tensor> fake_image_data_y, fake_image_data_uv;
for (size_t i = 0; i < num_batch * 2; ++i) {
fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1, static_cast<int32_t>(i)));
fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor(
ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1, static_cast<int32_t>(i)));
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 50;
in_data.resolution = 1;
in_data.seed = static_cast<int>(i);
fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data));
in_data.range = 256;
fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data));
}
auto ie = ov::Core();
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/broadcast.cpp
+5 -2
View File
@@ -170,8 +170,11 @@ protected:
}
} else {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(
funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/convolution_backprop_data.cpp
+5 -1
View File
@@ -101,7 +101,11 @@ public:
if (i == 1) {
tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], outShapeData[inferRequestNum].data());
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/detection_output.cpp
+5 -1
View File
@@ -142,7 +142,11 @@ public:
resolution = 10;
}
auto tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], range, 0, resolution);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = range;
in_data.resolution = resolution;
auto tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_elements.cpp
+5 -1
View File
@@ -56,7 +56,11 @@ public:
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 15, 0, 32768);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 15;
in_data.resolution = 32768;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_tree.cpp
+4 -4
View File
@@ -113,11 +113,11 @@ protected:
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = (i == 2 || i == 3) ? maxBeamIndex / 2 : 0;
in_data.range = maxBeamIndex;
auto tensor =
ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(),
targetInputStaticShapes[i],
maxBeamIndex,
(i == 2 || i == 3) ? maxBeamIndex / 2 : 0);
ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor});
}
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/grid_sample.cpp
+8 -5
View File
@@ -100,16 +100,19 @@ protected:
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::runtime::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
if (funcInput.get_node()->get_friendly_name() == "data") {
int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), targetInputStaticShapes[0].end(), 1u, std::multiplies<uint32_t>());
tensor = ov::test::utils::create_and_fill_tensor(
funcInput.get_element_type(), targetInputStaticShapes[0], range, -range / 2, 1);
in_data.start_from = -range / 2;
in_data.range = range;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data);
} else if (funcInput.get_node()->get_friendly_name() == "grid") {
int32_t range = std::max(targetInputStaticShapes[0][2], targetInputStaticShapes[0][3]) + 2;
int32_t resolution = range / 2;
tensor = ov::test::utils::create_and_fill_tensor(
funcInput.get_element_type(), targetInputStaticShapes[1], range, -1, resolution == 0 ? 1 : resolution);
in_data.start_from = -1;
in_data.range = range;
in_data.resolution = range / 2;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[1], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/group_convolution_backprop_data.cpp
+5 -1
View File
@@ -102,7 +102,11 @@ public:
if (i == 1) {
tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], outShapeData[inferRequestNum].data());
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/interpolate.cpp
+5 -1
View File
@@ -111,7 +111,11 @@ public:
ov::Tensor tensor;
if (i == 0) {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2560;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else if (i == 1) {
if (shapeCalcMode == ov::op::v4::Interpolate::ShapeCalcMode::SIZES || funcInputs.size() == 3) {
tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], sizes[inferRequestNum].data());
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/pad.cpp
+5 -2
View File
@@ -152,8 +152,11 @@ protected:
data[0] = argPadValue;
} else {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(
funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/roi_pooling.cpp
+5 -1
View File
@@ -149,7 +149,11 @@ protected:
}
}
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({ funcInput.get_node_shared_ptr(), tensor });
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/scatter_nd_update.cpp
+5 -1
View File
@@ -104,7 +104,11 @@ protected:
}
} else {
if (model_type.is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(model_type, targetShape, 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(model_type, targetShape, in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(model_type, targetShape);
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/tile.cpp
+5 -2
View File
@@ -116,8 +116,11 @@ protected:
}
} else {
if (funcInput.get_element_type().is_real()) {
tensor = ov::test::utils::create_and_fill_tensor(
funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 1000;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/top_k.cpp
+5 -4
View File
@@ -133,10 +133,11 @@ protected:
const auto& kPrecision = funcInputs[1].get_element_type();
const auto& kShape = targetInputStaticShapes[1];
const size_t startFrom = 1;
const size_t range = targetInputStaticShapes[0][axis];
const size_t seed = inferRequestNum++;
const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, range, startFrom, 1, seed);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = targetInputStaticShapes[0][axis];
in_data.seed = inferRequestNum++;
const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, in_data);
inputs.insert({funcInputs[1].get_node_shared_ptr(), kTensor});
}
src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/unique.cpp
+4 -5
View File
@@ -108,11 +108,10 @@ protected:
targetInputStaticShapes[0].end(),
1,
std::multiplies<size_t>());
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[0],
range,
-range / 2,
1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -range / 2;
in_data.range = range;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp
+6 -1
View File
@@ -807,7 +807,12 @@ protected:
inputs.insert({param, tensor});
} else {
auto tensor = ov::test::utils::create_and_fill_tensor(param->get_element_type(), input_shape, 10, 0, 128);
ov::test::utils::InputGenerateData inGenData;
inGenData.range = 10;
inGenData.start_from = 0;
inGenData.resolution = 128;
inGenData.seed = 1;
auto tensor = ov::test::utils::create_and_fill_tensor(param->get_element_type(), input_shape, inGenData);
inputs.insert({param, tensor});
}
}
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_model_static_split_layer.cpp
+13 -13
View File
@@ -47,19 +47,19 @@ public:
}
protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
80,
0,
8);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 80;
in_data.resolution = 8;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
void SetUp() override {
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_gen_impl_key.cpp
+13 -11
View File
@@ -54,17 +54,19 @@ public:
}
protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
80, 0, 8);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 80;
in_data.resolution = 8;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
void SetUp() override {
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_reduce_deconvolution_concat.cpp
+13 -11
View File
@@ -50,17 +50,19 @@ public:
}
protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
80, 0, 8);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 80;
in_data.resolution = 8;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
void SetUp() override {
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_activation.cpp
+13 -13
View File
@@ -56,19 +56,19 @@ public:
}
protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
80,
0,
8);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 80;
in_data.resolution = 8;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
void SetUp() override {
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_reduce_reshape.cpp
+13 -11
View File
@@ -52,17 +52,19 @@ public:
}
protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
80, 0, 8);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
const auto& funcInput = funcInputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 80;
in_data.resolution = 8;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
void SetUp() override {
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_with_empty_tensor.cpp
+21 -19
View File
@@ -49,26 +49,28 @@ public:
}
protected:
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
auto node = funcInputs[i].get_node_shared_ptr();
auto tensor = ov::runtime::Tensor(node->get_element_type(), targetInputStaticShapes[i]);
if (i == 0) {
// All zero inputs for non_zero op
auto tensor_ptr = static_cast<int32_t*>(tensor.data());
for (size_t j = 0; j < ov::shape_size(targetInputStaticShapes[i]); ++j) {
tensor_ptr[j] = 0;
}
} else {
// Random inputs for concat
tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(),
targetInputStaticShapes[i],
80, 0, 8);
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
inputs.clear();
const auto& funcInputs = function->inputs();
for (size_t i = 0; i < funcInputs.size(); ++i) {
auto node = funcInputs[i].get_node_shared_ptr();
auto tensor = ov::runtime::Tensor(node->get_element_type(), targetInputStaticShapes[i]);
if (i == 0) {
// All zero inputs for non_zero op
auto tensor_ptr = static_cast<int32_t*>(tensor.data());
for (size_t j = 0; j < ov::shape_size(targetInputStaticShapes[i]); ++j) {
tensor_ptr[j] = 0;
}
inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor});
}
} else {
// Random inputs for concat
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 80;
in_data.resolution = 8;
tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor});
}
}
void SetUp() override {
src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/matmul_weights_decompression.cpp
+10 -4
View File
@@ -192,7 +192,11 @@ protected:
mul_parent = std::make_shared<ov::op::v1::Subtract>(weights_convert, shift_convert);
}
auto scale_tensor = ov::test::utils::create_and_fill_tensor(data_precision, scaleshift_const_shape, 1, -0.5, 30000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -0.5;
in_data.range = 1;
in_data.resolution = 30000;
auto scale_tensor = ov::test::utils::create_and_fill_tensor(data_precision, scaleshift_const_shape, in_data);
for (size_t i = 0; i < scale_tensor.get_size(); i++) {
if (data_precision == ov::element::f16)
scale_tensor.data<ov::float16>()[i] /= ov::float16(16.f);
@@ -270,9 +274,11 @@ protected:
const auto& model_inputs = function->inputs();
for (size_t i = 0; i < model_inputs.size(); ++i) {
const auto& model_input = model_inputs[i];
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(),
target_input_static_shapes[i],
2, -1, 10000);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 10000;
ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), target_input_static_shapes[i], in_data);
inputs.insert({model_input.get_node_shared_ptr(), tensor});
}
}
src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/read_ir/read_ir.cpp
+2 -2
View File
@@ -139,7 +139,7 @@ void ReadIRTest::SetUp() {
if (!in_info.is_const) {
continue;
}
utils::ConstRanges::set(in_info.ranges.min, in_info.ranges.max);
ov::test::utils::set_const_ranges(in_info.ranges.min, in_info.ranges.max);
// auto next_node = param->get_default_output().get_node_shared_ptr();
auto next_node = param->get_default_output().get_target_inputs().begin()->get_node()->shared_from_this();
auto it = inputMap.find(next_node->get_type_info());
@@ -148,7 +148,7 @@ void ReadIRTest::SetUp() {
const_node->set_friendly_name(param->get_friendly_name());
ov::replace_node(param, const_node);
parameter_to_remove.push_back(param);
utils::ConstRanges::reset();
ov::test::utils::reset_const_ranges();
}
for (const auto& param : parameter_to_remove) {
function->remove_parameter(param);
src/tests/functional/plugin/shared/src/behavior/ov_infer_request/infer_request_dynamic.cpp
+22 -6
View File
@@ -93,7 +93,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetwork) {
ov::InferRequest req;
const std::string outputname = function->outputs().back().get_any_name();
for (auto& shape : vectorShapes) {
ov::runtime::Tensor inTensor = ov::test::utils::create_and_fill_tensor(element::f32, shape, 100, -50);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -50;
in_data.range = 100;
ov::runtime::Tensor inTensor = ov::test::utils::create_and_fill_tensor(element::f32, shape, in_data);
OV_ASSERT_NO_THROW(req = execNet.create_infer_request());
OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", inTensor));
OV_ASSERT_NO_THROW(req.infer());
@@ -115,11 +118,15 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkSetUnexpectedOutputTensorB
ov::runtime::Tensor tensor, otensor;
const std::string outputname = function->outputs().back().get_any_name();
OV_ASSERT_NO_THROW(req = execNet.create_infer_request());
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -50;
in_data.range = 100;
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data);
OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor));
auto outShape = refOutShape;
outShape[0] += 1;
otensor = ov::test::utils::create_and_fill_tensor(element::f32, outShape, 100, 50);
in_data.start_from = 50;
otensor = ov::test::utils::create_and_fill_tensor(element::f32, outShape, in_data);
OV_ASSERT_NO_THROW(req.set_tensor(outputname, otensor));
OV_ASSERT_NO_THROW(req.infer());
ASSERT_EQ(otensor.get_shape(), refOutShape);
@@ -140,7 +147,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkSetOutputTensorPreAllocate
ov::runtime::Tensor tensor;
const std::string outputname = function->outputs().back().get_any_name();
OV_ASSERT_NO_THROW(req = execNet.create_infer_request());
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -50;
in_data.range = 100;
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data);
OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor));
float ptr[5000];
ov::runtime::Tensor otensor(element::f32, refOutShape, ptr);
@@ -165,7 +175,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkSetOutputShapeBeforeInfer)
ov::runtime::Tensor tensor, otensor;
const std::string outputname = function->outputs().back().get_any_name();
OV_ASSERT_NO_THROW(req = execNet.create_infer_request());
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -50;
in_data.range = 100;
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data);
OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor));
OV_ASSERT_NO_THROW(otensor = req.get_tensor(outputname));
OV_ASSERT_NO_THROW(otensor.set_shape(refOutShape));
@@ -189,7 +202,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkGetOutputThenSetOutputTens
ov::runtime::Tensor tensor;
const std::string outputname = function->outputs().back().get_any_name();
OV_ASSERT_NO_THROW(req = execNet.create_infer_request());
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -50;
in_data.range = 100;
tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data);
OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor));
// first, get ouput tensor
OV_ASSERT_NO_THROW(req.infer());
src/tests/functional/plugin/shared/src/snippets/convert.cpp
+5 -2
View File
@@ -86,8 +86,11 @@ void Convert::generate_inputs(const std::vector<ov::Shape>& targetInputStaticSha
ov::Tensor tensor;
int32_t startFrom, range, resolution;
std::tie(startFrom, range, resolution) = params[i];
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i],
range, startFrom, resolution);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = startFrom;
in_data.range = range;
in_data.resolution = resolution;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
}
}
src/tests/functional/plugin/shared/src/snippets/mha.cpp
+16 -4
View File
@@ -81,9 +81,12 @@ void MHA::generate_inputs(const std::vector<ngraph::Shape>& targetInputStaticSha
for (int i = 0; i < model_inputs.size(); ++i) {
const auto& model_input = model_inputs[i];
ov::Tensor tensor;
ov::test::utils::InputGenerateData in_data;
// To avoid big relative errors in the vicinity of zero, only positive values are generated for bf16 precision
int start_from = model_input.get_element_type() == ov::element::bf16 ? 0 : -1;
tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), 2, start_from, 256);
in_data.start_from = model_input.get_element_type() == ov::element::bf16 ? 0 : -1;
in_data.range = 2;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), in_data);
inputs.insert({model_input.get_node_shared_ptr(), tensor});
}
}
@@ -101,10 +104,19 @@ void MHASelect::generate_inputs(const std::vector<ngraph::Shape>& targetInputSta
ov::Tensor tensor;
int seed = 0;
if (name.find("less") != std::string::npos) {
tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), 5 + seed, -2, 10, seed);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -2;
in_data.range = 5 + seed;
in_data.resolution = 10;
in_data.seed = seed;
tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), in_data);
seed++;
} else {
tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), 2, -1, 256);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -1;
in_data.range = 2;
in_data.resolution = 256;
tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), in_data);
}
inputs.insert({node_input, tensor});
}
src/tests/functional/plugin/shared/src/snippets/select.cpp
+15 -3
View File
@@ -16,9 +16,21 @@ namespace {
void generate_data(std::map<std::shared_ptr<ov::Node>, ov::Tensor>& data_inputs, const std::vector<ov::Output<ov::Node>>& model_inputs,
const std::vector<ngraph::Shape>& targetInputStaticShapes) {
data_inputs.clear();
auto tensor_bool = ov::test::utils::create_and_fill_tensor(model_inputs[0].get_element_type(), targetInputStaticShapes[0], 3, -1, 2);
auto tensor0 = ov::test::utils::create_and_fill_tensor(model_inputs[1].get_element_type(), targetInputStaticShapes[1], 10, -10, 2);
auto tensor1 = ov::test::utils::create_and_fill_tensor(model_inputs[2].get_element_type(), targetInputStaticShapes[2], 10, 0, 2);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -1;
in_data.range = 3;
in_data.resolution = 2;
auto tensor_bool = ov::test::utils::create_and_fill_tensor(model_inputs[0].get_element_type(), targetInputStaticShapes[0], in_data);
in_data.start_from = -10;
in_data.range = 10;
in_data.resolution = 2;
auto tensor0 = ov::test::utils::create_and_fill_tensor(model_inputs[1].get_element_type(), targetInputStaticShapes[1], in_data);
in_data.start_from = 0;
in_data.range = 10;
in_data.resolution = 2;
auto tensor1 = ov::test::utils::create_and_fill_tensor(model_inputs[2].get_element_type(), targetInputStaticShapes[2], in_data);
data_inputs.insert({model_inputs[0].get_node_shared_ptr(), tensor_bool});
data_inputs.insert({model_inputs[1].get_node_shared_ptr(), tensor0});
data_inputs.insert({model_inputs[2].get_node_shared_ptr(), tensor1});
src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/generate_inputs.hpp
+3
View File
@@ -13,6 +13,9 @@ namespace ov {
namespace test {
namespace utils {
void set_const_ranges(double _min, double _max);
void reset_const_ranges();
using InputsMap = std::map<ov::NodeTypeInfo, std::function<ov::runtime::Tensor(
const std::shared_ptr<ov::Node>& node,
size_t port,
src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp
+19 -54
View File
@@ -7,22 +7,25 @@
#include <map>
#include <vector>
#include "ngraph/node.hpp"
#include "ngraph/op/proposal.hpp"
#include "ngraph/op/power.hpp"
#include "ngraph/op/mod.hpp"
#include "ngraph/op/floor_mod.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/erf.hpp"
#include "ngraph/op/non_max_suppression.hpp"
#include "ngraph/op/reduce_l1.hpp"
#include "ngraph/op/reduce_l2.hpp"
#include "ngraph/op/reduce_sum.hpp"
#include "ngraph/op/reduce_prod.hpp"
#include "ngraph/op/reduce_mean.hpp"
#include "ngraph/op/max.hpp"
#include "ngraph/op/min.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "openvino/core/node.hpp"
#include "openvino/op/proposal.hpp"
#include "openvino/op/power.hpp"
#include "openvino/op/mod.hpp"
#include "openvino/op/floor_mod.hpp"
#include "openvino/op/divide.hpp"
#include "openvino/op/erf.hpp"
#include "openvino/op/non_max_suppression.hpp"
#include "openvino/op/reduce_l1.hpp"
#include "openvino/op/reduce_l2.hpp"
#include "openvino/op/reduce_sum.hpp"
#include "openvino/op/reduce_prod.hpp"
#include "openvino/op/reduce_mean.hpp"
#include "openvino/op/maximum.hpp"
#include "openvino/op/minimum.hpp"
#include "openvino/op/reduce_max.hpp"
#include "openvino/op/reduce_min.hpp"
#include "openvino/op/dft.hpp"
#include "openvino/op/idft.hpp"
#include "openvino/op/logical_and.hpp"
@@ -72,45 +75,7 @@ namespace ov {
namespace test {
namespace utils {
// todo: remove w/a to generate correct constant data (replace parameter to const) in conformance with defined range
struct ConstRanges {
static double max, min;
static bool is_defined;
static void set(double _min, double _max) {
min = _min;
max = _max;
is_defined = true;
}
static void reset() {
min = std::numeric_limits<double>::max();
max = std::numeric_limits<double>::min();
is_defined = false;
}
};
struct InputGenerateData {
double_t start_from;
uint32_t range;
int32_t resolution;
int seed;
InputGenerateData(double_t _start_from = 0, uint32_t _range = 10, int32_t _resolution = 1, int _seed = 1)
: start_from(_start_from), range(_range), resolution(_resolution), seed(_seed) {
if (ConstRanges::is_defined) {
auto min_orig = start_from;
auto max_orig = start_from + range * resolution;
auto min_ref = ConstRanges::min;
auto max_ref = ConstRanges::max;
if (min_orig < min_ref || min_orig == 0)
start_from = min_ref;
range = (max_orig > max_ref || max_orig == 10 ? max_ref : max_orig - start_from) - start_from;
}
}
};
static std::map<ov::NodeTypeInfo, std::vector<std::vector<InputGenerateData>>> inputRanges = {
static std::map<ov::NodeTypeInfo, std::vector<std::vector<ov::test::utils::InputGenerateData>>> inputRanges = {
// NodeTypeInfo: {IntRanges{}, RealRanges{}} (Ranges are used by generate<ov::Node>)
{ ov::op::v0::Erf::get_type_info_static(), {{{-3, 6}}, {{-3, 6, 10}}} },
{ ov::op::v1::Divide::get_type_info_static(), {{{101, 100}}, {{2, 2, 128}}} },
src/tests/functional/shared_test_classes/src/base/utils/generate_inputs.cpp
+88 -33
View File
@@ -20,9 +20,23 @@ namespace ov {
namespace test {
namespace utils {
double ConstRanges::max = std::numeric_limits<double>::min();
double ConstRanges::min = std::numeric_limits<double>::max();
bool ConstRanges::is_defined = false;
namespace {
struct {
double max = 0;
double min = 0;
bool is_defined = false;
} const_range;
} // namespace
void set_const_ranges(double _min, double _max) {
const_range.max = _max;
const_range.min = _min;
const_range.is_defined = true;
}
void reset_const_ranges() {
const_range.is_defined = false;
}
namespace {
@@ -43,6 +57,10 @@ namespace {
*
* All the generated numbers completely fit into the data type without truncation
*/
using ov::test::utils::InputGenerateData;
static inline void set_real_number_generation_data(InputGenerateData& inGenData) {
inGenData.range = 8;
inGenData.resolution = 32;
@@ -53,6 +71,17 @@ ov::runtime::Tensor generate(const std::shared_ptr<ov::Node>& node,
const ov::element::Type& elemType,
const ov::Shape& targetShape) {
InputGenerateData inGenData;
if (const_range.is_defined) {
auto min_orig = inGenData.start_from;
auto max_orig = inGenData.start_from + inGenData.range * inGenData.resolution;
auto min_ref = const_range.min;
auto max_ref = const_range.max;
if (min_orig < min_ref || min_orig == 0)
inGenData.start_from = min_ref;
inGenData.range = (max_orig > max_ref || max_orig == 10 ? max_ref : max_orig - inGenData.start_from) - inGenData.start_from;
}
if (elemType.is_real()) {
set_real_number_generation_data(inGenData);
}
@@ -67,8 +96,7 @@ ov::runtime::Tensor generate(const std::shared_ptr<ov::Node>& node,
const auto& range = ranges.at(elemType.is_real());
inGenData = range.size() < inNodeCnt ? range.front() : range.at(port);
}
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range,
inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
namespace Activation {
@@ -79,7 +107,7 @@ ov::runtime::Tensor generate(const ov::element::Type& elemType,
inGenData.range = 15;
inGenData.start_from = 0;
}
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
} // namespace Activation
@@ -89,10 +117,16 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v0::HardSigmoid>&
const ov::Shape& targetShape) {
switch (port) {
case 1: {
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, 0.2f);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0.2;
in_data.range = 0;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
}
case 2: {
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, 0.5f);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0.5;
in_data.range = 0;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
}
default: {
return Activation::generate(elemType, targetShape);
@@ -110,9 +144,15 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v0::PRelu>& node,
case 1: {
auto name = node->input(1).get_node()->get_friendly_name();
if (0 == name.compare("leakySlope")) {
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, 0.01f, 100);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0.01;
in_data.range = 0;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
} else if (0 == name.compare("negativeSlope")) {
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, -0.01f, 100);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -0.01;
in_data.range = 0;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
} else {
return Activation::generate(elemType, targetShape);
}
@@ -166,7 +206,7 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v0::DetectionOutp
inGenData.resolution = 10;
break;
}
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v0::FakeQuantize>& node,
@@ -225,7 +265,7 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v0::FakeQuantize>
inGenData.resolution = 1.0f;
inGenData.seed = seed;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
}
}
@@ -307,19 +347,22 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v1::GatherTree>&
InputGenerateData inGenData;
inGenData.start_from = maxBeamIndx / 2;
inGenData.range = maxBeamIndx;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
default:
InputGenerateData inGenData;
inGenData.range = maxBeamIndx;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
}
namespace LogicalOp {
ov::runtime::Tensor generate(const ov::element::Type& elemType,
const ov::Shape& targetShape) {
return create_and_fill_tensor(elemType, targetShape, 2, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 2;
return create_and_fill_tensor(elemType, targetShape, in_data);
}
}
@@ -373,7 +416,12 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v3::Bucketize>& n
switch (port) {
case 0: {
auto data_size = shape_size(targetShape);
return create_and_fill_tensor(elemType, targetShape, data_size * 5, 0, 10, 7235346);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = data_size * 5;
in_data.resolution = 10;
in_data.seed = 7235346;
return create_and_fill_tensor(elemType, targetShape, in_data);
}
case 1: {
return create_and_fill_tensor_unique_sequence(elemType, targetShape, 0, 10, 8234231);
@@ -446,8 +494,10 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v5::GRUSequence>&
const ov::element::Type& elemType,
const ov::Shape& targetShape) {
if (port == 2) {
unsigned int m_max_seq_len = 10;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, m_max_seq_len, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10; // max_seq_len
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
@@ -457,12 +507,16 @@ ov::runtime::Tensor generate(const std::shared_ptr<ov::op::v5::LSTMSequence>& no
const ov::element::Type& elemType,
const ov::Shape& targetShape) {
if (port == 2) {
unsigned int m_max_seq_len = 10;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, m_max_seq_len, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10; // max_seq_len
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
}
if (port == 3 && node->input(0).get_partial_shape().is_static()) {
auto seq_len = node->input(0).get_shape()[1];
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, seq_len);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = node->input(0).get_shape()[1]; // seq_len
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
@@ -593,8 +647,10 @@ ov::runtime::Tensor generate(const std::shared_ptr<ngraph::op::v5::RNNSequence>&
const ov::element::Type& elemType,
const ov::Shape& targetShape) {
if (port == 2) {
unsigned int m_max_seq_len = 10;
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, m_max_seq_len, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 10; // max_seq_len
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
@@ -769,8 +825,7 @@ ov::runtime::Tensor generate(const
in_gen_data.start_from = 0;
in_gen_data.resolution = 20;
}
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_gen_data.range,
in_gen_data.start_from, in_gen_data.resolution, in_gen_data.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_gen_data);
}
namespace comparison {
@@ -972,7 +1027,7 @@ ov::runtime::Tensor generate(const
const ov::Shape& targetShape) {
if (port == 0) {
InputGenerateData inGenData(-5, 10, 7, 222);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
@@ -983,7 +1038,7 @@ ov::runtime::Tensor generate(const
const ov::element::Type& elemType,
const ov::Shape& targetShape) {
InputGenerateData inGenData(1, 0, 1, 1);
auto tensor = ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
auto tensor = ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
if (0 == port || 1 == port) {
#define CASE(X) case X: { \
@@ -1017,7 +1072,7 @@ ov::runtime::Tensor generate(const
const ov::element::Type& elemType,
const ov::Shape& targetShape) {
InputGenerateData inGenData(1, 0, 1, 1);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
ov::runtime::Tensor generate(const
@@ -1031,7 +1086,7 @@ ov::runtime::Tensor generate(const
inGenData.range = 200;
inGenData.resolution = 2;
}
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
ov::runtime::Tensor generate(const
@@ -1041,7 +1096,7 @@ ov::runtime::Tensor generate(const
const ov::Shape& targetShape) {
if (port == 1) {
InputGenerateData inGenData(0, 1, 1000, 1);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
@@ -1053,7 +1108,7 @@ ov::runtime::Tensor generate(const
const ov::Shape& targetShape) {
if (port == 1) {
InputGenerateData inGenData(0, 1, 1000, 1);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
@@ -1065,7 +1120,7 @@ ov::runtime::Tensor generate(const
const ov::Shape& targetShape) {
if (port == 1) {
InputGenerateData inGenData(0, 1, 1000, 1);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed);
return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData);
}
return generate(std::dynamic_pointer_cast<ov::Node>(node), port, elemType, targetShape);
}
src/tests/functional/shared_test_classes/src/single_layer/gather_elements.cpp
+4 -1
View File
@@ -48,7 +48,10 @@ void GatherElementsLayerTest::SetUp() {
posAxis += dataShape.size();
const auto axisDim = dataShape[posAxis];
auto indicesValues = ov::test::utils::create_and_fill_tensor(ov::element::i32, indicesShape, axisDim - 1, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = axisDim - 1;
auto indicesValues = ov::test::utils::create_and_fill_tensor(ov::element::i32, indicesShape, in_data);
auto indicesNode = std::make_shared<ov::op::v0::Constant>(indicesValues);
auto gather = std::make_shared<ov::op::v6::GatherElements>(params[0], indicesNode, axis);
src/tests/functional/shared_test_classes/src/single_op/batch_norm.cpp
+9 -4
View File
@@ -40,18 +40,23 @@ void BatchNormLayerTest::SetUp() {
init_input_shapes(shapes);
ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(model_type, inputDynamicShapes.front())};
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = 1;
auto constant_shape = ov::Shape{params[0]->get_shape().at(1)};
auto gamma_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 1, 0);
auto gamma_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data);
auto gamma = std::make_shared<ov::op::v0::Constant>(gamma_tensor);
auto beta_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 1, 0);
auto beta_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data);
auto beta = std::make_shared<ov::op::v0::Constant>(beta_tensor);
auto mean_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 1, 0);
auto mean_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data);
auto mean = std::make_shared<ov::op::v0::Constant>(mean_tensor);
// Fill the vector for variance with positive values
auto variance_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 10, 0);
in_data.range = 10;
auto variance_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data);
auto variance = std::make_shared<ov::op::v0::Constant>(variance_tensor);
auto batch_norm = std::make_shared<ov::op::v5::BatchNormInference>(params[0], gamma, beta, mean, variance, epsilon);
src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp
+10 -3
View File
@@ -105,21 +105,28 @@ void EltwiseLayerTest::SetUp() {
parameters.push_back(param);
} else {
ov::Shape shape = inputDynamicShapes.back().get_max_shape();
ov::test::utils::InputGenerateData in_data;
switch (eltwise_type) {
case EltwiseTypes::DIVIDE:
case EltwiseTypes::MOD:
case EltwiseTypes::FLOOR_MOD: {
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, 8, 2);
in_data.start_from = 2;
in_data.range = 8;
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data);
secondary_input = std::make_shared<ov::op::v0::Constant>(tensor);
break;
}
case EltwiseTypes::POWER: {
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, 2, 1);
in_data.start_from = 1;
in_data.range = 2;
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data);
secondary_input = std::make_shared<ov::op::v0::Constant>(tensor);
break;
}
default: {
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, 9, 1);
in_data.start_from = 1;
in_data.range = 9;
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data);
secondary_input = std::make_shared<ov::op::v0::Constant>(tensor);
}
}
src/tests/functional/shared_test_classes/src/single_op/gather.cpp
+8 -2
View File
@@ -104,7 +104,10 @@ void Gather7LayerTest::SetUp() {
auto param = std::make_shared<ov::op::v0::Parameter>(model_type, inputDynamicShapes.front());
int axis_dim = targetStaticShapes[0][0][axis < 0 ? axis + targetStaticShapes[0][0].size() : axis];
auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, axis_dim - 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = axis_dim - 1;
auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, in_data);
auto indices_node = std::make_shared<ov::op::v0::Constant>(indices_node_tensor);
auto axis_node = ov::op::v0::Constant::create(ov::element::i64, ov::Shape(), {axis});
@@ -132,7 +135,10 @@ void Gather8LayerTest::SetUp() {
auto param = std::make_shared<ov::op::v0::Parameter>(model_type, inputDynamicShapes.front());
int axis_dim = targetStaticShapes[0][0][axis < 0 ? axis + targetStaticShapes[0][0].size() : axis];
auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, 2 * axis_dim, -axis_dim);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -axis_dim;
in_data.range = 2 * axis_dim;
auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, in_data);
auto indices_node = std::make_shared<ov::op::v0::Constant>(indices_node_tensor);
auto axis_node = ov::op::v0::Constant::create(ov::element::i64, ov::Shape(), {axis});
src/tests/functional/shared_test_classes/src/single_op/gather_elements.cpp
+4 -1
View File
@@ -52,7 +52,10 @@ void GatherElementsLayerTest::SetUp() {
auto param = std::make_shared<ov::op::v0::Parameter>(model_type, inputDynamicShapes.front());
auto axis_dim = targetStaticShapes[0][0][axis < 0 ? axis + targetStaticShapes[0][0].size() : axis];
auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(indices_type, indices_shape, axis_dim - 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = axis_dim - 1;
auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(indices_type, indices_shape, in_data);
auto indices_node = std::make_shared<ov::op::v0::Constant>(indices_node_tensor);
auto gather_el = std::make_shared<ov::op::v6::GatherElements>(param, indices_node, axis);
src/tests/functional/shared_test_classes/src/single_op/gather_tree.cpp
+4 -1
View File
@@ -59,7 +59,10 @@ void GatherTreeLayerTest::SetUp() {
}
for (const auto& shape : constant_shapes_static) {
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, input_shape.at(2) - 2, 1);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 1;
in_data.range = input_shape.at(2) - 2;
auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data);
auto constant = std::make_shared<ov::op::v0::Constant>(tensor);
inputs.push_back(constant);
}
src/tests/functional/shared_test_classes/src/single_op/gru_sequence.cpp
+4 -1
View File
@@ -97,7 +97,10 @@ void GRUSequenceTest::SetUp() {
seq_lengths_node = param;
} else if (mode == SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST ||
mode == SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) {
auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, targetStaticShapes[0][2], seq_lengths, 0);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = seq_lengths;
auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, targetStaticShapes[0][2], in_data);
seq_lengths_node = std::make_shared<ov::op::v0::Constant>(tensor);
} else {
std::vector<int64_t> lengths(batch, seq_lengths);
src/tests/functional/shared_test_classes/src/single_op/lstm_sequence.cpp
+4 -1
View File
@@ -116,7 +116,10 @@ void LSTMSequenceTest::SetUp() {
params.push_back(param);
} else if (mode == SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST ||
mode == SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) {
auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, inputShapes[3], seq_lengths);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = seq_lengths;
auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, inputShapes[3], in_data);
seq_lengths_node = std::make_shared<ov::op::v0::Constant>(tensor);
} else {
std::vector<int64_t> lengths(inputShapes[3][0], seq_lengths);
src/tests/functional/shared_test_classes/src/single_op/multiclass_nms.cpp
+2 -1
View File
@@ -66,7 +66,8 @@ void MulticlassNmsLayerTest::generate_inputs(const std::vector<ov::Shape>& targe
const size_t start_from = 0;
const size_t k = 1000;
const int seed = 1;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], range, start_from, k, seed);
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i],
ov::test::utils::InputGenerateData(start_from, range, k, seed));
} else if (i == 0) { // bboxes
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]);
} else { // roisnum
src/tests/functional/shared_test_classes/src/single_op/rnn_sequence.cpp
+4 -1
View File
@@ -85,7 +85,10 @@ void RNNSequenceTest::SetUp() {
seq_lengths_node = param;
} else if (mode == ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST ||
mode == ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) {
auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, input_shapes[2], static_cast<float>(seq_lengths), 0.f);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = seq_lengths;
auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, input_shapes[2], in_data);
seq_lengths_node = std::make_shared<ov::op::v0::Constant>(tensor);
} else {
std::vector<float> lengths(batch, seq_lengths);
src/tests/functional/shared_test_classes/src/subgraph/simple_if.cpp
+4 -4
View File
@@ -175,10 +175,10 @@ void SimpleIfNotConstConditionTest::generate_inputs(const std::vector<ov::Shape>
auto* dataPtr = tensor.data<bool>();
dataPtr[0] = condition;
} else {
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
targetInputStaticShapes[i],
10,
-5);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -5;
in_data.range = 10;
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data);
}
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
src/tests/test_utils/common_test_utils/include/common_test_utils/ov_tensor_utils.hpp
+20 -1
View File
@@ -9,9 +9,28 @@
namespace ov {
namespace test {
namespace utils {
struct InputGenerateData {
double start_from = 0;
uint32_t range = 10;
int32_t resolution = 1;
int32_t seed = 1;
InputGenerateData(double _start_from = 0, uint32_t _range = 10, int32_t _resolution = 1, int32_t _seed = 1)
: start_from(_start_from),
range(_range),
resolution(_resolution),
seed(_seed){};
};
ov::Tensor create_and_fill_tensor(const ov::element::Type element_type,
const ov::Shape& shape,
const uint32_t range = 10,
const InputGenerateData& inGenData = InputGenerateData(0, 10, 1, 1));
// Legacy impl for contrig repo
// todo: remove this after dependent repos clean up
ov::Tensor create_and_fill_tensor(const ov::element::Type element_type,
const ov::Shape& shape,
const uint32_t range,
const double_t start_from = 0,
const int32_t resolution = 1,
const int seed = 1);
src/tests/test_utils/common_test_utils/src/node_builders/augru_cell.cpp
+4 -4
View File
@@ -54,11 +54,11 @@ std::shared_ptr<ov::Node> make_augru(const OutputVector& in,
}
case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST:
case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = in[0].get_shape()[1];
auto seq_lengths_tensor =
ov::test::utils::create_and_fill_tensor(ov::element::i64,
constants[3],
static_cast<float>(in[0].get_shape()[1]),
0);
ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data);
seq_lengths = std::make_shared<ov::op::v0::Constant>(seq_lengths_tensor);
}
case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_PARAM:
src/tests/test_utils/common_test_utils/src/node_builders/gru_cell.cpp
+4 -4
View File
@@ -69,11 +69,11 @@ std::shared_ptr<ov::Node> make_gru(const OutputVector& in,
}
case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST:
case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = in[0].get_shape()[1];
auto seq_lengths_tensor =
ov::test::utils::create_and_fill_tensor(ov::element::i64,
constants[3],
static_cast<float>(in[0].get_shape()[1]),
0);
ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data);
seq_lengths = std::make_shared<ov::op::v0::Constant>(seq_lengths_tensor);
break;
}
src/tests/test_utils/common_test_utils/src/node_builders/lstm_cell.cpp
+12 -10
View File
@@ -31,14 +31,16 @@ std::shared_ptr<ov::Node> make_lstm(const std::vector<ov::Output<Node>>& in,
auto B = std::make_shared<ov::op::v0::Constant>(b_tensor);
if (WRB_range > 0) {
w_tensor =
ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[0], 2 * WRB_range, -WRB_range);
ov::test::utils::InputGenerateData in_data;
in_data.start_from = -WRB_range;
in_data.range = 2 * WRB_range;
w_tensor = ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[0], in_data);
W = std::make_shared<ov::op::v0::Constant>(w_tensor);
r_tensor =
ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[1], 2 * WRB_range, -WRB_range);
r_tensor = ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[1], in_data);
R = std::make_shared<ov::op::v0::Constant>(r_tensor);
b_tensor =
ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[2], 2 * WRB_range, -WRB_range);
b_tensor = ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[2], in_data);
B = std::make_shared<ov::op::v0::Constant>(b_tensor);
}
if (!make_sequence) {
@@ -80,11 +82,11 @@ std::shared_ptr<ov::Node> make_lstm(const std::vector<ov::Output<Node>>& in,
}
case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST:
case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = in[0].get_shape()[1];
auto seq_lengths_tensor =
ov::test::utils::create_and_fill_tensor(ov::element::i64,
constants[3],
static_cast<float>(in[0].get_shape()[1]),
0);
ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data);
seq_lengths = std::make_shared<ov::op::v0::Constant>(seq_lengths_tensor);
break;
}
src/tests/test_utils/common_test_utils/src/node_builders/rnn_cell.cpp
+4 -4
View File
@@ -67,11 +67,11 @@ std::shared_ptr<ov::Node> make_rnn(const OutputVector& in,
}
case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST:
case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: {
ov::test::utils::InputGenerateData in_data;
in_data.start_from = 0;
in_data.range = in[0].get_shape()[1];
auto seq_lengths_tensor =
ov::test::utils::create_and_fill_tensor(ov::element::i64,
constants[3],
static_cast<float>(in[0].get_shape()[1]),
0);
ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data);
seq_lengths = std::make_shared<ov::op::v0::Constant>(seq_lengths_tensor);
break;
}
src/tests/test_utils/common_test_utils/src/ov_tensor_utils.cpp
+42 -30
View File
@@ -13,44 +13,43 @@ namespace test {
namespace utils {
ov::Tensor create_and_fill_tensor(const ov::element::Type element_type,
const ov::Shape& shape,
const uint32_t range,
const double_t start_from,
const int32_t resolution,
const int seed) {
auto tensor = ov::Tensor{element_type, shape};
#define CASE(X) \
case X: \
fill_data_random(tensor.data<element_type_traits<X>::value_type>(), \
shape_size(shape), \
range, \
start_from, \
resolution, \
seed); \
const InputGenerateData& inGenData) {
auto tensor = ov::Tensor(element_type, shape);
#define CASE(X) \
case X: \
fill_data_random(tensor.data<fundamental_type_for<X>>(), \
shape_size(shape), \
inGenData.range, \
inGenData.start_from, \
inGenData.resolution, \
inGenData.seed); \
break;
switch (element_type) {
CASE(ov::element::Type_t::boolean)
CASE(ov::element::Type_t::i8)
CASE(ov::element::Type_t::i16)
CASE(ov::element::Type_t::i32)
CASE(ov::element::Type_t::i64)
CASE(ov::element::Type_t::u8)
CASE(ov::element::Type_t::u16)
CASE(ov::element::Type_t::u32)
CASE(ov::element::Type_t::u64)
CASE(ov::element::Type_t::bf16)
CASE(ov::element::Type_t::f16)
CASE(ov::element::Type_t::f32)
CASE(ov::element::Type_t::f64)
CASE(ov::element::boolean)
CASE(ov::element::i8)
CASE(ov::element::i16)
CASE(ov::element::i32)
CASE(ov::element::i64)
CASE(ov::element::u8)
CASE(ov::element::u16)
CASE(ov::element::u32)
CASE(ov::element::u64)
CASE(ov::element::bf16)
CASE(ov::element::f16)
CASE(ov::element::f32)
CASE(ov::element::f64)
case ov::element::Type_t::u1:
case ov::element::Type_t::i4:
case ov::element::Type_t::u4:
case ov::element::Type_t::nf4:
fill_data_random(static_cast<uint8_t*>(tensor.data()),
tensor.get_byte_size(),
range,
start_from,
resolution,
seed);
inGenData.range,
inGenData.start_from,
inGenData.resolution,
inGenData.seed);
break;
default:
OPENVINO_THROW("Unsupported element type: ", element_type);
@@ -59,6 +58,19 @@ ov::Tensor create_and_fill_tensor(const ov::element::Type element_type,
return tensor;
}
// Legacy impl for contrig repo
// todo: remove this after dependent repos clean up
ov::Tensor create_and_fill_tensor(const ov::element::Type element_type,
const ov::Shape& shape,
const uint32_t range,
const double_t start_from,
const int32_t resolution,
const int seed) {
return create_and_fill_tensor(element_type,
shape,
ov::test::utils::InputGenerateData(start_from, range, resolution, seed));
}
ov::Tensor create_and_fill_tensor_unique_sequence(const ov::element::Type element_type,
const ov::Shape& shape,
const int32_t start_from,
src/tests/test_utils/common_test_utils/src/postgres_helpers.cpp
+1 -1
View File
@@ -459,7 +459,7 @@ std::string get_hostname(void) {
#endif
}
return cHostName;
}
} // namespace PostgreSQLHelpers
void add_pair(std::map<std::string, std::string>& keyValues, const std::string& key, const std::string& value) {
size_t dPos;
src/tests/test_utils/common_test_utils/src/postgres_link.cpp
+4 -4
View File
@@ -474,7 +474,7 @@ class PostgreSQLEventListener : public ::testing::EmptyTestEventListener {
std::stringstream sstr;
sstr << "DELETE FROM test_results_temp WHERE tr_id=" << this->testId;
auto pgresult = connectionKeeper->query(sstr.str().c_str(), PGRES_COMMAND_OK);
CHECK_PGRESULT(pgresult, "Cannot remove waste results", return);
CHECK_PGRESULT(pgresult, "Cannot remove waste results", return );
this->testId = 0;
testDictionary.clear();
@@ -557,7 +557,7 @@ class PostgreSQLEventListener : public ::testing::EmptyTestEventListener {
<< ", run_count=" << test_suite.test_to_run_count() << ", total_count=" << test_suite.total_test_count()
<< " WHERE sr_id=" << this->testSuiteId;
auto pgresult = connectionKeeper->query(sstr.str().c_str(), PGRES_COMMAND_OK);
CHECK_PGRESULT(pgresult, "Cannot update test suite results", return);
CHECK_PGRESULT(pgresult, "Cannot update test suite results", return );
this->testSuiteId = 0;
if (reportingLevel == REPORT_LVL_FAST) {
@@ -641,13 +641,13 @@ class PostgreSQLEventListener : public ::testing::EmptyTestEventListener {
std::stringstream sstr;
sstr << "UPDATE runs SET end_time=NOW() WHERE run_id=" << this->testRunId << " AND end_time<NOW()";
auto pgresult = connectionKeeper->query(sstr.str().c_str(), PGRES_COMMAND_OK);
CHECK_PGRESULT(pgresult, "Cannot update run finish info", return);
CHECK_PGRESULT(pgresult, "Cannot update run finish info", return );
sstr.str("");
sstr.clear();
sstr << "UPDATE sessions SET end_time=NOW() WHERE session_id=" << this->sessionId << " AND end_time<NOW()";
pgresult = connectionKeeper->query(sstr.str().c_str(), PGRES_COMMAND_OK);
CHECK_PGRESULT(pgresult, "Cannot update session finish info", return);
CHECK_PGRESULT(pgresult, "Cannot update session finish info", return );
}
/* Prohobit creation outsize of class, need to make a Singleton */