[ IE TESTS ] Update tensor comparation function according plugin requirments (#23226)
### Details: - *Comparation function was changed to compare tensors based on element comparation* - *`std::abs(ref_value - plugin_value) <= abs_threshold + rel_threshold * ref_value`* - *`abs_threshold ` = std::max(std::numeric_limits::eps<plugin_element_type>(), std::numeric_limits::eps<ref_element_type>())* - *`ref_threshold = eps_by_expected_type()`, which is based on half `bit length of mantissa`* ### Tickets: - [CVS-133173](https://jira.devtools.intel.com/browse/CVS-133173) - [CVS-135540](https://jira.devtools.intel.com/browse/CVS-135540) --------- Co-authored-by: sbalandi <sofya.balandina@intel.com>
This commit is contained in:
Irina Efode
GitHub
parent
b520763404
commit
aebf81419b
|
|
@ -215,6 +215,12 @@ jobs:
|
|||
--gtest_filter=*smoke* \
|
||||
--gtest_output=xml:${INSTALL_TEST_DIR}/TEST-TemplateFuncTests.xml
|
||||
|
||||
- name: OV utils unit tests
|
||||
run: |
|
||||
source ${INSTALL_DIR}/setupvars.sh
|
||||
${INSTALL_TEST_DIR}/ov_util_tests --gtest_print_time=1 \
|
||||
--gtest_output=xml:${INSTALL_TEST_DIR}/TEST-ov_util_tests.xml
|
||||
|
||||
- name: OpenVINO C API tests
|
||||
if: fromJSON(inputs.affected-components).C_API.test
|
||||
run: |
|
||||
|
|
|
|||
|
|
@ -104,6 +104,7 @@ protected:
|
|||
|
||||
if (additionalConfig[ov::hint::inference_precision.name()] == ov::element::bf16) {
|
||||
selectedType = makeSelectedTypeStr(selectedType, ElementType::bf16);
|
||||
abs_threshold = 2e-2;
|
||||
} else {
|
||||
selectedType = makeSelectedTypeStr(selectedType, netPrecision);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -132,6 +132,14 @@ void ActivationLayerCPUTest::SetUp() {
|
|||
auto activation = utils::make_activation(params, netPrecision, activationType, activationShapes, constantsValue);
|
||||
activation->get_rt_info() = getCPUInfo();
|
||||
function = std::make_shared<ov::Model>(ov::NodeVector{activation}, ov::ParameterVector{params}, "Activation");
|
||||
#if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
|
||||
if (netPrecision == ov::element::f32 && outPrecision == ov::element::f32) {
|
||||
abs_threshold = 8e-4;
|
||||
}
|
||||
#endif
|
||||
if (netPrecision == ov::element::bf16 && outPrecision == ov::element::f32) {
|
||||
abs_threshold = 6e-2;
|
||||
}
|
||||
}
|
||||
|
||||
std::string ActivationLayerCPUTest::getPrimitiveType(const utils::ActivationTypes& activation_type,
|
||||
|
|
|
|||
|
|
@ -98,6 +98,7 @@ void PoolingLayerCPUTest::SetUp() {
|
|||
|
||||
std::shared_ptr<ov::Node> poolInput = params[0];
|
||||
if (isInt8) {
|
||||
abs_threshold = 2e-2;
|
||||
ov::Shape newShape(poolInput->get_output_partial_shape(0).size(), 1);
|
||||
poolInput = ov::test::utils::make_fake_quantize(poolInput, inPrc, 256, newShape);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -138,6 +138,13 @@ void ReduceCPULayerTest::SetUp() {
|
|||
}
|
||||
|
||||
function = makeNgraphFunction(netPrecision, params, reduce, "Reduce");
|
||||
|
||||
if (ov::with_cpu_x86_avx512_core_amx()) {
|
||||
if (netPrecision == ov::element::f32 && configuration.count(ov::hint::inference_precision.name()) &&
|
||||
configuration.at(ov::hint::inference_precision.name()) == ov::element::f16) {
|
||||
abs_threshold = 5e-3;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ReduceCPULayerTest::generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) {
|
||||
|
|
|
|||
|
|
@ -217,6 +217,10 @@ protected:
|
|||
}
|
||||
|
||||
function = makeNgraphFunction(netPrecision, parameters, deformable_conv, "deformable_convolution");
|
||||
|
||||
if (netPrecision == ov::element::f32) {
|
||||
abs_threshold = 5e-6;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -123,6 +123,10 @@ protected:
|
|||
}
|
||||
|
||||
function = makeNgraphFunction(inPrec, params, fq, "FakeQuantizeCPU");
|
||||
|
||||
if (inPrec == ov::element::f32) {
|
||||
abs_threshold = 1e-4;
|
||||
}
|
||||
}
|
||||
|
||||
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
|
||||
|
|
|
|||
|
|
@ -59,6 +59,9 @@ protected:
|
|||
auto axesNode = ov::op::v0::Constant::create(ov::element::i32, { axes.size() }, axes);
|
||||
auto lrn = std::make_shared<ov::op::v0::LRN>(params[0], axesNode, alpha, beta, bias, size);
|
||||
function = makeNgraphFunction(inputPrecision, params, lrn, "LRN");
|
||||
if (inputPrecision == ov::element::f32) {
|
||||
abs_threshold = 5e-3;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -146,6 +146,10 @@ protected:
|
|||
}
|
||||
}
|
||||
function = std::make_shared<Model>(rdft, inputs);
|
||||
|
||||
if (precision == ov::element::f32) {
|
||||
abs_threshold = 1e-4;
|
||||
}
|
||||
}
|
||||
|
||||
void generate_inputs(const std::vector<Shape>& targetInputStaticShapes) override {
|
||||
|
|
|
|||
|
|
@ -290,8 +290,6 @@ protected:
|
|||
};
|
||||
|
||||
TEST_P(ConvSumBroadcastTest, CompareWithRefs) {
|
||||
SKIP_IF_CURRENT_TEST_IS_DISABLED()
|
||||
|
||||
run();
|
||||
|
||||
CheckPluginRelatedResults(compiledModel, "Convolution");
|
||||
|
|
|
|||
|
|
@ -120,6 +120,8 @@ protected:
|
|||
|
||||
auto result = std::make_shared<ov::op::v0::Result>(relu3);
|
||||
function = std::make_shared<ov::Model>(result, params, "SimpleNet");
|
||||
|
||||
abs_threshold = 9e-4;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -70,6 +70,9 @@ protected:
|
|||
quantizeIntervals[3]);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(quantize)};
|
||||
function = std::make_shared<ov::Model>(results, ov::ParameterVector{param}, "FuseScaleShiftAndQuantize");
|
||||
if (inputPrecision == element::f32) {
|
||||
abs_threshold = 2e-7;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -279,6 +279,14 @@ protected:
|
|||
std::tie(postOpMgrPtr, fusedOps) = fusing_params;
|
||||
init_input_shapes({shape_params.data_shape, {{}, {{shape_params.weights_shape}}}});
|
||||
|
||||
// if dynamic quantization is enabled
|
||||
if (configuration.count(ov::hint::dynamic_quantization_group_size.name()) &&
|
||||
configuration.at(ov::hint::dynamic_quantization_group_size.name()) != 0) {
|
||||
abs_threshold = 0.1;
|
||||
} else if (!configuration.count(ov::hint::dynamic_quantization_group_size.name())) {
|
||||
abs_threshold = 5e-3;
|
||||
}
|
||||
|
||||
ElementType netType = ov::element::f32;
|
||||
inType = outType = netType;
|
||||
|
||||
|
|
|
|||
|
|
@ -229,35 +229,65 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
R"(.*smoke_LPT/GroupConvolutionQDqTransformation.CompareWithRefImpl/f32_\[1,6,24,24\]_CPU_f32_level=256_.*_precision=f32__u8___f32_\{\}__\{ 0.1 \}.*_f32_\[6,2,5,5\]__255_\[1,1,1,1\]_\{ -128 \}_\{ 127 \}__i8.*undefinedoutput_original_u8_multiplyAfter=(false|true).*)",
|
||||
R"(.*smoke_LPT/MatMulWithConstantTransformation.CompareWithRefImpl/\[(2,3,4|1,1,3,4)\]_f32_CPU_.*_shape=\[1,1,1\]_input_low=\{ 0 \}_input_high=\{ 255 \}_output_low=\{ 0, 0, 0 \}_output_high=\{ 255, 25.5, 255 \}_precision=_level=256_shape=\[1\]_input_low=\{ -128 \}_.*)",
|
||||
R"(.*smoke_LPT/ReduceSumTransformation.CompareWithRefImpl/f32_\[1,3,10,10\]_CPU_f32_level=256_shape=\[1,1,1,1\]_input_low=\{ 0 \}_input_high=\{ 255 \}_output_low=\{ 0 \}_output_high\{ 127 \}_precision=_keepDims__reduce_axis_2_3_.*)",
|
||||
R"(.*smoke_TestsDFT_1d/DFTLayerTest.Inference.*TS=.*10.4.20.32.2.*Precision=bf16_Axes=\((0|2|3|_2)\).*)",
|
||||
R"(.*smoke_TestsDFT_1d/DFTLayerTest.Inference.*TS=.*1.120.128.1.2.*Precision=bf16_Axes=\((1|2|_2)\).*)",
|
||||
R"(.*smoke_TestsDFT_1d/DFTLayerTest.Inference.*TS.*2.5.7.8.2.*Precision=bf16_Axes=\((2|_2)\)_signal_size=\(40\)_Inverse=1.*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*10.4.20.32.2.*_Precision=bf16.*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*2.5.7.8.2.*_Precision=bf16.*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*1.120.128.1.2.*_Precision=bf16.*_signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*1.120.128.1.2.*_Precision=bf16_Axes=\((0.1.2|1.2.3|2.3.1|0.2.3)\)_signal_size=\(7.11.32\)_Inverse=1.*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*1.120.128.1.2.*_Precision=bf16_Axes=\((1.2.3|2.3.1|0.2.3)\)_signal_size=\(7.11.32\)_Inverse=0.*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*1.120.128.1.2.*_Precision=bf16_Axes=\((_3._1._2|2.3.1)\)_signal_size=\(4.8.16\).*)",
|
||||
R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*10.4.20.32.2.*Precision=bf16_Axes=\(0.1.2.3\)_signal_size=\(5.2.5.2\).*)",
|
||||
R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*10.4.20.32.2.*Precision=bf16_Axes=\(0.1.2.3\)_signal_size=\(5.2.5.2\).*)",
|
||||
R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*2.5.7.8.2.*Precision=bf16.*)",
|
||||
R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*2.5.7.8.2.*Precision=bf16.*signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*TS=\{\((10.4.20.32.2|1.120.128.1.2)\)\}.*Precision=f32.*signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*1.120.128.1.2.*Precision=bf16.*signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*10.4.20.32.2.*_Precision=bf16.*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*2.5.7.8.2.*_Precision=bf16_Axes=\((_1._2|1.3|2.3|2.1)\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*2.5.7.8.2.*Precision=bf16_Axes=\(0.1\)_signal_size=\(\)_Inverse=1.*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*2.5.7.8.2.*Precision=bf16_Axes=\((0.1|2.0)\)_signal_size=\(16.8\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*2.5.7.8.2.*Precision=bf16_Axes=\(2.0\)_signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*2.5.7.8.2.*Precision=bf16_Axes=\(2.0\)_signal_size=\(5.7\)_Inverse=0.*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*2.5.7.8.2.*Precision=bf16_Axes=\(2.0\)_signal_size=\(4.10\)_Inverse=1.*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*1.120.128.1.2.*_Precision=bf16_.*_signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*1.120.128.1.2.*Precision=bf16_Axes=\((0.1|_1._2)\)_signal_size=\((4.10|5.7)\)_Inverse=1.*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*1.120.128.1.2.*Precision=bf16_Axes=\(2.1\)_signal_size=\((4.10|5.7)\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*1.120.128.1.2.*Precision=bf16_Axes=\((2.3|2.0|1.3)\)_signal_size=\(16.8\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*1.120.128.1.2.*Precision=bf16_Axes=\((2.3|2.0|1.3)\)_signal_size=\(16.8\).*)",
|
||||
#if defined(OPENVINO_ARCH_ARM)
|
||||
// Issue: 126177
|
||||
R"(.*smoke_CompareWithRefs_4D_Bitwise.*/EltwiseLayerCPUTest.*_eltwise_op_type=Bitwise.*_model_type=i32_.*)"
|
||||
#endif
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference/.*TS.*1.120.128.1.2.*Precision=bf16_Axes=\(2.1\)_signal_size=\(\).*)",
|
||||
// by calc abs_threshold with expected value
|
||||
R"(.*smoke_.*_4D.*/GatherLayerTestCPU.CompareWithRefs.*INFERENCE_PRECISION_HINT=bf16.*)",
|
||||
R"(.*smoke.*Mvn6LayerTest.Inference/.*TS.*1.10.5.7.8.*_ModelType=f32.*_Ax=\((2.3.4|-3.-2.-1)\).*)",
|
||||
R"(.*smoke.*Mvn6LayerTest.Inference/.*TS.*2.55.*_ModelType=f32.*)",
|
||||
R"(.*smoke_ConvWithZeroPointFuse/ConvWithZeroPointFuseSubgraphTest.CompareWithRefs.*)",
|
||||
R"(.*smoke_FakeQuantize/FakeQuantizeLayerTest.Inference.*TS=.*3.49.7.5.6.*LEVELS=(255|256).*netPRC=f32.*)",
|
||||
R"(.*smoke_FakeQuantize/FakeQuantizeLayerTest.Inference.*TS=.*(2.16.4.3.18|3.10.2.5.6|3.49.5.6|2.16.3.18|2.8.5.18|3.10.5.6|2.8.1.5.18).*LEVELS=255.*netPRC=f32.*)",
|
||||
R"(.*smoke_FakeQuantize.*/FakeQuantizeLayerTest.Inference.*TS=.*3.4.2.5.*LEVELS=255.*)",
|
||||
R"(.*smoke_FakeQuantizePerChannel.*/FakeQuantizeLayerTest.Inference.*TS=.*11.10.22.19.*LEVELS=(255|256).*netPRC=f32.*)",
|
||||
R"(.*smoke_MVN_5D/Mvn6LayerTest.Inference.*TS=.*3.4.2.5.*LEVELS=255.*netPRC=f16.*)",
|
||||
R"(.*smoke_Snippets_MHAINT8MatMul/MHAINT8MatMul.*)",
|
||||
R"(.*smoke_static/ConvertFqRnnToQuantizedRnn.*2.1.5.*2.1.1.*2.1.1.*)",
|
||||
R"(.*smoke_InterpolateBicubicPillow_Layout_Test/InterpolateLayerCPUTest.CompareWithRefs/ShapeCalcMode=sizes_IS=\[?.2..20.?.?\]_TS.*1.17.4.4.*2.3.10.12.*1.17.4.4.*Sizes.*4.4.*10.20.*10.4.*PARAMETER.*0.0.0.0.*0.0.1.1.*2.3.*)",
|
||||
R"(.*smoke_LoopForCommon/LoopLayerCPUTest.CompareWithRefs/.*_netType=bf16.*)",
|
||||
R"(.*smoke_FuseScaleShiftAndFakeQuantize/FuseScaleShiftAndFakeQuantizeTest.CompareWithRefs/.*Scale=\[ 30 \]_Shift=\[ 17 \]_Intervals=\[ -1 \],\[ 5 \],\[ -5 \],\[ 1 \].*)",
|
||||
R"(.*smoke_QuantizedConvolutionBatchNorm.*/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_quantize.*)",
|
||||
R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{3\}_OS=\[4,3,210\]_Min=-50_Max=0_ShapePrc=.*_OutPrc=f32_GlobalSeed=8_OperationalSeed=(0|3).*)",
|
||||
R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{3\}_OS=\[4,3,210\]_Min=-50_Max=50_ShapePrc=.*_OutPrc=f32_GlobalSeed=8_OperationalSeed=(5|3|0).*)",
|
||||
R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{3\}_OS=\[4,3,210\]_Min=-50_Max=50_ShapePrc=.*_OutPrc=f32_GlobalSeed=0_OperationalSeed=5.*)",
|
||||
R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{1\}_OS=\[500\]_Min=-50_Max=50_ShapePrc=.*_OutPrc=f32_GlobalSeed=0_OperationalSeed=5.*)",
|
||||
R"(.*smoke.*/RNNCellCPUTest.CompareWithRefs.*activations=.*relu.*INFERENCE_PRECISION_HINT=bf16.*)",
|
||||
R"(.*smoke_InterpolateBicubicPillow_Layout_Test/InterpolateLayerCPUTest.CompareWithRefs/ShapeCalcMode=sizes_IS=\[\?.2..20.\?.\?\]_TS=\(1.17.4.4\)_\(2.3.10.12\)_\(1.17.4.4\)_Sizes=\(4.4\)_\(10.20\)_\(10.4\)_PARAMETER.*P.*.1.1.*.*)",
|
||||
R"(.*smoke_InterpolateBicubicPillow_Layout_Test/InterpolateLayerCPUTest.CompareWithRefs/ShapeCalcMode=scales_IS=\[\?.2..20.\?.\?\]_TS=\(1.11.4.4\)_\(2.7.6.5\)_\(1.11.4.4\)_Scales=\(1.25.0.75\)_CONSTANT_.*PB=\(0.0.0.0\)_PE=\(0.0.1.1\).*)",
|
||||
R"(.*smoke_Conv_Sum_Broadcast_BF16/ConvSumInPlaceTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=bf16.*)",
|
||||
R"(.*smoke_Interpolate_Basic_Down_Sample_Tail/InterpolateLayerTest.Inference.*InterpolateMode=cubic_ShapeCalcMode=scales_CoordinateTransformMode=(pytorch_half_pixel|half_pixel).*netType=f32.*)",
|
||||
R"(.*smoke_basic/PermConvPermConcat.CompareWithRefs/IS=\(1.1.8.16\)_KS=\(1.5\)_OC=.*_ET=f32_targetDevice=CPU.*)",
|
||||
R"(.*smoke_basic/PermConvPermConcat.CompareWithRefs/IS=\(1.1.7.32\)_KS=\(1.3\)_OC=.*_ET=f32_targetDevice=CPU.*)",
|
||||
R"(.*smoke_BasicNegative/RangeAddSubgraphTest.*Step=-0.1_ET=f16.*)",
|
||||
R"(.*smoke_ConvertRangeSubgraphCPUTest/ConvertRangeSubgraphCPUTest.CompareWithRefs.*bf16.*)",
|
||||
R"(.*smoke_FQLayerDQBias_4D.*FQLayerDQBias.smoke_CompareWithRefs.*_TS=\(\(1.3.64.64\)_\)_layer_type=MatMul.*)",
|
||||
R"(.*smoke_Snippets_ConvMul/ConvEltwise.CompareWithRefImpl/IS\[0\]=\(1.10.16.16\)_IS\[1\]=\(1.10.16.16\)_Op=Multiply_#N=6_#S=1.*)",
|
||||
R"(.*smoke_InterpolateBicubicPillow_LayoutAlign_Test/InterpolateLayerCPUTest.CompareWithRefs/.*Sizes=\(6.8\).*)",
|
||||
R"(.*smoke_RDFT_CPU_1D/RDFTTestCPU.CompareWithRefs/prec=f32_.*TS0=\(\((106|246|245|510|1022)\)\).*)",
|
||||
R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_TS0=\(\((1022.64|24.39|126.32|510.64)\)\)_constAxes=true_axes=\(\(0.1\)\)_isInverse=false_primitive=jit_avx2.*)",
|
||||
R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_TS0=\(\((1022.64|126.32|510.64)\)\)_constAxes=true_axes=\(\(0\)\)_isInverse=false_primitive=jit_avx2.*)",
|
||||
R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_isInverse=false_primitive=jit_avx512.*)",
|
||||
R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_TS0=\(\((20.126|20.510|20.1022)\)\)_constAxes=true_axes=\(\(1\)\)_isInverse=false_primitive=jit_avx512.*)",
|
||||
R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*1.120.128.1.2.*_Precision=f32.*signal_size=\(\).*)",
|
||||
R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference.*TS=\{\(1.120.128.1.2\)\}_Precision=f32_Axes=\(2.1\)_signal_size=\(\)_Inverse=0.*)",
|
||||
R"(.*smoke_FakeQuantizeLayerCPUTest_4D_(jit|ref)/FakeQuantizeLayerCPUTest.CompareWithRefs/IS=\[\?.\?.\?.\?\]_TS=\(\(4.16.6.7\)\).*inPrec=f32.*LEVELS=255.*)",
|
||||
R"(.*smoke_FakeQuantizeLayerCPUTest_5D_(jit|ref)/FakeQuantizeLayerCPUTest.CompareWithRefs/IS=\[\?.\?.\?.\?.\?\]_TS=\(\((4|3).16.6.7.8\)\).*inPrec=f32.*LEVELS=255.*)",
|
||||
R"(.*smoke_FakeQuantizeLayerCPUTest_Decompos/FakeQuantizeLayerCPUTest.CompareWithRefs/IS.*\(\((4.5.6.7|1.1.6.7|1.1.6.1|1.5.1.6)\)\)_inPrec=f32.*LEVELS=255.*)",
|
||||
R"(.*smoke_CompareWithRefs/LRNLayerCPUTest.CompareWithRefs/f32_IS.*axes=\(1.2.3\).*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(9.16.32.126\)\)_constAxes=true_axes=\(\((0.1.2.3|3.1|_2._1)\)\).*isInverse=false.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(1.192.36.64\)\)_constAxes=true_axes=\(\((0.1.2.3|3.2|_2._1|0.1|1)\)\).*isInverse=false.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(1.192.36.64\)\)_constAxes=true_axes=\(\((0|_2._1|0.1.2.3)\)_.*isInverse=false.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=.*_TS0=\(\(1.192.36.64\)_.*constAxes=false.*isInverse=false.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(46.10.128.65\)\)_constAxes=true_axes=\(\((1.0|0.1.2.3|3.1|_2._1)\)\).*isInverse=false.*primitive=jit_avx512.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(10.46.128.65\)\)_constAxes=true_axes=\(\((0.1|1.2)\)\).*isInverse=false.*primitive=jit_avx512.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\?.192.36.64\]_.*_axes=\(\((0|_2._1|_1|1)\)_.*isInverse=false.*)",
|
||||
R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\((1.120.64.64|1.120.96.96|\?.\?.\?.\?|1.192.\?.\?|1..2.\?.\?.1..100)\)\).*isInverse=false.*)",
|
||||
R"(.*smoke_RDFT_2d/RDFTLayerTest.Inference/IS=\(100.16\)_modelType=f32_Axes=\((0.1|_2._1|1.0)\)_SignalSize=\(\).*)",
|
||||
};
|
||||
|
||||
#if defined(OPENVINO_ARCH_X86)
|
||||
|
|
@ -292,6 +322,15 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
retVector.emplace_back(R"(.*Extension.OnnxModelWithExtensionFromDSO.*)");
|
||||
retVector.emplace_back(R"(.*ONNXQuantizedModels/QuantizedModelsTests.MaxPool.*)");
|
||||
retVector.emplace_back(R"(.*ONNXQuantizedModels/QuantizedModelsTests.Convolution.*)");
|
||||
// by calc abs_threshold with expected value
|
||||
retVector.emplace_back(
|
||||
R"(.*smoke_Interpolate_Basic_Down_Sample_Tail/InterpolateLayerTest.Inference.*InterpolateMode=(linear|linear_onnx)_ShapeCalcMode=scales_CoordinateTransformMode=half_pixel.*PE=\(0.0.0.0\).*netType=f32.*)");
|
||||
retVector.emplace_back(R"(.*smoke_ConversionLayerTest/ConversionLayerTest.Inference/conversionOpType=Convert_.*_inputPRC=f16_targetPRC=(u8|i8).*)");
|
||||
retVector.emplace_back(R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference/.*TS=\{\((1.16.5.8|2.19.5.10)\)\}_ModelType=f32_.*_Ax=\(0.1.2.3\)_NormVariance=FALSE.*)");
|
||||
retVector.emplace_back(R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference/.*TS=\{\(2.19.5.10\)\}_ModelType=f32_.*_Ax=\(1\).*)");
|
||||
retVector.emplace_back(R"(.*smoke_LogSoftmax4D/LogSoftmaxLayerTest.Inference/.*TS=\{\(2.3.4.5\)\}_modelType=f32_axis=(-4|0).*)");
|
||||
retVector.emplace_back(R"(.*smoke_Interpolate_Basic/InterpolateLayerTest.Inference/.*InterpolateMode=cubic_ShapeCalcMode=sizes_CoordinateTransformMode=tf_half_pixel.*PB=\(0.0.0.0\)_PE=\(0.0.1.1\)_.*netType=f32.*)");
|
||||
retVector.emplace_back(R"(.*smoke_CompareWithRefs_4D_Bitwise.*/EltwiseLayerCPUTest.*_eltwise_op_type=Bitwise.*_model_type=i32_.*)");
|
||||
}
|
||||
// invalid test: checks u8 precision for runtime graph, while it should be f32
|
||||
retVector.emplace_back(R"(smoke_NegativeQuantizedMatMulMultiplyFusion.*)");
|
||||
|
|
@ -323,12 +362,13 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
retVector.emplace_back(R"(.*fma.*EltwiseLayerCPUTest.*)");
|
||||
retVector.emplace_back(R"(.*int_jit.*EltwiseLayerCPUTest.*)");
|
||||
retVector.emplace_back(R"(.*dyn.*EltwiseChainTest.*)");
|
||||
|
||||
retVector.emplace_back(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=i8.*Conversion=i8.*)");
|
||||
retVector.emplace_back(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=u8.*Conversion=i8.*)");
|
||||
retVector.emplace_back(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=i16.*Conversion=i8.*)");
|
||||
retVector.emplace_back(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=u16.*Conversion=i8.*)");
|
||||
retVector.emplace_back(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=i32.*Conversion=i8.*)");
|
||||
// by calc abs_threshold with expected value
|
||||
retVector.emplace_back(R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.*_eltwise_op_type=Div_.*_model_type=i32_.*)");
|
||||
#endif
|
||||
|
||||
#if !defined(OPENVINO_ARCH_X86_64)
|
||||
|
|
@ -353,10 +393,12 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
retVector.emplace_back(R"(.*smoke_LPT/FuseDequantizeToFakeQuantizeTransformation.CompareWithRefImpl/CPU_f32_0_undefined_\[\]_f32__\{\}_\{\}__\{ 0.01, 0.1, 1 \}_f32_\[1,3\]_1_1_.*)");
|
||||
retVector.emplace_back(R"(.*smoke_QuantizedConvolutionBatchNorm/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_quantize_.*)");
|
||||
retVector.emplace_back(R"(.*smoke_QuantizedConvolutionBatchNorm/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_backprop_quantize_type=(quantize_dequantize_intervals|compressed_weights_intervals).*)");
|
||||
retVector.emplace_back(R"(.*smoke_FQLayerDQBias_4D_static/FQLayerDQBias.smoke_CompareWithRefs/IS=\(\[\]\)_TS=\(\(1.3.64.64\)_\)_layer_type=MatMul.*)");
|
||||
retVector.emplace_back(R"(.*smoke_FQLayerDQBias_4D_dynamic/FQLayerDQBias.smoke_CompareWithRefs/IS=\(\[\?.3.\?.\?\]\)_TS=\(\(1.3.64.64\)_\)_layer_type=MatMul.*)");
|
||||
retVector.emplace_back(R"(.*smoke_LPT/MatMulTransformation.CompareWithRefImpl/f32_CPU_\[(1|8|1,1,1),4,12,2\]_level=256_shape=\[\]_input_low=\{ (0|-12.8) \}_input_high=\{ (25.5|12.7) \}_output_low=\{ (0|-12.8) \}_output_high\{ (25.5|12.7) \}_.*)");
|
||||
retVector.emplace_back(R"(.*smoke_LPT/MatMulTransformation.CompareWithRefImpl/f32_CPU_\[(1|8|1,1,1),4,12,2\]_level=256_shape=\[\]_input_low=\{ (0|-12.8) \}_input_high=\{ (25.5|12.7) \}_output_low=\{ (0|-12.8) \}_output_high\{ (25.5|12.7) \}_.*)");
|
||||
retVector.emplace_back(
|
||||
R"(.*smoke_MatMulCompressedWeights_corner_cases_basic/MatmulWeightsDecompression.CompareWithRefs/data_shape=\[\?.\?.\?\]_\(\[1,1,4096\]\)_weights_shape=\[4096,4096\]_group_size=128_weights_precision=nf4_decompression_precision=f16_transpose_weights=0_decompression_subtract=full_reshape_on_decompression=1_config=\(\).*)");
|
||||
retVector.emplace_back(R"(.*smoke_RDFT_CPU_1D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(126\)\)_constAxes=true_axes=\(\(0\)\)_isInverse=false.*)");
|
||||
retVector.emplace_back(R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(16.38\)\)_constAxes=true_axes=\(\(0.1\)\)_isInverse=false.*)");
|
||||
#endif
|
||||
if (!ov::with_cpu_x86_avx512_core()) {
|
||||
// on platforms which do not support bfloat16, we are disabling bf16 tests since there are no bf16 primitives,
|
||||
|
|
@ -415,6 +457,14 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
retVector.emplace_back(R"(smoke_JIT_AVX512_DW_GroupConv/GroupConvolutionLayerCPUTest.*inFmts=nCdhw16c.*INFERENCE_PRECISION_HINT=bf16.*)");
|
||||
// Issue: 131475
|
||||
retVector.emplace_back(R"(smoke_ExportImportTest/ExportOptimalNumStreams.OptimalNumStreams/.*)");
|
||||
// by calc abs_threshold with expected value
|
||||
retVector.emplace_back(R"(.*smoke_GatherCompressedWeights_basic/GatherWeightsDecompression.CompareWithRefs.*INFERENCE_PRECISION_HINT.*bf16.*)");
|
||||
retVector.emplace_back(R"(.*smoke_Interaction/IntertactionCPUTest.CompareWithRefs.*Prc=i32.*)");
|
||||
retVector.emplace_back(R"(.*smoke_MatMulCompressedWeights_(amx|corner_cases_amx)/MatmulWeightsDecompression.CompareWithRefs.*INFERENCE_PRECISION_HINT.*bf16.*)");
|
||||
retVector.emplace_back(R"(.*smoke_AutoBatching_CPU/AutoBatching_Test.*)");
|
||||
retVector.emplace_back(R"(.*smoke_Snippets_EnforcePrecision_bf16/EnforcePrecisionTest.*)");
|
||||
retVector.emplace_back(R"(.*smoke_Snippets_MHABF16_4D/MHA.CompareWithRefImpl/.*\[1.58.16.34\]_IS\[1\]=\[1.58.16.34\]_IS\[2\]=\[1.1.1.58\]_IS\[3\]=\[1.58.16.34\].*)");
|
||||
retVector.emplace_back(R"(.*smoke_Snippets_MHAWOTransposeBF16_(3|4)D/MHAWOTranspose.*)");
|
||||
}
|
||||
|
||||
if (ov::with_cpu_x86_avx512_core_fp16()) {
|
||||
|
|
|
|||
|
|
@ -131,5 +131,85 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
R"(.*smoke_MatMul_BothTranspose/MatMulLayerTest.Inference/IS=\(\[\]_\[\]\)_TS=\{\(5\)_\(5\)\}_transpose_a=1_transpose_b=1_secondary_input_type=(CONSTANT|PARAMETER)_modelType=(f16|f32).*)",
|
||||
R"(.*smoke_dynamic_conv_reshape_fullyconnected/ConvReshapeFullyConnectedDynamicGPUTestDynamic.Inference/IS=\[\?\.64\.1\.\?\.\?\]_\[1\.64\.1\.1\.1\]_model_type=f16.*)",
|
||||
R"(.*smoke_empty_tensor/EmptyTensorDynamicGPUTest.Inference/IS=\[\?\]_\[30\]_\[40\]_\[50\]_\[10\]_\[7\]_\[\?.\?\]_\[1.0\]_\[1.8\]_\[1.0\]_\[1.3\]_\[1.20\]_NetType=i32.*)",
|
||||
// by calc abs_threshold with expected value
|
||||
R"(.*smoke_Convolution2D_ExplicitPadding/ActivatiConvolutionLayerTestonLayerTest.Inference.*netPRC=f16.*)",
|
||||
R"(.*smoke_Convolution2D_AutoPadValid/ConvolutionLayerTest.Inference.*netPRC=f16.*)",
|
||||
R"(.*smoke_Convolution3D_Basic1/ConvolutionLayerTest.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_ExplicitPadding/ConvolutionBackpropDataLayerTest.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_AutoPadValid/ConvolutionBackpropDataLayerTest.*K\((3.5|3.3)\).*netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_ExplicitPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.*K\((3.5|3.3)\).*netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*K\((3.5|3.3)\).*PE\(1.1\).*netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*TS=\{\(1.32.10.10\).*K\((3.5|3.3)\).*PE\(0.0\).*netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*TS=\{\((1.3.30.30|1.16.10.10)\).*K\(3.5\).*PE\(0.0\).*netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData2D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*TS=\{\((1.3.30.30|1.16.10.10)\).*K\(3.3\).*PE\(0.0\).*O=(1|5|16)_AP=explicit_netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData3D_ExplicitPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*TS=\{\((1.16.5.5.5|1.32.5.5.5)\)\}.*O=(1|5)_AP=valid_netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData3D_ExplicitPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference.*O=16_AP=valid_netPRC=f16.*)",
|
||||
R"(.*moke_ConvolutionBackpropData3D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*TS=\{\((1.16.5.5.5|1.32.5.5.5)\)\}.*O=(1|5)_AP=valid_netPRC=f16.*)",
|
||||
R"(.*moke_ConvolutionBackpropData3D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference.*O=16_AP=valid_netPRC=f16.*)",
|
||||
R"(.*smoke_DeformableConvolution2D_ExplicitPadding/DeformableConvolutionLayerTest.Inference.*O=(1|5)_AP=explicit_BI_PAD=0_MODULATION=1_netPRC=f16.*)",
|
||||
R"(.*smoke_DeformableConvolution2D_AutoPadValid/DeformableConvolutionLayerTest.Inference.*O=(1|5)_AP=valid_BI_PAD=0_MODULATION=1_netPRC=f16.*)",
|
||||
R"(.*smoke_DeformableConvolution2D_DeformableGroups_ExplicitPadding/DeformableConvolutionLayerTest.Inference.*O=(1|5)_AP=explicit_BI_PAD=(0|1)_MODULATION=(0|1)_netPRC=f16.*)",
|
||||
R"(.*smoke_DeformableConvolution2D_SingleTestCase/DeformableConvolutionLayerTest.Inference.*O=(1|5)_AP=explicit_BI_PAD=(0|1)_MODULATION=(0|1)_netPRC=f16.*)",
|
||||
R"(.*smoke_DeformableConvolution2D_MultipleGroup.*/DeformableConvolutionLayerTest.Inference.*O=(1|5)_AP=explicit_BI_PAD=(0|1)_MODULATION=(0|1)_netPRC=f16.*)",
|
||||
R"(.*smoke_DFT_5d/DFTLayerTest.Inference/IS=\(\[\]\)_TS=\{\(10.4.8.2.2\)\}_Precision=f32_Axes=\(0.1.2.3\)_signal_size=\(\)_Inverse=0.*)",
|
||||
R"(.*smoke_DFT_6d/DFTLayerTest.Inference/IS=\(\[\]\)_TS=\{\(10.4.8.2.5.2\)\}_Precision=f32_Axes=\(0.1.2.3.4\)_signal_.*_Inverse=0.*)",
|
||||
R"(.*smoke_ConvolutionLayerGPUTest_ExplicitPad1D/ConvolutionLayerGPUTestDynamic.*netPRC=f16.*)",
|
||||
R"(.*smoke_MVN_5D/Mvn6LayerTest.Inference/.*ModelType=f16.*_Ax=\(2.3.4\).*)",
|
||||
R"(.*smoke_MVN_5D/Mvn6LayerTest.Inference/.*ModelType=f32.*_Ax=\(2.3.4\).*NormVariance=FALSE.*)",
|
||||
R"(.*smoke_MVN_4D/Mvn6LayerTest.Inference/.*TS=\{\(1.10.5.17\)\}.*_ModelType=f16.*Ax=\(2.3\).*)",
|
||||
R"(.*smoke_MVN_4D/Mvn6LayerTest.Inference/.*TS=\{\(1.3.8.9\)\}.*_ModelType=f16.*Ax=\((2.3|1.2.3)\).*)",
|
||||
R"(.*smoke_MVN_3D/Mvn6LayerTest.Inference/IS=\(\[\]\)_TS=\{\(1.32.17\)\}_ModelType=f16_AxType=(i64|i32)_Ax=\((1.2|2)\).*)",
|
||||
R"(.*smoke_MVN_2D/Mvn6LayerTest.Inference.*TS=\{\(2.55\)\}_ModelType=f32_.*)",
|
||||
|
||||
|
||||
R"(.*smoke_Decomposition_6D/Mvn6LayerTest.Inference.*ModelType=(f16|f32).*Ax=\(0.1.2\).*)",
|
||||
R"(.*smoke_Decomposition_6D/Mvn6LayerTest.Inference.*ModelType=(f16|f32).*Ax=\(0.1.5\).*)",
|
||||
|
||||
|
||||
R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference.*ModelType=f16.*Ax=\(1\).*)",
|
||||
R"(.*smoke_CTCLoss_Set2/CTCLossLayerTest.Inference/.*_LL=\(6.5.6\)_A=\(2.1.5.3.2.6\)\(3.3.3.3.3.3\)\(6.5.6.5.6.5\)_.*_BI=7_.*_CMR=1_U=1_PF=f16.*)",
|
||||
R"(.*smoke_RMSNormDecomposition_basic/RMSNormDecomposition.Inference/.*precision=f32.*)",
|
||||
R"(.*smoke_RMSNormDecomposition_basic/RMSNormDecomposition.Inference/IS=\(\[\]_\)_TS=\(\(1.2.6\)\)_input_precision=f16.*)",
|
||||
R"(.*smoke_RMSNormDecomposition_basic/RMSNormDecomposition.Inference_cached/IS=\(\[\?.\?.96\]_\)_TS=\(\(1.4.96\)\)_input_precision=f32.*)",
|
||||
R"(.*smoke_RMSNormDecomposition_basic/RMSNormDecomposition.Inference_cached/IS=\(\[\?.\?.\?\]_\)_TS=\(\(1.2.16\)\)_input_precision=f32.*)",
|
||||
R"(.*smoke_RMSNormDecomposition_basic/RMSNormDecomposition.Inference_cached/IS=\(\[\]_\)_TS=\(\(1.2.6\)\)_input_precision=(f16|f32).*)",
|
||||
R"(.*smoke_RMSNormDecomposition_basic/RMSNormDecomposition.Inference_cached/IS=\(\[\]_\)_TS=\(\(1.2.18\)\)_input_precision=f32.*)",
|
||||
R"(.*smoke_MM_Static_OneDNN/MatMulLayerGPUTest.Inference.*input_type=PARAMETER_netPRC=f16.*)",
|
||||
R"(.*smoke_Decomposition_3D/Mvn6LayerTest.Inference/.*TS=\{\(1.32.17\)\}_ModelType=f16_AxType=.*_Ax=\(0.1.2\).*)",
|
||||
R"(.*moke_Decomposition_3D/Mvn6LayerTest.Inference.*TS=\{\(1.37.9\)\}_ModelType=f16_AxType=.*_Ax=\(1\).*)",
|
||||
R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference/.*TS=\{\(2.19.5.10\)\}_ModelType=f32_AxType=(i32|i64)_Ax=\((0.3|3)\)_NormVariance=FALSE.*)",
|
||||
R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference/.*TS=\{\(2.19.5.10\)\}_ModelType=f16_AxType=(i32|i64)_Ax=\(0.3\)_NormVariance=TRUE.*)",
|
||||
R"(.*smoke_Convolution2D_ExplicitPadding/ConvolutionLayerTest.*netPRC=f16.*)",
|
||||
R"(.*smoke_SwiGLUFusion_basic/SwiGLUFusion.Inference.*/IS=\(\[\?.\?.96\]_\)_.*_input_precision=f16.*)",
|
||||
R"(.*smoke_dynamic_reduce_deconv_concat/ReduceDeconvConcatDynamicGPUTest.Inference/IS=\[1.32.64.\?.\?\]_\[1.32.64.64.64\]_\[1.8.128.\?.\?.4\]_\[1.8.128.128.128.4\]_model_type=f16.*)",
|
||||
R"(.*smoke_GPU_Dynamic/KVCacheTest.Inference.*_precision=f16.*)",
|
||||
R"(.*smoke_dynamic_shapeof_activation_sqrt/shapeofActivationDynamicGPUTest.Inference/IS=\[\?.\?.1.64\]_\[1.3136.1.64\]_\[1.49.1.64\]_\[2.49.1.64\]_NetType=f16_targetDevice=GPU_activatioinType=23_inShape=\(\)_constantValue=\(\).*)",
|
||||
R"(.*smoke_GroupConvolutionLayerGPUTest_dynamic2D.*/GroupConvolutionLayerGPUTestDynamic.Inference/.*_netPRC=f16.*)",
|
||||
R"(.*smoke_(DFT|IDFT|IRDFT)_GPU_4D/DFTLayerGPUTest.CompareWithRefs.*)",
|
||||
R"(.*smoke_RDFT_GPU_4D/DFTLayerGPUTest.CompareWithRefs/prec=(f32|f16)_IS0=\[\?.\?.\?.\?\]_TS0=\(\(1.192.36.64\)\)_IS1=\[\?\]_TS1=\(\(1\)\)_IS2=\[\?\]_TS2=\(\(1\)\).*)",
|
||||
R"(.*smoke_ConvolutionLayerGPUTest_dynamic.*ConvolutionLayerGPUTestDynamic.*netPRC=f16.*)",
|
||||
R"(.*smoke_NoReshape/SplitConvConcat.CompareWithRefImpl/IS=\(1.6.40.40\)_ET=f16_.*)",
|
||||
R"(.*smoke_basic/PermConvPermConcat.CompareWithRefs/IS=\(1.1.7.32\)_KS=\(1.3\)_OC=(32|64)_ET=f32.*)",
|
||||
R"(.*smoke_basic/PermConvPermConcat.CompareWithRefs/IS=\(1.1.8.16\)_KS=\(1.5\)_OC=(32|64)_ET=f32.*)",
|
||||
R"(.*smoke_MAX_and_AVGPool_ValidPad/PoolingLayerTest.Inference.*_AvgPool_ExcludePad=0_K\(3.5\).*modelType=f16.*)",
|
||||
R"(.*smoke_MatMul_NoTranspose/MatMulLayerTest.Inference/.*_TS=\{\(1.4.5.6\)_\(1.4.6.4\)\}_.*_input_type=CONSTANT_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_NoTranspose/MatMulLayerTest.Inference/.*_TS=\{\(4.5.6\)_\(6.3\)\}_.*_input_type=PARAMETER_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_NoTranspose/MatMulLayerTest.Inference/.*_TS=\{\(9.9.9\)_\(9.9\)\}_.*_input_type=PARAMETER_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_FirstTranspose/MatMulLayerTest.Inference/.*_TS=\{\(100.65\)_\(100.73\)\}_.*_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_SecondTranspose/MatMulLayerTest.Inference/.*_TS=\{\(1.16.128\)_\(1.64.128\)\}_.*_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_SecondTranspose/MatMulLayerTest.Inference/.*_TS=\{\(1.64.80\)_\(1.77.80\)\}_.*_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_SecondTranspose/MatMulLayerTest.Inference/.*_TS=\{\(65.100\)_\(73.100\)\}_.*_modelType=f16_.*)",
|
||||
R"(.*smoke_MatMul_BothTranspose/MatMulLayerTest.Inference/.*_TS=\{\(100.65\)_\(73.100\)\}_.*_modelType=f16_.*)",
|
||||
R"(.*smoke_Convolution2D_ExplicitPadding/ConvolutionLayerTest.Inference/.*_TS=\{\(1.3.30.30\)\}_K\(3.5\)_.*_O=5_AP=explicit_netPRC=f16.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData3D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*_TS=\{\(1.3.10.10.10\)\}_.*_PE\((0.0.0|1.1.1)\)_D=\(1.1.1\)_OP=\((1.1.1|2.2.2)\)_O=16_AP=explicit_netPRC=f16_.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData3D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*_TS=\{\(1.32.5.5.5\)\}_.*_netPRC=f16_.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData3D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*_TS=\{\(1.16.5.5.5\)\}_.*_netPRC=f16_.*)",
|
||||
R"(.*smoke_ConvolutionBackpropData3D_AutoPadding_OutputPaddingDefined/ConvolutionBackpropDataLayerTest.Inference/.*_TS=\{\(1.16.5.5.5\)\}_.*_netPRC=f16_.*)",
|
||||
R"(.*smoke_PSROIPooling_average/PSROIPoolingLayerTest.Inference/IS=\(3.8.16.16\)_coord_shape=\(10.5\)_out_dim=2_group_size=2_scale=(0.625|1)_bins_x=1_bins_y=1_mode=average_modelType=f16.*)",
|
||||
R"(.*smoke_RDFT_5d_last_axis/RDFTLayerTest.Inference/IS=\(10.4.8.2.5\)_modelType=f32_Axes=\(0.1.2.3.4\)_SignalSize=\(\).*)",
|
||||
#if defined(_WIN32)
|
||||
R"(.*smoke_RemoteTensor/OVRemoteTensorBatched_Test.NV12toBGR_buffer/(num_batch_4|num_batch_2).*)",
|
||||
R"(.*smoke_Check/ConstantResultSubgraphTest.Inference/SubgraphType=SINGLE_COMPONENT_IS=\[1,3,10,10\]_IT=i16_Device=GPU.*)",
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -123,7 +123,9 @@ std::vector<std::string> disabledTestPatterns() {
|
|||
R"(.*ReferenceInverse.*bf16.*[4,4].*)",
|
||||
R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.Inference/IS=\(\[\]_\)_TS=.*(4.4.200|1.10.200|10.200|2.200|1.10.100|4.4.16).*_eltwise_op_type=Mod_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f32_InType=undefined_OutType=undefined.*)",
|
||||
R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.Inference/IS=.*_TS=\(\(2.17.5.1\)_\(1.17.1.4\)_\)_eltwise_op_type=Mod_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f16_InType=undefined_OutType=undefined_.*)",
|
||||
R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.Inference/IS=.*_TS=.*(2.200|10.200|1.10.100|4.4.16|1.2.4|1.4.4|1.4.4.1).*eltwise_op_type=Mod_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f16_InType=undefined_OutType=undefined.*)"};
|
||||
R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.Inference/IS=.*_TS=.*(2.200|10.200|1.10.100|4.4.16|1.2.4|1.4.4|1.4.4.1).*eltwise_op_type=Mod_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f16_InType=undefined_OutType=undefined.*)",
|
||||
R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.Inference/IS=.*_TS=.*2.*eltwise_op_type=Pow_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f32_InType=undefined_OutType=undefined.*)",
|
||||
};
|
||||
#ifdef _WIN32
|
||||
// CVS-63989
|
||||
retVector.emplace_back(R"(.*ReferenceSigmoidLayerTest.*u64.*)");
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ namespace test {
|
|||
TEST_P(InterpolateLayerTest, Inference) {
|
||||
run();
|
||||
}
|
||||
|
||||
TEST_P(Interpolate11LayerTest, Inference) {
|
||||
run();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,6 +97,10 @@ void AddRollConst::SetUp() {
|
|||
if (!configuration.count("SNIPPETS_MODE")) {
|
||||
configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"});
|
||||
}
|
||||
|
||||
if (type == ov::element::bf16) {
|
||||
abs_threshold = 3e-2;
|
||||
}
|
||||
}
|
||||
|
||||
std::string AddPair::getTestCaseName(testing::TestParamInfo<ov::test::snippets::AddParamsPair> obj) {
|
||||
|
|
|
|||
|
|
@ -101,6 +101,10 @@ void ConvertInput::SetUp() {
|
|||
if (!configuration.count("SNIPPETS_MODE")) {
|
||||
configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"});
|
||||
}
|
||||
|
||||
if (types.first[0] == ov::element::f32 && types.second[0] == ov::element::bf16) {
|
||||
abs_threshold = 3e-2;
|
||||
}
|
||||
}
|
||||
|
||||
parameters ConvertInput::generate_params_random() const {
|
||||
|
|
@ -145,6 +149,10 @@ void ConvertOutput::SetUp() {
|
|||
if (!configuration.count("SNIPPETS_MODE")) {
|
||||
configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"});
|
||||
}
|
||||
|
||||
if (types.first[0] == ov::element::bf16 && types.second[0] == ov::element::f32) {
|
||||
abs_threshold = 4e-2;
|
||||
}
|
||||
}
|
||||
|
||||
void ConvertStub::SetUp() {
|
||||
|
|
|
|||
|
|
@ -78,6 +78,7 @@ TEST_P(MatMul, CompareWithRefImpl) {
|
|||
|
||||
TEST_P(MatMulFQ, CompareWithRefImpl) {
|
||||
SKIP_IF_CURRENT_TEST_IS_DISABLED()
|
||||
abs_threshold = 0.5;
|
||||
run();
|
||||
validateNumSubgraphs();
|
||||
}
|
||||
|
|
@ -102,6 +103,7 @@ TEST_P(MatMulsQuantized, CompareWithRefImpl) {
|
|||
|
||||
TEST_P(MatMulsQuantizedSoftmax, CompareWithRefImpl) {
|
||||
SKIP_IF_CURRENT_TEST_IS_DISABLED()
|
||||
abs_threshold = 4e-6;
|
||||
run();
|
||||
validateNumSubgraphs();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -231,6 +231,7 @@ TEST_P(MHAQuantMatMul0, CompareWithRefImpl) {
|
|||
|
||||
TEST_P(MHAFQAfterMatMul, CompareWithRefImpl) {
|
||||
SKIP_IF_CURRENT_TEST_IS_DISABLED()
|
||||
abs_threshold = 4e-6;
|
||||
run();
|
||||
validateNumSubgraphs();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,6 +57,7 @@ void TransposeMatMulFQ::SetUp() {
|
|||
if (!configuration.count("SNIPPETS_MODE")) {
|
||||
configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"});
|
||||
}
|
||||
abs_threshold = 5e-6;
|
||||
}
|
||||
|
||||
void ExplicitTransposeMatMul::SetUp() {
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ void TwoInputsAndOutputs::SetUp() {
|
|||
if (!configuration.count("SNIPPETS_MODE")) {
|
||||
configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"});
|
||||
}
|
||||
abs_threshold = 5e-7;
|
||||
}
|
||||
|
||||
void TwoInputsAndOutputsWithReversedOutputs::SetUp() {
|
||||
|
|
@ -50,6 +51,7 @@ void TwoInputsAndOutputsWithReversedOutputs::SetUp() {
|
|||
if (!configuration.count("SNIPPETS_MODE")) {
|
||||
configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"});
|
||||
}
|
||||
abs_threshold = 5e-7;
|
||||
}
|
||||
|
||||
TEST_P(TwoInputsAndOutputs, CompareWithRefImpl) {
|
||||
|
|
|
|||
|
|
@ -220,6 +220,16 @@ void ActivationLayerTest::SetUp() {
|
|||
auto result = std::make_shared<ov::op::v0::Result>(activation);
|
||||
|
||||
function = std::make_shared<ov::Model>(result, ov::ParameterVector{param}, "Activation");
|
||||
|
||||
#if defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_ARM)
|
||||
abs_threshold = 9e-4;
|
||||
#else
|
||||
if (model_type == ov::element::f32) {
|
||||
abs_threshold = 1e-5;
|
||||
} else if (model_type == ov::element::f16) {
|
||||
abs_threshold = 5e-4;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void ActivationParamLayerTest::SetUp() {
|
||||
|
|
|
|||
|
|
@ -87,6 +87,10 @@ void CTCLossLayerTest::SetUp() {
|
|||
|
||||
auto result = std::make_shared<ov::op::v0::Result>(ctc_loss);
|
||||
function = std::make_shared<ov::Model>(result, ov::ParameterVector{param}, "CTCLoss");
|
||||
|
||||
if (fp_type == ov::element::f16) {
|
||||
abs_threshold = 9e-3;
|
||||
}
|
||||
}
|
||||
} // namespace test
|
||||
} // namespace ov
|
||||
|
|
|
|||
|
|
@ -103,6 +103,12 @@ void DFTLayerTest::SetUp() {
|
|||
|
||||
auto result = std::make_shared<ov::op::v0::Result>(dft);
|
||||
function = std::make_shared<ov::Model>(result, ov::ParameterVector{param}, "DFT");
|
||||
|
||||
if (model_type == ov::element::f32) {
|
||||
abs_threshold = 8e-5;
|
||||
} else if (model_type == ov::element::bf16) {
|
||||
abs_threshold = 5e-7;
|
||||
}
|
||||
}
|
||||
} // namespace test
|
||||
} // namespace ov
|
||||
|
|
|
|||
|
|
@ -56,6 +56,10 @@ void GridSampleLayerTest::SetUp() {
|
|||
function = std::make_shared<ov::Model>(std::make_shared<ov::op::v0::Result>(gridSample),
|
||||
ov::ParameterVector{data, grid},
|
||||
"GridSample");
|
||||
|
||||
if (model_type == ov::element::f16 && grid_type == ov::element::f32) {
|
||||
abs_threshold = 2e-2;
|
||||
}
|
||||
}
|
||||
} // namespace test
|
||||
} // namespace ov
|
||||
|
|
|
|||
|
|
@ -111,6 +111,10 @@ void InterpolateLayerTest::SetUp() {
|
|||
auto result = std::make_shared<ov::op::v0::Result>(interpolate);
|
||||
|
||||
function = std::make_shared<ov::Model>(result, ov::ParameterVector{param}, "interpolate");
|
||||
|
||||
if (model_type == ov::element::f32) {
|
||||
abs_threshold = 1e-6;
|
||||
}
|
||||
}
|
||||
|
||||
std::string Interpolate11LayerTest::getTestCaseName(const testing::TestParamInfo<InterpolateLayerTestParams>& obj) {
|
||||
|
|
|
|||
|
|
@ -71,6 +71,10 @@ void Mvn1LayerTest::SetUp() {
|
|||
mvn = std::make_shared<ov::op::v0::MVN>(param, axes, normalize_variance, eps);
|
||||
}
|
||||
|
||||
if (model_type == ov::element::f32) {
|
||||
abs_threshold = 5e-7;
|
||||
}
|
||||
|
||||
auto result = std::make_shared<ov::op::v0::Result>(mvn);
|
||||
function = std::make_shared<ov::Model>(result, ov::ParameterVector{param}, "MVN1");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,6 +58,10 @@ void PSROIPoolingLayerTest::SetUp() {
|
|||
spatial_bins_y,
|
||||
mode);
|
||||
function = std::make_shared<ov::Model>(psroi_pooling->outputs(), params, "psroi_pooling");
|
||||
|
||||
if (model_type == ov::element::f16) {
|
||||
abs_threshold = 8e-3;
|
||||
}
|
||||
}
|
||||
} // namespace test
|
||||
} // namespace ov
|
||||
|
|
|
|||
|
|
@ -87,6 +87,10 @@ void RDFTLayerTest::SetUp() {
|
|||
auto param = std::make_shared<ov::op::v0::Parameter>(model_type, ov::Shape(input_shape));
|
||||
auto rdft = ov::test::utils::make_rdft(param, axes, signal_size, op_type);
|
||||
function = std::make_shared<ov::Model>(rdft->outputs(), ov::ParameterVector{param}, "RDFT");
|
||||
|
||||
if (model_type == ov::element::f32) {
|
||||
abs_threshold = 1e-4;
|
||||
}
|
||||
}
|
||||
} // namespace test
|
||||
} // namespace ov
|
||||
|
|
@ -105,6 +105,10 @@ void QuantizedMatMulConstTransposesExtractionTest::SetUp() {
|
|||
} else {
|
||||
ASSERT_TRUE(functions_equal);
|
||||
}
|
||||
|
||||
if (type == element::f32) {
|
||||
abs_threshold = 2e-7;
|
||||
}
|
||||
}
|
||||
|
||||
void QuantizedMatMulConstTransposesExtractionTest::TearDown() {
|
||||
|
|
|
|||
|
|
@ -115,6 +115,9 @@ void QuantizedMatMulMultiplyFusion::SetUp() {
|
|||
} else {
|
||||
ASSERT_TRUE(functions_equal);
|
||||
}
|
||||
if (precision == element::f32) {
|
||||
abs_threshold = 4e-7;
|
||||
}
|
||||
}
|
||||
|
||||
void QuantizedMatMulMultiplyFusion::TearDown() {
|
||||
|
|
|
|||
|
|
@ -52,6 +52,27 @@ struct InputGenerateData {
|
|||
};
|
||||
};
|
||||
|
||||
// Pre-defaned eps based on mantissa bit depth
|
||||
inline double get_eps_by_ov_type(const ov::element::Type& elem_type) {
|
||||
if (elem_type.is_integral()) {
|
||||
return 0.f;
|
||||
}
|
||||
switch (elem_type) {
|
||||
case ov::element::f64:
|
||||
return 1e-8;
|
||||
case ov::element::f32:
|
||||
return 1e-4;
|
||||
case ov::element::f16:
|
||||
return 1e-3;
|
||||
case ov::element::bf16:
|
||||
return 1e-2;
|
||||
case ov::element::nf4:
|
||||
return 1e-1;
|
||||
default:
|
||||
throw std::runtime_error("Incorrect element type to get epsilon!");
|
||||
}
|
||||
}
|
||||
|
||||
ov::Tensor create_and_fill_tensor(const ov::element::Type element_type,
|
||||
const ov::Shape& shape,
|
||||
const InputGenerateData& inGenData = InputGenerateData(0, 10, 1, 1));
|
||||
|
|
|
|||
|
|
@ -310,7 +310,8 @@ ov::Tensor create_and_fill_tensor_consistently(const ov::element::Type element_t
|
|||
|
||||
constexpr double eps = std::numeric_limits<double>::epsilon();
|
||||
|
||||
inline double less(double a, double b) {
|
||||
template <typename aT, typename bT>
|
||||
inline double less(aT a, bT b) {
|
||||
return std::fabs(a - b) > eps && a < b;
|
||||
}
|
||||
|
||||
|
|
@ -318,142 +319,140 @@ inline double less_or_equal(double a, double b) {
|
|||
bool res = true;
|
||||
if (std::isnan(a) || std::isnan(b)) {
|
||||
res = false;
|
||||
} else if (std::isinf(b) && std::isinf(b)) {
|
||||
res = true;
|
||||
} else if (std::isinf(b) && b > 0) {
|
||||
// b is grater than any number or eq the +Inf
|
||||
// b is greater than any number or eq the +Inf
|
||||
res = true;
|
||||
} else if (std::isinf(a) && a > 0) {
|
||||
res = false;
|
||||
} else {
|
||||
res = (std::fabs(b - a) <= (std::fmax(std::fabs(a), std::fabs(b)) * eps) || a < b);
|
||||
res = std::fabs(b - a) <= eps || a <= b;
|
||||
}
|
||||
double eq_midle_res = std::fabs(b - a);
|
||||
bool eq_res = (std::fabs(b - a) <= (std::fmax(std::fabs(a), std::fabs(b)) * eps));
|
||||
return res;
|
||||
}
|
||||
|
||||
struct Error {
|
||||
double max = 0.;
|
||||
double mean = 0.;
|
||||
size_t max_coordinate = 0;
|
||||
size_t count = 0;
|
||||
double threshold;
|
||||
template <typename T1, typename T2>
|
||||
inline bool check_values_suitable_for_comparison(double value1, double value2) {
|
||||
bool res = true;
|
||||
auto max_val1 = std::numeric_limits<T1>::max();
|
||||
auto min_val1 = std::numeric_limits<T1>::lowest();
|
||||
auto max_val2 = std::numeric_limits<T2>::max();
|
||||
auto min_val2 = std::numeric_limits<T2>::lowest();
|
||||
if (std::isnan(value1) && std::isnan(value2)) {
|
||||
res = false;
|
||||
} else if ((std::isinf(value1) || value1 >= max_val1) && (std::isinf(value2) || value2 >= max_val2)) {
|
||||
res = false;
|
||||
} else if ((std::isinf(value1) || value1 <= min_val1) && std::isinf(value2) || value2 <= min_val2) {
|
||||
res = false;
|
||||
}
|
||||
|
||||
Error(double _threshold) : threshold(_threshold) {}
|
||||
return res;
|
||||
}
|
||||
|
||||
void update(double val, size_t i) {
|
||||
if (less(max, val)) {
|
||||
max = val;
|
||||
max_coordinate = i;
|
||||
class Error {
|
||||
protected:
|
||||
struct IncorrectValue {
|
||||
size_t coordinate;
|
||||
double actual_value, expected_value, threshold;
|
||||
|
||||
IncorrectValue(double in_actual_value, double in_expected_value, double in_threshold, size_t in_coordinate)
|
||||
: actual_value(in_actual_value),
|
||||
expected_value(in_expected_value),
|
||||
threshold(in_threshold),
|
||||
coordinate(in_coordinate) {}
|
||||
};
|
||||
|
||||
std::vector<IncorrectValue> incorrect_values_abs;
|
||||
double abs_threshold, rel_threshold;
|
||||
int tensor_size;
|
||||
|
||||
void emplace_back(double in_actual_value, double in_expected_value, double in_threshold, size_t in_coordinate) {
|
||||
incorrect_values_abs.push_back(IncorrectValue(in_actual_value, in_expected_value, in_threshold, in_coordinate));
|
||||
}
|
||||
|
||||
public:
|
||||
Error(const double in_abs_threshold, const double in_rel_threshold, int in_tensor_size = 0)
|
||||
: abs_threshold(in_abs_threshold),
|
||||
rel_threshold(in_rel_threshold),
|
||||
tensor_size(in_tensor_size) {}
|
||||
|
||||
bool update(double actual, double expected, size_t coordinate) {
|
||||
const auto diff = std::fabs(expected - actual);
|
||||
|
||||
const auto calculated_abs_threshold = std::abs(abs_threshold) + std::abs(rel_threshold * expected);
|
||||
if (less_or_equal(diff, calculated_abs_threshold)) {
|
||||
return true;
|
||||
}
|
||||
emplace_back(actual, expected, calculated_abs_threshold, coordinate);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void check_results() {
|
||||
if (!incorrect_values_abs.empty()) {
|
||||
#ifdef NDEBUG
|
||||
std::string msg = "[ COMPARATION ] COMPARATION IS FAILED!";
|
||||
msg += " Use DEBUG mode to print `incorrect_values_abs` and get detailed information!";
|
||||
#else
|
||||
std::string msg = "[ COMPARATION ] COMPARATION IS FAILED! incorrect elem counter: ";
|
||||
msg += std::to_string(incorrect_values_abs.size());
|
||||
msg += " among ";
|
||||
msg += std::to_string(tensor_size);
|
||||
msg += " shapes.";
|
||||
for (auto val : incorrect_values_abs) {
|
||||
std::cout << "\nExpected: " << val.expected_value << " Actual: " << val.actual_value
|
||||
<< " Diff: " << std::fabs(val.expected_value - val.actual_value)
|
||||
<< " calculated_abs_threshold: " << val.threshold << " abs_threshold: " << abs_threshold
|
||||
<< " rel_threshold: " << rel_threshold << "\n";
|
||||
}
|
||||
#endif
|
||||
throw std::runtime_error(msg);
|
||||
}
|
||||
mean += val;
|
||||
count += less(threshold, val);
|
||||
}
|
||||
};
|
||||
|
||||
inline double calculate_median(std::vector<double>& abs_values) {
|
||||
double abs_median = 0.;
|
||||
auto expected_shape = abs_values.size();
|
||||
if (expected_shape % 2) {
|
||||
std::nth_element(abs_values.begin(), abs_values.begin() + expected_shape / 2, abs_values.end());
|
||||
abs_median = abs_values[expected_shape / 2];
|
||||
} else {
|
||||
std::nth_element(abs_values.begin(), abs_values.begin() + expected_shape / 2, abs_values.end());
|
||||
std::nth_element(abs_values.begin(), abs_values.begin() + (expected_shape - 1) / 2, abs_values.end());
|
||||
abs_median = (abs_values[(expected_shape - 1) / 2] + abs_values[expected_shape / 2]) / 2.0;
|
||||
}
|
||||
return abs_median;
|
||||
}
|
||||
|
||||
template <typename ExpectedT, typename ActualT>
|
||||
void compare(const ov::Tensor& expected,
|
||||
const ov::Tensor& actual,
|
||||
const double abs_threshold_ = std::numeric_limits<double>::max(),
|
||||
const double rel_threshold_ = std::numeric_limits<double>::max()) {
|
||||
void compare(const ov::Tensor& expected, const ov::Tensor& actual, double abs_threshold, double rel_threshold) {
|
||||
auto expected_shape = expected.get_shape();
|
||||
auto actual_shape = actual.get_shape();
|
||||
if (expected_shape != actual_shape) {
|
||||
std::ostringstream out_stream;
|
||||
out_stream << "Expected and actual shape are different: " << expected_shape << " " << actual_shape;
|
||||
throw std::runtime_error(out_stream.str());
|
||||
}
|
||||
if (shape_size(actual_shape) == 0) {
|
||||
} else if (shape_size(actual_shape) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto expected_data = expected.data<ExpectedT>();
|
||||
auto actual_data = actual.data<ActualT>();
|
||||
double abs_threshold = abs_threshold_;
|
||||
double rel_threshold = rel_threshold_;
|
||||
if (abs_threshold == std::numeric_limits<double>::max()) {
|
||||
abs_threshold = std::max((double)std::numeric_limits<ExpectedT>::epsilon(),
|
||||
(double)std::numeric_limits<ActualT>::epsilon());
|
||||
}
|
||||
|
||||
if (rel_threshold == std::numeric_limits<double>::max()) {
|
||||
rel_threshold = get_eps_by_ov_type(expected.get_element_type());
|
||||
}
|
||||
|
||||
size_t shape_size_cnt = shape_size(expected_shape);
|
||||
if (abs_threshold == std::numeric_limits<double>::max() && rel_threshold == std::numeric_limits<double>::max()) {
|
||||
if (sizeof(ExpectedT) == 1 || sizeof(ActualT) == 1) {
|
||||
abs_threshold = 1.;
|
||||
} else {
|
||||
std::vector<double> abs_values(shape_size_cnt);
|
||||
for (size_t i = 0; i < shape_size_cnt; i++) {
|
||||
abs_values[i] = std::fabs(static_cast<double>(expected_data[i]));
|
||||
}
|
||||
auto abs_median = calculate_median(abs_values);
|
||||
abs_threshold = abs_median * 0.05 < 1e-5 ? 1e-5 : 0.05 * abs_median;
|
||||
|
||||
if (std::is_integral<ExpectedT>::value) {
|
||||
abs_threshold = std::ceil(abs_threshold);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!std::isnan(abs_threshold)) {
|
||||
std::cout << "[ COMPARATION ] rel_threshold: " << rel_threshold << std::endl;
|
||||
}
|
||||
if (!std::isnan(rel_threshold)) {
|
||||
std::cout << "[ COMPARATION ] abs_threshold: " << abs_threshold << std::endl;
|
||||
}
|
||||
|
||||
auto max_type_expected = std::numeric_limits<ExpectedT>::max();
|
||||
auto max_type_actual = std::numeric_limits<ActualT>::max();
|
||||
auto min_type_expected = std::numeric_limits<ExpectedT>::min();
|
||||
auto min_type_actual = std::numeric_limits<ActualT>::min();
|
||||
Error abs_error(abs_threshold), rel_error(rel_threshold);
|
||||
Error error(abs_threshold, rel_threshold, shape_size_cnt);
|
||||
const auto expected_data = expected.data<ExpectedT>();
|
||||
const auto actual_data = actual.data<ActualT>();
|
||||
for (size_t i = 0; i < shape_size_cnt; ++i) {
|
||||
double expected_value = expected_data[i];
|
||||
double actual_value = actual_data[i];
|
||||
if ((std::isinf(expected_value) || expected_value >= max_type_expected) &&
|
||||
(std::isinf(actual_value) || actual_value >= max_type_actual)) {
|
||||
|
||||
if (!check_values_suitable_for_comparison<ExpectedT, ActualT>(expected_value, actual_value)) {
|
||||
continue;
|
||||
} else if ((std::isinf(expected_value) || expected_value <= min_type_expected) &&
|
||||
(std::isinf(actual_value) || actual_value <= min_type_actual)) {
|
||||
continue;
|
||||
}
|
||||
if (std::isnan(expected_value) && std::isnan(actual_value))
|
||||
continue;
|
||||
if (std::isnan(expected_value)) {
|
||||
std::ostringstream out_stream;
|
||||
out_stream << "Expected value is NAN but Actual value is not on coordinate: " << i;
|
||||
throw std::runtime_error(out_stream.str());
|
||||
}
|
||||
if (std::isnan(actual_value)) {
|
||||
std::ostringstream out_stream;
|
||||
out_stream << "Actual value is NAN but Expected value is not on coordinate: " << i;
|
||||
throw std::runtime_error(out_stream.str());
|
||||
}
|
||||
|
||||
double abs = std::fabs(expected_value - actual_value);
|
||||
double rel = expected_value ? (abs / std::fabs(expected_value)) : abs;
|
||||
abs_error.update(abs, i);
|
||||
rel_error.update(rel, i);
|
||||
}
|
||||
abs_error.mean /= shape_size_cnt;
|
||||
rel_error.mean /= shape_size_cnt;
|
||||
|
||||
if (!(less_or_equal(abs_error.max, abs_threshold) && less_or_equal(rel_error.max, rel_threshold))) {
|
||||
std::ostringstream out_stream;
|
||||
out_stream << "abs_max < abs_threshold && rel_max < rel_threshold"
|
||||
<< "\n\t abs_max: " << abs_error.max << "\n\t\t coordinate " << abs_error.max_coordinate
|
||||
<< "; abs errors count " << abs_error.count << "; abs mean " << abs_error.mean << "; abs threshold "
|
||||
<< abs_threshold << "\n\t rel_max: " << rel_error.max << "\n\t\t coordinate "
|
||||
<< rel_error.max_coordinate << "; rel errors count " << rel_error.count << "; rel mean "
|
||||
<< rel_error.mean << "; rel threshold " << rel_threshold;
|
||||
throw std::runtime_error(out_stream.str());
|
||||
bool status = error.update(expected_value, actual_value, i);
|
||||
#ifdef NDEBUG
|
||||
if (!status) {
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
error.check_results();
|
||||
}
|
||||
|
||||
void compare_str(const ov::Tensor& expected, const ov::Tensor& actual) {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,163 @@
|
|||
// Copyright (C) 2023 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "common_test_utils/ov_tensor_utils.hpp"
|
||||
|
||||
using namespace testing;
|
||||
using namespace ov::util;
|
||||
|
||||
TEST(Comparator, boolean) {
|
||||
const bool value = true;
|
||||
ov::element::Type element_type = ov::element::boolean;
|
||||
ov::Shape shape{1, 4};
|
||||
bool values[] = {value, value, value, value};
|
||||
bool values_ref[] = {value, value, value, value};
|
||||
auto tensor = ov::Tensor(element_type, shape, values);
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref);
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, boolean_negative) {
|
||||
const bool value = true;
|
||||
ov::element::Type element_type = ov::element::boolean;
|
||||
ov::Shape shape{1, 4};
|
||||
bool values[] = {value, value, value, value};
|
||||
bool values_ref[] = {value, value, value, !value};
|
||||
auto tensor = ov::Tensor(element_type, shape, values);
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref);
|
||||
ASSERT_ANY_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, integer) {
|
||||
const int value = 1;
|
||||
ov::element::Type element_type = ov::element::i32;
|
||||
ov::Shape shape{3, 4};
|
||||
std::vector<int> values(ov::shape_size(shape), value);
|
||||
std::vector<int> values_ref(ov::shape_size(shape), value);
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref.data());
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, integer_negative) {
|
||||
const int value = 1;
|
||||
ov::element::Type element_type = ov::element::i32;
|
||||
ov::Shape shape{3, 4};
|
||||
std::vector<int> values(ov::shape_size(shape), value);
|
||||
std::vector<int> values_ref(ov::shape_size(shape), value);
|
||||
values_ref[ov::shape_size(shape) - 1] = value * 0;
|
||||
values_ref[ov::shape_size(shape) / 2] = value * 2;
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref.data());
|
||||
ASSERT_ANY_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, float_) {
|
||||
const float value = 0.1f;
|
||||
ov::element::Type element_type = ov::element::f32;
|
||||
ov::Shape shape{3, 4};
|
||||
std::vector<float> values(ov::shape_size(shape), value);
|
||||
std::vector<float> values_ref(ov::shape_size(shape), value);
|
||||
// default rel_threshold * value * 0.5 + abs_threshold to be same
|
||||
const auto abs_threshold = std::numeric_limits<float>::epsilon();
|
||||
const auto def_threshold = ov::test::utils::get_eps_by_ov_type(element_type) * value * 0.9f + abs_threshold;
|
||||
for (auto& value : values) {
|
||||
value += def_threshold;
|
||||
}
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref.data());
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, float_large) {
|
||||
const float value = 1e6;
|
||||
ov::element::Type element_type = ov::element::f32;
|
||||
ov::Shape shape{3, 4};
|
||||
std::vector<float> values(ov::shape_size(shape), value);
|
||||
std::vector<float> values_ref(ov::shape_size(shape), value);
|
||||
// default rel_threshold * value * 0.5 + abs_threshold to be same
|
||||
const auto abs_threshold = std::numeric_limits<float>::epsilon();
|
||||
const auto def_threshold = ov::test::utils::get_eps_by_ov_type(element_type) * value * 0.99 + abs_threshold;
|
||||
for (size_t i = 0; i < values.size(); ++i) {
|
||||
values[i] += (i % 2 ? def_threshold : -def_threshold);
|
||||
}
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref.data());
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, float_negative) {
|
||||
const float value = 2.4f;
|
||||
ov::element::Type element_type = ov::element::f32;
|
||||
ov::Shape shape{3, 4};
|
||||
std::vector<float> values(ov::shape_size(shape), value);
|
||||
std::vector<float> values_ref(ov::shape_size(shape), value);
|
||||
const auto abs_threshold = std::numeric_limits<float>::epsilon();
|
||||
const auto def_threshold = ov::test::utils::get_eps_by_ov_type(element_type) * value * 1.1f + abs_threshold;
|
||||
for (size_t i = 0; i < values.size(); ++i) {
|
||||
values[i] += (i % 2 ? def_threshold : -def_threshold);
|
||||
}
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref.data());
|
||||
ASSERT_ANY_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, float_extra_small) {
|
||||
const float value = 1e-6;
|
||||
ov::element::Type element_type = ov::element::f32;
|
||||
ov::Shape shape{3, 4};
|
||||
std::vector<float> values(ov::shape_size(shape), value);
|
||||
std::vector<float> values_ref(ov::shape_size(shape), value);
|
||||
const auto abs_threshold = std::numeric_limits<float>::epsilon();
|
||||
const auto def_threshold = ov::test::utils::get_eps_by_ov_type(ov::element::f32) * value * 0.8f + abs_threshold;
|
||||
for (size_t i = 0; i < values.size(); ++i) {
|
||||
values[i] += (i % 2 ? def_threshold : -def_threshold);
|
||||
}
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape, values_ref.data());
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, different_shapes) {
|
||||
const float value = 1e-1;
|
||||
ov::element::Type element_type = ov::element::f32;
|
||||
ov::Shape shape{3, 4};
|
||||
ov::Shape shape_ref{1, 4};
|
||||
std::vector<float> values(ov::shape_size(shape), value);
|
||||
std::vector<float> values_ref(ov::shape_size(shape_ref), value);
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type, shape_ref, values_ref.data());
|
||||
ASSERT_ANY_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, different_prc_low) {
|
||||
const float value = 1e-2;
|
||||
ov::element::Type element_type = ov::element::f32;
|
||||
ov::element::Type element_type_ref = ov::element::f16;
|
||||
ov::Shape shape{3, 4};
|
||||
const auto abs_threshold = std::numeric_limits<ov::float16>::epsilon();
|
||||
const float threshold = ov::test::utils::get_eps_by_ov_type(element_type_ref) * value * 0.9 + abs_threshold;
|
||||
std::vector<float> values(ov::shape_size(shape), value + threshold);
|
||||
std::vector<ov::float16> values_ref(ov::shape_size(shape), ov::float16(value));
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type_ref, shape, values_ref.data());
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
||||
TEST(Comparator, different_prc_up) {
|
||||
const float value = 1e+2;
|
||||
ov::element::Type element_type = ov::element::f16;
|
||||
ov::element::Type element_type_ref = ov::element::f32;
|
||||
ov::Shape shape{3, 4};
|
||||
const auto abs_threshold = std::numeric_limits<float>::epsilon();
|
||||
const float threshold = ov::test::utils::get_eps_by_ov_type(element_type_ref) * value * 0.9f + abs_threshold;
|
||||
float updated_value = value - threshold;
|
||||
std::vector<ov::float16> values(ov::shape_size(shape), ov::float16(updated_value));
|
||||
std::vector<float> values_ref(ov::shape_size(shape), value);
|
||||
auto tensor = ov::Tensor(element_type, shape, values.data());
|
||||
auto tensor_ref = ov::Tensor(element_type_ref, shape, values_ref.data());
|
||||
ASSERT_NO_THROW(ov::test::utils::compare(tensor_ref, tensor));
|
||||
}
|
||||
|
|
@ -210,3 +210,38 @@ conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=
|
|||
conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=(),6.62629e-06
|
||||
conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=(),2.89071e-06
|
||||
conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=(),9.4639279043362649e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5f45e938f9e6d58ccc6bf771049731f2d9c4a8b0ed83e2a1942ac69ab76984b3_Device=CPU_Config=(),0.0557008
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=fcab2b4b3bf1a04070e3fd3490e6317f2d6870335d302d96c768f40da8565c8d_Device=CPU_Config=(),0.0457559
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=64551d094520cf00d40fe514f573f5f37f61416bd456474f4b0a21788c4ffd3a_Device=CPU_Config=(),0.0317511
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a05c6778a396b4eb89a5e112fe505a41f47ff6bef50fa025eee1dfb7ec6a95e7_Device=CPU_Config=(),0.0278555
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3f830d5ee243ca3f56d027f95929bbadd427e4954e286e6c890ddd60f9c5c2d0_Device=CPU_Config=(),0.0135749
|
||||
conformance_Mish/ReadIRTest.Inference/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=(),0.00464721
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d962e7157ea216206d6c5b11fe5ef6ee162a1f7dc20f84a3b058e405c324a592_Device=CPU_Config=(),0.00296796
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e00cea4f2ea99f32c11ea265ecc0483554192192bb99f36438dd38de09820888_Device=CPU_Config=(),0.00278618
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e250a19bfbe236f81b6715a92beb0c259080e4a5d379ea1187892e8c8d9add8a_Device=CPU_Config=(),0.00278133
|
||||
conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=753b524e2aad8fde7e7206fa8c3e7ca15c52c49f22f41d48cfb6b4d814cb40af_Device=CPU_Config=(),0.00219926
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=5bed52483d61091259db863ffcd3b09c190fedde5dac72edad6f1bf37230f344_Device=CPU_Config=(),0.00205555
|
||||
conformance_SoftPlus/ReadIRTest.Inference/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=(),0.00174142
|
||||
conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=(),0.000769389
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6e9fb2accb692c69349a88158442052e6350143ca7dc28f2525d8e8df29f8c78_Device=CPU_Config=(),0.000760651
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=(),0.000537296
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=(),0.00034203
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=71c0c7e3176ae8b233352c89d47a61394cb46695e7879118ed02070a4a23d5e1_Device=CPU_Config=(),0.000308682
|
||||
conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=db85fabcfcf049a7225468036e29c949eb779253ba145485205596e72cb8cc7e_Device=CPU_Config=(),0.000259235
|
||||
conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=(),0.000249187
|
||||
conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=(),0.000232472
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=aa6c3816ce7ce49f40be5edbe957468e80910a8eb5a3956f54d89fdf7c264b44_Device=CPU_Config=(),8.28313e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=(),7.37455e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=37ed85c113d481da6d55c0a820d49090a8b256694e0f1b111feded60fe708279_Device=CPU_Config=(),4.74166e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=67ed6a8048424f4e44f40c542faf7a2a2d2419e81aa982fe32a054af05caf309_Device=CPU_Config=(),4.70406e-05
|
||||
conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=(),4.06654e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=eca24a51b737307a94a918f4d03923c1e035a3379c73359515c63ff3ea98be85_Device=CPU_Config=(),3.99909e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5e31c7022ed7bf2adff14876be4bbf6562afdc2239a08ddcdb507e3d1a20071b_Device=CPU_Config=(),3.56296e-05
|
||||
conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43ba20ec70e156f4782e1f11a30f02daaaafb2039912a373620d845e995c97cc_Device=CPU_Config=(),3.51144e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ea8fff2db5032f5015f68d53904354d4bdfbe5288224c7f549a1573794455d80_Device=CPU_Config=(),2.01285e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7b1df1422bfecf1fdf9c25f72d938950cb1492ee1c7223d9c0d771f93b1fbdb8_Device=CPU_Config=(),2.0062e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ffc3cad64b8bf82ffa4d189a247a9434e71886cacd3582956c5dd98921fd2141_Device=CPU_Config=(),1.47491e-05
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f2eb693da69b0ad1af3bcef6c4af46ba2b92897f76989c310a65aac5c2027725_Device=CPU_Config=(),1.00834e-05
|
||||
conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=35c61b2251b78ad9f9804bd3f9e301e1f974c6dc138ce0466b8b940d106ddd72_Device=CPU_Config=(),9.92895e-06
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7caba2dff8ab10660f66796a39d8d2a78f3e282f0629c2ecbee9b90c34e62aa0_Device=CPU_Config=(),2.1896e-06
|
||||
conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2e06088cb191d8d26309843b1285b9ae4a1eb0722e1370875edde7fd2783851b_Device=CPU_Config=(),1.88776e-06
|
||||
|
Loading…
Reference in New Issue