From 14901333acb2b175c9b0c4b009a99d9ac66ca733 Mon Sep 17 00:00:00 2001 From: Przemyslaw Wysocki Date: Wed, 14 Aug 2024 06:53:16 +0200 Subject: [PATCH 001/117] Add reference implementations for `StringTensorPack-15` and `StringTensorUnpack-15` (#25941) ### Details: - Reference implementations for `StringTensorPack-15` and `StringTensorUnpack-15` - Leftover Code Review changes from the Core PR - Minor fixes ### Related PRs: - https://github.com/openvinotoolkit/openvino/pull/25104 - https://github.com/openvinotoolkit/openvino/pull/25606 ### Tickets: - CVS-143933 - CVS-143928 --------- Co-authored-by: Katarzyna Mitrus --- .../openvino/op/string_tensor_unpack.hpp | 2 +- .../include/openvino/opsets/opset15_tbl.hpp | 2 + .../openvino/reference/string_tensor_pack.hpp | 22 +++ .../reference/string_tensor_unpack.hpp | 24 +++ .../string_tensor_pack_shape_inference.hpp | 20 +- .../string_tensor_unpack_shape_inference.hpp | 18 +- src/core/tests/opset.cpp | 2 +- .../tests/type_prop/string_tensor_pack.cpp | 4 +- ...tring_tensor_pack_shape_inference_test.cpp | 4 +- .../template/backend/ops/ops_evaluates.hpp | 8 + .../backend/ops/string_tensor_pack.cpp | 45 +++++ .../backend/ops/string_tensor_unpack.cpp | 37 ++++ .../template/backend/opset_int_tbl.hpp | 2 + .../op_reference/string_tensor_pack.cpp | 181 ++++++++++++++++++ .../op_reference/string_tensor_unpack.cpp | 142 ++++++++++++++ .../src/op_impl_check/single_op_graph.cpp | 16 ++ 16 files changed, 499 insertions(+), 30 deletions(-) create mode 100644 src/core/reference/include/openvino/reference/string_tensor_pack.hpp create mode 100644 src/core/reference/include/openvino/reference/string_tensor_unpack.hpp create mode 100644 src/plugins/template/backend/ops/string_tensor_pack.cpp create mode 100644 src/plugins/template/backend/ops/string_tensor_unpack.cpp create mode 100644 src/plugins/template/tests/functional/op_reference/string_tensor_pack.cpp create mode 100644 src/plugins/template/tests/functional/op_reference/string_tensor_unpack.cpp diff --git a/src/core/include/openvino/op/string_tensor_unpack.hpp b/src/core/include/openvino/op/string_tensor_unpack.hpp index 0b70e60fc24134..3c930e15b515bf 100644 --- a/src/core/include/openvino/op/string_tensor_unpack.hpp +++ b/src/core/include/openvino/op/string_tensor_unpack.hpp @@ -18,7 +18,7 @@ class OPENVINO_API StringTensorUnpack : public ov::op::Op { StringTensorUnpack() = default; /// \brief Constructs a StringTensorUnpack operation. /// - /// \param data Input strings encoded in utf-8 bytes + /// \param data Input of type element::string StringTensorUnpack(const Output& data); void validate_and_infer_types() override; diff --git a/src/core/include/openvino/opsets/opset15_tbl.hpp b/src/core/include/openvino/opsets/opset15_tbl.hpp index 4d85571d5b69bc..fee8e40fdf2c74 100644 --- a/src/core/include/openvino/opsets/opset15_tbl.hpp +++ b/src/core/include/openvino/opsets/opset15_tbl.hpp @@ -18,5 +18,7 @@ _OPENVINO_OP_REG(ScatterNDUpdate, ov::op::v15) _OPENVINO_OP_REG(EmbeddingBagPacked, ov::op::v15) _OPENVINO_OP_REG(EmbeddingBagOffsets, ov::op::v15) _OPENVINO_OP_REG(Col2Im, ov::op::v15) +_OPENVINO_OP_REG(StringTensorUnpack, ov::op::v15) +_OPENVINO_OP_REG(StringTensorPack, ov::op::v15) _OPENVINO_OP_REG(BitwiseLeftShift, ov::op::v15) _OPENVINO_OP_REG(BitwiseRightShift, ov::op::v15) diff --git a/src/core/reference/include/openvino/reference/string_tensor_pack.hpp b/src/core/reference/include/openvino/reference/string_tensor_pack.hpp new file mode 100644 index 00000000000000..4ddff0c1a5811d --- /dev/null +++ b/src/core/reference/include/openvino/reference/string_tensor_pack.hpp @@ -0,0 +1,22 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once +#include "openvino/core/shape.hpp" + +namespace ov { +namespace reference { +template +void string_tensor_pack(const T_idx* begins, + const T_idx* ends, + const uint8_t* symbols, + std::string* out, + const size_t string_count) { + const char* chars = reinterpret_cast(symbols); + for (size_t i = 0; i < string_count; ++i) { + out[i].assign(chars + begins[i], chars + ends[i]); + } +} +} // namespace reference +} // namespace ov diff --git a/src/core/reference/include/openvino/reference/string_tensor_unpack.hpp b/src/core/reference/include/openvino/reference/string_tensor_unpack.hpp new file mode 100644 index 00000000000000..1e5b24870e3a9c --- /dev/null +++ b/src/core/reference/include/openvino/reference/string_tensor_unpack.hpp @@ -0,0 +1,24 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once +#include "openvino/core/shape.hpp" + +namespace ov { +namespace reference { +void string_tensor_unpack(const std::string* data, + int32_t* out_begins, + int32_t* out_ends, + uint8_t* out_symbols, + const size_t element_count) { + int32_t offset = 0; + for (size_t i = 0; i < element_count; ++i) { + out_begins[i] = offset; + out_symbols = std::copy(data[i].begin(), data[i].end(), out_symbols); + offset += static_cast(data[i].length()); + out_ends[i] = offset; + } +} +} // namespace reference +} // namespace ov diff --git a/src/core/shape_inference/include/string_tensor_pack_shape_inference.hpp b/src/core/shape_inference/include/string_tensor_pack_shape_inference.hpp index cb22d3d93fa2da..f87e69283e0dfa 100644 --- a/src/core/shape_inference/include/string_tensor_pack_shape_inference.hpp +++ b/src/core/shape_inference/include/string_tensor_pack_shape_inference.hpp @@ -26,12 +26,10 @@ static void validate_indices(const size_t input_index, NODE_SHAPE_INFER_CHECK(op, input_shapes, (*data)[0] >= 0, "Indices cannot be negative."); const auto& symbols_shape = input_shapes[2]; if (symbols_shape.is_static()) { - // ends indices are offset by 1 - const auto biggest_idx = symbols_shape[0].get_length() + (input_index == 0 ? 0 : 1); NODE_SHAPE_INFER_CHECK( op, input_shapes, - ov::cmp::lt(data->back(), biggest_idx), + ov::cmp::le(data->back(), symbols_shape[0].get_length()), "The biggest index cannot be higher than the amount or characters in symbols input."); } const auto are_indices_ascending = std::is_sorted(data->begin(), data->end()); @@ -50,18 +48,14 @@ std::vector shape_infer(const StringTensorPack* op, util::validate_indices(1, tensor_accessor, op, input_shapes); const auto& begins_shape = input_shapes[0]; const auto& ends_shape = input_shapes[1]; - NODE_SHAPE_INFER_CHECK(op, input_shapes, begins_shape.compatible(ends_shape)); const auto& symbols_shape = input_shapes[2]; NODE_SHAPE_INFER_CHECK(op, input_shapes, symbols_shape.rank().compatible(1), "Symbols input must be 1D."); - - // begins_shape and ends_shape always have to match - auto output_shapes = std::vector(); - if (begins_shape.is_dynamic() && ends_shape.is_static()) { - output_shapes.push_back(ends_shape); - } else { - output_shapes.push_back(begins_shape); - } - return {std::move(output_shapes)}; + auto output_shapes = std::vector{begins_shape}; + NODE_SHAPE_INFER_CHECK(op, + input_shapes, + TRShape::merge_into(output_shapes[0], ends_shape), + "The shapes of begins and ends have to be compatible."); + return output_shapes; } } // namespace v15 } // namespace op diff --git a/src/core/shape_inference/include/string_tensor_unpack_shape_inference.hpp b/src/core/shape_inference/include/string_tensor_unpack_shape_inference.hpp index f7b7950476453c..a218c92eb9c378 100644 --- a/src/core/shape_inference/include/string_tensor_unpack_shape_inference.hpp +++ b/src/core/shape_inference/include/string_tensor_unpack_shape_inference.hpp @@ -31,18 +31,14 @@ std::vector shape_infer(const StringTensorUnpack* op, NODE_VALIDATION_CHECK(op, input_shapes.size() == 1); const auto& data_shape = input_shapes[0]; auto output_shapes = std::vector{data_shape, data_shape}; - if (data_shape.is_static()) { - if (const auto string_data = util::get_string_tensor(op, tensor_accessor)) { - const auto string_count = string_data.get_size(); - const auto tensor_data = string_data.data(); - size_t total_length = 0; - for (auto it = tensor_data; it != std::next(tensor_data, string_count); ++it) { - total_length += (*it).length(); - } - output_shapes.emplace_back(TRShape{static_cast(total_length)}); - } else { - output_shapes.emplace_back(ov::PartialShape{ov::Dimension::dynamic()}); + if (const auto string_data = util::get_string_tensor(op, tensor_accessor)) { + const auto string_count = string_data.get_size(); + const auto tensor_data = string_data.data(); + size_t total_length = 0; + for (auto it = tensor_data; it != std::next(tensor_data, string_count); ++it) { + total_length += (*it).length(); } + output_shapes.emplace_back(TRShape{static_cast(total_length)}); } else { output_shapes.emplace_back(ov::PartialShape{ov::Dimension::dynamic()}); } diff --git a/src/core/tests/opset.cpp b/src/core/tests/opset.cpp index 3692ad5823f400..fe3c3290d51c17 100644 --- a/src/core/tests/opset.cpp +++ b/src/core/tests/opset.cpp @@ -75,7 +75,7 @@ INSTANTIATE_TEST_SUITE_P(opset, OpsetTestParams{ov::get_opset12, 178}, OpsetTestParams{ov::get_opset13, 186}, OpsetTestParams{ov::get_opset14, 188}, - OpsetTestParams{ov::get_opset15, 10}), + OpsetTestParams{ov::get_opset15, 12}), OpsetTestNameGenerator{}); class MyOpOld : public ov::op::Op { diff --git a/src/core/tests/type_prop/string_tensor_pack.cpp b/src/core/tests/type_prop/string_tensor_pack.cpp index 005ee56efef8fc..a81aa8eeb1ffd4 100644 --- a/src/core/tests/type_prop/string_tensor_pack.cpp +++ b/src/core/tests/type_prop/string_tensor_pack.cpp @@ -67,7 +67,7 @@ TEST_F(TypePropStringTensorPackV15Test, ends_static_begins_dynamic) { EXPECT_EQ(op->get_output_element_type(0), element::string); EXPECT_EQ(op->get_output_partial_shape(0), ends_shape); - EXPECT_EQ(get_shape_symbols(op->get_output_partial_shape(0)), ends_symbols); + EXPECT_EQ(get_shape_symbols(op->get_output_partial_shape(0)), begins_symbols); } TEST_F(TypePropStringTensorPackV15Test, default_case) { @@ -105,7 +105,7 @@ TEST_F(TypePropStringTensorPackV15Test, begins_ends_shape_mismatch) { const auto symbols = std::make_shared(element::u8, PartialShape{100}); OV_EXPECT_THROW(std::ignore = make_op(begins, ends, symbols), NodeValidationFailure, - HasSubstr("Check 'begins_shape.compatible(ends_shape)' failed")); + HasSubstr("The shapes of begins and ends have to be compatible")); } TEST_F(TypePropStringTensorPackV15Test, incorrect_types) { diff --git a/src/plugins/intel_cpu/tests/unit/shape_inference_test/string_tensor_pack_shape_inference_test.cpp b/src/plugins/intel_cpu/tests/unit/shape_inference_test/string_tensor_pack_shape_inference_test.cpp index 1ddf2c8636d95c..3379651e11f235 100644 --- a/src/plugins/intel_cpu/tests/unit/shape_inference_test/string_tensor_pack_shape_inference_test.cpp +++ b/src/plugins/intel_cpu/tests/unit/shape_inference_test/string_tensor_pack_shape_inference_test.cpp @@ -236,7 +236,7 @@ TEST_F(StringTensorPackStaticShapeInferenceWithTensorAccessorTest, indices_valid testing::HasSubstr("Indices cannot be negative")); } { // begins out of bounds - int32_t begins[] = {1, 1, 1, 3}; + int32_t begins[] = {1, 1, 1, 4}; int32_t ends[] = {1, 1, 2, 3}; const auto const_inputs = std::unordered_map{ {0, {element::i32, Shape{2, 2}, begins}}, @@ -247,7 +247,7 @@ TEST_F(StringTensorPackStaticShapeInferenceWithTensorAccessorTest, indices_valid testing::HasSubstr("The biggest index cannot be higher than the amount or characters in symbols input")); } { // ends out of bounds - int32_t begins[] = {1, 1, 1, 2}; + int32_t begins[] = {1, 1, 1, 3}; int32_t ends[] = {1, 1, 2, 4}; const auto const_inputs = std::unordered_map{ {0, {element::i32, Shape{2, 2}, begins}}, diff --git a/src/plugins/template/backend/ops/ops_evaluates.hpp b/src/plugins/template/backend/ops/ops_evaluates.hpp index 9bcd0d94b60cfb..7f02386d41e3e2 100644 --- a/src/plugins/template/backend/ops/ops_evaluates.hpp +++ b/src/plugins/template/backend/ops/ops_evaluates.hpp @@ -535,3 +535,11 @@ extern template bool evaluate_node(std::shared_ extern template bool evaluate_node(std::shared_ptr node, ov::TensorVector& outputs, const ov::TensorVector& inputs); + +extern template bool evaluate_node(std::shared_ptr node, + ov::TensorVector& outputs, + const ov::TensorVector& inputs); + +extern template bool evaluate_node(std::shared_ptr node, + ov::TensorVector& outputs, + const ov::TensorVector& inputs); diff --git a/src/plugins/template/backend/ops/string_tensor_pack.cpp b/src/plugins/template/backend/ops/string_tensor_pack.cpp new file mode 100644 index 00000000000000..dec0f8fd058e60 --- /dev/null +++ b/src/plugins/template/backend/ops/string_tensor_pack.cpp @@ -0,0 +1,45 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/reference/string_tensor_pack.hpp" + +#include "evaluate_node.hpp" +#include "string_tensor_pack_shape_inference.hpp" + +template <> +bool evaluate_node(std::shared_ptr node, + ov::TensorVector& outputs, + const ov::TensorVector& inputs) { + auto string_tensor_pack = std::dynamic_pointer_cast(node); + OPENVINO_ASSERT(string_tensor_pack, "Node passed to StringTensorPack evaluate function is invalid."); + ov::Shape output_shape; + output_shape = ov::op::v15::shape_infer(string_tensor_pack.get(), + ov::util::get_tensors_partial_shapes(inputs), + make_tensor_accessor(inputs)) + .front() + .to_shape(); + outputs.front().set_shape(output_shape); + const auto indices_type = node->get_input_element_type(0); + const auto& data_shape = node->get_input_shape(0); + int64_t string_count = std::accumulate(data_shape.begin(), data_shape.end(), 1, std::multiplies()); + switch (indices_type) { + case ov::element::i32: + ov::reference::string_tensor_pack(inputs[0].data(), + inputs[1].data(), + inputs[2].data(), + outputs[0].data(), + string_count); + break; + case ov::element::i64: + ov::reference::string_tensor_pack(inputs[0].data(), + inputs[1].data(), + inputs[2].data(), + outputs[0].data(), + string_count); + break; + default: + OPENVINO_THROW("Unhandled indices data type ", node->get_element_type().get_type_name(), " in evaluate_node()"); + } + return true; +} diff --git a/src/plugins/template/backend/ops/string_tensor_unpack.cpp b/src/plugins/template/backend/ops/string_tensor_unpack.cpp new file mode 100644 index 00000000000000..319762023265d5 --- /dev/null +++ b/src/plugins/template/backend/ops/string_tensor_unpack.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/reference/string_tensor_unpack.hpp" + +#include "evaluate_node.hpp" +#include "string_tensor_unpack_shape_inference.hpp" + +template <> +bool evaluate_node(std::shared_ptr node, + ov::TensorVector& outputs, + const ov::TensorVector& inputs) { + if (node->get_input_element_type(0) == ov::element::string) { + auto string_tensor_unpack = std::dynamic_pointer_cast(node); + OPENVINO_ASSERT(string_tensor_unpack, "Node passed to StringTensorUnpack evaluate function is invalid."); + std::vector output_shapes; + output_shapes = ov::op::v15::shape_infer(string_tensor_unpack.get(), + ov::util::get_tensors_partial_shapes(inputs), + make_tensor_accessor(inputs)); + auto outputs_it = outputs.begin(); + for (const auto& p_shape : output_shapes) { + outputs_it->set_shape(p_shape.get_shape()); + ++outputs_it; + } + const auto& data_shape = node->get_input_shape(0); + const auto element_count = shape_size(data_shape); + ov::reference::string_tensor_unpack(inputs[0].data(), + outputs[0].data(), + outputs[1].data(), + outputs[2].data(), + element_count); + } else { + OPENVINO_THROW("The input type for StringTensorUnpack operation must be ov::element::string."); + } + return true; +} diff --git a/src/plugins/template/backend/opset_int_tbl.hpp b/src/plugins/template/backend/opset_int_tbl.hpp index cce47e15111ead..f31f451454d2cb 100644 --- a/src/plugins/template/backend/opset_int_tbl.hpp +++ b/src/plugins/template/backend/opset_int_tbl.hpp @@ -169,6 +169,8 @@ _OPENVINO_OP_REG(ROIAlignRotated, ov::op::v15) _OPENVINO_OP_REG(EmbeddingBagOffsets, op::v15) _OPENVINO_OP_REG(EmbeddingBagPacked, op::v15) _OPENVINO_OP_REG(Col2Im, ov::op::v15) +_OPENVINO_OP_REG(StringTensorUnpack, ov::op::v15) +_OPENVINO_OP_REG(StringTensorPack, ov::op::v15) _OPENVINO_OP_REG(BitwiseLeftShift, ov::op::v15) _OPENVINO_OP_REG(BitwiseRightShift, ov::op::v15) diff --git a/src/plugins/template/tests/functional/op_reference/string_tensor_pack.cpp b/src/plugins/template/tests/functional/op_reference/string_tensor_pack.cpp new file mode 100644 index 00000000000000..0cfcff46b93de4 --- /dev/null +++ b/src/plugins/template/tests/functional/op_reference/string_tensor_pack.cpp @@ -0,0 +1,181 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/op/string_tensor_pack.hpp" + +#include + +#include "base_reference_test.hpp" + +namespace { +struct StringTensorPackParams { + StringTensorPackParams(const reference_tests::Tensor& beginsTensor, + const reference_tests::Tensor& endsTensor, + const reference_tests::Tensor& symbolsTensor, + const reference_tests::Tensor& stringTensor) + : beginsTensor(beginsTensor), + endsTensor(endsTensor), + symbolsTensor(symbolsTensor), + stringTensor(stringTensor) {} + + reference_tests::Tensor beginsTensor; + reference_tests::Tensor endsTensor; + reference_tests::Tensor symbolsTensor; + reference_tests::Tensor stringTensor; +}; + +class ReferenceStringTensorPackV15LayerTest : public testing::TestWithParam, + public reference_tests::CommonReferenceTest { +protected: + void SetUp() override { + const auto& params = GetParam(); + function = CreateFunction(params); + inputData = {params.beginsTensor.data, params.endsTensor.data, params.symbolsTensor.data}; + refOutData = {params.stringTensor.data}; + } + +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "indicesShape=" << param.beginsTensor.shape; + result << "_indicesType=" << param.beginsTensor.type; + result << "_symbolsShape=" << param.symbolsTensor.shape; + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const StringTensorPackParams& params) { + const auto begins = + std::make_shared(params.beginsTensor.type, params.beginsTensor.shape); + const auto ends = std::make_shared(params.endsTensor.type, params.endsTensor.shape); + const auto symbols = + std::make_shared(params.symbolsTensor.type, params.symbolsTensor.shape); + const auto string_tensor_pack = std::make_shared(begins, ends, symbols); + return std::make_shared(ov::OutputVector{string_tensor_pack->outputs()}, + ov::ParameterVector{begins, ends, symbols}, + ov::op::util::VariableVector{}); + } +}; + +TEST_P(ReferenceStringTensorPackV15LayerTest, CompareWithRefs) { + Exec(); +} + +template +std::vector generateStringTensorPackParams() { + using ov::element::Type_t; + using reference_tests::Tensor; + using T_I = typename ov::element_type_traits::value_type; + const std::vector StringTensorPackParamsList{ + // simple 1D case + StringTensorPackParams( + Tensor({2}, T_idx, std::vector{0, 5}), + Tensor({2}, T_idx, std::vector{5, 13}), + Tensor({13}, + ov::element::u8, + std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x56, 0x49, 0x4e, 0x4f}), + Tensor({2}, ov::element::string, std::vector{"Intel", "OpenVINO"})), + // 2D strings with spaces and an empty string + StringTensorPackParams( + Tensor({1, 5}, T_idx, std::vector{0, 10, 13, 22, 22}), + Tensor({1, 5}, T_idx, std::vector{10, 13, 22, 22, 45}), + + Tensor({45}, ov::element::u8, std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x20, 0x43, 0x6f, 0x72, + 0x70, 0x20, 0x20, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x20, + 0x56, 0x49, 0x4e, 0x4f, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x49, 0x6e, 0x74, + 0x65, 0x6c, 0x6c, 0x69, 0x67, 0x65, 0x6e, 0x63, 0x65}), + Tensor({1, 5}, + ov::element::string, + std::vector{"Intel Corp", " ", "Open VINO", "", "Artificial Intelligence"})), + // strings with special characters + StringTensorPackParams( + Tensor({3}, T_idx, std::vector{0, 6, 15}), + Tensor({3}, T_idx, std::vector{6, 15, 18}), + Tensor({18}, + ov::element::u8, + std::vector{0x49, + 0x6e, + 0x40, + 0x74, + 0x65, + 0x6c, + 0x4f, + 0x70, + 0x65, + 0x6e, + 0x23, + 0x56, + 0x49, + 0x4e, + 0x4f, + 0x41, + 0x24, + 0x49}), + Tensor({3}, ov::element::string, std::vector{"In@tel", "Open#VINO", "A$I"})), + // (2, 2, 2) data shape + StringTensorPackParams( + Tensor({2, 2, 2}, T_idx, std::vector{0, 5, 13, 15, 19, 27, 33, 39}), + Tensor({2, 2, 2}, T_idx, std::vector{5, 13, 15, 19, 27, 33, 39, 47}), + Tensor({47}, + ov::element::u8, + std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x56, 0x49, 0x4e, + 0x4f, 0x41, 0x49, 0x45, 0x64, 0x67, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x75, + 0x74, 0x65, 0x72, 0x56, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x4e, 0x65, 0x75, + 0x72, 0x61, 0x6c, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x73}), + Tensor({2, 2, 2}, + ov::element::string, + std::vector< + std::string>{"Intel", "OpenVINO", "AI", "Edge", "Computer", "Vision", "Neural", "Networks"})), + // single, empty string + StringTensorPackParams(Tensor({1, 1, 1, 1}, T_idx, std::vector{0}), + Tensor({1, 1, 1, 1}, T_idx, std::vector{0}), + Tensor({0}, ov::element::u8, std::vector{}), + Tensor({1, 1, 1, 1}, ov::element::string, std::vector{""})), + // empty data + StringTensorPackParams(Tensor({0}, T_idx, std::vector{}), + Tensor({0}, T_idx, std::vector{}), + Tensor({0}, ov::element::u8, std::vector{}), + Tensor({0}, ov::element::string, std::vector{})), + // skipped symbols + StringTensorPackParams( + Tensor({1, 2}, T_idx, std::vector{0, 8}), + Tensor({1, 2}, T_idx, std::vector{3, 13}), + Tensor({13}, + ov::element::u8, + std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x56, 0x49, 0x4e, 0x4f}), + Tensor({1, 2}, ov::element::string, std::vector{"Int", "nVINO"})), + // empty string at the end + StringTensorPackParams( + Tensor({1, 3}, T_idx, std::vector{0, 5, 13}), + Tensor({1, 3}, T_idx, std::vector{5, 13, 13}), + Tensor({13}, + ov::element::u8, + std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x56, 0x49, 0x4e, 0x4f}), + Tensor({1, 3}, ov::element::string, std::vector{"Intel", "OpenVINO", ""})), + }; + return StringTensorPackParamsList; +} + +std::vector generateStringTensorPackV15CombinedParams() { + using ov::element::Type_t; + const std::vector> stringTensorPackTypeParams{ + generateStringTensorPackParams(), + generateStringTensorPackParams(), + }; + + std::vector combinedParams; + for (const auto& params : stringTensorPackTypeParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_StringTensorPack_With_Hardcoded_Refs, + ReferenceStringTensorPackV15LayerTest, + testing::ValuesIn(generateStringTensorPackV15CombinedParams()), + ReferenceStringTensorPackV15LayerTest::getTestCaseName); + +} // namespace diff --git a/src/plugins/template/tests/functional/op_reference/string_tensor_unpack.cpp b/src/plugins/template/tests/functional/op_reference/string_tensor_unpack.cpp new file mode 100644 index 00000000000000..5719a17b0a6c84 --- /dev/null +++ b/src/plugins/template/tests/functional/op_reference/string_tensor_unpack.cpp @@ -0,0 +1,142 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/op/string_tensor_unpack.hpp" + +#include + +#include "base_reference_test.hpp" + +namespace { +struct StringTensorUnpackParams { + StringTensorUnpackParams(const reference_tests::Tensor& dataTensor, + const reference_tests::Tensor& beginsTensor, + const reference_tests::Tensor& endsTensor, + const reference_tests::Tensor& symbolsTensor) + : dataTensor(dataTensor), + beginsTensor(beginsTensor), + endsTensor(endsTensor), + symbolsTensor(symbolsTensor) {} + + reference_tests::Tensor dataTensor; + reference_tests::Tensor beginsTensor; + reference_tests::Tensor endsTensor; + reference_tests::Tensor symbolsTensor; +}; + +class ReferenceStringTensorUnpackV15LayerTest : public testing::TestWithParam, + public reference_tests::CommonReferenceTest { +protected: + void SetUp() override { + const auto& params = GetParam(); + function = CreateFunction(params); + inputData = {params.dataTensor.data}; + refOutData = {params.beginsTensor.data, params.endsTensor.data, params.symbolsTensor.data}; + } + +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "dShape=" << param.dataTensor.shape; + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const StringTensorUnpackParams& params) { + const auto data = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + const auto string_tensor_unpack = std::make_shared(data); + return std::make_shared(ov::OutputVector{string_tensor_unpack->outputs()}, + ov::ParameterVector{data}, + ov::op::util::VariableVector{}); + } +}; + +TEST_P(ReferenceStringTensorUnpackV15LayerTest, CompareWithRefs) { + Exec(); +} + +std::vector generateStringTensorUnpackParams() { + using ov::element::Type_t; + using reference_tests::Tensor; + const std::vector stringTensorUnpackParams{ + // simple 1D case + StringTensorUnpackParams( + Tensor({2}, ov::element::string, std::vector{"Intel", "OpenVINO"}), + Tensor({2}, ov::element::i32, std::vector{0, 5}), + Tensor({2}, ov::element::i32, std::vector{5, 13}), + Tensor({13}, + ov::element::u8, + std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x56, 0x49, 0x4e, 0x4f})), + // 2D strings with spaces and an empty string + StringTensorUnpackParams( + Tensor({1, 5}, + ov::element::string, + std::vector{"Intel Corp", " ", "Open VINO", "", "Artificial Intelligence"}), + Tensor({1, 5}, ov::element::i32, std::vector{0, 10, 13, 22, 22}), + Tensor({1, 5}, ov::element::i32, std::vector{10, 13, 22, 22, 45}), + Tensor({45}, ov::element::u8, std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x20, 0x43, 0x6f, 0x72, + 0x70, 0x20, 0x20, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x20, + 0x56, 0x49, 0x4e, 0x4f, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x49, 0x6e, 0x74, + 0x65, 0x6c, 0x6c, 0x69, 0x67, 0x65, 0x6e, 0x63, 0x65})), + // strings with special characters + StringTensorUnpackParams( + Tensor({3}, ov::element::string, std::vector{"In@tel", "Open#VINO", "A$I"}), + Tensor({3}, ov::element::i32, std::vector{0, 6, 15}), + Tensor({3}, ov::element::i32, std::vector{6, 15, 18}), + Tensor({18}, + ov::element::u8, + std::vector{0x49, + 0x6e, + 0x40, + 0x74, + 0x65, + 0x6c, + 0x4f, + 0x70, + 0x65, + 0x6e, + 0x23, + 0x56, + 0x49, + 0x4e, + 0x4f, + 0x41, + 0x24, + 0x49})), + // (2, 2, 2) data shape + StringTensorUnpackParams( + Tensor({2, 2, 2}, + ov::element::string, + std::vector< + std::string>{"Intel", "OpenVINO", "AI", "Edge", "Computer", "Vision", "Neural", "Networks"}), + Tensor({2, 2, 2}, ov::element::i32, std::vector{0, 5, 13, 15, 19, 27, 33, 39}), + Tensor({2, 2, 2}, ov::element::i32, std::vector{5, 13, 15, 19, 27, 33, 39, 47}), + Tensor({47}, + ov::element::u8, + std::vector{0x49, 0x6e, 0x74, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x56, 0x49, 0x4e, + 0x4f, 0x41, 0x49, 0x45, 0x64, 0x67, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x75, + 0x74, 0x65, 0x72, 0x56, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x4e, 0x65, 0x75, + 0x72, 0x61, 0x6c, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x73})), + // single, empty string + StringTensorUnpackParams(Tensor({1, 1, 1, 1}, ov::element::string, std::vector{""}), + Tensor({1, 1, 1, 1}, ov::element::i32, std::vector{0}), + Tensor({1, 1, 1, 1}, ov::element::i32, std::vector{0}), + Tensor({0}, ov::element::u8, std::vector{})), + // empty data + StringTensorUnpackParams(Tensor({0}, ov::element::string, std::vector{}), + Tensor({0}, ov::element::i32, std::vector{}), + Tensor({0}, ov::element::i32, std::vector{}), + Tensor({0}, ov::element::u8, std::vector{})), + }; + return stringTensorUnpackParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_StringTensorUnpack_With_Hardcoded_Refs, + ReferenceStringTensorUnpackV15LayerTest, + testing::ValuesIn(generateStringTensorUnpackParams()), + ReferenceStringTensorUnpackV15LayerTest::getTestCaseName); + +} // namespace diff --git a/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp b/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp index 73595dfd1dc72e..aa46f0cb1238b0 100644 --- a/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp +++ b/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp @@ -1913,6 +1913,22 @@ std::shared_ptr generate(const std::shared_ptr & return std::make_shared(results, ov::ParameterVector{data}, "Col2ImGraph"); } +std::shared_ptr generate(const std::shared_ptr &node) { + const auto data = std::make_shared(ov::element::string, ov::PartialShape{2}); + const auto StringTensorUnpackNode = std::make_shared(data); + ov::ResultVector results{std::make_shared(StringTensorUnpackNode)}; + return std::make_shared(results, ov::ParameterVector{data}, "StringTensorUnpackGraph"); +} + +std::shared_ptr generate(const std::shared_ptr &node) { + const auto begins = std::make_shared(ov::element::i32, ov::PartialShape{2}); + const auto ends = std::make_shared(ov::element::i32, ov::PartialShape{2}); + const auto symbols = std::make_shared(ov::element::u8, ov::PartialShape{5}); + const auto StringTensorPackNode = std::make_shared(begins, ends, symbols); + ov::ResultVector results{std::make_shared(StringTensorPackNode)}; + return std::make_shared(results, ov::ParameterVector{begins, ends, symbols}, "StringTensorPackGraph"); +} + std::shared_ptr generateRNNCellBase(const std::shared_ptr &node) { std::shared_ptr RNNCellBaseNode; if (ov::is_type(node)) { From 0be82e8e69b6b771eeccc64ecf7a47069181b790 Mon Sep 17 00:00:00 2001 From: Mateusz Mikolajczyk Date: Wed, 14 Aug 2024 06:54:14 +0200 Subject: [PATCH 002/117] [Spec][Opset15] Add SliceScatter-15 specification (#25642) ### Details: - *Add specification for SliceScatter-15* ### Tickets: - *138735* --------- Co-authored-by: Michal Lukaszewski --- .../movement/slice-scatter-15.rst | 191 ++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/movement/slice-scatter-15.rst diff --git a/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/movement/slice-scatter-15.rst b/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/movement/slice-scatter-15.rst new file mode 100644 index 00000000000000..125fd963cdb10d --- /dev/null +++ b/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/movement/slice-scatter-15.rst @@ -0,0 +1,191 @@ +.. {#openvino_docs_ops_movement_SliceScatter_15} + +SliceScatter +=============== + + +.. meta:: + :description: Learn about SliceScatter-15 - a data movement operation, which can be + performed on five required input tensors. + +**Versioned name**: *SliceScatter-15* + +**Category**: *Data movement* + +**Short description**: Creates copy of ``data`` tensor and applies elements from ``updates`` using slicing parametrized by ``start``, ``stop`` and ``step`` over ``axes`` dimensions. + +**Detailed description**: + +The operation produces a copy of ``data`` tensor and updates it using values specified by ``updates`` at specific slices parametrized by ``start``, ``stop`` and ``step`` values over corresponding ``axes`` dimensions. +The output shape and type is the same as ``data``. Number of elements for ``start``, ``stop``, ``step`` and ``axes`` is required to be equal. Values in ``axes`` are required to be unique. + +Operator SliceScatter-15 is an equivalent to following NumPy snippet: + +.. code-block:: py + + def slice_scatter_15( + data: np.ndarray, + updates: np.ndarray, + start: List[int], + stop: List[int], + step: List[int], + axes: Optional[List[int]] = None, + ): + out = np.copy(data) + if axes is None: + axes = list(range(len(start))) + slice_list = [slice(None)] * data.ndim + for slice_start, slice_stop, slice_step, slice_axis in zip(start, stop, step, axes): + slice_list[slice_axis] = slice(slice_start, slice_stop, slice_step) + out[tuple(slice_list)] = updates + return out + +**Attributes**: *SliceScatter* does not have attributes. + +**Inputs**: + +* **1**: ``data`` tensor of arbitrary rank ``r`` >= 1 and of type *T*. **Required.** + +* **2**: ``updates`` - tensor of type *T* and same shape as ``data`` except axes set by ``axes`` where dimensions should be equal to the length of corresponding update slices. **Required.** + +* **3**: ``start`` - 1D tensor of type *T_IND*. + + Defines the starting coordinate of the update slice in the ``data`` tensor at ``axes`` dimension. + A negative index value represents counting elements from the end of that dimension. + A value larger than the size of a dimension is silently clamped. **Required.** + +* **4**: ``stop`` - 1D tensor of type *T_IND*. + + Defines the coordinate of the opposite vertex of the update slice, or where the update slice ends. + Stop indexes are exclusive, which means values lying on the ending edge are not updated. + A value larger than the size of a dimension is silently clamped. + To create slice to the end of a dimension of unknown size ``INT_MAX`` + may be used (or ``INT_MIN`` if slicing backwards). **Required.** + +* **5**: ``step`` - 1D tensor of type *T_IND*. + + Integer value that specifies the increment between each index used in slicing. + Value cannot be ``0``, negative value indicates slicing backwards. **Required.** + +* **6**: ``axes`` - 1D tensor of type *T_AXIS*. + + Optional 1D tensor indicating which dimensions the values in ``start``, ``stop`` and ``step`` apply to. + Negative value means counting dimensions from the end. The range is ``[-r, r - 1]``, where ``r`` is the rank of the ``data`` input tensor. + Values are required to be unique. + Default value: ``[0, 1, 2, ..., start.shape[0] - 1]``. **Optional.** + +Number of elements in ``start``, ``stop``, ``step``, and ``axes`` inputs are required to be equal. + +**Outputs**: + +* **1**: tensor with shape equal to ``data`` tensor of the type *T*. + +**Types** + +* *T*: any numeric type. +* *T_IND*: any supported integer type. +* *T_AXIS*: any supported integer type. + +**Example** + +*Example 1: Fill slice over axis==0.* + +.. code-block:: xml + + + + + 2 + 5 + + + 1 + 5 + + + 1 + + + 1 + + + 1 + + + 1 + + + + + 2 + 5 + + + + +*Example 2: Update every second value over axis==1, clamp values of start and stop.* + +.. code-block:: xml + + + + + 2 + 5 + + + 2 + 3 + + + 1 + + + 1 + + + 1 + + + 1 + + + + + 2 + 5 + + + + +*Example 3: Update every second value over both axes with different slice starts.* + +.. code-block:: xml + + + + + 3 + 5 + + + 2 + 2 + + + 1 + + + 1 + + + 1 + + + + + 3 + 5 + + + From fe285bf823b58985639afeaec193963c49ec6a14 Mon Sep 17 00:00:00 2001 From: Egor Duplenskii Date: Wed, 14 Aug 2024 08:47:47 +0200 Subject: [PATCH 003/117] [THIRDPARTY] Fix gtest sha (#26048) Use a merged one from the remote branch: - https://github.com/openvinotoolkit/googletest/commits/v1.10.x-openvino/ instead of a commit from review: - https://github.com/openvinotoolkit/googletest/pull/4/commits Co-authored-by: Ilya Lavrenov --- thirdparty/gtest/gtest | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/thirdparty/gtest/gtest b/thirdparty/gtest/gtest index f163ae4a3a35f6..99760ac1776430 160000 --- a/thirdparty/gtest/gtest +++ b/thirdparty/gtest/gtest @@ -1 +1 @@ -Subproject commit f163ae4a3a35f61626b7d7f5b9aa85d799e10b84 +Subproject commit 99760ac1776430f3df65947992bf4e8ebc0d7660 From 25eac0455bd982f24484aa9ce7b5b71556f02a74 Mon Sep 17 00:00:00 2001 From: Zhiyuan Tan <66934674+BHbean@users.noreply.github.com> Date: Wed, 14 Aug 2024 15:42:50 +0800 Subject: [PATCH 004/117] [RISCV64] [GSoC] Integrate SHL eltwise ops into OV (#25674) ### Details: - *integrate eltwise ops from `shl` lib: `Add`, `Sub`, `Mul`, `Div`, `Maximum`, `Minimum`, `Exp`, `ReLu`, `LeakyReLu` and `PReLu`* - *PR to SHL repository: https://github.com/openvinotoolkit/shl/pull/5* ### Tickets: - *N/A* --- src/plugins/intel_cpu/src/nodes/eltwise.cpp | 48 +++- src/plugins/intel_cpu/src/nodes/eltwise.h | 4 +- .../src/nodes/executors/eltwise_list.cpp | 1 + .../src/nodes/executors/eltwise_list.hpp | 3 + .../intel_cpu/src/nodes/executors/shl/shl.hpp | 128 +++++++++- .../src/nodes/executors/shl/shl_eltwise.cpp | 234 ++++++++++++++++++ .../src/nodes/executors/shl/shl_eltwise.hpp | 52 ++++ .../executors/shl/shl_fullyconnected.cpp | 4 +- .../src/utils/debug_capabilities.cpp | 2 +- .../intel_cpu/tests/functional/CMakeLists.txt | 15 +- .../functional/cmake/specific_tests.cmake | 6 +- .../functional/cmake/target_per_test.cmake | 3 + .../single_layer_tests/classes/activation.cpp | 9 + .../single_layer_tests/classes/eltwise.cpp | 9 + .../single_layer_tests/classes/extremum.cpp | 2 + .../src/common/concat_conv_sum_inplace.cpp | 3 + .../src/common/eltwise_caching.cpp | 10 +- .../skip_tests_config.cpp | 8 + .../utils/riscv64/filter_cpu_info.cpp | 84 +++++++ src/plugins/intel_cpu/thirdparty/shl | 2 +- 20 files changed, 590 insertions(+), 37 deletions(-) create mode 100644 src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.cpp create mode 100644 src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.hpp create mode 100644 src/plugins/intel_cpu/tests/functional/utils/riscv64/filter_cpu_info.cpp diff --git a/src/plugins/intel_cpu/src/nodes/eltwise.cpp b/src/plugins/intel_cpu/src/nodes/eltwise.cpp index 7005cc8851591a..940185453746eb 100644 --- a/src/plugins/intel_cpu/src/nodes/eltwise.cpp +++ b/src/plugins/intel_cpu/src/nodes/eltwise.cpp @@ -2317,6 +2317,16 @@ void Eltwise::initSupportedPrimitiveDescriptors() { } outputPrecision = filterPrecision(outputPrecision, forcedPrec); } else { +#endif +#if defined(OV_CPU_WITH_SHL) + if (ShlEltwiseExecutor::isEltwiseAlgorithmSupported(getAlgorithm())) { + // SHL implementation supports only identical precisions on inputs/outputs and only FP32 for now + const ov::element::Type forcedPrec = ov::element::f32; + for (size_t i = 0; i < inputPrecisions.size(); i++) { + inputPrecisions[i] = forcedPrec; + } + outputPrecision = forcedPrec; + } else { #endif auto filterPrecision = [&](const ov::element::Type& prc) { if (implType == EltwiseImplType::reference) { @@ -2344,6 +2354,9 @@ void Eltwise::initSupportedPrimitiveDescriptors() { inputPrecisions[i] = filterPrecision(inputPrecisions[i]); } outputPrecision = filterPrecision(outputPrecision); +#if defined(OV_CPU_WITH_SHL) + } +#endif #if defined(OV_CPU_WITH_ACL) } #endif @@ -2364,7 +2377,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() { Blocked }; - auto initDesc = [&] (LayoutType lt, const bool useAclExecutor = false, const bool useJit = false) -> NodeDesc { + auto initDesc = [&] (LayoutType lt, const bool useEltwiseExecutor = false, const bool useJit = false) -> NodeDesc { auto createMemoryDesc = [lt](const Shape &shape, ov::element::Type prc, size_t offset) -> std::shared_ptr { const auto &dims = shape.getDims(); if (lt == ChannelsFirst && shape.getRank() != 1) { @@ -2438,7 +2451,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() { config.outConfs.push_back(portConfig); - if (useAclExecutor || useJit) { + if (useEltwiseExecutor || useJit) { impl_desc_type impl_type; #if defined (OPENVINO_ARCH_ARM64) if (useJit) { @@ -2512,7 +2525,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() { inputNum = getParentEdges().size(); currentInBlkDims.resize(inputNum); -#if defined (OV_CPU_WITH_ACL) +#if defined(OV_CPU_WITH_ACL) if (useAcl || useJit) { eltwiseAttrs = {algorithm, alpha, beta, gamma}; @@ -2533,12 +2546,28 @@ void Eltwise::initSupportedPrimitiveDescriptors() { addDesc(supportedPrimitiveDescriptors, ChannelsFirst); } - canUseAclExecutor = !supportedPrimitiveDescriptors.empty() && !useJit; + canUseEltwiseExecPtr = !supportedPrimitiveDescriptors.empty() && !useJit; if (!supportedPrimitiveDescriptors.empty()) return; } #endif +#if defined(OV_CPU_WITH_SHL) + eltwiseAttrs = {algorithm, alpha, beta, gamma}; + + auto addDesc = [&initDesc](std::vector& supportedPrimitiveDescriptors, const LayoutType layoutType) { + auto nodeDesc = initDesc(layoutType, true, false); + if (nodeDesc.getExecutorFactory()) + supportedPrimitiveDescriptors.emplace_back(nodeDesc); + }; + + addDesc(supportedPrimitiveDescriptors, Planar); + + canUseEltwiseExecPtr = !supportedPrimitiveDescriptors.empty(); + if (!supportedPrimitiveDescriptors.empty()) + return; +#endif + if (isChannelsFirstApplicable) supportedPrimitiveDescriptors.emplace_back(initDesc(ChannelsFirst)); if (isBlockedApplicable) @@ -2570,7 +2599,7 @@ void Eltwise::createPrimitive() { } void Eltwise::prepareParams() { - if (canUseAclExecutor) { + if (canUseEltwiseExecPtr) { std::vector srcMemoryDescs; for (size_t i = 0; i < getParentEdges().size(); i++) { srcMemoryDescs.push_back(getSrcMemoryAtPort(i)->getDescPtr()); @@ -2579,8 +2608,8 @@ void Eltwise::prepareParams() { dstMemoryDescs.push_back(getDstMemoryAtPort(0)->getDescPtr()); auto selectedPD = getSelectedPrimitiveDescriptor(); - aclExecPtr = selectedPD->getExecutorFactoryAs()->makeExecutor(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs, {}); - selectedPD->setImplementationType(aclExecPtr->getImplType()); + eltwiseExecPtr = selectedPD->getExecutorFactoryAs()->makeExecutor(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs, {}); + selectedPD->setImplementationType(eltwiseExecPtr->getImplType()); return; } @@ -2748,7 +2777,7 @@ void Eltwise::execute(dnnl::stream strm) { args_ptrs.dst_offsets = execParams.outOffsets.data(); } execPtr->exec(args_ptrs, dims_out); - } else if (aclExecPtr) { + } else if (eltwiseExecPtr) { std::vector srcMemory; for (size_t i = 0; i < getParentEdges().size(); i++) { srcMemory.push_back(getSrcMemoryAtPort(i)); @@ -2756,7 +2785,7 @@ void Eltwise::execute(dnnl::stream strm) { std::vector dstMemory; dstMemory.push_back(getDstMemoryAtPort(0)); - aclExecPtr->exec(srcMemory, dstMemory, fqDataPtrs.data()); + eltwiseExecPtr->exec(srcMemory, dstMemory, fqDataPtrs.data()); } else { OPENVINO_THROW("Can't execute eltwise node with name: ", getName(), ". Primitive isn't created"); } @@ -3154,7 +3183,6 @@ ov::element::Type Eltwise::getRuntimePrecision() const { return getMaxPrecision(inputPrecisions); } - } // namespace node } // namespace intel_cpu } // namespace ov diff --git a/src/plugins/intel_cpu/src/nodes/eltwise.h b/src/plugins/intel_cpu/src/nodes/eltwise.h index fe148b097df8a6..6013ce732ee5fc 100644 --- a/src/plugins/intel_cpu/src/nodes/eltwise.h +++ b/src/plugins/intel_cpu/src/nodes/eltwise.h @@ -186,9 +186,9 @@ class Eltwise : public Node { void appendMemory(const std::vector &data, MemoryPtr &memPtr, std::vector& postOpsMem); void appendMemory(const std::vector &data, MemoryPtr &memPtr, std::vector& postOpsMem); - bool canUseAclExecutor = false; + bool canUseEltwiseExecPtr = false; EltwiseAttrs eltwiseAttrs; - std::shared_ptr aclExecPtr = nullptr; + std::shared_ptr eltwiseExecPtr = nullptr; }; class eltwise_precision_helper { diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp index 4c2fbecb297ddc..1bd6647310d387 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp @@ -10,6 +10,7 @@ namespace intel_cpu { const std::vector& getEltwiseExecutorsList() { static std::vector descs = { OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared()) + OV_CPU_INSTANCE_SHL(ExecutorType::Shl, std::make_shared()) }; return descs; diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp index ad3716fe2c458c..618e3499dc10a7 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp +++ b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp @@ -11,6 +11,9 @@ #include "aarch64/jit_eltwise.hpp" #include "acl/acl_eltwise.hpp" #endif +#if defined(OV_CPU_WITH_SHL) +#include "shl/shl_eltwise.hpp" +#endif #include "onednn/iml_type_mapper.h" #include "common/primitive_cache.hpp" diff --git a/src/plugins/intel_cpu/src/nodes/executors/shl/shl.hpp b/src/plugins/intel_cpu/src/nodes/executors/shl/shl.hpp index f900f24569dcc0..862cd94800025a 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/shl/shl.hpp +++ b/src/plugins/intel_cpu/src/nodes/executors/shl/shl.hpp @@ -163,6 +163,42 @@ struct ShlTensor : public ShlStructure { OPENVINO_ASSERT(get()->dim_count < MAX_DIM, "Shl supports shapes with rank less or equal to 8"); for (int i = 0; i < get()->dim_count; ++i) get()->dim[i] = static_cast(shape[i]); + }; +}; + +// virtual base class for different kinds of params +struct IShlParams { +public: + virtual ~IShlParams() = default; + virtual void* get(bool allow_empty = false) const = 0; +}; + +template > +struct ShlParams : public ShlStructure, public IShlParams { + ShlParams() { + T params = static_cast(csinn_alloc_params(sizeof(typename std::remove_pointer::type), nullptr)); + OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_params"); + this->reset(params); + } + + ShlParams(const ShlSession& session) { + T params = static_cast(csinn_alloc_params(sizeof(typename std::remove_pointer::type), session.get())); + OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_params"); + this->reset(params); + } + + ShlParams(const ShlSession& session, csinn_api_enum api) : ShlParams(session) { + setAPI(api); + } + + void* get(bool allow_empty = false) const override { + return this->ShlStructure::get(allow_empty); + } + +private: + void setAPI(csinn_api_enum api) { + auto params = static_cast::type*>(this->get()); + params->base.api = api; } }; @@ -172,18 +208,90 @@ struct ShlStructureTraits { return csinn_free_params(p); } }; -struct ShlFCParams : public ShlStructure { - ShlFCParams() { - csinn_fc_params* params = static_cast(csinn_alloc_params(sizeof(csinn_fc_params), nullptr)); - OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_fc_params"); - reset(params); +struct ShlFCParams : public ShlParams { + using ShlParams::ShlParams; +}; + +template <> +struct ShlStructureTraits { + static void destructor(csinn_diso_params* p) { + return csinn_free_params(p); } +}; +struct ShlDisoParams : public ShlParams { + using ShlParams::ShlParams; +}; - ShlFCParams(const ShlSession& session, csinn_api_enum api) { - csinn_fc_params* params = static_cast(csinn_alloc_params(sizeof(csinn_fc_params), session.get())); - OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_fc_params"); - params->base.api = api; - reset(params); +template <> +struct ShlStructureTraits { + static void destructor(csinn_siso_params* p) { + return csinn_free_params(p); + } +}; +struct ShlSisoParams : public ShlParams { + using ShlParams::ShlParams; +}; + +template <> +struct ShlStructureTraits { + static void destructor(csinn_relu_params* p) { + return csinn_free_params(p); + } +}; +struct ShlReluParams : public ShlParams { + using ShlParams::ShlParams; + + ShlReluParams(float alpha) : ShlParams() { + auto params = static_cast(this->get()); + params->n = alpha; + } + + ShlReluParams(const ShlSession& session, float alpha) : ShlParams(session) { + auto params = static_cast(this->get()); + params->n = alpha; + } + + ShlReluParams(const ShlSession& session, csinn_api_enum api, float alpha) : ShlParams(session, api) { + auto params = static_cast(this->get()); + params->n = alpha; + } +}; + +template <> +struct ShlStructureTraits { + static void destructor(csinn_prelu_params* p) { + return csinn_free_params(p); + } +}; +struct ShlPReluParams : public ShlParams { + using ShlParams::ShlParams; +}; + +template <> +struct ShlStructureTraits { + static void destructor(csinn_clip_params* p) { + return csinn_free_params(p); + } +}; +struct ShlClipParams : public ShlParams { + using ShlParams::ShlParams; + + ShlClipParams(float min, float max) : ShlParams() { + auto params = static_cast(this->get()); + params->min_value = min; + params->max_value = max; + } + + ShlClipParams(const ShlSession& session, float min, float max) : ShlParams(session) { + auto params = static_cast(this->get()); + params->min_value = min; + params->max_value = max; + } + + ShlClipParams(const ShlSession& session, csinn_api_enum api, float min, float max) : ShlParams(session, api) { + auto params = static_cast(this->get()); + params->min_value = min; + params->max_value = max; } }; diff --git a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.cpp b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.cpp new file mode 100644 index 00000000000000..9506fa74505636 --- /dev/null +++ b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.cpp @@ -0,0 +1,234 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "shl_eltwise.hpp" +#include "shl_utils.hpp" +#include "csinn/csi_nn.h" +#include "utils/debug_capabilities.h" + +namespace ov { +namespace intel_cpu { + +inline void log_unsupported_prec(const std::vector& srcDescs, + const std::vector& dstDescs, + const Algorithm eltwiseAlgorithm) { + std::string srcPrec; + for (size_t i = 0; i < srcDescs.size(); i++) { + srcPrec += srcDescs[i]->getPrecision().to_string() + " "; + } + DEBUG_LOG(algToString(eltwiseAlgorithm), ": provided combination of src precisions: [", srcPrec, + "] and dst precision: ", dstDescs[0]->getPrecision().to_string(), " is not supported"); +} + +bool ShlEltwiseExecutor::isEltwiseAlgorithmSupported(Algorithm algorithm) { + if (one_of(algorithm, Algorithm::EltwiseAdd, + Algorithm::EltwiseSubtract, + Algorithm::EltwiseMultiply, + Algorithm::EltwiseDivide, + Algorithm::EltwiseMaximum, + Algorithm::EltwiseMinimum, + Algorithm::EltwiseExp, + Algorithm::EltwiseClamp, + Algorithm::EltwiseRelu, + Algorithm::EltwisePrelu)) { + return true; + } + return false; +} + +bool ShlEltwiseExecutorBuilder::isSupported(const EltwiseAttrs& eltwiseAttrs, + const std::vector& srcDescs, + const std::vector& dstDescs) const { + if (!ShlEltwiseExecutor::isEltwiseAlgorithmSupported(eltwiseAttrs.algorithm)) { + DEBUG_LOG("Eltwise algorithm ", algToString(eltwiseAttrs.algorithm), " is not supported"); + return false; + } + + constexpr auto supported_prec = ov::element::f32; + auto is_precision_supported = [supported_prec](const MemoryDescPtr& desc) { return desc->getPrecision() == supported_prec; }; + if (!(std::all_of(srcDescs.cbegin(), srcDescs.cend(), is_precision_supported) && + std::all_of(dstDescs.cbegin(), dstDescs.cend(), is_precision_supported))) { + DEBUG_LOG("ShlEltwise supports only f32"); + return false; + } + + for (const auto& srcDesc : srcDescs) { + csinn_layout_enum supportedLayout = getShlDataLayoutByMemoryDesc(srcDesc); + switch (eltwiseAttrs.algorithm) { + case Algorithm::EltwisePrelu: + // SHL PRelu op only supports these two kinds of layout + if (!(supportedLayout == csinn_layout_enum::CSINN_LAYOUT_NC1HWC0 || supportedLayout == csinn_layout_enum::CSINN_LAYOUT_NCHW)) { + DEBUG_LOG("src descriptor layout is unsupported by SHL Prelu op: ", srcDesc->serializeFormat()); + return false; + } + break; + default: + if (supportedLayout == csinn_layout_enum::CSINN_LAYOUT_NULL) { + DEBUG_LOG("src descriptor layout is unsupported by SHL: ", srcDesc->serializeFormat()); + return false; + } + continue; + } + } + for (const auto& dstDesc : dstDescs) { + if (getShlDataLayoutByMemoryDesc(dstDesc) == csinn_layout_enum::CSINN_LAYOUT_NULL) { + DEBUG_LOG("dst descriptor layout is unsupported by SHL: ", dstDesc->serializeFormat()); + return false; + } + } + + return true; +} + +ShlEltwiseExecutor::ShlEltwiseExecutor(const ExecutorContext::CPtr context) : EltwiseExecutor(context) {} + +bool ShlEltwiseExecutor::init(const EltwiseAttrs &eltwiseAttrs, + const std::vector &srcDescs, + const std::vector &dstDescs, + const std::vector &postOps) { + if (!postOps.empty()) { return false; } + shlEltwiseAttrs = eltwiseAttrs; + + srcTensors = std::vector(srcDescs.size()); + dstTensors = std::vector(dstDescs.size()); + + // Allocate Shl session + sess = ShlSession(); + + for (size_t i = 0; i < srcDescs.size(); i++) { + srcTensors[i] = ShlTensor(sess, precisionToShlDataType(srcDescs[i]->getPrecision()), getShlDataLayoutByMemoryDesc(srcDescs[i]), srcDescs[i]->getShape().getStaticDims()); + } + for (size_t i = 0; i < dstDescs.size(); i++) { + dstTensors[i] = ShlTensor(sess, precisionToShlDataType(dstDescs[i]->getPrecision()), getShlDataLayoutByMemoryDesc(dstDescs[i]), dstDescs[i]->getShape().getStaticDims()); + } + + std::function initFunc = nullptr; + enum csinn_api_enum shl_api = CSINN_RVV; + switch (shlEltwiseAttrs.algorithm) { + case Algorithm::EltwiseAdd: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_add_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_add(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseSubtract: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_sub_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_sub(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseMultiply: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_mul_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_mul(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseDivide: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_div_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_div(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseMaximum: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_maximum_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_maximum(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseMinimum: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_minimum_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_minimum(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseExp: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_exp_init(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_exp(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseClamp: + params = ov::intel_cpu::make_unique(sess, shl_api, eltwiseAttrs.alpha, eltwiseAttrs.beta); + initFunc = [&]() { + return csinn_clip_init(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_clip(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + case Algorithm::EltwiseRelu: + if (shlEltwiseAttrs.alpha == 0) { + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_relu_init(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_relu(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + } else { + params = ov::intel_cpu::make_unique(sess, shl_api, eltwiseAttrs.alpha); + initFunc = [&]() { + return csinn_leaky_relu_init(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_leaky_relu(srcTensors[0].get(), dstTensors[0].get(), static_cast(params->get())); + }; + } + break; + case Algorithm::EltwisePrelu: + params = ov::intel_cpu::make_unique(sess, shl_api); + initFunc = [&]() { + return csinn_prelu_init(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + shlExecFunc = [&]() { + return csinn_prelu(srcTensors[0].get(), srcTensors[1].get(), dstTensors[0].get(), static_cast(params->get())); + }; + break; + default: + OPENVINO_THROW("Unsupported operation type for SHL Eltwise executor: ", + static_cast(shlEltwiseAttrs.algorithm)); + } + + return initFunc != nullptr && initFunc() == CSINN_TRUE; +} + +void ShlEltwiseExecutor::exec(const std::vector &src, + const std::vector &dst, + const void *post_ops_data_) { + for (size_t i = 0; i < src.size(); i++) { + srcTensors[i].setData(src[i]->getData()); + } + for (size_t i = 0; i < dst.size(); i++) { + dstTensors[i].setData(dst[i]->getData()); + } + + OPENVINO_ASSERT(shlExecFunc != nullptr && shlExecFunc() == CSINN_TRUE, + "ShlEltwiseExecutor: failed to execute"); + + return; +} + +} // namespace intel_cpu +} // namespace ov \ No newline at end of file diff --git a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.hpp b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.hpp new file mode 100644 index 00000000000000..fba8a90bd76e11 --- /dev/null +++ b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_eltwise.hpp @@ -0,0 +1,52 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// +#pragma once + +#include "shl.hpp" +#include "cpu_memory.h" +#include "nodes/executors/eltwise.hpp" +#include + +namespace ov { +namespace intel_cpu { + +class ShlEltwiseExecutor : public EltwiseExecutor { +public: + explicit ShlEltwiseExecutor(const ExecutorContext::CPtr context); + static bool isEltwiseAlgorithmSupported(Algorithm algorithm); + + bool init(const EltwiseAttrs& eltwiseAttrs, + const std::vector& srcDescs, + const std::vector& dstDescs, + const std::vector& postOps) override; + + void exec(const std::vector& src, + const std::vector& dst, + const void *post_ops_data_) override; + + impl_desc_type getImplType() const override { + return impl_desc_type::shl; + } + +private: + EltwiseAttrs shlEltwiseAttrs{}; + ShlSession sess = {}; + std::vector srcTensors, dstTensors; + std::unique_ptr params; + std::function shlExecFunc; +}; + +class ShlEltwiseExecutorBuilder : public EltwiseExecutorBuilder { +public: + bool isSupported(const EltwiseAttrs& eltwiseAttrs, + const std::vector& srcDescs, + const std::vector& dstDescs) const override; + + EltwiseExecutorPtr makeExecutor(const ExecutorContext::CPtr context) const override { + return std::make_shared(context); + } +}; + +} // namespace intel_cpu +} // namespace ov \ No newline at end of file diff --git a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp index 829502cefdcd7d..ede6d7511cc62e 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp @@ -112,7 +112,7 @@ ShlFCExecutor::ShlFCExecutor(const FCAttrs& attrs, // Init FC params params = ShlFCParams(sess, CSINN_RVV); - OPENVINO_ASSERT(csinn_fullyconnected_init(src.get(), dst.get(), wei.get(), bias.get(), params.get()) == CSINN_TRUE, + OPENVINO_ASSERT(csinn_fullyconnected_init(src.get(), dst.get(), wei.get(), bias.get(), static_cast(params.get())) == CSINN_TRUE, "ShlFCExecutor: failed to init FC"); } @@ -132,7 +132,7 @@ void ShlFCExecutor::execute(const MemoryArgs& memory) { bias.setData(memory.at(ARG_BIAS)->getData()); } - OPENVINO_ASSERT(csinn_fullyconnected(src.get(), dst.get(), wei.get(), bias.get(), params.get()) == CSINN_TRUE, + OPENVINO_ASSERT(csinn_fullyconnected(src.get(), dst.get(), wei.get(), bias.get(), static_cast(params.get())) == CSINN_TRUE, "ShlFCExecutor: failed to execute"); } diff --git a/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp b/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp index 0a400c5edd4f2d..230705af88bb06 100644 --- a/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp +++ b/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp @@ -103,7 +103,7 @@ void DebugLogEnabled::break_at(const std::string & log) { std::cout << "[ DEBUG ] " << " Debug log breakpoint hit" << std::endl; #if defined(_MSC_VER) __debugbreak(); -#elif defined(__APPLE__) || defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64) +#elif defined(__APPLE__) || defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_RISCV64) __builtin_trap(); #else asm("int3"); diff --git a/src/plugins/intel_cpu/tests/functional/CMakeLists.txt b/src/plugins/intel_cpu/tests/functional/CMakeLists.txt index 64fd58448749e8..dada93a41f7875 100644 --- a/src/plugins/intel_cpu/tests/functional/CMakeLists.txt +++ b/src/plugins/intel_cpu/tests/functional/CMakeLists.txt @@ -39,21 +39,26 @@ endif() if(NOT RISCV64) list(APPEND EXCLUDED_SOURCE_PATHS - ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/riscv64) + ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/riscv64 + ${CMAKE_CURRENT_SOURCE_DIR}/utils/riscv64) elseif(NOT OV_CPU_WITH_SHL) list(APPEND EXCLUDED_SOURCE_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/riscv64/shl) endif() + +if(NOT (X86 OR X86_64)) + list(APPEND EXCLUDED_SOURCE_PATHS + ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/x64 + ${CMAKE_CURRENT_SOURCE_DIR}/custom/subgraph_tests/src/x64 + ${CMAKE_CURRENT_SOURCE_DIR}/utils/x64) +endif() + if(NOT (ARM OR AARCH64)) list(APPEND EXCLUDED_SOURCE_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/arm ${CMAKE_CURRENT_SOURCE_DIR}/custom/subgraph_tests/src/arm ${CMAKE_CURRENT_SOURCE_DIR}/utils/arm) else() - list(APPEND EXCLUDED_SOURCE_PATHS - ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/x64 - ${CMAKE_CURRENT_SOURCE_DIR}/custom/subgraph_tests/src/x64 - ${CMAKE_CURRENT_SOURCE_DIR}/utils/x64) # temporary disable all custom tests for ARM list(APPEND EXCLUDED_SOURCE_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests diff --git a/src/plugins/intel_cpu/tests/functional/cmake/specific_tests.cmake b/src/plugins/intel_cpu/tests/functional/cmake/specific_tests.cmake index 8c5df4ab123efd..3d4c19eae5e154 100644 --- a/src/plugins/intel_cpu/tests/functional/cmake/specific_tests.cmake +++ b/src/plugins/intel_cpu/tests/functional/cmake/specific_tests.cmake @@ -39,7 +39,11 @@ if(DEFINED ENABLE_CPU_SUBSET_TESTS_PATH) if(NOT (ARM OR AARCH64)) list(APPEND EXCLUDED_SOURCE_PATHS_FOR_SUBSET_TEST ${CMAKE_CURRENT_SOURCE_DIR}/utils/arm) -elseif(NOT X86_64) +endif() +if(NOT RISCV64) + list(APPEND EXCLUDED_SOURCE_PATHS_FOR_SUBSET_TEST ${CMAKE_CURRENT_SOURCE_DIR}/utils/riscv64) +endif() +if(NOT X86_64) list(APPEND EXCLUDED_SOURCE_PATHS_FOR_SUBSET_TEST ${CMAKE_CURRENT_SOURCE_DIR}/utils/x64) endif() diff --git a/src/plugins/intel_cpu/tests/functional/cmake/target_per_test.cmake b/src/plugins/intel_cpu/tests/functional/cmake/target_per_test.cmake index 190466f8f4aa71..057869a864d87b 100644 --- a/src/plugins/intel_cpu/tests/functional/cmake/target_per_test.cmake +++ b/src/plugins/intel_cpu/tests/functional/cmake/target_per_test.cmake @@ -23,6 +23,9 @@ if(X86_64) elseif(ARM OR AARCH64) list(APPEND REQUIRED_OBJECT_FILES ${CMAKE_CURRENT_SOURCE_DIR}/utils/arm/filter_cpu_info.cpp) +elseif(RISCV64) + list(APPEND REQUIRED_OBJECT_FILES + ${CMAKE_CURRENT_SOURCE_DIR}/utils/riscv64/filter_cpu_info.cpp) endif() file(GLOB LIST_OF_TEST_FILES ${TEST_DIR}/*.cpp) diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp index 4ffff2aa0de94f..4d47eb9ed2b78b 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp @@ -204,6 +204,15 @@ std::string ActivationLayerCPUTest::getPrimitiveType(const utils::ActivationType return "ref"; } return "acl"; +#elif defined(OV_CPU_WITH_SHL) + if ((activation_type == utils::ActivationTypes::Relu) || + (activation_type == utils::ActivationTypes::PReLu) || + (activation_type == utils::ActivationTypes::Exp) || + (activation_type == utils::ActivationTypes::Clamp)) { + return "shl"; + } else { + return "ref"; + } #else return CPUTestsBase::getPrimitiveType(); #endif diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp index 2378bf82ede20e..8541928c244cd1 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp @@ -267,6 +267,15 @@ std::string EltwiseLayerCPUTest::getPrimitiveType(const utils::EltwiseTypes& elt } else { return "acl"; } +#elif defined(OV_CPU_WITH_SHL) + if ((eltwise_type == utils::EltwiseTypes::ADD) || + (eltwise_type == utils::EltwiseTypes::SUBTRACT) || + (eltwise_type == utils::EltwiseTypes::MULTIPLY) || + (eltwise_type == utils::EltwiseTypes::DIVIDE)) { + return "shl"; + } else { + return "ref"; + } #else return CPUTestsBase::getPrimitiveType(); #endif diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/extremum.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/extremum.cpp index 2cc3b2dd1d91ff..714e1ef0cbe31b 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/extremum.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/extremum.cpp @@ -82,6 +82,8 @@ std::string ExtremumLayerCPUTest::getPrimitiveType() { return "jit"; #endif return "acl"; +#elif defined(OV_CPU_WITH_SHL) + return "shl"; #else return CPUTestsBase::getPrimitiveType(); #endif diff --git a/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/concat_conv_sum_inplace.cpp b/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/concat_conv_sum_inplace.cpp index 9538250832059d..7000812e6f672e 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/concat_conv_sum_inplace.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/concat_conv_sum_inplace.cpp @@ -48,9 +48,12 @@ class ReLuConcatConvSumInPlaceTest : virtual public SubgraphBaseStaticTest { const size_t convOutChannels = 64; #if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) const auto targetFormat = with_cpu_x86_avx512_core() ? nChw16c : nChw8c; +#elif defined(OV_CPU_WITH_SHL) + const auto targetFormat = nchw; #else const auto targetFormat = nhwc; #endif + ov::ParameterVector inputParams{std::make_shared(ov::element::f32, inputShape), std::make_shared(ov::element::f32, inputShape)}; auto Relu1 = std::make_shared(inputParams[0]); diff --git a/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/eltwise_caching.cpp b/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/eltwise_caching.cpp index 1326e4060a5476..4f59425a0e8a93 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/eltwise_caching.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/eltwise_caching.cpp @@ -628,7 +628,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_EltwiseCache_3D_nspc_dyn, EltwiseCacheTest, ::testing::Values(true), ::testing::Values(false), // CPU Plugin doesn't support non-planar layout for Subgraphs ::testing::Values(ov::test::utils::DEVICE_CPU), - ::testing::Values(cpuParams_3D_nspc)), + ::testing::ValuesIn(filterCPUSpecificParams({cpuParams_3D_nspc}))), EltwiseCacheTest::getTestCaseName); @@ -898,7 +898,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_EltwiseCache_4D_nspc_dyn, EltwiseCacheTest, ::testing::Values(true), ::testing::Values(false), // CPU Plugin doesn't support non-planar layout for Subgraphs ::testing::Values(ov::test::utils::DEVICE_CPU), - ::testing::Values(cpuParams_4D_nspc)), + ::testing::ValuesIn(filterCPUSpecificParams({cpuParams_4D_nspc}))), EltwiseCacheTest::getTestCaseName); std::vector inputShapes_4D_nspc_collapse_dyn = { @@ -958,7 +958,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_EltwiseCache_4D_nspc_collapse_dyn, EltwiseCacheTe ::testing::Values(true), ::testing::Values(false), // CPU Plugin doesn't support non-planar layout for Subgraphs ::testing::Values(ov::test::utils::DEVICE_CPU), - ::testing::Values(cpuParams_4D_nspc)), + ::testing::ValuesIn(filterCPUSpecificParams({cpuParams_4D_nspc}))), EltwiseCacheTest::getTestCaseName); @@ -1229,7 +1229,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_EltwiseCache_5D_nspc_dyn, EltwiseCacheTest, ::testing::Values(true), ::testing::Values(false), // CPU Plugin doesn't support non-planar layout for Subgraphs ::testing::Values(ov::test::utils::DEVICE_CPU), - ::testing::Values(cpuParams_5D_nspc)), + ::testing::ValuesIn(filterCPUSpecificParams({cpuParams_5D_nspc}))), EltwiseCacheTest::getTestCaseName); std::vector inputShapes_5D_nspc_collapse_dyn = { @@ -1289,7 +1289,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_EltwiseCache_5D_nspc_collapse_dyn, EltwiseCacheTe ::testing::Values(true), ::testing::Values(false), // CPU Plugin doesn't support non-planar layout for Subgraphs ::testing::Values(ov::test::utils::DEVICE_CPU), - ::testing::Values(cpuParams_5D_nspc)), + ::testing::ValuesIn(filterCPUSpecificParams({cpuParams_5D_nspc}))), EltwiseCacheTest::getTestCaseName); diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp index 477c6190694205..68ccfd0ac5b5a1 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp @@ -380,6 +380,11 @@ std::vector disabledTestPatterns() { #endif #if defined(OPENVINO_ARCH_RISCV64) + // object is not initialized + retVector.emplace_back(R"(.*StaticLoopDynamicSubgraphCPUTest.smoke_StaticLoopWithDynSubgraph.*)"); + // crash with 'double free or corruption (!prev)' + retVector.emplace_back(R"(.*smoke_InterpolateBilinearPillow_Layout_Test.*)"); + retVector.emplace_back(R"(.*smoke_InterpolateBicubicPillow_Layout_Test.*)"); // unsupported node type 'CausalMaskPreprocess' retVector.emplace_back(R"(CausalMaskPreprocessCausalMaskPreprocess.smoke_CompareWithRefs)"); // fused op FakeQuantize has not been found @@ -394,9 +399,12 @@ std::vector disabledTestPatterns() { retVector.emplace_back(R"(.*smoke_TopK(_int32|_bubble_BLK_on_channel_horiz)?(_dynamic)?/TopKLayerCPUTest.CompareWithRefs.*inFmts=(nhwc|nChw8c|nChw16c).x.*)"); retVector.emplace_back(R"(.*smoke_(Group)?Convolution(2|3)D/ConvConcatSubgraphTest.CompareWithRefs.*)"); retVector.emplace_back(R"(.*smoke_FakeQuantizeCache_(4|5)D/FakeQuantizeCacheTest.CompareWithRefs.*inFmts=(nhwc|nChw8c|ndhwc|nCdhw8c).*)"); + retVector.emplace_back(R"(.*ReduceCPULayerTest.CompareWithRefs.*inFmts=nhwc.*)"); // only infer_precision=f32 is supported on riscv64 platforms retVector.emplace_back(R"(.*smoke_CompareWithRefs_(4|5)D.*EltwiseLayerCPUTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"); retVector.emplace_back(R"(.*smoke_CompareWithRefs_Mvn[12345]D.*/MvnLayerCPUTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"); + retVector.emplace_back(R"(.*ReduceCPULayerTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"); + retVector.emplace_back(R"(.*RemoveUselessFP16ConvertCPUTest.*INFERENCE_PRECISION_HINT=f16.*)"); // fused op Add has not been found retVector.emplace_back(R"(.*smoke_CompareWithRefs_fma_(4|5)D/EltwiseLayerCPUTest.CompareWithRefs.*)"); // primType is unexpected diff --git a/src/plugins/intel_cpu/tests/functional/utils/riscv64/filter_cpu_info.cpp b/src/plugins/intel_cpu/tests/functional/utils/riscv64/filter_cpu_info.cpp new file mode 100644 index 00000000000000..72a3d07f2640f4 --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/utils/riscv64/filter_cpu_info.cpp @@ -0,0 +1,84 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "utils/cpu_test_utils.hpp" +#include "utils/filter_cpu_info.hpp" +#include "utils/general_utils.h" + +namespace CPUTestUtils { + +std::vector filterCPUInfo(const std::vector& CPUParams) { + std::vector archCPUParams = filterCPUInfoForArch(CPUParams); + std::vector deviceCPUParams = filterCPUInfoForDevice(archCPUParams); + return deviceCPUParams; +} + +std::vector filterCPUInfoForArch(const std::vector& CPUParams) { + std::vector resCPUParams; + const int selectedTypeIndex = 3; + + for (auto param : CPUParams) { + auto selectedTypeStr = std::get(param); + + if (selectedTypeStr.find("shl") == std::string::npos && + selectedTypeStr.find("ref") == std::string::npos) + continue; + + resCPUParams.push_back(param); + } + + return resCPUParams; +} + +std::vector filterCPUInfoForDevice(const std::vector& CPUParams) { + std::vector resCPUParams; + const int selectedTypeIndex = 3; + + for (auto param : CPUParams) { + auto selectedTypeStr = std::get(param); + + if (selectedTypeStr.find("jit") != std::string::npos) + continue; + if (selectedTypeStr.find("acl") != std::string::npos) + continue; + if (selectedTypeStr.find("sse42") != std::string::npos) + continue; + if (selectedTypeStr.find("avx") != std::string::npos) + continue; + if (selectedTypeStr.find("avx2") != std::string::npos) + continue; + if (selectedTypeStr.find("avx512") != std::string::npos) + continue; + if (selectedTypeStr.find("amx") != std::string::npos) + continue; + + resCPUParams.push_back(param); + } + return resCPUParams; +} + +std::vector filterCPUInfoForDeviceWithFP16(const std::vector& allParams) { + std::vector resCPUParams; + return resCPUParams; +} + +std::vector filterCPUSpecificParams(const std::vector ¶msVector) { + static const std::vector supported_f = {CPUTestUtils::cpu_memory_format_t::ncw, + CPUTestUtils::cpu_memory_format_t::nchw, + CPUTestUtils::cpu_memory_format_t::ncdhw}; + std::vector filteredParamsVector = paramsVector; + filteredParamsVector.erase(std::remove_if(filteredParamsVector.begin(), + filteredParamsVector.end(), + [](CPUSpecificParams param) { + const int inMemoryFormatTypeIndex = 0; + std::vector inFormat = std::get(param); + const int outMemoryFormatIndex = 1; + std::vector outFormat = std::get(param); + return !containsSupportedFormatsOnly(inFormat, supported_f) || + !containsSupportedFormatsOnly(outFormat, supported_f); + }), + filteredParamsVector.end()); + return filteredParamsVector; +} +} // namespace CPUTestUtils diff --git a/src/plugins/intel_cpu/thirdparty/shl b/src/plugins/intel_cpu/thirdparty/shl index 73001ef5a2ceb8..27992eaf41ef96 160000 --- a/src/plugins/intel_cpu/thirdparty/shl +++ b/src/plugins/intel_cpu/thirdparty/shl @@ -1 +1 @@ -Subproject commit 73001ef5a2ceb872d97c61c560d0a43fb28f0696 +Subproject commit 27992eaf41ef967ed228ea8d801b1aa489ea8997 From e0e5612b896339d252f4662e62e820bc74079c61 Mon Sep 17 00:00:00 2001 From: Fang Xu Date: Wed, 14 Aug 2024 16:24:51 +0800 Subject: [PATCH 005/117] update oneTBB2021.13.0 on linux/mac (#26040) ### Details: - *update oneTBB 2021.13.0 (https://github.com/oneapi-src/oneTBB/releases/tag/v2021.13.0) for linux/mac* - *remove debug files for linux and mac (arm64)* ### Tickets: - *147579* - *143793* --- cmake/dependencies.cmake | 16 ++++++++-------- src/inference/tests/unit/CMakeLists.txt | 3 +++ 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake index 117cf5d2765e6f..2ebfceb8b9612e 100644 --- a/cmake/dependencies.cmake +++ b/cmake/dependencies.cmake @@ -117,10 +117,10 @@ function(ov_download_tbb) elseif(LINUX AND X86_64 AND OPENVINO_GNU_LIBC AND OV_LIBC_VERSION VERSION_GREATER_EQUAL 2.17) # build oneTBB 2021.2.1 with gcc 4.8 (glibc 2.17) RESOLVE_DEPENDENCY(TBB - ARCHIVE_LIN "oneapi-tbb-2021.2.4-lin.tgz" + ARCHIVE_LIN "oneapi-tbb-2021.13.0-lin-release.tgz" TARGET_PATH "${TEMP}/tbb" ENVIRONMENT "TBBROOT" - SHA256 "6523661559a340e88131472ea9a595582c306af083e55293b7357d11b8015546" + SHA256 "fd2e889323cd5458be750eefdc026ce6791c723fae60b146c2511a5caeaf01c5" USE_NEW_LOCATION TRUE) elseif(YOCTO_AARCH64) RESOLVE_DEPENDENCY(TBB @@ -132,10 +132,10 @@ function(ov_download_tbb) elseif(APPLE AND X86_64) # build oneTBB 2021.2.1 with OS version 11.4 RESOLVE_DEPENDENCY(TBB - ARCHIVE_MAC "oneapi-tbb-2021.2.5-mac-trim.tgz" + ARCHIVE_MAC "oneapi-tbb-2021.13.0-mac.tgz" TARGET_PATH "${TEMP}/tbb" ENVIRONMENT "TBBROOT" - SHA256 "5a6035fcf7b9d3bd8183ecc31b3e2b2026a749152b5b879f8e4d147e09479efc" + SHA256 "86e07127bfead5c4aad456c765de845013502342bda33d249d8097ed57afe945" USE_NEW_LOCATION TRUE) elseif(WIN32 AND AARCH64) # build oneTBB 2021.2.1 with Visual Studio 2022 (MSVC 14.35) @@ -148,18 +148,18 @@ function(ov_download_tbb) elseif(LINUX AND AARCH64 AND OPENVINO_GNU_LIBC AND OV_LIBC_VERSION VERSION_GREATER_EQUAL 2.17) # build oneTBB with glibc 2.17 RESOLVE_DEPENDENCY(TBB - ARCHIVE_LIN "oneapi-tbb-2021.13.0-rc1-lin-arm64-trim.tgz" + ARCHIVE_LIN "oneapi-tbb-2021.13.0-lin-arm64-release.tgz" TARGET_PATH "${TEMP}/tbb" ENVIRONMENT "TBBROOT" - SHA256 "7fe49525217de9536980a820d90645784216ad4a61e11799b8c95129dcdeeecf" + SHA256 "6e1106735714600474440c134df25b40a225d40b44c2102d7ff23e0482834faa" USE_NEW_LOCATION TRUE) elseif(APPLE AND AARCH64) # build oneTBB with export MACOSX_DEPLOYMENT_TARGET=11.0 RESOLVE_DEPENDENCY(TBB - ARCHIVE_MAC "oneapi-tbb-2021.13.0-rc1-mac-arm64-trim.tgz" + ARCHIVE_MAC "oneapi-tbb-2021.13.0-mac-arm64-release.tgz" TARGET_PATH "${TEMP}/tbb" ENVIRONMENT "TBBROOT" - SHA256 "d3ce1c00e46a187baee459458e8d13d3421dc7242bff0c977b95d8d66d74441a" + SHA256 "de9893f8699c15b1c8b46daa7fc51e112e84353d66d5baf1c35574932747c64c" USE_NEW_LOCATION TRUE) else() message(WARNING "Prebuilt TBB is not available on current platform") diff --git a/src/inference/tests/unit/CMakeLists.txt b/src/inference/tests/unit/CMakeLists.txt index 7893984c31dfd8..8a162937c01b6e 100644 --- a/src/inference/tests/unit/CMakeLists.txt +++ b/src/inference/tests/unit/CMakeLists.txt @@ -20,4 +20,7 @@ ov_add_test_target( OV UNIT RUNTIME ) +# fix LTO add_symbol_to_partition_1 issue +set_target_properties(${TARGET_NAME} PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE ${ENABLE_LTO}) + ov_set_threading_interface_for(${TARGET_NAME}) From 98e4c364ecd555f804759ad122d12ce5ae60c8f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hubert=20B=C5=82aszczyk?= <56601011+hub-bla@users.noreply.github.com> Date: Wed, 14 Aug 2024 13:17:45 +0200 Subject: [PATCH 006/117] [OV JS] Enable CompiledModel set/get property() (#25808) ### Details: - add 2 methods: `CompiledModel::set_property()` and `CompiledModel::get_property()` - create TypeScript definition for new created methods - create unit tests for new functionalities (due to the issue that was mentioned [here](https://github.com/openvinotoolkit/openvino/issues/24374#issuecomment-2257999988), it's more of a mock now and should be altered as soon as the issue is fixed) ### Tickets: - 134825 --- .../js/node/include/compiled_model.hpp | 16 ++++ src/bindings/js/node/lib/addon.ts | 16 +++- src/bindings/js/node/src/compiled_model.cpp | 39 +++++++++- .../js/node/tests/unit/compiled_model.test.js | 78 +++++++++++++++++++ 4 files changed, 147 insertions(+), 2 deletions(-) create mode 100644 src/bindings/js/node/tests/unit/compiled_model.test.js diff --git a/src/bindings/js/node/include/compiled_model.hpp b/src/bindings/js/node/include/compiled_model.hpp index 4e3834a3a527bd..56c483064be9ec 100644 --- a/src/bindings/js/node/include/compiled_model.hpp +++ b/src/bindings/js/node/include/compiled_model.hpp @@ -71,6 +71,22 @@ class CompiledModelWrap : public Napi::ObjectWrap { /** @brief Exports the compiled model to bytes/output stream. */ Napi::Value export_model(const Napi::CallbackInfo& info); + /** + * @brief Sets properties for current compiled model. + * @param info Contains information about the environment and passed arguments, + * this method accepts only one argument of type object. + * @return Napi::Undefined + */ + Napi::Value set_property(const Napi::CallbackInfo& info); + + /** + * @brief Gets property for current compiled model. + * @param info Contains information about the environment and passed arguments, + * this method accepts only one argument of type string. + * @return A Napi::Value + */ + Napi::Value get_property(const Napi::CallbackInfo& info); + private: /** @brief Gets node of a compiled model specified in CallbackInfo. */ Napi::Value get_node(const Napi::CallbackInfo& info, diff --git a/src/bindings/js/node/lib/addon.ts b/src/bindings/js/node/lib/addon.ts index 88bd874210dbcc..9ea694c154a641 100644 --- a/src/bindings/js/node/lib/addon.ts +++ b/src/bindings/js/node/lib/addon.ts @@ -305,6 +305,12 @@ interface CompiledModel { inputs: Output[]; /** It gets all outputs of a compiled model. */ outputs: Output[]; + /** + * It gets the property for the current compiled model. + * @param propertyName A string to get the property value. + * @returns The property value. + */ + getProperty(propertyName: string): string | number | boolean; /** * It creates an inference request object used to infer the compiled model. * @return {InferRequest} @@ -353,7 +359,15 @@ interface CompiledModel { * @returns {Output} A compiled model input. */ input(name: string): Output; - + /** + * It sets properties for the current compiled model. Properties + * can be retrieved via {@link CompiledModel.getProperty}. + * @param property An object with the key-value pairs. + * (property name, property value) + */ + setProperty(properties: { + [propertyName: string]: string | number | boolean + }): void; } /** diff --git a/src/bindings/js/node/src/compiled_model.cpp b/src/bindings/js/node/src/compiled_model.cpp index 495322dab15823..f9d13ddeb66d13 100644 --- a/src/bindings/js/node/src/compiled_model.cpp +++ b/src/bindings/js/node/src/compiled_model.cpp @@ -5,8 +5,10 @@ #include "node/include/addon.hpp" #include "node/include/errors.hpp" +#include "node/include/helper.hpp" #include "node/include/infer_request.hpp" #include "node/include/node_output.hpp" +#include "node/include/type_validation.hpp" CompiledModelWrap::CompiledModelWrap(const Napi::CallbackInfo& info) : Napi::ObjectWrap(info), @@ -20,7 +22,9 @@ Napi::Function CompiledModelWrap::get_class(Napi::Env env) { InstanceAccessor<&CompiledModelWrap::get_inputs>("inputs"), InstanceMethod("output", &CompiledModelWrap::get_output), InstanceAccessor<&CompiledModelWrap::get_outputs>("outputs"), - InstanceMethod("exportModelSync", &CompiledModelWrap::export_model)}); + InstanceMethod("exportModelSync", &CompiledModelWrap::export_model), + InstanceMethod("setProperty", &CompiledModelWrap::set_property), + InstanceMethod("getProperty", &CompiledModelWrap::get_property)}); } Napi::Object CompiledModelWrap::wrap(Napi::Env env, ov::CompiledModel compiled_model) { @@ -122,3 +126,36 @@ Napi::Value CompiledModelWrap::export_model(const Napi::CallbackInfo& info) { const auto& exported = _stream.str(); return Napi::Buffer::Copy(info.Env(), exported.c_str(), exported.size()); } + +Napi::Value CompiledModelWrap::set_property(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + std::vector allowed_signatures; + try { + if (ov::js::validate(info, allowed_signatures)) { + const auto properties = to_anyMap(env, info[0]); + _compiled_model.set_property(properties); + } else { + OPENVINO_THROW("'setProperty'", ov::js::get_parameters_error_msg(info, allowed_signatures)); + } + } catch (const std::exception& e) { + reportError(env, e.what()); + } + return env.Undefined(); +} + +Napi::Value CompiledModelWrap::get_property(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + std::vector allowed_signatures; + try { + if (ov::js::validate(info, allowed_signatures)) { + const auto property_name = info[0].As().Utf8Value(); + const auto property = _compiled_model.get_property(property_name); + return any_to_js(info, property); + } else { + OPENVINO_THROW("'getProperty'", ov::js::get_parameters_error_msg(info, allowed_signatures)); + } + } catch (const std::exception& e) { + reportError(env, e.what()); + } + return env.Undefined(); +} diff --git a/src/bindings/js/node/tests/unit/compiled_model.test.js b/src/bindings/js/node/tests/unit/compiled_model.test.js new file mode 100644 index 00000000000000..6b33296131b04d --- /dev/null +++ b/src/bindings/js/node/tests/unit/compiled_model.test.js @@ -0,0 +1,78 @@ +// -*- coding: utf-8 -*- +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +const { addon: ov } = require('../..'); +const assert = require('assert'); +const { describe, it } = require('node:test'); +const { getModelPath } = require('./utils.js'); + +const testXml = getModelPath().xml; +const core = new ov.Core(); +const properties = { + "AUTO_BATCH_TIMEOUT": '1' +}; +const compiledModel = core.compileModelSync(testXml, 'BATCH:CPU', properties); + +describe('setProperty() / getProperty()', () => { + + describe('getProperty()', () => { + it('returns the value of property from compiled model', () => { + assert.strictEqual(compiledModel.getProperty('AUTO_BATCH_TIMEOUT'), '1'); + }); + it('throws an error when called without arguments', () => { + assert.throws( + () => compiledModel.getProperty(), + /'getProperty' method called with incorrect parameters/ + ); + }); + it('throws an error when called with property name that does not exists', ()=>{ + assert.throws( + () => compiledModel.getProperty('PROPERTY_THAT_DOES_NOT_EXIST') + ); + }); + }); + + describe('setProperty()', () => { + it('sets a properties for compiled model', () => { + properties["AUTO_BATCH_TIMEOUT"] = '1000'; + assert.doesNotThrow(() => compiledModel.setProperty(properties)); + }); + + it('throws an error when called without an object argument', () => { + assert.throws( + () => compiledModel.setProperty(), + /'setProperty' method called with incorrect parameters/ + ); + }); + it('throws an error when called with wrong argument', () => { + assert.throws( + () => compiledModel.setProperty(123), + /'setProperty' method called with incorrect parameters/ + ); + }); + + it('throws an error when called with multiple arguments', () => { + assert.throws( + () => compiledModel.setProperty({"PERFORMANCE_HINT": "THROUGHPUT"}, {"NUM_STREAMS": "AUTO"}), + /'setProperty' method called with incorrect parameters/ + ); + }); + + it('returns the set property of the compiled model', () => { + properties["AUTO_BATCH_TIMEOUT"] = '123'; + compiledModel.setProperty(properties); + assert.strictEqual(compiledModel.getProperty('AUTO_BATCH_TIMEOUT'), 123); + }); + + it('retains the last set property when set multiple times', () => { + compiledModel.setProperty({"AUTO_BATCH_TIMEOUT": '321'}); + compiledModel.setProperty({'AUTO_BATCH_TIMEOUT': '132'}); + assert.strictEqual(compiledModel.getProperty('AUTO_BATCH_TIMEOUT'), 132); + }); + + it('allows to pass empty object', () => { + assert.doesNotThrow(() => compiledModel.setProperty({})); + }); + }); +}); From c0f7765f3ff72f5439908f2529efd3cd910c984f Mon Sep 17 00:00:00 2001 From: Maxim Vafin Date: Wed, 14 Aug 2024 14:50:54 +0200 Subject: [PATCH 007/117] [PT FE] Support aten.eye.m for FX graph (#25833) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --- src/frontends/pytorch/src/op/eye.cpp | 14 ++++++++++++++ src/frontends/pytorch/src/op_table.cpp | 2 ++ tests/layer_tests/pytorch_tests/test_eye.py | 2 ++ 3 files changed, 18 insertions(+) diff --git a/src/frontends/pytorch/src/op/eye.cpp b/src/frontends/pytorch/src/op/eye.cpp index 7565b4a5f06764..64751bfae3d30e 100644 --- a/src/frontends/pytorch/src/op/eye.cpp +++ b/src/frontends/pytorch/src/op/eye.cpp @@ -45,6 +45,20 @@ OutputVector translate_eye(const NodeContext& context) { return {context.mark_node(std::make_shared(eye, dtype))}; }; +OutputVector translate_eye_fx(const NodeContext& context) { + num_inputs_check(context, 2, 2); + auto x = get_input_as_i32(context, 0); + auto y = get_input_as_i32(context, 1); + // aten::eye support only main diagonal + auto diagonal = context.mark_node(v0::Constant::create(element::i32, Shape{}, {0})); + auto dtype = element::i32; + if (context.has_attribute("dtype")) { + dtype = context.get_attribute("dtype"); + } + auto eye = context.mark_node(std::make_shared(x, y, diagonal, dtype)); + return {context.mark_node(std::make_shared(eye, dtype))}; +}; + } // namespace op } // namespace pytorch } // namespace frontend diff --git a/src/frontends/pytorch/src/op_table.cpp b/src/frontends/pytorch/src/op_table.cpp index 078af4e3655636..83ff923efcd89e 100644 --- a/src/frontends/pytorch/src/op_table.cpp +++ b/src/frontends/pytorch/src/op_table.cpp @@ -267,6 +267,7 @@ OP_CONVERTER(translate_div_fx); OP_CONVERTER(translate_div_fx_); OP_CONVERTER(translate_embedding_bag_fx); OP_CONVERTER(translate_expand_fx); +OP_CONVERTER(translate_eye_fx); OP_CONVERTER(translate_fake_quantize_per_channel_affine_fx); OP_CONVERTER(translate_fake_quantize_per_tensor_affine_fx); OP_CONVERTER(translate_full_fx); @@ -839,6 +840,7 @@ const std::map get_supported_ops_fx() { {"aten.exp.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment}, {"aten.expm1.default", op::translate_expm1}, {"aten.expand.default", op::translate_expand_fx}, + {"aten.eye.m", op::translate_eye_fx}, {"aten.fake_quantize_per_channel_affine_cachemask.default", op::translate_fake_quantize_per_channel_affine_fx}, {"aten.fill.Scalar", op::translate_fill}, {"aten.fill_.Scalar", op::inplace_op}, diff --git a/tests/layer_tests/pytorch_tests/test_eye.py b/tests/layer_tests/pytorch_tests/test_eye.py index c79422731eefac..55af29b12a5b50 100644 --- a/tests/layer_tests/pytorch_tests/test_eye.py +++ b/tests/layer_tests/pytorch_tests/test_eye.py @@ -51,6 +51,7 @@ def forward(self, x, y): @pytest.mark.nightly @pytest.mark.precommit + @pytest.mark.precommit_torch_export @pytest.mark.parametrize("dtype", ["bool", "int8", "uint8", "int32", "int64", "float32", "float64"]) @pytest.mark.parametrize("m", [2, 3, 4, 5]) def test_eye_square(self, dtype, m, ie_device, precision, ir_version): @@ -60,6 +61,7 @@ def test_eye_square(self, dtype, m, ie_device, precision, ir_version): @pytest.mark.nightly @pytest.mark.precommit + @pytest.mark.precommit_torch_export @pytest.mark.parametrize("dtype", ["bool", "int8", "uint8", "int32", "int64", "float32", "float64"]) @pytest.mark.parametrize(("m", "n"), [[2, 2], [3, 4], [5, 3]]) def test_eye(self, dtype, m, n, ie_device, precision, ir_version): From 267e6f9de9495f829108fccd3f693a6ad4228e8b Mon Sep 17 00:00:00 2001 From: Aleksandr Voron Date: Wed, 14 Aug 2024 15:43:12 +0200 Subject: [PATCH 008/117] [CPU][ARM] Enable SLT Interpolate tests on ARM (#26039) ### Details: - Interpolate SLT test file has been splitted into test class and test instances. - As were agreed with @EgorDuplensky there are dedicated test instances for x64 and arm since ACL supports very limited scope of Interpolate configuration. - While enabling tests on ARM it was found that ACL NEScale does not support scales mode with linear/linear_onnx and half_pixel/asymmetric, so additional limitation has been added. - To add the limitation mentioned above `shapeCalcMode` was moved from `Interpolate` node into `InterpolateAttrs` structure. - Enabled `fp16` in arm test instances - Enabled `NHWC` in arm test instances ### Tickets: - *ticket-id* --- .../nodes/executors/acl/acl_interpolate.cpp | 7 + .../nodes/executors/acl/acl_interpolate.hpp | 2 +- .../src/nodes/executors/interpolate.hpp | 1 + .../intel_cpu/src/nodes/interpolate.cpp | 22 +- src/plugins/intel_cpu/src/nodes/interpolate.h | 1 - .../classes/interpolate.cpp | 264 +++++++++++ .../classes/interpolate.hpp | 60 +++ .../instances/arm/interpolate.cpp | 237 ++++++++++ .../{ => instances/x64}/interpolate.cpp | 440 ++++-------------- 9 files changed, 661 insertions(+), 373 deletions(-) create mode 100644 src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.cpp create mode 100644 src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.hpp create mode 100644 src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/arm/interpolate.cpp rename src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/{ => instances/x64}/interpolate.cpp (71%) diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.cpp index 5c74293d04dff5..33bd49e2f04d9b 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.cpp @@ -187,6 +187,13 @@ bool ov::intel_cpu::ACLInterpolateExecutorBuilder::isSupported(const ov::intel_c return false; } + if (interpolateAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales && + one_of(interpolateAttrs.coordTransMode, InterpolateCoordTransMode::half_pixel, InterpolateCoordTransMode::asymmetric) && + one_of(interpolateAttrs.mode, InterpolateMode::linear, InterpolateMode::linear_onnx)) { + DEBUG_LOG("ACL Interpolate does not support scales mode with linear/linear_onnx and half_pixel/asymmetric"); + return false; + } + if (interpolateAttrs.mode == InterpolateMode::nearest && !isSupportedConfiguration(interpolateAttrs, srcDescs, dstDescs)) { DEBUG_LOG("ACL Interpolate isSupportedConfiguration method fails for nearest mode"); diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.hpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.hpp index 263619735ffba4..17cdfec5928544 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.hpp +++ b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.hpp @@ -4,7 +4,7 @@ #pragma once -#include "../interpolate.hpp" +#include "nodes/executors/interpolate.hpp" #include "arm_compute/runtime/NEON/functions/NEScale.h" #include "arm_compute/runtime/Tensor.h" diff --git a/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp b/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp index d28c4af323b730..15df4eed5f0471 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp +++ b/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp @@ -48,6 +48,7 @@ enum class InterpolateShapeCalcMode { }; struct InterpolateAttrs { + InterpolateShapeCalcMode shapeCalcMode = InterpolateShapeCalcMode::sizes; InterpolateMode mode = InterpolateMode::nearest; InterpolateCoordTransMode coordTransMode = InterpolateCoordTransMode::half_pixel; InterpolateNearestMode nearestMode = InterpolateNearestMode::round_prefer_floor; diff --git a/src/plugins/intel_cpu/src/nodes/interpolate.cpp b/src/plugins/intel_cpu/src/nodes/interpolate.cpp index b81a2c89cff2ef..a04834fd55f1ae 100644 --- a/src/plugins/intel_cpu/src/nodes/interpolate.cpp +++ b/src/plugins/intel_cpu/src/nodes/interpolate.cpp @@ -1862,9 +1862,9 @@ Interpolate::Interpolate(const std::shared_ptr& op, const GraphContext const auto &interpShapeCalcMode = interpAttr.shape_calculation_mode; if (interpShapeCalcMode == ngInterpShapeCalcMode::SCALES) { - shapeCalcMode = InterpolateShapeCalcMode::scales; + interpAttrs.shapeCalcMode = InterpolateShapeCalcMode::scales; } else if (interpShapeCalcMode == ngInterpShapeCalcMode::SIZES) { - shapeCalcMode = InterpolateShapeCalcMode::sizes; + interpAttrs.shapeCalcMode = InterpolateShapeCalcMode::sizes; } else { OPENVINO_THROW(errorPrefix, " has unsupported shape calculation mode"); } @@ -1925,14 +1925,14 @@ Interpolate::Interpolate(const std::shared_ptr& op, const GraphContext const auto &interpShapeCalcMode = interpAttr.shape_calculation_mode; if (interpShapeCalcMode == ngInterpShapeCalcMode::SCALES) { - shapeCalcMode = InterpolateShapeCalcMode::scales; + interpAttrs.shapeCalcMode = InterpolateShapeCalcMode::scales; const auto scalesNode = std::dynamic_pointer_cast(interp->get_input_node_shared_ptr(SIZE_OR_SCALE_ID_V11)); if (scalesNode) { scales = scalesNode->cast_vector(); isScaleConstant = true; } } else if (interpShapeCalcMode == ngInterpShapeCalcMode::SIZES) { - shapeCalcMode = InterpolateShapeCalcMode::sizes; + interpAttrs.shapeCalcMode = InterpolateShapeCalcMode::sizes; } else { OPENVINO_THROW(errorPrefix, " has unsupported shape calculation mode"); } @@ -2074,7 +2074,7 @@ void Interpolate::initSupportedPrimitiveDescriptors() { auto pushDesc = [&](LayoutType dataFormat, impl_desc_type implDetail, bool is_version11, bool useAclExecutor = false) { config.inConfs[DATA_ID].setMemDesc(creatorsMap.at(dataFormat)->createSharedDesc(inputPrecision, getInputShapeAtPort(DATA_ID))); if (is_version11) { - if (shapeCalcMode == InterpolateShapeCalcMode::sizes) { + if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::sizes) { config.inConfs[SIZE_OR_SCALE_ID_V11].setMemDesc( creatorsMap.at(LayoutType::ncsp)->createSharedDesc(targetShapeType, getInputShapeAtPort(SIZE_OR_SCALE_ID_V11))); } else { @@ -2198,7 +2198,7 @@ bool Interpolate::needShapeInfer() const { if (Node::inputShapesModified()) { return true; } - if (shapeCalcMode == InterpolateShapeCalcMode::scales) { + if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales) { if (lastScales.empty()) { return true; } @@ -2225,9 +2225,9 @@ bool Interpolate::needShapeInfer() const { void Interpolate::executeDynamicImpl(dnnl::stream strm) { execute(strm); - const size_t port = shapeCalcMode == InterpolateShapeCalcMode::sizes ? TARGET_SHAPE_ID : get_scale_id(); + const size_t port = interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::sizes ? TARGET_SHAPE_ID : get_scale_id(); const auto &memory = getParentEdgeAt(port)->getMemory(); - if (shapeCalcMode == InterpolateShapeCalcMode::scales) { + if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales) { const float *scales = memory.getDataAs(); lastScales.assign(scales, scales + memory.getDesc().getShape().getElementsCount()); } else { @@ -2268,7 +2268,7 @@ void Interpolate::prepareParams() { if (!srcMemPtr || !srcMemPtr->isAllocated()) OPENVINO_THROW(errorPrefix, " did not allocate input memory"); - if (shapeCalcMode == InterpolateShapeCalcMode::sizes) { + if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::sizes) { auto tsMemPtr = getSrcMemoryAtPort(TARGET_SHAPE_ID); if (!tsMemPtr || !tsMemPtr->isAllocated()) OPENVINO_THROW(errorPrefix, " did not allocate target shape memory"); @@ -2307,7 +2307,7 @@ void Interpolate::prepareParams() { interpAttrs.layout = InterpolateLayoutType::by_channel; } - if (shapeCalcMode == InterpolateShapeCalcMode::scales) { + if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales) { if (!isScaleConstant) { const auto& scalesMem = getParentEdgeAt(get_scale_id())->getMemory(); const float* scalesData = scalesMem.getDataAs(); @@ -2460,7 +2460,7 @@ std::vector Interpolate::getScales(const VectorDims &srcDimPad, const Vec if (interpAttrs.mode == InterpolateMode::bilinear_pillow || interpAttrs.mode == InterpolateMode::bicubic_pillow) { fullScales[axis] = static_cast(dstDim[axis]) / static_cast(srcDimPad[axis]); } else { - fullScales[axis] = (shapeCalcMode == InterpolateShapeCalcMode::scales) ? scales[i] : + fullScales[axis] = (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales) ? scales[i] : static_cast(dstDim[axis]) / static_cast(srcDimPad[axis]); } } diff --git a/src/plugins/intel_cpu/src/nodes/interpolate.h b/src/plugins/intel_cpu/src/nodes/interpolate.h index e8d09ee24028ba..11f0e3104e5085 100644 --- a/src/plugins/intel_cpu/src/nodes/interpolate.h +++ b/src/plugins/intel_cpu/src/nodes/interpolate.h @@ -223,7 +223,6 @@ class Interpolate : public Node { static size_t getSpatialDimsNum(const Dim rank); bool hasPad = false; - InterpolateShapeCalcMode shapeCalcMode = InterpolateShapeCalcMode::sizes; bool isAxesSpecified = false; std::vector axes; diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.cpp new file mode 100644 index 00000000000000..3b36a2fef062bc --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.cpp @@ -0,0 +1,264 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "interpolate.hpp" +#include "gtest/gtest.h" +#include "utils/cpu_test_utils.hpp" +#include "utils/general_utils.h" +#include "openvino/pass/manager.hpp" +#include "transformations/op_conversions/convert_interpolate11_downgrade.hpp" + +using namespace CPUTestUtils; +using namespace ov::intel_cpu; + +namespace ov { +namespace test { + +std::string InterpolateLayerCPUTest::getTestCaseName(testing::TestParamInfo obj) { + InterpolateSpecificParams specificParams; + ShapeParams shapeParams; + ElementType prec; + CPUSpecificParams cpuParams; + fusingSpecificParams fusingParams; + ov::AnyMap additionalConfig; + std::tie(specificParams, shapeParams, prec, cpuParams, fusingParams, additionalConfig) = obj.param; + + ov::op::v11::Interpolate::InterpolateMode mode; + ov::op::v11::Interpolate::CoordinateTransformMode transfMode; + ov::op::v11::Interpolate::NearestMode nearMode; + bool antiAlias; + std::vector padBegin; + std::vector padEnd; + double cubeCoef; + std::tie(mode, transfMode, nearMode, antiAlias, padBegin, padEnd, cubeCoef) = specificParams; + + ov::op::v11::Interpolate::ShapeCalcMode shapeCalcMode; + InputShape inputShapes; + ov::test::utils::InputLayerType shapeInputType; + std::vector> shapeDataForInput; + std::vector axes; + std::tie(shapeCalcMode, inputShapes, shapeInputType, shapeDataForInput, axes) = shapeParams; + + using ov::test::utils::operator<<; + std::ostringstream result; + result << "ShapeCalcMode=" << shapeCalcMode << "_"; + result << "IS="; + result << ov::test::utils::partialShape2str({inputShapes.first}) << "_"; + result << "TS="; + for (const auto& shape : inputShapes.second) { + result << ov::test::utils::vec2str(shape) << "_"; + } + if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { + result << "Scales="; + } else { + result << "Sizes="; + } + for (const auto &data : shapeDataForInput) { + result << ov::test::utils::vec2str(data) << "_"; + } + result << shapeInputType << "_"; + result << "InterpolateMode=" << mode << "_"; + result << "CoordinateTransformMode=" << transfMode << "_"; + result << "NearestMode=" << nearMode << "_"; + result << "CubeCoef=" << cubeCoef << "_"; + result << "Antialias=" << antiAlias << "_"; + result << "PB=" << ov::test::utils::vec2str(padBegin) << "_"; + result << "PE=" << ov::test::utils::vec2str(padEnd) << "_"; + result << "Axes=" << ov::test::utils::vec2str(axes) << "_"; + result << "PRC=" << prec << "_"; + + result << CPUTestsBase::getTestCaseName(cpuParams); + result << CpuTestWithFusing::getTestCaseName(fusingParams); + + if (!additionalConfig.empty()) { + result << "_PluginConf"; + for (auto& item : additionalConfig) { + result << "_" << item.first << "=" << item.second.as(); + } + } + + return result.str(); +} + +void InterpolateLayerCPUTest::generate_inputs(const std::vector& targetInputStaticShapes) { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + ov::Tensor tensor; + + if (i == 1) { + if (shapeCalcMode == ov::op::v4::Interpolate::ShapeCalcMode::SIZES) { + tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], sizes[inferRequestNum].data()); + } else { + tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], scales[inferRequestNum].data()); + } + } else { + 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}); + } + inferRequestNum++; +} + +void InterpolateLayerCPUTest::configure_model() { + ov::preprocess::PrePostProcessor p(function); + { + auto& params = function->get_parameters(); + for (size_t i = 0; i < params.size(); i++) { + if (i > 0) { + continue; + } + if (inType != ov::element::Type_t::undefined) { + p.input(i).tensor().set_element_type(inType); + } + } + } + { + auto results = function->get_results(); + for (size_t i = 0; i < results.size(); i++) { + if (outType != ov::element::Type_t::undefined) { + p.output(i).tensor().set_element_type(outType); + } + } + } + function = p.build(); +} + +void InterpolateLayerCPUTest::SetUp() { + targetDevice = ov::test::utils::DEVICE_CPU; + + InterpolateSpecificParams specificParams; + ShapeParams shapeParams; + ElementType ngPrc; + CPUSpecificParams cpuParams; + fusingSpecificParams fusingParams; + ov::AnyMap additionalConfig; + std::tie(specificParams, shapeParams, ngPrc, cpuParams, fusingParams, additionalConfig) = this->GetParam(); + + std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; + std::tie(postOpMgrPtr, fusedOps) = fusingParams; + configuration.insert(additionalConfig.begin(), additionalConfig.end()); + + ov::op::v11::Interpolate::InterpolateMode mode; + ov::op::v11::Interpolate::CoordinateTransformMode transfMode; + ov::op::v11::Interpolate::NearestMode nearMode; + bool antiAlias; + std::vector padBegin; + std::vector padEnd; + double cubeCoef; + std::tie(mode, transfMode, nearMode, antiAlias, padBegin, padEnd, cubeCoef) = specificParams; + + InputShape dataShape; + ov::test::utils::InputLayerType shapeInputType; + std::vector> shapeDataForInput; + std::vector axes; + std::tie(shapeCalcMode, dataShape, shapeInputType, shapeDataForInput, axes) = shapeParams; + + if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { + scales = shapeDataForInput; + } else { + sizes.resize(shapeDataForInput.size()); + for (size_t i = 0; i < shapeDataForInput.size(); i++) { + for (size_t j = 0; j < shapeDataForInput[i].size(); j++) { + sizes[i].push_back(shapeDataForInput[i][j]); + } + } + } + + std::vector inputShapes; + inputShapes.push_back(dataShape); + if (shapeInputType == ov::test::utils::InputLayerType::PARAMETER) { + inputShapes.push_back(InputShape({static_cast(axes.size())}, std::vector(dataShape.second.size(), {axes.size()}))); + } + + auto it = additionalConfig.find(ov::hint::inference_precision.name()); + if (it != additionalConfig.end() && it->second.as() == ov::element::bf16) { + inType = outType = ngPrc = ElementType::bf16; + rel_threshold = 1e-2f; + } else if (it != additionalConfig.end() && it->second.as() == ov::element::f16) { + inType = outType = ngPrc = ElementType::f16; + rel_threshold = 1e-2f; + } else { + inType = outType = ngPrc; + } + + init_input_shapes(inputShapes); + + ov::ParameterVector params{std::make_shared(ngPrc, inputDynamicShapes.front())}; + std::shared_ptr sizesInput, scalesInput; + if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { + if (shapeInputType == ov::test::utils::InputLayerType::PARAMETER) { + auto paramNode = std::make_shared(ElementType::f32, ov::Shape{scales.front().size()}); + params.push_back(paramNode); + scalesInput = paramNode; + } else { + scalesInput = std::make_shared(ElementType::f32, ov::Shape{scales.front().size()}, scales.front()); + } + } else { + if (shapeInputType == ov::test::utils::InputLayerType::PARAMETER) { + auto paramNode = std::make_shared(ElementType::i32, ov::Shape{sizes.front().size()}); + params.push_back(paramNode); + sizesInput = paramNode; + } else { + sizesInput = std::make_shared(ElementType::i32, ov::Shape{sizes.front().size()}, sizes.front()); + } + } + auto axesInput = std::make_shared(ElementType::i64, ov::Shape{axes.size()}, axes); + + for (size_t i = 0; i < params.size(); i++) { + params[i]->set_friendly_name(std::string("param_") + std::to_string(i)); + } + + ov::op::v11::Interpolate::InterpolateAttrs interpAttr{mode, shapeCalcMode, padBegin, padEnd, transfMode, nearMode, + antiAlias, cubeCoef}; + + std::shared_ptr interp = nullptr; + if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { + interp = std::make_shared(params[0], scalesInput, axesInput, interpAttr); + } else { + interp = std::make_shared(params[0], sizesInput, axesInput, interpAttr); + } + + function = makeNgraphFunction(ngPrc, params, interp, "InterpolateCPU"); + + ov::pass::Manager m; + m.register_pass(); + m.run_passes(function); + if (selectedType.empty()) { + selectedType = getPrimitiveType(); + } + selectedType = makeSelectedTypeStr(selectedType, ngPrc); +} + +TEST_P(InterpolateLayerCPUTest, CompareWithRefs) { + run(); + CheckPluginRelatedResults(compiledModel, "Interpolate"); +} + + +namespace Interpolate { +const std::vector defNearestModes() { + static const std::vector defNearestModes { + ov::op::v11::Interpolate::NearestMode::ROUND_PREFER_FLOOR + }; + return defNearestModes; +} + +const std::vector antialias() { + return { false }; +} + +const std::vector cubeCoefs() { + return { -0.75f }; +} + +} // namespace Interpolate +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.hpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.hpp new file mode 100644 index 00000000000000..c9614cd2f497c7 --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/interpolate.hpp @@ -0,0 +1,60 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "shared_test_classes/base/ov_subgraph.hpp" +#include "utils/fusing_test_utils.hpp" + +using namespace CPUTestUtils; + +namespace ov { +namespace test { + +using InterpolateSpecificParams = + std::tuple, // PadBegin + std::vector, // PadEnd + double>; // Cube coef + +using ShapeParams = std::tuple>, // scales or sizes values + std::vector>; // axes + +using InterpolateLayerCPUTestParamsSet = std::tuple; + +class InterpolateLayerCPUTest : public testing::WithParamInterface, + virtual public SubgraphBaseTest, public CpuTestWithFusing { +public: + static std::string getTestCaseName(testing::TestParamInfo obj); + void generate_inputs(const std::vector& targetInputStaticShapes) override; + void configure_model() override; + +protected: + std::vector> scales; + std::vector> sizes; + ov::op::v4::Interpolate::ShapeCalcMode shapeCalcMode; + size_t inferRequestNum = 0; + + void SetUp() override; +}; + +namespace Interpolate { + const std::vector defNearestModes(); + const std::vector antialias(); + const std::vector cubeCoefs(); +} // namespace Interpolate +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/arm/interpolate.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/arm/interpolate.cpp new file mode 100644 index 00000000000000..0463d25924c3b8 --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/arm/interpolate.cpp @@ -0,0 +1,237 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "custom/single_layer_tests/classes/interpolate.hpp" +#include "common_test_utils/ov_tensor_utils.hpp" +#include "openvino/core/preprocess/pre_post_process.hpp" +#include "shared_test_classes/base/ov_subgraph.hpp" +#include "utils/cpu_test_utils.hpp" +#include "utils/fusing_test_utils.hpp" + +using namespace CPUTestUtils; + +namespace ov { +namespace test { +namespace Interpolate { + +const std::vector coordinateTransformModes_Full = { + ov::op::v11::Interpolate::CoordinateTransformMode::HALF_PIXEL, + ov::op::v11::Interpolate::CoordinateTransformMode::ASYMMETRIC, + ov::op::v11::Interpolate::CoordinateTransformMode::ALIGN_CORNERS +}; + +const std::vector interpolateNearestModes = { + ov::op::v11::Interpolate::NearestMode::SIMPLE, + ov::op::v11::Interpolate::NearestMode::FLOOR +}; + +const std::vector interpolateFusingParamsSet{ + emptyFusingSpec +}; + +const std::vector filterAdditionalConfig = { + {ov::hint::inference_precision(ov::element::f32)}, + {ov::hint::inference_precision(ov::element::f16)} +}; + +const std::vector filterCPUInfoForDevice = { + CPUSpecificParams{{nchw, x, x, x}, {nchw}, {"acl"}, "acl"}, + CPUSpecificParams{{nhwc, x, x, x}, {nhwc}, {"acl"}, "acl"} +}; + +const std::vector> pads4D = { + {0, 0, 0, 0} +}; + +const std::vector> defaultAxes4D = { + {0, 1, 2, 3} +}; + +const std::vector shapeParams4D_Smoke = { + ShapeParams{ + ov::op::v11::Interpolate::ShapeCalcMode::SCALES, + InputShape{{}, {{1, 11, 4, 4}}}, + ov::test::utils::InputLayerType::CONSTANT, + {{1.f, 1.f, 1.25f, 1.5f}}, + defaultAxes4D.front() + }, + ShapeParams{ + ov::op::v11::Interpolate::ShapeCalcMode::SIZES, + InputShape{{}, {{1, 11, 4, 4}}}, + ov::test::utils::InputLayerType::CONSTANT, + {{1, 11, 5, 6}}, + defaultAxes4D.front() + } +}; + +const ShapeParams shapeParams4D_Scales = ShapeParams{ + ov::op::v11::Interpolate::ShapeCalcMode::SCALES, + InputShape{{-1, {2, 20}, -1, -1}, {{1, 11, 4, 4}, {2, 7, 6, 5}, {1, 11, 4, 4}}}, + ov::test::utils::InputLayerType::CONSTANT, + {{1.f, 1.f, 1.25f, 1.5f}}, + defaultAxes4D.front() + }; + +const ShapeParams shapeParams4D_Sizes = ShapeParams{ + ov::op::v11::Interpolate::ShapeCalcMode::SIZES, + InputShape{{-1, {2, 20}, -1, -1}, {{1, 11, 4, 4}, {1, 11, 5, 5}, {1, 11, 4, 4}}}, + ov::test::utils::InputLayerType::CONSTANT, + {{1, 11, 5, 6}}, + defaultAxes4D.front() + }; + +const std::vector shapeParams4D_Full = { shapeParams4D_Scales, shapeParams4D_Sizes }; + +INSTANTIATE_TEST_SUITE_P(smoke_InterpolateNN_Layout_Test, InterpolateLayerCPUTest, + ::testing::Combine( + ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), + ::testing::Values(ov::op::v11::Interpolate::CoordinateTransformMode::ASYMMETRIC), + ::testing::ValuesIn(interpolateNearestModes), + ::testing::ValuesIn(antialias()), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(cubeCoefs())), + ::testing::ValuesIn(shapeParams4D_Smoke), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +const auto interpolateCasesNN_Full = ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), + ::testing::Values(ov::op::v11::Interpolate::CoordinateTransformMode::ALIGN_CORNERS), + ::testing::Values(ov::op::v11::Interpolate::NearestMode::ROUND_PREFER_CEIL), + ::testing::ValuesIn(antialias()), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(cubeCoefs())); + +INSTANTIATE_TEST_SUITE_P(InterpolateNN_Layout_Test, InterpolateLayerCPUTest, + ::testing::Combine( + interpolateCasesNN_Full, + ::testing::ValuesIn(shapeParams4D_Full), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +const auto interpolateCasesLinearOnnx_Full = ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR_ONNX), + ::testing::ValuesIn(coordinateTransformModes_Full), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(cubeCoefs())); + +INSTANTIATE_TEST_SUITE_P(InterpolateLinearOnnx_Layout_Test_Sizes, InterpolateLayerCPUTest, + ::testing::Combine( + interpolateCasesLinearOnnx_Full, + ::testing::Values(shapeParams4D_Sizes), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +const auto interpolateCasesLinearOnnx_Scales = ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR_ONNX), + ::testing::Values(ov::op::v11::Interpolate::CoordinateTransformMode::ALIGN_CORNERS), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(cubeCoefs())); + +INSTANTIATE_TEST_SUITE_P(InterpolateLinearOnnx_Layout_Test_Scales, InterpolateLayerCPUTest, + ::testing::Combine( + interpolateCasesLinearOnnx_Scales, + ::testing::Values(shapeParams4D_Scales), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +const auto interpolateCasesLinear_Full = ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR), + ::testing::ValuesIn(coordinateTransformModes_Full), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(cubeCoefs())); + +INSTANTIATE_TEST_SUITE_P(InterpolateLinear_Layout_Test_sizes, InterpolateLayerCPUTest, + ::testing::Combine( + interpolateCasesLinear_Full, + ::testing::Values(shapeParams4D_Sizes), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +const auto interpolateCasesLinear_Scales = ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR), + ::testing::Values(ov::op::v11::Interpolate::CoordinateTransformMode::ALIGN_CORNERS), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(pads4D), + ::testing::ValuesIn(cubeCoefs())); + +INSTANTIATE_TEST_SUITE_P(InterpolateLinear_Layout_Test_scales, InterpolateLayerCPUTest, + ::testing::Combine( + interpolateCasesLinear_Scales, + ::testing::Values(shapeParams4D_Scales), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +// corner cases +const std::vector shapeParams4D_corner = { + ShapeParams{ + ov::op::v11::Interpolate::ShapeCalcMode::SCALES, + InputShape{{1, 11, 4, 4}, {{1, 11, 4, 4}, {1, 11, 4, 4}}}, + ov::test::utils::InputLayerType::PARAMETER, + {{1.f, 1.f, 1.25f, 1.5f}, {1.f, 1.f, 1.25f, 1.25f}}, + defaultAxes4D.front() + }, + ShapeParams{ + ov::op::v11::Interpolate::ShapeCalcMode::SIZES, + InputShape{{1, 11, 4, 4}, {{1, 11, 4, 4}, {1, 11, 4, 4}}}, + ov::test::utils::InputLayerType::PARAMETER, + {{1, 11, 6, 7}, {1, 11, 8, 7}}, + defaultAxes4D.front() + } +}; + +const auto interpolateCornerCases = ::testing::Combine( + ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), + ::testing::Values(ov::op::v11::Interpolate::CoordinateTransformMode::ASYMMETRIC), + ::testing::Values(ov::op::v11::Interpolate::NearestMode::SIMPLE), + ::testing::ValuesIn(antialias()), + ::testing::Values(std::vector{0, 0, 0, 0}), + ::testing::Values(std::vector{0, 0, 0, 0}), + ::testing::ValuesIn(cubeCoefs())); + +INSTANTIATE_TEST_SUITE_P(smoke_Interpolate_corner_Layout_Test, InterpolateLayerCPUTest, + ::testing::Combine( + interpolateCornerCases, + ::testing::ValuesIn(shapeParams4D_corner), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(filterCPUInfoForDevice), + ::testing::ValuesIn(interpolateFusingParamsSet), + ::testing::ValuesIn(filterAdditionalConfig)), + InterpolateLayerCPUTest::getTestCaseName); + +} // namespace Interpolate +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/interpolate.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/interpolate.cpp similarity index 71% rename from src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/interpolate.cpp rename to src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/interpolate.cpp index 1dc0a3ec6b7942..b129af76bde93d 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/interpolate.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/interpolate.cpp @@ -2,278 +2,43 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "custom/single_layer_tests/classes/interpolate.hpp" #include "common_test_utils/ov_tensor_utils.hpp" #include "openvino/core/preprocess/pre_post_process.hpp" #include "shared_test_classes/base/ov_subgraph.hpp" #include "utils/cpu_test_utils.hpp" #include "utils/fusing_test_utils.hpp" -#include "transformations/op_conversions/convert_interpolate11_downgrade.hpp" -#include "openvino/pass/manager.hpp" using namespace CPUTestUtils; namespace ov { namespace test { +namespace Interpolate { +namespace { -using InterpolateSpecificParams = - std::tuple, // PadBegin - std::vector, // PadEnd - double>; // Cube coef - -using ShapeParams = std::tuple>, // scales or sizes values - std::vector>; // axes - -using InterpolateLayerCPUTestParamsSet = std::tuple; - -class InterpolateLayerCPUTest : public testing::WithParamInterface, - virtual public SubgraphBaseTest, public CpuTestWithFusing { -public: - static std::string getTestCaseName(testing::TestParamInfo obj) { - InterpolateSpecificParams specificParams; - ShapeParams shapeParams; - ElementType prec; - CPUSpecificParams cpuParams; - fusingSpecificParams fusingParams; - ov::AnyMap additionalConfig; - std::tie(specificParams, shapeParams, prec, cpuParams, fusingParams, additionalConfig) = obj.param; - - ov::op::v11::Interpolate::InterpolateMode mode; - ov::op::v11::Interpolate::CoordinateTransformMode transfMode; - ov::op::v11::Interpolate::NearestMode nearMode; - bool antiAlias; - std::vector padBegin; - std::vector padEnd; - double cubeCoef; - std::tie(mode, transfMode, nearMode, antiAlias, padBegin, padEnd, cubeCoef) = specificParams; - - ov::op::v11::Interpolate::ShapeCalcMode shapeCalcMode; - InputShape inputShapes; - ov::test::utils::InputLayerType shapeInputType; - std::vector> shapeDataForInput; - std::vector axes; - std::tie(shapeCalcMode, inputShapes, shapeInputType, shapeDataForInput, axes) = shapeParams; - - using ov::test::utils::operator<<; - std::ostringstream result; - result << "ShapeCalcMode=" << shapeCalcMode << "_"; - result << "IS="; - result << ov::test::utils::partialShape2str({inputShapes.first}) << "_"; - result << "TS="; - for (const auto& shape : inputShapes.second) { - result << ov::test::utils::vec2str(shape) << "_"; - } - if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { - result << "Scales="; - } else { - result << "Sizes="; - } - for (const auto &data : shapeDataForInput) { - result << ov::test::utils::vec2str(data) << "_"; - } - result << shapeInputType << "_"; - result << "InterpolateMode=" << mode << "_"; - result << "CoordinateTransformMode=" << transfMode << "_"; - result << "NearestMode=" << nearMode << "_"; - result << "CubeCoef=" << cubeCoef << "_"; - result << "Antialias=" << antiAlias << "_"; - result << "PB=" << ov::test::utils::vec2str(padBegin) << "_"; - result << "PE=" << ov::test::utils::vec2str(padEnd) << "_"; - result << "Axes=" << ov::test::utils::vec2str(axes) << "_"; - result << "PRC=" << prec << "_"; - - result << CPUTestsBase::getTestCaseName(cpuParams); - result << CpuTestWithFusing::getTestCaseName(fusingParams); - - if (!additionalConfig.empty()) { - result << "_PluginConf"; - for (auto& item : additionalConfig) { - result << "_" << item.first << "=" << item.second.as(); - } - } - - return result.str(); - } - - void generate_inputs(const std::vector& 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; - - if (i == 1) { - if (shapeCalcMode == ov::op::v4::Interpolate::ShapeCalcMode::SIZES) { - tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], sizes[inferRequestNum].data()); - } else { - tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], scales[inferRequestNum].data()); - } - } else { - 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}); - } - inferRequestNum++; - } - - void configure_model() override { - ov::preprocess::PrePostProcessor p(function); - { - auto& params = function->get_parameters(); - for (size_t i = 0; i < params.size(); i++) { - if (i > 0) { - continue; - } - if (inType != ov::element::Type_t::undefined) { - p.input(i).tensor().set_element_type(inType); - } - } - } - { - auto results = function->get_results(); - for (size_t i = 0; i < results.size(); i++) { - if (outType != ov::element::Type_t::undefined) { - p.output(i).tensor().set_element_type(outType); - } - } - } - function = p.build(); +const std::vector filterAdditionalConfig() { + if (ov::with_cpu_x86_avx512f()) { + return {{{ov::hint::inference_precision(ov::element::f32)}}, + {{ov::hint::inference_precision(ov::element::bf16)}}}; + } else { + return {// default config as an stub for target without avx512, otherwise all tests with BF16 in its name are + // skipped + {}}; } +} -protected: - std::vector> scales; - std::vector> sizes; - ov::op::v4::Interpolate::ShapeCalcMode shapeCalcMode; - size_t inferRequestNum = 0; - - void SetUp() override { - targetDevice = ov::test::utils::DEVICE_CPU; - - InterpolateSpecificParams specificParams; - ShapeParams shapeParams; - ElementType ngPrc; - CPUSpecificParams cpuParams; - fusingSpecificParams fusingParams; - ov::AnyMap additionalConfig; - std::tie(specificParams, shapeParams, ngPrc, cpuParams, fusingParams, additionalConfig) = this->GetParam(); - - std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; - std::tie(postOpMgrPtr, fusedOps) = fusingParams; - configuration.insert(additionalConfig.begin(), additionalConfig.end()); - - ov::op::v11::Interpolate::InterpolateMode mode; - ov::op::v11::Interpolate::CoordinateTransformMode transfMode; - ov::op::v11::Interpolate::NearestMode nearMode; - bool antiAlias; - std::vector padBegin; - std::vector padEnd; - double cubeCoef; - std::tie(mode, transfMode, nearMode, antiAlias, padBegin, padEnd, cubeCoef) = specificParams; - - InputShape dataShape; - ov::test::utils::InputLayerType shapeInputType; - std::vector> shapeDataForInput; - std::vector axes; - std::tie(shapeCalcMode, dataShape, shapeInputType, shapeDataForInput, axes) = shapeParams; - - if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { - scales = shapeDataForInput; - } else { - sizes.resize(shapeDataForInput.size()); - for (size_t i = 0; i < shapeDataForInput.size(); i++) { - for (size_t j = 0; j < shapeDataForInput[i].size(); j++) { - sizes[i].push_back(shapeDataForInput[i][j]); - } - } - } - - std::vector inputShapes; - inputShapes.push_back(dataShape); - if (shapeInputType == ov::test::utils::InputLayerType::PARAMETER) { - inputShapes.push_back(InputShape({static_cast(axes.size())}, std::vector(dataShape.second.size(), {axes.size()}))); - } - - auto it = additionalConfig.find(ov::hint::inference_precision.name()); - if (it != additionalConfig.end() && it->second.as() == ov::element::bf16) { - inType = outType = ngPrc = ElementType::bf16; - rel_threshold = 1e-2f; - } else { - inType = outType = ngPrc; - } - - init_input_shapes(inputShapes); - - ov::ParameterVector params{std::make_shared(ngPrc, inputDynamicShapes.front())}; - std::shared_ptr sizesInput, scalesInput; - if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { - if (shapeInputType == ov::test::utils::InputLayerType::PARAMETER) { - auto paramNode = std::make_shared(ElementType::f32, ov::Shape{scales.front().size()}); - params.push_back(paramNode); - scalesInput = paramNode; - } else { - scalesInput = std::make_shared(ElementType::f32, ov::Shape{scales.front().size()}, scales.front()); - } - } else { - if (shapeInputType == ov::test::utils::InputLayerType::PARAMETER) { - auto paramNode = std::make_shared(ElementType::i32, ov::Shape{sizes.front().size()}); - params.push_back(paramNode); - sizesInput = paramNode; - } else { - sizesInput = std::make_shared(ElementType::i32, ov::Shape{sizes.front().size()}, sizes.front()); - } - } - auto axesInput = std::make_shared(ElementType::i64, ov::Shape{axes.size()}, axes); - - for (size_t i = 0; i < params.size(); i++) { - params[i]->set_friendly_name(std::string("param_") + std::to_string(i)); - } - - ov::op::v11::Interpolate::InterpolateAttrs interpAttr{mode, shapeCalcMode, padBegin, padEnd, transfMode, nearMode, - antiAlias, cubeCoef}; - - std::shared_ptr interp = nullptr; - if (shapeCalcMode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES) { - interp = std::make_shared(params[0], scalesInput, axesInput, interpAttr); - } else { - interp = std::make_shared(params[0], sizesInput, axesInput, interpAttr); - } - - function = makeNgraphFunction(ngPrc, params, interp, "InterpolateCPU"); - - ov::pass::Manager m; - m.register_pass(); - m.run_passes(function); - - if (selectedType.empty()) { - selectedType = getPrimitiveType(); - } - selectedType = makeSelectedTypeStr(selectedType, ngPrc); +const std::vector filterCPUInfoForDevice3D() { + if (ov::with_cpu_x86_avx2()) { + return { CPUSpecificParams{{ncw, x, x, x}, {ncw}, {"jit_avx2"}, "jit_avx2"} }; + } else { + return { CPUSpecificParams{{ncw, x, x, x}, {ncw}, {"ref"}, "ref"} }; } -}; +} -TEST_P(InterpolateLayerCPUTest, CompareWithRefs) { - run(); - CheckPluginRelatedResults(compiledModel, "Interpolate"); +const std::vector filterAdditionalConfig3D() { + return { {} }; } -namespace { const std::vector coordinateTransformModes_Smoke = { ov::op::v11::Interpolate::CoordinateTransformMode::HALF_PIXEL, ov::op::v11::Interpolate::CoordinateTransformMode::ASYMMETRIC, @@ -301,54 +66,12 @@ const std::vector nearestModes_Full = { ov::op::v11::Interpolate::NearestMode::ROUND_PREFER_CEIL, }; -const std::vector defNearestModes = { - ov::op::v11::Interpolate::NearestMode::ROUND_PREFER_FLOOR, -}; - -const std::vector antialias = { - false, -}; - -const std::vector cubeCoefs = { - -0.75f, -}; - const std::vector interpolateFusingParamsSet{ emptyFusingSpec, -#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) fusingSwish, - fusingFakeQuantizePerTensorRelu, -#endif + fusingFakeQuantizePerTensorRelu }; -std::vector filterAdditionalConfig() { - if (ov::with_cpu_x86_avx512f()) { - return {{{ov::hint::inference_precision(ov::element::f32)}}, - {{ov::hint::inference_precision(ov::element::bf16)}}}; - } else { - return {// default config as an stub for target without avx512, otherwise all tests with BF16 in its name are - // skipped - {}}; - } -} - -// 3D -std::vector filterCPUInfoForDevice3D() { - std::vector resCPUParams; - if (ov::with_cpu_x86_avx2()) { - resCPUParams.push_back(CPUSpecificParams{{ncw, x, x, x}, {ncw}, {"jit_avx2"}, "jit_avx2"}); - } else { - resCPUParams.push_back(CPUSpecificParams{{ncw, x, x, x}, {ncw}, {"ref"}, "ref"}); - } - return resCPUParams; -} - -std::vector filterAdditionalConfig3D() { - return { - {} - }; -} - const std::vector> pads3D_smoke = { {0, 0, 0}, }; @@ -382,10 +105,10 @@ const auto interpolateCasesNN_Smoke_3D = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::ValuesIn(coordinateTransformModes_Smoke), ::testing::ValuesIn(nearestModes_Smoke), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads3D_smoke), ::testing::ValuesIn(pads3D_smoke), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateNN_Layout_Test_3D, InterpolateLayerCPUTest, ::testing::Combine( interpolateCasesNN_Smoke_3D, @@ -400,10 +123,10 @@ const auto interpolateCasesNN_Full_3D = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::ValuesIn(coordinateTransformModes_Full), ::testing::ValuesIn(nearestModes_Full), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads3D_full), ::testing::ValuesIn(pads3D_full), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(InterpolateNN_Layout_Test_3D, InterpolateLayerCPUTest, ::testing::Combine( interpolateCasesNN_Full_3D, @@ -414,7 +137,6 @@ INSTANTIATE_TEST_SUITE_P(InterpolateNN_Layout_Test_3D, InterpolateLayerCPUTest, ::testing::ValuesIn(filterAdditionalConfig3D())), InterpolateLayerCPUTest::getTestCaseName); -#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) const std::vector interpolateFusingParamsSet3D_fixed_C() { std::vector fuseParams; if (ov::with_cpu_x86_avx2()) { @@ -461,25 +183,24 @@ INSTANTIATE_TEST_SUITE_P(InterpolateNN_Layout_PerChannelFuse3D_Test, Interpolate ::testing::ValuesIn(interpolateFusingParamsSet3D_fixed_C()), ::testing::ValuesIn(filterAdditionalConfig3D())), InterpolateLayerCPUTest::getTestCaseName); -#endif const auto interpolateCasesLinear3D_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR), ::testing::ValuesIn(coordinateTransformModes_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads3D_smoke), ::testing::ValuesIn(pads3D_smoke), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesLinear3D_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR), ::testing::ValuesIn(coordinateTransformModes_Full), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads3D_full), ::testing::ValuesIn(pads3D_full), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateLinear_Layout3D_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -504,20 +225,20 @@ INSTANTIATE_TEST_SUITE_P(InterpolateLinear_Layout3D_Test, InterpolateLayerCPUTes const auto interpolateCasesCubic3D_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::CUBIC), ::testing::ValuesIn(coordinateTransformModes_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads3D_smoke), ::testing::ValuesIn(pads3D_smoke), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesCubic3D_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::CUBIC), ::testing::ValuesIn(coordinateTransformModes_Full), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads3D_full), ::testing::ValuesIn(pads3D_full), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateCubic_Layout3D_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -619,19 +340,19 @@ const auto interpolateCasesNN_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::ValuesIn(coordinateTransformModes_Smoke), ::testing::ValuesIn(nearestModes_Smoke), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesNN_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::ValuesIn(coordinateTransformModes_Full), ::testing::ValuesIn(nearestModes_Full), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateNN_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -653,7 +374,6 @@ INSTANTIATE_TEST_SUITE_P(InterpolateNN_Layout_Test, InterpolateLayerCPUTest, ::testing::ValuesIn(filterAdditionalConfig())), InterpolateLayerCPUTest::getTestCaseName); -#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) const std::vector interpolateFusingParamsSet_fixed_C{ fusingFakeQuantizePerChannelRelu, fusingMultiplyPerChannel, @@ -695,25 +415,24 @@ INSTANTIATE_TEST_SUITE_P(InterpolateNN_Layout_PerChannelFuse_Test, InterpolateLa ::testing::ValuesIn(interpolateFusingParamsSet_fixed_C), ::testing::ValuesIn(filterAdditionalConfig())), InterpolateLayerCPUTest::getTestCaseName); -#endif const auto interpolateCasesLinearOnnx_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR_ONNX), ::testing::ValuesIn(coordinateTransformModes_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesLinearOnnx_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR_ONNX), ::testing::ValuesIn(coordinateTransformModes_Full), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateLinearOnnx_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -738,20 +457,20 @@ INSTANTIATE_TEST_SUITE_P(InterpolateLinearOnnx_Layout_Test, InterpolateLayerCPUT const auto interpolateCasesLinear_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR), ::testing::ValuesIn(coordinateTransformModes_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesLinear_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR), ::testing::ValuesIn(coordinateTransformModes_Full), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateLinear_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -776,20 +495,20 @@ INSTANTIATE_TEST_SUITE_P(InterpolateLinear_Layout_Test, InterpolateLayerCPUTest, const auto interpolateCasesCubic_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::CUBIC), ::testing::ValuesIn(coordinateTransformModes_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesCubic_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::CUBIC), ::testing::ValuesIn(coordinateTransformModes_Full), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateCubic_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -889,19 +608,19 @@ const std::vector shapeParams5D_Full = { const auto interpolateCasesLinearOnnx5D_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR_ONNX), ::testing::ValuesIn(coordinateTransformModes_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads5D), ::testing::ValuesIn(pads5D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesLinearOnnx5D_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::LINEAR_ONNX), ::testing::ValuesIn(coordinateTransformModes_Full), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads5D), ::testing::ValuesIn(pads5D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateLinearOnnx5D_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -927,19 +646,19 @@ const auto interpolateCasesNN5D_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::ValuesIn(coordinateTransformModes_Smoke), ::testing::ValuesIn(nearestModes_Smoke), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads5D), ::testing::ValuesIn(pads5D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); const auto interpolateCasesNN5D_Full = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::ValuesIn(coordinateTransformModes_Full), ::testing::ValuesIn(nearestModes_Full), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads5D), ::testing::ValuesIn(pads5D), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_InterpolateNN5D_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -983,10 +702,10 @@ const auto interpolateCornerCases = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::NEAREST), ::testing::Values(ov::op::v11::Interpolate::CoordinateTransformMode::ASYMMETRIC), ::testing::Values(ov::op::v11::Interpolate::NearestMode::SIMPLE), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(antialias()), ::testing::Values(std::vector{0, 0, 0, 0}), ::testing::Values(std::vector{0, 0, 0, 0}), - ::testing::ValuesIn(cubeCoefs)); + ::testing::ValuesIn(cubeCoefs())); INSTANTIATE_TEST_SUITE_P(smoke_Interpolate_corner_Layout_Test, InterpolateLayerCPUTest, ::testing::Combine( @@ -1101,8 +820,8 @@ std::vector filterPillowAdditionalConfig() { const auto interpolateCasesBilinearPillow_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::BILINEAR_PILLOW), ::testing::ValuesIn(coordinateTransformModesPillow_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(cubeCoefsPillow)); @@ -1110,8 +829,8 @@ const auto interpolateCasesBilinearPillow_Smoke = ::testing::Combine( const auto interpolateCasesBicubicPillow_Smoke = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::BICUBIC_PILLOW), ::testing::ValuesIn(coordinateTransformModesPillow_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(pads4D), ::testing::ValuesIn(cubeCoefsPillow)); @@ -1191,8 +910,8 @@ std::vector filterCPUInfoForDevice_pillow_nchw_as_nhwc() { const auto interpolateCasesBilinearPillow_Smoke_nchw_as_nhwc = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::BILINEAR_PILLOW), ::testing::ValuesIn(coordinateTransformModesPillow_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D_nchw_as_nhwc), ::testing::ValuesIn(pads4D_nchw_as_nhwc), ::testing::ValuesIn(cubeCoefsPillow)); @@ -1210,8 +929,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_InterpolateBilinearPillow_LayoutAlign_Test, Inter const auto interpolateCasesBicubicPillow_Smoke_nchw_as_nhwc = ::testing::Combine( ::testing::Values(ov::op::v11::Interpolate::InterpolateMode::BICUBIC_PILLOW), ::testing::ValuesIn(coordinateTransformModesPillow_Smoke), - ::testing::ValuesIn(defNearestModes), - ::testing::ValuesIn(antialias), + ::testing::ValuesIn(defNearestModes()), + ::testing::ValuesIn(antialias()), ::testing::ValuesIn(pads4D_nchw_as_nhwc), ::testing::ValuesIn(pads4D_nchw_as_nhwc), ::testing::ValuesIn(cubeCoefsPillow)); @@ -1227,5 +946,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_InterpolateBicubicPillow_LayoutAlign_Test, Interp InterpolateLayerCPUTest::getTestCaseName); } // namespace +} // namespace Interpolate } // namespace test } // namespace ov From eda21ba7a6f2c2a078ec60918611bc78e4c23559 Mon Sep 17 00:00:00 2001 From: Egor Duplenskii Date: Wed, 14 Aug 2024 18:14:48 +0200 Subject: [PATCH 009/117] [CPU] Introduce additional OV_CPU_VERBOSE levels (#26062) Levels enable printing of: - 1 - executable nodes only - 2 - same as `1` plus `Input` and `Output` nodes - 3 - same as `2` plus constant path nodes (executed in scope of `compile_model()`) --- .../intel_cpu/docs/debug_capabilities/verbose.md | 5 ++++- src/plugins/intel_cpu/src/graph.cpp | 2 ++ src/plugins/intel_cpu/src/utils/verbose.cpp | 13 +++++++------ src/plugins/intel_cpu/src/utils/verbose.h | 6 +++++- 4 files changed, 18 insertions(+), 8 deletions(-) diff --git a/src/plugins/intel_cpu/docs/debug_capabilities/verbose.md b/src/plugins/intel_cpu/docs/debug_capabilities/verbose.md index ed9573468f8dc4..50a2d501210f24 100644 --- a/src/plugins/intel_cpu/docs/debug_capabilities/verbose.md +++ b/src/plugins/intel_cpu/docs/debug_capabilities/verbose.md @@ -29,7 +29,10 @@ To turn on verbose mode the following environment variable should be used: OV_CPU_VERBOSE= binary ... ``` -Currently verbose mode has only one level, any digit can be used for activation. +Levels enable printing of: + - 1 - executable nodes only + - 2 - same as `1` plus `Input` and `Output` nodes + - 3 - same as `2` plus constant path nodes (executed in scope of `compile_model()`) To have colored verbose output just duplicate level's digit, for example: ```sh diff --git a/src/plugins/intel_cpu/src/graph.cpp b/src/plugins/intel_cpu/src/graph.cpp index b908aca6ebc964..66be31c858cc76 100644 --- a/src/plugins/intel_cpu/src/graph.cpp +++ b/src/plugins/intel_cpu/src/graph.cpp @@ -495,6 +495,8 @@ void Graph::CreatePrimitivesAndExecConstants() const { continue; } + VERBOSE(node, getConfig().debugCaps.verbose); + if (context->getWeightsCache()) { auto sharedOutputs = acquireSharedOutputs(node); diff --git a/src/plugins/intel_cpu/src/utils/verbose.cpp b/src/plugins/intel_cpu/src/utils/verbose.cpp index 7799e1771ef708..54a62db2bc86e1 100644 --- a/src/plugins/intel_cpu/src/utils/verbose.cpp +++ b/src/plugins/intel_cpu/src/utils/verbose.cpp @@ -1,6 +1,7 @@ // Copyright (C) 2018-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // +#include "utils/general_utils.h" #ifdef CPU_DEBUG_CAPS #include "verbose.h" @@ -25,11 +26,15 @@ bool Verbose::shouldBePrinted() const { if (lvl < 1) return false; - if (node->isConstant() || - node->getType() == Type::Input || node->getType() == Type::Output) + if (lvl < 2 && one_of(node->getType(), Type::Input, Type::Output)) return false; + + if (lvl < 3 && node->isConstant()) + return false; + return true; } + /** * Print node verbose execution information to cout. * Similiar to DNNL_VERBOSE output @@ -37,10 +42,6 @@ bool Verbose::shouldBePrinted() const { * Can be rewritten in pure C++ if necessary */ void Verbose::printInfo() { - /* 1, 2, 3, etc -> no color - * 11, 22, 33, etc -> colorize */ - bool colorUp = lvl / 10 > 0 ? true : false; - enum Color { RED, GREEN, diff --git a/src/plugins/intel_cpu/src/utils/verbose.h b/src/plugins/intel_cpu/src/utils/verbose.h index 5984438b20b4ec..f5407ec679dd7e 100644 --- a/src/plugins/intel_cpu/src/utils/verbose.h +++ b/src/plugins/intel_cpu/src/utils/verbose.h @@ -17,7 +17,10 @@ namespace intel_cpu { class Verbose { public: Verbose(const NodePtr& _node, const std::string& _lvl) - : node(_node), lvl(atoi(_lvl.c_str())) { + : node(_node), + lvl(atoi(_lvl.c_str()) % 10), + /* 1, 2, 3, etc -> no color. 11, 22, 33, etc -> colorize */ + colorUp(atoi(_lvl.c_str()) / 10) { if (!shouldBePrinted()) return; printInfo(); @@ -34,6 +37,7 @@ class Verbose { private: const NodePtr& node; const int lvl; + const bool colorUp; std::stringstream stream; bool shouldBePrinted() const; From aa4455a5ba6aac66a6b27d7686abea673ae02d09 Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Wed, 14 Aug 2024 21:09:49 +0400 Subject: [PATCH 010/117] [TF FE] Support SparseTensorDenseMatMul operation (#26064) **Details:** Support SparseTensorDenseMatMul operation. Required for customer model. **Ticket:** 104539 --------- Signed-off-by: Kazantsev, Roman --- .../tensorflow/docs/supported_ops.md | 2 +- src/frontends/tensorflow/src/op_table.cpp | 3 +- .../include/common_op_table.hpp | 1 + .../src/op/sparse_tensor_dense_mat_mul.cpp | 39 +++++++ .../test_tf_SparseTensorDenseMatMul.py | 100 ++++++++++++++++++ 5 files changed, 143 insertions(+), 2 deletions(-) create mode 100644 src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp create mode 100644 tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py diff --git a/src/frontends/tensorflow/docs/supported_ops.md b/src/frontends/tensorflow/docs/supported_ops.md index ed1307c3b264bb..aa96ddb4fa1c3f 100644 --- a/src/frontends/tensorflow/docs/supported_ops.md +++ b/src/frontends/tensorflow/docs/supported_ops.md @@ -1150,7 +1150,7 @@ A "supported operation" is one that TensorFlow Frontend can convert to the OpenV | SparseSparseMinimum | NO | | | SparseSplit | NO | | | SparseTensorDenseAdd | NO | | -| SparseTensorDenseMatMul | NO | | +| SparseTensorDenseMatMul | YES | | | SparseTensorSliceDataset | NO | | | SparseTensorToCSRSparseMatrix | NO | | | SparseToDense | YES | | diff --git a/src/frontends/tensorflow/src/op_table.cpp b/src/frontends/tensorflow/src/op_table.cpp index 69fba3d2453711..67a8ecfb68288c 100644 --- a/src/frontends/tensorflow/src/op_table.cpp +++ b/src/frontends/tensorflow/src/op_table.cpp @@ -370,7 +370,6 @@ const std::map get_supported_ops() { {"SaveV2", CreatorFunction(translate_no_op)}, {"ScatterNd", CreatorFunction(translate_scatter_nd_op)}, {"SegmentSum", CreatorFunction(translate_segment_sum_op)}, - {"SparseToDense", CreatorFunction(translate_sparse_to_dense_op)}, {"Select", CreatorFunction(translate_select_op)}, {"SelectV2", CreatorFunction(translate_select_v2_op)}, {"Shape", CreatorFunction(translate_shape_op)}, @@ -381,6 +380,8 @@ const std::map get_supported_ops() { {"Softmax", CreatorFunction(translate_softmax_op)}, {"SpaceToDepth", CreatorFunction(translate_space_to_depth_op)}, {"SparseReshape", CreatorFunction(translate_sparse_reshape_op)}, + {"SparseTensorDenseMatMul", CreatorFunction(translate_sparse_tensor_dense_mat_mul_op)}, + {"SparseToDense", CreatorFunction(translate_sparse_to_dense_op)}, {"Split", CreatorFunction(translate_split_op)}, {"SplitV", CreatorFunction(translate_split_v_op)}, {"StopGradient", CreatorFunction(translate_identity_op)}, diff --git a/src/frontends/tensorflow_common/include/common_op_table.hpp b/src/frontends/tensorflow_common/include/common_op_table.hpp index e617aae601bf58..3332122edee0c8 100644 --- a/src/frontends/tensorflow_common/include/common_op_table.hpp +++ b/src/frontends/tensorflow_common/include/common_op_table.hpp @@ -146,6 +146,7 @@ OP_CONVERTER(translate_rsqrt_op); OP_CONVERTER(translate_scatter_nd_op); OP_CONVERTER(translate_segment_sum_op); OP_CONVERTER(translate_space_to_batch_nd_op); +OP_CONVERTER(translate_sparse_tensor_dense_mat_mul_op); OP_CONVERTER(translate_sparse_to_dense_op); OP_CONVERTER(translate_select_op); OP_CONVERTER(translate_select_v2_op); diff --git a/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp b/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp new file mode 100644 index 00000000000000..e9cb1bf17c11fb --- /dev/null +++ b/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp @@ -0,0 +1,39 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "common_op_table.hpp" +#include "openvino/op/broadcast.hpp" +#include "openvino/op/matmul.hpp" +#include "openvino/op/scatter_nd_update.hpp" +#include "utils.hpp" + +using namespace std; +using namespace ov::op; + +namespace ov { +namespace frontend { +namespace tensorflow { +namespace op { +OutputVector translate_sparse_tensor_dense_mat_mul_op(const NodeContext& node) { + default_op_checks(node, 4, {"SparseTensorDenseMatMul"}); + auto a_indices = node.get_input(0); + auto a_values = node.get_input(1); + auto a_shape = node.get_input(2); + auto b = node.get_input(3); + auto adjoint_a = node.get_attribute("adjoint_a", false); + auto adjoint_b = node.get_attribute("adjoint_b", false); + + // create dense tensor + auto zero_const = create_same_type_const_scalar(a_values, 0); + ov::Output a = make_shared(zero_const, a_shape); + a = make_shared(a, a_indices, a_values); + auto res = make_shared(a, b, adjoint_a, adjoint_b); + set_node_name(node.get_name(), res); + return {res}; +} + +} // namespace op +} // namespace tensorflow +} // namespace frontend +} // namespace ov diff --git a/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py new file mode 100644 index 00000000000000..1eb31a753b6bfd --- /dev/null +++ b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py @@ -0,0 +1,100 @@ +# Copyright (C) 2018-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import platform +import pytest +import tensorflow as tf +from common.tf_layer_test_class import CommonTFLayerTest + +rng = np.random.default_rng(475912) + + +class TestSparseTensorDenseMatMul(CommonTFLayerTest): + def _prepare_input(self, inputs_info): + assert 'a_indices:0' in inputs_info + assert 'a_values:0' in inputs_info + assert 'b:0' in inputs_info + + a_values_shape = inputs_info['a_values:0'] + b_shape = inputs_info['b:0'] + + inputs_data = {} + if np.issubdtype(self.data_type, np.floating): + inputs_data['a_values:0'] = rng.uniform(-5.0, 5.0, a_values_shape).astype(self.data_type) + inputs_data['b:0'] = rng.uniform(-5.0, 5.0, b_shape).astype(self.data_type) + elif np.issubdtype(self.data_type, np.signedinteger): + inputs_data['a_values:0'] = rng.integers(-8, 8, a_values_shape).astype(self.data_type) + inputs_data['b:0'] = rng.integers(-8, 8, b_shape).astype(self.data_type) + else: + inputs_data['a_values:0'] = rng.integers(0, 8, a_values_shape).astype(self.data_type) + inputs_data['b:0'] = rng.integers(0, 8, b_shape).astype(self.data_type) + + a_rows_num = self.a_shape[0] + a_cols_num = self.a_shape[1] + + # generate all possible indices + all_indices = [] + for row_ind in range(0, a_rows_num): + for col_ind in range(0, a_cols_num): + all_indices.append([row_ind, col_ind]) + inputs_data['a_indices:0'] = rng.choice(all_indices, self.nnz, replace=False).astype(self.indices_type) + + return inputs_data + + def create_sparse_tensor_dense_mat_mul_net(self, data_type, indices_type, + adjoint_a, adjoint_b, + a_shape, b_shape, nnz): + a_shape = a_shape.copy() + b_shape = b_shape.copy() + if adjoint_a: + a_shape.reverse() + if adjoint_b: + b_shape.reverse() + + self.data_type = data_type + self.indices_type = indices_type + self.a_shape = a_shape + self.nnz = nnz + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + a_indices = tf.compat.v1.placeholder(indices_type, [nnz, 2], 'a_indices') + a_values = tf.compat.v1.placeholder(data_type, [nnz], 'a_values') + a_shape = tf.constant(a_shape, dtype=tf.int64) + b = tf.compat.v1.placeholder(data_type, b_shape, 'b') + tf.raw_ops.SparseTensorDenseMatMul( + a_indices=a_indices, + a_values=a_values, + a_shape=a_shape, + b=b, + adjoint_a=adjoint_a, + adjoint_b=adjoint_b) + tf.compat.v1.global_variables_initializer() + tf_net = sess.graph_def + + ref_net = None + + return tf_net, ref_net + + @pytest.mark.parametrize('data_type', [np.float32, np.float64, np.int32]) + @pytest.mark.parametrize('indices_type', [np.int32, np.int64]) + @pytest.mark.parametrize('adjoint_a', [True, False]) + @pytest.mark.parametrize('adjoint_b', [True, False]) + @pytest.mark.parametrize('a_shape, b_shape, nnz', [ + [[4, 10], [10, 5], 8], + [[5, 5], [5, 5], 3], + ]) + @pytest.mark.precommit + @pytest.mark.nightly + def test_sparse_tensor_dense_mat_mul(self, data_type, indices_type, + adjoint_a, adjoint_b, + a_shape, b_shape, nnz, + ie_device, precision, ir_version, temp_dir, + use_legacy_frontend): + if ie_device == 'GPU': + pytest.skip("149830: ScatterNDUpdate-15 is not supported on GPU") + self._test(*self.create_sparse_tensor_dense_mat_mul_net(data_type, indices_type, + adjoint_a, adjoint_b, + a_shape, b_shape, nnz), + ie_device, precision, ir_version, temp_dir=temp_dir, + use_legacy_frontend=use_legacy_frontend) From 5a119fb2498f798571d58b0cb21bb8ede8bcf271 Mon Sep 17 00:00:00 2001 From: Maxim Vafin Date: Wed, 14 Aug 2024 19:10:21 +0200 Subject: [PATCH 011/117] [PT FE] Use GroupNormalization for aten::group_norm instead of MVN (#26063) ### Details: - *Use GroupNormalization for `aten::group_norm` instead of MVN* ### Tickets: - *ticket-id* --- src/frontends/pytorch/src/op/group_norm.cpp | 51 ++++++++++----------- 1 file changed, 24 insertions(+), 27 deletions(-) diff --git a/src/frontends/pytorch/src/op/group_norm.cpp b/src/frontends/pytorch/src/op/group_norm.cpp index 2ab51533c42288..42daa0f63f20d7 100644 --- a/src/frontends/pytorch/src/op/group_norm.cpp +++ b/src/frontends/pytorch/src/op/group_norm.cpp @@ -3,15 +3,13 @@ // #include "openvino/frontend/pytorch/node_context.hpp" -#include "openvino/op/add.hpp" +#include "openvino/op/broadcast.hpp" #include "openvino/op/constant.hpp" -#include "openvino/op/multiply.hpp" -#include "openvino/op/mvn.hpp" -#include "openvino/op/range.hpp" -#include "openvino/op/reshape.hpp" -#include "openvino/op/subtract.hpp" +#include "openvino/op/convert_like.hpp" +#include "openvino/op/gather.hpp" +#include "openvino/op/group_normalization.hpp" +#include "openvino/op/shape_of.hpp" #include "openvino/op/unsqueeze.hpp" -#include "openvino/op/util/framework_node.hpp" #include "utils.hpp" namespace ov { @@ -33,30 +31,29 @@ OutputVector translate_group_norm_common(const NodeContext& context, auto data = context.get_input(0); auto num_groups = context.const_input(group_idx); // input 2 - weights and input 3 - bias are optional without default value, we handle them later - auto eps = static_cast(context.const_input(eps_idx)); - Output input_shape; - Output input_rank; - std::tie(input_shape, input_rank) = get_shape_rank(context, data, true, element::i32); - auto scalar_one = context.mark_node(v0::Constant::create(element::i32, {}, {1})); - auto shape = context.mark_node( - std::make_shared(element::i32, Shape({3}), std::vector{0, num_groups, -1})); - auto reshaped_input = context.mark_node(std::make_shared(data, shape, true)); - auto reduction_axes = context.mark_node(v0::Constant::create(element::i32, Shape({1}), std::vector(1, 2))); - auto reshaped_norm = context.mark_node( - std::make_shared(reshaped_input, reduction_axes, true, eps, MVNEpsMode::INSIDE_SQRT)); - auto norm = context.mark_node(std::make_shared(reshaped_norm, input_shape, true)); - auto skip_last = context.mark_node(std::make_shared(input_rank, scalar_one)); - auto axes = context.mark_node(std::make_shared(scalar_one, skip_last, scalar_one, element::i32)); + auto eps = context.const_input(eps_idx); + + auto zero = context.mark_node(v0::Constant::create(element::i32, Shape{}, {0})); + auto one = context.mark_node(v0::Constant::create(element::i32, Shape{}, {1})); + auto shape = context.mark_node(std::make_shared(data, element::i32)); + auto channels = context.mark_node(std::make_shared(shape, one, zero)); + channels = context.mark_node(std::make_shared(channels, zero)); + + Output scale; if (!context.input_is_none(weights_idx)) { - auto weights = context.get_input(static_cast(weights_idx)); - weights = context.mark_node(std::make_shared(weights, axes)); - norm = context.mark_node(std::make_shared(norm, weights)); + scale = context.get_input(static_cast(weights_idx)); + } else { + scale = context.mark_node(std::make_shared(one, channels)); + scale = context.mark_node(std::make_shared(scale, data)); } + Output bias; if (!context.input_is_none(bias_idx)) { - auto bias = context.get_input(static_cast(bias_idx)); - bias = context.mark_node(std::make_shared(bias, axes)); - norm = context.mark_node(std::make_shared(norm, bias)); + bias = context.get_input(static_cast(bias_idx)); + } else { + bias = context.mark_node(std::make_shared(zero, channels)); + bias = context.mark_node(std::make_shared(bias, data)); } + auto norm = context.mark_node(std::make_shared(data, scale, bias, num_groups, eps)); // Input with index 5 is flag "cudnn_enabled" we can ignore it return {norm}; }; From ab952f511459c9d1d395c56bf960459565ad7554 Mon Sep 17 00:00:00 2001 From: Alexandra Sidorova Date: Thu, 15 Aug 2024 08:53:06 +0400 Subject: [PATCH 012/117] [Snippets] Fixed coverity (#26055) ### Details: - *Fixed the coverity warning "Division or modulo by zero": added validation checks for non-zero value before division/modulo* ### Tickets: - *149658* --- .../src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp | 1 + .../src/transformations/snippets/x64/op/brgemm_utils.cpp | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp index 1169e87753aec2..8d2f33b18513f6 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp @@ -57,6 +57,7 @@ jit_brgemm_copy_b_emitter::jit_brgemm_copy_b_emitter(jit_generator* h, cpu_isa_t m_inner_N_tail = m_N_blk % m_inner_N_block; m_brgemmVNNIFactor = compute_vnni_factor(m_brg_weight_etype); + OV_CPU_JIT_EMITTER_ASSERT(m_brgemmVNNIFactor > 0, "brgemmVNNIFactor value must be positive."); OV_CPU_JIT_EMITTER_ASSERT(m_K_blk == m_K || m_K_blk % m_brgemmVNNIFactor == 0, "K Block size (", m_K_blk, "), which is not divisible by brgemmVNNIFactor (", m_brgemmVNNIFactor, ") and not equal to K dimension (", m_K, diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp index 2535aa2d6118cf..4e8414d7d09430 100644 --- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp +++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp @@ -99,7 +99,9 @@ size_t get_repacking_buffer_size(const ov::snippets::lowered::ExpressionPtr& cop // Low precision repacking writes the result by m_brgemmVNNIFactor * m_inner_n_block blocks // despite the actual size of the input data. Because of that we have to round-up the allocation shape to always have enough memory allocated. // For the details, please see 'copy_4x64' and 'copy_2x32' implementations and usage in onednn/src/cpu/x64/matmul/brgemm_matmul_copy_utils.cpp - return N_dim * rnd_up(k_blk, brgemm_utils::compute_vnni_factor(precision)); + const auto brgemmVNNIFactor = brgemm_utils::compute_vnni_factor(precision); + OPENVINO_ASSERT(brgemmVNNIFactor > 0, "brgemmVNNIFactor value must be positive."); + return N_dim * rnd_up(k_blk, brgemmVNNIFactor); } } From 08d8cbdfa68da1f7cc91576c81a331194a8fb132 Mon Sep 17 00:00:00 2001 From: Alexey Smirnov Date: Thu, 15 Aug 2024 07:13:50 +0100 Subject: [PATCH 013/117] [NPUW] Support remote tensor in weights bank (#26034) Co-authored-by: Dmitry Matveev --- .../src/plugin/npuw/compiled_model.cpp | 6 +-- .../plugin/npuw/just_sync_infer_request.cpp | 5 +- .../src/plugin/npuw/weights_bank.cpp | 53 ++++++++++++++++--- .../src/plugin/npuw/weights_bank.hpp | 21 +++++--- 4 files changed, 67 insertions(+), 18 deletions(-) diff --git a/src/plugins/intel_npu/src/plugin/npuw/compiled_model.cpp b/src/plugins/intel_npu/src/plugin/npuw/compiled_model.cpp index 721f03185a80be..6cfb7fd7ce1dc7 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/compiled_model.cpp +++ b/src/plugins/intel_npu/src/plugin/npuw/compiled_model.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2023 Intel Corporation +// Copyright (C) 2023-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // #include "compiled_model.hpp" @@ -114,7 +114,7 @@ ov::npuw::CompiledModel::CompiledModel(const std::shared_ptr& model, // Initialize weights bank const std::string weights_bank_opt = m_cfg.get<::intel_npu::NPUW_WEIGHTS_BANK>(); - m_weights_bank = ov::npuw::weights::bank(weights_bank_opt); + m_weights_bank = ov::npuw::weights::bank(weights_bank_opt, plugin->get_core()); LOG_VERB("*** Original model ***"); const auto& orig_parameters = model->get_parameters(); @@ -402,7 +402,7 @@ void ov::npuw::CompiledModel::fill_weights_bank(const std::size_t idx) { auto& comp_model_desc = m_compiled_submodels[idx]; for (std::size_t cidx = 0u; cidx < comp_model_desc.closure.size(); cidx++) { - comp_model_desc.closure[cidx] = m_weights_bank->get(comp_model_desc.closure[cidx]); + comp_model_desc.closure[cidx] = m_weights_bank->update(comp_model_desc.closure[cidx]); if (m_cfg.get<::intel_npu::NPUW_FOLD>()) { comp_model_desc.update_required[cidx] = true; } else { diff --git a/src/plugins/intel_npu/src/plugin/npuw/just_sync_infer_request.cpp b/src/plugins/intel_npu/src/plugin/npuw/just_sync_infer_request.cpp index e64597abffe107..6bd1b296c3a9a9 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/just_sync_infer_request.cpp +++ b/src/plugins/intel_npu/src/plugin/npuw/just_sync_infer_request.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2023 Intel Corporation +// Copyright (C) 2023-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // @@ -171,6 +171,7 @@ ov::npuw::JustInferRequest::JustInferRequest(const std::shared_ptrm_weights_bank; for (size_t i = 0; i < m_num_submodels; i++) { LOG_VERB("Trying to preemptively set tensors for Subgraph[" << i << "]..."); LOG_BLOCK(); @@ -193,7 +194,7 @@ ov::npuw::JustInferRequest::JustInferRequest(const std::shared_ptrset_tensor(iport, ov::get_tensor_impl(closure)); + request->set_tensor(iport, ov::get_tensor_impl(wbank->get(closure, *func_desc.device_it))); } } // for(closure) LOG_VERB("DONE"); diff --git a/src/plugins/intel_npu/src/plugin/npuw/weights_bank.cpp b/src/plugins/intel_npu/src/plugin/npuw/weights_bank.cpp index 38a2fdd42a4a4e..08181f80e7f39a 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/weights_bank.cpp +++ b/src/plugins/intel_npu/src/plugin/npuw/weights_bank.cpp @@ -20,7 +20,7 @@ class BankManager { public: // Public API - std::shared_ptr getBank(const std::string& bank_name); + std::shared_ptr getBank(const std::string& bank_name, const std::shared_ptr& core); private: // Data @@ -28,7 +28,7 @@ class BankManager { std::mutex m_mutex; }; -ov::Tensor Bank::get(const ov::Tensor& tensor) { +ov::Tensor Bank::update(const ov::Tensor& tensor) { if (!tensor) { OPENVINO_THROW("Uninitialized tensor in weights bank allocation!"); } @@ -43,24 +43,63 @@ ov::Tensor Bank::get(const ov::Tensor& tensor) { return tensor; } -std::shared_ptr BankManager::getBank(const std::string& bank_name) { +ov::Tensor Bank::get(const ov::Tensor& tensor, const std::string& device) { + if (!tensor) { + OPENVINO_THROW("Uninitialized tensor in weights bank allocation!"); + } + + if (device != "CPU" && device != "NPU") { + OPENVINO_THROW("Unsupported device in weights bank allocation: ", device); + } + + std::lock_guard guard(m_mutex); + + auto iter_cpu = m_bank.find(tensor.data()); + if (iter_cpu == m_bank.end()) { + OPENVINO_THROW("Unknown tensor in weights bank allocation!"); + } + + // If target device is CPU - just reuse the default bank + if (device == "CPU") { + return iter_cpu->second; + } + + // Non-CPU - check if the tensor is already there + auto& device_bank = m_device_bank[device]; + auto iter_device = device_bank.find(tensor.data()); + if (iter_device != device_bank.end()) { + // Already allocated on the device - reuse + return iter_device->second; + } + + // Allocation needed + m_remote_ctx = m_core->get_default_context(device)._ptr; + auto remote_tensor = m_remote_ctx->create_host_tensor(tensor.get_element_type(), tensor.get_shape()); + auto allocated_tensor = ov::make_tensor(remote_tensor); + tensor.copy_to(allocated_tensor); + device_bank[tensor.data()] = allocated_tensor; + return allocated_tensor; +} + +std::shared_ptr BankManager::getBank(const std::string& bank_name, const std::shared_ptr& core) { std::lock_guard guard(m_mutex); auto iter = m_bank_map.find(bank_name); if (iter == m_bank_map.end()) { - auto bank = std::make_shared(); + auto bank = std::make_shared(core); m_bank_map[bank_name] = bank; return bank; } return iter->second.lock(); } -std::shared_ptr ov::npuw::weights::bank(const std::string& bank_name) { +std::shared_ptr ov::npuw::weights::bank(const std::string& bank_name, + const std::shared_ptr& core) { if (bank_name.empty()) { // Don't share this bank in manager - return std::make_shared(); + return std::make_shared(core); } auto& instance = BankManager::getInstance(); - return instance.getBank(bank_name); + return instance.getBank(bank_name, core); } diff --git a/src/plugins/intel_npu/src/plugin/npuw/weights_bank.hpp b/src/plugins/intel_npu/src/plugin/npuw/weights_bank.hpp index 1ddd00750d36f5..c8efa46a30116c 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/weights_bank.hpp +++ b/src/plugins/intel_npu/src/plugin/npuw/weights_bank.hpp @@ -1,4 +1,4 @@ -// Copyright (C) 2023 Intel Corporation +// Copyright (C) 2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // @@ -9,7 +9,8 @@ #include #include -#include "openvino/openvino.hpp" +#include "openvino/runtime/iplugin.hpp" +#include "openvino/runtime/iremote_context.hpp" #include "openvino/runtime/make_tensor.hpp" #include "openvino/runtime/tensor.hpp" @@ -19,17 +20,25 @@ namespace weights { class Bank { public: - Bank() = default; + explicit Bank(const std::shared_ptr& core) : m_core(core) {} - ov::Tensor get(const ov::Tensor& tensor); + // Capture CPU version of the tensor + ov::Tensor update(const ov::Tensor& tensor); + + // Based on previously captured tensor allocate a new tensor (if needed) on a specified device + ov::Tensor get(const ov::Tensor& tensor, const std::string& device); private: - // Note: suits both - remote and ordinary tensors + // Default CPU bank. Filled by update() std::unordered_map m_bank; + // Bank for specified device and their allocated memory + std::unordered_map> m_device_bank; std::mutex m_mutex; + std::shared_ptr m_core = nullptr; + std::shared_ptr m_remote_ctx = nullptr; }; -std::shared_ptr bank(const std::string& bank_name); +std::shared_ptr bank(const std::string& bank_name, const std::shared_ptr& core); } // namespace weights } // namespace npuw From 9b8a813f5dd64d9bc22bc46937433173688908c7 Mon Sep 17 00:00:00 2001 From: Bogdan Pereanu Date: Thu, 15 Aug 2024 10:48:55 +0300 Subject: [PATCH 014/117] [NPU] Fix NPU coverity issues (#26059) ### Details: - *Fix the NPU coverity issues* ### Tickets: - *EISW-134105* --- src/plugins/intel_npu/src/al/src/remote_tensor.cpp | 2 +- src/plugins/intel_npu/src/backend/src/zero_host_tensor.cpp | 7 ++++++- .../intel_npu/src/backend/src/zero_infer_request.cpp | 2 +- .../intel_npu/src/backend/src/zero_remote_tensor.cpp | 4 ++-- .../intel_npu/src/compiler/src/zero_compiler_in_driver.cpp | 2 +- src/plugins/intel_npu/src/plugin/include/metrics.hpp | 2 +- src/plugins/intel_npu/src/plugin/src/compiled_model.cpp | 2 +- src/plugins/intel_npu/src/plugin/src/metrics.cpp | 2 +- 8 files changed, 14 insertions(+), 9 deletions(-) diff --git a/src/plugins/intel_npu/src/al/src/remote_tensor.cpp b/src/plugins/intel_npu/src/al/src/remote_tensor.cpp index 58035243100828..1055e6a57dc537 100644 --- a/src/plugins/intel_npu/src/al/src/remote_tensor.cpp +++ b/src/plugins/intel_npu/src/al/src/remote_tensor.cpp @@ -13,7 +13,7 @@ namespace intel_npu { RemoteTensor::RemoteTensor(std::shared_ptr context, const ov::element::Type& element_type, const ov::Shape& shape) - : _context(context), + : _context(std::move(context)), _element_type(element_type), _shape(shape), _capacity(shape) { diff --git a/src/plugins/intel_npu/src/backend/src/zero_host_tensor.cpp b/src/plugins/intel_npu/src/backend/src/zero_host_tensor.cpp index e4ebe2c1d5a8ba..e0f1094e67da05 100644 --- a/src/plugins/intel_npu/src/backend/src/zero_host_tensor.cpp +++ b/src/plugins/intel_npu/src/backend/src/zero_host_tensor.cpp @@ -22,7 +22,12 @@ ZeroHostTensor::ZeroHostTensor(std::shared_ptr context, ov::intel_npu::MemType::L0_INTERNAL_BUF)) {} void* ZeroHostTensor::data(const ov::element::Type&) const { - return m_impl->get_properties().find(ov::intel_npu::mem_handle.name())->second.as(); + auto itrHandle = m_impl->get_properties().find(ov::intel_npu::mem_handle.name()); + if (itrHandle == m_impl->get_properties().end()) { + OPENVINO_THROW("No parameter ", ov::intel_npu::mem_handle.name(), " found in parameters map"); + } + + return ov::Any(itrHandle->second).as(); } const ov::element::Type& ZeroHostTensor::get_element_type() const { diff --git a/src/plugins/intel_npu/src/backend/src/zero_infer_request.cpp b/src/plugins/intel_npu/src/backend/src/zero_infer_request.cpp index 27c1aac7eeeff5..4771e4543479cf 100644 --- a/src/plugins/intel_npu/src/backend/src/zero_infer_request.cpp +++ b/src/plugins/intel_npu/src/backend/src/zero_infer_request.cpp @@ -395,7 +395,7 @@ void ZeroInferRequest::set_tensor(const ov::Output& port, const set_tensor_data(tensor._ptr, foundPort.idx, foundPort.is_input()); } else { _logger.debug("ZeroInferRequest::set_tensor - set new remote tensor"); - set_remote_tensor_data(remoteTensor, foundPort.idx, foundPort.is_input()); + set_remote_tensor_data(std::move(remoteTensor), foundPort.idx, foundPort.is_input()); } } } diff --git a/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp b/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp index a97073d3324126..d27ee74d9e5d1e 100644 --- a/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp +++ b/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp @@ -28,10 +28,10 @@ ZeroRemoteTensor::ZeroRemoteTensor(std::shared_ptr context, TensorType tensor_type, MemType mem_type, void* mem) - : RemoteTensor(context, element_type, shape), + : RemoteTensor(std::move(context), element_type, shape), _config(config), _logger("ZeroRemoteContext", _config.get()), - _init_structs(init_structs), + _init_structs(std::move(init_structs)), _tensor_type(tensor_type), _mem_type(mem_type), _mem(mem) { diff --git a/src/plugins/intel_npu/src/compiler/src/zero_compiler_in_driver.cpp b/src/plugins/intel_npu/src/compiler/src/zero_compiler_in_driver.cpp index efe8d2e594f5b7..cbf585a2bd8815 100644 --- a/src/plugins/intel_npu/src/compiler/src/zero_compiler_in_driver.cpp +++ b/src/plugins/intel_npu/src/compiler/src/zero_compiler_in_driver.cpp @@ -988,7 +988,7 @@ static IODescriptor getIODescriptor(const ze_graph_argument_properties_3_t& arg, isShapeTensor = true; } - return {nameFromCompiler, + return {std::move(nameFromCompiler), precision, std::move(shapeFromCompiler), isStateInput, diff --git a/src/plugins/intel_npu/src/plugin/include/metrics.hpp b/src/plugins/intel_npu/src/plugin/include/metrics.hpp index 9b1a8be694d33a..abd24a3c1b092c 100644 --- a/src/plugins/intel_npu/src/plugin/include/metrics.hpp +++ b/src/plugins/intel_npu/src/plugin/include/metrics.hpp @@ -26,7 +26,7 @@ class Metrics final { std::string GetFullDeviceName(const std::string& specifiedDeviceName) const; IDevice::Uuid GetDeviceUuid(const std::string& specifiedDeviceName) const; const std::vector& GetSupportedConfigKeys() const; - const std::vector& GetOptimizationCapabilities() const; + const std::vector GetOptimizationCapabilities() const; const std::tuple& GetRangeForAsyncInferRequest() const; const std::tuple& GetRangeForStreams() const; std::string GetDeviceArchitecture(const std::string& specifiedDeviceName) const; diff --git a/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp b/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp index d584c62704fbf9..54942d1416208e 100644 --- a/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp +++ b/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp @@ -214,7 +214,7 @@ void CompiledModel::configure_stream_executors() { } void CompiledModel::initialize_properties() { - const auto pluginSupportedProperties = + const auto& pluginSupportedProperties = get_plugin()->get_property(ov::supported_properties.name(), {}).as>(); const auto isPropertySupported = [&pluginSupportedProperties](const std::string& name) { return std::any_of(pluginSupportedProperties.begin(), diff --git a/src/plugins/intel_npu/src/plugin/src/metrics.cpp b/src/plugins/intel_npu/src/plugin/src/metrics.cpp index 565dad5edc5793..f363d1ad9a29b4 100644 --- a/src/plugins/intel_npu/src/plugin/src/metrics.cpp +++ b/src/plugins/intel_npu/src/plugin/src/metrics.cpp @@ -65,7 +65,7 @@ const std::vector& Metrics::GetSupportedConfigKeys() const { } // TODO each backend may support different optimization capabilities -const std::vector& Metrics::GetOptimizationCapabilities() const { +const std::vector Metrics::GetOptimizationCapabilities() const { return _optimizationCapabilities; } From 848b5ca37a10a326abef0701f46d8795bbc5020d Mon Sep 17 00:00:00 2001 From: Vladislav Golubev Date: Thu, 15 Aug 2024 11:18:11 +0200 Subject: [PATCH 015/117] [Snippets] Dynamic SplitDimensionM via runtime configurator (#25733) ### Details: - *Introduced `ParallelWAOptimizer` class, which is used in RuntimeConfigurator to split M dimension of LIR with brgemms in order to optimize parallel work amount* ### Tickets: - *147834* --- .../snippets/lowered/pass/init_loops.hpp | 12 +- .../snippets/pass/split_dimension_m.hpp | 40 ++- .../include/snippets/runtime_configurator.hpp | 86 +++++- .../snippets/include/snippets/utils/utils.hpp | 13 + .../snippets/src/lowered/pass/init_loops.cpp | 39 +-- .../snippets/src/pass/split_dimension_m.cpp | 85 +++--- .../snippets/src/runtime_configurator.cpp | 273 +++++++++++++++--- src/common/snippets/src/utils/utils.cpp | 34 +++ .../snippets/cpu_runtime_configurator.cpp | 21 +- .../snippets/cpu_runtime_configurator.hpp | 7 +- .../transformation_pipeline.cpp | 20 +- .../skip_tests_config.cpp | 2 +- .../shared_tests_instances/snippets/mha.cpp | 78 ++++- 13 files changed, 575 insertions(+), 135 deletions(-) diff --git a/src/common/snippets/include/snippets/lowered/pass/init_loops.hpp b/src/common/snippets/include/snippets/lowered/pass/init_loops.hpp index 9696040d949c54..367715140a1bf4 100644 --- a/src/common/snippets/include/snippets/lowered/pass/init_loops.hpp +++ b/src/common/snippets/include/snippets/lowered/pass/init_loops.hpp @@ -24,7 +24,17 @@ class InitLoops : public Pass { InitLoops() = default; bool run(LinearIR& linear_ir) override; - static void init_loop_info(const UnifiedLoopInfoPtr& loop_info, size_t loop_id, bool only_runtime_args = false); + /** + * @brief Updates ptr_increments and finalization offsets of the provided "loop_info" based on current work amount + */ + static void update_data_pointer_shifts(const UnifiedLoopInfoPtr& loop_info); + /** + * @brief Updates work amount and updates data pointer shifts of the provided "loop_info" + */ + static void update_runtime_parameters(const UnifiedLoopInfoPtr& loop_info); + +private: + static void update_compile_parameters(const UnifiedLoopInfoPtr& loop_info, size_t loop_id); }; } // namespace pass diff --git a/src/common/snippets/include/snippets/pass/split_dimension_m.hpp b/src/common/snippets/include/snippets/pass/split_dimension_m.hpp index e6d808794a164e..e9a9a46d3847ff 100644 --- a/src/common/snippets/include/snippets/pass/split_dimension_m.hpp +++ b/src/common/snippets/include/snippets/pass/split_dimension_m.hpp @@ -14,6 +14,9 @@ namespace pass { * @interface SplitDimensionM * @brief Inserts Reshape nodes before inputs and after outputs of Subgraphs with MatMul inside * to split dimension M for MatMuls. It allows to increase work amount for parallelism + * @attention This pass works only for MHA with static shapes. + * For dynamic shapes, parallel work amount is optimized in RuntimeConfigurator. + * @todo Ticket 148805: Move static cases handling in RuntimeConfigurator as well. * @ingroup snippets */ class SplitDimensionM: public CommonOptimizations::SubgraphPass { @@ -28,17 +31,48 @@ class SplitDimensionM: public CommonOptimizations::SubgraphPass { // Returns True if parallelism work amount (concurrency) can be increased by this optimization static bool can_be_optimized(const std::shared_ptr& node, size_t concurrency); + /** + * @brief Tries to split M dimension in "shape" in accordance to optimal parallel work amount + * @param shape Original shape + * @param optimal_parallelism_work_amount Optimal work amount + * @param batch_m_dim reference on batch's part of the split M + * @param new_m_dim reference on new M dim after the split + * @return true if split was successfull, otherwise false + */ + static bool split(const ov::Shape& shape, size_t optimal_parallelism_work_amount, size_t& batch_m_dim, size_t& new_m_dim); + + /** + * @brief Splits m dimension in order + * @param order Original order + * @param m_index M dimension index + * @return updated order with the split M dimension + */ + static std::vector get_updated_order(const std::vector& order, size_t m_index); + /** + * @brief Reshapes m dimension in "shape": separates M in two parts: "batch_m_dim" and "new_m_dim" + * @param shape Shape to split + * @param m_index M dimension index + * @param batch_m_dim batch's part of the split M + * @param new_m_dim new M dim after the split + * @return the updated shape + */ + static ov::snippets::VectorDims reshape_m_dim(ov::snippets::VectorDims shape, size_t m_index, size_t batch_m_dim, size_t new_m_dim); + /** + * @brief Unsqueezes m dimension in "shape" (inserts "1" before the dimension) + * @param shape Shape to split + * @param m_index M dimension index + * @return the updated shape + */ + static ov::snippets::VectorDims unsqueeze_m_dim(ov::snippets::VectorDims shape, size_t m_index); + private: static std::shared_ptr get_matmul(const std::shared_ptr& subgraph); static std::pair get_splited_dimensions(size_t batch_dim, size_t m_dim, size_t optimal_parallelism_work_amount); - static bool split(const ov::Shape& shape, size_t optimal_parallelism_work_amount, size_t& batch_m_dim, size_t& new_m_dim); void reshape_subgraph(const std::shared_ptr& subgraph, const ov::Shape& shape, size_t batch_m_dim, size_t new_m_dim); size_t m_concurrency; }; - - } // namespace pass } // namespace snippets } // namespace ov diff --git a/src/common/snippets/include/snippets/runtime_configurator.hpp b/src/common/snippets/include/snippets/runtime_configurator.hpp index 396f76fab9304a..af01757cb0194f 100644 --- a/src/common/snippets/include/snippets/runtime_configurator.hpp +++ b/src/common/snippets/include/snippets/runtime_configurator.hpp @@ -5,6 +5,7 @@ #pragma once #include "snippets/lowered/linear_ir.hpp" +#include "snippets/lowered/loop_info.hpp" #include "snippets/kernel_executor_table.hpp" #include "snippets/lowered/pass/pass.hpp" @@ -82,8 +83,14 @@ class RuntimeConfigurator { /** * @brief Update RuntimeConfig based on LinearIR * @param linear_ir LinearIR + * @todo Ticket 148891: Rewrite on PassPipeline */ virtual void update(const lowered::LinearIRCPtr& linear_ir); + /** + * @brief Update tensor rank based on master shape + * @param master_shape Master shape + */ + virtual void update_tensor_rank(const ov::snippets::VectorDims& master_shape); /** * @brief Allocate and intialize fields in RuntimeConfig and RuntimeConfigurator * @param linear_ir LinearIR @@ -109,11 +116,21 @@ class RuntimeConfigurator { * @param linear_ir LinearIR */ virtual void init_tensor_rank(const lowered::LinearIRCPtr& linear_ir) const; + + struct UnifiedLoopInfoRtParams { + size_t work_amount = 0; + std::vector ptr_increments; + std::vector finalization_offsets; + }; + static UnifiedLoopInfoRtParams compute_runtime_params(const lowered::UnifiedLoopInfoPtr& unified_loop_info); + using LoopInfoRuntimeParamsMap = std::unordered_map; /** * @brief Update Loop informations in LinearIR: Unified and ExpandedLoopInfo * @param linear_ir LinearIR + * @param initializated_info_map Reference on a map [LoopInfo->RuntimeParams]. + * Can be used to pass in the method loop infos which were already initialized, e.g. by parallel domain optimization */ - void update_loop_info(const lowered::LinearIRCPtr& linear_ir) const; + void update_loop_info(const lowered::LinearIRCPtr& linear_ir, LoopInfoRuntimeParamsMap& initializated_info_map) const; /** * @brief Update Buffer scratchpad size and offsets if needed * Note: `update_loop_info` must be called before @@ -122,12 +139,73 @@ class RuntimeConfigurator { void update_buffer_scratchpad_size(const lowered::LinearIRCPtr& linear_ir) const; /** * @brief Calculate data offsets of LinearIR and update these values in RuntimeConfig + * @param shapes shapes used in offsets computation + * @param layouts layouts used in offsets computation + */ + void update_data_offsets(const std::vector& shapes, + const std::vector>& layouts) const; + /** + * @brief Extract shapes from m_io_descs */ - void update_data_offsets() const; + std::vector extract_shapes() const; /** - * @brief Update latest input shapes + * @brief Extract layouts from m_io_descs */ - void update_latest_shapes(); + std::vector> extract_layouts() const; + + class ParallelWAOptimizer { + public: + /** + * @brief Inits ParallelWAOptimizer: computes optimizer parameters which should be set at compilation stage + * @param linear_ir LinearIR + * @param io_descs Input/output descriptors which are used for optimizer parameters initialization + * @param in_num Number of inputs. It is needed to distinguish input and output shapes/layouts + */ + void init(const ov::snippets::lowered::LinearIRCPtr& linear_ir, + const std::vector& io_descs, + size_t in_num); + /** + * @brief Checks if optimizer is enabled + * @todo Ticket 148891: when RuntimeConfigurator::update will be rewritten on PassPipeline, this method should be removed + * We will not just register ParallelWAOptimizer in case if it is not needed + */ + bool enabled(); + /** + * @brief Checks if the current master shape can be optimized, and if yes, updates all the necessary runtime information + * @param master_shape Master shape + * @param map Loop info -> Runtime params map which will be passed in "update_loop_info" + * the map is filled with updated loops_to_split loops: "new_m" work amount is set for them, and runtime params are updated correspondingly + * @param shapes Vector which is filled with the split shapes + * @param layouts Vector which is filled with the split layouts + * @param in_num Number of inputs. It is needed to distinguish input and output shapes/layouts + * @return status if the optimization is applied + */ + void optimize(ov::snippets::VectorDims& master_shape, + ov::snippets::RuntimeConfigurator::LoopInfoRuntimeParamsMap& map, + std::vector& shapes, + std::vector>& layouts, + size_t in_num); + + private: + void update_master_shape(ov::snippets::VectorDims& master_shape, size_t new_batch_dim, size_t new_kernel_dim); + void update_split_loops_info(ov::snippets::RuntimeConfigurator::LoopInfoRuntimeParamsMap& map, size_t new_kernel_dim); + void update_shapes(std::vector& shapes, size_t new_batch_dim, size_t new_kernel_dim); + void update_layouts(std::vector>& layouts); + + static std::unordered_set find_applicable_brgemms(const ov::snippets::lowered::LinearIRCPtr& linear_ir); + static std::unordered_set find_unsqueezed_params( + const ov::snippets::lowered::LinearIRCPtr& linear_ir, + const std::unordered_set& brgemms); + static std::unordered_set find_loops_to_split( + const ov::snippets::lowered::LinearIRCPtr& linear_ir, + const std::unordered_set& unsqueezed_params); + + std::unordered_set loops_to_split{}; + std::unordered_set unsqueezed_params{}; + std::vector> optimized_layouts{}; + std::vector m_dim_idces{}; + size_t concurrency = 0; + } m_optimizer; std::shared_ptr m_config = nullptr; diff --git a/src/common/snippets/include/snippets/utils/utils.hpp b/src/common/snippets/include/snippets/utils/utils.hpp index f576f4e3988c56..e9a7e7d1ca9523 100644 --- a/src/common/snippets/include/snippets/utils/utils.hpp +++ b/src/common/snippets/include/snippets/utils/utils.hpp @@ -275,6 +275,19 @@ std::shared_ptr get_leaf_node_of_first_parent_shape_infer_seq(const st int64_t get_dim_stride(const lowered::ExpressionPort& expr_port, size_t idx = 1); +/** + * @brief Traverses path starting from "expr", and calls "func" for each expression. + * Traversal direction is defined by "visit_parent_path" + * @param expr The expr from which path is started. + * @param visited Set of expressions which were visited. + * @param func The function which is called for each visited node. + * @param visit_parent_path if true, parent nodes are visited. Otherwise, consumers are visited. + */ +void visit_path(const lowered::ExpressionPtr& expr, + std::unordered_set& visited, + std::function func, + bool visit_parent_path); + } // namespace utils } // namespace snippets } // namespace ov diff --git a/src/common/snippets/src/lowered/pass/init_loops.cpp b/src/common/snippets/src/lowered/pass/init_loops.cpp index 61c33dc277801f..18575131aad306 100644 --- a/src/common/snippets/src/lowered/pass/init_loops.cpp +++ b/src/common/snippets/src/lowered/pass/init_loops.cpp @@ -120,32 +120,34 @@ inline void init_work_amount(const LoopInfoPtr& loop_info) { } } // namespace -void InitLoops::init_loop_info(const UnifiedLoopInfoPtr& loop_info, const size_t loop_id, bool only_runtime_args) { - OPENVINO_ASSERT(loop_info != nullptr, "UnifiedLoopInfo is nullptr, nothing to initialize"); - if (!loop_info->is_work_amount_const()) - init_work_amount(loop_info); +void InitLoops::update_compile_parameters(const UnifiedLoopInfoPtr& loop_info, size_t loop_id) { + OPENVINO_ASSERT(loop_info != nullptr, "UnifiedLoopInfo is nullptr, nothing to update"); + loop_info->iterate_through_infos( + [loop_id](LoopPort& loop_port, UnifiedLoopInfo::LoopPortDesc& ptr_shifts_params) { + init_is_incremented(loop_port, loop_id); + ptr_shifts_params.data_size = get_data_size(loop_port); + }); +} +void InitLoops::update_data_pointer_shifts(const UnifiedLoopInfoPtr& loop_info) { + OPENVINO_ASSERT(loop_info != nullptr, "UnifiedLoopInfo is nullptr, nothing to update"); const auto work_amount = loop_info->get_work_amount(); const auto input_count = loop_info->get_input_count(); const auto output_count = loop_info->get_output_count(); - auto init_runtime_parameters = [&work_amount, &input_count, &output_count](LoopPort& loop_port, UnifiedLoopInfo::LoopPortDesc& ptr_shifts_params) { + auto update_shifts = [&work_amount, &input_count, &output_count](LoopPort& loop_port, UnifiedLoopInfo::LoopPortDesc& ptr_shifts_params) { ptr_shifts_params.ptr_increment = get_ptr_increment(loop_port, work_amount, loop_port.expr_port->get_type() == ExpressionPort::Input ? input_count : output_count); ptr_shifts_params.finalization_offset = get_finalization_offset(work_amount, ptr_shifts_params.ptr_increment); }; + loop_info->iterate_through_infos(update_shifts); +} - auto init_all_parameters = [loop_id, &init_runtime_parameters](LoopPort& loop_port, UnifiedLoopInfo::LoopPortDesc& ptr_shifts_params) { - init_is_incremented(loop_port, loop_id); - ptr_shifts_params.data_size = get_data_size(loop_port); - init_runtime_parameters(loop_port, ptr_shifts_params); - }; - - if (only_runtime_args) { - loop_info->iterate_through_infos(init_runtime_parameters); - } else { - loop_info->iterate_through_infos(init_all_parameters); - } +void InitLoops::update_runtime_parameters(const UnifiedLoopInfoPtr& loop_info) { + OPENVINO_ASSERT(loop_info != nullptr, "UnifiedLoopInfo is nullptr, nothing to update"); + if (!loop_info->is_work_amount_const()) + init_work_amount(loop_info); + update_data_pointer_shifts(loop_info); } bool InitLoops::run(LinearIR& linear_ir) { @@ -156,7 +158,10 @@ bool InitLoops::run(LinearIR& linear_ir) { const auto& loop_manager = linear_ir.get_loop_manager(); const auto& loops = loop_manager->get_map(); for (const auto& loop : loops) { - init_loop_info(ov::as_type_ptr(loop.second), loop.first); + const auto& loop_id = loop.first; + const auto& loop_info = ov::as_type_ptr(loop.second); + update_compile_parameters(loop_info, loop_id); + update_runtime_parameters(loop_info); } return true; diff --git a/src/common/snippets/src/pass/split_dimension_m.cpp b/src/common/snippets/src/pass/split_dimension_m.cpp index d43f53c7c16b17..0f50ad27931e04 100644 --- a/src/common/snippets/src/pass/split_dimension_m.cpp +++ b/src/common/snippets/src/pass/split_dimension_m.cpp @@ -23,13 +23,15 @@ bool is_prime_number(size_t value) { } } // namespace -bool ov::snippets::pass::SplitDimensionM::is_supported_matmul(const std::shared_ptr& node) { +namespace ov { +namespace snippets { +namespace pass { +bool SplitDimensionM::is_supported_matmul(const std::shared_ptr& node) { const auto matmul = ov::as_type_ptr(node); return matmul && !matmul->get_transpose_a() && !matmul->is_dynamic(); } -std::pair ov::snippets::pass::SplitDimensionM::get_splited_dimensions(size_t batch_dim, size_t m_dim, - size_t optimal_parallelism_work_amount) { +std::pair SplitDimensionM::get_splited_dimensions(size_t batch_dim, size_t m_dim, size_t optimal_parallelism_work_amount) { std::pair splited = { 1, m_dim }; const size_t lower_bound = optimal_parallelism_work_amount / batch_dim; @@ -53,14 +55,42 @@ std::pair ov::snippets::pass::SplitDimensionM::get_splited_dimen return splited; } -bool ov::snippets::pass::SplitDimensionM::can_be_optimized(const std::shared_ptr& node, size_t concurrency) { +bool SplitDimensionM::can_be_optimized(const std::shared_ptr& node, size_t concurrency) { if (!is_supported_matmul(node)) return false; size_t batch_m_dim, new_m_dim; return split(node->get_shape(), concurrency, batch_m_dim, new_m_dim); } -std::shared_ptr ov::snippets::pass::SplitDimensionM::get_matmul(const std::shared_ptr& subgraph) { +std::vector SplitDimensionM::get_updated_order(const std::vector& order, size_t m_index) { + std::vector new_order(order.size() + 1, 0); + size_t shift_idx = 0; + for (size_t i = 0; i < order.size(); ++i) { + if (order[i] < m_index) { + new_order[i + shift_idx] = order[i]; + } else if (order[i] == m_index) { + new_order[i + shift_idx++] = order[i]; + new_order[i + shift_idx] = order[i] + 1; + } else { + new_order[i + shift_idx] = order[i] + 1; + } + } + return new_order; +} + +ov::snippets::VectorDims SplitDimensionM::reshape_m_dim(ov::snippets::VectorDims shape, size_t m_index, size_t batch_m_dim, size_t new_m_dim) { + if (shape[m_index] == 1) + return unsqueeze_m_dim(std::move(shape), m_index); + shape[m_index] = new_m_dim; + shape.insert(shape.begin() + m_index, batch_m_dim); + return shape; +} +ov::snippets::VectorDims SplitDimensionM::unsqueeze_m_dim(ov::snippets::VectorDims shape, size_t m_index) { + shape.insert(shape.begin() + m_index, 1); + return shape; +} + +std::shared_ptr SplitDimensionM::get_matmul(const std::shared_ptr& subgraph) { const auto& body = subgraph->body_ptr(); const auto& parameters = body->get_parameters(); // [107806]: If count of Parameters isn't equal to Subgraph inputs (it's possible case in general), @@ -79,7 +109,7 @@ std::shared_ptr ov::snippets::pass::SplitDimensionM::get_mat return is_supported_matmul(matmul0) ? ov::as_type_ptr(matmul0) : nullptr; } -bool ov::snippets::pass::SplitDimensionM::split(const ov::Shape& shape, size_t optimal_parallelism_work_amount, size_t& batch_m_dim, size_t& new_m_dim) { +bool SplitDimensionM::split(const ov::Shape& shape, size_t optimal_parallelism_work_amount, size_t& batch_m_dim, size_t& new_m_dim) { const auto batch_dim = std::accumulate(shape.rbegin() + 2, shape.rend(), size_t(1), std::multiplies()); // B (batch) const auto m_dim = get_dim_M(shape); // M @@ -98,8 +128,7 @@ bool ov::snippets::pass::SplitDimensionM::split(const ov::Shape& shape, size_t o return is_optimized(batch_dim * batch_m_dim); } -void ov::snippets::pass::SplitDimensionM::reshape_subgraph(const std::shared_ptr& subgraph, - const ov::Shape& shape, size_t batch_m_dim, size_t new_m_dim) { +void SplitDimensionM::reshape_subgraph(const std::shared_ptr& subgraph, const ov::Shape& shape, size_t batch_m_dim, size_t new_m_dim) { const auto& body = subgraph->body_ptr(); const auto& parameters = body->get_parameters(); const auto& results = body->get_results(); @@ -121,42 +150,20 @@ void ov::snippets::pass::SplitDimensionM::reshape_subgraph(const std::shared_ptr reshaped_params.insert(param); }; - auto get_updated_shape = [&](const ov::Shape& shape, size_t m_index, bool split_m_dim) { + auto get_updated_shape = [&](const ov::snippets::VectorDims& shape, size_t m_index, bool split_m_dim) { const auto current_m_dim = shape[m_index]; OPENVINO_ASSERT(!split_m_dim || current_m_dim == 1 || current_m_dim == m_dim, "Incorrect shape for splitting!"); - ov::Shape new_shape = shape; - if ((split_m_dim && current_m_dim == 1) || !split_m_dim) { - new_shape.insert(new_shape.begin() + m_index, 1); - } else { - new_shape[m_index] = new_m_dim; - new_shape.insert(new_shape.begin() + m_index, batch_m_dim); - } + const auto new_shape = split_m_dim ? reshape_m_dim(shape, m_index, batch_m_dim, new_m_dim) : unsqueeze_m_dim(shape, m_index); OPENVINO_ASSERT(ov::shape_size(new_shape) == ov::shape_size(shape), "Incorrect shape splitting!"); return new_shape; }; - auto get_updated_order = [](const std::vector& order, int m_index) { - std::vector new_order(order.size() + 1, 0); - size_t shift_idx = 0; - for (size_t i = 0; i < order.size(); ++i) { - if (order[i] < m_index) { - new_order[i + shift_idx] = order[i]; - } else if (order[i] == m_index) { - new_order[i + shift_idx++] = order[i]; - new_order[i + shift_idx] = order[i] + 1; - } else { - new_order[i + shift_idx] = order[i] + 1; - } - } - return new_order; - }; - auto reshape_transpose = [&](const std::shared_ptr& transpose, bool is_input) -> size_t { const auto order_constant = ov::as_type_ptr(transpose->get_input_node_shared_ptr(1)); OPENVINO_ASSERT(order_constant != nullptr, "Transpose must have Constant order"); - const auto order = order_constant->cast_vector(); + const auto order = order_constant->cast_vector(); const auto m_index = is_input ? order[order.size() - 2] : order.size() - 2; // Index of M dimension in the previous order - const auto new_order = get_updated_order(order, static_cast(m_index)); + const auto new_order = get_updated_order(order, m_index); transpose->set_argument(1, std::make_shared(order_constant->get_element_type(), ov::Shape{new_order.size()}, new_order)); return m_index; }; @@ -201,9 +208,10 @@ void ov::snippets::pass::SplitDimensionM::reshape_subgraph(const std::shared_ptr softmax_v1->set_axis(softmax_v1->get_output_partial_shape(0).size()); // since new_shape.size() = old_shape.size() + 1 } else if (const auto broadcast = ov::as_type_ptr(op)) { // Broadcast is tokenized only between MatMuls -> Split M dimension - const auto shape_const = ov::as_type_ptr(broadcast->input_value(1).get_node_shared_ptr()); + const auto shape_const = ov::as_type_ptr(broadcast->get_input_node_shared_ptr(1)); OPENVINO_ASSERT(shape_const, "SplitDimensionM expects Broadcast with Constant output shape"); - const auto new_shape = get_updated_shape(shape_const->cast_vector(), broadcast->get_output_shape(0).size() - 2, true); + const auto m_dim_idx = broadcast->get_output_partial_shape(0).size() - 2; + const auto new_shape = get_updated_shape(shape_const->cast_vector(), m_dim_idx, true); broadcast->set_argument(1, std::make_shared(shape_const->get_element_type(), ov::Shape{new_shape.size()}, new_shape)); } } @@ -251,7 +259,7 @@ void ov::snippets::pass::SplitDimensionM::reshape_subgraph(const std::shared_ptr subgraph->validate_and_infer_types(); } -bool ov::snippets::pass::SplitDimensionM::run_on_subgraph(const std::shared_ptr& subgraph) { +bool SplitDimensionM::run_on_subgraph(const std::shared_ptr& subgraph) { OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::SplitDimensionM"); // To increase parallelism work in MHA pattern, // we split 1st dimension (starting from 0th) into 2 new dimensions to get 4D Shapes where @@ -273,3 +281,6 @@ bool ov::snippets::pass::SplitDimensionM::run_on_subgraph(const std::shared_ptr< } return false; } +} // namespace pass +} // namespace snippets +} // namespace ov diff --git a/src/common/snippets/src/runtime_configurator.cpp b/src/common/snippets/src/runtime_configurator.cpp index 2dbf25ba429cb1..e22e4b3bee57fb 100644 --- a/src/common/snippets/src/runtime_configurator.cpp +++ b/src/common/snippets/src/runtime_configurator.cpp @@ -4,31 +4,18 @@ #include "snippets/runtime_configurator.hpp" +#include "snippets/lowered/pass/compute_buffer_allocation_size.hpp" #include "snippets/lowered/pass/init_loops.hpp" #include "snippets/lowered/pass/insert_specific_iterations.hpp" -#include "snippets/lowered/pass/compute_buffer_allocation_size.hpp" +#include "snippets/pass/split_dimension_m.hpp" #include "snippets/snippets_isa.hpp" #include "snippets/utils/utils.hpp" namespace ov { namespace snippets { -namespace { -void init_data_ptr_shifts(const lowered::UnifiedLoopInfoPtr& unified_loop_info, std::vector& ptr_increments, - std::vector& finalization_offsets) { - const auto count = unified_loop_info->get_input_count() + unified_loop_info->get_output_count(); - ptr_increments.resize(count); - finalization_offsets.resize(count); - - size_t idx = 0; - unified_loop_info->iterate_through_descs( - [&ptr_increments, &finalization_offsets, &idx](const lowered::UnifiedLoopInfo::LoopPortDesc& desc) { - ptr_increments[idx] = desc.ptr_increment; - finalization_offsets[idx] = desc.finalization_offset; - ++idx; - }); -} -} // namespace +using namespace ov::snippets::pass; +using namespace ov::snippets::lowered; RuntimeConfigurator::RuntimeConfigurator(std::shared_ptr c) : m_config(std::move(c)) { @@ -57,18 +44,34 @@ void RuntimeConfigurator::initialization(const lowered::LinearIRCPtr& linear_ir) m_latest_shapes.resize(m_io_num); m_config->io_data_offsets.resize(m_io_num); m_config->tile_rank = linear_ir->get_config().m_loop_depth; + m_optimizer.init(linear_ir, m_io_descs, m_in_num); } void RuntimeConfigurator::update(const lowered::LinearIRCPtr& linear_ir) { + m_config->master_shape = linear_ir->get_master_shape(); + + LoopInfoRuntimeParamsMap initialized_info; + auto shapes = extract_shapes(); + auto layouts = extract_layouts(); + if (m_optimizer.enabled()) { + m_optimizer.optimize(m_config->master_shape, initialized_info, shapes, layouts, m_in_num); + update_tensor_rank(m_config->master_shape); + } + if (linear_ir->is_dynamic()) { - update_loop_info(linear_ir); + update_loop_info(linear_ir, initialized_info); + // Update KernelExecutor Table should be before `update_buffer_scratchpad_size` + // because `ComputeAllocationSize` depends on subtensors which are updated in the table + get_kernel_executor_table()->update_state(linear_ir); update_buffer_scratchpad_size(linear_ir); } - m_config->master_shape = linear_ir->get_master_shape(); + update_data_offsets(shapes, layouts); + m_latest_shapes = std::move(shapes); +} - update_data_offsets(); - update_latest_shapes(); +void RuntimeConfigurator::update_tensor_rank(const ov::snippets::VectorDims& master_shape) { + m_config->tensor_rank = master_shape.size(); } void RuntimeConfigurator::init_tensor_rank(const lowered::LinearIRCPtr& linear_ir) const { @@ -83,7 +86,7 @@ void RuntimeConfigurator::init_data_info(const lowered::LinearIRCPtr& linear_ir) m_io_descs.reserve(m_io_num); m_io_data_sizes.reserve(m_io_num); - auto update_io_parameters = [&](const snippets::lowered::PortDescriptorPtr& desc, const ov::element::Type& etype) { + auto update_io_parameters = [&](const PortDescriptorPtr& desc, const ov::element::Type& etype) { OPENVINO_ASSERT(desc, "IO Descriptor is missed!"); OPENVINO_ASSERT(desc->get_shape().size() == desc->get_layout().size() || desc->get_layout().empty(), "Incompatible ranks of shape and layout!"); @@ -93,8 +96,8 @@ void RuntimeConfigurator::init_data_info(const lowered::LinearIRCPtr& linear_ir) for (const auto& param : parameters) { // input->shape changing ops->load - snippets::lowered::PortDescriptorPtr desc = nullptr; - const auto& shape_infer_seq = ov::snippets::utils::get_first_child_shape_infer_expr_seq(param); + PortDescriptorPtr desc = nullptr; + const auto& shape_infer_seq = utils::get_first_child_shape_infer_expr_seq(param); const auto& mem_desc_expr = shape_infer_seq.empty() ? param : shape_infer_seq.back(); auto consumer_inputs = mem_desc_expr->get_output_port_connector(0)->get_consumers(); for (const auto& child_input : consumer_inputs) { @@ -109,7 +112,7 @@ void RuntimeConfigurator::init_data_info(const lowered::LinearIRCPtr& linear_ir) } for (const auto& result : results) { // store->shape changing ops->result - const auto& shape_infer_seq = ov::snippets::utils::get_first_parent_shape_infer_expr_seq(result); + const auto& shape_infer_seq = utils::get_first_parent_shape_infer_expr_seq(result); const auto& mem_desc_expr = shape_infer_seq.empty() ? result : shape_infer_seq.back(); const auto& desc = mem_desc_expr->get_input_port_connector(0)->get_source().get_descriptor_ptr(); const auto& etype = mem_desc_expr->get_node()->get_input_element_type(0); @@ -147,15 +150,8 @@ void RuntimeConfigurator::init_buffer_info(const lowered::LinearIRCPtr& linear_i m_dynamic_buffer_clusters = std::move(dynamic_buffer_clusters); } -void RuntimeConfigurator::update_loop_info(const lowered::LinearIRCPtr& linear_ir) const { - // Initialized UnifiedLoopInfo - struct CurrentUnifiedLoopInfo { - size_t current_work_amount = 0; - std::vector ptr_increments; - std::vector finalization_offsets; - }; - std::unordered_map initializated_info_map; - +void RuntimeConfigurator::update_loop_info(const lowered::LinearIRCPtr& linear_ir, + LoopInfoRuntimeParamsMap& initializated_info_map) const { const auto& loop_map = linear_ir->get_loop_manager()->get_map(); for (const auto& p : loop_map) { const auto& expanded_loop_info = ov::as_type_ptr(p.second); @@ -164,15 +160,12 @@ void RuntimeConfigurator::update_loop_info(const lowered::LinearIRCPtr& linear_i // First visiting of unified (whole) loop const auto& current_unified_loop_info = expanded_loop_info->get_unified_loop_info(); if (initializated_info_map.count(current_unified_loop_info) == 0) { - auto& current_info = initializated_info_map[current_unified_loop_info]; - lowered::pass::InitLoops::init_loop_info(current_unified_loop_info, true); - - current_info.current_work_amount = current_unified_loop_info->get_work_amount(); - init_data_ptr_shifts(current_unified_loop_info, current_info.ptr_increments, current_info.finalization_offsets); + lowered::pass::InitLoops::update_runtime_parameters(current_unified_loop_info); + initializated_info_map[current_unified_loop_info] = compute_runtime_params(current_unified_loop_info); } auto& initializated_info = initializated_info_map.at(current_unified_loop_info); - auto& current_work_amount = initializated_info.current_work_amount; + auto& current_work_amount = initializated_info.work_amount; const auto& ptr_increments = initializated_info.ptr_increments; const auto& finalization_offsets = initializated_info.finalization_offsets; @@ -232,7 +225,10 @@ void RuntimeConfigurator::update_buffer_scratchpad_size(const lowered::LinearIRC OPENVINO_ASSERT(!utils::is_dynamic_value(m_config->buffer_scratchpad_size), "Buffer scratchpad size must be defined!"); } -void RuntimeConfigurator::update_data_offsets() const { +void RuntimeConfigurator::update_data_offsets(const std::vector& shapes, + const std::vector>& layouts) const { + OPENVINO_ASSERT(shapes.size() == m_io_num, "Number of custom shapes must be 0 or be equal to m_io_num"); + OPENVINO_ASSERT(layouts.size() == m_io_num, "Number of custom layouts must be 0 or be equal to m_io_num"); for (size_t i = 0; i < m_io_num; ++i) { // offsets represent distance between consecutive elements of corresponding dimension. // If a dim size == 1, then the next dim starts immediately and the stride is 0 @@ -242,16 +238,16 @@ void RuntimeConfigurator::update_data_offsets() const { // case 2: // shape: s0, s1, s2 == 1, s3 // offsets: s1*s3, s3, 0, 1 - const auto& shape = m_io_descs[i]->get_shape(); + const auto& shape = shapes[i]; if (shape == m_latest_shapes[i]) continue; - const auto& layout = m_io_descs[i]->get_layout(); + const auto& layout = layouts[i]; auto& offsets = m_config->io_data_offsets[i]; offsets.resize(m_config->tensor_rank); std::fill(offsets.begin(), offsets.end(), 0); - if (ov::snippets::utils::is_dynamic_vdims(shape)) + if (utils::is_dynamic_vdims(shape)) return; size_t dim_step = m_io_data_sizes[i]; @@ -276,10 +272,18 @@ void RuntimeConfigurator::update_data_offsets() const { } } -void RuntimeConfigurator::update_latest_shapes() { - for (size_t i = 0; i < m_io_num; ++i) { - m_latest_shapes[i] = m_io_descs[i]->get_shape(); - } +std::vector RuntimeConfigurator::extract_shapes() const { + std::vector shapes(m_io_num); + for (size_t i = 0; i < m_io_num; ++i) + shapes[i] = m_io_descs[i]->get_shape(); + return shapes; +} + +std::vector> RuntimeConfigurator::extract_layouts() const { + std::vector> layouts(m_io_num); + for (size_t i = 0; i < m_io_num; ++i) + layouts[i] = m_io_descs[i]->get_layout(); + return layouts; } void RuntimeConfigurator::set_kernel_executor_table(std::shared_ptr table) const { @@ -287,5 +291,178 @@ void RuntimeConfigurator::set_kernel_executor_table(std::shared_ptrkernel_executor_table = std::move(table); } +RuntimeConfigurator::UnifiedLoopInfoRtParams RuntimeConfigurator::compute_runtime_params(const lowered::UnifiedLoopInfoPtr& loop_info) { + RuntimeConfigurator::UnifiedLoopInfoRtParams rt_params; + rt_params.work_amount = loop_info->get_work_amount(); + const auto count = loop_info->get_input_count() + loop_info->get_output_count(); + rt_params.ptr_increments.resize(count); + rt_params.finalization_offsets.resize(count); + + size_t idx = 0; + loop_info->iterate_through_descs( + [&rt_params, &idx](const lowered::UnifiedLoopInfo::LoopPortDesc& desc) { + rt_params.ptr_increments[idx] = desc.ptr_increment; + rt_params.finalization_offsets[idx] = desc.finalization_offset; + ++idx; + }); + return rt_params; +} + +void RuntimeConfigurator::ParallelWAOptimizer::init(const lowered::LinearIRCPtr& linear_ir, + const std::vector& io_descs, + size_t in_num) { + if (linear_ir->get_config().m_enable_domain_optimization || !linear_ir->is_dynamic()) + return; + + const auto brgemms = find_applicable_brgemms(linear_ir); + // Parallel WA optimization is Brgemm related + if (brgemms.empty()) + return; + + concurrency = linear_ir->get_config().m_min_parallel_work_amount; + // At the moment this optimization is Brgemm related so there must be `unsqueezed_params` + unsqueezed_params = find_unsqueezed_params(linear_ir, brgemms); + OPENVINO_ASSERT(!unsqueezed_params.empty(), "unsqueezed_params mustn't be empty after initialization"); + loops_to_split = find_loops_to_split(linear_ir, unsqueezed_params); + + m_dim_idces.resize(io_descs.size()); + optimized_layouts.resize(io_descs.size()); + for (size_t i = 0; i < io_descs.size(); ++i) { + const auto& layout = io_descs[i]->get_layout(); + const auto dim_idx = i < in_num ? utils::get_input_dim_idx(layout, 1) + : utils::get_output_dim_idx(layout, 1); + m_dim_idces[i] = dim_idx; + optimized_layouts[i] = SplitDimensionM::get_updated_order(layout, i < in_num ? dim_idx : layout.size() - 2); + } +} + +bool RuntimeConfigurator::ParallelWAOptimizer::enabled() { + return !loops_to_split.empty(); +} + +void RuntimeConfigurator::ParallelWAOptimizer::optimize(VectorDims& master_shape, + RuntimeConfigurator::LoopInfoRuntimeParamsMap& map, + std::vector& shapes, + std::vector>& layouts, + size_t in_num) { + size_t new_batch_dim, new_kernel_dim; + if (!SplitDimensionM::split(master_shape, concurrency, new_batch_dim, new_kernel_dim)) + return; + + update_master_shape(master_shape, new_batch_dim, new_kernel_dim); + update_split_loops_info(map, new_kernel_dim); + update_shapes(shapes, new_batch_dim, new_kernel_dim); + update_layouts(layouts); +} + +void RuntimeConfigurator::ParallelWAOptimizer::update_master_shape(VectorDims& master_shape, size_t new_batch_dim, size_t new_kernel_dim) { + *++master_shape.rbegin() = new_kernel_dim; + master_shape.insert(master_shape.cbegin() + master_shape.size() - 2, new_batch_dim); +} + +void RuntimeConfigurator::ParallelWAOptimizer::update_split_loops_info(LoopInfoRuntimeParamsMap& initialized_info, size_t new_kernel_dim) { + OPENVINO_ASSERT(initialized_info.empty(), "ParallelWAOptimizer::update_split_loops_info expects empty initialized_info map"); + for (const auto& loop : loops_to_split) { + loop->set_work_amount(new_kernel_dim); + lowered::pass::InitLoops::update_data_pointer_shifts(loop); + initialized_info[loop] = compute_runtime_params(loop); + } +} + +void RuntimeConfigurator::ParallelWAOptimizer::update_shapes(std::vector& shapes, size_t new_batch_dim, size_t new_kernel_dim) { + for (size_t i = 0; i < m_dim_idces.size(); ++i) { + shapes[i] = unsqueezed_params.count(i) + ? SplitDimensionM::unsqueeze_m_dim(shapes[i], m_dim_idces[i]) + : SplitDimensionM::reshape_m_dim(shapes[i], m_dim_idces[i], new_batch_dim, new_kernel_dim); + } +} + +void RuntimeConfigurator::ParallelWAOptimizer::update_layouts(std::vector>& layouts) { + layouts = optimized_layouts; +} + +std::unordered_set RuntimeConfigurator::ParallelWAOptimizer::find_applicable_brgemms( + const lowered::LinearIRCPtr& linear_ir) { + auto is_brgemm = [](const ExpressionPtr& expr) { + return ov::is_type(expr->get_node()); + }; + auto brgemm_it = std::find_if(linear_ir->begin(), linear_ir->end(), is_brgemm); + std::unordered_set brgemms; + while (brgemm_it != linear_ir->end()) { + brgemms.insert(*brgemm_it); + brgemm_it = std::find_if(std::next(brgemm_it), linear_ir->end(), is_brgemm); + } + const auto& loop_manager = linear_ir->get_loop_manager(); + // Brgemm is applicable if it has dynamic loop by M + // The loop by M is necessary since only in this case we can regulate BrgemmExecutor parameters (via loop's work amount) + // Only dynamic loops are applicable since in static case LoopEnd expressions are not updated during code generation and compiled as is + // Ticket: 148805 + auto applicable_brgemm = [&loop_manager](const ExpressionPtr& expr) { + const auto& loop_idces = expr->get_loop_ids(); + if (loop_idces.empty()) + return false; + const auto& outermost_loop = loop_manager->get_loop_info(loop_idces[0]); + if (!utils::is_dynamic_value(outermost_loop->get_work_amount())) + return false; + bool loop_by_m = true; + outermost_loop->iterate_through_ports([&loop_by_m](const LoopPort& port) { + if (port.is_incremented && port.dim_idx != 1) + loop_by_m = false; + }); + return loop_by_m; + }; + // Note: if at least one brgemm is inapplicable, the parallel work amount optimization can't be applied + return std::all_of(brgemms.begin(), brgemms.end(), applicable_brgemm) ? brgemms : std::unordered_set{}; +} + +std::unordered_set RuntimeConfigurator::ParallelWAOptimizer::find_unsqueezed_params( + const lowered::LinearIRCPtr& linear_ir, + const std::unordered_set& brgemms) { + const auto& params = linear_ir->get_parameters(); + std::unordered_set unsqueezed_params; + auto add_param = [¶ms, &unsqueezed_params](const ExpressionPtr& expr) { + if (ov::is_type(expr->get_node())) { + auto found_param = std::find(params.begin(), params.end(), expr); + OPENVINO_ASSERT(found_param != params.end(), "find_param didn't found parameter for expr"); + unsqueezed_params.insert(std::distance(params.begin(), found_param)); + } + }; + + std::unordered_set visited; + for (const auto& brgemm : brgemms) { + const auto& brgemm_b_input = brgemm->get_input_port_connector(1)->get_source().get_expr(); + utils::visit_path(brgemm_b_input, visited, add_param, true); + } + return unsqueezed_params; +} + +std::unordered_set RuntimeConfigurator::ParallelWAOptimizer::find_loops_to_split( + const lowered::LinearIRCPtr& linear_ir, + const std::unordered_set& unsqueezed_params) { + const auto loop_manager = linear_ir->get_loop_manager(); + + std::unordered_set loops_to_split; + auto add_loops_to_split = [&loop_manager, &loops_to_split](const ExpressionPtr& expr) { + const auto& loop_ids = expr->get_loop_ids(); + if (!loop_ids.empty()) { + const auto outermost_loop_idx = loop_ids[0]; + const auto loop_info_to_add = loop_manager->get_loop_info(outermost_loop_idx); + loops_to_split.insert(loop_info_to_add->get_unified_loop_info()); + } + }; + + size_t i = 0; + std::unordered_set visited; + // The idea is to traverse LIR down from the M dimension related parameters + // and find all the outermost loops: these loops will be split in runtime + for (const auto& param : linear_ir->get_parameters()) { + // Ops after non related params mustn't be traversed + if (unsqueezed_params.count(i++)) + continue; + utils::visit_path(param, visited, add_loops_to_split, false); + } + return loops_to_split; +} + } // namespace snippets } // namespace ov diff --git a/src/common/snippets/src/utils/utils.cpp b/src/common/snippets/src/utils/utils.cpp index f46761d2d21886..cd64958207d958 100644 --- a/src/common/snippets/src/utils/utils.cpp +++ b/src/common/snippets/src/utils/utils.cpp @@ -316,6 +316,40 @@ int64_t get_dim_stride(const lowered::ExpressionPort& expr_port, size_t idx) { return get_stride(dim_idx, expr_port.get_descriptor_ptr()->get_shape()); } +void visit_path(const lowered::ExpressionPtr& expr, + std::unordered_set& visited, + std::function func, + bool visit_parent_path) { + std::deque exprs{expr}; + + auto continue_traversal = [&](const lowered::ExpressionPtr& expr) { + if (visited.count(expr) == 0) { + exprs.push_front(expr); + visited.insert(expr); + } + }; + + while (!exprs.empty()) { + auto curr_expr = exprs.front(); + exprs.pop_front(); + func(curr_expr); + + if (visit_parent_path) { + for (const auto& input_connector : curr_expr->get_input_port_connectors()) { + const auto& parent_expr = input_connector->get_source().get_expr(); + continue_traversal(parent_expr); + } + } else { + for (const auto& output_connector : curr_expr->get_output_port_connectors()) { + for (const auto& consumer : output_connector->get_consumers()) { + const auto& consumer_expr = consumer.get_expr(); + continue_traversal(consumer_expr); + } + } + } + } +} + } // namespace utils } // namespace snippets } // namespace ov diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp index 1387992792e0a0..40da4130b212c9 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp @@ -4,30 +4,25 @@ #include "emitters/snippets/cpu_runtime_configurator.hpp" -#include "snippets/utils/utils.hpp" #include "snippets/lowered/loop_manager.hpp" - +#include "snippets/utils/utils.hpp" namespace ov { namespace intel_cpu { +const size_t CPURuntimeConfigurator::rank6D = 6; + CPURuntimeConfigurator::CPURuntimeConfigurator() : ov::snippets::RuntimeConfigurator(std::make_shared()) { } void CPURuntimeConfigurator::update(const ov::snippets::lowered::LinearIRCPtr& linear_ir) { - if (linear_ir->is_dynamic()) { - update_loop_info(linear_ir); + RuntimeConfigurator::update(linear_ir); + if (linear_ir->is_dynamic()) update_loop_args(linear_ir); - // Update KernelExecutor Table should be before `update_buffer_scratchpad_size` - // because `ComputeAllocationSize` depends on subtensors which are updated in the table - get_kernel_executor_table()->update_state(linear_ir); - update_buffer_scratchpad_size(linear_ir); - } - - m_config->master_shape = linear_ir->get_master_shape(); +} - update_data_offsets(); - update_latest_shapes(); +void CPURuntimeConfigurator::update_tensor_rank(const ov::snippets::VectorDims& master_shape) { + m_config->tensor_rank = std::max(master_shape.size(), rank6D); } void CPURuntimeConfigurator::init_tensor_rank(const ov::snippets::lowered::LinearIRCPtr& linear_ir) const { diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp index 93cbb6b598146c..2104dfbdd42ddb 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp @@ -30,6 +30,11 @@ class CPURuntimeConfigurator : public ov::snippets::RuntimeConfigurator { * @param linear_ir LinearIR */ void update(const ov::snippets::lowered::LinearIRCPtr& linear_ir) override; + /** + * @brief Update tensor rank based on master shape + * @param master_shape Master shape + */ + void update_tensor_rank(const ov::snippets::VectorDims& master_shape) override; /** * @brief Initializes tensor rank of config * @param linear_ir LinearIR @@ -41,7 +46,7 @@ class CPURuntimeConfigurator : public ov::snippets::RuntimeConfigurator { */ void update_loop_args(const ov::snippets::lowered::LinearIRCPtr& linear_ir) const; - const size_t rank6D = 6; + static const size_t rank6D; }; } // namespace intel_cpu diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp index 4504ff85de6bc2..726a416fe1c6c5 100644 --- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp +++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp @@ -951,7 +951,7 @@ void Transformations::MainSnippets(void) { #if defined(OPENVINO_ARCH_X86_64) auto is_supported_matmul = [this](const std::shared_ptr& n) { const auto matmul = ov::as_type_ptr(n); - if (!matmul || matmul->is_dynamic()) + if (!matmul) return false; const auto in_type0 = matmul->get_input_element_type(0); const auto in_type1 = matmul->get_input_element_type(1); @@ -959,6 +959,9 @@ void Transformations::MainSnippets(void) { return false; if (in_type0 == ov::element::f32 && in_type1 == ov::element::f32 && one_of(inferencePrecision, element::f32, element::undefined)) return true; + // Only FP32 dynamic MHA is supported + if (matmul->is_dynamic()) + return false; // [114487] brgemm kernel in oneDNN requires brgemm_copy_b kernel if MatMul node has transposed_b=True // The current solution with ExtractExplicitMatMulTranspose pass is slower for non-f32 cases than using of brgemm_copy_b kernel if (matmul->get_transpose_a() || matmul->get_transpose_b()) @@ -982,10 +985,13 @@ void Transformations::MainSnippets(void) { } return true; }; - auto is_unsupported_parallel_work_amount = [&](const std::shared_ptr& n, const ov::Shape& shape) { - const size_t parallel_work_amount = std::accumulate(shape.rbegin() + 2, shape.rend(), 1, std::multiplies()); + auto is_unsupported_parallel_work_amount = [&](const std::shared_ptr& n, const ov::PartialShape& shape) { + // SplitDimensionM transformation doesn't support dynamic shapes, so M dim is split in runtime configurator + if (shape.is_dynamic()) + return false; + const auto parallel_work_amount = std::accumulate(shape.rbegin() + 2, shape.rend(), ov::Dimension(1), std::multiplies()); const auto is_unsupported_parallel_work_amount = - parallel_work_amount < tokenization_config.get_concurrency() && + static_cast(parallel_work_amount.get_length()) < tokenization_config.get_concurrency() && !ov::snippets::pass::SplitDimensionM::can_be_optimized(n, tokenization_config.get_concurrency()); return is_unsupported_parallel_work_amount; }; @@ -1083,11 +1089,11 @@ void Transformations::MainSnippets(void) { if (!is_supported_matmul(child)) return true; - const auto& shape = child->get_input_shape(0); - return is_unsupported_parallel_work_amount(n, shape); + const auto& pshape = child->get_input_partial_shape(0); + return is_unsupported_parallel_work_amount(n, pshape); }, snippets::pass::TokenizeMHASnippets); CPU_SET_CALLBACK_X64(snippetsManager, [&](const std::shared_ptr& n) -> bool { - return !is_supported_matmul(n) || is_unsupported_parallel_work_amount(n, n->get_output_shape(0)); + return !is_supported_matmul(n) || is_unsupported_parallel_work_amount(n, n->get_output_partial_shape(0)); }, snippets::pass::ExtractReshapesFromMHA); } diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp index 68ccfd0ac5b5a1..50fab4febfa150 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp @@ -176,7 +176,7 @@ std::vector disabledTestPatterns() { // Need to generate sequence exactly in the i64 data type. Enable in scope of i64 enabling. R"(.*RandomUniformLayerTestCPU.*OutPrc=i64.*)", // Issue: 123815 (Tests are sensintive to available thread count on testing machines) - R"(.*smoke_Snippets_MHA_.?D_SplitDimensionM.*)", + R"(.*smoke_Snippets_MHA_.?D_SplitDimensionM_static.*)", // Issue: 122356 R"(.*NmsRotatedOpTest.*(SortDesc=True|Clockwise=False).*)", // Issue: 126095 diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp index 5f28fa2aa9ed3c..19f1b230cd2c58 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp @@ -104,10 +104,12 @@ INSTANTIATE_TEST_SUITE_P(smoke_Snippets_MHA_3D, ::testing::Values(CPUTestUtils::empty_plugin_config)), MHA::getTestCaseName); +const auto& splitm_static_shapes = STATIC_SHAPES({{1, 128, 2, 64}, {1, 128, 2, 64}, {1, 1, 1, 1}, {1, 128, 2, 64}}); + INSTANTIATE_TEST_SUITE_P( - smoke_Snippets_MHA_4D_SplitDimensionM, + smoke_Snippets_MHA_4D_SplitDimensionM_static, MHA, - ::testing::Combine(::testing::ValuesIn(STATIC_SHAPES({{1, 128, 2, 64}, {1, 128, 2, 64}, {1, 1, 1, 1}, {1, 128, 2, 64}})), + ::testing::Combine(::testing::ValuesIn(splitm_static_shapes), ::testing::ValuesIn(precision_f32(4)), ::testing::Values(ov::element::f32), ::testing::Values(true), @@ -119,7 +121,7 @@ INSTANTIATE_TEST_SUITE_P( MHA::getTestCaseName); INSTANTIATE_TEST_SUITE_P( - smoke_Snippets_MHA_3D_SplitDimensionM, + smoke_Snippets_MHA_3D_SplitDimensionM_static, MHA, ::testing::Combine( ::testing::ValuesIn(STATIC_SHAPES({{384, 2, 64}, {384, 2, 64}, {1, 384, 384}, {384, 2, 64}})), @@ -133,6 +135,76 @@ INSTANTIATE_TEST_SUITE_P( ::testing::Values(enable_callback())), MHA::getTestCaseName); +std::vector> splitm_dynamic_shapes_4d = { + { + {PartialShape{-1, -1, -1, -1}, {{1, 128, 2, 64}, {1, 17, 2, 64}, {1, 128, 2, 64}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 128, 2, 64}, {1, 17, 2, 64}, {1, 128, 2, 64}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 1, 1, 128}, {1, 1, 1, 17}, {1, 1, 1, 128}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 128, 2, 64}, {1, 17, 2, 64}, {1, 128, 2, 64}}}, + }, + { + {PartialShape{-1, 128, -1, -1}, {{1, 128, 2, 64}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 64}}}, + {PartialShape{-1, -1, 128, -1}, {{1, 1, 128, 16}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 32}}}, + }, + { + {PartialShape{-1, 32, -1, -1}, {{1, 32, 2, 64}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 64}}}, + {PartialShape{-1, -1, 32, -1}, {{1, 1, 32, 16}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 32}}}, + }, + { + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 64}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 64}}}, + {PartialShape{-1, -1, 16, -1}, {{1, 1, 16, 16}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 16, 2, 32}}}, + }, +}; + +INSTANTIATE_TEST_SUITE_P( + smoke_Snippets_MHA_4D_SplitDimensionM_dynamic, + MHA, + ::testing::Combine(::testing::ValuesIn(splitm_dynamic_shapes_4d), + ::testing::ValuesIn(precision_f32(4)), + ::testing::Values(ov::element::f32), + ::testing::Values(false), + ::testing::Values(4), // 4 Threads + ::testing::Values(1), + ::testing::Values(1), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(CPUTestUtils::empty_plugin_config)), + MHA::getTestCaseName); + +std::vector> splitm_dynamic_shapes_3d = { + { + {PartialShape{-1, -1, -1}, {{128, 2, 64}, {17, 2, 64}, {128, 2, 64}}}, + {PartialShape{-1, -1, -1}, {{128, 2, 64}, {17, 2, 64}, {128, 2, 64}}}, + {PartialShape{-1, -1, -1}, {{1, 1, 128}, {1, 1, 17}, {1, 1, 128}}}, + {PartialShape{-1, -1, -1}, {{128, 2, 64}, {17, 2, 64}, {128, 2, 64}}}, + }, + { + {PartialShape{-1, 2, 64}, {{128, 2, 64}, {64, 2, 64}, {128, 2, 64}}}, + {PartialShape{-1, 2, 64}, {{128, 2, 64}, {64, 2, 64}, {128, 2, 64}}}, + {PartialShape{1, 1, -1}, {{1, 1, 128}, {1, 1, 64}, {1, 1, 128}}}, + {PartialShape{-1, 2, 64}, {{128, 2, 64}, {64, 2, 64}, {128, 2, 64}}}, + }, +}; + +INSTANTIATE_TEST_SUITE_P( + smoke_Snippets_MHA_3D_SplitDimensionM_dynamic, + MHA, + ::testing::Combine(::testing::ValuesIn(splitm_dynamic_shapes_3d), + ::testing::ValuesIn(precision_f32(4)), + ::testing::Values(ov::element::f32), + ::testing::Values(false), + ::testing::Values(4), // 4 Threads + ::testing::Values(5), // Subgraph + 4 Transpose + ::testing::Values(2), // MHA + one of the transposes is executed via Subgraph (because callback is disabled) + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(CPUTestUtils::empty_plugin_config)), + MHA::getTestCaseName); + INSTANTIATE_TEST_SUITE_P(smoke_Snippets_MHABF16_4D, MHA, ::testing::Combine(::testing::ValuesIn(inputShapes_4D), From 0015fc52bfec5a85d2e8906a7d4504e4b0d927d1 Mon Sep 17 00:00:00 2001 From: Wilson Seok Date: Thu, 15 Aug 2024 02:37:55 -0700 Subject: [PATCH 016/117] [GPU] Consider group weight format when block inner index of custom traits is created (#26018) ### Details: - Consider group weight format when block inner index of custom traits is created ### Tickets: - 148549 --- .../src/graph/impls/onednn/utils.cpp | 2 +- .../tests/unit/onednn/utils_test.cpp | 4 +- .../unit/passes/post_optimize_weights.cpp | 46 +++++++++++++++++++ 3 files changed, 49 insertions(+), 3 deletions(-) diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/utils.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/utils.cpp index e7c9ce750c7ae1..a1d35073af499e 100644 --- a/src/plugins/intel_gpu/src/graph/impls/onednn/utils.cpp +++ b/src/plugins/intel_gpu/src/graph/impls/onednn/utils.cpp @@ -516,7 +516,7 @@ cldnn::format_traits convert_memory_desc_to_traits(const dnnl::memory::desc& des std::vector> block_sizes(inner_nblks); for (int i = 0; i < inner_nblks; i++) { - block_sizes[i] = std::make_pair(inner_idxs[i], inner_blks[i]); + block_sizes[i] = std::make_pair(inner_idxs[i] + (is_grouped && inner_idxs[i] == 0 ? 9 : 0) + (is_grouped ? -1 : 0), inner_blks[i]); } // all fmts has at least batch and feature dim for now diff --git a/src/plugins/intel_gpu/tests/unit/onednn/utils_test.cpp b/src/plugins/intel_gpu/tests/unit/onednn/utils_test.cpp index 4b41a9a601499a..4b7806fedebf36 100644 --- a/src/plugins/intel_gpu/tests/unit/onednn/utils_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/onednn/utils_test.cpp @@ -247,13 +247,13 @@ INSTANTIATE_TEST_SUITE_P(smoke, memory_desc_to_fmt_conversion_test, { {10, 20, 30, 40, 50}, dnnl::memory::data_type::f32, dnnl::memory::format_tag::AcdeB24a2b, true, format_traits{ - "custom", 1, 1, 2, 1, {0, 2, 3, 4, 1}, "giyxo", "oixy????g", {{0, 24}, {1, 2}} + "custom", 1, 1, 2, 1, {0, 2, 3, 4, 1}, "giyxo", "oixy????g", {{8, 24}, {0, 2}} } }, { {10, 60, 70, 40, 50}, dnnl::memory::data_type::f32, dnnl::memory::format_tag::aCBde4c8b8c4b, true, format_traits{ - "custom", 1, 1, 2, 1, {0, 2, 1, 3, 4}, "gioyx", "oixy????g", {{2, 4}, {1, 8}, {2, 8}, {1, 4}} + "custom", 1, 1, 2, 1, {0, 2, 1, 3, 4}, "gioyx", "oixy????g", {{1, 4}, {0, 8}, {1, 8}, {0, 4}} } }, }), diff --git a/src/plugins/intel_gpu/tests/unit/passes/post_optimize_weights.cpp b/src/plugins/intel_gpu/tests/unit/passes/post_optimize_weights.cpp index 2dd8f3217c2f10..07ac5ac243ad77 100644 --- a/src/plugins/intel_gpu/tests/unit/passes/post_optimize_weights.cpp +++ b/src/plugins/intel_gpu/tests/unit/passes/post_optimize_weights.cpp @@ -5,6 +5,7 @@ #include "test_utils.h" #include "program_wrapper.h" #include "fully_connected_inst.h" +#include "convolution_inst.h" #ifdef ENABLE_ONEDNN_FOR_GPU #include "graph/impls/onednn/utils.hpp" #endif @@ -245,3 +246,48 @@ TEST(post_optimize_weights, fuse_reorder_to_onednn_weights_reorder_test) { ASSERT_TRUE(onednn_weights_params->_in_desc.get_data_type() == onednn::convert_data_type(data_types::f32)); #endif } + +TEST(post_optimize_weights, onednn_group_conv_weights_reorder_test) { + auto& engine = get_test_engine(); + if (!engine.get_device_info().supports_immad) + return; + + ov::Shape pshape = { 1, 512, 2, 332 }; + ov::Shape weight_pshape = { 64, 1, 8, 5, 5 }; + auto input = engine.allocate_memory({ pshape, data_types::f16, format::bfyx }); + auto weights = engine.allocate_memory({ weight_pshape, data_types::f16, format::bfzyx }); + + std::vector weights_data(weight_pshape[0] * weight_pshape[1] * weight_pshape[2] * weight_pshape[3] * weight_pshape[4]); + std::iota(weights_data.begin(), weights_data.end(), 0.f); + set_values(weights, weights_data); + + topology topology( + input_layout("input", input->get_layout()), + data("weights", weights), + convolution("conv", input_info("input"), "weights", "", 64, {1, 1}, {1, 1}, {2, 2}, {2, 2}, true) + ); + + ExecutionConfig config = get_test_default_config(engine); + config.set_property(ov::intel_gpu::optimize_data(true)); + config.set_property(ov::intel_gpu::allow_new_shape_infer(true)); + + if (engine.get_device_info().supports_immad) { + ov::intel_gpu::ImplementationDesc conv_impl = { format::b_fs_yx_fsv16, std::string(""), impl_types::onednn }; + config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ {"conv", conv_impl} })); + } + + layout_optimizer lo(true); + lo.set_optimization_attribute(layout_optimizer::optimization_attributes_type::use_onednn_impls, true); + + auto prog = program::build_program(engine, topology, config); + + auto& conv_node = prog->get_node("conv"); + auto weights_param = conv_node.as().get_selected_impl()->get_weights_reorder_params(); + ASSERT_TRUE(format::is_weights_format(prog->get_node("weights_weights_reorder_0").get_output_layout().format)); + +#ifdef ENABLE_ONEDNN_FOR_GPU + // Check onednn_weights_params->_out_desc.get_size() with reorder output_layout bytes_count + auto onednn_weights_params = std::dynamic_pointer_cast(weights_param); + ASSERT_TRUE(onednn_weights_params->_out_desc.get_size() == prog->get_node("weights_weights_reorder_0").get_output_layout().bytes_count()); +#endif +} \ No newline at end of file From 353131c2b7bfe622d1e666c7c6f7828939ba4c3c Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Thu, 15 Aug 2024 14:19:58 +0400 Subject: [PATCH 017/117] Removed GHA WA for old ONNX versions (#26078) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --- .github/workflows/job_build_linux.yml | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/.github/workflows/job_build_linux.yml b/.github/workflows/job_build_linux.yml index aee69fe6b232e7..8fd35f48172a85 100644 --- a/.github/workflows/job_build_linux.yml +++ b/.github/workflows/job_build_linux.yml @@ -113,13 +113,7 @@ jobs: python3 -m pip install -r ${OPENVINO_REPO}/src/bindings/python/wheel/requirements-dev.txt # For running ONNX frontend unit tests - if [[ ${{ inputs.os }} == 'ubuntu_24_04' ]]; then - # Should be removed after https://github.com/openvinotoolkit/openvino/pull/24242 is merged - export CMAKE_GENERATOR="Unix Makefiles" - python3 -m pip install --force-reinstall --no-cache-dir -r ${OPENVINO_REPO}/src/frontends/onnx/tests/requirements.txt - else - python3 -m pip install --force-reinstall -r ${OPENVINO_REPO}/src/frontends/onnx/tests/requirements.txt - fi + python3 -m pip install -r ${OPENVINO_REPO}/src/frontends/onnx/tests/requirements.txt # For running TensorFlow frontend unit tests python3 -m pip install -r ${OPENVINO_REPO}/src/frontends/tensorflow/tests/requirements.txt From ea04fad482c2d7ef5364a7a75af61211481e3c5f Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Thu, 15 Aug 2024 14:32:17 +0400 Subject: [PATCH 018/117] Updated RPM packages build (#26075) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --- .github/workflows/fedora.yml | 2 ++ cmake/features.cmake | 3 --- cmake/packaging/rpm.cmake | 11 ++++++----- src/bindings/python/CMakeLists.txt | 5 ++++- thirdparty/dependencies.cmake | 4 ++++ 5 files changed, 16 insertions(+), 9 deletions(-) diff --git a/.github/workflows/fedora.yml b/.github/workflows/fedora.yml index 5833c1d2000fa7..6f0eb7eb62a21b 100644 --- a/.github/workflows/fedora.yml +++ b/.github/workflows/fedora.yml @@ -221,6 +221,7 @@ jobs: if-no-files-found: 'error' RPM_Packages: + name: RPM packages needs: [Docker, Build] timeout-minutes: 10 defaults: @@ -273,6 +274,7 @@ jobs: python3 -c 'from openvino import Core; Core().get_property("BATCH", "SUPPORTED_PROPERTIES")' python3 -c 'from openvino.frontend import FrontEndManager; assert len(FrontEndManager().get_available_front_ends()) == 7' benchmark_app --help + opt_in_out --help ovc --help Overall_Status: diff --git a/cmake/features.cmake b/cmake/features.cmake index 6794bf06ccf4b3..fa11b1894dfbba 100644 --- a/cmake/features.cmake +++ b/cmake/features.cmake @@ -194,9 +194,6 @@ ov_dependent_option (ENABLE_SYSTEM_PROTOBUF "Enables use of system Protobuf" OFF ov_dependent_option (ENABLE_SYSTEM_SNAPPY "Enables use of system version of Snappy" OFF "ENABLE_SNAPPY_COMPRESSION" OFF) -ov_dependent_option (ENABLE_PYTHON_PACKAGING "Enables packaging of Python API in APT / YUM" OFF - "ENABLE_PYTHON;UNIX" OFF) - ov_dependent_option(ENABLE_JS "Enables JS API building" ${ENABLE_JS_DEFAULT} "NOT ANDROID;NOT EMSCRIPTEN" OFF) ov_option(ENABLE_OPENVINO_DEBUG "Enable output for OPENVINO_DEBUG statements" OFF) diff --git a/cmake/packaging/rpm.cmake b/cmake/packaging/rpm.cmake index e8132b5bba6043..e856a916417e30 100644 --- a/cmake/packaging/rpm.cmake +++ b/cmake/packaging/rpm.cmake @@ -274,9 +274,6 @@ macro(ov_cpack_settings) ov_rpm_generate_conflicts("${OV_CPACK_COMP_CORE_DEV}" ${conflicting_versions}) ov_rpm_add_rpmlint_suppression("${OV_CPACK_COMP_CORE_DEV}" - # contains samples source codes - "devel-file-in-non-devel-package /usr/${OV_CPACK_INCLUDEDIR}/ngraph" - "devel-file-in-non-devel-package /usr/${OV_CPACK_INCLUDEDIR}/ie" "devel-file-in-non-devel-package /usr/${OV_CPACK_INCLUDEDIR}/openvino" "devel-file-in-non-devel-package /usr/${OV_CPACK_RUNTIMEDIR}/libopenvino*" "devel-file-in-non-devel-package /usr/${OV_CPACK_RUNTIMEDIR}/pkgconfig/openvino.pc") @@ -302,8 +299,12 @@ macro(ov_cpack_settings) ov_rpm_generate_conflicts(${python_component} ${conflicting_versions}) ov_rpm_add_rpmlint_suppression("${python_component}" + # entry points + "no-manual-page-for-binary benchmark_app" + "no-manual-page-for-binary opt_in_out" + "no-manual-page-for-binary ovc" # all directories - "non-standard-dir-perm /usr/lib64/${pyversion}/site-packages/openvino/*" + "non-standard-dir-perm /usr/lib/${pyversion}/site-packages/openvino/*" ) endif() @@ -383,7 +384,7 @@ macro(ov_cpack_settings) set(CPACK_COMPONENT_OPENVINO_DESCRIPTION "Intel(R) Distribution of OpenVINO(TM) Toolkit Libraries and Development files") set(CPACK_RPM_OPENVINO_PACKAGE_REQUIRES "${libraries_dev_package}, ${samples_package}") if(ENABLE_PYTHON_PACKAGING) - set(CPACK_DEBIAN_OPENVINO_PACKAGE_DEPENDS "${CPACK_RPM_OPENVINO_PACKAGE_REQUIRES}, ${python_package}, ${python_samples_package}") + set(CPACK_RPM_OPENVINO_PACKAGE_REQUIRES "${CPACK_RPM_OPENVINO_PACKAGE_REQUIRES}, ${python_package}, ${python_samples_package}") endif() set(CPACK_RPM_OPENVINO_PACKAGE_NAME "openvino-${cpack_name_ver}") set(CPACK_RPM_OPENVINO_PACKAGE_ARCHITECTURE "noarch") diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index d5db314b30d2e1..dc816d73fa79b1 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -116,6 +116,9 @@ ov_check_init_files_alignment("${INIT_FILES_RUNTIME}") ov_option(ENABLE_PYTHON "Enables OpenVINO Python API build" ${ENABLE_PYTHON_DEFAULT}) +ov_dependent_option (ENABLE_PYTHON_PACKAGING "Enables packaging of Python API in APT / YUM" OFF + "ENABLE_PYTHON;LINUX" OFF) + # # Check for wheel package # @@ -366,7 +369,7 @@ if(ENABLE_PYTHON_PACKAGING) ov_cpack_add_component(${OV_CPACK_COMP_PYTHON_OPENVINO}_package_${pyversion} HIDDEN) install(DIRECTORY ${ov_python_package_prefix}/ ${telemetry_python_package_prefix}/ - DESTINATION ${CMAKE_INSTALL_PREFIX} + DESTINATION . COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO_PACKAGE}_${pyversion} ${OV_CPACK_COMP_PYTHON_OPENVINO_PACKAGE_EXCLUDE_ALL} USE_SOURCE_PERMISSIONS) diff --git a/thirdparty/dependencies.cmake b/thirdparty/dependencies.cmake index 5fa49b2cda9c23..9423aa5c0bc9f1 100644 --- a/thirdparty/dependencies.cmake +++ b/thirdparty/dependencies.cmake @@ -543,8 +543,10 @@ install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/json/nlohmann_json DESTINATION ${OV_CPACK_SAMPLESDIR}/cpp/thirdparty COMPONENT ${OV_CPACK_COMP_CPP_SAMPLES} ${OV_CPACK_COMP_CPP_SAMPLES_EXCLUDE_ALL} + PATTERN BUILD.bazel EXCLUDE PATTERN ChangeLog.md EXCLUDE PATTERN CITATION.cff EXCLUDE + PATTERN .cirrus.yml EXCLUDE PATTERN .clang-format EXCLUDE PATTERN .clang-tidy EXCLUDE PATTERN docs EXCLUDE @@ -554,10 +556,12 @@ install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/json/nlohmann_json PATTERN .lgtm.yml EXCLUDE PATTERN Makefile EXCLUDE PATTERN meson.build EXCLUDE + PATTERN Package.swift EXCLUDE PATTERN README.md EXCLUDE PATTERN .reuse EXCLUDE PATTERN tests EXCLUDE PATTERN tools EXCLUDE + PATTERN WORKSPACE.bazel EXCLUDE PATTERN wsjcpp.yml EXCLUDE) # restore state From e1598c1e1ad65e91ee4ff5e8766c9caeeadc3362 Mon Sep 17 00:00:00 2001 From: Andrei Kashchikhin Date: Thu, 15 Aug 2024 12:01:10 +0100 Subject: [PATCH 019/117] [CI] [GHA] Add check for build that utilizes `FASTER_BUILD=ON` option (#25858) ### Tickets: - *146300* --- .github/workflows/linux_conditional_compilation.yml | 3 ++- .../conformance/subgraphs_dumper/tests/cache/op_cache.cpp | 4 ++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/.github/workflows/linux_conditional_compilation.yml b/.github/workflows/linux_conditional_compilation.yml index cfccad5fe23e12..8f0cb8982ec446 100644 --- a/.github/workflows/linux_conditional_compilation.yml +++ b/.github/workflows/linux_conditional_compilation.yml @@ -102,7 +102,7 @@ jobs: BUILD_DIR: /__w/openvino/openvino/openvino_build SELECTIVE_BUILD_STAT_DIR: /__w/openvino/openvino/selective_build_stat MODELS_PATH: /__w/openvino/openvino/testdata - SCCACHE_AZURE_KEY_PREFIX: ubuntu22_x86_64_itt_clang_Release + SCCACHE_AZURE_KEY_PREFIX: ubuntu22_x86_64_itt_clang_Release_faster_build if: ${{ !needs.smart_ci.outputs.skip_workflow && github.event_name != 'merge_group' }} steps: @@ -157,6 +157,7 @@ jobs: -DCMAKE_COMPILE_WARNING_AS_ERROR=ON \ -DENABLE_PROFILING_ITT=ON \ -DSELECTIVE_BUILD=COLLECT \ + -DENABLE_FASTER_BUILD=ON \ -DENABLE_DEBUG_CAPS=ON \ -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CMAKE_C_COMPILER_LAUNCHER }} \ -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CMAKE_CXX_COMPILER_LAUNCHER }} \ diff --git a/src/tests/functional/plugin/conformance/subgraphs_dumper/tests/cache/op_cache.cpp b/src/tests/functional/plugin/conformance/subgraphs_dumper/tests/cache/op_cache.cpp index 4e0997f46a641e..66ef666172f4c3 100644 --- a/src/tests/functional/plugin/conformance/subgraphs_dumper/tests/cache/op_cache.cpp +++ b/src/tests/functional/plugin/conformance/subgraphs_dumper/tests/cache/op_cache.cpp @@ -159,6 +159,10 @@ TEST_F(OpCacheUnitTest, update_cache_by_model) { } TEST_F(OpCacheUnitTest, serialize_op) { + // Ticket: 149824 + if (std::getenv("GITHUB_ACTIONS")) { + GTEST_SKIP(); + } this->set_serialization_dir(test_artifacts_dir); ASSERT_TRUE(this->serialize_op({convert_node, test_meta})); ASSERT_TRUE(ov::util::directory_exists(test_artifacts_dir)); From fd072003fae0a7de585cae79913e8adb13e4cacc Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Thu, 15 Aug 2024 16:02:03 +0400 Subject: [PATCH 020/117] [TF FE] Stabilize Bucketize tests on all platforms (#26072) **Details:** Stabilize Bucketize tests on all platforms (ARM, GPU inclusively) **Ticket:** 122716 --------- Signed-off-by: Kazantsev, Roman --- tests/layer_tests/common/utils/tf_utils.py | 12 +++- .../tensorflow_tests/test_tf_Bucketize.py | 60 ++++++++++++------- 2 files changed, 49 insertions(+), 23 deletions(-) diff --git a/tests/layer_tests/common/utils/tf_utils.py b/tests/layer_tests/common/utils/tf_utils.py index b50afefd25722b..db9690a1fff956 100644 --- a/tests/layer_tests/common/utils/tf_utils.py +++ b/tests/layer_tests/common/utils/tf_utils.py @@ -1,10 +1,9 @@ # Copyright (C) 2018-2024 Intel Corporation # SPDX-License-Identifier: Apache-2.0 +import numpy as np import os import re - -import numpy as np import tensorflow as tf os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' @@ -22,6 +21,15 @@ def mix_array_with_value(input_array, value): return np.where(mask, input_array, value) +def mix_array_with_several_values(input_array, values, rng): + num_values = len(values) + input_shape = input_array.shape + mask = rng.choice(num_values + 1, input_shape).astype(np.int32) + for ind, value in enumerate(values): + input_array = np.where(mask == ind, input_array, value) + return input_array + + def load_graph(model_file, output_nodes_for_freeze=None): is_meta = os.path.splitext(model_file)[-1] == ".meta" diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py b/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py index bbe1f283e280ea..1e64843c963ecb 100644 --- a/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py +++ b/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py @@ -1,53 +1,71 @@ # Copyright (C) 2018-2024 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -import platform - import numpy as np +import platform +import platform import pytest import tensorflow as tf from common.tf_layer_test_class import CommonTFLayerTest +from common.utils.tf_utils import mix_array_with_several_values + +rng = np.random.default_rng(3476123) class TestBucketize(CommonTFLayerTest): def _prepare_input(self, inputs_info): - assert 'input:0' in inputs_info, "Test error: inputs_info must contain `input`" + assert 'input:0' in inputs_info, "inputs_info must contain `input`" input_shape = inputs_info['input:0'] input_type = self.input_type + boundaries = self.boundaries + + # compute all preferable values that is good to see + all_prefer_values = [] + boundaries_size = len(boundaries) + for ind in range(boundaries_size): + if ind == 0: + all_prefer_values.append(boundaries[ind] - 1.0) + else: + all_prefer_values.append((boundaries[ind - 1] + boundaries[ind]) / 2.0) + all_prefer_values.append(boundaries[ind]) + if ind == (boundaries_size - 1): + all_prefer_values.append(boundaries[ind] + 1.0) + inputs_data = {} - input_data = np.random.randint(-20, 20, input_shape).astype(input_type) + input_data = rng.choice(200, input_shape).astype(input_type) - 100 + # mix input data with preferable values + input_data = mix_array_with_several_values(input_data, all_prefer_values, rng) inputs_data['input:0'] = input_data return inputs_data def create_bucketize_net(self, input_shape, input_type, boundaries_size): self.input_type = input_type + # generate boundaries list + # use wider range for boundaries than input data in order to cover all bucket indices cases + boundaries = (np.sort(rng.choice(400, boundaries_size, replace=False).astype(np.float32) - 200)).tolist() + self.boundaries = boundaries + tf.compat.v1.reset_default_graph() with tf.compat.v1.Session() as sess: input = tf.compat.v1.placeholder(input_type, input_shape, 'input') - # generate boundaries list - # use wider range for boundaries than input data in order to cover all bucket indices cases - boundaries = np.sort(np.unique(np.random.randint(-200, 200, [boundaries_size]).astype(np.float32))).tolist() tf.raw_ops.Bucketize(input=input, boundaries=boundaries) tf.compat.v1.global_variables_initializer() tf_net = sess.graph_def return tf_net, None - test_data_basic = [ - dict(input_shape=[5], input_type=np.int32, boundaries_size=1), - dict(input_shape=[3, 4], input_type=np.float32, boundaries_size=0), - dict(input_shape=[2, 3, 4], input_type=np.float32, boundaries_size=300), - ] - - @pytest.mark.parametrize("params", test_data_basic) + @pytest.mark.parametrize('input_shape', [[], [5], [3, 4], [2, 3, 4]]) + @pytest.mark.parametrize('input_type', [np.int32, np.int64, np.float32, np.float64]) + @pytest.mark.parametrize('boundaries_size', [0, 1, 10, 200]) @pytest.mark.precommit @pytest.mark.nightly - @pytest.mark.xfail(platform.machine() in ["aarch64", "arm64", "ARM64"], - reason='Ticket - 122716') - def test_bucketize_basic(self, params, ie_device, precision, ir_version, temp_dir, - use_legacy_frontend): - if ie_device == 'GPU': - pytest.skip("accuracy mismatch on GPU") - self._test(*self.create_bucketize_net(**params), + def test_bucketize(self, input_shape, input_type, boundaries_size, + ie_device, precision, ir_version, temp_dir, + use_legacy_frontend): + if ie_device == 'GPU' and boundaries_size == 0: + pytest.skip("149852: accuracy error for boundaries_size == 0 on GPU") + if platform.machine() in ["aarch64", "arm64", "ARM64"] and boundaries_size == 0: + pytest.skip("149853: segmentation fault or signal 11 for boundaries_size == 0 on CPU") + self._test(*self.create_bucketize_net(input_shape, input_type, boundaries_size), ie_device, precision, ir_version, temp_dir=temp_dir, use_legacy_frontend=use_legacy_frontend) From e263db135ccbc230dc8846ac57398b0d812d6c27 Mon Sep 17 00:00:00 2001 From: Evgeny Kotov Date: Thu, 15 Aug 2024 15:51:47 +0200 Subject: [PATCH 021/117] tensorflow_hub performance tests failure while reading config empty line (#26068) ### Details: - fix utils reading config ### Tickets: - 149822 Co-authored-by: Roman Kazantsev --- tests/model_hub_tests/models_hub_common/utils.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/model_hub_tests/models_hub_common/utils.py b/tests/model_hub_tests/models_hub_common/utils.py index 068826669fab5b..b014c8dc64c2d8 100644 --- a/tests/model_hub_tests/models_hub_common/utils.py +++ b/tests/model_hub_tests/models_hub_common/utils.py @@ -39,6 +39,8 @@ def get_skipped_model_links(filename: str): with open(filename) as f: for model_info in f: model_info = model_info.strip() + if not model_info: + continue model_name, model_link = model_info.split(',') links.add(model_link) return links From 1de23c3c0cfd0b36d14152c4a7e3bc69a2d5fc44 Mon Sep 17 00:00:00 2001 From: Evgenya Nugmanova Date: Thu, 15 Aug 2024 08:05:04 -0700 Subject: [PATCH 022/117] Symbol: operator+; operator-; (#25360) ### Details: - *Introduces operator+ and operator- for ov::Symbol* - *Uses introduced operators in `Add::evaluate_symbol`, `Subtract::evaluate_symbol` and shape_infer of Range operation* Significantly reduces the number of unique symbols in models, allowing better optimization of ShapeOf subgraphs in dynamic models. ### Tickets: - *CVS-112292* --------- Co-authored-by: Pavel Durandin Co-authored-by: Michal Lukaszewski Co-authored-by: Anastasia Kuporosova Co-authored-by: Ivan Tikhonov --- .../python/src/pyopenvino/graph/symbol.cpp | 14 + .../tests/test_runtime/test_dimension.py | 9 + .../symbolic_optimizations.cpp | 48 -- src/core/include/openvino/core/symbol.hpp | 31 +- src/core/include/openvino/op/add.hpp | 1 + src/core/include/openvino/op/subtract.hpp | 1 + .../include/range_shape_inference.hpp | 46 +- src/core/src/dimension.cpp | 8 +- src/core/src/op/add.cpp | 15 + src/core/src/op/subtract.cpp | 15 + src/core/src/symbol.cpp | 431 +++++++++++++++++- src/core/tests/symbol.cpp | 71 +++ src/core/tests/type_prop/range.cpp | 44 ++ 13 files changed, 651 insertions(+), 83 deletions(-) create mode 100644 src/core/tests/symbol.cpp diff --git a/src/bindings/python/src/pyopenvino/graph/symbol.cpp b/src/bindings/python/src/pyopenvino/graph/symbol.cpp index 5ed06c3506177d..339284de8dc5da 100644 --- a/src/bindings/python/src/pyopenvino/graph/symbol.cpp +++ b/src/bindings/python/src/pyopenvino/graph/symbol.cpp @@ -25,6 +25,20 @@ void regclass_graph_Symbol(py::module m) { }, py::is_operator()); + symbol.def( + "__add__", + [](const std::shared_ptr& a, const std::shared_ptr& b) { + return a + b; + }, + py::is_operator()); + + symbol.def( + "__sub__", + [](const std::shared_ptr& a, const std::shared_ptr& b) { + return a - b; + }, + py::is_operator()); + symbol.def( "__bool__", [](const std::shared_ptr& self) -> bool { diff --git a/src/bindings/python/tests/test_runtime/test_dimension.py b/src/bindings/python/tests/test_runtime/test_dimension.py index cd20accc14bc33..d3a87a606ad6ad 100644 --- a/src/bindings/python/tests/test_runtime/test_dimension.py +++ b/src/bindings/python/tests/test_runtime/test_dimension.py @@ -80,6 +80,15 @@ def test_symbol(): assert dimension.get_symbol() == new_dimension.get_symbol(), "Check: Two symbols are equal: Symbol.__eq__" +def test_symbol_operators(): + symbol_a, symbol_b = Symbol(), Symbol() + assert symbol_a + symbol_b == symbol_b + symbol_a + + symbol_c, symbol_d = Symbol(), Symbol() + assert symbol_c + symbol_d - symbol_d == symbol_c + assert symbol_c + symbol_d - symbol_c == symbol_d + + def test_symbol_hash(): symbol = Symbol() assert isinstance(hash(symbol), int) diff --git a/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp b/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp index d6629f326a2a70..e0a057ef74e390 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp @@ -46,50 +46,6 @@ void symbolic_set_up_for_shape(ov::PartialShape& shape) { d.set_symbol(std::make_shared()); } } - -void special_case_range_symbol_propagation(const std::shared_ptr& node) { - /* Symbol propagation through specific Range operation - start shift - | \ / - | Add step == 1 - \ / / - Range - */ - if (!ov::is_type(node) && !ov::is_type(node)) - return; - - auto output_shape = node->get_output_partial_shape(0); - if (output_shape.rank().is_dynamic() || output_shape.size() != 1) - return; - - auto step_value = ov::util::get_constant_from_source(node->input_value(2)); - if (!step_value || step_value->cast_vector()[0] != 1) - return; - - auto start_symbols = node->get_input_tensor(0).get_value_symbol(); - if (start_symbols.size() != 1 || start_symbols[0] == nullptr) - return; - auto start_symbol = start_symbols[0]; - - auto stop_node = node->input_value(1).get_node_shared_ptr(); - if (!ov::is_type(stop_node)) - return; - auto add_in0_symbols = stop_node->get_input_tensor(0).get_value_symbol(); - if (add_in0_symbols.size() != 1 || add_in0_symbols[0] == nullptr) - return; - auto add_in0_symbol = add_in0_symbols[0]; - - auto add_in1_symbols = stop_node->get_input_tensor(1).get_value_symbol(); - if (add_in1_symbols.size() != 1 || add_in1_symbols[0] == nullptr) - return; - auto add_in1_symbol = add_in1_symbols[0]; - - if (add_in0_symbol == start_symbol) - output_shape[0].set_symbol(add_in1_symbol); - else if (add_in1_symbol == start_symbol) - output_shape[0].set_symbol(add_in0_symbol); - node->set_output_type(0, node->get_output_element_type(0), output_shape); -} } // namespace bool ov::pass::SymbolicPropagation::run_on_model(const std::shared_ptr& m) { @@ -104,10 +60,6 @@ bool ov::pass::SymbolicPropagation::run_on_model(const std::shared_ptroutputs()) { auto shape = output.get_partial_shape(); symbolic_set_up_for_shape(shape); diff --git a/src/core/include/openvino/core/symbol.hpp b/src/core/include/openvino/core/symbol.hpp index 48a733e0d5c08b..6eb52692553bbf 100644 --- a/src/core/include/openvino/core/symbol.hpp +++ b/src/core/include/openvino/core/symbol.hpp @@ -3,37 +3,46 @@ // #pragma once - #include +#include +#include #include "openvino/core/core_visibility.hpp" namespace ov { - class Symbol; +using SymbolPtr = std::shared_ptr; namespace symbol { /// \brief If both symbols are valid, sets them as equal -void OPENVINO_API set_equal(const std::shared_ptr& lhs, const std::shared_ptr& rhs); +void OPENVINO_API set_equal(const SymbolPtr& lhs, const SymbolPtr& rhs); /// \brief Returns true if both symbols are valid and are equal otherwise returns false -bool OPENVINO_API are_equal(const std::shared_ptr& lhs, const std::shared_ptr& rhs); +bool OPENVINO_API are_equal(const SymbolPtr& lhs, const SymbolPtr& rhs); /// \brief Returns a representative (the most distant parent) of an equality group of this symbol -std::shared_ptr OPENVINO_API ancestor_of(const std::shared_ptr& x); +std::shared_ptr OPENVINO_API ancestor_of(const SymbolPtr& x); } // namespace symbol -/// \brief Class representing unique symbol for the purpose of symbolic shape inference. Equality of symbols is being -/// tracked by Disjoint-set data structure +SymbolPtr OPENVINO_API operator+(const SymbolPtr& lhs, const SymbolPtr& rhs); +SymbolPtr OPENVINO_API operator-(const SymbolPtr& lhs, const SymbolPtr& rhs); + +/// \brief Class representing unique symbol for the purpose of symbolic shape inference /// \ingroup ov_model_cpp_api class OPENVINO_API Symbol { public: /// \brief Default constructs a unique symbol - Symbol() = default; + Symbol(); + /// @brief Destructor ensures shared MathMaps are cleared from the expired symbols + ~Symbol(); private: - friend std::shared_ptr ov::symbol::ancestor_of(const std::shared_ptr& x); - friend void ov::symbol::set_equal(const std::shared_ptr& lhs, const std::shared_ptr& rhs); + friend SymbolPtr ov::symbol::ancestor_of(const SymbolPtr& x); + friend void ov::symbol::set_equal(const SymbolPtr& lhs, const SymbolPtr& rhs); + + friend SymbolPtr ov::operator+(const SymbolPtr& lhs, const SymbolPtr& rhs); + friend SymbolPtr ov::operator-(const SymbolPtr& lhs, const SymbolPtr& rhs); - std::shared_ptr m_parent = nullptr; + class Impl; + std::unique_ptr pimpl; }; } // namespace ov diff --git a/src/core/include/openvino/op/add.hpp b/src/core/include/openvino/op/add.hpp index 0691cdfed29371..ebc21fe089afde 100644 --- a/src/core/include/openvino/op/add.hpp +++ b/src/core/include/openvino/op/add.hpp @@ -39,6 +39,7 @@ class OPENVINO_API Add : public util::BinaryElementwiseArithmetic { std::shared_ptr clone_with_new_inputs(const OutputVector& new_args) const override; bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override; + bool evaluate_symbol(ov::TensorSymbolVector& output_symbols) const override; bool has_evaluate() const override; }; } // namespace v1 diff --git a/src/core/include/openvino/op/subtract.hpp b/src/core/include/openvino/op/subtract.hpp index 35ed4e332823f4..181b05d55662cd 100644 --- a/src/core/include/openvino/op/subtract.hpp +++ b/src/core/include/openvino/op/subtract.hpp @@ -28,6 +28,7 @@ class OPENVINO_API Subtract : public util::BinaryElementwiseArithmetic { std::shared_ptr clone_with_new_inputs(const OutputVector& new_args) const override; bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override; + bool evaluate_symbol(ov::TensorSymbolVector& output_symbols) const override; bool has_evaluate() const override; }; } // namespace v1 diff --git a/src/core/shape_inference/include/range_shape_inference.hpp b/src/core/shape_inference/include/range_shape_inference.hpp index 3be56a4543a7dd..e82bd5f5d1fbb6 100644 --- a/src/core/shape_inference/include/range_shape_inference.hpp +++ b/src/core/shape_inference/include/range_shape_inference.hpp @@ -11,6 +11,33 @@ namespace op { namespace ShapeInferRange { +template ::value>::type* = nullptr> +void dynamic_case(const Node* op, + std::vector& output_shapes, + const double& start, + const double& step, + bool start_val, + bool step_val) { + output_shapes[0] = ov::PartialShape::dynamic(1); + if (op->get_input_size() == 3 && step_val && step == 1) { + auto start_symbol = op->input_value(0).get_tensor().get_value_symbol(); + auto stop_symbol = op->input_value(1).get_tensor().get_value_symbol(); + if (start_val && start == 0 && !stop_symbol.empty()) { + output_shapes[0][0].set_symbol(stop_symbol[0]); + } else if (!start_symbol.empty() && !stop_symbol.empty()) { + output_shapes[0][0].set_symbol(stop_symbol[0] - start_symbol[0]); + } + } +} + +template ::value>::type* = nullptr> +void dynamic_case(const Node* op, + std::vector& output_shapes, + const double& start, + const double& step, + bool start_val, + bool step_val) {} + template > std::vector range_shape_infer(const Node* op, const std::vector& input_shapes, @@ -35,12 +62,18 @@ std::vector range_shape_infer(const Node* op, NODE_VALIDATION_CHECK(op, start_val->size() == 1); start = (*start_val)[0]; NODE_VALIDATION_CHECK(op, std::isfinite(start) && !std::isnan(start), "'start' cannot be nan or infinite."); + if (output_is_integral) + // all inputs must be casted to output_type before the rounding for casting values are done towards zero + start = std::trunc(start); } if (stop_val) { NODE_VALIDATION_CHECK(op, stop_val->size() == 1); stop = (*stop_val)[0]; NODE_VALIDATION_CHECK(op, std::isfinite(stop) && !std::isnan(stop), "'stop' cannot be nan or infinite."); + if (output_is_integral) + // all inputs must be casted to output_type before the rounding for casting values are done towards zero + stop = std::trunc(stop); } if (step_val) { @@ -52,18 +85,13 @@ std::vector range_shape_infer(const Node* op, NODE_VALIDATION_CHECK(op, std::isfinite(step) && !std::isnan(step) && step != 0, "'step' cannot be zero, nan, or infinite."); + if (output_is_integral) + // all inputs must be casted to output_type before the rounding for casting values are done towards zero + step = std::trunc(step); } auto output_shapes = std::vector(1); if (start_val && stop_val && step_val) { - // all inputs must be casted to output_type before - // the rounding for casting values are done towards zero - if (output_is_integral) { - start = std::trunc(start); - stop = std::trunc(stop); - step = std::trunc(step); - } - // the number of elements is: max(ceil((stop − start) / step), 0) double span; if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) { @@ -76,7 +104,7 @@ std::vector range_shape_infer(const Node* op, output_shapes[0] = TRShape{static_cast(strided)}; } else { - output_shapes[0] = ov::PartialShape::dynamic(1); + dynamic_case(op, output_shapes, start, step, start_val, step_val); } return output_shapes; } diff --git a/src/core/src/dimension.cpp b/src/core/src/dimension.cpp index 454207c24377e4..78e7f2c7cffdf4 100644 --- a/src/core/src/dimension.cpp +++ b/src/core/src/dimension.cpp @@ -132,13 +132,17 @@ Dimension Dimension::operator+(const Dimension& dim) const { return *this; else if (m_dimension == 0) return dim; - return Dimension(m_dimension + dim.m_dimension); + auto result = Dimension(m_dimension + dim.m_dimension); + result.m_symbol = m_symbol + dim.m_symbol; + return result; } Dimension Dimension::operator-(const Dimension& dim) const { if (dim.m_dimension == 0) return *this; - return Dimension(m_dimension - dim.m_dimension); + auto result = Dimension(m_dimension - dim.m_dimension); + result.m_symbol = m_symbol - dim.m_symbol; + return result; } Dimension Dimension::operator/(const value_type divisor) const { diff --git a/src/core/src/op/add.cpp b/src/core/src/op/add.cpp index 6b4680fed57349..7e7748beccca7f 100644 --- a/src/core/src/op/add.cpp +++ b/src/core/src/op/add.cpp @@ -63,6 +63,21 @@ bool Add::evaluate(ov::TensorVector& outputs, const ov::TensorVector& inputs) co get_autob()); } +bool Add::evaluate_symbol(ov::TensorSymbolVector& output_symbols) const { + const auto &lhs_pshape = input(0).get_tensor().get_partial_shape(), + &rhs_pshape = input(1).get_tensor().get_partial_shape(); + const auto &lhs_symbols = input(0).get_tensor().get_value_symbol(), + &rhs_symbols = input(1).get_tensor().get_value_symbol(); + if (lhs_pshape.is_dynamic() || rhs_pshape.is_dynamic() || lhs_pshape != rhs_pshape || lhs_symbols.empty() || + lhs_symbols.size() != rhs_symbols.size()) + return false; // broadcasting is not supported here yet + output_symbols.resize(1); + output_symbols[0].resize(shape_size(lhs_pshape.to_shape())); + for (size_t i = 0; i < output_symbols[0].size(); ++i) + output_symbols[0][i] = lhs_symbols[i] + rhs_symbols[i]; + return true; +} + bool Add::has_evaluate() const { OV_OP_SCOPE(v1_Add_has_evaluate); switch (get_input_element_type(0)) { diff --git a/src/core/src/op/subtract.cpp b/src/core/src/op/subtract.cpp index f8f0bb93d03e2b..3695f36110efc0 100644 --- a/src/core/src/op/subtract.cpp +++ b/src/core/src/op/subtract.cpp @@ -63,6 +63,21 @@ bool Subtract::evaluate(TensorVector& outputs, const TensorVector& inputs) const get_autob()); } +bool Subtract::evaluate_symbol(ov::TensorSymbolVector& output_symbols) const { + const auto &lhs_pshape = input(0).get_tensor().get_partial_shape(), + &rhs_pshape = input(1).get_tensor().get_partial_shape(); + const auto &lhs_symbols = input(0).get_tensor().get_value_symbol(), + &rhs_symbols = input(1).get_tensor().get_value_symbol(); + if (lhs_pshape.is_dynamic() || rhs_pshape.is_dynamic() || lhs_pshape != rhs_pshape || lhs_symbols.empty() || + lhs_symbols.size() != rhs_symbols.size()) + return false; // broadcasting is not supported here yet + output_symbols.resize(1); + output_symbols[0].resize(shape_size(lhs_pshape.to_shape())); + for (size_t i = 0; i < output_symbols[0].size(); ++i) + output_symbols[0][i] = lhs_symbols[i] - rhs_symbols[i]; + return true; +} + bool Subtract::has_evaluate() const { OV_OP_SCOPE(v1_Subtract_has_evaluate); switch (get_input_element_type(0)) { diff --git a/src/core/src/symbol.cpp b/src/core/src/symbol.cpp index 48c913bfb53881..d6037b6c004b47 100644 --- a/src/core/src/symbol.cpp +++ b/src/core/src/symbol.cpp @@ -4,27 +4,432 @@ #include "openvino/core/symbol.hpp" -std::shared_ptr ov::symbol::ancestor_of(const std::shared_ptr& symbol) { +#include +#include +#include + +namespace ov { +using WeakSymbol = std::weak_ptr; +using WeakSymbolVector = std::vector; + +inline bool operator==(const WeakSymbol& lhs, const WeakSymbol& rhs) { + if (lhs.expired() && rhs.expired()) + return true; + if (lhs.expired() || rhs.expired()) + return false; + return lhs.lock().get() == rhs.lock().get(); +} + +inline bool operator!=(const WeakSymbol& lhs, const WeakSymbol& rhs) { + return !(lhs == rhs); +} + +inline bool operator<(const WeakSymbol& lhs, const WeakSymbol& rhs) { + return std::owner_less()(lhs.lock(), rhs.lock()); +} + +struct WeakSymbolVectorHash { + std::size_t operator()(const WeakSymbolVector& v) const { + size_t seed = 0; + for (const auto& element : v) { + const auto& el_hash = element.expired() ? 0 : std::hash()(element.lock()); + seed ^= el_hash + 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + return seed; + } +}; + +using MathMap = std::map; + +class ov::Symbol::Impl { +public: + Impl() = default; + ~Impl() = default; + +private: + /* + * Equality relations between symbols are managed by the Disjoint-set data structure. + * m_parent field gives access to a parent tree. Parent tree grows when we use set_equal routine. + * + * The root of parent tree is called ancestor -- a representative of a group of equal symbols. + * To get an ancestor of any symbol, call ancestor_of routine. If current symbol is an ancestor, then its m_parent + * field is nullptr and ancestor_of would return current symbol. + * */ + SymbolPtr m_parent = nullptr; + + /* + * Shared MathMap represents mathematical relations between symbols. Rules: + * - map stores only ancestor symbols + * - all the Symbols in the map must share the same map as their respective field + * + * To ensure rules, set_equal routine and operators are managing maps of both symbols. + * + * MathMap m_add reflects addition and subtraction. Given symbols A, B, C and D + * - relation A + B = C would be reflected as key={A, B} value=C in the map + * - relation A - B = C would be reflected as key={B, C} value=A in the map + * - relation A + B + C = D would be reflected as key={A, B, C} value=D in the map + * + * During destruction of a symbol, m_add map is being cleared from the records with expired symbols + */ + std::shared_ptr m_add = nullptr; + +public: + const SymbolPtr& get_parent() const { + return m_parent; + } + + void set_parent(const SymbolPtr& new_parent) { + m_parent = new_parent; + } + + const std::shared_ptr& get_add_map() const { + return m_add; + } + + void set_add_map(const std::shared_ptr& new_map) { + m_add = new_map; + } +}; +} // namespace ov + +ov::SymbolPtr ov::symbol::ancestor_of(const SymbolPtr& symbol) { auto x = symbol; - while (x->m_parent) { - if (x->m_parent->m_parent) - x->m_parent = x->m_parent->m_parent; - x = x->m_parent; + while (const auto& parent = x->pimpl->get_parent()) { + const auto& grand_parent = parent->pimpl->get_parent(); + if (grand_parent) + x->pimpl->set_parent(grand_parent); + x = x->pimpl->get_parent(); } return x; } -bool ov::symbol::are_equal(const std::shared_ptr& lhs, const std::shared_ptr& rhs) { +bool ov::symbol::are_equal(const SymbolPtr& lhs, const SymbolPtr& rhs) { if (lhs == nullptr || rhs == nullptr) return false; - return ov::symbol::ancestor_of(lhs).get() == ov::symbol::ancestor_of(rhs).get(); + return ancestor_of(lhs).get() == ancestor_of(rhs).get(); } -void ov::symbol::set_equal(const std::shared_ptr& lhs, const std::shared_ptr& rhs) { - if (lhs == nullptr || rhs == nullptr) +namespace { // helpers to work with shared math maps in symbols +bool contains(const ov::WeakSymbolVector& vec, const ov::WeakSymbol& s) { + return std::find(vec.cbegin(), vec.cend(), s) != vec.cend(); +} + +bool contains(const ov::WeakSymbolVector& vec, const ov::Symbol* s) { + return std::any_of(vec.begin(), vec.end(), [&s](const ov::WeakSymbol& i) { + if (i.lock() == nullptr) + return s == nullptr; + return i.lock().get() == s; + }); +} + +void sort(ov::WeakSymbolVector& vec) { + std::sort(vec.begin(), vec.end()); +} + +void replace(ov::WeakSymbolVector& vec, const ov::WeakSymbol& old_s, const ov::WeakSymbol& new_s) { + std::replace_if( + vec.begin(), + vec.end(), + [&old_s](const ov::WeakSymbol& s) { + return s == old_s; + }, + new_s); + sort(vec); +} + +void replace_no_check(ov::SymbolPtr old_symbol, ov::SymbolPtr new_symbol, ov::MathMap& m) { + ov::MathMap map_with_old; + for (const auto& item : m) + if (item.second == ov::WeakSymbol(old_symbol) || contains(item.first, old_symbol.get())) + map_with_old.insert(item); + for (const auto& item : map_with_old) + m.erase(item.first); + for (const auto& item : map_with_old) { + auto new_key = item.first; + replace(new_key, old_symbol, new_symbol); + m.insert({new_key, item.second == old_symbol ? new_symbol : item.second}); + } +} + +void remove_same_elements(ov::WeakSymbolVector& lhs, ov::WeakSymbolVector& rhs) { + for (auto lhs_it = lhs.begin(); lhs_it != lhs.end();) { + if (lhs_it->expired()) + continue; + auto rhs_it = std::find(rhs.cbegin(), rhs.cend(), *lhs_it); + if (rhs_it != rhs.end()) { + rhs.erase(rhs_it); + lhs_it = lhs.erase(lhs_it); + } else { + ++lhs_it; + } + } +} + +void insert_with_check(const ov::WeakSymbolVector& key, + const ov::WeakSymbol& value, + ov::MathMap& m, + std::queue>& to_equalize) { + bool insert = true; + auto it = m.find(key); + if (it != m.end()) { + // map m already contains the record with same key, no need to insert new record into the map m + insert = false; + if (it->second != value) + // if the record had different value, then we need to equalize original and new key + to_equalize.emplace(it->second, value); + } else { + // map m doesn't have records with the key, however we are in a search for new equality rules + for (const auto& item : m) { + if (item.second == value) { // map_ker + if (item.first.size() == key.size()) { + auto item_diff = item.first, key_diff = key; + remove_same_elements(item_diff, key_diff); + if (item_diff.size() == 1 && key_diff.size() == 1) { + to_equalize.emplace(item_diff[0], key_diff[0]); + insert = false; + } + } + } + } + } + if (insert) + m.insert({key, value}); +} + +void replace_inplace_with_check(ov::SymbolPtr old_symbol, + ov::SymbolPtr new_symbol, + ov::MathMap& m, + std::queue>& to_equalize) { + ov::MathMap with_old; + for (const auto& item : m) + if (item.second == old_symbol || contains(item.first, old_symbol)) + with_old.insert({item.first, item.second}); + for (const auto& item : with_old) + m.erase(item.first); + for (const auto& item : with_old) { + auto new_key = item.first; + replace(new_key, old_symbol, new_symbol); + insert_with_check(new_key, (item.second == old_symbol ? new_symbol : item.second), m, to_equalize); + } +} + +void replace_with_check(ov::SymbolPtr old_symbol, + ov::SymbolPtr new_symbol, + ov::MathMap& old_map, + ov::MathMap& new_map, + std::queue>& to_equalize) { + ov::MathMap with_new; + for (const auto& item : new_map) + if (item.second == new_symbol || contains(item.first, new_symbol)) + with_new.insert({item.first, item.second}); + for (const auto& item : with_new) + new_map.erase(item.first); + // new_map contains only independent records, with_new contains records with new_symbol + ov::MathMap with_old; + for (const auto& item : old_map) { + if (item.second == old_symbol || contains(item.first, old_symbol)) { + auto new_key = item.first; + replace(new_key, old_symbol, new_symbol); + with_old.insert({new_key, item.second}); + } else { + new_map.insert({item.first, item.second}); + } + } + // new_map contains independent records from new and from old map; old_map won't be used further + old_map.clear(); + // with_old contains records from old_map that had old_symbol, old_symbol was replaced with new_symbol + + // merging with_new and with_old, performing necessary checks to figure out if we have more equality rules + for (const auto& item : with_old) + insert_with_check(item.first, (item.second == old_symbol ? new_symbol : item.second), with_new, to_equalize); + // with_old is merged into the with_new; necessary checks were made to ensure all new equality rules are collected + + for (const auto& item : with_new) + new_map.insert({item.first, item.second}); +} + +void collect_records_with_result(ov::SymbolPtr result, + const std::shared_ptr& map, + std::vector& records) { + if (map) + for (const auto& item : *map) + if (item.second.lock() && item.second.lock().get() == result.get()) + records.push_back(item.first); +} + +void share_map(std::shared_ptr shared_map, + std::shared_ptr donor_map, + void (*set_map)(const ov::WeakSymbol&, std::shared_ptr)) { + if (!donor_map || donor_map->empty()) return; - auto lhs_root = ov::symbol::ancestor_of(lhs), rhs_root = ov::symbol::ancestor_of(rhs); - if (lhs_root.get() == rhs_root.get()) - return; // already are equal - lhs_root->m_parent = std::move(rhs_root); + for (const auto& item : *donor_map) { + auto key = item.first; + for (const auto& key_element : key) + set_map(key_element, shared_map); + auto value = item.second; + set_map(value, shared_map); + shared_map->insert({key, value}); + } +} +} // namespace + +void ov::symbol::set_equal(const SymbolPtr& l, const SymbolPtr& r) { + std::queue> to_equalize; + to_equalize.emplace(l, r); + + do { + auto item = to_equalize.front(); + to_equalize.pop(); + auto lhs = item.first.lock(), rhs = item.second.lock(); + if (!lhs || !rhs || ov::symbol::are_equal(lhs, rhs)) + continue; // invalid or already are equal + auto A = ancestor_of(lhs), B = ancestor_of(rhs); + A->pimpl->set_parent(B); + + // m_add unification + auto A_map = A->pimpl->get_add_map(); + auto B_map = B->pimpl->get_add_map(); + + if (A_map && !B_map) { + replace_no_check(A, B, *A_map); + B->pimpl->set_add_map(A_map); // rhs is the root of lhs now + A->pimpl->set_add_map(nullptr); + } else if (A_map && B_map && A_map.get() == B_map.get()) { + replace_inplace_with_check(A, B, *B_map, to_equalize); + A->pimpl->set_add_map(nullptr); // rhs is the root of lhs now + } else if (A_map && B_map) { + replace_with_check(A, B, *A_map, *B_map, to_equalize); + for (auto& i : *B_map) { + for (auto& j : i.first) { + if (!j.expired()) + j.lock()->pimpl->set_add_map(B_map); + } + if (!i.second.expired()) + i.second.lock()->pimpl->set_add_map(B_map); + } + A->pimpl->set_add_map(nullptr); + } + } while (!to_equalize.empty()); +} + +ov::Symbol::Symbol() : pimpl(new Impl()) {} + +ov::Symbol::~Symbol() { + if (pimpl->get_add_map()) { + for (auto item = pimpl->get_add_map()->begin(), last = pimpl->get_add_map()->end(); item != last;) { + if (contains(item->first, nullptr) || contains(item->first, this) || item->second.expired() || + item->second.lock().get() == this) { + item = pimpl->get_add_map()->erase(item); + } else { + ++item; + } + } + pimpl->set_add_map(nullptr); + } +} + +ov::SymbolPtr ov::operator+(const SymbolPtr& lhs, const SymbolPtr& rhs) { + if (lhs == nullptr || rhs == nullptr) + return nullptr; // should we create a new shared_ptr to a symbol here? + // A + B = C + auto A = symbol::ancestor_of(lhs); + auto B = symbol::ancestor_of(rhs); + auto new_key = ov::WeakSymbolVector({A, B}); + sort(new_key); + std::shared_ptr shared_map = nullptr; + if (A->pimpl->get_add_map() && B->pimpl->get_add_map() && + A->pimpl->get_add_map().get() == B->pimpl->get_add_map().get() && + !A->pimpl->get_add_map()->empty()) { // maps are shared + auto it = A->pimpl->get_add_map()->find(new_key); + if (it != A->pimpl->get_add_map()->end() && it->second.lock()) { // elements were summed before + return it->second.lock(); + } + shared_map = A->pimpl->get_add_map(); + } else { + // share maps (if any) between A and B + shared_map = std::make_shared(); + auto set_m_add = [](const ov::WeakSymbol& s, std::shared_ptr m) -> void { + if (!s.expired()) + s.lock()->pimpl->set_add_map(m); + }; + share_map(shared_map, A->pimpl->get_add_map(), set_m_add); + share_map(shared_map, B->pimpl->get_add_map(), set_m_add); + A->pimpl->set_add_map(shared_map); + B->pimpl->set_add_map(shared_map); + } + auto C = std::make_shared(); + C->pimpl->set_add_map(shared_map); + + // add L + R = result to the shared map + // search for X + Y = L and W + Z = R records to make X + Y + W + Z = result records + std::vector this_components{{A}}, other_components{{B}}; + collect_records_with_result(A, shared_map, this_components); + collect_records_with_result(B, shared_map, other_components); + for (const auto& this_element : this_components) { + for (const auto& other_element : other_components) { + ov::WeakSymbolVector new_key = this_element; + new_key.insert(new_key.begin(), other_element.begin(), other_element.end()); + sort(new_key); + shared_map->insert({new_key, C}); + } + } + return C; +} + +ov::SymbolPtr ov::operator-(const SymbolPtr& lhs, const SymbolPtr& rhs) { + if (lhs == nullptr || rhs == nullptr) + return nullptr; // should we create a new shared_ptr here? + // A - B = C => B + C = A + auto A = symbol::ancestor_of(lhs); + auto B = symbol::ancestor_of(rhs); + const auto bw = ov::WeakSymbol(B); + + std::shared_ptr shared_map = nullptr; + + if (A->pimpl->get_add_map() && B->pimpl->get_add_map() && + A->pimpl->get_add_map().get() == B->pimpl->get_add_map().get() && + !A->pimpl->get_add_map()->empty()) { // maps are shared + std::vector A_components{}, B_components{}; + collect_records_with_result(A, A->pimpl->get_add_map(), A_components); + for (const auto& item : A_components) { + if (item.size() == 2 && item[0] == bw && !item[1].expired()) { + return item[1].lock(); + } + if (item.size() == 2 && item[1] == bw && !item[0].expired()) { + return item[0].lock(); + } + } + collect_records_with_result(B, B->pimpl->get_add_map(), B_components); + for (auto A_equation : A_components) { + for (auto B_equation : B_components) { + remove_same_elements(A_equation, B_equation); + if (A_equation.size() == 1 && B_equation.empty() && !A_equation[0].expired()) { + return A_equation[0].lock(); + } + } + } + shared_map = A->pimpl->get_add_map(); + } else { + // share maps (if any) between A and B + shared_map = std::make_shared(); + auto set_m_add = [](const ov::WeakSymbol& s, std::shared_ptr m) -> void { + if (!s.expired()) + s.lock()->pimpl->set_add_map(m); + }; + share_map(shared_map, A->pimpl->get_add_map(), set_m_add); + share_map(shared_map, B->pimpl->get_add_map(), set_m_add); + A->pimpl->set_add_map(shared_map); + B->pimpl->set_add_map(shared_map); + } + auto C = std::make_shared(); + C->pimpl->set_add_map(shared_map); + + std::vector B_components{{B}}; + collect_records_with_result(B, B->pimpl->get_add_map(), B_components); + for (auto& new_key : B_components) { + new_key.insert(new_key.begin(), C); + sort(new_key); + shared_map->insert({new_key, A}); + } + return C; } diff --git a/src/core/tests/symbol.cpp b/src/core/tests/symbol.cpp new file mode 100644 index 00000000000000..9303078c03f65d --- /dev/null +++ b/src/core/tests/symbol.cpp @@ -0,0 +1,71 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/core/symbol.hpp" + +#include + +#include + +TEST(shape, test_symbol_add) { + auto A = std::make_shared(); + auto B = std::make_shared(); + + ASSERT_TRUE(ov::symbol::are_equal(A + B, B + A)); + + auto C = std::make_shared(); + auto D = std::make_shared(); + + auto E = A + B; + auto F = C + D; + + ASSERT_FALSE(ov::symbol::are_equal(E, F)); + + ov::symbol::set_equal(A, C); + ov::symbol::set_equal(B, D); + + ASSERT_TRUE(ov::symbol::are_equal(E, F)); +} + +TEST(shape, test_symbol_sub) { + auto A = std::make_shared(); + auto B = std::make_shared(); + + ASSERT_FALSE(ov::symbol::are_equal(A - B, B - A)); + + auto C = std::make_shared(); + auto D = std::make_shared(); + + auto E = A - B; + auto F = C - D; + + ASSERT_FALSE(ov::symbol::are_equal(E, F)); + + ov::symbol::set_equal(A, C); + ov::symbol::set_equal(B, D); + + ASSERT_TRUE(ov::symbol::are_equal(E, F)); +} + +TEST(shape, test_symbol_add_sub) { + auto A = std::make_shared(); + auto B = std::make_shared(); + auto C = std::make_shared(); + + auto D = A + B; + auto E = D + C; // E = A + B + C + auto F = B + C; + + auto G = E - F; // G = A + B + C - B - C = A + ASSERT_TRUE(ov::symbol::are_equal(A, G)); +} + +TEST(shape, test_symbol_null) { + auto A = std::make_shared(); + std::shared_ptr B = nullptr; + ASSERT_EQ(A + B, nullptr); + ASSERT_EQ(nullptr, A + B); + ASSERT_EQ(A - B, nullptr); + ASSERT_EQ(nullptr, A - B); +} diff --git a/src/core/tests/type_prop/range.cpp b/src/core/tests/type_prop/range.cpp index c37f5987047a53..5298112fdfe3fc 100644 --- a/src/core/tests/type_prop/range.cpp +++ b/src/core/tests/type_prop/range.cpp @@ -6,6 +6,8 @@ #include "common_test_utils/type_prop.hpp" #include "openvino/op/constant.hpp" +#include "openvino/op/gather.hpp" +#include "openvino/op/shape_of.hpp" using namespace std; using namespace ov; @@ -895,3 +897,45 @@ INSTANTIATE_TEST_SUITE_P(type_prop, RangeParams{-1, 1, 0.25, PartialShape{8}}, RangeParams{-1, 0.875, 0.25, PartialShape{8}}), PrintToDummyParamName()); + +TEST(type_prop, range_symbol_start_0_stop_A_step_1) { + auto stop_symbol = std::make_shared(); + auto source_shape = PartialShape::dynamic(1); + source_shape[0].set_symbol(stop_symbol); + auto symbol_source = + make_shared(make_shared(element::i64, source_shape)); + + auto start = make_shared(element::i64, Shape{}, 0); + auto stop = make_shared(symbol_source, + make_shared(element::i64, Shape{}, 0), + make_shared(element::i64, Shape{}, 0)); + auto step = make_shared(element::i64, Shape{}, 1); + + auto range = make_shared(start, stop, step); + + ASSERT_TRUE(ov::symbol::are_equal(range->get_output_partial_shape(0)[0].get_symbol(), stop_symbol)); +} + +TEST(type_prop, range_symbol_start_A_stop_A_plus_B_step_1) { + auto start_symbol = std::make_shared(); + auto output_symbol = std::make_shared(); + auto stop_symbol = start_symbol + output_symbol; + + auto source_shape = PartialShape::dynamic(2); + source_shape[0].set_symbol(start_symbol); + source_shape[1].set_symbol(stop_symbol); + auto symbol_source = + make_shared(make_shared(element::i64, source_shape)); + + auto start = make_shared(symbol_source, + make_shared(element::i64, Shape{}, 0), + make_shared(element::i64, Shape{}, 0)); + auto stop = make_shared(symbol_source, + make_shared(element::i64, Shape{}, 1), + make_shared(element::i64, Shape{}, 0)); + auto step = make_shared(element::i64, Shape{}, 1); + + auto range = make_shared(start, stop, step); + + ASSERT_TRUE(ov::symbol::are_equal(range->get_output_partial_shape(0)[0].get_symbol(), output_symbol)); +} From 0b38dd7096c60d991a81e394a54f08b4fd972b83 Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Thu, 15 Aug 2024 22:44:21 +0400 Subject: [PATCH 023/117] Allow to keep RPATH for install tree (#26080) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --- cmake/developer_package/packaging/archive.cmake | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/cmake/developer_package/packaging/archive.cmake b/cmake/developer_package/packaging/archive.cmake index 9c14e01ca2eba8..da6c676de6c574 100644 --- a/cmake/developer_package/packaging/archive.cmake +++ b/cmake/developer_package/packaging/archive.cmake @@ -7,10 +7,14 @@ include(GNUInstallDirs) if(APPLE) # on macOS versions with SIP enabled, we need to use @rpath # because DYLD_LIBRARY_PATH is ignored - set(CMAKE_SKIP_INSTALL_RPATH OFF) + set(CMAKE_SKIP_INSTALL_RPATH_DEFAULT OFF) else() # we don't need RPATHs, because setupvars.sh is used - set(CMAKE_SKIP_INSTALL_RPATH ON) + set(CMAKE_SKIP_INSTALL_RPATH_DEFAULT ON) +endif() + +if(NOT DEFINED CMAKE_SKIP_INSTALL_RPATH) + set(CMAKE_SKIP_INSTALL_RPATH ${CMAKE_SKIP_INSTALL_RPATH_DEFAULT}) endif() # From c6ab24a6d7f39cba2dada53dd0f7cb1810290e32 Mon Sep 17 00:00:00 2001 From: Taylor Yeonbok Lee Date: Thu, 15 Aug 2024 16:23:00 -0700 Subject: [PATCH 024/117] [GPU] Relaxed condition to select strided_slice impl with gpu (#25985) ### Details: - Relaxed condition set in https://github.com/openvinotoolkit/openvino/pull/25601 - Checked with actual model which contains 128x1024 size strided_slice (baichuan 7b) - For both platform with small EU count and many EU count, using gpu impl was better ![image](https://github.com/user-attachments/assets/259e3843-f722-40e3-b001-9786e6bb7906) ### Tickets: - *ticket-id* --- .../src/graph/graph_optimizer/mark_shape_of_subgraphs.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/mark_shape_of_subgraphs.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/mark_shape_of_subgraphs.cpp index 3599e68301da29..cf0b733b6ef178 100644 --- a/src/plugins/intel_gpu/src/graph/graph_optimizer/mark_shape_of_subgraphs.cpp +++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/mark_shape_of_subgraphs.cpp @@ -82,7 +82,7 @@ bool mark_shape_of_subgraphs::can_mark_node(const program_node& node) { // Exclude stride_slice primitive if it's input is big const ternsor, else CPU reference implementation // will lead to huge performance drop. if (node.is_type() && node.get_dependency(0).is_constant() && - node.get_dependency(0).get_output_layout().count() > 1024 * 1024) { + node.get_dependency(0).get_output_layout().count() > 128 * 1024) { return false; } From 8b82aae747c984e873dc2912a7a76ad6a8d5dad3 Mon Sep 17 00:00:00 2001 From: River Li Date: Fri, 16 Aug 2024 12:12:19 +0800 Subject: [PATCH 025/117] [GPU] optimize ReduceMax pattern (#24073) ### Details - Optimize ReduceMax pattern to avoid scheduling the whole primitive executed in single EU Sometimes ReduceMax OP is used to convert 3D/4D shape tensor to a scalar output, which leads to all computation are executed in single EUs due to only one output. It causes very poor performance for some models. For example: Grounding DINO model `ReduceMax cost 59.24 ms and cosumed 49% execution time out of whole models.` To break this bottleneck, this PR applies more EUs to execute this primitive by doing ReduceMax one dimension by one dimension. We also notice that the ReduceMax OP selects ref-kernel rather than opt-kernel, which may also cause some performance issue. But it seems the ReduceMax OP doesn't need too much computation, ref-kernel should be enough. The key problem should be only one EU is scheduled to do the whole ReduceMax computation, which is the root cause of poor performace. ![image](https://github.com/openvinotoolkit/openvino/assets/31196718/561b98cc-98af-44a9-9ec2-36e5c63de797) ![image](https://github.com/openvinotoolkit/openvino/assets/31196718/d35c33f9-0714-4871-b049-354ccacd95ea) Test result shows: ReduceMax will be improved from 59.24ms to 2.25ms, fps from 8.24 to 15.55 (+88% improvement) ![image](https://github.com/openvinotoolkit/openvino/assets/31196718/4b981bc5-251c-4913-a5d1-84d5bbd5aec8) ### Tickets: - *145690* --- .../decompose_reduce_scalar_output.cpp | 111 ++++++++++++++ .../decompose_reduce_scalar_output.hpp | 23 +++ .../src/plugin/transformations_pipeline.cpp | 2 + .../decompose_reduce_scalar_output_test.cpp | 140 ++++++++++++++++++ 4 files changed, 276 insertions(+) create mode 100644 src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp create mode 100644 src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.hpp create mode 100644 src/plugins/intel_gpu/tests/unit/transformations/decompose_reduce_scalar_output_test.cpp diff --git a/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp new file mode 100644 index 00000000000000..7bca11f9143393 --- /dev/null +++ b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp @@ -0,0 +1,111 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "decompose_reduce_scalar_output.hpp" + +#include +#include +#include + +#include "openvino/core/node.hpp" +#include "openvino/core/rt_info.hpp" +#include "openvino/op/constant.hpp" +#include "openvino/op/reduce_max.hpp" +#include "openvino/op/reduce_min.hpp" +#include "openvino/op/reduce_prod.hpp" +#include "openvino/op/reduce_sum.hpp" +#include "openvino/pass/pattern/op/wrap_type.hpp" +#include "transformations/utils/utils.hpp" + +#define CREATE_REDUCE(input, reduce_const, keep_dims) \ + if (ov::is_type(reduce_orig)) \ + reduce_new = std::make_shared(input, reduce_const, keep_dims); \ + else if (ov::is_type(reduce_orig)) \ + reduce_new = std::make_shared(input, reduce_const, keep_dims); \ + else if (ov::is_type(reduce_orig)) \ + reduce_new = std::make_shared(input, reduce_const, keep_dims); \ + else if (ov::is_type(reduce_orig)) \ + reduce_new = std::make_shared(input, reduce_const, keep_dims); \ + else \ + return false; + +ov::intel_gpu::DecomposeReduceForScalarOutput::DecomposeReduceForScalarOutput() { + auto check_reduce_shape = [=](Output output) -> bool { + const auto reduce = ov::as_type_ptr(output.get_node_shared_ptr()); + const auto input_shape = reduce->input_value(0).get_partial_shape(); + const auto reduce_shape = reduce->input_value(1).get_partial_shape(); + if (reduce_shape.is_dynamic() || reduce_shape.size() != 1) { + return false; + } else if (reduce_shape.to_shape()[0] <= 1 || reduce_shape.to_shape()[0] != input_shape.size()) { + return false; + } + const auto output_shape = reduce->get_output_partial_shape(0); + if (output_shape.is_static() && input_shape.is_static()) { + // Output size decides at most how many EU threads can be used for this node execution, + // less than 4 EU threads to execute a primitive will lead to poor performance. + if (ov::shape_size(output_shape.to_shape()) > 4) { + return false; + } + // Input shape is too small, 1 EU thread should be enough. + const auto input_static_shape = input_shape.to_shape(); + if (ov::shape_size(input_static_shape) < 64) { + return false; + } + } + return true; + }; + + auto reduce_pattern = ov::pass::pattern:: + wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + check_reduce_shape); + + // register callback + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { + const auto& pattern_map = m.get_pattern_value_map(); + auto reduce_orig = + as_type_ptr(pattern_map.at(reduce_pattern).get_node_shared_ptr()); + if (!reduce_orig || transformation_callback(reduce_orig)) + return false; + + const auto input_shape = reduce_orig->input_value(0).get_partial_shape(); + const auto output_shape = reduce_orig->get_output_partial_shape(0); + bool dynamic_shape = input_shape.is_dynamic() || output_shape.is_dynamic(); + std::shared_ptr reduce_new = nullptr; + if (!dynamic_shape) { + // Find out the the most length dimension + const auto input_static_shape = input_shape.to_shape(); + size_t max_dim = std::distance(input_static_shape.begin(), + std::max_element(input_static_shape.begin(), input_static_shape.end())); + if (input_static_shape[max_dim] == ov::shape_size(input_static_shape)) { + return false; + } + CREATE_REDUCE(reduce_orig->input_value(0), + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {max_dim}), + true); + + } else if (input_shape.rank().is_static()) { + // Dynamic shape and output shape is [0], which will lead to 1 EU thread to do all work. + auto input = reduce_orig->input_value(0); + for (size_t i = input_shape.size() - 1; i > 0; i--) { + // Reduce one dimension by one dimension to avoid 1 EU thread do all work. + if (input_shape[i].is_dynamic() || (input_shape[i].is_static() && input_shape[i].get_length() >= 4)) { + CREATE_REDUCE(input, ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {i}), true); + input = reduce_new->get_default_output(); + } + } + } + if (!reduce_new) + return false; + + CREATE_REDUCE(reduce_new->get_default_output(), reduce_orig->input_value(1), reduce_orig->get_keep_dims()); + reduce_new->set_friendly_name(reduce_orig->get_friendly_name()); + copy_runtime_info(reduce_orig, reduce_new); + replace_node(reduce_orig, reduce_new); + return true; + }; + + auto m = std::make_shared(reduce_pattern, "DecomposeReduceForScalarOutput"); + register_matcher(m, callback); +} diff --git a/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.hpp b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.hpp new file mode 100644 index 00000000000000..cb5db2b715c333 --- /dev/null +++ b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.hpp @@ -0,0 +1,23 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "openvino/core/visibility.hpp" +#include "openvino/pass/graph_rewrite.hpp" + +namespace ov { +namespace intel_gpu { + +// In some case, Reduce OP is used to reduce one 2D/3D/4D/5D tensor to a scalar output, which leads to all computation +// are executed in single EU thread due to only one output, then fall in very poor performance. This pattern is used to +// detect this case and decompose Reduce by dimension to avoid poor performance. +class DecomposeReduceForScalarOutput : public ov::pass::MatcherPass { +public: + OPENVINO_RTTI("DecomposeReduceForScalarOutput", "0"); + DecomposeReduceForScalarOutput(); +}; + +} // namespace intel_gpu +} // namespace ov diff --git a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp index 54f5fe5b9360e4..f5cb6783d4b080 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp @@ -58,6 +58,7 @@ #include "plugin/transformations/convert_fc_to_compressed.hpp" #include "plugin/transformations/convert_matmul_to_fc.hpp" #include "plugin/transformations/convert_stridedslices_to_variadicsplit.hpp" +#include "plugin/transformations/decompose_reduce_scalar_output.hpp" #include "plugin/transformations/fc_convert_fusion.hpp" #include "plugin/transformations/fc_horizontal_fusion.hpp" #include "plugin/transformations/kv_cache_fusion.hpp" @@ -408,6 +409,7 @@ void TransformationsPipeline::apply(std::shared_ptr func) { manager.register_pass(); manager.register_pass(); manager.register_pass(); + manager.register_pass(); precisions_map int_convert_precision_map { {ov::element::i64, ov::element::i32}, diff --git a/src/plugins/intel_gpu/tests/unit/transformations/decompose_reduce_scalar_output_test.cpp b/src/plugins/intel_gpu/tests/unit/transformations/decompose_reduce_scalar_output_test.cpp new file mode 100644 index 00000000000000..7f35e39834aacc --- /dev/null +++ b/src/plugins/intel_gpu/tests/unit/transformations/decompose_reduce_scalar_output_test.cpp @@ -0,0 +1,140 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "common_test_utils/ov_test_utils.hpp" +#include "intel_gpu/primitives/reduce.hpp" + +using namespace testing; +using namespace ov::intel_gpu; +using namespace ov; + +template +std::shared_ptr build_model(const ov::PartialShape& input_shape, + const ov::element::Type& input_type, + const std::vector& reduction_axes, + const bool keep_dim) { + const auto in = std::make_shared(input_type, input_shape); + auto reduce = std::make_shared( + in->get_default_output(), + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{reduction_axes.size()}, reduction_axes), + keep_dim); + return std::make_shared(ov::NodeVector{reduce}, ov::ParameterVector{in}); +} + +#define decompose_reduce_static_shape(reduce_type) \ + const ov::PartialShape in_shape = {1, 256, 1024, 10}; \ + const ov::element::Type in_type = ov::element::Type_t::f16; \ + const std::vector reduction_axes = {0, 1, 2, 3}; \ + disable_rt_info_check(); \ + { \ + model = build_model(in_shape, in_type, reduction_axes, false); \ + manager.register_pass(); \ + } \ + { \ + const auto in = std::make_shared(in_type, in_shape); \ + auto reduce = std::make_shared(in->get_default_output(), \ + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {2}), \ + true); \ + reduce = std::make_shared( \ + reduce->get_default_output(), \ + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{reduction_axes.size()}, reduction_axes), \ + false); \ + model_ref = std::make_shared(ov::NodeVector{reduce}, ov::ParameterVector{in}); \ + } + +// Static shape reduce to scalar output, decompose reduce. +TEST_F(TransformationTestsF, DecomposeReduceMaxTest_static_shape){decompose_reduce_static_shape(ov::op::v1::ReduceMax)} + +TEST_F(TransformationTestsF, DecomposeReduceMinTest_static_shape){decompose_reduce_static_shape(ov::op::v1::ReduceMin)} + +TEST_F(TransformationTestsF, DecomposeReduceSumTest_static_shape){decompose_reduce_static_shape(ov::op::v1::ReduceSum)} + +TEST_F(TransformationTestsF, + DecomposeReduceProbTest_static_shape){decompose_reduce_static_shape(ov::op::v1::ReduceProd)} + +// Static shape with small input, don't decompose reduce. +TEST_F(TransformationTestsF, DecomposeReduceMaxTest_static_shape_small_input_skip) { + const ov::PartialShape in_shape = {1, 2, 8, 2}; + const ov::element::Type in_type = ov::element::Type_t::f16; + const std::vector reduction_axes = {0, 1, 2, 3}; + { + model = build_model(in_shape, in_type, reduction_axes, true); + manager.register_pass(); + } + { model_ref = build_model(in_shape, in_type, reduction_axes, true); } +} + +// Static shape reduce to non scalar output, don't decompose reduce. +TEST_F(TransformationTestsF, DecomposeReduceMaxTest_static_shape_skip) { + const ov::PartialShape in_shape = {256, 1024, 10}; + const ov::element::Type in_type = ov::element::Type_t::f16; + const std::vector reduction_axes = {1}; + { + model = build_model(in_shape, in_type, reduction_axes, true); + manager.register_pass(); + } + { model_ref = build_model(in_shape, in_type, reduction_axes, true); } +} + +// Dynamic shape reduce to scalar output, decompose reduce. +#define decompose_reduce_dynamic_shape(reduce_type) \ + const ov::PartialShape in_shape = {4, -1, -1, 10}; \ + const ov::element::Type in_type = ov::element::Type_t::f16; \ + const std::vector reduction_axes = {0, 1, 2, 3}; \ + disable_rt_info_check(); \ + { \ + model = build_model(in_shape, in_type, reduction_axes, false); \ + manager.register_pass(); \ + } \ + { \ + const auto in = std::make_shared(in_type, in_shape); \ + auto reduce = std::make_shared(in->get_default_output(), \ + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {3}), \ + true); \ + reduce = std::make_shared(reduce->get_default_output(), \ + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {2}), \ + true); \ + reduce = std::make_shared(reduce->get_default_output(), \ + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {1}), \ + true); \ + reduce = std::make_shared( \ + reduce->get_default_output(), \ + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{reduction_axes.size()}, reduction_axes), \ + false); \ + model_ref = std::make_shared(ov::NodeVector{reduce}, ov::ParameterVector{in}); \ + } + +TEST_F(TransformationTestsF, + DecomposeReduceMaxTest_dynamic_shape){decompose_reduce_dynamic_shape(ov::op::v1::ReduceMax)} + +TEST_F(TransformationTestsF, + DecomposeReduceMinTest_dynamic_shape){decompose_reduce_dynamic_shape(ov::op::v1::ReduceMin)} + +TEST_F(TransformationTestsF, + DecomposeReduceSumTest_dynamic_shape){decompose_reduce_dynamic_shape(ov::op::v1::ReduceSum)} + +TEST_F(TransformationTestsF, + DecomposeReduceProbTest_dynamic_shape){decompose_reduce_dynamic_shape(ov::op::v1::ReduceProd)} + +// Dynamic shape reduce to non-scalar output, don't decompose reduce. +TEST_F(TransformationTestsF, DecomposeReduceMaxTest_dynamic_shape_skip) { + const ov::PartialShape in_shape = {4, -1, -1, 10}; + const ov::element::Type in_type = ov::element::Type_t::f16; + const std::vector reduction_axes = {2}; + { + model = build_model(in_shape, in_type, reduction_axes, false); + manager.register_pass(); + } + { model_ref = build_model(in_shape, in_type, reduction_axes, false); } +} \ No newline at end of file From 09f1f9119989a37b243de99a163588ccbcf1569b Mon Sep 17 00:00:00 2001 From: Roman Lyamin Date: Fri, 16 Aug 2024 08:59:03 +0400 Subject: [PATCH 026/117] [GPU] Fixed axes normalization for squeeze (#26082) ### Tickets: - *[149721](https://jira.devtools.intel.com/browse/CVS-149721)* --- src/plugins/intel_gpu/src/plugin/ops/reshape.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/plugins/intel_gpu/src/plugin/ops/reshape.cpp b/src/plugins/intel_gpu/src/plugin/ops/reshape.cpp index a95e00725736e6..7e98d79583cc07 100644 --- a/src/plugins/intel_gpu/src/plugin/ops/reshape.cpp +++ b/src/plugins/intel_gpu/src/plugin/ops/reshape.cpp @@ -31,8 +31,10 @@ static void CreateCommonReshapeOp(ProgramBuilder& p, const std::shared_ptr output_pattern = {}; if (second_const_input != nullptr) { output_pattern = second_const_input->cast_vector(); - if (mode == cldnn::reshape::reshape_mode::unsqueeze || mode == cldnn::reshape::reshape_mode::squeeze) { + if (mode == cldnn::reshape::reshape_mode::unsqueeze) { ov::util::try_normalize_axes(output_pattern, op->get_output_partial_shape(0).rank(), *op); + } else if (mode == cldnn::reshape::reshape_mode::squeeze) { + ov::util::try_normalize_axes(output_pattern, op->get_input_partial_shape(0).rank(), *op); } } From d3f8efa86b3ae305b9dd2c69d763af00f8d1fdf6 Mon Sep 17 00:00:00 2001 From: Nesterov Alexander Date: Fri, 16 Aug 2024 07:22:13 +0200 Subject: [PATCH 027/117] [ARM][CPU] Fix ACL FC executor post ops check on ARM32 (#26065) ### Tickets: - CVS-149013 --- .../executors/acl/acl_fullyconnected.cpp | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_fullyconnected.cpp index 99acb9070550dc..6f464abf33d036 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_fullyconnected.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_fullyconnected.cpp @@ -156,12 +156,15 @@ static MemoryPtr prepareWeightMemory(const MemoryArgs &memory, } static bool checkPostOps(const PostOps &postOps) { - // Add postops - if (!postOps.empty() && postOps.size() == 1) { - if (const auto activation = std::dynamic_pointer_cast(postOps[0])) { - if (checkActivationLayerInfo(convertToEltwiseAlgorithm(activation->type()))) { - return true; - } + if (postOps.empty()) { + return true; + } + if (postOps.size() > 1) { + return false; + } + if (const auto activation = std::dynamic_pointer_cast(postOps[0])) { + if (checkActivationLayerInfo(convertToEltwiseAlgorithm(activation->type()))) { + return true; } } return false; @@ -179,7 +182,7 @@ static void initFCAttrs(const FCAttrs &attrs, fullyConnectedLayerInfo.transpose_weights = false; aclfcAttrs.weightsNonTransposed = attrs.weightsNonTransposed; - if (checkPostOps(postOps)) { + if (!postOps.empty() && checkPostOps(postOps)) { auto activation = std::dynamic_pointer_cast(postOps[0]); fullyConnectedLayerInfo.activation_info = getActivationLayerInfo( convertToEltwiseAlgorithm(activation->type()), @@ -203,10 +206,7 @@ bool ACLFullyConnectedExecutor::supports(const FCConfig &config) { VERIFY(one_of(srcType(config), ov::element::f16, ov::element::f32), UNSUPPORTED_SRC_PRECISIONS); VERIFY(one_of(weiType(config), ov::element::f16, ov::element::f32), UNSUPPORTED_WEI_PRECISIONS); VERIFY(postOpsNumbers(config) < 2, UNSUPPORTED_NUMBER_OF_POSTOPS); - // This define is set because on ARM32 devices postOps in the function is empty (CVS-149013) -#ifndef OPENVINO_ARCH_ARM VERIFY(checkPostOps(config.postOps), UNSUPPORTED_TYPE_OF_POSTOPS); -#endif VERIFY(one_of(srcRank(config), 2U, 3U, 4U), UNSUPPORTED_SRC_RANK); VERIFY(one_of(weiRank(config), 2U, 3U), UNSUPPORTED_WEI_RANK); return true; From e7e6d8bcc7e2761ef4f125afa040bcd0cb02b858 Mon Sep 17 00:00:00 2001 From: Egor Duplenskii Date: Fri, 16 Aug 2024 07:25:45 +0200 Subject: [PATCH 028/117] [CPU][DOC][DEBUG_CAPS] Add examples right into a readme file (#26073) To have a kind of cheat sheet in a single place --- .../docs/debug_capabilities/README.md | 26 ++++++++++++------- .../debug_capabilities/graph_serialization.md | 2 +- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/src/plugins/intel_cpu/docs/debug_capabilities/README.md b/src/plugins/intel_cpu/docs/debug_capabilities/README.md index 40c1a626685982..f7989217be4a7f 100644 --- a/src/plugins/intel_cpu/docs/debug_capabilities/README.md +++ b/src/plugins/intel_cpu/docs/debug_capabilities/README.md @@ -7,12 +7,20 @@ Use the following cmake option to enable debug capabilities: `-DENABLE_DEBUG_CAPS=ON` -* [Verbose mode](verbose.md) -* [Blob dumping](blob_dumping.md) -* [Graph serialization](graph_serialization.md) -* [Graph transformation disabling](feature_disabling.md#graph-transformations) -* [Logging](logging.md) -* [Inference Precision](infer_prc.md) -* Performance summary - * set `OV_CPU_SUMMARY_PERF` environment variable to display performance summary at the time when model is being destructed. - * Internal performance counter will be enabled automatically. +* [Verbose mode](verbose.md) + `OV_CPU_VERBOSE=1` +* [Blob dumping](blob_dumping.md) + `OV_CPU_BLOB_DUMP_NODE_NAME="*" OV_CPU_BLOB_DUMP_DIR=blob_dump` +* [Graph serialization](graph_serialization.md) + `OV_CPU_EXEC_GRAPH_PATH=graph.xml` + `OV_CPU_DUMP_IR="transformations dir=path/dumpdir formats=svg,xml,dot"` +* [Graph transformation disabling](feature_disabling.md#graph-transformations) + `OV_CPU_DISABLE="transformations=common,preLpt,lpt,postLpt,snippets,specific"` +* [Logging](logging.md) + `OV_CPU_DEBUG_LOG=-` +* [Inference Precision](infer_prc.md) + `OV_CPU_INFER_PRC_POS_PATTERN="^FullyConnected@"` +* Performance summary + `OV_CPU_SUMMARY_PERF=1` + Set the environment variable to display performance summary at the time when model is being destructed. + Internal performance counter will be enabled automatically. diff --git a/src/plugins/intel_cpu/docs/debug_capabilities/graph_serialization.md b/src/plugins/intel_cpu/docs/debug_capabilities/graph_serialization.md index af0947419f7e4c..601a25f3f1e53c 100644 --- a/src/plugins/intel_cpu/docs/debug_capabilities/graph_serialization.md +++ b/src/plugins/intel_cpu/docs/debug_capabilities/graph_serialization.md @@ -27,7 +27,7 @@ Examples: ```sh OV_CPU_DUMP_IR="transformations" binary ... OV_CPU_DUMP_IR="transformations=snippets dir=path/dumpDir" binary ... - OV_CPU_DUMP_IR="transformations=all,-common DIR=path/dumpdir formats=svg,xml" binary ... + OV_CPU_DUMP_IR="transformations=all,-common dir=path/dumpdir formats=svg,xml" binary ... ``` Option names are case insensitive, the following options are supported: From 8713ca2475adc138f2ce0b0de28fa1d1ceea04ef Mon Sep 17 00:00:00 2001 From: Egor Duplenskii Date: Fri, 16 Aug 2024 07:52:42 +0200 Subject: [PATCH 029/117] [CPU] Fix resolve edge conflicts Convert insertion (#25643) ### Details - Current version does not clean extra edge in case Convert + Reorder is inserted. In this case we need to remove an edge, which is replaced with Convert node first, and then remove childEdge of the newly inserted Convert node, after Reorder is inserted. - The idea is to simplify this logic and do one thing at a time: 1. Insert Convert. 2. If Reorder is still necessary for the new inserted edge, it will be handled later in the loop. It seems to be impossible to write a test for x86 platform, since there is no reorder which does not support precision conversion. --- src/plugins/intel_cpu/src/graph.cpp | 94 +++++++++++++++-------------- src/plugins/intel_cpu/src/graph.h | 1 + 2 files changed, 50 insertions(+), 45 deletions(-) diff --git a/src/plugins/intel_cpu/src/graph.cpp b/src/plugins/intel_cpu/src/graph.cpp index 66be31c858cc76..bfb28f769b95e7 100644 --- a/src/plugins/intel_cpu/src/graph.cpp +++ b/src/plugins/intel_cpu/src/graph.cpp @@ -5,6 +5,7 @@ #include "graph.h" #include +#include #include #include #include @@ -557,59 +558,65 @@ void Graph::insertReorder(EdgePtr& edge, bool isOptimized, std::unordered_setgetInputDesc(), edge->getOutputDesc(), isOptimized); } -void Graph::ResolveEdgeConflicts() { - OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::ResolveEdgeConflicts"); +void Graph::insertConvert(EdgePtr& edge) { + const auto& inDesc = edge->getInputDesc(); + const auto& outDesc = edge->getOutputDesc(); - ptrdiff_t numberOfEdges = static_cast(graphEdges.size()); + std::string convertName = edge->getParent()->getName() + "_" + + inDesc.getPrecision().get_type_name() + "_" + outDesc.getPrecision().get_type_name(); + auto convertNode = std::make_shared(inDesc.getShape(), inDesc.getPrecision(), outDesc.getPrecision(), + convertName, context); + convertNode->setDescs(inDesc, outDesc); + InsertNode(edge, convertNode, true); +} + +static std::unordered_set getUniqueLayerNames(const std::vector& graphNodes) { std::unordered_set uniqueLayerNames; + uniqueLayerNames.reserve(graphNodes.size()); + for (auto node : graphNodes) { uniqueLayerNames.insert(node->getName()); } - auto updateEdge = [&](ptrdiff_t& i) { - graphEdges.erase(graphEdges.begin() + i); - i--; - numberOfEdges--; - }; + return uniqueLayerNames; +} - for (ptrdiff_t i = 0; i < numberOfEdges; i++) { - auto edge = graphEdges[i]; - auto reorderStatus = graphEdges[i]->needReorder(); - DEBUG_LOG(graphEdges[i]->name(), " reorderStatus = ", reorderStatus); - if (reorderStatus == Edge::ReorderStatus::Regular) { - Edge::ReorderStatus reorderStatusInternal = Edge::ReorderStatus::Regular; - // Check if there is a reorder that needs the precision conversion - if (edge->getInputDesc().getPrecision() != edge->getOutputDesc().getPrecision() && - !isReorderAvailable(edge->getInputPortDesc()->getMemDesc(), - edge->getOutputPortDesc()->getMemDesc(), - this->getEngine())) { - // If we are here, then we need to insert Convert, because there are no reorders that support such type conversion - const auto& inDesc = edge->getInputDesc(); - const auto& outDesc = edge->getOutputDesc(); - - std::string convertName = edge->getParent()->getName() + "_" + - inDesc.getPrecision().get_type_name() + "_" + outDesc.getPrecision().get_type_name(); - - auto convertNode = std::make_shared(inDesc.getShape(), inDesc.getPrecision(), outDesc.getPrecision(), - convertName, context); - convertNode->setDescs(inDesc, outDesc); - InsertNode(edge, convertNode, true); - - //Check if reorder is still needed - reorderStatusInternal = convertNode->getChildEdgeAt(0)->needReorder(); - if (reorderStatusInternal != Edge::ReorderStatus::No) - edge = convertNode->getChildEdgeAt(0); - } - if (reorderStatusInternal != Edge::ReorderStatus::No) { - insertReorder(edge, reorderStatusInternal == Edge::ReorderStatus::Optimized, uniqueLayerNames); +void Graph::ResolveEdgeConflicts() { + OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::ResolveEdgeConflicts"); + + std::unordered_set uniqueLayerNames = getUniqueLayerNames(graphNodes); + + /* When inserting convert / reorder, two new edges are added (pushed to the end) to the graphEdges. + So use a plain for loop, to handle newly inserted edges as well */ + for (size_t i = 0; i < graphEdges.size(); i++) { + auto& edge = graphEdges[i]; + auto reorderStatus = edge->needReorder(); + DEBUG_LOG(*edge, " reorderStatus = ", reorderStatus); + + switch (reorderStatus) { + case Edge::ReorderStatus::Regular: { + if (reorderStatus == Edge::ReorderStatus::Regular && + edge->getInputDesc().getPrecision() != edge->getOutputDesc().getPrecision() && + !isReorderAvailable(edge->getInputPortDesc()->getMemDesc(), + edge->getOutputPortDesc()->getMemDesc(), + this->getEngine())) { + // just insert convert. If layout reorder is still needed, it will be inserted later in the traverse + insertConvert(edge); + } else { + insertReorder(edge, false, uniqueLayerNames); } - updateEdge(i); - } else if (reorderStatus == Edge::ReorderStatus::Optimized) { + break; + } + case Edge::ReorderStatus::Optimized: insertReorder(edge, true, uniqueLayerNames); - updateEdge(i); + break; + case Edge::ReorderStatus::No: + break; } } + + RemoveDroppedEdges(); } void Graph::ResolveComplexInplaceConflicts() { @@ -617,10 +624,7 @@ void Graph::ResolveComplexInplaceConflicts() { ptrdiff_t numberOfEdges = static_cast(graphEdges.size()); - std::unordered_set uniqueLayerNames; - for (auto node : graphNodes) { - uniqueLayerNames.insert(node->getName()); - } + std::unordered_set uniqueLayerNames = getUniqueLayerNames(graphNodes); auto updateEdge = [&](ptrdiff_t& i) { graphEdges.erase(graphEdges.begin() + i); diff --git a/src/plugins/intel_cpu/src/graph.h b/src/plugins/intel_cpu/src/graph.h index 4e6d6e6f3beca6..6816dcc75c1a67 100644 --- a/src/plugins/intel_cpu/src/graph.h +++ b/src/plugins/intel_cpu/src/graph.h @@ -258,6 +258,7 @@ class Graph { void EnforceInferencePrecision(); void EnforceBF16(); void insertReorder(EdgePtr& edge, bool isOptimized, std::unordered_set& uniqueLayerNames); + void insertConvert(EdgePtr& edge); }; using GraphPtr = std::shared_ptr; From 6f297800624f0e3ae5e7e6e440b1445be88a745c Mon Sep 17 00:00:00 2001 From: Andrei Kashchikhin Date: Fri, 16 Aug 2024 15:23:41 +0100 Subject: [PATCH 030/117] [CI] [GHA] Add check for `FASTER_BUILD=ON` on Windows (#26088) ### Tickets: - *149827* --- .github/workflows/windows_conditional_compilation.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/windows_conditional_compilation.yml b/.github/workflows/windows_conditional_compilation.yml index 641ee2289c8532..b94da30fdf95a3 100644 --- a/.github/workflows/windows_conditional_compilation.yml +++ b/.github/workflows/windows_conditional_compilation.yml @@ -169,6 +169,7 @@ jobs: -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ` -DENABLE_PROFILING_ITT=ON ` -DSELECTIVE_BUILD=COLLECT ` + -DENABLE_FASTER_BUILD=ON ` -DCMAKE_DISABLE_FIND_PACKAGE_PkgConfig=ON ` -DCMAKE_TOOLCHAIN_FILE=${{ env.ONECORE_TOOLCHAIN }} ` -S ${{ env.OPENVINO_REPO }} ` From 2b6bcf182dda006b626931c05d8a8289cbaae610 Mon Sep 17 00:00:00 2001 From: Evgeny Kotov Date: Fri, 16 Aug 2024 17:01:45 +0200 Subject: [PATCH 031/117] Rope testing in pre-commit (#25943) ### Details: - add precommit tests to check if RoPE fusion works ### Tickets: - 146982 --------- Co-authored-by: Ivan Tikhonov --- .../workflows/job_pytorch_models_tests.yml | 9 ++ .../models_hub_common/utils.py | 60 +++++++----- .../models/transformations-models-precommit | 27 +++++ .../test_transformations.py | 98 +++++++++++++++++++ 4 files changed, 167 insertions(+), 27 deletions(-) create mode 100644 tests/model_hub_tests/transformation_tests/models/transformations-models-precommit create mode 100644 tests/model_hub_tests/transformation_tests/test_transformations.py diff --git a/.github/workflows/job_pytorch_models_tests.yml b/.github/workflows/job_pytorch_models_tests.yml index 381b0a51eb49df..43e1d46319b089 100644 --- a/.github/workflows/job_pytorch_models_tests.yml +++ b/.github/workflows/job_pytorch_models_tests.yml @@ -160,6 +160,15 @@ jobs: TEST_DEVICE: CPU USE_SYSTEM_CACHE: False + - name: RoPE Test + if: ${{ inputs.model_scope == 'precommit' }} + run: | + export PYTHONPATH=${MODEL_HUB_TESTS_INSTALL_DIR}:$PYTHONPATH + python3 -m pytest ${MODEL_HUB_TESTS_INSTALL_DIR}/transformation_tests/test_transformations.py -m precommit --html=${INSTALL_TEST_DIR}/TEST-torch_rope_tests.html --self-contained-html -v --tb=short -n 2 + env: + TEST_DEVICE: CPU + USE_SYSTEM_CACHE: False + - name: StatefulToStateless Test if: ${{ inputs.model_scope == 'precommit' }} run: | diff --git a/tests/model_hub_tests/models_hub_common/utils.py b/tests/model_hub_tests/models_hub_common/utils.py index b014c8dc64c2d8..428802c58463fc 100644 --- a/tests/model_hub_tests/models_hub_common/utils.py +++ b/tests/model_hub_tests/models_hub_common/utils.py @@ -11,39 +11,45 @@ from models_hub_common.constants import test_device -def get_models_list(file_name: str): - models = [] - with open(file_name) as f: - for model_info in f: +def parse_list_file(file_name: str): + with open(file_name, 'r') as f_in: + for model_info in f_in: + if not model_info: + continue model_info = model_info.strip() # skip comment in model scope file - if model_info.startswith('#'): + if not model_info or model_info.startswith('#'): continue - mark = None - reason = None - assert len(model_info.split(',')) == 2 or len(model_info.split(',')) == 4, \ - "Incorrect model info `{}`. It must contain either 2 or 4 fields.".format(model_info) - if len(model_info.split(',')) == 2: - model_name, model_link = model_info.split(',') - elif len(model_info.split(',')) == 4: - model_name, model_link, mark, reason = model_info.split(',') - models.append((model_name, model_link, mark, reason)) + yield model_info.split(',') - return models +def get_models_list(file_name: str): + models = [] + for line_items in parse_list_file(file_name): + if len(line_items) == 2: + model_name, model_link = line_items + models.append((model_name, model_link, None, None)) + elif len(line_items) == 4: + model_name, model_link, mark, reason = line_items + models.append((model_name, model_link, mark, reason)) + elif len(line_items) > 4: + model_name, model_link, mark, reason = line_items[:4] + if not mark: + mark = None + if not reason: + reason = None + other = line_items[4:] + transformations = [item[8:] for item in other if item.startswith('ts_name:')] + layers = [item[6:] for item in other if item.startswith('layer:')] + models.append((model_name, model_link, mark, reason, transformations, layers)) + else: + items = ','.join(line_items) + assert False, \ + f'Incorrect model info fields {items}. It must contain either 2 or 4 or more than 4 fields.' + return models -def get_skipped_model_links(filename: str): - links = set() - if not os.path.exists(filename): - return links - with open(filename) as f: - for model_info in f: - model_info = model_info.strip() - if not model_info: - continue - model_name, model_link = model_info.split(',') - links.add(model_link) - return links +def get_skipped_model_links(file_name: str): + return {line_items[1] for line_items in parse_list_file(file_name)} def get_models_list_not_skipped(model_list_file: str, skip_list_file: str): diff --git a/tests/model_hub_tests/transformation_tests/models/transformations-models-precommit b/tests/model_hub_tests/transformation_tests/models/transformations-models-precommit new file mode 100644 index 00000000000000..b3068ffbb52840 --- /dev/null +++ b/tests/model_hub_tests/transformation_tests/models/transformations-models-precommit @@ -0,0 +1,27 @@ +hf-internal-testing/tiny-random-LlamaForCausalLM,https://huggingface.co/trl-internal-testing/tiny-random-LlamaForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-GPTJForCausalLM,https://huggingface.co/trl-internal-testing/tiny-random-GPTJForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-GPTNeoXForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-GPTNeoXForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-MistralForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-MistralForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-CodeGenForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-CodeGenForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/Mixtral-tiny,https://huggingface.co/hf-internal-testing/Mixtral-tiny,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-Starcoder2ForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-Starcoder2ForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-PhiForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-PhiForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-StableLmForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-StableLmForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-PersimmonForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-PersimmonForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +hf-internal-testing/tiny-random-FalconForCausalLM,https://huggingface.co/hf-internal-testing/tiny-random-FalconForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-xverse,https://huggingface.co/katuni4ka/tiny-random-xverse,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-qwen,https://huggingface.co/katuni4ka/tiny-random-qwen,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-aquilachat,https://huggingface.co/katuni4ka/tiny-random-aquilachat,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-aquila2,https://huggingface.co/katuni4ka/tiny-random-aquila2,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-qwen1.5-moe,https://huggingface.co/katuni4ka/tiny-random-qwen1.5-moe,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-olmo-hf,https://huggingface.co/katuni4ka/tiny-random-olmo-hf,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-baichuan2,https://huggingface.co/katuni4ka/tiny-random-baichuan2,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-internlm,https://huggingface.co/katuni4ka/tiny-random-internlm,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-internlm2,https://huggingface.co/katuni4ka/tiny-random-internlm2,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-minicpm,https://huggingface.co/katuni4ka/tiny-random-minicpm,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-falcon-40b,https://huggingface.co/katuni4ka/tiny-random-falcon-40b,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +katuni4ka/tiny-random-dbrx,https://huggingface.co/katuni4ka/tiny-random-dbrx,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +fxmarty/tiny-random-GemmaForCausalLM,https://huggingface.co/fxmarty/tiny-random-GemmaForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +fxmarty/tiny-dummy-qwen2,https://huggingface.co/fxmarty/tiny-dummy-qwen2,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +fxmarty/really-tiny-falcon-testing,https://huggingface.co/fxmarty/really-tiny-falcon-testing,,,ts_name:ov::pass::RoPEFusion,layer:RoPE +Xenova/tiny-random-Phi3ForCausalLM,https://huggingface.co/Xenova/tiny-random-Phi3ForCausalLM,,,ts_name:ov::pass::RoPEFusion,layer:RoPE diff --git a/tests/model_hub_tests/transformation_tests/test_transformations.py b/tests/model_hub_tests/transformation_tests/test_transformations.py new file mode 100644 index 00000000000000..235fb2cf10b6f3 --- /dev/null +++ b/tests/model_hub_tests/transformation_tests/test_transformations.py @@ -0,0 +1,98 @@ +# Copyright (C) 2018-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + + +from optimum.intel import OVModelForCausalLM +import models_hub_common.utils as utils +import pytest +import os +import openvino as ov +import tempfile +from collections import deque +import csv + + +def parse_transformations_log(file_name): + with open(file_name, 'r') as f_in: + csv_reader = csv.reader(f_in, delimiter=';') + for line in csv_reader: + if line[0] != 't': + continue + ts_name = line[1] + status = line[4] + yield ts_name, status + + +def check_transformations(file_name, ts_names): + not_executed = deque(ts_names) + false_executed = set() + for ts_name, status in parse_transformations_log(file_name): + if not not_executed and not false_executed: + break + for _ in range(len(not_executed)): + not_executed_name = not_executed.popleft() + if not_executed_name == ts_name: + if status != '1': + false_executed.add(not_executed_name) + break + not_executed.append(not_executed_name) + if ts_name in false_executed and status == '1': + false_executed.remove(ts_name) + if not_executed or false_executed: + fail_text = '' + if not_executed: + not_executed_names = ','.join(not_executed) + fail_text = f'transformation(s) {not_executed_names} not executed' + if false_executed: + false_executed_names = ','.join(false_executed) + if bool(fail_text): + fail_text += '; ' + fail_text += f'transformation(s) {false_executed_names} executed with false return' + pytest.fail(fail_text) + + +def check_operations(actual_layer_types, expected_layer_types): + not_found = [layer for layer in expected_layer_types if layer not in actual_layer_types] + if not_found: + names = ','.join(not_found) + pytest.fail(f'operation(s) {names} not found in compiled model') + + +class EnvVar: + def __init__(self, env_vars): + self.__vars = env_vars + + def __enter__(self): + for name, value in self.__vars.items(): + os.environ[name] = value + + def __exit__(self, exc_type, exc_val, exc_tb): + for name in self.__vars: + del os.environ[name] + + +def run_test(model_id, ie_device, ts_names, expected_layer_types): + model = OVModelForCausalLM.from_pretrained(model_id, export=True, trust_remote_code=True) + + with tempfile.NamedTemporaryFile(delete=True) as temp_file, \ + EnvVar({'OV_ENABLE_PROFILE_PASS': temp_file.name}): + core = ov.Core() + compiled = core.compile_model(model.model, ie_device) + check_transformations(temp_file.name, ts_names) + ov_model = compiled.get_runtime_model() + type_names = {op.get_rt_info()["layerType"] for op in ov_model.get_ordered_ops()} + check_operations(type_names, expected_layer_types) + + +@pytest.mark.precommit +@pytest.mark.parametrize("model_name, model_link, mark, reason, ts_names, layer_types", utils.get_models_list(os.path.join(os.path.dirname(__file__), "models", "transformations-models-precommit"))) +def test_transformations_precommit(tmp_path, model_name, model_link, mark, reason, ie_device, ts_names, layer_types): + assert mark is None or mark == 'skip' or mark == 'xfail', \ + "Incorrect test case: {}, {}".format(model_name, model_link) + if mark == 'skip': + pytest.skip(reason) + elif mark == 'xfail': + pytest.xfail(reason) + if not ts_names and not layer_types: + return + run_test(model_name, ie_device, ts_names, layer_types) From 9ae8c658bcb6b8cccc1d0f91a1590a2794578b35 Mon Sep 17 00:00:00 2001 From: David Pava Date: Fri, 16 Aug 2024 22:49:55 +0300 Subject: [PATCH 032/117] [NPU] Adding a model set property test for Workload Type (#26070) ### Details: - Adding a test in which we set the WorkloadType property for a compiled model and validate that it changed. ### Tickets: - EISW-134862 --- .../internal/overload/compile_and_infer.hpp | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/plugins/intel_npu/tests/functional/internal/overload/compile_and_infer.hpp b/src/plugins/intel_npu/tests/functional/internal/overload/compile_and_infer.hpp index d35f0b393c02e5..03df711402c8e4 100644 --- a/src/plugins/intel_npu/tests/functional/internal/overload/compile_and_infer.hpp +++ b/src/plugins/intel_npu/tests/functional/internal/overload/compile_and_infer.hpp @@ -183,6 +183,29 @@ TEST_P(OVCompileAndInferRequest, CompiledModelWorkloadTypeDelayedExecutor) { } } +TEST_P(OVCompileAndInferRequest, CompiledModelWorkloadTypeUpdateAfterCompilation) { + if (isCommandQueueExtSupported()) { + configuration[workload_type.name()] = WorkloadType::DEFAULT; + OV_ASSERT_NO_THROW(execNet = core->compile_model(function, target_device, configuration)); + + ASSERT_EQ(execNet.get_property(workload_type.name()).as(), WorkloadType::DEFAULT); + ov::AnyMap modelConfiguration; + modelConfiguration[workload_type.name()] = WorkloadType::EFFICIENT; + OV_ASSERT_NO_THROW(execNet.set_property(modelConfiguration)); + ASSERT_EQ(execNet.get_property(workload_type.name()).as(), WorkloadType::EFFICIENT); + ov::InferRequest req; + OV_ASSERT_NO_THROW(req = execNet.create_infer_request()); + bool is_called = false; + OV_ASSERT_NO_THROW(req.set_callback([&](std::exception_ptr exception_ptr) { + ASSERT_EQ(exception_ptr, nullptr); + is_called = true; + })); + OV_ASSERT_NO_THROW(req.start_async()); + OV_ASSERT_NO_THROW(req.wait()); + ASSERT_TRUE(is_called); + } +} + using OVCompileAndInferRequestTurbo = OVCompileAndInferRequest; TEST_P(OVCompileAndInferRequestTurbo, CompiledModelTurbo) { From 3692cf8fcb92343814c6bf7edd902dcaa6dfe015 Mon Sep 17 00:00:00 2001 From: Xuejun Zhai Date: Sun, 18 Aug 2024 18:05:11 +0800 Subject: [PATCH 033/117] Fix PVS-Studio static analyzer issues (#25897) ### Details: - Static analyzer issues: https://pvs-studio.com/en/blog/posts/cpp/1137/ - *...* ### Tickets: - https://github.com/openvinotoolkit/openvino/issues/25247 --------- Signed-off-by: Zhai, Xuejun --- .../shuffle_channels_fusion.cpp | 2 +- .../op_conversions/convert_pad_to_group_conv.cpp | 2 +- src/core/src/pattern/matcher.cpp | 2 +- .../frontend/src/detail/subgraph_extraction.cpp | 2 +- .../emitters/plugin/x64/jit_eltwise_emitters.cpp | 8 ++++---- src/plugins/intel_cpu/src/node.cpp | 14 ++++++++------ src/plugins/intel_cpu/src/nodes/bin_conv.cpp | 2 +- src/plugins/intel_cpu/src/nodes/fake_quantize.cpp | 2 +- .../src/nodes/kernels/x64/grid_sample.cpp | 6 +++--- src/plugins/template/src/variable_state.hpp | 4 ++-- 10 files changed, 23 insertions(+), 21 deletions(-) diff --git a/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp index 6b6d3081fe434c..8b2407f4d99d84 100644 --- a/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp @@ -112,7 +112,7 @@ ov::pass::ShuffleChannelsFusion::ShuffleChannelsFusion(const bool reshape_consta std::dynamic_pointer_cast(pattern_map.at(reshape_after_pattern).get_node_shared_ptr()); auto reshape_after_constant = std::dynamic_pointer_cast( pattern_map.at(reshape_after_const_pattern).get_node_shared_ptr()); - if (!reshape_after || !transpose || !reshape_after || !reshape_before_constant || !reshape_after_constant) { + if (!reshape_after || !transpose || !reshape_before || !reshape_before_constant || !reshape_after_constant) { return false; } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp b/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp index be3233a45ad811..c7d01d732b60b7 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp @@ -64,7 +64,7 @@ ov::pass::ConvertPadToGroupConvolution::ConvertPadToGroupConvolution() { return a < 0; }; if (std::any_of(pad_begin.begin(), pad_begin.end(), pred) || - std::any_of(pad_begin.begin(), pad_begin.end(), pred)) { + std::any_of(pad_end.begin(), pad_end.end(), pred)) { return false; } diff --git a/src/core/src/pattern/matcher.cpp b/src/core/src/pattern/matcher.cpp index 0ab96573f010bb..c01f7b58d9c1e5 100644 --- a/src/core/src/pattern/matcher.cpp +++ b/src/core/src/pattern/matcher.cpp @@ -44,7 +44,7 @@ MatcherState::~MatcherState() { m_matcher->m_matched_list.end()); } - if (!m_pattern_value_maps.empty()) { + if (!m_matcher->m_pattern_value_maps.empty()) { m_matcher->m_pattern_value_maps.erase(m_pattern_value_maps.begin() + m_capture_size, m_pattern_value_maps.end()); } diff --git a/src/frontends/onnx/frontend/src/detail/subgraph_extraction.cpp b/src/frontends/onnx/frontend/src/detail/subgraph_extraction.cpp index 7822e47d54b70d..65fed5f1fe70a2 100644 --- a/src/frontends/onnx/frontend/src/detail/subgraph_extraction.cpp +++ b/src/frontends/onnx/frontend/src/detail/subgraph_extraction.cpp @@ -297,7 +297,7 @@ void SubgraphExtractor::add_new_inputs(const std::vector& new_inputs, input_consumers = 0; // get index of the current edge from new_inputs in order to pass it to append_new_graph_input() - auto it = std::find_if(new_inputs.begin(), new_inputs.begin(), [&](const InputEdge& input_edge) { + auto it = std::find_if(new_inputs.begin(), new_inputs.end(), [&](const InputEdge& input_edge) { return get_input_tensor_name(m_onnx_graph, input_edge) == input.first; }); index = static_cast(std::distance(new_inputs.begin(), it)); diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp index 4f1ca1c4185132..1c90af2d48e85a 100644 --- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp +++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp @@ -702,7 +702,7 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector &in_vec_idxs, // caller obligation to save k-regs as callee may use them size_t n_k_regs_to_save = 8; - if (isa == x64::avx512_core || isa == x64::avx512_core) { + if (isa == x64::avx512_core) { h->sub(h->rsp, n_k_regs_to_save * k_mask_size); for (size_t i = 0; i < n_k_regs_to_save; ++i) { if (x64::mayiuse(x64::avx512_core)) @@ -751,7 +751,7 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector &in_vec_idxs, h->add(h->rsp, (get_max_vecs_count() + 2) * get_vec_length()); // restore k registers - if (isa == x64::avx512_core || isa == x64::avx512_core) { + if (isa == x64::avx512_core) { for (int i = n_k_regs_to_save - 1; i >= 0; --i) { if (x64::mayiuse(x64::avx512_core)) h->kmovq(Opmask(i), h->ptr[h->rsp + i * k_mask_size]); @@ -1606,7 +1606,7 @@ void jit_power_static_emitter::emit_isa(const std::vector &in_vec_idxs, // caller obligation to save k-regs as callee may use them size_t n_k_regs_to_save = 8; - if (isa == x64::avx512_core || isa == x64::avx512_core) { + if (isa == x64::avx512_core) { h->sub(h->rsp, n_k_regs_to_save * k_mask_size); for (size_t i = 0; i < n_k_regs_to_save; ++i) { if (x64::mayiuse(x64::avx512_core)) @@ -1655,7 +1655,7 @@ void jit_power_static_emitter::emit_isa(const std::vector &in_vec_idxs, h->add(h->rsp, (get_max_vecs_count() + 2) * get_vec_length()); // restore k registers - if (isa == x64::avx512_core || isa == x64::avx512_core) { + if (isa == x64::avx512_core) { for (int i = n_k_regs_to_save - 1; i >= 0; --i) { if (x64::mayiuse(x64::avx512_core)) h->kmovq(Opmask(i), h->ptr[h->rsp + i * k_mask_size]); diff --git a/src/plugins/intel_cpu/src/node.cpp b/src/plugins/intel_cpu/src/node.cpp index 326b3e907dcc8f..5f9ca8f02ee4ce 100644 --- a/src/plugins/intel_cpu/src/node.cpp +++ b/src/plugins/intel_cpu/src/node.cpp @@ -396,9 +396,10 @@ void Node::resolveInPlaceEdges(Edge::LOOK look) { MemoryDescPtr Node::getBaseMemDescAtInputPort(size_t portNum) const { if (auto primDesc = getSelectedPrimitiveDescriptor()) { const auto& inConfs = primDesc->getConfig().inConfs; - if (inConfs.size() < portNum) { - OPENVINO_THROW("Can't get input memory desc at port: ", portNum, ", incorrect port number"); - } + OPENVINO_ASSERT(portNum < inConfs.size(), + "Can't get input memory desc at port: ", + portNum, + ", incorrect port number"); return inConfs[portNum].getMemDesc(); } OPENVINO_THROW("Can't get input memory desc, primitive descriptor is not selected"); @@ -407,9 +408,10 @@ MemoryDescPtr Node::getBaseMemDescAtInputPort(size_t portNum) const { MemoryDescPtr Node::getBaseMemDescAtOutputPort(size_t portNum) const { if (auto primDesc = getSelectedPrimitiveDescriptor()) { const auto& outConfs = primDesc->getConfig().outConfs; - if (outConfs.size() < portNum) { - OPENVINO_THROW("Can't get output memory desc at port: ", portNum, ", incorrect port number"); - } + OPENVINO_ASSERT(portNum < outConfs.size(), + "Can't get output memory desc at port: ", + portNum, + ", incorrect port number"); return outConfs[portNum].getMemDesc(); } OPENVINO_THROW("Can't get output memory desc, primitive descriptor is not selected"); diff --git a/src/plugins/intel_cpu/src/nodes/bin_conv.cpp b/src/plugins/intel_cpu/src/nodes/bin_conv.cpp index a54c4b76ea8feb..f2de2d20a17528 100644 --- a/src/plugins/intel_cpu/src/nodes/bin_conv.cpp +++ b/src/plugins/intel_cpu/src/nodes/bin_conv.cpp @@ -1085,7 +1085,7 @@ void BinaryConvolution::createPrimitive() { int r_pad_no_tail = nstl::max(0, (jcp.ow - jcp.ur_w_tail - 1) * jcp.stride_w + (jcp.kw - 1) * (jcp.dilate_w + 1) - (jcp.iw + jcp.l_pad - 1)); - bool args_ok = jcp.l_pad <= jcp.ur_w && (r_pad_no_tail <= jcp.ur_w) && (jcp.l_pad <= jcp.ur_w) && + bool args_ok = (jcp.l_pad <= jcp.ur_w) && (r_pad_no_tail <= jcp.ur_w) && IMPLICATION(jcp.kw > 7, (jcp.t_pad == 0 && jcp.l_pad == 0) || (jcp.stride_w == 1 && jcp.stride_h == 1)); if (!args_ok) OPENVINO_THROW("BinaryConvolution with name '", getName(), "' has unsupported parameters"); diff --git a/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp b/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp index fa823d79c3c208..f12ab40cf5643b 100644 --- a/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp +++ b/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp @@ -1298,7 +1298,7 @@ void FakeQuantize::getSupportedDescriptors() { if (getChildEdges().empty()) OPENVINO_THROW(errorPrefix, "has incorrect number of output edges: ", getChildEdges().size()); - if (getInputShapeAtPort(0).getRank() != getInputShapeAtPort(0).getRank()) { + if (getInputShapeAtPort(0).getRank() != getOutputShapeAtPort(0).getRank()) { OPENVINO_THROW(errorPrefix, "has different ranks for input and output tensors"); } diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp index e56de2dd892bea..d91688689b86c0 100644 --- a/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp +++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp @@ -922,7 +922,7 @@ void GridSampleKernel::reflectionPadding(const Vmm& vCoordDst, const Vmm& v mov(rAux, ptr[regParams + GET_OFF(srcWidthMul2Sub1F)]); uni_vmovups(vAux1, ptr[rAux]); } - } else if (coord::h) { + } else if (dim == coord::h) { if (vSrcHeightMul2Sub1F.isInitialized()) { vMul2Sub1 = vSrcHeightMul2Sub1F; } else { @@ -956,7 +956,7 @@ void GridSampleKernel::reflectionPadding(const Vmm& vCoordDst, const Vmm& v mov(rAux, ptr[regParams + GET_OFF(srcWidthMul2F)]); uni_vmovups(vAux1, ptr[rAux]); } - } else if (coord::h) { + } else if (dim == coord::h) { if (vSrcHeightMul2F.isInitialized()) { vMul2 = vSrcHeightMul2F; } else { @@ -987,7 +987,7 @@ void GridSampleKernel::reflectionPadding(const Vmm& vCoordDst, const Vmm& v mov(rAux, ptr[regParams + GET_OFF(srcWidthMul2Sub1F)]); uni_vsubps(vAux0, vCoordDst, ptr[rAux]); } - } else if (coord::h) { + } else if (dim == coord::h) { if (vSrcHeightMul2Sub1F.isInitialized()) { uni_vsubps(vAux0, vCoordDst, vSrcHeightMul2Sub1F); } else { diff --git a/src/plugins/template/src/variable_state.hpp b/src/plugins/template/src/variable_state.hpp index 22517b5e3e9694..8227a22c0fe93c 100644 --- a/src/plugins/template/src/variable_state.hpp +++ b/src/plugins/template/src/variable_state.hpp @@ -20,8 +20,8 @@ class VariableState : public ov::IVariableState { } void set_state(const ov::SoPtr& state) override { OPENVINO_ASSERT(state->get_shape() == m_state->get_shape(), "Wrong tensor shape."); - OPENVINO_ASSERT(state->get_element_type() == state->get_element_type(), "Wrong tensor type."); - OPENVINO_ASSERT(state->get_byte_size() == state->get_byte_size(), "Blob size of tensors are not equal."); + OPENVINO_ASSERT(state->get_element_type() == m_state->get_element_type(), "Wrong tensor type."); + OPENVINO_ASSERT(state->get_byte_size() == m_state->get_byte_size(), "Blob size of tensors are not equal."); std::memcpy(m_state->data(), state->data(), state->get_byte_size()); } From 70b729a5c5e45785c889756910d8eae8a776fdc7 Mon Sep 17 00:00:00 2001 From: River Li Date: Mon, 19 Aug 2024 13:13:59 +0800 Subject: [PATCH 034/117] Fix Coverity Scan issue (#26099) ### Details: - Fix CS issues: Performance inefficiencies (AUTO_CAUSES_COPY) Using the "auto" keyword without an "&" causes the copy of an object of type "ov::PartialShape". ### Tickets: - *ticket-id* --- .../transformations/decompose_reduce_scalar_output.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp index 7bca11f9143393..99503babd5750e 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_scalar_output.cpp @@ -33,14 +33,14 @@ ov::intel_gpu::DecomposeReduceForScalarOutput::DecomposeReduceForScalarOutput() { auto check_reduce_shape = [=](Output output) -> bool { const auto reduce = ov::as_type_ptr(output.get_node_shared_ptr()); - const auto input_shape = reduce->input_value(0).get_partial_shape(); - const auto reduce_shape = reduce->input_value(1).get_partial_shape(); + auto& input_shape = reduce->input_value(0).get_partial_shape(); + auto& reduce_shape = reduce->input_value(1).get_partial_shape(); if (reduce_shape.is_dynamic() || reduce_shape.size() != 1) { return false; } else if (reduce_shape.to_shape()[0] <= 1 || reduce_shape.to_shape()[0] != input_shape.size()) { return false; } - const auto output_shape = reduce->get_output_partial_shape(0); + auto& output_shape = reduce->get_output_partial_shape(0); if (output_shape.is_static() && input_shape.is_static()) { // Output size decides at most how many EU threads can be used for this node execution, // less than 4 EU threads to execute a primitive will lead to poor performance. @@ -69,8 +69,8 @@ ov::intel_gpu::DecomposeReduceForScalarOutput::DecomposeReduceForScalarOutput() if (!reduce_orig || transformation_callback(reduce_orig)) return false; - const auto input_shape = reduce_orig->input_value(0).get_partial_shape(); - const auto output_shape = reduce_orig->get_output_partial_shape(0); + auto& input_shape = reduce_orig->input_value(0).get_partial_shape(); + auto& output_shape = reduce_orig->get_output_partial_shape(0); bool dynamic_shape = input_shape.is_dynamic() || output_shape.is_dynamic(); std::shared_ptr reduce_new = nullptr; if (!dynamic_shape) { From 0a48811933f89ff6d2e02a88355798177894bbc1 Mon Sep 17 00:00:00 2001 From: Aleksandr Voron Date: Mon, 19 Aug 2024 07:24:27 +0200 Subject: [PATCH 035/117] [CPU][ARM] Disable ACL MVN executor for NHWC and `across_channels` = false (#26089) ### Details: - Reverts PR https://github.com/openvinotoolkit/openvino/pull/25905 - Fixed layout check in `isSupported` method to cover both 4D and 5D cases - Removed workaround that skips unsupported cases (NHWC\NDHWC + `across_channels` = false) on ARM - Moved tests with unsupported cases from common to x64 dir ### Tickets: - *ticket-id* --- .../src/nodes/executors/acl/acl_mvn.cpp | 39 ++++++ .../src/nodes/executors/acl/acl_mvn.hpp | 32 +---- .../custom/single_layer_tests/classes/mvn.cpp | 52 +++++--- .../custom/single_layer_tests/classes/mvn.hpp | 8 +- .../instances/common/mvn.cpp | 122 ++++++++++-------- .../single_layer_tests/instances/x64/mvn.cpp | 89 +++++++++---- 6 files changed, 215 insertions(+), 127 deletions(-) diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.cpp index 120e957740ae41..6fde4bb0db5604 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.cpp @@ -72,5 +72,44 @@ void AclMVNExecutor::exec(const std::vector& src, const std::vector< dstTensor.allocator()->free(); } +bool AclMVNExecutorBuilder::isSupported(const MVNAttrs& mvnAttrs, + const std::vector& srcDescs, + const std::vector& dstDescs) const { + if ((srcDescs[0]->getPrecision() != ov::element::f32 && + srcDescs[0]->getPrecision() != ov::element::f16) || + srcDescs[0]->getPrecision() != dstDescs[0]->getPrecision()) { + DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support precisions:", + " src[0]=", srcDescs[0]->getPrecision(), + " dst[0]=", dstDescs[0]->getPrecision()); + return false; + } + + if (!(srcDescs[0]->hasLayoutType(LayoutType::ncsp) && + dstDescs[0]->hasLayoutType(LayoutType::ncsp)) && + !(srcDescs[0]->hasLayoutType(LayoutType::nspc) && + dstDescs[0]->hasLayoutType(LayoutType::nspc))) { + DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support layout:", + " src: ", srcDescs[0]->serializeFormat(), + " dst: ", dstDescs[0]->serializeFormat()); + return false; + } + + if (mvnAttrs.epsMode_ == MVNEpsMode::OUTSIDE_SQRT) { + DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support OUTSIDE_SQRT mode"); + return false; + } + if (!mvnAttrs.normalizeVariance_) { + DEBUG_LOG("NEMeanStdDevNormalizationLayer supports normalize_variance=true only"); + return false; + } + if (!mvnAttrs.initAcrossChannels_ && + srcDescs[0]->hasLayoutType(LayoutType::nspc)) { + DEBUG_LOG("initAcrossChannels = false is not supported by ACL for NHWC layout"); + return false; + } + + return true; + } + } // namespace intel_cpu } // namespace ov diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.hpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.hpp index f8c5603d3e529e..7ba445253f8d02 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.hpp +++ b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.hpp @@ -40,37 +40,7 @@ class AclMVNExecutorBuilder : public MVNExecutorBuilder { public: bool isSupported(const MVNAttrs& mvnAttrs, const std::vector& srcDescs, - const std::vector& dstDescs) const override { - if ((srcDescs[0]->getPrecision() != ov::element::f32 && - srcDescs[0]->getPrecision() != ov::element::f16) || - srcDescs[0]->getPrecision() != dstDescs[0]->getPrecision()) { - DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support precisions:", - " src[0]=", srcDescs[0]->getPrecision(), - " dst[0]=", dstDescs[0]->getPrecision()); - return false; - } - - if (!(srcDescs[0]->hasLayoutType(LayoutType::ncsp) && - dstDescs[0]->hasLayoutType(LayoutType::ncsp)) && - !(srcDescs[0]->hasLayoutType(LayoutType::nspc) && - dstDescs[0]->hasLayoutType(LayoutType::nspc))) { - DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support layout:", - " src: ", srcDescs[0]->serializeFormat(), - " dst: ", dstDescs[0]->serializeFormat()); - return false; - } - - if (mvnAttrs.epsMode_ == MVNEpsMode::OUTSIDE_SQRT) { - DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support OUTSIDE_SQRT mode"); - return false; - } - if (!mvnAttrs.normalizeVariance_) { - DEBUG_LOG("NEMeanStdDevNormalizationLayer supports normalize_variance=true only"); - return false; - } - - return true; - } + const std::vector& dstDescs) const override; MVNExecutorPtr makeExecutor(const ExecutorContext::CPtr context) const override { return std::make_shared(context); diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.cpp index 598447f8ec8363..2537fb4e87a5db 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.cpp @@ -61,17 +61,6 @@ std::string MvnLayerCPUTest::getTestCaseName(testing::TestParamInfo& epsilon() { return epsilon; } +const std::vector& cpuParams_4D() { + static const std::vector cpuParams_4D = { + CPUSpecificParams({nchw}, {nchw}, {}, {}), + CPUSpecificParams({nhwc}, {nhwc}, {}, {}), + }; + return cpuParams_4D; +} + +const std::vector& cpuParams_5D() { + static const std::vector cpuParams_5D = { + CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}), + CPUSpecificParams({ndhwc}, {ndhwc}, {}, {}), + }; + return cpuParams_5D; +} + +const std::vector& inpPrc() { + static const std::vector inpPrc = { + ElementType::i8, + ElementType::f32, + }; + return inpPrc; +} + +const std::vector& outPrc() { + static const std::vector outPrc = { + ElementType::f32, + }; + return outPrc; +} + +const std::vector& fusingParamsSet() { + static const std::vector fusingParamsSet = { + emptyFusingSpec, + }; + return fusingParamsSet; +} } // namespace MVN } // namespace test } // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.hpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.hpp index daa002fe559660..6c76360bc12420 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.hpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/mvn.hpp @@ -35,7 +35,6 @@ class MvnLayerCPUTest : public testing::WithParamInterface obj); - bool isSupportedTestCase(); protected: void SetUp() override; private: @@ -58,6 +57,13 @@ namespace MVN { const std::vector& acrossChannels(); const std::vector& epsilon(); + const std::vector& cpuParams_4D(); + const std::vector& cpuParams_5D(); + + const std::vector& inpPrc(); + const std::vector& outPrc(); + + const std::vector& fusingParamsSet(); const std::vector& additionalConfig(); } // namespace MVN } // namespace test diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/mvn.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/mvn.cpp index 30cfdacde5291e..1140beeb1db26a 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/mvn.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/mvn.cpp @@ -17,26 +17,12 @@ const std::vector normalizeVariance = { true }; -std::vector inpPrc = { - ElementType::i8, - ElementType::f32, -}; -std::vector outPrc = { - ElementType::f32, -}; - -std::vector cpuParams_4D = { - CPUSpecificParams({nchw}, {nchw}, {}, {}), - CPUSpecificParams({nhwc}, {nhwc}, {}, {}), -}; - -std::vector cpuParams_5D = { - CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}), - CPUSpecificParams({ndhwc}, {ndhwc}, {}, {}), +const std::vector cpuParams_4D_ncsp = { + CPUSpecificParams({nchw}, {nchw}, {}, {}) }; -std::vector fusingParamsSet { - emptyFusingSpec, +const std::vector cpuParams_5D_ncsp = { + CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}) }; std::vector fusingParamsSetStaticShape { @@ -52,44 +38,76 @@ const auto Mvn3D = ::testing::Combine( ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), - ::testing::ValuesIn(fusingParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(fusingParamsSet()), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn3D, MvnLayerCPUTest, Mvn3D, MvnLayerCPUTest::getTestCaseName); -const auto Mvn4D = ::testing::Combine( +const auto Mvn4D_across_channels = ::testing::Combine( ::testing::Combine( ::testing::ValuesIn(inputShapes_4D()), ::testing::Values(ElementType::f32), ::testing::ValuesIn(emptyReductionAxes()), - ::testing::ValuesIn(acrossChannels()), + ::testing::Values(true), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D)), - ::testing::ValuesIn(fusingParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D())), + ::testing::ValuesIn(fusingParamsSet()), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), + ::testing::ValuesIn(additionalConfig())); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn4D_across_channels, MvnLayerCPUTest, Mvn4D_across_channels, MvnLayerCPUTest::getTestCaseName); + +const auto Mvn4D_no_across_channels_ncsp = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(inputShapes_4D()), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(emptyReductionAxes()), + ::testing::Values(false), + ::testing::Values(true), + ::testing::ValuesIn(epsilon())), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D_ncsp)), + ::testing::ValuesIn(fusingParamsSet()), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn4D, MvnLayerCPUTest, Mvn4D, MvnLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn4D_no_across_channels_ncsp, MvnLayerCPUTest, Mvn4D_no_across_channels_ncsp, MvnLayerCPUTest::getTestCaseName); -const auto Mvn5D = ::testing::Combine( +const auto Mvn5D_across_channels = ::testing::Combine( ::testing::Combine( ::testing::ValuesIn(inputShapes_5D()), ::testing::Values(ElementType::f32), ::testing::ValuesIn(emptyReductionAxes()), - ::testing::ValuesIn(acrossChannels()), + ::testing::Values(true), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D)), - ::testing::ValuesIn(fusingParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D())), + ::testing::ValuesIn(fusingParamsSet()), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), + ::testing::ValuesIn(additionalConfig())); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn5D_across_channels, MvnLayerCPUTest, Mvn5D_across_channels, MvnLayerCPUTest::getTestCaseName); + +const auto Mvn5D_no_across_channels_ncsp = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(inputShapes_5D()), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(emptyReductionAxes()), + ::testing::Values(false), + ::testing::Values(true), + ::testing::ValuesIn(epsilon())), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D_ncsp)), + ::testing::ValuesIn(fusingParamsSet()), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn5D, MvnLayerCPUTest, Mvn5D, MvnLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn5D_no_across_channels_ncsp, MvnLayerCPUTest, Mvn5D_no_across_channels_ncsp, MvnLayerCPUTest::getTestCaseName); // 1D 2D case std::vector fusingUnaryEltwiseParamsSet { @@ -106,8 +124,8 @@ const auto Mvn1D = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingUnaryEltwiseParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn1D, MvnLayerCPUTest, Mvn1D, MvnLayerCPUTest::getTestCaseName); @@ -122,9 +140,9 @@ const auto Mvn2D = ::testing::Combine( ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), - ::testing::ValuesIn(fusingParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(fusingParamsSet()), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn2D, MvnLayerCPUTest, Mvn2D, MvnLayerCPUTest::getTestCaseName); @@ -140,8 +158,8 @@ const auto Mvn2DTrans = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingUnaryEltwiseParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn2DTrans, MvnLayerCPUTest, Mvn2DTrans, MvnLayerCPUTest::getTestCaseName); @@ -156,8 +174,8 @@ const auto Mvn2DStatic = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); const auto Mvn3DStatic = ::testing::Combine( @@ -170,8 +188,8 @@ const auto Mvn3DStatic = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn3D_Static, MvnLayerCPUTest, Mvn3DStatic, MvnLayerCPUTest::getTestCaseName); @@ -184,10 +202,10 @@ const auto Mvn4DStatic = ::testing::Combine( ::testing::Values(true), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D)), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D())), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn4D_Static, MvnLayerCPUTest, Mvn4DStatic, MvnLayerCPUTest::getTestCaseName); @@ -200,10 +218,10 @@ const auto Mvn5DStatic = ::testing::Combine( ::testing::Values(true), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D)), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D())), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn5D_Static, MvnLayerCPUTest, Mvn5DStatic, MvnLayerCPUTest::getTestCaseName); diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/mvn.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/mvn.cpp index 25893c59c0a96c..e3edc36741cac5 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/mvn.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/mvn.cpp @@ -19,18 +19,11 @@ const std::vector normalizeVariance = { false }; -std::vector inpPrc = { - ElementType::bf16 -}; -std::vector outPrc = { - ElementType::bf16 -}; - -std::vector cpuParams_4D = { +std::vector cpuParams_4D_blocked = { CPUSpecificParams({nChw16c}, {nChw16c}, {}, {}) }; -std::vector cpuParams_5D = { +std::vector cpuParams_5D_blocked = { CPUSpecificParams({nCdhw16c}, {nCdhw16c}, {}, {}) }; @@ -64,8 +57,8 @@ const auto Mvn3D = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn3D, MvnLayerCPUTest, Mvn3D, MvnLayerCPUTest::getTestCaseName); @@ -89,8 +82,8 @@ const auto Mvn1D = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingUnaryEltwiseParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn1D, MvnLayerCPUTest, Mvn1D, MvnLayerCPUTest::getTestCaseName); @@ -106,8 +99,8 @@ const auto Mvn2D = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn2D, MvnLayerCPUTest, Mvn2D, MvnLayerCPUTest::getTestCaseName); @@ -123,8 +116,8 @@ const auto Mvn2DTrans = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingUnaryEltwiseParamsSet), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn2DTrans, MvnLayerCPUTest, Mvn2DTrans, MvnLayerCPUTest::getTestCaseName); @@ -139,8 +132,8 @@ const auto Mvn2DStatic = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); const auto Mvn3DStatic = ::testing::Combine( @@ -153,8 +146,8 @@ const auto Mvn3DStatic = ::testing::Combine( ::testing::ValuesIn(epsilon())), ::testing::Values(emptyCPUSpec), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn3D_Static, MvnLayerCPUTest, Mvn3DStatic, MvnLayerCPUTest::getTestCaseName); @@ -167,10 +160,10 @@ const auto Mvn4DStatic = ::testing::Combine( ::testing::Values(false), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D)), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D_blocked)), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn4D_Static, MvnLayerCPUTest, Mvn4DStatic, MvnLayerCPUTest::getTestCaseName); @@ -198,7 +191,7 @@ const auto Mvn4DStaticCTails = ::testing::Combine( ::testing::Values(false), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D)), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D_blocked)), ::testing::Values(emptyFusingSpec), ::testing::Values(ElementType::f32), ::testing::Values(ElementType::f32), @@ -215,10 +208,10 @@ const auto Mvn5DStatic = ::testing::Combine( ::testing::Values(false), ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon())), - ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D)), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D_blocked)), ::testing::ValuesIn(fusingParamsSetStaticShape), - ::testing::ValuesIn(inpPrc), - ::testing::ValuesIn(outPrc), + ::testing::Values(ElementType::bf16), + ::testing::Values(ElementType::bf16), ::testing::ValuesIn(additionalConfig())); INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn5D_Static, MvnLayerCPUTest, Mvn5DStatic, MvnLayerCPUTest::getTestCaseName); @@ -247,6 +240,46 @@ const auto MvnSmallSpatial = ::testing::Combine( INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_MvnSmallSpatial, MvnLayerCPUTest, MvnSmallSpatial, MvnLayerCPUTest::getTestCaseName); +const std::vector cpuParams_4D_nspc = { + CPUSpecificParams({nhwc}, {nhwc}, {}, {}) +}; + +const std::vector cpuParams_5D_nspc = { + CPUSpecificParams({ndhwc}, {ndhwc}, {}, {}) +}; + +const auto Mvn4D_no_across_channels_nspc = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(inputShapes_4D()), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(emptyReductionAxes()), + ::testing::Values(false), + ::testing::ValuesIn(normalizeVariance), + ::testing::ValuesIn(epsilon())), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_4D_nspc)), + ::testing::Values(emptyFusingSpec), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), + ::testing::ValuesIn(additionalConfig())); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn4D_no_across_channels_nspc, MvnLayerCPUTest, Mvn4D_no_across_channels_nspc, MvnLayerCPUTest::getTestCaseName); + +const auto Mvn5D_no_across_channels_nspc = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(inputShapes_5D()), + ::testing::Values(ElementType::f32), + ::testing::ValuesIn(emptyReductionAxes()), + ::testing::Values(false), + ::testing::ValuesIn(normalizeVariance), + ::testing::ValuesIn(epsilon())), + ::testing::ValuesIn(filterCPUSpecificParams(cpuParams_5D_nspc)), + ::testing::Values(emptyFusingSpec), + ::testing::ValuesIn(inpPrc()), + ::testing::ValuesIn(outPrc()), + ::testing::ValuesIn(additionalConfig())); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_Mvn5D_no_across_channels_nspc, MvnLayerCPUTest, Mvn5D_no_across_channels_nspc, MvnLayerCPUTest::getTestCaseName); + } // namespace } // namespace MVN } // namespace test From f06365af7e85f546e713e9c3a0e35ad7b3c84e67 Mon Sep 17 00:00:00 2001 From: Andrew Kwangwoong Park Date: Mon, 19 Aug 2024 17:05:16 +0900 Subject: [PATCH 036/117] [GPU] Fix accuracy issue for StableDiffusion3 (#26032) ### Details: - Fix accuracy issue from runtime buffer fusing for crop(https://github.com/openvinotoolkit/openvino/pull/25060) - If user is MVN and dynamic padding exists, output padding propagation is not supported in the base mode reshape - oneDNN supports padded input of outer axis only for buffer fusing on static shape ### Tickets: - [CVS-149472](https://jira.devtools.intel.com/browse/CVS-149472) --------- Signed-off-by: Andrew Park --- .../src/graph/include/reshape_inst.h | 9 +- .../intel_gpu/src/graph/primitive_inst.cpp | 11 ++- .../passes/prepare_buffer_fusing_test.cpp | 82 +++++++++++++++++++ 3 files changed, 98 insertions(+), 4 deletions(-) diff --git a/src/plugins/intel_gpu/src/graph/include/reshape_inst.h b/src/plugins/intel_gpu/src/graph/include/reshape_inst.h index 7ae1d4792879eb..d5a60138a50777 100644 --- a/src/plugins/intel_gpu/src/graph/include/reshape_inst.h +++ b/src/plugins/intel_gpu/src/graph/include/reshape_inst.h @@ -8,6 +8,7 @@ #include "openvino/core/partial_shape.hpp" #include "crop_inst.h" #include "rope_inst.h" +#include "mvn_inst.h" #include "primitive_inst.h" #include @@ -42,8 +43,12 @@ struct typed_program_node : public typed_program_node_base { if (!input().is_type()) return false; - // TODO: If user is RoPE and dynamic padding exists, ouput padding propagation is not supported in the base mode - if (get_users().size() == 1 && get_users().front()->is_type()) + // oneDNN supports padded input of outer axis only for buffer fusing on static shape + if (!has_outer_padding_offset() && get_users().front()->get_preferred_impl_type() == impl_types::onednn) + return false; + + // TODO: If user is RoPE or MVN and dynamic padding exists, ouput padding propagation is not supported in the base mode + if (get_users().size() == 1 && (get_users().front()->is_type() || get_users().front()->is_type())) return false; auto axis = input().as().get_primitive()->axis; diff --git a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp index 281700ba8770b1..03c2444042623e 100644 --- a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp +++ b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp @@ -1494,12 +1494,19 @@ void primitive_inst::do_runtime_in_place_crop() { if (!crop_in_place_optimization::match(u->get_node(), *u->_impl_params, pred_layout, true)) { u->set_can_be_optimized(false); GPU_DEBUG_TRACE_DETAIL << "[In place crop] " << u->id() << " cannot be optimized " << std::endl; - return; + continue; } auto crop_axis = u->_impl_params->typed_desc()->axis; auto offsets = u->_impl_params->input_offsets[0]; if (crop_in_place_optimization::can_crop_be_optimized_along_feature(crop_layout, pred_layout)) { + // TODO: If crop is optimized out w/ data padding along feature and crop's user is reshape + // manual dynamic padding update to reshape output layout is not currently supported + if (user_info.first) { + u->set_can_be_optimized(false); + GPU_DEBUG_TRACE_DETAIL << "[In place crop] " << u->id() << " cannot be optimized " << std::endl; + continue; + } crop_in_place_optimization::update_in_place_crop_padding_along_feature(u->get_node(), crop_layout, pred_layout, offsets, crop_axis, true); } else if (crop_in_place_optimization::can_crop_be_optimized_simple_data_format(crop_layout, pred_layout)) { crop_in_place_optimization::update_in_place_crop_padding_simple_data_format(crop_layout, pred_layout, user_info, offsets, crop_axis, true); @@ -1511,7 +1518,7 @@ void primitive_inst::do_runtime_in_place_crop() { } else { u->set_can_be_optimized(false); GPU_DEBUG_TRACE_DETAIL << "[In place crop] " << u->id() << " cannot be optimized " << std::endl; - return; + continue; } u->_impl_params->output_layouts[0] = crop_layout; u->set_can_be_optimized(true); diff --git a/src/plugins/intel_gpu/tests/unit/passes/prepare_buffer_fusing_test.cpp b/src/plugins/intel_gpu/tests/unit/passes/prepare_buffer_fusing_test.cpp index 668003aac77192..c1ccb7bbf0ff7a 100644 --- a/src/plugins/intel_gpu/tests/unit/passes/prepare_buffer_fusing_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/passes/prepare_buffer_fusing_test.cpp @@ -20,6 +20,7 @@ #include "shape_of_inst.h" #include "gather_inst.h" #include "strided_slice_inst.h" +#include "mvn_inst.h" #include "intel_gpu/graph/network.hpp" #include "pass_manager.h" #include "to_string_utils.h" @@ -941,6 +942,87 @@ TEST(prepare_buffer_fusing, in_place_crop_dynamic_split_lengths) { ASSERT_EQ(output_ptr_3[i], out3[i]); } +TEST(prepare_buffer_fusing, in_place_crop_dynamic_mvn) { + auto& engine = get_test_engine(); + + auto in_layout = layout{ ov::PartialShape{-1, -1, 4}, data_types::f32, format::bfyx}; + auto input_mem = engine.allocate_memory({ {1, 2, 4}, data_types::f32, format::bfyx }); + auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::u8, format::bfyx }); + auto bias_mem = engine.allocate_memory({ {1, 1, 8}, data_types::f32, format::bfyx }); + auto scale_mem = engine.allocate_memory({ {8, 1}, data_types::f32, format::bfyx }); + auto zp_mem = engine.allocate_memory({ {8, 1}, data_types::f32, format::bfyx }); + auto axis_mem = engine.allocate_memory({ {}, data_types::i64, format::bfyx }); + auto splits_length_mem = engine.allocate_memory({ {2}, data_types::i64, format::bfyx }); + + int64_t axis = 2; + set_values(input_mem, { -0.5f, 2.0f, 0.5f, 1.0f, + 0.5f, -2.0f, -0.5f, -1.0f }); + set_values(axis_mem, {axis}); + set_values(splits_length_mem, { 2, 6 }); + set_values(weights_mem, { 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 0, + 15, 14, 13, 12, + 11, 10, 9, 8, + 7, 6, 5, 4, + 3, 2, 1, 0}); + set_values(bias_mem, { 1.0f, -2.0f, 3.0f, -4.0f, 5.0f, -6.0f, 7.0f, 2.0f }); + set_values(scale_mem, { 2.0f, 4.0f, -2.0f, -4.0f, 0.5f, -0.5f, 2.0f, 2.0f }); + set_values(zp_mem, { 1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 1.0f, 6.0f, 2.0f }); + + std::vector out1 = { 13.f, 58.f, -11.f, -62.f }; + std::vector out2 = { -24.0833f, -81.0833f, 45.4167f, 8.91667f, 27.9167f, 22.9167f, 27.75f, 70.75f, -37.75f, -23.25f, -16.25f, -21.25f }; + std::vector out3 = { 13.f, 58.f, -51.f, -108.f, 18.5f, -18.f, 1.f, -4.f, -11.f, -62.f, 57.f, 100.f, -8.5f, 6.f, 13.f, 8.f }; + + cldnn::crop_ngraph_op_mode op_mode = cldnn::crop_ngraph_op_mode::variadic_split; + topology topology( + input_layout("input", in_layout), + data("axis", axis_mem), + data("splits_length", splits_length_mem), + data("weights", weights_mem), + data("bias", bias_mem), + data("scale", scale_mem), + data("zp", zp_mem), + fully_connected("fc", input_info("input"), "weights", "bias", "scale", "zp", data_types::f32, 3, 2), + crop("crop1", { input_info("fc"), input_info("axis"), input_info("splits_length") }, cldnn::tensor(1), cldnn::tensor(0), op_mode, 0, axis), + reorder("output1", input_info("crop1"), format::bfyx, data_types::f32), + crop("crop2", { input_info("fc"), input_info("axis"), input_info("splits_length") }, cldnn::tensor(1), cldnn::tensor(0), op_mode, 1, axis), + reshape("reshape", input_info("crop2"), true, std::vector{0, 0, 3, 2}, ov::PartialShape{-1, -1, 3, 2}, cldnn::reshape::reshape_mode::base), + mvn("mvn", input_info("reshape"), false, 1e-10f, false, {2, 3}), + reorder("output2", input_info("mvn"), format::bfyx, data_types::f32, std::vector(), reorder_mean_mode::subtract, padding(), true), + reorder("output3", input_info("fc"), format::bfyx, data_types::f32) + ); + + auto config = get_test_default_config(engine); + config.set_property(ov::intel_gpu::allow_new_shape_infer(true)); + config.set_property(ov::intel_gpu::optimize_data(true)); + network network(engine, topology, config); + + network.set_input_data("input", input_mem); + + auto outputs = network.execute(); + + auto output = outputs.at("output1").get_memory(); + cldnn::mem_lock output_ptr(output, get_test_stream()); + + for (size_t i = 0; i < out1.size(); i++) + ASSERT_EQ(output_ptr[i], out1[i]); + + auto output_2 = outputs.at("output2").get_memory(); + cldnn::mem_lock output_ptr_2(output_2, get_test_stream()); + + for (size_t i = 0; i < out2.size(); i++) { + ASSERT_NEAR(output_ptr_2[i], out2[i], 0.0001); + } + + auto output_3 = outputs.at("output3").get_memory(); + cldnn::mem_lock output_ptr_3(output_3, get_test_stream()); + + for (size_t i = 0; i < out3.size(); i++) + ASSERT_EQ(output_ptr_3[i], out3[i]); +} + // Testing for implicit crop along batch axis and outer padding optimzing. // Outer padding opt includes opt out of reshape and reorder which has padded input only in batch axis // This optimzing also includes offset(outer axis padded input) handling of oneDNN primitive. From dcf9605f7fba5ed7a79835d91d3fdedecc73779b Mon Sep 17 00:00:00 2001 From: Sergey Shlyapnikov Date: Mon, 19 Aug 2024 12:35:50 +0400 Subject: [PATCH 037/117] [GPU] Fix accuracy loss in Range due to high value generation for attention mask (#26093) ### Details: - Fixed accuracy loss in the Range operation due to high value generation for the attention mask in cases of long input sequences ### Tickets: - [CVS-146283](https://jira.devtools.intel.com/browse/CVS-146283) --- .../src/transformations/convert_precision.cpp | 2 +- ...k_subgraphs_to_keep_in_mixed_precision.cpp | 71 ++++++++++++++++++ ...bgraph_to_keep_in_mixed_precision_test.cpp | 72 +++++++++++++++++++ 3 files changed, 144 insertions(+), 1 deletion(-) diff --git a/src/common/transformations/src/transformations/convert_precision.cpp b/src/common/transformations/src/transformations/convert_precision.cpp index 3c819d481bacee..ef1e815ab2fad1 100644 --- a/src/common/transformations/src/transformations/convert_precision.cpp +++ b/src/common/transformations/src/transformations/convert_precision.cpp @@ -560,7 +560,7 @@ bool fuse_type_to_range_v4(const std::shared_ptr& node, const precisio return false; const auto& to = it->second; if (auto range = ov::as_type_ptr(node)) { - if (to.is_integral_number() || to.is_real()) { + if (!fp16_compression_is_disabled(node) && (to.is_integral_number() || to.is_real())) { range->set_output_type(to); return true; } diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp index ef367571642eb2..769fa3c72870e9 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp @@ -13,13 +13,18 @@ #include "openvino/op/divide.hpp" #include "openvino/op/exp.hpp" #include "openvino/op/fake_quantize.hpp" +#include "openvino/op/greater.hpp" +#include "openvino/op/greater_eq.hpp" #include "openvino/op/interpolate.hpp" +#include "openvino/op/less.hpp" +#include "openvino/op/less_eq.hpp" #include "openvino/op/max_pool.hpp" #include "openvino/op/maximum.hpp" #include "openvino/op/multiply.hpp" #include "openvino/op/mvn.hpp" #include "openvino/op/normalize_l2.hpp" #include "openvino/op/power.hpp" +#include "openvino/op/range.hpp" #include "openvino/op/reduce_max.hpp" #include "openvino/op/reduce_mean.hpp" #include "openvino/op/reduce_min.hpp" @@ -78,6 +83,19 @@ void erase_fq_path(const std::shared_ptr& node) { rt_info.erase("fq_path"); } +void mark_range_path(const std::shared_ptr& node) { + node->get_rt_info().emplace("range_path", true); +} + +bool is_range_path(const std::shared_ptr& node) { + return node->get_rt_info().count("range_path"); +} + +void erase_range_path(const std::shared_ptr& node) { + auto& rt_info = node->get_rt_info(); + rt_info.erase("range_path"); +} + // Marking continues to propagate through these ops. const std::shared_ptr propagate_through_ops = pattern::wrap_type(); + + matcher_pass_callback callback = [=](pattern::Matcher& m) { + const auto& node = m.get_match_root(); + if (!node) + return false; + + auto range = as_type_ptr(node); + if (range && range->get_output_type().is_real()) { + mark_range_path(node); + disable_fp16_compression(node); + return true; + } + + bool is_changed = false; + + for (const auto& in_node_output : node->input_values()) { + auto input_node = in_node_output.get_node_shared_ptr(); + if (is_range_path(input_node)) { + mark_range_path(node); + disable_fp16_compression(node); + is_changed = true; + } + } + + return is_changed; + }; + auto m = make_shared(range_propagating_nodes, matcher_name); + register_matcher(m, callback); + } +}; + class PropagateMarkUpReduceOpPath : public pass::MatcherPass { public: OPENVINO_RTTI("PropagateMarkUpReduceOpPath", "0"); @@ -426,6 +495,7 @@ bool MarkSugraphsToKeepInMixedPrecision::run_on_model(const shared_ptrget_ops()) { erase_reduceop_path(node); erase_fq_path(node); + erase_range_path(node); } return false; // no need to revalidate diff --git a/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp b/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp index 95dfeae604e247..669d79ffbf6335 100644 --- a/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp +++ b/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp @@ -1087,6 +1087,78 @@ TEST(TransformationTests, MarkDivWithEpsToKeepInMixedPrecision_MinimalPatternUnc ASSERT_TRUE(result.valid) << result.message; } +TEST(TransformationTests, MarkFloatingPointRange) { + shared_ptr model, model_ref; + pass::Manager manager; + { + auto begin = Constant::create(element::i64, Shape{}, {0}); + auto step = Constant::create(element::i64, Shape{}, {1}); + + auto end = make_shared(element::i64, Shape{}); + + auto range_1 = make_shared(begin, end, step, element::f32); + auto range_2 = make_shared(begin, end, step, element::f32); + + auto convert_1 = make_shared(range_1, element::i64); + auto convert_2 = make_shared(convert_1, element::f32); + + auto unsqueeze_const = Constant::create(element::i64, Shape{2}, {-1, 1}); + auto unsqueeze = make_shared(range_2, unsqueeze_const); + + auto greater = make_shared(convert_2, unsqueeze); + auto convert = make_shared(greater, element::f32); + + auto multiply_const = Constant::create(element::f32, Shape{}, {1.f}); + auto multiply = make_shared(convert, multiply_const); + + model = make_shared(NodeVector{convert}, ParameterVector{end}); + + manager.register_pass(); + manager.run_passes(model); + } + + { + auto begin = Constant::create(element::i64, Shape{}, {0}); + auto step = Constant::create(element::i64, Shape{}, {1}); + + auto end = make_shared(element::i64, Shape{}); + + auto range_1 = make_shared(begin, end, step, element::f32); + auto range_2 = make_shared(begin, end, step, element::f32); + + auto convert_1 = make_shared(range_1, element::i64); + auto convert_2 = make_shared(convert_1, element::f32); + + auto unsqueeze_const = Constant::create(element::i64, Shape{2}, {-1, 1}); + auto unsqueeze = make_shared(range_2, unsqueeze_const); + + auto greater = make_shared(convert_2, unsqueeze); + auto convert = make_shared(greater, element::f32); + + auto multiply_const = Constant::create(element::f32, Shape{}, {1.f}); + auto multiply = make_shared(convert, multiply_const); + + // marking nodes to be kept in fp32 for mixed precision + disable_fp16_compression(range_1); + disable_fp16_compression(range_2); + disable_fp16_compression(convert_1); + disable_fp16_compression(convert_2); + disable_fp16_compression(unsqueeze); + disable_fp16_compression(greater); + disable_fp16_compression(convert); + + model_ref = make_shared(NodeVector{convert}, ParameterVector{end}); + } + + const FunctionsComparator func_comparator = + FunctionsComparator::with_default().enable(FunctionsComparator::RUNTIME_KEYS); + // need to compare twice to ensure that no extra nodes are marked + FunctionsComparator::Result result = func_comparator(model_ref, model); + ASSERT_TRUE(result.valid) << result.message; + result = func_comparator(model, model_ref); + ASSERT_TRUE(result.valid) << result.message; +} + TEST(TransformationTests, MarkDivWithEpsToKeepInMixedPrecision_InL2NormWithSqrtAndWithMax) { const float eps_value = 1.e-12f; shared_ptr model, model_ref; From 17fa918f1868c4c80e8395149d4b8a98ff8d0f5e Mon Sep 17 00:00:00 2001 From: Damian Kurek Date: Mon, 19 Aug 2024 11:32:03 +0200 Subject: [PATCH 038/117] [GPU] Improve Group Normalization BFYX OPT reductions (#26098) ### Details: - Improve Group Normalization BFYX OPT kernel performance - Simplify code - Use work group functions - Drop usage of local memory which is not needed anymore - Removed SLM_SIZE for improved host performance and smaller code size ### Tickets: - 149951 --- .../group_normalization_gpu_bfyx_opt.cl | 28 +++---------------- .../group_normalization_kernel_bfyx_opt.cpp | 2 -- 2 files changed, 4 insertions(+), 26 deletions(-) diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/group_normalization_gpu_bfyx_opt.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/group_normalization_gpu_bfyx_opt.cl index ed943c65d5a67e..498b5c8fb80339 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/group_normalization_gpu_bfyx_opt.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/group_normalization_gpu_bfyx_opt.cl @@ -36,8 +36,6 @@ KERNEL(calc_mean_per_feature)( const uint x_base = get_local_id(0); const uint x_leftover = INPUT0_SIZE_X - x_num_workers * x_block_size; - __local ACCUMULATOR_TYPE mean_per_feature[SLM_SIZE]; - ACCUMULATOR_TYPE mean = ACCUMULATOR_VAL_ZERO; #if INPUT0_DIMS == 5 @@ -120,18 +118,10 @@ KERNEL(calc_mean_per_feature)( #endif const uint worker_idx = get_local_linear_id(); - mean_per_feature[worker_idx] = mean; - uint reduce_add_level = 1; - while (num_local_workers > reduce_add_level) { - barrier(CLK_LOCAL_MEM_FENCE); - if (worker_idx % (reduce_add_level * 2) == 0 && (worker_idx + reduce_add_level) < num_local_workers) { - mean_per_feature[worker_idx] += mean_per_feature[worker_idx + reduce_add_level]; - } - reduce_add_level *= 2; - } + mean = work_group_reduce_add(mean); if (worker_idx == 0) { - mean = mean_per_feature[0] / TO_ACCUMULATOR_TYPE(INPUT0_SIZE_Z * INPUT0_SIZE_Y * INPUT0_SIZE_X); + mean = mean / TO_ACCUMULATOR_TYPE(INPUT0_SIZE_Z * INPUT0_SIZE_Y * INPUT0_SIZE_X); internal_mean[bf] = mean; } } @@ -189,8 +179,6 @@ KERNEL(calc_var_per_feature)( const uint x_base = get_local_id(0); const uint x_leftover = INPUT0_SIZE_X - x_num_workers * x_block_size; - __local ACCUMULATOR_TYPE var_per_feature[SLM_SIZE]; - const ACCUMULATOR_TYPE mean = internal_mean[bf]; ACCUMULATOR_TYPE variance = ACCUMULATOR_VAL_ZERO; @@ -284,18 +272,10 @@ KERNEL(calc_var_per_feature)( #endif const uint worker_idx = get_local_linear_id(); - var_per_feature[worker_idx] = variance; - uint reduce_add_level = 1; - while (num_local_workers > reduce_add_level) { - barrier(CLK_LOCAL_MEM_FENCE); - if (worker_idx % (reduce_add_level * 2) == 0 && (worker_idx + reduce_add_level) < num_local_workers) { - var_per_feature[worker_idx] += var_per_feature[worker_idx + reduce_add_level]; - } - reduce_add_level *= 2; - } + variance = work_group_reduce_add(variance); if (worker_idx == 0) { - variance = var_per_feature[0] / TO_ACCUMULATOR_TYPE(INPUT0_SIZE_Z * INPUT0_SIZE_Y * INPUT0_SIZE_X); + variance = variance / TO_ACCUMULATOR_TYPE(INPUT0_SIZE_Z * INPUT0_SIZE_Y * INPUT0_SIZE_X); internal_variance[bf] = variance; } } diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp index 069e2abbe9a1cf..806fdfa77755d2 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp +++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp @@ -125,7 +125,6 @@ JitConstants GroupNormalizationKernelBfyx::GetJitConstants(const group_normaliza if (params.has_dynamic_tensors()) { jit.AddConstants({ - MakeJitConstant("SLM_SIZE", params.engineInfo.maxWorkGroupSize), MakeJitConstant("GWS0", "get_global_size(0)"), MakeJitConstant("LWS0", "get_local_size(0)"), MakeJitConstant("LWS1", "get_local_size(1)"), @@ -133,7 +132,6 @@ JitConstants GroupNormalizationKernelBfyx::GetJitConstants(const group_normaliza }); } else { jit.AddConstants({ - MakeJitConstant("SLM_SIZE", (dispatchData.lws[0] * dispatchData.lws[1] * dispatchData.lws[2])), MakeJitConstant("GWS0", dispatchData.gws[0]), MakeJitConstant("LWS0", dispatchData.lws[0]), MakeJitConstant("LWS1", dispatchData.lws[1]), From 54b79bb5289cd00c2b0d71eef9b4df42d8877256 Mon Sep 17 00:00:00 2001 From: Ivan Novoselov Date: Mon, 19 Aug 2024 12:14:48 +0100 Subject: [PATCH 039/117] [Snippets][TPP] Fix ov_cpu_unit_tests build & status for LIBXSMM (#26095) ### Details: - *Fixes `Linux CPU Plugin Snippets with LIBXSMM` GHA job* - *Fixes BrgemmBlocking unit tests when the `ENABLE_SNIPPETS_LIBXSMM_TPP` is set* ### Tickets: - *-* --- .../dev_cpu_linux_snippets_libxsmm.yml | 2 ++ .../intel_cpu/tests/unit/CMakeLists.txt | 7 +++++ .../x64/lowered/brgemm_blocking.cpp | 29 ++++++++++++------- 3 files changed, 28 insertions(+), 10 deletions(-) diff --git a/.github/workflows/dev_cpu_linux_snippets_libxsmm.yml b/.github/workflows/dev_cpu_linux_snippets_libxsmm.yml index a259c8e5fb33e4..17c40b94265b4f 100644 --- a/.github/workflows/dev_cpu_linux_snippets_libxsmm.yml +++ b/.github/workflows/dev_cpu_linux_snippets_libxsmm.yml @@ -11,6 +11,8 @@ on: - 'src/plugins/intel_cpu/src/emitters/tpp/**' - 'src/plugins/intel_cpu/src/transformations/snippets/**' - 'src/plugins/intel_cpu/src/transformations/tpp/**' + - 'src/plugins/intel_cpu/tests/unit/snippets_transformations/**' + - 'src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/**' concurrency: group: ${{ github.event_name == 'push' && github.run_id || github.ref }}-linux-cpu-dev diff --git a/src/plugins/intel_cpu/tests/unit/CMakeLists.txt b/src/plugins/intel_cpu/tests/unit/CMakeLists.txt index 24a0b490e76936..a3cf33c347ffb8 100644 --- a/src/plugins/intel_cpu/tests/unit/CMakeLists.txt +++ b/src/plugins/intel_cpu/tests/unit/CMakeLists.txt @@ -66,6 +66,13 @@ ov_add_test_target( OV UNIT CPU ) +if (ENABLE_SNIPPETS_LIBXSMM_TPP) + add_definitions(-DSNIPPETS_LIBXSMM_TPP -DLIBXSMM_DEFAULT_CONFIG) + target_compile_definitions(xsmm PRIVATE __BLAS=0) + target_link_libraries(${TARGET_NAME} PRIVATE xsmm) + target_include_directories(${TARGET_NAME} SYSTEM PRIVATE $) +endif() + # LTO set_target_properties(${TARGET_NAME} PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE ${ENABLE_LTO}) diff --git a/src/plugins/intel_cpu/tests/unit/snippets_transformations/x64/lowered/brgemm_blocking.cpp b/src/plugins/intel_cpu/tests/unit/snippets_transformations/x64/lowered/brgemm_blocking.cpp index dfae3be2a73946..a0ec6c931a9420 100644 --- a/src/plugins/intel_cpu/tests/unit/snippets_transformations/x64/lowered/brgemm_blocking.cpp +++ b/src/plugins/intel_cpu/tests/unit/snippets_transformations/x64/lowered/brgemm_blocking.cpp @@ -3,11 +3,12 @@ // #include "transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp" -#include "transformations/tpp/x64/pass/lowered/brgemm_tpp_blocking.hpp" +#ifdef SNIPPETS_LIBXSMM_TPP + #include "transformations/tpp/x64/pass/lowered/brgemm_tpp_blocking.hpp" +#endif #include "lir_test_utils.hpp" #include "openvino/opsets/opset10.hpp" -#include "snippets/lowered/linear_ir.hpp" #include "snippets/lowered/loop_info.hpp" #include "snippets/snippets_isa.hpp" #include "transformations/snippets/x64/op/brgemm_copy_b.hpp" @@ -24,14 +25,21 @@ using namespace ov::snippets; using BRGEMM_TYPE = intel_cpu::brgemm_utils::BRGEMM_TYPE; namespace { - -SpecificIterationHandlers get_k_loop_handlers(size_t work_amount, size_t block_size) { +enum class BACKEND_TYPE{CPU, TPP}; +SpecificIterationHandlers get_k_loop_handlers(size_t work_amount, size_t block_size, BACKEND_TYPE backend = BACKEND_TYPE::CPU) { auto handlers = BrgemmBlockingBase::get_default_blocking_loop_handlers(work_amount, block_size); + switch (backend) { #ifdef SNIPPETS_LIBXSMM_TPP - handlers.register_pass(); -#else - handlers.register_pass(); + case BACKEND_TYPE::TPP: + handlers.register_pass(); + break; #endif + case BACKEND_TYPE::CPU: + handlers.register_pass(); + break; + default: + OPENVINO_THROW("Unsupported code generator backend type"); + } return handlers; } @@ -39,7 +47,8 @@ void create_brgemm_loop_infos(const LinearIRPtr& linear_ir, const ExpressionPtr& brgemm_expr, size_t m = 0, size_t m_blk = 0, size_t k = 0, size_t k_blk = 0, - size_t n = 0, size_t n_blk = 0) { + size_t n = 0, size_t n_blk = 0, + BACKEND_TYPE backend = BACKEND_TYPE::CPU) { const bool k_block = k != 0 && k_blk != 0; const bool n_block = k != 0 && k_blk != 0; const bool m_block = m != 0 && m_blk != 0; @@ -49,7 +58,7 @@ void create_brgemm_loop_infos(const LinearIRPtr& linear_ir, std::vector{LoopPort(brgemm_expr->get_input_port(0)), LoopPort(brgemm_expr->get_input_port(1), true, 1)}, std::vector{LoopPort(brgemm_expr->get_output_port(0), false)}, - get_k_loop_handlers(k, k_block)); + get_k_loop_handlers(k, k_block, backend)); linear_ir->get_loop_manager()->add_loop_info(loop_info); } if (n_block) { @@ -328,7 +337,7 @@ TEST_F(BrgemmTPPBlockingTest, TPPFloating) { layout_a, layout_b, layout_c); const auto& brgemm_expr = *brgemm.first; init_expr_descriptors(brgemm_expr, {{m_blk, k_blk}, {k_blk, n_blk}, {m_blk, n_blk}}, {layout_a, layout_b, layout_c}); - create_brgemm_loop_infos(linear_ir_ref, brgemm_expr, 384, m_blk, 1024, k_blk, 384, n_blk); + create_brgemm_loop_infos(linear_ir_ref, brgemm_expr, 384, m_blk, 1024, k_blk, 384, n_blk, BACKEND_TYPE::TPP); brgemm_expr->set_loop_ids({2, 1, 0}); auto result = linear_ir_ref->push_node(brgemm.second); } From 2b919e180198f663273b26c8eb0cb185a393ae1e Mon Sep 17 00:00:00 2001 From: Sofya Balandina Date: Mon, 19 Aug 2024 12:26:26 +0100 Subject: [PATCH 040/117] Update IR version for conformance tests (#25984) ### Details: - *Version of IR package is moved to [2023.3.0](https://storage.openvinotoolkit.org/test_data/conformance_ir/2023.3.0-13657-d5b0f4d2d73.tar) for actions tests* --- .../layer_tests_summary/data/models.lst | 2 +- .../github/cache/CPU/test_cache_OP.lst | 10694 ++++++++-------- .../skip_configs/CPU/expected_failures_OP.csv | 445 +- 3 files changed, 5262 insertions(+), 5879 deletions(-) diff --git a/src/tests/test_utils/functional_test_utils/layer_tests_summary/data/models.lst b/src/tests/test_utils/functional_test_utils/layer_tests_summary/data/models.lst index 3f517d20061dbb..6ae099e9196e92 100644 --- a/src/tests/test_utils/functional_test_utils/layer_tests_summary/data/models.lst +++ b/src/tests/test_utils/functional_test_utils/layer_tests_summary/data/models.lst @@ -1 +1 @@ -https://storage.openvinotoolkit.org/test_data/conformance_ir/2023.3.0-13657-d5b0f4d2d73.tar \ No newline at end of file +https://storage.openvinotoolkit.org/test_data/conformance_ir/2024.3.0-15913-e4cfd8f2edd.tar \ No newline at end of file diff --git a/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/cache/CPU/test_cache_OP.lst b/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/cache/CPU/test_cache_OP.lst index 7e00aa09e2d998..180b256128960c 100644 --- a/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/cache/CPU/test_cache_OP.lst +++ b/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/cache/CPU/test_cache_OP.lst @@ -1,5631 +1,5069 @@ -849647:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=() -731668:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=2f842d4b64513c6df5748c54a1166a3f14436dc1ca59b7a28530bcafcdcde2f6_Device=CPU_Config=() -635397:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=() -456010:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=c20603ac895226554bc910680f6be82589e053503b3067b3074bcc210f4d0ef2_Device=CPU_Config=() -446637:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=214e4e8f7de64e9cc8c77c67d214172905cfb4b9fde65e2ef3d32bb7b4ed93f1_Device=CPU_Config=() -441629:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=dynamic_IR=0b30cc6cee9ce5400085a0e78b44763bc169eeea93357f22fd716564f20226db_Device=CPU_Config=() -396559:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=72c58b462f61521af4eab9c890e568b5676c7a3194c4e35f8e04f98596013c47_Device=CPU_Config=() -396011:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a9b0552d84d057a656080c8e302afa30962dc02105abe7136cfd77f0433eec18_Device=CPU_Config=() -395765:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=3d24c272ca88d4ee24f437a310abc05340e110f8596beb6a1ef96dd18818ebbe_Device=CPU_Config=() -393035:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=b31dbb99720fd5083e5a7e5b1b626bda91455999e2918eb8e658992cfa6588dc_Device=CPU_Config=() -374552:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=396388d4dce8240937c39dcd24e583e775f7b4e84d6c85fa9b5930588dfb9b56_Device=CPU_Config=() -338843:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=77d771a04d8618bf32943e460b714076f7bbc34cd1d40f9a90864af976bea30e_Device=CPU_Config=() -270513:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=() -256725:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=6daca83f4b162285c00c695825e255cbafce9cf9c9cea68b969a301105475303_Device=CPU_Config=() -208248:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=97f6fd9998be395222e6878ccaab47f5d50561d1ab8f988987f7f292e784fe2d_Device=CPU_Config=() -189998:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=5bed52483d61091259db863ffcd3b09c190fedde5dac72edad6f1bf37230f344_Device=CPU_Config=() -185722:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=04e25f2a56de557c8da87110ba02c02ae45277d029964d932fe6837acc0f1b10_Device=CPU_Config=() -172531:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=() -161595:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=327d5120022c693531fe0f1f42429b1ad78f36cd5e414f1c8bab7d0c2ced62f7_Device=CPU_Config=() -156520:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=9d4ebc5a7d195ea0e566695253c38ac5d02fea1f4fbe97396828ef9f7754808a_Device=CPU_Config=() -151346:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e0f4f91a6470af49c5e2497ae8fa917051879c18dd1e39cae18d159b697e8fec_Device=CPU_Config=() -138107:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=2cc50ee05a039bf65fd7be2282284790d9d2e1fabb4cfec509f5bed121152d93_Device=CPU_Config=() -129459:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6eeea9355df867c7fc97af81dae6d02799239ec1e480dc2c975a60761fc5f7be_Device=CPU_Config=() -124864:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d99c03088bad009d9be7f29ec5bad7e3b6c7534fe2649f9670b6f713bf017e7e_Device=CPU_Config=() -122520:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=b7a53df966d640f075cea7421ca5989ca91ca638e7af16aff33bc275eb7dfe9c_Device=CPU_Config=() -117935:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=2538d525d8f11b9f4961c2a4a8cc36fd27d8b3d97271ef7db4f7eac9732b71f4_Device=CPU_Config=() -109657:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4baf5444c85028a4cfdedc5888a7cd403e2491ab694ab65c820dd3c410f8eafb_Device=CPU_Config=() -108857:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=cf334277b64fe023019fb7f007aae9ebf7432b733a1876d6cd61bce6a204e0dd_Device=CPU_Config=() -108610:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=08fa156c3f25fc8836356fd1a8edb73222f9fe2b3476c0ae32a26636b5870247_Device=CPU_Config=() -95941:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=() -85631:conformance_LogSoftmax/ReadIRTest.Inference/Op=LogSoftmax.5_Type=f32_Shape=static_IR=38bcc7d745ee21a7c6858a161e269f0281d3f41d62d65d10fde9b0a9b80992c4_Device=CPU_Config=() -82193:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=7d3d30fa9e2a8a839cf42249de3eb8228681229e8b302ff7f290cc0d00c10a1a_Device=CPU_Config=() -81468:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=() -78474:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=() -72738:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2006e1eaa808a3e78550535058de54c5cd83e9a32a52e488fef1f7883c321a3_Device=CPU_Config=() -70803:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=6838901bafb44e26f73134e2c0eb2be8f1f777ab794ae340d61b62d891ff3d59_Device=CPU_Config=() -70509:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=27d1a1cfdbadd9a8c2d0269f6177d6aabd55320aafe9a0047e90681dcad1cbe9_Device=CPU_Config=() -68993:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=59c0e972ae75900cd8c802aa7be9b6c13c96cb10417ff417eb1aafbc49b891ea_Device=CPU_Config=() -67199:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=() -63154:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=dynamic_IR=a99a5ab2de2d408c2e40ad5734c9bd5ab4d1d221f4dd24572e05538b134ef88c_Device=CPU_Config=() -62584:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5c33d593e408ad72bf438729a423318330c69c69f1504402420635942050ac06_Device=CPU_Config=() -62058:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6e9fb2accb692c69349a88158442052e6350143ca7dc28f2525d8e8df29f8c78_Device=CPU_Config=() -59834:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a78437a93ab424a706d064188d1bc0971b2e1afc98a74fea979a6f8b99036597_Device=CPU_Config=() -55761:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b04f836c4ed5b0403f4b7fdf9c5cb8d11ff9f65105ab9bde39f80191a65f7f17_Device=CPU_Config=() -55653:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c5637c5151109c002830514b8b1450092dc52df14146ecee467dc54469a77718_Device=CPU_Config=() -52008:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=978c6fe274296020718998393e7fe94bbe0a0856fc377aa474df0454534824a6_Device=CPU_Config=() -52005:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=92c3646daf445784fceeb022afba2831938fed34660bac5445f033a1efdccc34_Device=CPU_Config=() -50210:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=bb5cb4e2a8cb9be32332ed3255c99de478d8d2e31cfb1747aa322df438ebaa49_Device=CPU_Config=() -49713:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1457b3d8c7f130113d74f540dfbd2d4062f869018f7b1afb11c743acc0a007b9_Device=CPU_Config=() -49506:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=28e31d83986a1435f11ba6355b98472025fcf2c3c6e090103283d9486356b5de_Device=CPU_Config=() -48827:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6bbd8d7f90e7c210514c28d527eb33bf0889b1fafbd5cf7d9660532f5d6bd940_Device=CPU_Config=() -48749:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e27f0bcb3118a7cdb488f4685707bec982ae54ff8bf7e97aff9ea6ecedd66714_Device=CPU_Config=() -48376:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=29d8ef1a41f51b6fed0300f97d17a3795a97e4ffb3ef3abda37f790f5f53b389_Device=CPU_Config=() -45924:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=59d132b45e2ac60a670eb43efafa43f065bb43d492208ac670fc8234b4f618c9_Device=CPU_Config=() -44983:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=6119edc6e1f969159ce54e6ff4451d96db51485b54fae625a972035414c704ef_Device=CPU_Config=() -44976:conformance_LSTMSequence/ReadIRTest.Inference/Op=LSTMSequence.5_Type=f32_Shape=static_IR=b8e32896d2ab304fb4fdca3924e0110852da92be25307f30709cd7d897c2f038_Device=CPU_Config=() -44579:conformance_LSTMSequence/ReadIRTest.Inference/Op=LSTMSequence.5_Type=f32_Shape=static_IR=1f24aeeef6f9f91272546fca89299c1ce448b0008fe43905db434ae3f28a75d0_Device=CPU_Config=() -44495:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=dynamic_IR=f550a37ab884668f47ed232e7119c2a2baa814c98fbbcfa3129e7a00feebde0b_Device=CPU_Config=() -42892:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a05c6778a396b4eb89a5e112fe505a41f47ff6bef50fa025eee1dfb7ec6a95e7_Device=CPU_Config=() -42101:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=dynamic_IR=848de524e27e13a1e5b33e5db3cdf2710ba4566c3219a018e878f998c07dd718_Device=CPU_Config=() -40769:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f13ce39b60cc25991465a0c02e27edcb35af0523cd28004adf6fd9acd8a5fcb8_Device=CPU_Config=() -40683:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=ca0d551f3da549b28475d996906bfa5202402be286f59f9bf53ac809c9fceb49_Device=CPU_Config=() -40680:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3f830d5ee243ca3f56d027f95929bbadd427e4954e286e6c890ddd60f9c5c2d0_Device=CPU_Config=() -39521:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=6289232b1cbbafc963ac3cd787330c81a9cd02def9fefb83d6f6cced249de92f_Device=CPU_Config=() -38647:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=31ce051edcf02344a693eb2d200fa02b53412a5707faaffc2907cadcf81192f4_Device=CPU_Config=() -37717:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=29c89ebfa45163b40be304d7bfc96f3068cd96175db94e6ebda942d3c4af538f_Device=CPU_Config=() -37206:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=74f34c8b7abfe0f7afe021ba5d4861e29f9f3915beba5cdb2af936f1f2409fb6_Device=CPU_Config=() -32780:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6b86bf4f834b297dcb461acb5854aeb9783a381521ea1a8e1cf4fbeb60d6d09b_Device=CPU_Config=() -32716:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=() -32707:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=40c74727a381659b1343c4083d7f903ac2519d5297703fd15979a32f820adfcb_Device=CPU_Config=() -32456:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e4be028a5a300682b79da2f015dd1c1b13381b38b19bb76951e1f26439173212_Device=CPU_Config=() -32446:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e62245706f4242ff86bcb70d4d221bf49aa31db3807698d574125166bff5f8aa_Device=CPU_Config=() -32265:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=ccef47523d9134720116dbd4a37d5038c9d15e2c393ccf1a6d24c3790529c282_Device=CPU_Config=() -31838:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2ca34430931dd41f08f2b3cb8163ea5c1889a23b53d0f3b7d26b7a8af1acef3_Device=CPU_Config=() -30604:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8c773c776396a2ff506691f857349efa9a4a580f1e046d1f17ff2ab49c73553d_Device=CPU_Config=() -29187:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e58cf21c9c62dd427747021dcf9544157638e0773329eecfb8755a71b24f65a8_Device=CPU_Config=() -27559:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=2f7925a034999529ce07a5c8bed2b2c7aeeb7936f74730d9c8ca5a5086dea4cd_Device=CPU_Config=() -27187:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cbd851b8c4e89bce3a20b8795b3bc5a0105d26e252a4674541ff630496144aaa_Device=CPU_Config=() -26806:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b3fdb9be3484a0c498bf40f1a102c452eea04caa5b1dd627e8267087df0acc87_Device=CPU_Config=() -26668:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7d706b614d2b5d59c5e152bbb61a8fd558686bb3b8e9fda199c499ca49f03042_Device=CPU_Config=() -26456:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=7625f5af6c70a9d4bccb783dc369a11b53ef1f6492df030ae5404452ea0cdc79_Device=CPU_Config=() -25831:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=b7aebb27d8d2b43e770ade887778c291072210b947b77b1b92e05d3327843977_Device=CPU_Config=() -25671:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d16722dfa770998d9923d09fa1e2a973bac5ae7afc6452a0b5ac21d839720bb4_Device=CPU_Config=() -25633:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8710c3eaa10d25119059f4e15970d8a6381f978cd905fc8eb1b4d43a36d1d5f6_Device=CPU_Config=() -25404:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d6d8f4f28ac34b734cc984f83e8f5f6598c063a6955d00ef4c08252d5d05c276_Device=CPU_Config=() -25192:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=66df22ce11e7009aea35ba6a11b4294eda44815bf041eed0721499a3d2c484b1_Device=CPU_Config=() -25026:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d962e7157ea216206d6c5b11fe5ef6ee162a1f7dc20f84a3b058e405c324a592_Device=CPU_Config=() -24415:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=12b6ad1cd462f676c9add533f2fb2a5d98698e72fc5d0e6dc984abb27f54475d_Device=CPU_Config=() -23343:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=() -22724:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=10c19142631a9ac6d8026ec82820aa75ba1e14605fe5ea1e017fa4bde4a90c44_Device=CPU_Config=() -22581:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=074ab76268ab5d03283f03f4e228a7cf73ab5a18fc0e7366778cf8c45286f18a_Device=CPU_Config=() -22370:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2ef3273b8c144dedd6cc2d2b8c2d2921d999fa286b10d90aa796fa188dc52cef_Device=CPU_Config=() -22356:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=8e098b9c129ab30efc257d55cfbc737d990d2ff0f7931039d3335c42d5f286eb_Device=CPU_Config=() -22117:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f2eb693da69b0ad1af3bcef6c4af46ba2b92897f76989c310a65aac5c2027725_Device=CPU_Config=() -22044:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=9a26ec9d1e0c4963016ff36986c79f5faed763ca5189215923d375e43c70a17c_Device=CPU_Config=() -22028:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0182ad6b02d77803accd2ebe55d87b679950570d1dcfef2940adcbb5fb9f1a24_Device=CPU_Config=() -21992:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=030fa97d19aab57ae9eb898fe101353fdc76bbc034d4574971c68ef254006c85_Device=CPU_Config=() -21939:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e250a19bfbe236f81b6715a92beb0c259080e4a5d379ea1187892e8c8d9add8a_Device=CPU_Config=() -21548:conformance_ReduceMax/ReadIRTest.Inference/Op=ReduceMax.1_Type=f32_Shape=static_IR=a3b350b1516cb0391e088317ea67433757a08847710c4a4bff143922873208df_Device=CPU_Config=() -20799:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=f45b24f3bf21a2c94bc89cdc3d20c283d47f4e6ea386444897330e232bd7d90f_Device=CPU_Config=() -20662:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=355bfa53a1f9e712db4df6642a51970e96e3612583b2ec90e7a8170e45b1625c_Device=CPU_Config=() -20314:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a76c4cc0a1f2294a3ceb18dd5d214d842cf37c08d2e34770c66c29b44ee92e48_Device=CPU_Config=() -20067:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=df19449b7a95887e834ba16ebf2e1f08416d6293686a6cb6b6cf39fc82559595_Device=CPU_Config=() -19334:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=65a5483c793396983edaf7f2cc2c13898507525bd84a8469e97b2d662b5df782_Device=CPU_Config=() -19317:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b91f26a0b7b56224c507de772631016119cd0bc3fd49527013f571e2db477402_Device=CPU_Config=() -19108:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=50a0e83d438a3220ed14dd8ae783e92c96381f645b10719669054ea944297244_Device=CPU_Config=() -19056:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=99866ef63c9a2e7e2d9b7f00d11a4c177775bef9cfdf074e83f56318c143e6a3_Device=CPU_Config=() -19032:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7b1df1422bfecf1fdf9c25f72d938950cb1492ee1c7223d9c0d771f93b1fbdb8_Device=CPU_Config=() -18804:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5adf6fcb72c0d6086a95fbbc5744e7d02dfb32490e0f42c62b57bc98489b801c_Device=CPU_Config=() -18330:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=dynamic_IR=85a35059512fed9e0c70cdcbd5e73c1e247ef97821d5193cbc4f7f7c3ebbaef8_Device=CPU_Config=() -18149:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=() -17854:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=67ed6a8048424f4e44f40c542faf7a2a2d2419e81aa982fe32a054af05caf309_Device=CPU_Config=() -17283:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=89dcb383b48e2a4423a7c81461f282b74b1d9ab0f48f0a0427cd4c599672f3fb_Device=CPU_Config=() -17094:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cdc57df56ccf890a00f886c3b83f504d24ea9d4ed5f0ef05f1189879172777f8_Device=CPU_Config=() -17045:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3374f930d0ffd26ccd7cb542638f2386ae5f803b5bdce4d848ba1e93b4a173a8_Device=CPU_Config=() -16722:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=970f3f48203f3bd46dcd6ca55ad20f5ff8ad2426c3f6f74377759fdddaaf93cc_Device=CPU_Config=() -16608:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=07849f3111a0f12a712cb0deb7ec9c4778e70120385bdff7f17c1af30e31062c_Device=CPU_Config=() -16595:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d2d4814c8ab7cbe5107a556fb3e73998aafae0278b0d304fa07fc4ac9fad4559_Device=CPU_Config=() -16560:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=42fc9a4f8909a26e98a1938054417339bbc3c21668dfa2792da78fa1ed8eb49b_Device=CPU_Config=() -16417:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6017d3f7ee3d7e667e8e7e4881f9aae335d47c8617c92b18ec370aa0770314d9_Device=CPU_Config=() -16215:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9360fbacf32f2208bd7f241535752ccaf434551d16bd8fd46d0422cd1cafc3c6_Device=CPU_Config=() -16210:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=61f6b4fbde686888b82614a5d24cac53e835377c4cfa791ace3f3cd3f8ac2dd8_Device=CPU_Config=() -16028:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=37ed85c113d481da6d55c0a820d49090a8b256694e0f1b111feded60fe708279_Device=CPU_Config=() -15403:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f9b090cbcb19663630a1490fe18357b752e430ad793c0e3aaabedcb74ab64934_Device=CPU_Config=() -15230:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=b9581fac6848b0c6c9fc9af5fd17eca3f2f64832fb7205f97684f1cc4c1985f0_Device=CPU_Config=() -15180:conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=() -14925:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=29eeefa6ea54ff2530e2e17153db324026e85d4e45432c053ca066699187bbc5_Device=CPU_Config=() -14748:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8de274a65748ff76511a53b614cfb33651d2b51720714851a16976fc1ee2b6ea_Device=CPU_Config=() -14304:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e23a8faab46e1096894a906794325ff1a8c6001d3b980aa809088385675c77ed_Device=CPU_Config=() -14151:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a0f8789f0f95beb6f28efc829bdf2f99d34a3e9397ad1a80d7831aaaf125b5eb_Device=CPU_Config=() -14057:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c80a104f5912c91154ff9731be5aaf1ce189988eb9689ebc32cf4bb8f1307615_Device=CPU_Config=() -13911:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7caba2dff8ab10660f66796a39d8d2a78f3e282f0629c2ecbee9b90c34e62aa0_Device=CPU_Config=() -13718:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=fcab2b4b3bf1a04070e3fd3490e6317f2d6870335d302d96c768f40da8565c8d_Device=CPU_Config=() -13664:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d9b3427efacda497c4fb86cebe89023b322722167d0c32de8a2602a80b23580b_Device=CPU_Config=() -13656:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=() -13630:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=59bac5d30704b81def0385b29fb8d79e459a71b9251b4f6e94116524bd9aa7be_Device=CPU_Config=() -13600:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=78a5e7f340d63660dc0710d0e390dea2d3f68ac98f16e8dbc11b4c28ac0440e0_Device=CPU_Config=() -13576:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a1e0bbe02c433cb144b4825a9f1b2c30c03743f210830db5462736850b6db383_Device=CPU_Config=() -13571:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=3866cad522b1a4da567b64df204a69863faf25dd6e09f85dc5806d3101689458_Device=CPU_Config=() -13536:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7d3a099a5040e70c73014df347c478d0976123d68b6fcab6bf767f90bbdf8e6a_Device=CPU_Config=() -13455:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2e06088cb191d8d26309843b1285b9ae4a1eb0722e1370875edde7fd2783851b_Device=CPU_Config=() -13422:conformance_ROIPooling/ReadIRTest.Inference/Op=ROIPooling.2_Type=f32_Shape=static_IR=1a0e3f63698678d2e6bb8968fbadc98227d9ce548e77c53021412d80d7711753_Device=CPU_Config=() -13340:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c39e4c1d9cbf5b8730644e1686cc09f36f7e4a4b89cadaf8d8902fdb27993a7a_Device=CPU_Config=() -13301:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4772901ff77541ae624f89db89901c7d5a502a0dc5d1e0dc21eb8e08c599525_Device=CPU_Config=() -13259:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=776ce5493890837f137a7abc7851ff04164468d7c13ef1022f73f1f68e058c1c_Device=CPU_Config=() -13216:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8ad9f9e5cb26eb922d7d7d80f93be2e9d3a5ef344a013c9dd546df2ef195ec24_Device=CPU_Config=() -13112:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=42f3f3a5b34aacb93147f9c77ad5709cf7436ae8cad9318434a9b6ff6852982d_Device=CPU_Config=() -13108:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d46034925bf5b01e31b5a57911fe30f5dd09a8712432312fb1efd844e69913bf_Device=CPU_Config=() -13078:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0fb6a7848271e000d49d4966647edf55e65f181523883089f43147c14cfb9871_Device=CPU_Config=() -13042:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=dynamic_IR=0f5965e2daa2a1f6b050813850956d9a4bbd771cb234ec814617099e1541ea0c_Device=CPU_Config=() -12852:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d4b1dbc565a45f6c9f60cd4a73bb15c0f9e05baadfd3acdcd5e133d782c54cbb_Device=CPU_Config=() -12629:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6d71ec3285f12c65001e4396546f6c8c02215560675397656d85777f0c9c2644_Device=CPU_Config=() -12604:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f8795aaaf3fb96028b8cdcc963cbdff4c3362d78c4801af4172a73a3cd843edc_Device=CPU_Config=() -12589:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=e77dc4aecdbd4ab3d67fc3c1d9e350a9d259af1d4c0188d680121a31c6ed8ccf_Device=CPU_Config=() -12588:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5f45e938f9e6d58ccc6bf771049731f2d9c4a8b0ed83e2a1942ac69ab76984b3_Device=CPU_Config=() -12584:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=776b4b6d6b102654bbc08df901869e4d16af505a5dff7f2d27686874bd20ccc1_Device=CPU_Config=() -12561:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=beb6b43d96ce20db13ecf6abc53742fdc20d2221ea66af01e3c945348acf9bd4_Device=CPU_Config=() -12431:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3c0b9fab07568e0eebb5e5d068cfccdd617ee6e98e4253a0461ea8d3f0f582e8_Device=CPU_Config=() -12372:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=7201a55d869ac6072af38ff89dfac3cfd2e6720d25f7607c6cc5f80040a8e82a_Device=CPU_Config=() -12364:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b2ca18b9d9f9e7c05f66a1f197b65ef9ca1d59319ed5f30d4eadf6f8befcd9bf_Device=CPU_Config=() -12352:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=008176749f0b2cb46830abe910865d8cf1974cd62902ce3e157a03df2b1cf9c3_Device=CPU_Config=() -12342:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=243bd2256612673dd04651521ed8d3fa4087c90af7b85e1a4aa381c074bacd47_Device=CPU_Config=() -12328:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d8fc538fc2b9ca150eb22763e4c7416c002b5c7fa6481314201540178e940a78_Device=CPU_Config=() -12304:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=28bb0064e4cb56c497227ec69899b08dc09cccbf7d390555416aff617a393f81_Device=CPU_Config=() -12224:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=225aaa01462e6e43c0c12cff65f96e7d9c07d368a820ff3c1b2939fefe86d492_Device=CPU_Config=() -12068:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6e508ca44667fb311f5b6d634584d2751c3fb15fc034626765c90695b7de9619_Device=CPU_Config=() -11931:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=64efb6dd46c36bec02b92148d178bc032417c8c2d999ff7b0a24ba08af365f91_Device=CPU_Config=() -11786:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=83e2d01e24eebe910418ed24fb506852c37576ce70c18d27de197f675f49c9d2_Device=CPU_Config=() -11515:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=eca24a51b737307a94a918f4d03923c1e035a3379c73359515c63ff3ea98be85_Device=CPU_Config=() -11406:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=780fe1f9a82f728f88511b2d8194c4f425144ffb5ae4aaeb1ce90c6fdea3362a_Device=CPU_Config=() -11018:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f82842bfa510be994f17d9c00d43b6f67b232b3a41c64ae276e243610d927d9_Device=CPU_Config=() -11009:conformance_LSTMSequence/ReadIRTest.Inference/Op=LSTMSequence.5_Type=f32_Shape=static_IR=981b213f0fd1305e70515849fd08553471da63e6bf64827a47cc475fd4ed9561_Device=CPU_Config=() -10912:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e77468c2881ce0c38c14038151d560ccadc7dcbd5eb5f21b68b8e227c89813a7_Device=CPU_Config=() -10891:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3b3a5cbc6a255792eeeec698aa5a90947164eab96ec744ada9d02b6c7f453f8f_Device=CPU_Config=() -10877:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=f61b45eec10f28e255a0f82842384e1c947830dc5d5618bf00c6385cecbab8d5_Device=CPU_Config=() -10736:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=9ca1360242688f494c59b8eb1073a4bf7291ee7b2ff460380bd47248fc591dc1_Device=CPU_Config=() -10405:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=e03d85019ea733c10b7ece4721036f3aeae2e60179d9b044d34e862608fd36a1_Device=CPU_Config=() -10289:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5beb9762188e985c9554ffb0a05fdc1608fb7d970baacebbbd7118186a324617_Device=CPU_Config=() -10200:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=64551d094520cf00d40fe514f573f5f37f61416bd456474f4b0a21788c4ffd3a_Device=CPU_Config=() -10072:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=eeed611756b048927c290a65dd92a5833ad66d347bbc772abddaa751f2016ff1_Device=CPU_Config=() -10071:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ed872c2ef0d35af97e7f9be84d83eee6d42f2fb279b71f4feaa1aecefb450a28_Device=CPU_Config=() -10009:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0e78ae14fcef33de9637ac99e87f672b3247ea32c221a4b555b2e5bbdff88788_Device=CPU_Config=() -9912:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2a819b46a29c8bd965ec330a28b5c163dd0a06fa2717d71bd16493ad460e8dad_Device=CPU_Config=() -9886:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=eb98c3593d72ffaa01de42caf4832854d9486b4148c57742c6dd72a251f8cb45_Device=CPU_Config=() -9770:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9465b2ea76ea3be1365dfe1255524d4ecce0dff6123e929a2157bfc767396b0c_Device=CPU_Config=() -9748:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cc5e06594accd8694073f3ebe702319fe0711c3b7d4db5e06072d83eeb7cb096_Device=CPU_Config=() -9638:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2f96ff03126561aa475067ad88e454b2da78fc8f0b816dc6c01ec5c81568288d_Device=CPU_Config=() -9593:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b0a418fb8ec50f25147079b3aef1b13095ea626a9e52a643600c39972982ff9c_Device=CPU_Config=() -9571:conformance_LSTMSequence/ReadIRTest.Inference/Op=LSTMSequence.5_Type=f32_Shape=static_IR=f36a3f626860d7088b33d97a5a6ce009c89609c142158b256aeb6b5e6dac02d0_Device=CPU_Config=() -9501:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=562ad06104aa1fed1781e5e3438d71855e1ee7e0126457f2d8d8d415f9c30c03_Device=CPU_Config=() -9244:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=80bc3dff7b0901463ccc52bd8e4a8e7522b1e9768421de45e63bdf8db601b9d6_Device=CPU_Config=() -9202:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=1a0639f04a426db13dd7cfac918ec6e2254e1cb8f18e0853e3bd597cdf090421_Device=CPU_Config=() -9200:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f166c58732107cb0c82859af62b8fc0d3d144468ab66ff4615a1eb4bd325d3c4_Device=CPU_Config=() -9130:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=27a43bf8c20a81f1e244ace4c53f7cd9343a2603ba2c8b50bb041a4046ae6ecd_Device=CPU_Config=() -9084:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4a9237e5cd29f0d2d5e738891752c6f6b29c9dc4c29d130b9c9921ad5787f819_Device=CPU_Config=() -9007:conformance_TopK/ReadIRTest.Inference/Op=TopK.3_Type=f32_Shape=dynamic_IR=fb3cc70d8993f96508516aa7a36cdcb9973edd563c78a7d6d5ac5ca9f816e3fd_Device=CPU_Config=() -8944:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1b59316585dcbdfdbef9fd71e2681207498cc867a2285eff20d125c4fca0502c_Device=CPU_Config=() -8850:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=b7973bf8dd344289b971d9b47575d6793643f503e13bb83c4e9c2a2863570b7a_Device=CPU_Config=() -8743:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=57b104f3a1796c31d59d676d9f6d65789ed72fb21beb382bf418c452b8452d27_Device=CPU_Config=() -8743:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=e020cc29b6ec76cfac0e0b52ed3024458fbeb567c4fe9932eb5257e3ade79b95_Device=CPU_Config=() -8732:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d671a241de6d46bd5562def47a92602d2c9ba076568feed303765168433ee89b_Device=CPU_Config=() -8615:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d932ccb58823509e768be954dc85ef1162d9456db17138d650a2a883e31b99ed_Device=CPU_Config=() -8601:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e6aef819fecf54f7c98b15f330074d33ea0ca6c8fc3edd895b362f04449b12a7_Device=CPU_Config=() -8548:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=() -8477:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=95ea118f8053f6bd18c8f34bbc475c00921bab5dc3af177492829d5cba16aa39_Device=CPU_Config=() -8475:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=90cf12798b53937dd1a31daebe5444e1c10c27c5a67fcde6dc61b5feb1df89ec_Device=CPU_Config=() -8409:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9b4725171957a420a98f908742f18062fbcee198871d527ab5b4d939005ac4e6_Device=CPU_Config=() -8390:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=dynamic_IR=a9636e6e43bc01f8b1cfcfcd8e60e4ffba20837d0d3b80429c93f23cd8da89e0_Device=CPU_Config=() -8203:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8eef79ab2081a12ed39f5c6f8f2e917d14685f54ccd0fcb0e19865740ca7d608_Device=CPU_Config=() -8040:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fb5525d36d14f54eebc5670c06232ca4e32cf920d309b5777e37d3377d386433_Device=CPU_Config=() -7779:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=2a9ba5f3e5a74f05be93e288553139a15242f1500e1eca8317dbd82ee8cf00d1_Device=CPU_Config=() -7739:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c161ff64d4c506fdbe44d0ee76042f958f5dfce778833653628a026de01a3f9f_Device=CPU_Config=() -7687:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=aa6c3816ce7ce49f40be5edbe957468e80910a8eb5a3956f54d89fdf7c264b44_Device=CPU_Config=() -7640:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=() -7580:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=c4e2668f98d5c21fc085695c9b6037f08a1e6710e1854fa73b7465a618e99b95_Device=CPU_Config=() -7528:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5976ce31ff4cf399e87efd691dce3e75dc2de962241a84c09538593c9865b257_Device=CPU_Config=() -7446:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=dynamic_IR=8c78da5f8bf9c1a4cd7f89cde9d61eb6500fa10ea0454e36a585466ed97fb12d_Device=CPU_Config=() -7434:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=26d09bb7dc7ce95aac39023ac90bd083da9101b9e7383af49e7467e4f0571f2e_Device=CPU_Config=() -7343:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=95d9789ef78c733e0c7972738bafd4da289a90f0d9ea00bc9452192173390b6f_Device=CPU_Config=() -7306:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=004b6fd9b060324a42aad296dcb21f5b7eb7586c082f98d23f25a6d882f70c14_Device=CPU_Config=() -7292:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b3e45847dae7906b7f320b6a751727593b35ad8659ee80a11caf445f44f392df_Device=CPU_Config=() -7276:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e2734d3e803c031e2fd56d0c9f7a72818227bc7981d9f7d9d1148f1cf07135fa_Device=CPU_Config=() -7191:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=e894ea68d25e2a0af6fe2e330929c3305710bd07aca8e099b727df78fb26cdf6_Device=CPU_Config=() -7187:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=f76da5edfb7a9e3fa7cec034fa43307bce74eeb0629176ae5dd40d154baf858f_Device=CPU_Config=() -7172:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=5a1aa66136ca2be83f714067139e11fcbf672d73f8b28c57d29333b885a17f83_Device=CPU_Config=() -7058:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=65493d18baa6530c757031b74c5fbd51757e2b04bb79149d3acbf6c40bac11c1_Device=CPU_Config=() -7042:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7a3cae38e357ee1e5b0400c7e1256cc8a2d78da81911fbbb3ae6d9e510d78aac_Device=CPU_Config=() -6976:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=d8432e7d31bcf4d95ff7ab845a6858ea67cf751c7ef0fca60a9bab1d187fe3cf_Device=CPU_Config=() -6865:conformance_TopK/ReadIRTest.Inference/Op=TopK.3_Type=f32_Shape=static_IR=a56b3f758c88a5723e4a2cf04ce46c92681ed7fb0d6dd7f4d5b937dbf00b0eff_Device=CPU_Config=() -6823:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=ba1b92833f2c8734c5178762b6cd8c847c23027ecf79ebeba295c39b667162a1_Device=CPU_Config=() -6737:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5953b8e79f64e33e67dd330999ff8e3d8391c8f3fa7eae519b117b1273c8c19f_Device=CPU_Config=() -6702:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=fbb85f74ecfa0ffc50b9e6ce637911b406f1fd6ad054a886b9c6ddc6bc898739_Device=CPU_Config=() -6699:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2758266e894d04cd7283921f678a468cc1fced81d1a09a3c95add3ed9e5d6719_Device=CPU_Config=() -6606:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a7242174afe3f7c2e95d31cd14d56ceb0a566e2e8d65ba97e07d004200f4f517_Device=CPU_Config=() -6529:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6a7aa747b98a21c0469c7edf7ef78a050e1279d891b0c69ddc071befafd42c76_Device=CPU_Config=() -6473:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=e2ab1cf295df4df47d43e632065bf8a48fa58e6f3a6d1bc971b45fe97a66652e_Device=CPU_Config=() -6464:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=a3de81c04a0e7d5cab275045415ab4c294ed3270588c2ef704ab6db5514ed0dc_Device=CPU_Config=() -6429:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=166d8442037dcf0469f0b14ab83676b30bce53edd79494c52a575e3744920c4d_Device=CPU_Config=() -6403:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6513dbb80f00e325d6dfc953d1208c5834199f75a60430fc85925ed6eb0d9bb5_Device=CPU_Config=() -6355:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b2931a4972ae4f946778af45cd5824e6958dcc1fc79cea4da1032590b2663d16_Device=CPU_Config=() -6348:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=138e0258106faf2065b52655adfb8b45d49b677f9cd04850bc5ac9335a9d16d7_Device=CPU_Config=() -6336:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=afd856f31f3a815b84c34b66e1ba0a70a313301ce82fdccc2f1b779ad3157d4f_Device=CPU_Config=() -6263:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3147f462ceda9b383de633ac08d6014a7779e74b169d3745990fa2b2799b1dbd_Device=CPU_Config=() -6239:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ba28829f211d64d6d4922682b85f1bad6a3c28cc30b4f9651186b1e8fab39fec_Device=CPU_Config=() -6225:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=90f981f067c23b4fd3d2df838af8e6d11ae1c5e9465b566501628c7f3d63674d_Device=CPU_Config=() -6189:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=() -6117:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=3c7c072c9e4ee694e049a5f256cf0e72caf85384291ee8d399ce136d22c575a3_Device=CPU_Config=() -6110:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9fbf4ccaa68a81191afe2432a2212ee1a559df380d602459ebd2d0266053d82d_Device=CPU_Config=() -6091:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=93dee798d72e36c04cf60499e95f84cd6b63d84226d7dd1dc0edcf0875cf301f_Device=CPU_Config=() -6035:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=aa14d6e18f8580015dd7d32b167fba6ee137133b87fd617eab4599f407a51b69_Device=CPU_Config=() -5864:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=deaa5ef98e478a5850df528107031c9c7bfa6305bc7507325c91b98f9337b0b8_Device=CPU_Config=() -5855:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ea8fff2db5032f5015f68d53904354d4bdfbe5288224c7f549a1573794455d80_Device=CPU_Config=() -5789:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=abd733caa05592feccf41344f138de6625efce4afe605efeea57e0748d7b2e07_Device=CPU_Config=() -5767:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8fdd77d8381b78b82c04360bc3f05a358bd690bd8204e2cdaa2c0a65bff61a41_Device=CPU_Config=() -5758:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0a16d9d3d8d553c2c747b2c68b12eee3dcc016e29e597992cad8f83aff0aa759_Device=CPU_Config=() -5752:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=556de70b55386fc9a264a24a9000d075a07636de6461cc5f4cd41af639b0597e_Device=CPU_Config=() -5668:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e00cea4f2ea99f32c11ea265ecc0483554192192bb99f36438dd38de09820888_Device=CPU_Config=() -5656:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=9f7a30c4f90df2edf8e70468ac22f325bc97e99613fa6ee2aced93e71ea5896a_Device=CPU_Config=() -5641:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d13d862f7b8306948676388381950639ef433dcc4e38f5a6fa8d50575d1aa814_Device=CPU_Config=() -5611:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4d2e12e00779d116e2192ca77f2be233d76bdd5ce366ddabcf436cc205a9f811_Device=CPU_Config=() -5600:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=033c6bc337d14053ae097dcbee99ef5de7cb7728b589cc8d64783467505a8ba7_Device=CPU_Config=() -5544:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=90deb33b54746ec16cf8594f8aa0792c6aab2e27ff12ed97523da583402aad95_Device=CPU_Config=() -5535:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=d93633fac99f9472435ede6fcdb9c72475b68bf1352d58b33e8cbdf9ca74ac50_Device=CPU_Config=() -5519:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=aecc8a062c16343ac138f351d774858b523e42d5a09ab67b1b61e64fe62e73ff_Device=CPU_Config=() -5412:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4ef9d8687805658001fa7650e660620d74bab09868b356603c268bc8cdf7a5c7_Device=CPU_Config=() -5407:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=5b1fc9693e4e947bc88a88bf1ad22ee2f59c13bf291626eec3e8ed49b0cef7ed_Device=CPU_Config=() -5341:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=4e14d87b7667a7900d4427ec46c72eb3c7bfd2e3d86e5bdf92eb2485059b4951_Device=CPU_Config=() -5324:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5288d099588f5876e907c5cd750c9f0b2191d1ea060881e80af1006cfad259ac_Device=CPU_Config=() -5305:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.1_Type=f32_Shape=static_IR=2b1509d227d4c32fee4bb0b7ac59d4ecf5018afce9fd19714067a20d01933455_Device=CPU_Config=() -5304:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7b42d3a61f732f3639d1ae7011b86158d070acc922308a18f00a01b9c6a60ead_Device=CPU_Config=() -5297:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f0472c0e5ff8fb82651424269bd9f77e73eff6c43c70b6192f07303c0d35db8e_Device=CPU_Config=() -5295:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=4212a754718adff414309fb1da18c4361792b5478366bfdc0994490c7bc716e3_Device=CPU_Config=() -5258:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=94de295ab12bd6b03bc5de22f9e9c46d5875d111eb942d3ba35f8e2456ece1cd_Device=CPU_Config=() -5190:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9beef927f57c512d381a87a35982fe4ca7a00b9a9d50ede54f7baecc5ec7fa0c_Device=CPU_Config=() -5165:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f83f2d7d9c08aaf30635b39b51c0d7f1f622b4624da59c6cbcdf28d42470f11d_Device=CPU_Config=() -5099:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ff39aa885f7ecc22a06f668b79fef4ac41b3adf8dea82f428711b241c0fa6059_Device=CPU_Config=() -4982:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=06069a23d29d9bb6910729ac49ce1466e4fc6185c6ca31fa54fe7dd3289c41f7_Device=CPU_Config=() -4949:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=dynamic_IR=516ad610612780fdaf83c5dc151316e83772eda4700882f934c97b2a2bd86dac_Device=CPU_Config=() -4872:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=dynamic_IR=791be312b2af6da6abd2eadadc6185c7052271efbcf314bb678828313fc58414_Device=CPU_Config=() -4839:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3888863c4f725445490846561b2aef4a5498ef1583903b365fb864e387eb9641_Device=CPU_Config=() -4816:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3421ca968a9f4061cea0492ac3920fe1a29fb35093314cbb56a78bbb136d8fc7_Device=CPU_Config=() -4804:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f8a096633b64512b865ea5e4a57529cbf621afedcb873285bd5e24cdb199a46_Device=CPU_Config=() -4773:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b78ffc69401084763d529e2aee12f9b9793bc92be3eca3df2a97730b9a252ce3_Device=CPU_Config=() -4760:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1385af2553c7c9b0f9ce2aa4345d8b767d36136a9cd8e2acae79d4970d6b5c8b_Device=CPU_Config=() -4735:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ee1f9348ff09a058dc09cd63581663590521d463d14b785a23ccd3cd28110b5b_Device=CPU_Config=() -4722:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f4b78bee713f23abfda124ca92d58828eeab6118710d93572a491cfd85cd05b4_Device=CPU_Config=() -4686:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=461dc8aa282946831fdc86d1c024a273ac0f29f5ad615cd55b879feea6d23007_Device=CPU_Config=() -4648:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=92f5c3aa4427a89ad6ef275c0beb2139cbd0c6ce2eb71205117448adf592ad20_Device=CPU_Config=() -4564:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ede6f5f8a1d9bcfd1979965f575c8f267870e0d6a5d3a62d229ea029893525b6_Device=CPU_Config=() -4488:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=b16650eec74ddd46ff3bffc9eedb340b6bad99a338fbe6b11f7eca3098a324d2_Device=CPU_Config=() -4451:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=588ef4d887ae9d8ad432525108c81a9762dc27490a3e01d3e86795c73275148b_Device=CPU_Config=() -4450:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2c20f6aace24bf601953b848c173ad475502b91b667c903638acf41fb9a67d3a_Device=CPU_Config=() -4427:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=089d73af2221696ce3755a9f33124c9af87fd3e860a1d4f229995eb01ff46703_Device=CPU_Config=() -4407:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=fabbe8bc510b0d1afb64f2fbe68d755be05fdccfadec5fe845dc6b3c4e6a2767_Device=CPU_Config=() -4404:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b706dc1dbca4cc6c308f2cadf799fec41a8b3f08251de3a58444f0d760994cbb_Device=CPU_Config=() -4352:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=92ed2f40e1ecbb9a90904cfe8e8ceda94f73154a44ac28a50c0d7acb221e8835_Device=CPU_Config=() -4351:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=29bb3b751638e157d0ba7114cc0e156a4b792a9dbb2bafa3ca124516595f01a2_Device=CPU_Config=() -4332:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ffc3cad64b8bf82ffa4d189a247a9434e71886cacd3582956c5dd98921fd2141_Device=CPU_Config=() -4332:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=b050ebcbd31acbbc43d657d87a54415e0e52d3e91fa95b57aa1dd0451a5bf50f_Device=CPU_Config=() -4321:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=95bbf8a23b19badbde31e9ae7f016aa436d50d797f59bd736e220030f645bd9b_Device=CPU_Config=() -4309:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=57921f181e48af2b294b923633e457650e5ab2a9ac7f5d4d07930974ad5e03e1_Device=CPU_Config=() -4308:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=66a4d902b67742a95e2d41d79b9d2434e57a55c168a88049624a0ccb62df9ca2_Device=CPU_Config=() -4289:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=491b849a7ce8fdb2190df5415fe037ff02fc23814efc520c343e872f539d6e55_Device=CPU_Config=() -4284:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=dynamic_IR=2af646407076eafcc1ed2d628158fc32eac4ef2fb34fb967962c06f81376d61c_Device=CPU_Config=() -4256:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=1f6be1a43c786bfbf35baad6ff643b762e9d63c069c884a69b4ec6e89062ad7e_Device=CPU_Config=() -4240:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=15197edec77da431c491f42f64e86a811d89a337bf44615824226425b1c64d28_Device=CPU_Config=() -4208:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3a3886301663fd20cf2c8c0f74c11d80dfe8b74ac39e41652f0eac1ec9bfa2df_Device=CPU_Config=() -4182:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=9281a7e3ea8124fdbe416d1f15434752a7e799fc77a63be64babddf60b6f2d8b_Device=CPU_Config=() -4119:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6453d2955ad3344d5e021f97d71691ddd7c27ffc0d9044b724c9a6b5c20cb427_Device=CPU_Config=() -4086:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=71c0c7e3176ae8b233352c89d47a61394cb46695e7879118ed02070a4a23d5e1_Device=CPU_Config=() -4070:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f69e74dc680137ec5ef0b63e38d451da7bf1b61d2acabab77df46b76c9777402_Device=CPU_Config=() -4055:conformance_ROIPooling/ReadIRTest.Inference/Op=ROIPooling.2_Type=f32_Shape=static_IR=556c6863ca3b12d255c4c81d92b4573203f02c5588e064fb22dd4aa23c8283c6_Device=CPU_Config=() -3943:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=07b4c5d05754987a0524385690d79f74988302f437597b7477770e8d062d72a0_Device=CPU_Config=() -3930:conformance_If/ReadIRTest.Inference/Op=If.8_Type=f32_Shape=static_IR=e178ca7afdd75b09f1ee18e50afd30eed0740497637863c3397b5a75c0f8bfd5_Device=CPU_Config=() -3928:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6eb80b60b2162fc469f652535ee11822ae34c903ca44191dc95ad7f9678b9337_Device=CPU_Config=() -3867:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ec19939673cc58f2511ffd6695a3652f1d724872b0db958a6d667e1e87002b21_Device=CPU_Config=() -3853:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f6f3c6d199a224ee983f6905aa4f72ea4138e6076d7307c72588dda0cc9c6ed1_Device=CPU_Config=() -3848:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=45ce409a7078c7e732a092633cee36d6a0aa80fa9249cc98dce44e5b4bfc1693_Device=CPU_Config=() -3830:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=2a3d6c0476c17897fd4cc6d3623519fc033ac4022a01fbebd40b461f414f6c15_Device=CPU_Config=() -3807:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=3d20de7392465c055c84dc20d0af64ae6d14809f5a6e4bb05e315a2654066f93_Device=CPU_Config=() -3763:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=20af9ae4466332a072f3b04c1219146d272daabf2306b66c755980bfd31f2a76_Device=CPU_Config=() -3683:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3e2e16f3ba7681bebb6b4c06788f38a40fe24e26fa3ec3accd756c87bee7d62f_Device=CPU_Config=() -3668:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3f87262a458b0dd0a330ab0cfc48c74ee687819228d3e2e1226df3b02de26afb_Device=CPU_Config=() -3652:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f8408a1d4e8c11ebbda01e0431217a5ff4ac6a869cc4cd3208cc9adc59d227fa_Device=CPU_Config=() -3636:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=125ec4e4ba4158d3a6d1a7725cda9a18a220926d5ad6ed623a1433688c79b579_Device=CPU_Config=() -3623:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=dynamic_IR=dac2c804cd13d69a51906319a3648ac0edd87764c686c99fb47179f379cecf7d_Device=CPU_Config=() -3583:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e0293184207036f6016f557f8df813c6536b18332f589245c5c606a3b36df1e4_Device=CPU_Config=() -3572:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=3fec5c6f9e39d8a15d58c5800a889e1660adb375cb7660af1526cd31e69f7cdc_Device=CPU_Config=() -3570:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=69c68c20edefc8789e62a7cc8a0f8fe7e649f884649ac30833fb5a2ce43c4098_Device=CPU_Config=() -3546:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8e80bbd29743e87a0a6d4158a06249766b6a9cf424cc1c0ed3c6f60e30e6db58_Device=CPU_Config=() -3534:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4b3740eda9e6bbd3968dd39e6abb33b22a90a811298df6a761958216acb389f_Device=CPU_Config=() -3524:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f3b3afbedffce0d70b40d78f882a0061ba05e26e385c37cf902aec88ea43a649_Device=CPU_Config=() -3517:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f89a1dfd0ef8b50a998962d5a4f4b54451ea4c533476a2e3d42c04e9e645afaa_Device=CPU_Config=() -3511:conformance_LSTMSequence/ReadIRTest.ImportExport/Op=LSTMSequence.5_Type=f32_Shape=static_IR=981b213f0fd1305e70515849fd08553471da63e6bf64827a47cc475fd4ed9561_Device=CPU_Config=() -3489:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=945bd465761a4d9b013b0a5e88a3a9e041d8bd8bfa8df8044f28d71ba26f224b_Device=CPU_Config=() -3483:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=969c6a651dc204576d68d7d893ad2dbff1f7c74803b1763857d41aabdd19a72a_Device=CPU_Config=() -3471:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=0a7b1efc8d314c5e37062e482a9398f718082ba0528c6ca2d2f6c88e7a4a2bb0_Device=CPU_Config=() -3450:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=() -3431:conformance_If/ReadIRTest.Inference/Op=If.8_Type=f32_Shape=static_IR=If-8_707_Device=CPU_Config=() -3363:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=81c2956d325aab4a7bfd931d94151e1285083a15326e0890f861b97017a24bb9_Device=CPU_Config=() -3356:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=1d7cabddc96cb4ca2ed111c9f7a9c31b76ed9a052fd0b79db6bdc8fc55f24a4b_Device=CPU_Config=() -3354:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=86d8d42c30e423e801b5d4d832f87cd6837bf9feb3c546f5bf87e04f842a04f1_Device=CPU_Config=() -3352:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d56533ce961113b2ca0baf02f3ff9f8ff210264343f6bebf26418a35ecf36b02_Device=CPU_Config=() -3348:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=f01fb29e8f5ddc7562e954e46b1d2bdbe6144d6bbe2ed2a0f16610f2812ac721_Device=CPU_Config=() -3265:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=1d8577d7a316c5a2726f3be79b4f8b22d6dccdd5491a4c7896a7c9de37330e77_Device=CPU_Config=() -3246:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=45b3506bf3dbe053fcb290dd1040a9d125c56086b37223e8480647bdd9b9372d_Device=CPU_Config=() -3244:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=87f3815fd73265960ef5910a3b03580b13e96d02784e159a0bf0ebc30bc911d5_Device=CPU_Config=() -3243:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=978c328422e3866322f3bdd52955690a47a1fdd47ddb9db66a4707b36a535dbf_Device=CPU_Config=() -3202:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2fc01b66086ac5d8272dd81ab731188b62bbe8920bff1efe61bf3261a3a8b3e6_Device=CPU_Config=() -3159:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1fe78f5a88510b70fb39ed088e1418ae09155d179afc3a614a641b4e8f86574f_Device=CPU_Config=() -3158:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f84dc200af2852df01662dfbe891b8ed4abb27db6763f3a2b645ab75324834f3_Device=CPU_Config=() -3148:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=3fbff9f870428a19ed434cdf72834eec251edc3dddd149491c94319d63a8438e_Device=CPU_Config=() -3143:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=09c1f9f81a463477da73d33f00d1321fa5c1f64a9c3c51c6e3c1344e362d4ced_Device=CPU_Config=() -3131:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6a9a72aca963de945d97658e484453191cf6af26cd6838c1603299aff3a49a8c_Device=CPU_Config=() -3125:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=() -3101:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=00709ceadeb9692263607310765b0957f34a8af1ebd17a13cc28d9587d360465_Device=CPU_Config=() -3093:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8ef4d7ceb7d904a084d93d6ede1c15a64d2511b3bf1312d630792eb21c591408_Device=CPU_Config=() -3089:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=6b0b123bc93e799aed7bee84e55ed9def25af4f11d27958d8368983eee9c527b_Device=CPU_Config=() -3076:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8dfd99ad2ffed2573598829ff34a62deccbd70f5337c1fec4c2962cef1992595_Device=CPU_Config=() -3075:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=7d73fec5a605ca6fc06cb014fb723236fd2ddfa1820648acb7fdae8530866f45_Device=CPU_Config=() -3074:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=() -3072:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cc3619fbe03f9b98ff07babc5c11f9bd9f26927c8d793abc7188595145bd1371_Device=CPU_Config=() -3046:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0edbc14a5d5ac1265a4b880131348aa16e284012547556ddedb36b185d833284_Device=CPU_Config=() -2976:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=fd10c1c5d33aef77d3428fb5c9789f3c2c2463ab9f6cb51184ad37951578320a_Device=CPU_Config=() -2973:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=14f550bd7e83223ffbf501918141376e6a144484865f03c9768fe9da49a9f06f_Device=CPU_Config=() -2949:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=49ed5fbacb5510d9cb3970dee136271e98ad5322b95217c6dc41026e583f3bcc_Device=CPU_Config=() -2939:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=965ded994c427ec62353194906203c202a52dfc0467196d5f1143759fed94b07_Device=CPU_Config=() -2938:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5d5dd8756ccd01ee77e0c17d26f248c9e35d07aa812dc64bc39ac1ffe17ae585_Device=CPU_Config=() -2932:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4bb7bd2471752f1a62dc15dbcacad87dd329443459a90dc6768b1a34fd00c064_Device=CPU_Config=() -2916:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=059046ce67f6b09ef45aaad5724e28fdaaf40afb92613740fd058c974a120d3e_Device=CPU_Config=() -2894:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d7a96943c0264427eb83ab413f6e7b0f15f09f83525de581fba582655d0fa4af_Device=CPU_Config=() -2870:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=0c6a844f626f6628628034d332ccb6d520e0447e4b616048c7efb516d0fd87bb_Device=CPU_Config=() -2867:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=c0c1a43608279d8870258be63005b38e23fe5501876c87840cc16a0bb2cf8dfe_Device=CPU_Config=() -2863:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=ac87d885a27bfd348d3f9fad5a03680b73b7198fad17dfdf08675e6e3d239ca3_Device=CPU_Config=() -2860:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=95afe52c888afd5c641ad2d6d0c3f8491f039af2c6938b91fe6fca613ec0b6ab_Device=CPU_Config=() -2837:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=f31f6d969e04a7a1c964c02f107a7291c85067ac31d935921bc418363c2a7a46_Device=CPU_Config=() -2826:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0ffc7d7836be264b6d9f26daa71a8c7100ae6bc6fa1af23614a2736226fbdf0f_Device=CPU_Config=() -2796:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=49245e23b8c1c485428d0e490a687e48c541bfb833eb7838efd8c112736a076d_Device=CPU_Config=() -2766:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=05690f7225eecae70805d45641cd02c02c46bc61f9fa4cf91d3ec7ce94f6fd3f_Device=CPU_Config=() -2759:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4746fb4d92aab20d21eeb0885d35c88abd50aa250298473f5bd143658eef2316_Device=CPU_Config=() -2730:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=45d612bd5bc0895879f727cffcc13c978977a0aa10dfc726d00d6450faeff068_Device=CPU_Config=() -2706:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=05e9fdd5183bd179e5ef996ebcdc53f239900ca46a8122ee8bb1e885c2c091ce_Device=CPU_Config=() -2682:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e27641fd09143d736ece2166cc3156e80c190d5def706b86358f49fe980cf9b7_Device=CPU_Config=() -2667:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=16ccecc11352f2c476db041adea21d67a96e03cf33902b37f4f6855b5113c202_Device=CPU_Config=() -2658:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=6ac457e9181610da9eb4bf0bec6cd53bf3078e0b84df1211f49921207d81c6e9_Device=CPU_Config=() -2636:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f28013382ca254b4538a5527896cdfcd9d404aa854af83ef1d417abcdd781ef5_Device=CPU_Config=() -2570:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=99377bd11138d36797502d82ac9adddc31dfe1e4cbb8bba8684b1479f8a16f26_Device=CPU_Config=() -2567:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=d34bccebe88a4093c9810d56088e4bf07b55bdab1801d7d830360aea1be22499_Device=CPU_Config=() -2537:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=348254d0e2b145f9e5443b4d4470b2ab29487acbb34a71285a5c0e1bd29cb942_Device=CPU_Config=() -2535:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=847ce287888e882e988cdd5bf41277c32c207e38215e1e7d41439890037216db_Device=CPU_Config=() -2520:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=() -2516:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=dc4bcacb769fc4d8f1ef4ff20ca7ba6b3b369d69ea3b1c65733d4cbd2cb0762c_Device=CPU_Config=() -2505:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9ba199e71a3ff06e6bd330e453a1e1103599902893fc267c60da9ae47575a8a0_Device=CPU_Config=() -2504:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0e9ccd2a8aded784ff21758802648777721176f1d112ff60aaf3f150d6292156_Device=CPU_Config=() -2492:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6ea8e16cab0d6f60ef13562706c941f5ba3c90d3a65447ab3844e100cec5a0ad_Device=CPU_Config=() -2481:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=065b3de2617f318d1376e9610f9fa1a2f2fc04292f9a7cc949780ae41d3539b4_Device=CPU_Config=() -2476:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4819c2459dd2bf875545cc912152c6751ed5db8ef07aba31d3eae6c3dedc7aca_Device=CPU_Config=() -2455:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=254937408e91c70536c4f3b3f81f1a7aede93b29f142631a46fa7d962c531131_Device=CPU_Config=() -2432:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=4ccf5cecf790d27400fb95526a993f8a1a28cd4f3120b897cf45bbe78f087ab2_Device=CPU_Config=() -2425:conformance_NonMaxSuppression/ReadIRTest.Inference/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=() -2419:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=dynamic_IR=50ebc9636f3321fe9bc87cbfe301c8ca3ea27f56cf429c983ceed6ae63bb3885_Device=CPU_Config=() -2396:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=68853f0b8867d4ddb5eeb239690f1b41600c05f64ee4d3efa8cc828e72b9bc1f_Device=CPU_Config=() -2390:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5e31c7022ed7bf2adff14876be4bbf6562afdc2239a08ddcdb507e3d1a20071b_Device=CPU_Config=() -2381:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=263843a2c307b91ff7d59d9b21cd8b2126e985d787fc18f44df3525a6bfd71f3_Device=CPU_Config=() -2380:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6e73ec183893b70ec42a4393f3b1b7c55767a14f630eaab0c3e3b6d22c6b8e26_Device=CPU_Config=() -2376:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1245c8dbd9027cc56d2eeb58e1bd23774ce945522f66a17ecc3c03ca1ca163b0_Device=CPU_Config=() -2372:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ca3d0cbccca665493e85a757798ab5e12399ad295466cea744c7a2d278c86c97_Device=CPU_Config=() -2361:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=7ad6fe3ff1472399c9c0e12aba1db89105e1e4a243cd092dc43ee763a2571fa9_Device=CPU_Config=() -2323:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=254aa036653eace9f3faddc8f2fb69e04ba0c788a2070c054b4c9fc059d33845_Device=CPU_Config=() -2308:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b6503944921be5fa3feb0b7647c6715465af16702c645dec4e2f2556d8d679c_Device=CPU_Config=() -2296:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=949611ba6617b054b828175c04452b8fcbd109c99cb25d5d8827a872b4044fd3_Device=CPU_Config=() -2296:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=053d601716750db93af5ae01d67213086ed987370f9ff59723824dcd0a6c2462_Device=CPU_Config=() -2289:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=35c61b2251b78ad9f9804bd3f9e301e1f974c6dc138ce0466b8b940d106ddd72_Device=CPU_Config=() -2282:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1d52baa348f922bf85866fbfaa488c1ca33e01f0b79bd6a25fb430e8b7fc8b06_Device=CPU_Config=() -2229:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b46a2ee4f7042328b2496382ed2bb9cf39621c3e3e27fd1d355c9682543effc2_Device=CPU_Config=() -2228:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=860decd2bf091a335f6f820b2c6b6acc58618fbb6027e30484470ce899bb1591_Device=CPU_Config=() -2203:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=d507892556310f7fe85cbf9245ddf040b219ec8cfe9c779809180a011caab9d6_Device=CPU_Config=() -2196:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8fa841d409e36b6665e289f4963330eaff4124d5452c93b75d779937cabe14d8_Device=CPU_Config=() -2191:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=4fe6c9c924477957512c3d32086ca167fe5a4ddd5cd1b90d5d32452f6de8317e_Device=CPU_Config=() -2178:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=d066432a0ddac020441582a98f139d063cf5f4e9f34deaa0be5ab9b9f048aa0b_Device=CPU_Config=() -2175:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ad4c3d2d3f258a4be14846d9d26203008e01b2832ff004bb8a23ff05c72747b5_Device=CPU_Config=() -2165:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d73edb68da4aee1c052b79ffce030b368f204c04bffd9a9dc01a9b54de932e7_Device=CPU_Config=() -2158:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2435ff5e2ac06afcf99563821fa2a2a5e4a9456cb3f74154b3eb364a6f0e450a_Device=CPU_Config=() -2157:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=125693eeea442dd24dd812dd2eaf8d2154274f5975d68b0132d2bf9bedfe0ee8_Device=CPU_Config=() -2131:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=506b15e531d5a643d3276fd84af8e10eb2a62ce20fe3aeda90c50cd7442e0a88_Device=CPU_Config=() -2112:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0a16d9d3d8d553c2c747b2c68b12eee3dcc016e29e597992cad8f83aff0aa759_Device=CPU_Config=() -2094:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4722375e4770c972f87bc89a8ca16871aa57251a9c01ab2a14adc11f885cac91_Device=CPU_Config=() -2090:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=f42d85c8e1388cf2cb69f9efb2970255c6535f1c3f904a9b08cc18cbea6aa6c3_Device=CPU_Config=() -2084:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eace26dff7f6f0403126e78a4c93920ee5e54a721cd580b4b18c2c9989baef86_Device=CPU_Config=() -2083:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bf235091db192c86756347e70771b4b00a6ac2c8852b93079749ba718d57d022_Device=CPU_Config=() -2064:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f49b212b59261888a5ea4652f9a4cdfe25657c7a0e4d3b6ecc16255e8d2e8cd5_Device=CPU_Config=() -2056:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6d705ecceb3a026a9be0b5963705b0c3c6be0123fb7d25885d3ae21213f1716b_Device=CPU_Config=() -2043:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6adce7c66c1630295ec8938bcb429f20b628b0ceed938bf81ac0fca8580f8d34_Device=CPU_Config=() -2043:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aeabe9639d6dcd5ab6e09f9905ffa8bdfe7cafcc7f5c8598e20e4ff39bdb50a6_Device=CPU_Config=() -2042:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6b87ee29001d1d3b17ec72a66638e954796b7d6ec1d6f6be86890c7d5a3bcceb_Device=CPU_Config=() -2028:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f55c473236715e5c4e6ec21a9e07d1c73b14d529b57fae0cb38ef9d6cd383b53_Device=CPU_Config=() -2008:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=7a1d8cbdb446c3330ed845d7a81e20d9b7c7662d532f4d816d4fc1c56822fa81_Device=CPU_Config=() -2001:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=439308ddb64edf02f96ade09e7888cf89f422fbdb8c8242521ecc3f93e61bdd7_Device=CPU_Config=() -1997:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bf802641cd9b20a23b73202f401f4b32903ac7083d0ac7026098cfb4311b35c5_Device=CPU_Config=() -1975:conformance_SoftPlus/ReadIRTest.Inference/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=() -1972:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=539610c21b2839b71cfecbb15b7b7145f9fee8bfef8ed9e1d73aaad2de661496_Device=CPU_Config=() -1957:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=dynamic_IR=70c260fea7c5ff6d2d1e9580ecf6c6a8a26c0e688b4f8dc4540888526bc13e76_Device=CPU_Config=() -1940:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=910dee337e395f94d7673f664a3e58647ead8bcedf50ea1439250bdfe8da25dc_Device=CPU_Config=() -1938:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=66bf131d73ad3116d698e15ac3c9e48bde66e096228138eb865c0807295c0d4d_Device=CPU_Config=() -1936:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=eaac8b3d6a4920fa2ac101965805d140502fb409e230821d5c2a370aec15eed8_Device=CPU_Config=() -1916:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=() -1894:conformance_Proposal/ReadIRTest.Inference/Op=Proposal.4_Type=f32_Shape=static_IR=ea8cc682a9a36cc61498573e967ec64d289af84a9e3da1911085b1de4fea4c82_Device=CPU_Config=() -1891:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=3effc90c24c0eb76bbc89809d34c6541654366a02e21378a668dd932a6cc7756_Device=CPU_Config=() -1884:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=447c546ed54e81edcfea77cafa8d18261923bf25c050666029828ea72e3a875c_Device=CPU_Config=() -1884:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=98a6da6e0972a1b70caa5df788a6921d4e470565dc3880faa59e913fdc15f460_Device=CPU_Config=() -1879:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2386bb6412e51aa72e9426e12f9f2b2646e7074413b33fff8d95dde141ee12fc_Device=CPU_Config=() -1876:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=c8bb865a43a3782b3b85e05c3e86388fac07473697ed45a7b04f60010555a3c9_Device=CPU_Config=() -1874:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=b4fecfa9b5d565a02a9f0d0ed19a11127ea9c8c4e70a0e5f7b920701e0665d51_Device=CPU_Config=() -1867:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=f9f031e1fb61fcf87468eb1f4b2005e7cecc5f073eca95c161fe62fbbfc983f4_Device=CPU_Config=() -1860:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=37a75b89894d8a024fe6d1808e0674b4fb59534cd319f4bcd07c6d9caaaf97a5_Device=CPU_Config=() -1855:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=bf7feb979b2eab03afc780965804a3f6b8471b574c36125654fcaf3ebc2c30f5_Device=CPU_Config=() -1852:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a110c620d27325938e9febcd9d757a5525c421bc29450fea960403fbca3507f4_Device=CPU_Config=() -1844:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0e58762b5cd9926391cba6f63db3c7db49285b900ad0abc93b4d05d4baec800c_Device=CPU_Config=() -1832:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=dynamic_IR=6a0218ea2e7eb0329e4915f2f6a7c215742d2469e868a4a8e43c683c2dddc01d_Device=CPU_Config=() -1829:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fc8b85b03281a7e8532a130a70fcfce5b6c40b1c8863eaea3910013a0bc4e769_Device=CPU_Config=() -1820:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=cd389fc4a9417c7136f75474e42dfb43d1f9cb35fa0e104632ffa69fce2b7e57_Device=CPU_Config=() -1802:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2ce1f8773e871f8aed0d3541cfafba0bb079e1765f04c1336af8a47f354cd766_Device=CPU_Config=() -1798:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=static_IR=7aacf3576c3d114915bc3aa48c8ee4ac9e94bc00928709d86461877a8d2d84fa_Device=CPU_Config=() -1793:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=fbdf008803736374dd213f1d7e0a041fc0e9b3f025c212a588fa05842ee5ee56_Device=CPU_Config=() -1780:conformance_Abs/ReadIRTest.Inference/Op=Abs.1_Type=f32_Shape=static_IR=5713be8dd761def00c701c74d0aa913d259206eff1103b9fa6de0f6f1a25e566_Device=CPU_Config=() -1768:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4e6262ae12e4f9470a87cc4f1cc1ef2a817a8080e25a79ca4ef67cb60a558b41_Device=CPU_Config=() -1726:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8ec74565f16a2ee1e322b4549ea19aa0b30719787abd90bd957e121705edb268_Device=CPU_Config=() -1720:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=04db488d856ff6cf4f04ad155967df95830796ad733e589f42c3862224acd874_Device=CPU_Config=() -1707:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=139cc84777f1e0d489245d058877303e72a93eba3cffbf5f919de21b4514bb0d_Device=CPU_Config=() -1688:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d0aad85620a1b97486758b17c69043a6a9cf75a459bf6e283b28ca132e917dcb_Device=CPU_Config=() -1685:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fa2eea1b545d6b876282ed0165fb935f0af249c713e3f20fd97cc06118e615eb_Device=CPU_Config=() -1685:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eba756a8d0ce89c9a8df50baeaeb82d5b719461bbaa06386db7e1be10ec535f3_Device=CPU_Config=() -1683:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a093f44f22a851366eec46b6ed80fcecd2a4a96ca797c2caf288922a2fae1fd1_Device=CPU_Config=() -1679:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=662ca1fd253f0a0c29b89eb1310ea5c7c87895533130ca1a8b76f791ef1ad99b_Device=CPU_Config=() -1670:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=d50dd7c19583071293118e8b98f2bc749ef3e34ab8eb0149138e6b9fe49a153c_Device=CPU_Config=() -1668:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d0bade0811581a6fae53c343866f1bdb63acfe07776fd60b7e791f8edd3f88b2_Device=CPU_Config=() -1665:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c9352ef8b6aae01025051f9c73f023e7b5a13f8987f81bfff4ce0ff9725c21b5_Device=CPU_Config=() -1661:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=14f4dcbc8e714fdb791d15b62646db0da2cf647d431dd6ea044ca6976ef51753_Device=CPU_Config=() -1660:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=3bfc4cff938f4386af23d87ce10f8680a62a25ce1fa9178874f212edf45ee045_Device=CPU_Config=() -1646:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3c03ae2ab13dfccc85d9909840eafb6a291b978e9bf859f27886b4a0d3e87ffa_Device=CPU_Config=() -1644:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=234277ecce31161bea52cf4aa2a37aa8cd43f1bbeed281a79a6aa1d07368872c_Device=CPU_Config=() -1640:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=30f4b90114764377dcd8e010019eefe0ec9c21dc6f0503b52323dfe867a51df5_Device=CPU_Config=() -1633:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=30b790c0018dfbf2d699b7518dc62d7b1d8944cfe0375174e03f00dbf33f1c19_Device=CPU_Config=() -1629:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=b729ddf6b689006067cfce88ec7d9e89268dd6cd904e4596717016541632b13b_Device=CPU_Config=() -1618:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=cb67c5d0b8712ebac00fe4169f0cad2e0a8c71d7f9603d5d2ce6ff6dd6bc055e_Device=CPU_Config=() -1615:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a4e797de860d6e4dcec00062050168ba9745d3da953b9c644de654f4d2818b77_Device=CPU_Config=() -1612:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=351e48db45e09ca6c4bc54a271eda4cb2ddd69ba43f361b9915a6588913768b0_Device=CPU_Config=() -1612:conformance_Erf/ReadIRTest.Inference/Op=Erf.1_Type=f32_Shape=dynamic_IR=e6f95710a782b6c7df8397480e5cffbfa773fdf4ef11c93b2b1ac4694313b080_Device=CPU_Config=() -1599:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=af1f864a9f4bc94bdb713b0fed3f4c39dbd290cf7464f3cee8f1aded11981d4d_Device=CPU_Config=() -1596:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f9f701a7d26d77a2b1eb3cc822efb5da95f1edbe614469f725a381ce892d8d91_Device=CPU_Config=() -1592:conformance_BatchToSpace/ReadIRTest.Inference/Op=BatchToSpace.2_Type=f32_Shape=static_IR=f118f5911730937f9dab91ad5eb6f78cb1af6de7bae1dc745dab2d4f02257fff_Device=CPU_Config=() -1587:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0bc70791680aff885fa6a5903cea30fdb2386e7720403a8e6698362c5491a877_Device=CPU_Config=() -1585:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9991a1b4140ee8e6ed0460fb384b7729f681bc1068315a4d970eea59dcc89950_Device=CPU_Config=() -1578:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=33d8f6d258ae8dfd09b8e6fd39f0e74384eabfb685e0e72a3c798101ea56a1d2_Device=CPU_Config=() -1577:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=154d7358887845b8f2a661e79ef57318fa9499ee5c19b7cae461b6f798c57b36_Device=CPU_Config=() -1573:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=97181a6433949eaef7277fdfec4f8f94b27463ee3ed4a6aefc678fdaf7eab4db_Device=CPU_Config=() -1567:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=992d8967c619d96c75985952485fcd79b943ac5e71c40457eafad4b71bf56a4a_Device=CPU_Config=() -1565:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=7798cef9c8734d0908103b3c42fd7fc791806ad61d35dc680dc43d9597c6f1fb_Device=CPU_Config=() -1558:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ab760f0d90b0fef133a0555cb2a5d40fb525aef88e6568c5387a87d7e82f67f8_Device=CPU_Config=() -1555:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=c0c3d43548fe20fc4e63bcfc8ee6d0a70a6076dfc0ee79e31fdcecf6cf35921c_Device=CPU_Config=() -1550:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=92c3646daf445784fceeb022afba2831938fed34660bac5445f033a1efdccc34_Device=CPU_Config=() -1539:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=() -1535:conformance_Proposal/ReadIRTest.Inference/Op=Proposal.4_Type=f32_Shape=static_IR=c0884ce897724cace24b30df395a33443364f8494f1f8495d212f2db20fc49e2_Device=CPU_Config=() -1534:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=bca72a16df5bcf81d10dfbbb0e53aceb2a8a70ec94d4247d47333679de7214c5_Device=CPU_Config=() -1533:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=bb5cb4e2a8cb9be32332ed3255c99de478d8d2e31cfb1747aa322df438ebaa49_Device=CPU_Config=() -1528:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=90f882a97d637e527900edfb1b7c277b65544832793d08efdf8454be21a2f496_Device=CPU_Config=() -1517:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0f623457008d91f7fcaead549e4a3f90a5ca77dd7c52fba19906f559c34b333b_Device=CPU_Config=() -1513:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3c7d4160bf883d550620e8d1ceb54b3d78bf1512388b5ee57e1a380949d441e1_Device=CPU_Config=() -1507:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=539610c21b2839b71cfecbb15b7b7145f9fee8bfef8ed9e1d73aaad2de661496_Device=CPU_Config=() -1506:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b2fc03d707298e863f83bd3912617e76e63d0fd922c87edf912c17bf51cc1fcb_Device=CPU_Config=() -1499:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=ed75de35729f20a3285506937672f78d2d5137851a3043d15f4eafc040768fc8_Device=CPU_Config=() -1497:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c3e5791580edfc2b522c8a3aecd33445b3fa8d771e2b5a8387ef0f303773c848_Device=CPU_Config=() -1494:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=966eae58d5c103f24a598a5143d7b3a3c40a12fa2606a65431f0d1aef855cd32_Device=CPU_Config=() -1486:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a0b3d7813e380f287a758c35e56e8e8edbb72b8c64fab6194a8890dacd5e2f16_Device=CPU_Config=() -1482:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ef702f626a20bec33a58f2596e4e6e15f105860ebfff1d6f42116a514d853c4a_Device=CPU_Config=() -1469:conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i64_Shape=dynamic_IR=0d660483dfd9c9975f102d300ec98da49785fcb6484b379c45df8a61e1292797_Device=CPU_Config=() -1456:conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=() -1446:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=fb6a053d244fc1bdea6fd5e69e0c05025272ac0da2f676e077c598239b6493c2_Device=CPU_Config=() -1444:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=42062545b0991e415aad8d29d47de2a278e5791996ea55974411694aa821b54c_Device=CPU_Config=() -1443:conformance_SpaceToBatch/ReadIRTest.Inference/Op=SpaceToBatch.2_Type=f32_Shape=static_IR=8acd95619121cb22760fd92815b1ba85f541f282d3860e910f73036ed335a9ee_Device=CPU_Config=() -1436:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2bdfd42ec67d330dec8ea2817499b4c2d32a3d91deccede902acba057b050c49_Device=CPU_Config=() -1430:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7c8594e723d769f8817c58fc16146033afb91d821bc941dff944223796029f8b_Device=CPU_Config=() -1429:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f0c4dee4dcd8f03dd599ae04d7dd6ccfafc4d900d052a62f232a5507ffc006f0_Device=CPU_Config=() -1427:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=c3f8bb35f2f4473c563c3e5171a8fdc6f7a0ae20e4acde31a578bd20630952fa_Device=CPU_Config=() -1416:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43ba20ec70e156f4782e1f11a30f02daaaafb2039912a373620d845e995c97cc_Device=CPU_Config=() -1415:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ad640e033c11cf7d81ab237630f0ba656968f620eb4ed77f38cd79c6cbac42f6_Device=CPU_Config=() -1415:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=351e48db45e09ca6c4bc54a271eda4cb2ddd69ba43f361b9915a6588913768b0_Device=CPU_Config=() -1411:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=634db7c7a580a605f3375f671b3bcb2a1baf5856b32032d2786a5f8061df63c3_Device=CPU_Config=() -1404:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e7b65875a7e2d88532271dfb93a4a0fbe4c41963fee3193cb3de547c19121f78_Device=CPU_Config=() -1404:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=923032e47821636c4c8098a7a9afa97b331a47d47357c780b7bced2e46ea9921_Device=CPU_Config=() -1403:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a05c6778a396b4eb89a5e112fe505a41f47ff6bef50fa025eee1dfb7ec6a95e7_Device=CPU_Config=() -1384:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8484c5c087ca8317588ef676a0cafb63ded379be5bad862e4d0504f43bc6fb45_Device=CPU_Config=() -1380:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a08cb2499595ed0de5c51e3b0feae24d9d5462d227572e771862564e1875b6ef_Device=CPU_Config=() -1374:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=df8ed5b481f6b03ca63572f2059d20911d3a7757f4c032455bef9933f2c1dc35_Device=CPU_Config=() -1371:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=3e893f54d0ed092823ca8e256e66c367f53e466f30573a7b5911a432d88299a2_Device=CPU_Config=() -1360:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=e939c4d2a27e1d7dba93827ab807881c32e47d48b726fec701712bc85c3404a8_Device=CPU_Config=() -1359:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4a3c7edd1efc847f3d1255738c19cdaa682c9348c0b0bfc466ea9d5749d5eca4_Device=CPU_Config=() -1354:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=f2995592ad35fbaf52873e0180081397916db8165b9596166e8d449e44b57169_Device=CPU_Config=() -1345:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=fe80b80ced0033aef6f7f97abd22de1271430f700d7dc9aad9a2a819f91e11a5_Device=CPU_Config=() -1330:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=fb8064c0836e50254162e2a9cab01514f76b19f78084410b6d1b69bd54f93168_Device=CPU_Config=() -1329:conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=() -1324:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=dcfe0aa2fab0afc3b370be59184a5e59c7bc0e8b2930bb671d1d6b38f55234ea_Device=CPU_Config=() -1321:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=() -1312:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=() -1311:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5176d95c14be776a4247f25a469708ba7976378b7aa8860a115a28a8bf2c2902_Device=CPU_Config=() -1308:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d27e8ca8280dc9219f4b76a2c8f47cf526b32a58710126c7549e2c04026944de_Device=CPU_Config=() -1305:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4bedf955c6ec574258a05f59e5397225e1360ba68ea49d4fe105d6a62ccb3e97_Device=CPU_Config=() -1299:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f1f52703006b7d81ccadfa1c54db42d8b19ac7b8beb3ee88f2d7252170358d90_Device=CPU_Config=() -1295:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7cbd5676618d9b507238807c281801b8a817202b0ae648a44cfa32fc16c02547_Device=CPU_Config=() -1292:conformance_CTCGreedyDecoderSeqLen/ReadIRTest.ImportExport/Op=CTCGreedyDecoderSeqLen.6_Type=i64_Shape=static_IR=117fa486a51d9715d9ba1ad90cb5d6741e762cb36ea55a91129f1947b4886649_Device=CPU_Config=() -1290:conformance_Ceiling/ReadIRTest.ImportExport/Op=Ceiling.1_Type=f32_Shape=static_IR=1484c3d0a5a8b6d1daa002e27b07bb8ba0b5d83aae50b0a3b3bea08483815d55_Device=CPU_Config=() -1288:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b91ccf96246dcf055dd9122c823ccc54ea572f1ad8fcbad3a98c88edb7e454c4_Device=CPU_Config=() -1287:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f99caac2fbfafe61a686cc29c0df0779eae1a0a1826f5bcb820048ec3c148207_Device=CPU_Config=() -1273:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=a714d51739b3d420cf27f476e338bacbeabb40d0ced1e1527587756265253d8a_Device=CPU_Config=() -1258:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0f623457008d91f7fcaead549e4a3f90a5ca77dd7c52fba19906f559c34b333b_Device=CPU_Config=() -1257:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=f32_Shape=static_IR=dbc3b2f724614a68d750ae4adfd7d8239c77ced05d30f89deabe272f104a5e75_Device=CPU_Config=() -1253:conformance_CTCGreedyDecoderSeqLen/ReadIRTest.Inference/Op=CTCGreedyDecoderSeqLen.6_Type=i64_Shape=static_IR=117fa486a51d9715d9ba1ad90cb5d6741e762cb36ea55a91129f1947b4886649_Device=CPU_Config=() -1251:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0ffc7d7836be264b6d9f26daa71a8c7100ae6bc6fa1af23614a2736226fbdf0f_Device=CPU_Config=() -1249:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=72eb2887828b5b14b41d001b6c7277d395f39c8003b9461730a938833899aacc_Device=CPU_Config=() -1244:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ae538f87e4d49bbdc53184fcaa6082eee131a79b480dab9b46e12976d01ea913_Device=CPU_Config=() -1244:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1ceb1c4ba1a45cbb5cabe7cb4b416cbfeb93f24533c8123e4c2315cc7e9f40a5_Device=CPU_Config=() -1242:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=64551d094520cf00d40fe514f573f5f37f61416bd456474f4b0a21788c4ffd3a_Device=CPU_Config=() -1238:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d7e3ea8c5ea46f1b0430b6a2763c85395235c0ac58652e1d269e1257f6dbf7c8_Device=CPU_Config=() -1225:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bf235091db192c86756347e70771b4b00a6ac2c8852b93079749ba718d57d022_Device=CPU_Config=() -1220:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4694d5512c7f6b97213ae6c93eb6f547e57922279edf34b94a8e45b7f6a9a980_Device=CPU_Config=() -1215:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e6aa73efa73e8b557d46457037aea3d6ba037b67ac1b52437354c2823abf2be8_Device=CPU_Config=() -1215:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=bbe05f014b2e4602f4e44d9c07795321404d2459bf782d2dd406de14bd2bd523_Device=CPU_Config=() -1212:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=185e849a9d8fec26bd81b2098d63bd842d34dc7a8ee7e47086a208e4b8bd9298_Device=CPU_Config=() -1203:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ea604e7edf80c14a14bf7fcb042125f4d666d0d69ce3c0209c2f9dce26d406fa_Device=CPU_Config=() -1198:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=97f8a2367c5590d5fe7e405d32ec48e5318a6cb3c0862f2b0e8705a7842e8105_Device=CPU_Config=() -1192:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.1_Type=f32_Shape=dynamic_IR=7cb8f8f3f3b4335221f85190d4bc29dd28a6b99133ab630a5ee04640af0843a0_Device=CPU_Config=() -1190:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dc9060efbe22735c22c69f0323c7e6a77a30cfbaae7b79670b9b26fb2be70_Device=CPU_Config=() -1189:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=8c82cead166c3db4616f034b66c4795cb4bed653de41d2b6dc71b48ce76a296e_Device=CPU_Config=() -1177:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9cb8bb36dacdb562fddf77e93890fba560c6cdf038921e057e21f3e5e458c88e_Device=CPU_Config=() -1172:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=922699707423c4110bf8a551eaf7dc3689fd3673fff79cca21442cda90c22dda_Device=CPU_Config=() -1160:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=94693638ec4742dea16dc168eb9323995f1b2a35a53f577cf58ac3a08096892d_Device=CPU_Config=() -1154:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=319c7b312e9074a43819b034ce82eddf1c8f9e51d4eba3fbc7a112cb6393debf_Device=CPU_Config=() -1152:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=8ef34b5ce0dd0100a8efad53b3b71e87f76ed69496cb6f030e76478d7daddf69_Device=CPU_Config=() -1144:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f729a1e882f1894319a357f6c5474552e883ae9322cc3dc399b3a292b13e6de4_Device=CPU_Config=() -1138:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a45c7a05cac7f403aae101f22fac53b2697d90dcade1bb550200ce439cda7914_Device=CPU_Config=() -1136:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5b6503944921be5fa3feb0b7647c6715465af16702c645dec4e2f2556d8d679c_Device=CPU_Config=() -1135:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a48d232b00b4d4a735d6b9999c29b413a32cd7f05c104610a11cab01465a3887_Device=CPU_Config=() -1135:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=dac1d1bb4f11cef03519894a2853742d914abb0e3225b7caa3bc5f23d167cdaf_Device=CPU_Config=() -1133:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=313740a93070bb3cb89143685b7521ea0ace30c3f6d510a4d83ed809808caeac_Device=CPU_Config=() -1131:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0f61e4837d11be2b01f69947cd0b424a45d2e548d9c70ae53b07c43fa1237cd0_Device=CPU_Config=() -1130:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=8919e05ab2b0d545cabc2e2732828fa693c8f364e9d4d03faf7097f787d4f628_Device=CPU_Config=() -1128:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=bd3ed1b35506cb92c8e587acb102c70abbe02bdaa75f76e5792d48d8e1f2f33f_Device=CPU_Config=() -1126:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4fb0809c5cf2945a097d18f445de6f4f5cd2c124cdb495e6f0a12e9d937e2b80_Device=CPU_Config=() -1126:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0b4b74693c2ec96e714901b1acc772655accc3b29170cdb64ae934003338b296_Device=CPU_Config=() -1122:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2e1d1400763fcb89889255855a5c99dbbb17ee5e390e891c94211308fa2d725_Device=CPU_Config=() -1117:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=577ff3f9c8d226d1899056073c0223ae2d81dcc940c5fef8b9ce9cf63931e9e2_Device=CPU_Config=() -1116:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0a16d9d3d8d553c2c747b2c68b12eee3dcc016e29e597992cad8f83aff0aa759_Device=CPU_Config=() -1116:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8108f6881c436dfa59a0c27d173054c885f082306ae5af1694cdede13718bde2_Device=CPU_Config=() -1107:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c6abba035865ece7c6c44b0284ab7c6b8f735bc1ad1f75a9ee3bae6ce26c58fa_Device=CPU_Config=() -1104:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=dynamic_IR=43ceadf05184954dd8697d4f737de323ec2ee75f93e0d33d60dab2acc995f3b6_Device=CPU_Config=() -1100:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2cc5f8b67a407507c1d59a08981887766d377c7368b53cb0a18ec71df291b1f2_Device=CPU_Config=() -1086:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f8ee6adb1573c51bcffdd8c24455ecd6b6fbf04f171e9aa5de36c5d6f18babe_Device=CPU_Config=() -1085:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=25ae6295f4d206fa9069e20bc659dbd87c20aaa15c3f149ab25d003641c738c5_Device=CPU_Config=() -1079:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9f8fca1ab855d5a71d7acabdefda202e270bf16b559fd581f9e663caa301ffd7_Device=CPU_Config=() -1078:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1457b3d8c7f130113d74f540dfbd2d4062f869018f7b1afb11c743acc0a007b9_Device=CPU_Config=() -1073:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d141b35e277394511f5635b2e395039c986ac392e6f49c2415da6a5071bee96a_Device=CPU_Config=() -1073:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b3cb0ba09807204990d7e1635ef35fc96aa10330de2ffefd95f6483e68dca532_Device=CPU_Config=() -1071:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1e9f662cfa263a98c546e69de318268918914f2ddd0ee87cba23c2690a81ec19_Device=CPU_Config=() -1069:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=93788242c06d787e33afa50ecbef5372898e50024d0c88624056a752535572bf_Device=CPU_Config=() -1067:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4baf5444c85028a4cfdedc5888a7cd403e2491ab694ab65c820dd3c410f8eafb_Device=CPU_Config=() -1064:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=269ec3789c76e21789e01e31f13f0f1a4895905b3f131e710e663ed2a0d8f632_Device=CPU_Config=() -1062:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=62409191ca760efe019eed9d1923c8df9ab545d39f90b1230a58d1747d3143b1_Device=CPU_Config=() -1061:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=3ade42cfc9d970963d8f162b001075864e6967034198986f408ec09ce4093d18_Device=CPU_Config=() -1059:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=de01a0d560bebb0018927f02409922427ef35b59a96f0aef8f18991ee0d9542a_Device=CPU_Config=() -1054:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ede6f5f8a1d9bcfd1979965f575c8f267870e0d6a5d3a62d229ea029893525b6_Device=CPU_Config=() -1051:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e62245706f4242ff86bcb70d4d221bf49aa31db3807698d574125166bff5f8aa_Device=CPU_Config=() -1051:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=() -1051:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=165dc8f683138c4d731ee850aa6212a70851b91630cc42e2b4e9d46e0ab15b57_Device=CPU_Config=() -1046:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=641b1e74512a5cdc87bcd63515a28a409f155a3475fa923e440868e563daaffd_Device=CPU_Config=() -1045:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5d522332a7166265867b633721d8bd8ff23a233e7c8bff59a245bbb24d7be234_Device=CPU_Config=() -1041:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=14108fac0139d5bb39f6b2106857e1ac91c8d44ef9156e4e0873facf9d932316_Device=CPU_Config=() -1040:conformance_Mish/ReadIRTest.Inference/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=() -1038:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c90ac17f02f16c647a0a206326f24ac348a0f8a7787037486e52ecc8c091818e_Device=CPU_Config=() -1036:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=9ec266d6550d7e0c9f4d6114272d7afc80ad822b0bf5078654598b3d623f356b_Device=CPU_Config=() -1033:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3ebf4d995c8af299693b32b6adabb6a261a3761137ec6c5e68b35bdf0942bd85_Device=CPU_Config=() -1033:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3c03ae2ab13dfccc85d9909840eafb6a291b978e9bf859f27886b4a0d3e87ffa_Device=CPU_Config=() -1032:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f18fa21106120cecd81f50d635b1c42cbd641877ffbf78e746ef7375ff546d7d_Device=CPU_Config=() -1028:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6903ceb67d029d79d90687340dee0204830d5df1f1ea6fbb09f14a6eca234739_Device=CPU_Config=() -1027:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d242e8ecc8ae0239fc2e7773fe0f8a1d50792a71ae4aaac4fd439174e87e95b1_Device=CPU_Config=() -1026:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=45959eb5eb391b2bc86455cb1e86aca76799c6b082437e72b15c171037a6206d_Device=CPU_Config=() -1023:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ca3d0cbccca665493e85a757798ab5e12399ad295466cea744c7a2d278c86c97_Device=CPU_Config=() -1019:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=b7b0a0b3921a1e1434a3fef630e32b124c810e8bd15a3e861fe7da79158947b2_Device=CPU_Config=() -1006:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2dd63d58c85301d765882b95995de97f4eff14bbb3c933c4e4b8ee5fbc2e9e71_Device=CPU_Config=() -1005:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f2403b7d119fabadb1609250bbd0959aeef2cd68c62a4036657518ebfbcedf71_Device=CPU_Config=() -1004:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9ea20be5797b5ab937555c69751a5be584c73a191b3fe3d6fb96a5665e26fcbb_Device=CPU_Config=() -1001:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5c33d593e408ad72bf438729a423318330c69c69f1504402420635942050ac06_Device=CPU_Config=() -994:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=997a090766babacae10464bab19af5db238eb28704c6d463cfcba48767a90c8b_Device=CPU_Config=() -992:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b63e04695c1e6145a3fa9835130a4919df52ff3a420d3c800bddff65af7dd76e_Device=CPU_Config=() -992:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=622add2dcd72d2e1560e983ef4aad56fd35b48b71964ea8204137026f445d37d_Device=CPU_Config=() -992:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1891282a9bf460336bad3c354519aa0d87ba6ef40876d4a07592194d2d678e25_Device=CPU_Config=() -990:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=178677f6c6e3857b2c3aa8765c8e3186bd25b73154ba6463ff33a9e1c911e6bf_Device=CPU_Config=() -985:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=59eaeea8102953f8ffe85ed1ced2a44ddeed77ec237608b45be0573bb32b1104_Device=CPU_Config=() -982:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=f1e43476084575ad240db6631f433a61ba2076d1ca95e44a0e4471ea9d6f66df_Device=CPU_Config=() -981:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a3e1aaa7054d4d046bab4614737c931b25a574051a2f8b79799aaf6fbbd2c2e3_Device=CPU_Config=() -981:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f71810b04667907bc88c4a1ecc28b9325fde04026b5e56b5eb0e2d6608f3742_Device=CPU_Config=() -980:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=2620e86e1e6ce8f0ecb3eebce969f3e7df11f7f86c6f97309aa24993f9036033_Device=CPU_Config=() -977:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=017d4b1dac18731e05634414942698ecbc750e306eb86e773ffe5007bfa9feee_Device=CPU_Config=() -974:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e00cea4f2ea99f32c11ea265ecc0483554192192bb99f36438dd38de09820888_Device=CPU_Config=() -971:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9cd66958dfe8db471d48d6ea35f1b4547a413fcdc6c61c804a456befcbb09d15_Device=CPU_Config=() -966:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2058548f687014df36b4da1b2644f07fa117d5a1d303a13c4d913a3f979d3ed6_Device=CPU_Config=() -965:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=4e6db028c1ff414e411bc09accf3b7c20cf81e530c903e14586eaad4c21fa111_Device=CPU_Config=() -963:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=35525421f74fa15c49098ff1c7faed4fe65763d72ed13add33c6fe8d4dcfb0ed_Device=CPU_Config=() -963:conformance_LSTMSequence/ReadIRTest.ImportExport/Op=LSTMSequence.5_Type=f32_Shape=static_IR=1f24aeeef6f9f91272546fca89299c1ce448b0008fe43905db434ae3f28a75d0_Device=CPU_Config=() -958:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5976ce31ff4cf399e87efd691dce3e75dc2de962241a84c09538593c9865b257_Device=CPU_Config=() -957:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=acaf36c12445c608b306074ac4e2be9cfde2f5550905993d4b5bd1714dc96aaa_Device=CPU_Config=() -955:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=028177a440f430edc5dfd7a7f0f2c0dded422876a98b6da66a647ad9aca10e57_Device=CPU_Config=() -953:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0dafd9117cb3fba3a335f7cd28aaa3fbd9276878383657b357210e135a93d916_Device=CPU_Config=() -951:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d77f317dd01a80955f901d0da2930aa1f82531848f4bf22d839c60a84941e6c4_Device=CPU_Config=() -948:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=caf20ebc8d39cb23a107a03e819e8ee5b2807fbd311fe65453446251e4b6a611_Device=CPU_Config=() -947:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7373e7e64fbb2fabed337c09be0d6b42c5cfad39b26d92c6dd74810499863448_Device=CPU_Config=() -944:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=285bcc240dec2c32e171f3866ea33107a109566fb8ef39f0dd84e99664aaf8df_Device=CPU_Config=() -943:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=b6417017678573faaf72824d1bec40bcccd73ae0007aef24b089dc3743276b14_Device=CPU_Config=() -939:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ba15b8b85609531d91c7809eb90c3a0079d19d36b83c8767306cb276c9d67ace_Device=CPU_Config=() -934:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7ab51e173b82572bfb29cac5dfdc326e3689e466c68cf91590dcbdddf1f530de_Device=CPU_Config=() -929:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f9e738e5e947a25c9a0d18fe47597f10526e8a74e9d72b35fd848b73f4c80b0f_Device=CPU_Config=() -927:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=45c9fd0289649c455939587c623f1884a4e675e2f970192d9ac2f60a65e6da9a_Device=CPU_Config=() -924:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e86061c75b7e9a65644e82de6b8fb2a532ebdfb302f46f378b6ff20af8d1d14b_Device=CPU_Config=() -924:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9795aaeb71c115680b567eab0877df338c0d8971858b489a2636c4483f3512cb_Device=CPU_Config=() -923:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6587874c50811a2ca7e27f84cb4381e9a06eb4465e940ea877c76dfaeba02753_Device=CPU_Config=() -920:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c6b8f476c9b5cf1a102cb33d5e68033bb074a520d01e360ff46b3e479addf407_Device=CPU_Config=() -920:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e7e10785757d3131ebc375ebfd83c556e2c34a72be20965d9dd3e4f24a5ee2f9_Device=CPU_Config=() -920:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=58cd9ea3d8db317b6ff7fca55bebcbc6846aebdbe309b1b621f5535b18a70320_Device=CPU_Config=() -919:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=() -917:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=574e53e574b1a6e0bc16a7296aadd78785cac535293e956b008b0a2274b7cb36_Device=CPU_Config=() -916:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b42c98b6313e56a7a012553eeabae92f0672c0bde6f9895d10fb459796448b75_Device=CPU_Config=() -915:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=bea169459345470ab5d89e5ae9a8b67d6e9401caf7dc35f5060805152e20d6cf_Device=CPU_Config=() -907:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6624c22e3b5d72c4e8d21df59af6f3759fa4d8fa68f2b5f3f92a98d6a943d0b4_Device=CPU_Config=() -906:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=776b4b6d6b102654bbc08df901869e4d16af505a5dff7f2d27686874bd20ccc1_Device=CPU_Config=() -905:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=8832b317ba58dd0efd1e8fa5238d35644d8468a03c9b35809a20ae64098dc986_Device=CPU_Config=() -905:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=a58fb7847e59bb119656b143af0c6f65e29f8211034fe7aab03666cdb95d7fe1_Device=CPU_Config=() -903:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=516b04726c16c5c01fbeb1c97f8f9d9376b80e9341d2029c634f7fe4975cc4be_Device=CPU_Config=() -901:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=750599c4cdfcbe7468328647a8760c7249a9f5dba8bc33ebd00c151d9f3b13f6_Device=CPU_Config=() -899:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9650ac479045f70fd763f5c95d0c27c3b3cc4d6fc00b43e8ad627d16f817f342_Device=CPU_Config=() -898:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=43d0f2c259414c3e23105e2f5a13e8faaf322904d9b70ceb8a056bdb51677ef6_Device=CPU_Config=() -898:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1180dfe50d43ef6b95980bafd3b84816f6d249f8341b03a6f67d20bd8f8ba6a4_Device=CPU_Config=() -892:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=81954ff76e3fd04ec3b3e3c26e28a79ac259c9b255f90ebe3cc0772fb673874e_Device=CPU_Config=() -890:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d8574c324ded923f1ea3ab0d8e09c626f3e8a04efe08258b665539c639b7958b_Device=CPU_Config=() -888:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0973b76264164ca52a9883a69ff5f7df977e28c33a0dbe9095e7e92acd7854bf_Device=CPU_Config=() -884:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=afc2cb913bcb4e4badd203c9cdf491ea1e6ed4f1cd835e7507889a9bba25b958_Device=CPU_Config=() -881:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=06069a23d29d9bb6910729ac49ce1466e4fc6185c6ca31fa54fe7dd3289c41f7_Device=CPU_Config=() -881:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=87523dfccb2a9c8334d6810e33c2a2d3b6bc09db7623e7ae93ba4cea89b66a06_Device=CPU_Config=() -875:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=27b03da9a0155039856b1bebe424d10d1b8ad768747cbeb851bfc0463edd5cb6_Device=CPU_Config=() -875:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0ac57f7cc81a683585f810885288fdaa174de2497d00156b85e067653aad3a56_Device=CPU_Config=() -874:conformance_NormalizeL2/ReadIRTest.Inference/Op=NormalizeL2.1_Type=f32_Shape=static_IR=acdcf37615b571d8a1275b71cfe0c43a6410e56f5f18db8e9d795e46aac73d0c_Device=CPU_Config=() -870:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d12581f68d14d140f4b982b47b97000f6b666cd115483247d369fed87267556e_Device=CPU_Config=() -870:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=52ee24baa14f302174ce3b13a119ccb6a54994413daa1f052a75464528b07088_Device=CPU_Config=() -868:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43a00b4dc097228af52c00054951dd5b57d8e0086207f11a8996e5ac880c8980_Device=CPU_Config=() -861:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=20c2030cdd180dbbfad1e5b8a4f865d1757a9d427c3d5ff21651a429369f4341_Device=CPU_Config=() -859:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2b59c9f67435c46699dc1c66ee7ddbdd333bfa544d0aef7bd1389db2635868c7_Device=CPU_Config=() -856:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c9352ef8b6aae01025051f9c73f023e7b5a13f8987f81bfff4ce0ff9725c21b5_Device=CPU_Config=() -854:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b01e9e819c2e610a4fdedcb693f536f99b9dbdeccfcf9b0e70dc37c19c365421_Device=CPU_Config=() -854:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=31e75a7408a46928e1a3a8babe3da21bccc6d442f87291c0b2bf57b29e18face_Device=CPU_Config=() -853:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=839faaa50aafa2e3ed38fc682d0759304b694043dac1a242a085e2973aac8091_Device=CPU_Config=() -852:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=40c74727a381659b1343c4083d7f903ac2519d5297703fd15979a32f820adfcb_Device=CPU_Config=() -851:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=46282ba6f0eb5aac6acc1e114a2408cc301300a027c6d7a05691928b5e6dd9dd_Device=CPU_Config=() -850:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=f32_Shape=static_IR=f5807b455d9031305e8225f2b65fd5cc289f61785d762f19a275280085a2e5e8_Device=CPU_Config=() -850:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1eb25d18fbd1070f2a8ff803d76077d092d493f9e9df80e93e2f58f3621a121f_Device=CPU_Config=() -849:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ab760f0d90b0fef133a0555cb2a5d40fb525aef88e6568c5387a87d7e82f67f8_Device=CPU_Config=() -848:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=f3d84b4cb7f301c6b64c64927dd1e8c20e144671419843ed3d20692f0773445c_Device=CPU_Config=() -847:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=() -846:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=429b91023f3ae9a323e40ed372fc29926fcd6aa7a8e77e4ddaaf68fa648c43b7_Device=CPU_Config=() -845:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=874c0fa19029457645c4cff20769f66ba7aaa1a35ade84c948f83aaa9c1ead19_Device=CPU_Config=() -845:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=09683cb2a0a44acb804a2791ca93bf004bfc3882c11af94ea67a9fc1eb1e5052_Device=CPU_Config=() -838:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=() -837:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5288d099588f5876e907c5cd750c9f0b2191d1ea060881e80af1006cfad259ac_Device=CPU_Config=() -836:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f729a1e882f1894319a357f6c5474552e883ae9322cc3dc399b3a292b13e6de4_Device=CPU_Config=() -835:conformance_BatchNormInference/ReadIRTest.Inference/Op=BatchNormInference.5_Type=f32_Shape=static_IR=8f1629e9b003409304f12c3e315e8ae8246b3bc80208c3f612d5c5c179082a7b_Device=CPU_Config=() -835:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=9d26a7c321db2d87b29b93baeca20dd25357e7777261ea6a4cbf968a203969ea_Device=CPU_Config=() -834:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e044b25aa265a98dcd0a5cf5f7132fdac5f36074068dc2210e04dd4c459aad61_Device=CPU_Config=() -828:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2d38082f8971dd7614234070dc9cb8c9b6b12fee7dc918503f0e256ab32d2fef_Device=CPU_Config=() -826:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6fefc3626ba6ef60433d3635bd5abeb3e7025277a86e2fd9d92234ff099c303e_Device=CPU_Config=() -825:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c599f8f5de2a73e08727a5e27e2f77989b4c5ce9a5e70e6b98ce4c87e8aa26f5_Device=CPU_Config=() -820:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a7ad8306fe632a2d0c45a492ad2d21dbe40f2f9ea55074d602beb6f8dde17982_Device=CPU_Config=() -816:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=12c56cc6ebb22e8e31d97e0ef640fecab5f93e5c5b2810c4dde56b09a7ac7f48_Device=CPU_Config=() -816:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=static_IR=2b026a0d21a35251b07099e31ec58c459b848602575d2afa67e55830e8f3f411_Device=CPU_Config=() -816:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=23654f4a28ae697d81f49d72568e7f0657d5c15b82e173fd7381760ebcb61cda_Device=CPU_Config=() -815:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a50644dc2d133df429ff4aa6a19ca9bafbf41d2948522e584fc5f417ad16d76c_Device=CPU_Config=() -815:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=7244cd4799e0eab987f823edc7d6038b76afa7585e4663278be826124c5596ed_Device=CPU_Config=() -814:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0bb9a29f02d37ba32dc29b4284f58e10ce59571799f58381d449c77655c795d6_Device=CPU_Config=() -813:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4104a7840dc96c214be896cac75911b70baebb902a42a26f12b281bc2cd87318_Device=CPU_Config=() -812:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=59eaeea8102953f8ffe85ed1ced2a44ddeed77ec237608b45be0573bb32b1104_Device=CPU_Config=() -808:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c9fa96695ebc82ee5e83b4cde8910e54ce09611f304f24fb6b3faa692a21c60f_Device=CPU_Config=() -807:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4a80814933ec1c6198745b1caa4d5b7c9171395b6d8a53cd791dcdf64fa6c91b_Device=CPU_Config=() -806:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=55d83e2240e88295a78084f92162888c9b0beef46ae468cd7ab93a1c0a432835_Device=CPU_Config=() -801:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=93a9a06d14c3b4d51891ff0e704c74dae5905db9b5de06d31379f33fa685c80c_Device=CPU_Config=() -801:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=28dbc474828462a812108c43a47aa4e70fa0d2e8e814bef5916092f3e8c7a2fd_Device=CPU_Config=() -801:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bbb0129fbafd6d1874ccef37a1bb60379733012c502d58326dae70f413e387f2_Device=CPU_Config=() -798:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=83d90ef3fac993f7efba4a8ed369781571b1b536af03ceb0267ae979379e1dd9_Device=CPU_Config=() -797:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b0dea4cb6a0cd2380e8657b0b64caab43819c0f8182ed73b2cb12eec608bfa7d_Device=CPU_Config=() -796:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=09d4b4ea324f91ba6006bad4c82ca08e723c83c1b862d8075475e986696220da_Device=CPU_Config=() -795:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b66a71c512cd06f5dc1d1a254ba0128b606c1c41b860f272dc1d2514502c2350_Device=CPU_Config=() -795:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b3fdb9be3484a0c498bf40f1a102c452eea04caa5b1dd627e8267087df0acc87_Device=CPU_Config=() -793:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=65afcce29f554c2dfbbb4449ea6e11f1f1b9b96aa5c8bf73a55796de849b58bd_Device=CPU_Config=() -789:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=f286960ead5b83e3e4015ee5751b114a9d70e90aa788e0fb004ac50b95a8fa2d_Device=CPU_Config=() -788:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5f45e938f9e6d58ccc6bf771049731f2d9c4a8b0ed83e2a1942ac69ab76984b3_Device=CPU_Config=() -788:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=c0eaf7f2465de396f92db5829a30b7d887dc26bc8d49b86f0fd0d688c7129e18_Device=CPU_Config=() -787:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a52a8e6ef7bbeacbc1435cde72a1a70bdb8a3abf78b5b971c2ecb1135cb4c136_Device=CPU_Config=() -786:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=1f29402ea664e850ea05d5f2e500f087a6165f1f4c9b3e5102b5509c020f0f6d_Device=CPU_Config=() -785:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=() -785:conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=() -782:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5bf1e9348ae0ec7106a2231d8940acc74464f5ecf0cbc6a682defc3a9bc5c2c2_Device=CPU_Config=() -782:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=43c8e8300f01242788a8cfdc37b48779f51f7ee7aef5b28e8de542320ba86e4e_Device=CPU_Config=() -782:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=073dca39b0ed99c8af202a5e272db241f95de1f64a7a1611e83853b92e7f7f09_Device=CPU_Config=() -781:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=a65e17fc28c74df4f3b1bad89635ccfc376a857f2d92ba646ca830b03eafab7c_Device=CPU_Config=() -781:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bba92f0e1fe2ee647564aec64223ab2c5b32d3defae9bad5daa5a24df76aac48_Device=CPU_Config=() -780:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c777366b6b37df3f4a3b19b637f66b707fbbb113972a9eff7eb4d793731f8c9b_Device=CPU_Config=() -780:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9efd5749a1591709057d6e97334c9b5b89f5864d705c91774e0196d42966d1b9_Device=CPU_Config=() -779:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=517a5eeb2f1f21304b8a1d5971f89bfc93aa678252180bdb05144657b1a8619f_Device=CPU_Config=() -776:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a9311932565e68fff052e15c1a0522e1c09270d06521541ca28b67c34184b1c5_Device=CPU_Config=() -774:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3a17c045930ed967b45d1606b78fdc92e736731b198465e95ed7268d99eed246_Device=CPU_Config=() -773:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=35525421f74fa15c49098ff1c7faed4fe65763d72ed13add33c6fe8d4dcfb0ed_Device=CPU_Config=() -770:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bee11d430236dcbd0fb5efbae712d8d89d84beeb89e0ee60e0ba3ba9512079f8_Device=CPU_Config=() -770:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=ef6e4b3910cac801199b1f6be74902b42105d23de549d426b1c4bcdd7361f79a_Device=CPU_Config=() -767:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=df97761393479b4c56cc923a2b89888b7c3fb949f5c3a93f4bba0ac8a44178aa_Device=CPU_Config=() -763:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0aa7024ee856fc832b1e639fbed60e1382c8e1b84f7cf2d33447f4bbd9ce75ec_Device=CPU_Config=() -762:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=dc350b3fec164adcb096b8fc922e342cf7b0c6f7a4aa25074bec5566225cff01_Device=CPU_Config=() -762:conformance_IDFT/ReadIRTest.Inference/Op=IDFT.7_Type=f32_Shape=static_IR=cf47311b142dabf10271ebf5c2e359455d9bcea82d95ad2a1a2d58915c77bb16_Device=CPU_Config=() -762:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=8b8121ebbd51ee995f98531f595145a01ba70ce026ad0bee588733c33e70272d_Device=CPU_Config=() -761:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=30eb0edc699f72085fb77a6cc31ad4aa9e62cf97befb64273493d234494fc64c_Device=CPU_Config=() -761:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=eeeaf32688af20dbc39dd3705dc09fc804c0636d4d5807b003c002eaab1e79dd_Device=CPU_Config=() -760:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=ade98724a678a73bf789fc539dfa277031242ea3a694227dae29c11b45cdfb9e_Device=CPU_Config=() -760:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2027d5da17dab73d23b4984fe88696fb770ba2fa479a194b3531d30ac75dc840_Device=CPU_Config=() -759:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=c7998d9fa7e16dedd52f8cbe3d0814f2f3b30ee6d728881d64c4743e0ff6fae0_Device=CPU_Config=() -758:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1c73b4d05053065f5c37954586376ae4e1cf9e220959363b7c2cb381f489bee0_Device=CPU_Config=() -756:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f5d63cfc40e19fff35078633a3354fe5e3a8b6dbadbc89e20747398d87e02176_Device=CPU_Config=() -756:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6e9fb2accb692c69349a88158442052e6350143ca7dc28f2525d8e8df29f8c78_Device=CPU_Config=() -756:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=4946bdb7dec06c2bc8eae33d5903d6fa41bbf3654b13a0cb5cfa4af5a4720426_Device=CPU_Config=() -755:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=cc2f28d736d3c67fdd13fbea9b8cef7c0b075f06b37034581fc732966421802f_Device=CPU_Config=() -754:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=15dd996f113d962d9bb21424d1006af0aa28376a2af63d791a80f0ab95a604fb_Device=CPU_Config=() -754:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=876a77d1e2efb758a87bce1dd2fe35cd8e455c6f3dd7cd2bed8e10504c426de4_Device=CPU_Config=() -753:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=() -753:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bfd899e1dd2a03f99d8b55d9fa5ab04c6e4576358c910e9bda97cf497f0418a4_Device=CPU_Config=() -752:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=86decc829c047a5febe7e5d047c689075810441a2f4725088317ef68d6c31239_Device=CPU_Config=() -752:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=150b1e03f5e8abf76f88e68ae56a3afc3cb3ae110fcb12af35192aaf93b20f5b_Device=CPU_Config=() -751:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=879bb4767167c3e9c45eacd08a14fb7e01b072864013784f924d62aad7b37c56_Device=CPU_Config=() -748:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a7b2c196b6ae12252522b2571af40b540eae94513bfbd88e15708fee816869f8_Device=CPU_Config=() -747:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b0376bbdfc6560184c2eb15a9cff7fc6d6b39c47dd22936fb64629d345e227d0_Device=CPU_Config=() -747:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=fe615eeceb735b046b190d844931c56223d45439021da3b6b23227a1f9cb73c7_Device=CPU_Config=() -747:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=87a966d3d3b90cb32db3454c5dfb2f67af86b68a5e45fa1c5f4a75c3b5cb452b_Device=CPU_Config=() -746:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=969c6a651dc204576d68d7d893ad2dbff1f7c74803b1763857d41aabdd19a72a_Device=CPU_Config=() -746:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=d435aa8d2d045d69b2d187147f90c879205f27346ac991765ba97bd47d4fe0f6_Device=CPU_Config=() -745:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=78db1c0e2c0fd4f0d351e66ce9cd31f7a6ee804cd23bc686b8c9081125b7142e_Device=CPU_Config=() -745:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=54a5630072fb0e0127611a4ae63db14b7c0fa0979f4d2be7bfec548b5291a0af_Device=CPU_Config=() -744:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=50c46a070e458a716446dafab20580095bfe902eeb4ad96c39bc2c617964c1d8_Device=CPU_Config=() -744:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=005e1b57ad768f4c8efb3116fe51bc85661c377e6632518b9172e8862d1c3edc_Device=CPU_Config=() -744:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=08fa156c3f25fc8836356fd1a8edb73222f9fe2b3476c0ae32a26636b5870247_Device=CPU_Config=() -743:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b339277c7465442a5163600e784319030de12cab4005f43c0b903bcd0c46e87f_Device=CPU_Config=() -742:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=008176749f0b2cb46830abe910865d8cf1974cd62902ce3e157a03df2b1cf9c3_Device=CPU_Config=() -740:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=319f74dd5b7a959d0e5443c76051fa5958463cd18ec11c275ef92b77321bb93c_Device=CPU_Config=() -740:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6964f870fd6bf44d1d5ee5925eee8892230b8928aeee1966db73b6c4fcd5acf8_Device=CPU_Config=() -739:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2fda32f5fe8957d151306845ffd0f877b2efad70f7bd4921fab2fd770d78c2a8_Device=CPU_Config=() -738:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f43df065734a36674b3fdc7a47fddd1cfa5c1b36bf73e7de86a100c645fbc7d3_Device=CPU_Config=() -738:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=b077af9b63e937fc64589d3007372d5fb2e4accc392ea09889a2519e3885413d_Device=CPU_Config=() -736:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=547fea7da34d5e65ad7ea069be003753e9ef281110c80dde11520bc350c4ca14_Device=CPU_Config=() -735:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=120b0e6b0c1f7bda754d62ac7c88e7c8bd9e96ddb85e7e5f29decdaa7c1cde96_Device=CPU_Config=() -734:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0ffc7d7836be264b6d9f26daa71a8c7100ae6bc6fa1af23614a2736226fbdf0f_Device=CPU_Config=() -734:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c4ae9be783990e398b3e8f0af76cab50d72c40c705677a3fe1c5dea592952d1e_Device=CPU_Config=() -732:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0f3e035b6571da159267ff1f89b5f2b2d3bbd599760dc5d5721a1fb2ab2ea75d_Device=CPU_Config=() -730:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=65a5483c793396983edaf7f2cc2c13898507525bd84a8469e97b2d662b5df782_Device=CPU_Config=() -728:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=68c3856ae6a30752004a5ebfabb93bd0d98446a91ba7fd84e686226f45d326b9_Device=CPU_Config=() -728:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=f645a2275ff33ad614c801a8f2f262ce1ca95417e0ca59e28d4b87cf3289c00b_Device=CPU_Config=() -726:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a5e5b588f6223da1508413c42c21c3945994f492b039511b7ba2e576a052a52a_Device=CPU_Config=() -726:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=dd366f3f5b63fbfce3d9378cf0d8bfa4a909a973bc3e5e97eaa9d346c5cbf1d4_Device=CPU_Config=() -725:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=fa88ad79fad41544d799f0333f83b91322f2bb408689e27e53bd175786ed0979_Device=CPU_Config=() -725:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=246f55d43a6e986a8ba35f711c43dd32cfb1ca097598b0a01690d4765e0d5019_Device=CPU_Config=() -723:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a7eb49934c05ef49a453b19adf40a9d4c2ea9477464e8d42858dc9517c30b88c_Device=CPU_Config=() -722:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=64d7467cf7785e52814a8c25f96c1a5d82c071ced27dea8302b5cd69b464ac65_Device=CPU_Config=() -720:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c0413244803edff103b95dbbcab27b2c714740372ba215264371a9474355a8c4_Device=CPU_Config=() -719:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8978b8e985b54cc12e2cefa8d9097f4a3a03d477129230b6c7e3daf8112e2c0e_Device=CPU_Config=() -719:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=71010d034cbc059af32ae6066fff1f27834db480e76042d1ef7bd1e7bc426a08_Device=CPU_Config=() -719:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=d575b00d2b6e155319fe7120133d8e0c3dcb5c79bda710b0650fa48543dc5c84_Device=CPU_Config=() -718:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=1a9779319a9cc5f21b6005ebb9b4517e0bb1f868ef8e568453a58c44474c40bf_Device=CPU_Config=() -718:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=deec30214c79ceb43a503bf521937a2bd554588775195d0e6302c521cd2b55ab_Device=CPU_Config=() -718:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=45d612bd5bc0895879f727cffcc13c978977a0aa10dfc726d00d6450faeff068_Device=CPU_Config=() -717:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=bd99ad9e1d756435cca9c6309caf45043f34c6c3c844f60e17deb8dfef4234f4_Device=CPU_Config=() -715:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=() -715:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0ce1ec496e5d71728fc5daaba87809c5922406a65e85823913381de0d2112e01_Device=CPU_Config=() -714:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b83a85737c23e279f8878f6795581dc2b003c55e4eb8baadfbfd73fb0e98758f_Device=CPU_Config=() -713:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=dda009a1f3191e35286b7515f5741905e303f27287041248e2ce15f6954af810_Device=CPU_Config=() -712:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0e78ae14fcef33de9637ac99e87f672b3247ea32c221a4b555b2e5bbdff88788_Device=CPU_Config=() -711:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9ba199e71a3ff06e6bd330e453a1e1103599902893fc267c60da9ae47575a8a0_Device=CPU_Config=() -711:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2e586703f4f8e9285249881d509a2a0b96d4758be5f97d75e7ee4f78951c58e9_Device=CPU_Config=() -711:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=176c218db11ea18f367fdf98a3de14e9a9c65152bbcc39783c38772b37f6e9c2_Device=CPU_Config=() -710:conformance_If/ReadIRTest.ImportExport/Op=If.8_Type=f32_Shape=static_IR=e178ca7afdd75b09f1ee18e50afd30eed0740497637863c3397b5a75c0f8bfd5_Device=CPU_Config=() -710:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7754523e2d3739481e051eb21a4347f2d157e94db3c37d47f0006ecd8d77d512_Device=CPU_Config=() -709:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7d3a099a5040e70c73014df347c478d0976123d68b6fcab6bf767f90bbdf8e6a_Device=CPU_Config=() -709:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=b574ee57274a9f27f6d0908cef2645c458983225e3cb82c455148e83337ee3ef_Device=CPU_Config=() -709:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=c1c38223834d99f4481cb74db2bc302710629de5807b4f08381fd01655b9d44a_Device=CPU_Config=() -708:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7d706b614d2b5d59c5e152bbb61a8fd558686bb3b8e9fda199c499ca49f03042_Device=CPU_Config=() -708:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=49b05f6b6a636d84beca451fdc1fc81e3411a100ea105fbcd49ef72ef1fa0934_Device=CPU_Config=() -708:conformance_HSwish/ReadIRTest.Inference/Op=HSwish.4_Type=f32_Shape=static_IR=ce108d9befa5ee87b0161e969c5ac986c176e468ecae9f66895cdc4fc6bad940_Device=CPU_Config=() -707:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=6e6c053ee1974a5d036c6d549508f6d43586d501c72db05df9930639ad745bc4_Device=CPU_Config=() -705:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=88e65a668c1bbccdf69927ed3926a7c273c97f72a7059d1d748ba6b0da8492e7_Device=CPU_Config=() -705:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=69c68c20edefc8789e62a7cc8a0f8fe7e649f884649ac30833fb5a2ce43c4098_Device=CPU_Config=() -704:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=45e4a607b0964915174f6a14de049a61a5740f258a4a71817e5aae1b93be5ae7_Device=CPU_Config=() -703:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=697bdfc59094203ea1616203d64759a40193f1a23a4a51f11340a7912e355cd1_Device=CPU_Config=() -702:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=21a3318957d920b39d8b3d84c76cfd2a5ad98515824f88145326deead0961486_Device=CPU_Config=() -702:conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=() -701:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e5092af5c0f683044b1df5a45f211f4a692436d1112181a5d613bbf335941684_Device=CPU_Config=() -700:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4c794e0e6b27bbef5d21922537d8b23d0d2b5955622c1f5ee724a4d8faf2c86b_Device=CPU_Config=() -698:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a917525b3e5a37fc2be5f35fd5a3d50b57627cd9b985333e082b169c29f848f3_Device=CPU_Config=() -698:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0495648ac153ca7bb07160aed49b620b855a89b368d363a22fb45ff3428349eb_Device=CPU_Config=() -697:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e7895756d4bbd8fc1d5f9794410daea2a42c1df95f57627cbad46e6787e6aa5b_Device=CPU_Config=() -696:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=cb7ad9dd22a7bccd73ade4d4aa78f9a25cc2bb7f0c08a01064491200089b3718_Device=CPU_Config=() -696:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=() -696:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4694d5512c7f6b97213ae6c93eb6f547e57922279edf34b94a8e45b7f6a9a980_Device=CPU_Config=() -695:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=29bb3b751638e157d0ba7114cc0e156a4b792a9dbb2bafa3ca124516595f01a2_Device=CPU_Config=() -695:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=5be0b1c69be525cbddd7996b695c1a4a9f380173d03f291e8570df76c050678b_Device=CPU_Config=() -694:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bee11d430236dcbd0fb5efbae712d8d89d84beeb89e0ee60e0ba3ba9512079f8_Device=CPU_Config=() -692:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=cd2470c72fa7d2238d2eca4d067e49a02340ad187681be2fa7e0bac6eab3500b_Device=CPU_Config=() -692:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=717ea579a24839ee9c5ba7c59a07af667fea4fd44ee18bf60e8970264852bde7_Device=CPU_Config=() -692:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=13e9472dcdeb5e6ce2928191ed13dde08b6cdd62c82c94e77469d8a3ed94e39b_Device=CPU_Config=() -691:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=be720054cd6d960249271114344ef2f4f36e2a2208376df70d4395a82386dd01_Device=CPU_Config=() -690:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d9db827de158568b8a10347c13216e92b37ec20d8eac92c38aabd86690114805_Device=CPU_Config=() -689:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=662ca1fd253f0a0c29b89eb1310ea5c7c87895533130ca1a8b76f791ef1ad99b_Device=CPU_Config=() -685:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a3370e3b46f385ea6e46137d49d5f1b4158fe08d0a3e9feb47a162f6b3640951_Device=CPU_Config=() -684:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cdc57df56ccf890a00f886c3b83f504d24ea9d4ed5f0ef05f1189879172777f8_Device=CPU_Config=() -684:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=65afcce29f554c2dfbbb4449ea6e11f1f1b9b96aa5c8bf73a55796de849b58bd_Device=CPU_Config=() -683:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f01152d615a3092ffd4ad1059779ea183d7a62c1ab5b970d940f3f537e6f12db_Device=CPU_Config=() -683:conformance_LSTMSequence/ReadIRTest.ImportExport/Op=LSTMSequence.5_Type=f32_Shape=static_IR=f36a3f626860d7088b33d97a5a6ce009c89609c142158b256aeb6b5e6dac02d0_Device=CPU_Config=() -681:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=0d413b2d40036984ce2b85933c4b5ffda416e8779a20b602095d2654db296d58_Device=CPU_Config=() -680:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=e7e985d4d02762d236131e74fd867acff1828bcd4c4eb32e190de20eadb831fb_Device=CPU_Config=() -679:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e2d2eef3e776af9379eb35540d8f4c888491082d8333aeb70f58822aa5cee878_Device=CPU_Config=() -678:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=47423c3e9443249e3dbbf58ee0f5b69b15e677f84de44ddb9d2851d1341dae96_Device=CPU_Config=() -677:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=76ef553ce6e6b782a200e030fcb744ed737623fc3a8c9c8faeb0e05691c5a55c_Device=CPU_Config=() -676:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=ff96b044b0064dcc13dc7c1d80f2b2cddde0ead8c4501d5d741034833079d47b_Device=CPU_Config=() -675:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6289210c93bab9199850c9aef5ac3144ad0a900007dbca3e889a9f875318e9b5_Device=CPU_Config=() -673:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9e21c0af425c90066d92577a0b8aadb6e9fdee50c197b15eea040b89eb715a6a_Device=CPU_Config=() -672:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3209c1cce78c7b856203c0a5676f6fad4d098a3146c7305ee3c0471b3be2e3d5_Device=CPU_Config=() -671:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bf4d5291899ea4eccf6584f62d4ecdfb39de79edd102e509f840664838f59d19_Device=CPU_Config=() -670:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1e56a3e2379d29d81af93174e56ef91408af41dfc085d4851ff58dbec781b8fa_Device=CPU_Config=() -669:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=97a94ab826d2992013df32a4f93f6adbc38ad17a26503005046f68904adf53d1_Device=CPU_Config=() -667:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0d40552a1b6c1945765ada16284a0c03f5c1454fb12f226a34dee8a07b14f17f_Device=CPU_Config=() -667:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=db85fabcfcf049a7225468036e29c949eb779253ba145485205596e72cb8cc7e_Device=CPU_Config=() -666:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6a05cd292e71af9d96e456cbc515097d5224a9e41cd9c3d48cc73f1a4e6e2164_Device=CPU_Config=() -664:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a6b95dd49e84f2860b57f1f1ab6fe2baa265bb757112e53def3004a360053aa8_Device=CPU_Config=() -664:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b83a85737c23e279f8878f6795581dc2b003c55e4eb8baadfbfd73fb0e98758f_Device=CPU_Config=() -663:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=() -662:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=851aa3cf931a01e0188758055b866fd14280bc344f548da6166e4a57ca7c9254_Device=CPU_Config=() -661:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=562ad06104aa1fed1781e5e3438d71855e1ee7e0126457f2d8d8d415f9c30c03_Device=CPU_Config=() -657:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1ceb1c4ba1a45cbb5cabe7cb4b416cbfeb93f24533c8123e4c2315cc7e9f40a5_Device=CPU_Config=() -656:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=36783f31e83ed0f978f00a1cdd87a25b4b881c251fe059e5d2829be3d0b45c5c_Device=CPU_Config=() -655:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=e2d1f4fde3dc1889d4f86004173ea34a9d9836f645730727f5cdf90bc0738361_Device=CPU_Config=() -654:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=910dee337e395f94d7673f664a3e58647ead8bcedf50ea1439250bdfe8da25dc_Device=CPU_Config=() -652:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=cc989fde083332a75d3066112105028a711bdac4fc44463d098022774da752b7_Device=CPU_Config=() -651:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8978b8e985b54cc12e2cefa8d9097f4a3a03d477129230b6c7e3daf8112e2c0e_Device=CPU_Config=() -651:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=965ded994c427ec62353194906203c202a52dfc0467196d5f1143759fed94b07_Device=CPU_Config=() -649:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2acd53645519bc460dcc71923563fd462ed997366cc7ae08cb5a30245302a859_Device=CPU_Config=() -649:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=3b4dbc6facc24173723b52757e4ee60953d7a639e1fcb6e70236918d6a40b3a5_Device=CPU_Config=() -649:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d4b1dbc565a45f6c9f60cd4a73bb15c0f9e05baadfd3acdcd5e133d782c54cbb_Device=CPU_Config=() -649:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=970f3f48203f3bd46dcd6ca55ad20f5ff8ad2426c3f6f74377759fdddaaf93cc_Device=CPU_Config=() -647:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f06ff28476f886d4298a83d39f88aff34399d5cd589e0a6d6395e00b0ad96876_Device=CPU_Config=() -646:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=5f43b4d027388fff204c9c64df9f62bd2a72034143bd655e45121ca886c5d15a_Device=CPU_Config=() -646:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6513dbb80f00e325d6dfc953d1208c5834199f75a60430fc85925ed6eb0d9bb5_Device=CPU_Config=() -645:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=83d90ef3fac993f7efba4a8ed369781571b1b536af03ceb0267ae979379e1dd9_Device=CPU_Config=() -644:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f208ab78a0ef0497856952f499578a17818269d066f4281183ef92ac2f9ce449_Device=CPU_Config=() -644:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e8c2981885674129fedb6fc6a376f3fd3db7bf6f9867ee8a3f4e5aede63ee168_Device=CPU_Config=() -644:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a3d6337c1ea3e8b67256696ea4231da4fc0e9d9f8bea169607a1287233086b3f_Device=CPU_Config=() -643:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c08b3d30c1b4f1b5456e4791d4d7fab1d21f743dff0dac1ae5d09abc6764fca8_Device=CPU_Config=() -643:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9beef927f57c512d381a87a35982fe4ca7a00b9a9d50ede54f7baecc5ec7fa0c_Device=CPU_Config=() -643:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=dynamic_IR=60bd170e816e0c2345a1658fd88459775fe8b7cce5de31a16e4e6cdea199f264_Device=CPU_Config=() -642:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cdd7ce044f231ae39fc0f7460a55473c0de6934124cd263444a5912b8cbbc0ce_Device=CPU_Config=() -642:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=a3d8e1343e43c666358304b530278c73bc7c52a0d7fff38977154b6f7c456731_Device=CPU_Config=() -641:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=327d5120022c693531fe0f1f42429b1ad78f36cd5e414f1c8bab7d0c2ced62f7_Device=CPU_Config=() -639:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6adce7c66c1630295ec8938bcb429f20b628b0ceed938bf81ac0fca8580f8d34_Device=CPU_Config=() -639:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=eabe482de99e120ef1260cc91a746df95f8db04fa1cf6832dc45b3ee1b38f9c5_Device=CPU_Config=() -638:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=d8441d8bc521ac390fb58cb882a952618ebf5892d40e8768a9051f852a9dcfc6_Device=CPU_Config=() -638:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=adabeb9321a0770cb065345aca787cbf7d1adef68132cc5c7d8df885ea64ab2c_Device=CPU_Config=() -637:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=f0ae8e6b136d1db7e5e7748c03eeaed6907460d3d3941fcb1a6651cff61be113_Device=CPU_Config=() -636:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1891282a9bf460336bad3c354519aa0d87ba6ef40876d4a07592194d2d678e25_Device=CPU_Config=() -635:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b6e76f65817017d4cbe3504634568430a419a30e418a5febf75b89b566ca3631_Device=CPU_Config=() -634:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=be4634976e408d799217398ce693fe430fd46cdba6c78e01e9b824c208856128_Device=CPU_Config=() -634:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6e73ec183893b70ec42a4393f3b1b7c55767a14f630eaab0c3e3b6d22c6b8e26_Device=CPU_Config=() -634:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=i32_Shape=static_IR=6650e462a4f0086329d8576eb6352979e89825517f48e264fe719c7c5ca276fc_Device=CPU_Config=() -633:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d1b4dff28b71e41d8106d3730f2705e537487aafe0dd53ae7dfba9ec21724287_Device=CPU_Config=() -633:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d7ce9fd9d99a7ce9ebb5fdadb4db39f4ea66f74788704b2b9f96660c7403c031_Device=CPU_Config=() -632:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=aecc8a062c16343ac138f351d774858b523e42d5a09ab67b1b61e64fe62e73ff_Device=CPU_Config=() -631:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d9937a6c3eb62ad6328d7367f15e45758ce5f2ebc0488931855a5b1925574d36_Device=CPU_Config=() -631:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=dd575df40c907e85f7561296f2b1b5bb9786bf44bc27f26e33f235ba57391e26_Device=CPU_Config=() -630:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=64358a022d0c072ff89427a2f3acd3a3afb49b8f76e57353eb95962fd2572ca9_Device=CPU_Config=() -629:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=dynamic_IR=c117722add2db4a6eee4dc2fbfb99174911d54eb3896c65097d31d656fdee639_Device=CPU_Config=() -628:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=243d5b44a22822e90c2f6b7c2817f8110bd6a060331e686c1fde1869f3392db1_Device=CPU_Config=() -628:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1b46ce72aadab0dcf92991f242e971bbb36689e1bcafecc68d646aace43291ed_Device=CPU_Config=() -628:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cf02be750ce25545f7bfd694603192667eb3fdb07a186eaa7f3ecf5767547651_Device=CPU_Config=() -628:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1180dfe50d43ef6b95980bafd3b84816f6d249f8341b03a6f67d20bd8f8ba6a4_Device=CPU_Config=() -625:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=8c43b49d99c64bec883205ca15c7b2d9dbb47b9fe5140fedaeb8eb7220a36f6c_Device=CPU_Config=() -622:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c6e38c3297ab303b166e2a613203a1f09f4ba5a15659c8d2b233febd8fd09d9d_Device=CPU_Config=() -622:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=79a6d2a402cdd74cf1277a57ff95b71d61384da394ad2a4d9ebcf422eb5c3258_Device=CPU_Config=() -622:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=c5f54dc9ad0b693c13c07d44fe5572bd91852b0edd57f8f06314df3e71f3659b_Device=CPU_Config=() -621:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=d04bc06efa76ef2937aa1539893ec9c79ac61c765cb50cd4a26dbf5586bfc904_Device=CPU_Config=() -620:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=89ed1d3c7fa6e15c01df3b792a183ade5b90edbb87886e1d58db075566b60a92_Device=CPU_Config=() -620:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=83e2d01e24eebe910418ed24fb506852c37576ce70c18d27de197f675f49c9d2_Device=CPU_Config=() -620:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=362638bf065f1917d2b4dac3008a8f46f8f8d64a80d2442c1ad98f4fb943cff9_Device=CPU_Config=() -619:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=42062545b0991e415aad8d29d47de2a278e5791996ea55974411694aa821b54c_Device=CPU_Config=() -618:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=37f1a0a9bb9b948ed78217a65a5a2de7f0234b1e000fe5ee11ede68767240f1b_Device=CPU_Config=() -618:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6cf01dbf95872b3fc0c914e73415ed8e4dd52cb355031002a65e3e974559d6d6_Device=CPU_Config=() -618:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8f731757a7c32fa8e4d602d7197af81a1a82ea228ec05f4baeae7c59eba11f2b_Device=CPU_Config=() -617:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=61f6b4fbde686888b82614a5d24cac53e835377c4cfa791ace3f3cd3f8ac2dd8_Device=CPU_Config=() -617:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4d2e12e00779d116e2192ca77f2be233d76bdd5ce366ddabcf436cc205a9f811_Device=CPU_Config=() -616:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e58cf21c9c62dd427747021dcf9544157638e0773329eecfb8755a71b24f65a8_Device=CPU_Config=() -616:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=d98330d8f9f03556036d103fb4ca3f8436be42fa4f0b21b185aaad3abb2fb53c_Device=CPU_Config=() -616:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=cda3b9bda63d065b5c27e6bce5ffe20968024d77efe5e174a9f4395db56a30c0_Device=CPU_Config=() -616:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7f30f8f46d999a18110b8f8f9235b3534249be45e55f1aacb419126ed1eb5851_Device=CPU_Config=() -616:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=15d323a190bbeb1834cfa08a3afc633a2c203e44e2660bff4e98453c02ea4cfc_Device=CPU_Config=() -614:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=431db89311a543581d104e2a2c498fe021da2e4026323817834670bf5bee67a2_Device=CPU_Config=() -614:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=131fa1ed3ff9df038bbed73979ab906c3d84fea9dd2cf5dedc82b3222d511b1d_Device=CPU_Config=() -614:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=3e4364d93433ea741efe178b0c83cfb13c46259888aec468f59f77cd3f1bb39f_Device=CPU_Config=() -613:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a29be1e2e5f78c12657221f33e5309470a7a4dbb9061a8100d7c454215198f7c_Device=CPU_Config=() -613:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1e04d36f6e56abacf8388fad66368b15355eed9d216d5771b650b0b058db3a76_Device=CPU_Config=() -613:conformance_CTCGreedyDecoderSeqLen/ReadIRTest.QueryModel/Op=CTCGreedyDecoderSeqLen.6_Type=i64_Shape=static_IR=117fa486a51d9715d9ba1ad90cb5d6741e762cb36ea55a91129f1947b4886649_Device=CPU_Config=() -612:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e5249d5630503351688090f1a9d0143b02e750045924aee8f9003072446583f4_Device=CPU_Config=() -612:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0b7d6fb137555d6fde92f0c9b3e6278715adaeb38cf760236070b17bafb5babc_Device=CPU_Config=() -612:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=8bc8753f4d26c5d1f2ea481937dcce0f5b78971f18f5ebb258f49d4a0d86a333_Device=CPU_Config=() -612:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.1_Type=i64_Shape=static_IR=26d97c755f660ed8ee08a0de8d6ab88598391cc79b239bfaf0a102722ffc4bf7_Device=CPU_Config=() -612:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=41ea59b807081adea7869609c65776a42f88079ec22180807905d5c2e8ca0777_Device=CPU_Config=() -612:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=27d1a1cfdbadd9a8c2d0269f6177d6aabd55320aafe9a0047e90681dcad1cbe9_Device=CPU_Config=() -610:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=eaac9340f5625cd59856645684fd84a5f1f0703dd3748eb85fdff2eedd8ee64a_Device=CPU_Config=() -609:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6289210c93bab9199850c9aef5ac3144ad0a900007dbca3e889a9f875318e9b5_Device=CPU_Config=() -609:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4b00183255fde45d5c3b815b552e5a4279284bfe1ceb31389560260ad5546c14_Device=CPU_Config=() -609:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b15fd62115a849e0b5226ebe9162cda9371ad2783637a518f2a8724d24710253_Device=CPU_Config=() -608:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=351e48db45e09ca6c4bc54a271eda4cb2ddd69ba43f361b9915a6588913768b0_Device=CPU_Config=() -608:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2ebbd25d315f10aa32cd8251ced4e269c1688202ee64b4fb5245e4ab53cba16b_Device=CPU_Config=() -607:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b3e45847dae7906b7f320b6a751727593b35ad8659ee80a11caf445f44f392df_Device=CPU_Config=() -606:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=dynamic_IR=1af860b153ea667f413c7de4c98752d48ed8ac1fc7f90889009a2916e2ab1026_Device=CPU_Config=() -605:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=dd575df40c907e85f7561296f2b1b5bb9786bf44bc27f26e33f235ba57391e26_Device=CPU_Config=() -605:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ec60ac68ad3b748ccd56a7c91b3a2461510f05d66e4b64e12a2069483d8243ae_Device=CPU_Config=() -605:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ce2bcc21fba106cc8be4846179a73cb30f650e7ec48d443fed591f6b479fa9d1_Device=CPU_Config=() -603:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=dynamic_IR=6b70264ed3eb3831e0e034230813ce1a1e71c157a302822b56335e587bd200b3_Device=CPU_Config=() -602:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0534fdfa97228a6aacf4ed196a9ace8e09d8e4decdcce058176b0312500b6c07_Device=CPU_Config=() -601:conformance_ReverseSequence/ReadIRTest.Inference/Op=ReverseSequence.1_Type=f32_Shape=static_IR=a5cc0793d73f7f76fc02b5ae04ef2a29bf212ce5c59f9bbef91e0aa5ee17785c_Device=CPU_Config=() -601:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=25f55a7cb5f72689bff67eb95af15c64b31c2d29bcde97611e74917fa6724ff3_Device=CPU_Config=() -600:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=356e2a728749d3970a85939d23344315d0ff533567c35a559caa3bef173b76f7_Device=CPU_Config=() -600:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d46034925bf5b01e31b5a57911fe30f5dd09a8712432312fb1efd844e69913bf_Device=CPU_Config=() -600:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a4772901ff77541ae624f89db89901c7d5a502a0dc5d1e0dc21eb8e08c599525_Device=CPU_Config=() -600:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=() -600:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=99b432aa5821136994e06b4e3c690a4e298bc5a496740ea2c5fe6aa300edacf8_Device=CPU_Config=() -599:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0b4b74693c2ec96e714901b1acc772655accc3b29170cdb64ae934003338b296_Device=CPU_Config=() -598:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8c773c776396a2ff506691f857349efa9a4a580f1e046d1f17ff2ab49c73553d_Device=CPU_Config=() -597:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4d569fc3e7d2fa1724c99fec62e4f31fb000a6f5c306273c404e2b449761feba_Device=CPU_Config=() -597:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=80bc3dff7b0901463ccc52bd8e4a8e7522b1e9768421de45e63bdf8db601b9d6_Device=CPU_Config=() -597:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1e04d36f6e56abacf8388fad66368b15355eed9d216d5771b650b0b058db3a76_Device=CPU_Config=() -597:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=059046ce67f6b09ef45aaad5724e28fdaaf40afb92613740fd058c974a120d3e_Device=CPU_Config=() -597:conformance_Abs/ReadIRTest.Inference/Op=Abs.1_Type=f32_Shape=static_IR=083771171646a2eadcbb3384bd457e04d74ce8ea771813cdf67c56f7bbf20c69_Device=CPU_Config=() -596:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fe70e0ee3f24f0bfe4391da7797647a01f66fcb109b481ca859c9f8f7dc7b411_Device=CPU_Config=() -596:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fb83c1c4a2ce0a8860479916f23f3961a5c20481e62de79390573dd7859c09f0_Device=CPU_Config=() -596:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=29d8ef1a41f51b6fed0300f97d17a3795a97e4ffb3ef3abda37f790f5f53b389_Device=CPU_Config=() -595:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b2ca18b9d9f9e7c05f66a1f197b65ef9ca1d59319ed5f30d4eadf6f8befcd9bf_Device=CPU_Config=() -595:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=a3add607f5e37633f3298794f8e32e409e3403666af3c0fc57c7d4427b714eca_Device=CPU_Config=() -594:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=13c78a6d628bed4392d2577f132f924d9e17a7e29a2171dafebc0a596d2ade04_Device=CPU_Config=() -592:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=75bf24e3b7a4c4374c5c92331d9e48423d734d35b5cafb951222e39ea4c29613_Device=CPU_Config=() -591:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=eaac9340f5625cd59856645684fd84a5f1f0703dd3748eb85fdff2eedd8ee64a_Device=CPU_Config=() -591:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e4b374c3afdeb45605c3ac745c03fc9eb938cf3f3828c119917ca92a6e9135f0_Device=CPU_Config=() -591:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=c202ffc0e1805a36e48ee4b06d06b68a9f179eef00dc353a092a13818e8ebbe9_Device=CPU_Config=() -590:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=dc350b3fec164adcb096b8fc922e342cf7b0c6f7a4aa25074bec5566225cff01_Device=CPU_Config=() -590:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2a819b46a29c8bd965ec330a28b5c163dd0a06fa2717d71bd16493ad460e8dad_Device=CPU_Config=() -589:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=f8662769a2f3a5fb20582ccbb1931b7e3fa73ec7713eca30362b0e7c0baf829a_Device=CPU_Config=() -588:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=962d8a421369e4dac96b6d89d05053f63c9e5fc8b7b82a60c922432125da80c0_Device=CPU_Config=() -588:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b0dea4cb6a0cd2380e8657b0b64caab43819c0f8182ed73b2cb12eec608bfa7d_Device=CPU_Config=() -588:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a7eb49934c05ef49a453b19adf40a9d4c2ea9477464e8d42858dc9517c30b88c_Device=CPU_Config=() -587:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cc3619fbe03f9b98ff07babc5c11f9bd9f26927c8d793abc7188595145bd1371_Device=CPU_Config=() -587:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=81973bc511c12f7470f620b3484f6f7c82077975f916e080091dcd4757268b17_Device=CPU_Config=() -586:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c1ffd0690c9370725a30028d2915ec798aff173f86a1864f3dc92a4defefef85_Device=CPU_Config=() -586:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=dynamic_IR=e46ec3487f18188d1da4c029a2981033018c1f8f273f60d3f7d1bcbdae18c2c5_Device=CPU_Config=() -585:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9360fbacf32f2208bd7f241535752ccaf434551d16bd8fd46d0422cd1cafc3c6_Device=CPU_Config=() -585:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=839faaa50aafa2e3ed38fc682d0759304b694043dac1a242a085e2973aac8091_Device=CPU_Config=() -585:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=30466048a7da9db59d20a210af1979341f7b9552362e64a89357d650102a213e_Device=CPU_Config=() -584:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c990afda81456723598f8f4085cb476376b1789d7f755e340e1d5498bcf02080_Device=CPU_Config=() -584:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dd181ad2875cd08679b8554d2a85ea0fd15d7f09f733a8290f677fed6c757_Device=CPU_Config=() -583:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=4541365c567e68739f0733edba54e889f231026025e6866f805446392c575960_Device=CPU_Config=() -582:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3e1e1cd684c1bcfcf06febedcb4eb0f4f62b5c0920098fa0715c828e9a9761a7_Device=CPU_Config=() -582:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=deada5d69a05cf27af659254f89b4e53e6685c517fdc2bb8a250cb5d4ba0a3dc_Device=CPU_Config=() -582:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=a815b68b6a8d36546d3ac0112c60283bd69ae1059e8deeb98b21f538c8089beb_Device=CPU_Config=() -579:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=030fa97d19aab57ae9eb898fe101353fdc76bbc034d4574971c68ef254006c85_Device=CPU_Config=() -578:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=ba4f511cc4a0870c64cc5027fa39b2bf91a6e7f39ea36cd43a693eb59de6d836_Device=CPU_Config=() -578:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=12e7ea655764a32069a93a3f7ab147983bceeacc8a2bc88fbb2def005a1596b3_Device=CPU_Config=() -577:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=() -577:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f66bbeb796e4da5d462ef573e38fe52db5bdaf2367b2a07aeedae6ce33c6704f_Device=CPU_Config=() -577:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4479acfb061c41832bd1f2ff0de0141dde3a3c496ee4471523fac0a37451311d_Device=CPU_Config=() -577:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=41bcf70f8013164bdfeb7e348c05e6d43d9a1afc49087c49745679bc3aaf1e10_Device=CPU_Config=() -576:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=fcab2b4b3bf1a04070e3fd3490e6317f2d6870335d302d96c768f40da8565c8d_Device=CPU_Config=() -575:conformance_Negative/ReadIRTest.Inference/Op=Negative.1_Type=f32_Shape=static_IR=c29451ffff103b5e965a1bbea7994ef6da6394060855ee071b9e7a3a4702141f_Device=CPU_Config=() -575:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=df62dbfb022ab001a9df6b16311f57e744e8674fa8751b4e3a7ffee872fecc20_Device=CPU_Config=() -574:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fe5cbe273830f6a09e3f18eaf8e9410f9f7f1083af508a9dcaf5f0f22aa3ac1f_Device=CPU_Config=() -574:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=13f3d097d5e17c2add48d6f9b6f86454a1b521408d7fb8252e3638d9f17ea6fb_Device=CPU_Config=() -573:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=2ce56cfc77884dfc61f7e9fab9a0ce04a4b016f9b3d13465cde1576b9374a2a6_Device=CPU_Config=() -572:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9575e384c23faea27b9011de8c0093099fbe0ee6462baaebaceb075529664665_Device=CPU_Config=() -572:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1269afc1a9f9a4f71ca2167cc59274b7a3bead8cca474162919619b810eb9c1a_Device=CPU_Config=() -572:conformance_LSTMSequence/ReadIRTest.QueryModel/Op=LSTMSequence.5_Type=f32_Shape=static_IR=981b213f0fd1305e70515849fd08553471da63e6bf64827a47cc475fd4ed9561_Device=CPU_Config=() -572:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=00709ceadeb9692263607310765b0957f34a8af1ebd17a13cc28d9587d360465_Device=CPU_Config=() -571:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=259cf71b937e6d184948130afa5684d7539769988cee7a74b06138ad4d09c689_Device=CPU_Config=() -571:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a9d3d025df92369ee1f1a81fe676bb00d7d6cc488868e04d0e713fb9e42451a9_Device=CPU_Config=() -570:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=7dcfe3f43645f6b9f3290b524024a1a3d48efa3ce346eacc2330be7e27a046fd_Device=CPU_Config=() -570:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ea604e7edf80c14a14bf7fcb042125f4d666d0d69ce3c0209c2f9dce26d406fa_Device=CPU_Config=() -570:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=739517c4c613063fc5ef734443f0a599400dec31cd5a56686735f3165b2dc2d0_Device=CPU_Config=() -569:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0f623457008d91f7fcaead549e4a3f90a5ca77dd7c52fba19906f559c34b333b_Device=CPU_Config=() -569:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ad4c3d2d3f258a4be14846d9d26203008e01b2832ff004bb8a23ff05c72747b5_Device=CPU_Config=() -569:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=94ad9524c175a0e0d2fe22bceeac82b0dc66006caa0942d343d551268e03afec_Device=CPU_Config=() -568:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=244310d1092f478729162ea9a4da5660b066ad7ca70a65d8a205cb03787eb73b_Device=CPU_Config=() -568:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=09683cb2a0a44acb804a2791ca93bf004bfc3882c11af94ea67a9fc1eb1e5052_Device=CPU_Config=() -567:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=60ab42bb613fe785777ed45bc99044f41dae00316065ed5e5f07e69f5c861fc4_Device=CPU_Config=() -566:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=() -565:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=40876e66f31053b621aea004baaba7607b9131d4fff8e8b00ed7e1e58204988c_Device=CPU_Config=() -564:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=4d9f16ede014da56824607d45502439f71b57275c332fbf15c6ba2ec1496466f_Device=CPU_Config=() -564:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=214e4e8f7de64e9cc8c77c67d214172905cfb4b9fde65e2ef3d32bb7b4ed93f1_Device=CPU_Config=() -564:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=117fd22d36b97216edb2112c043ba97872b9b7915d7909dfc395406e8ad91e4d_Device=CPU_Config=() -564:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=() -563:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=65493d18baa6530c757031b74c5fbd51757e2b04bb79149d3acbf6c40bac11c1_Device=CPU_Config=() -563:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=21a343909133e844b3d88a967b2f6c948e4c9c9eb96030b936f9517dd9bec865_Device=CPU_Config=() -563:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6587874c50811a2ca7e27f84cb4381e9a06eb4465e940ea877c76dfaeba02753_Device=CPU_Config=() -563:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=180e9c4ce23626df8010b5b79a28ecc4c6c75b65dea91938fa99025a65411239_Device=CPU_Config=() -561:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=984e628a0090ff9d04bf8f41b795f0682dd3083fb78b71397a51cc2efacee247_Device=CPU_Config=() -560:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f8795aaaf3fb96028b8cdcc963cbdff4c3362d78c4801af4172a73a3cd843edc_Device=CPU_Config=() -560:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b53fa2c9b93d3750c17dfb8ef75e51c43881ee79fddc863d6c1c2adfeaeaba2e_Device=CPU_Config=() -560:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=45959eb5eb391b2bc86455cb1e86aca76799c6b082437e72b15c171037a6206d_Device=CPU_Config=() -560:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=b8e37f2c8e2574b3f3554578b72e9df771c290c1bb47238fc4de9754c6e6f126_Device=CPU_Config=() -560:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=03e7b025285b1369ca39bcf887783a843fe06ea29f7f394efc8201d1b7ad3a09_Device=CPU_Config=() +603290:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c9c03f1be9f6d66301feef3e2ddaff82fc6412c616494f29214d4a6bbf89adcd_Device=CPU_Config=() +536763:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=() +390306:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=() +227793:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e0f4f91a6470af49c5e2497ae8fa917051879c18dd1e39cae18d159b697e8fec_Device=CPU_Config=() +224827:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d0c2f7eea6a0d6d6d9d97881c8db3649f9e9b713633c9d5698459eb1d2e28345_Device=CPU_Config=() +188494:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d99c03088bad009d9be7f29ec5bad7e3b6c7534fe2649f9670b6f713bf017e7e_Device=CPU_Config=() +174861:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8b9ae72303fcba7808c28f788e0187827b2f548efcd6d023e6ad28047121216e_Device=CPU_Config=() +119106:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=214e4e8f7de64e9cc8c77c67d214172905cfb4b9fde65e2ef3d32bb7b4ed93f1_Device=CPU_Config=() +106950:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e0ae8d59ba587db8057e6d8a9304e9d9b946d338db08ea5311182b6adfed4478_Device=CPU_Config=() +103486:conformance_LSTMSequence/ReadIRTest.Inference/Op=LSTMSequence.5_Type=f32_Shape=static_IR=b8e32896d2ab304fb4fdca3924e0110852da92be25307f30709cd7d897c2f038_Device=CPU_Config=() +102409:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8222f4a2e6c27f1bf5455fe495f04e3c7f48118a20687c6c5f6434c1e3d12f3d_Device=CPU_Config=() +98679:conformance_LSTMSequence/ReadIRTest.Inference/Op=LSTMSequence.5_Type=f32_Shape=static_IR=1f24aeeef6f9f91272546fca89299c1ce448b0008fe43905db434ae3f28a75d0_Device=CPU_Config=() +88311:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=aebf91fbdf6124d046e8016cfe5d5a5a967f7c4130642e9dc4b812ad067ecbf8_Device=CPU_Config=() +79011:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b94603cd976e1acfa5a3f8310be1e05800114009541c22ed53c0c07cd0816685_Device=CPU_Config=() +76309:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a5d03dc78d3b89cf1aaee33c609a3d52626d3b98827b980422b01eefc32cde03_Device=CPU_Config=() +68493:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0cb77146d653391361407152c1320db480d5f737d2918eac934c5ffd371cbaeb_Device=CPU_Config=() +66091:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=39930bd67f003081f138d781076ec2d3571ced21865a9cccc81bd9185c151b39_Device=CPU_Config=() +63688:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a5247d95c2671970ffbf4c367bbae5fe76245fd6e0db79c9c4fb9b7659dbd4f0_Device=CPU_Config=() +63148:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=7d3d30fa9e2a8a839cf42249de3eb8228681229e8b302ff7f290cc0d00c10a1a_Device=CPU_Config=() +62172:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3b743fa55fcb61cd34046e3e97d71a05de0f8db98d3abcff4e14426d143771cb_Device=CPU_Config=() +58550:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=e77dc4aecdbd4ab3d67fc3c1d9e350a9d259af1d4c0188d680121a31c6ed8ccf_Device=CPU_Config=() +58173:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f13ce39b60cc25991465a0c02e27edcb35af0523cd28004adf6fd9acd8a5fcb8_Device=CPU_Config=() +57500:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6a16663e3760c233a39f49948fbc5e2b41658e0e9fbb86e8a5d0cc16dfac33bb_Device=CPU_Config=() +56030:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e62245706f4242ff86bcb70d4d221bf49aa31db3807698d574125166bff5f8aa_Device=CPU_Config=() +54826:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e27f0bcb3118a7cdb488f4685707bec982ae54ff8bf7e97aff9ea6ecedd66714_Device=CPU_Config=() +52917:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9d667416103520d22b2328feb82905999d9d34664283e3bc754131126f9dea8a_Device=CPU_Config=() +52863:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=29c89ebfa45163b40be304d7bfc96f3068cd96175db94e6ebda942d3c4af538f_Device=CPU_Config=() +52771:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=edb315ef0796a043a072730952495a3c1a4e080553efbbef8cde28d14d79ead3_Device=CPU_Config=() +52423:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d9b9fc6875f06b7dc454279fc5fa4432f514736cfd1a35d2a40cfc82f680c009_Device=CPU_Config=() +51560:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=74f34c8b7abfe0f7afe021ba5d4861e29f9f3915beba5cdb2af936f1f2409fb6_Device=CPU_Config=() +51063:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c18f4f45c8ca59e5fcf1d2aa0b6115c7fb6789c4d4a583cf93901e65f4ac692c_Device=CPU_Config=() +50376:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cdc993ef8686eb949184e962d0790c38c26bd864e8d415fe06a86abe3bbcb4e7_Device=CPU_Config=() +48948:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=76539d5ef8e5f423a8cab413fed102f918a53f68d19bc3c054d01e8a18e41841_Device=CPU_Config=() +48313:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ffe64e2ecd6d3ed3128559b89dd2a26ed439c533f6ebeb969ebeac62f80dc12e_Device=CPU_Config=() +47178:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3ee918ec76a3432c5179480e1417b0bc84da24c2716af490292525a824d1d2ae_Device=CPU_Config=() +46664:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d4f7d35516f95fa128d0cc3d63ab95c2dba96c29977a88a6573d5e90c3b89271_Device=CPU_Config=() +46231:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=bb5cb4e2a8cb9be32332ed3255c99de478d8d2e31cfb1747aa322df438ebaa49_Device=CPU_Config=() +45299:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=858bc9246515c70bfc3ea024102604566e53cd6f618059fa1f6d0046d0de9565_Device=CPU_Config=() +43537:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=92c3646daf445784fceeb022afba2831938fed34660bac5445f033a1efdccc34_Device=CPU_Config=() +40153:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=6289232b1cbbafc963ac3cd787330c81a9cd02def9fefb83d6f6cced249de92f_Device=CPU_Config=() +39997:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6b86bf4f834b297dcb461acb5854aeb9783a381521ea1a8e1cf4fbeb60d6d09b_Device=CPU_Config=() +39445:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=966eae58d5c103f24a598a5143d7b3a3c40a12fa2606a65431f0d1aef855cd32_Device=CPU_Config=() +38138:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b91f26a0b7b56224c507de772631016119cd0bc3fd49527013f571e2db477402_Device=CPU_Config=() +35849:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a76c4cc0a1f2294a3ceb18dd5d214d842cf37c08d2e34770c66c29b44ee92e48_Device=CPU_Config=() +35476:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=29d8ef1a41f51b6fed0300f97d17a3795a97e4ffb3ef3abda37f790f5f53b389_Device=CPU_Config=() +35243:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=6119edc6e1f969159ce54e6ff4451d96db51485b54fae625a972035414c704ef_Device=CPU_Config=() +34351:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=9f7a30c4f90df2edf8e70468ac22f325bc97e99613fa6ee2aced93e71ea5896a_Device=CPU_Config=() +33292:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=8e098b9c129ab30efc257d55cfbc737d990d2ff0f7931039d3335c42d5f286eb_Device=CPU_Config=() +33141:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=59d132b45e2ac60a670eb43efafa43f065bb43d492208ac670fc8234b4f618c9_Device=CPU_Config=() +32740:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f9b090cbcb19663630a1490fe18357b752e430ad793c0e3aaabedcb74ab64934_Device=CPU_Config=() +32492:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=99866ef63c9a2e7e2d9b7f00d11a4c177775bef9cfdf074e83f56318c143e6a3_Device=CPU_Config=() +32337:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=31ce051edcf02344a693eb2d200fa02b53412a5707faaffc2907cadcf81192f4_Device=CPU_Config=() +32330:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=7625f5af6c70a9d4bccb783dc369a11b53ef1f6492df030ae5404452ea0cdc79_Device=CPU_Config=() +30614:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9360fbacf32f2208bd7f241535752ccaf434551d16bd8fd46d0422cd1cafc3c6_Device=CPU_Config=() +30098:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=abeadd9ea4814d6b3d678af4ec0853b8392165cc6270ae2b1a1f6f9d04d3cf4d_Device=CPU_Config=() +30091:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fd62dfe7f4707f12da18744aa57795baf078b77819fd22b889cd02559e70d7d6_Device=CPU_Config=() +29941:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7d706b614d2b5d59c5e152bbb61a8fd558686bb3b8e9fda199c499ca49f03042_Device=CPU_Config=() +29491:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8710c3eaa10d25119059f4e15970d8a6381f978cd905fc8eb1b4d43a36d1d5f6_Device=CPU_Config=() +29288:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c533b2b13f88a1c6296bcb6831a96fdd4d354c69848e02bf3e9a1e632264524c_Device=CPU_Config=() +29194:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=355bfa53a1f9e712db4df6642a51970e96e3612583b2ec90e7a8170e45b1625c_Device=CPU_Config=() +28837:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5adf6fcb72c0d6086a95fbbc5744e7d02dfb32490e0f42c62b57bc98489b801c_Device=CPU_Config=() +28528:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3c31856cc439ae60215ceed2dc33dd4427c528e87a5f61a3b920e52ae2c87785_Device=CPU_Config=() +27441:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2ef3273b8c144dedd6cc2d2b8c2d2921d999fa286b10d90aa796fa188dc52cef_Device=CPU_Config=() +27391:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=f45b24f3bf21a2c94bc89cdc3d20c283d47f4e6ea386444897330e232bd7d90f_Device=CPU_Config=() +27387:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=50a0e83d438a3220ed14dd8ae783e92c96381f645b10719669054ea944297244_Device=CPU_Config=() +27100:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=65a49a4d063513732033e2f838b45c3c176217b8f801ecb9357c99a35022587b_Device=CPU_Config=() +26875:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=() +26039:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=67396728229ab01facbaa211eeb0a7213b6a9e32d99709bd6320863fc63d1c4f_Device=CPU_Config=() +25719:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=e77d1474b4055b15278305f6cf7720f30254a5a4e2f6c101970a226f24e79b94_Device=CPU_Config=() +25523:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ffd182dd2438f8b3907013ef38c64288a16d6f98a9fd206e6f8e3d2db48a3a73_Device=CPU_Config=() +25334:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=27a43bf8c20a81f1e244ace4c53f7cd9343a2603ba2c8b50bb041a4046ae6ecd_Device=CPU_Config=() +24875:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=65a5483c793396983edaf7f2cc2c13898507525bd84a8469e97b2d662b5df782_Device=CPU_Config=() +24844:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b5d0b3117c15997ddf3779525e849ba35c0096ad654c8e27fd1e87e29cbd61dd_Device=CPU_Config=() +24280:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2a819b46a29c8bd965ec330a28b5c163dd0a06fa2717d71bd16493ad460e8dad_Device=CPU_Config=() +23998:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d4b1dbc565a45f6c9f60cd4a73bb15c0f9e05baadfd3acdcd5e133d782c54cbb_Device=CPU_Config=() +23618:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d20696b7743fb5d47628ddc4be77a3627b2848014e649db977ca1028586cd3b5_Device=CPU_Config=() +23148:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bcaccd02132919b356b3d4928fa5f1dc4bb2902748fe238f849e557a42e7a879_Device=CPU_Config=() +22764:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2006e1eaa808a3e78550535058de54c5cd83e9a32a52e488fef1f7883c321a3_Device=CPU_Config=() +22681:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=() +22470:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=827eabaef75593763cce8084a77e9ab8c8aee3de527727acafbffcdf5efc2766_Device=CPU_Config=() +21890:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=680b155374ac22f8d01e47a3b26f133a20842702d07dbb2d0fe2d1c03333afcf_Device=CPU_Config=() +21627:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d46034925bf5b01e31b5a57911fe30f5dd09a8712432312fb1efd844e69913bf_Device=CPU_Config=() +21473:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=767873fb6967801da9fcbc8dda360a2d30ba207cb97cbabc82a509799c40a882_Device=CPU_Config=() +21124:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=74310de2f35ad8a1bf7388138114655c2c74f1e85fb8cde4584f3d7905345140_Device=CPU_Config=() +20199:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e77468c2881ce0c38c14038151d560ccadc7dcbd5eb5f21b68b8e227c89813a7_Device=CPU_Config=() +20180:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e4c6d363cce1031b198de7bd1133cc023f1ff118a9dcc787d5a5f57593e6795d_Device=CPU_Config=() +19589:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f780e2914ea358c4b9c3775e3d4876ddea5efb96ee43545cae2592db34bc9d54_Device=CPU_Config=() +19554:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f9f264e1e7e84711ec78c28ac19f0c120290cd8cae589996ff10d4096d35f592_Device=CPU_Config=() +19303:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=4d9f16ede014da56824607d45502439f71b57275c332fbf15c6ba2ec1496466f_Device=CPU_Config=() +19245:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=385190d3bc54bfee5cfd98858a99a50146f755735ce9e86804b0d50f2191bd8c_Device=CPU_Config=() +19186:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=776ce5493890837f137a7abc7851ff04164468d7c13ef1022f73f1f68e058c1c_Device=CPU_Config=() +19108:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2f8c5775d77906707d4d8dfc991f73e4a780d87571fe695725e131e833049370_Device=CPU_Config=() +19079:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d932ccb58823509e768be954dc85ef1162d9456db17138d650a2a883e31b99ed_Device=CPU_Config=() +18981:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5eb341117f8535a929c96a55b0a932c37b1254f07a03af2a05a0862c7c2675aa_Device=CPU_Config=() +18932:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cdc57df56ccf890a00f886c3b83f504d24ea9d4ed5f0ef05f1189879172777f8_Device=CPU_Config=() +18847:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=114c112cd0e9ee76e06605b2c3dca5a6403f6d7c675177b371096087782e06d6_Device=CPU_Config=() +18730:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d4c59fb1b2e6f27da249cc36d5d1a4c867d0fb17e9354f63b69f61f74780f8d0_Device=CPU_Config=() +18528:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=29d1a1e024ca9bace919909bf537adbeadce2875807ab12a4e3b3499c4c834b5_Device=CPU_Config=() +18423:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=7201a55d869ac6072af38ff89dfac3cfd2e6720d25f7607c6cc5f80040a8e82a_Device=CPU_Config=() +18337:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4772901ff77541ae624f89db89901c7d5a502a0dc5d1e0dc21eb8e08c599525_Device=CPU_Config=() +18181:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=284de068bb05428358d75ba098c74615e828fd9223970fdea43d02fa028419fa_Device=CPU_Config=() +18017:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=78069dcce6d7d8dcb87e840286aabf2c6fb8727525b625653096be38f0291101_Device=CPU_Config=() +18006:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d671a241de6d46bd5562def47a92602d2c9ba076568feed303765168433ee89b_Device=CPU_Config=() +18002:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=e020cc29b6ec76cfac0e0b52ed3024458fbeb567c4fe9932eb5257e3ade79b95_Device=CPU_Config=() +17971:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=66abbc2c605a0f866880bd4730865ae6b5401a1f4beb242f346bf6f2f8138eb6_Device=CPU_Config=() +17577:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e995424209defee7f9c521cb07889eb499bd546ed3dde685841d518b2e69da58_Device=CPU_Config=() +17575:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=af74e05cf6032c57a3ecd980402b9694581a8823946e3f1c76716692a7747d4a_Device=CPU_Config=() +17552:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fb5525d36d14f54eebc5670c06232ca4e32cf920d309b5777e37d3377d386433_Device=CPU_Config=() +17524:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=95ea118f8053f6bd18c8f34bbc475c00921bab5dc3af177492829d5cba16aa39_Device=CPU_Config=() +17160:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=66ab5cfd788be1a5ebe89e70a1318d6b905d3600d0ac5a967d07a0ad6828e7df_Device=CPU_Config=() +17141:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3453b13d94c5885206e02df250d0d07ce9930fb3260f992502bd677de9c348fa_Device=CPU_Config=() +16891:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b4c9edcf320dc72ad463dcf64da84add367d2ea5eaf1a8524793f37a5eae7c7c_Device=CPU_Config=() +16745:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6d96cbf402de4085be87bac94f42f06f28049e17188cb3467dc8010e8e99f698_Device=CPU_Config=() +16712:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0e78ae14fcef33de9637ac99e87f672b3247ea32c221a4b555b2e5bbdff88788_Device=CPU_Config=() +16709:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f0ea143c11c6a4cda8cfcc01f0532c256b592f807ddceebebda7e9eb8f01d919_Device=CPU_Config=() +16455:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6017d3f7ee3d7e667e8e7e4881f9aae335d47c8617c92b18ec370aa0770314d9_Device=CPU_Config=() +16172:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7d3a099a5040e70c73014df347c478d0976123d68b6fcab6bf767f90bbdf8e6a_Device=CPU_Config=() +16010:conformance_LSTMCell/ReadIRTest.ImportExport/Op=LSTMCell.4_Type=f32_Shape=static_IR=4dd9fa786fdb5a24b9ac201a72429641de305a294bc5cb4ead1e55dc1836592a_Device=CPU_Config=() +15903:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f0472c0e5ff8fb82651424269bd9f77e73eff6c43c70b6192f07303c0d35db8e_Device=CPU_Config=() +15552:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=42f3f3a5b34aacb93147f9c77ad5709cf7436ae8cad9318434a9b6ff6852982d_Device=CPU_Config=() +15532:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b65d46a8038b26d7ec9a5691744a9324aecf33bd3e89152e5f5c067ee4a56606_Device=CPU_Config=() +15206:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6e508ca44667fb311f5b6d634584d2751c3fb15fc034626765c90695b7de9619_Device=CPU_Config=() +15112:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=() +15100:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c2db5dd4ed881038f0521cfb566b3773cda95681a2ef8339950d0515616c015d_Device=CPU_Config=() +14845:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4b386237f65fdaa6fdcc6826f3c331a945b8a7c0ab860e83f60fe2cb24e3277b_Device=CPU_Config=() +14820:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=64efb6dd46c36bec02b92148d178bc032417c8c2d999ff7b0a24ba08af365f91_Device=CPU_Config=() +14787:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=83e2d01e24eebe910418ed24fb506852c37576ce70c18d27de197f675f49c9d2_Device=CPU_Config=() +14704:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fa169b001a47d2c4cfe07d837ca82977192701fb3f1f557e0c792675f00f8158_Device=CPU_Config=() +14449:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=243bd2256612673dd04651521ed8d3fa4087c90af7b85e1a4aa381c074bacd47_Device=CPU_Config=() +14174:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d8a0ff565e3467b3d0e2d6f1dd856b2ab812d675a09645b4a3b3bc8f29957453_Device=CPU_Config=() +14169:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=28bb0064e4cb56c497227ec69899b08dc09cccbf7d390555416aff617a393f81_Device=CPU_Config=() +13843:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0182ad6b02d77803accd2ebe55d87b679950570d1dcfef2940adcbb5fb9f1a24_Device=CPU_Config=() +13724:conformance_LSTMCell/ReadIRTest.Inference/Op=LSTMCell.4_Type=f32_Shape=static_IR=4dd9fa786fdb5a24b9ac201a72429641de305a294bc5cb4ead1e55dc1836592a_Device=CPU_Config=() +13706:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a3bc997e1de8be5fd5b66a48e1a9ef4bf9e4143cb12313b2d9adf3dc12ae0111_Device=CPU_Config=() +13697:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=730427f186dab4c4268e164d10b32a50afb588c1100af2de2c3293454e7c71fa_Device=CPU_Config=() +13580:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fb61da088a1643592479d343650408e3ec6518afaf1f38d808feda9c222f7564_Device=CPU_Config=() +13467:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=feeeccadf83749f2827985b49721a9b8c5a0c9c90a709193e27002e5dd7f0bc0_Device=CPU_Config=() +13365:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f7271aaaa48555bb6e77b1b22aff8e1507d5a3fd2bff3581d3b6c5c18b6b4963_Device=CPU_Config=() +13134:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1396dd3cb903e42ed4ef83843ffa16a65203a07192ac9ba8160fdf02ed26632f_Device=CPU_Config=() +13089:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fa2eea1b545d6b876282ed0165fb935f0af249c713e3f20fd97cc06118e615eb_Device=CPU_Config=() +12912:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=556de70b55386fc9a264a24a9000d075a07636de6461cc5f4cd41af639b0597e_Device=CPU_Config=() +12773:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ed872c2ef0d35af97e7f9be84d83eee6d42f2fb279b71f4feaa1aecefb450a28_Device=CPU_Config=() +12764:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=63923bfd18e06b6a4a5f5f975b049eb9a46c9beee83a1759bd99d72483130af6_Device=CPU_Config=() +12728:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2dd63d58c85301d765882b95995de97f4eff14bbb3c933c4e4b8ee5fbc2e9e71_Device=CPU_Config=() +12726:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4e73a0235c7b64a58687dbaaf8530e902e4d714a509dc9fc3ff499467c2fd05_Device=CPU_Config=() +12664:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2076165a2a28f14ff923bf8c44250bc59536d2ffb67b4a4785f480df49c1a243_Device=CPU_Config=() +12596:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5f2924e748f389c659aeeb2dd9899519d96db396695abd625520a5ec60d6ba5e_Device=CPU_Config=() +12586:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ee1f9348ff09a058dc09cd63581663590521d463d14b785a23ccd3cd28110b5b_Device=CPU_Config=() +12547:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e1aca62d840d626a9f0b30aa19a251616a698bfec39e4ae679e50345edfdd4e8_Device=CPU_Config=() +12542:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=225aaa01462e6e43c0c12cff65f96e7d9c07d368a820ff3c1b2939fefe86d492_Device=CPU_Config=() +12314:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=60e017f098b38fe7f824eb78635cd13cfa1ff460387abfcd6420c8a7d559a915_Device=CPU_Config=() +12289:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=34069e6a539019d1d06ed15853842399d30a3c7931488d2e03dbbc9eb4c189fc_Device=CPU_Config=() +12251:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9b6b036dbdc251b786d53d5f0aca9c57b72afeece113f9b2d8935020ed697166_Device=CPU_Config=() +12197:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a1e0bbe02c433cb144b4825a9f1b2c30c03743f210830db5462736850b6db383_Device=CPU_Config=() +12193:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7257c42699a127367a2904db71c700c5cc94b265e3132a6737f5503950f90fcb_Device=CPU_Config=() +12186:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3147f462ceda9b383de633ac08d6014a7779e74b169d3745990fa2b2799b1dbd_Device=CPU_Config=() +12080:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=4212a754718adff414309fb1da18c4361792b5478366bfdc0994490c7bc716e3_Device=CPU_Config=() +12077:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8dcce54a5f8ee92f5cb0f376b6baa4513e2f5bc0b6b7487ca85bf6f8c2a02c3a_Device=CPU_Config=() +11758:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=79dde0b4a7ccb6e275b507d3467b9ad1e02498ca54329e111d06903d57355623_Device=CPU_Config=() +11676:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ac12549a897d099d4b2e7c3872b9b9588639b7bc484648662121cffefd6c04a8_Device=CPU_Config=() +11663:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9fbf4ccaa68a81191afe2432a2212ee1a559df380d602459ebd2d0266053d82d_Device=CPU_Config=() +11641:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a8bd299de91e7b19efaf1e0cf6437b26549b7f99481196b375357bd1a71037e3_Device=CPU_Config=() +11539:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0fb6a7848271e000d49d4966647edf55e65f181523883089f43147c14cfb9871_Device=CPU_Config=() +11184:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5aa3e3ebd200b6e711e72c5af6e13edc0b956656d479f25f85d6d76377c1767e_Device=CPU_Config=() +11169:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e098a555ca156806b9c32b2049d750a8610e250d8976d9bf35629e517ea6e85f_Device=CPU_Config=() +11079:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5f0ff4c88ede5deb6d12935a74027fd8e9a1c966e03e064f0a94cbcc11415918_Device=CPU_Config=() +11014:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1ee4e453beffb322abb75896695a160ca8b14b0fed69999731588374e6ea4b93_Device=CPU_Config=() +11001:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cfd594e916dbe86e473f1a80da2913bbbc365130d9bac66c0be9531ad40ba673_Device=CPU_Config=() +10955:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d3ad2d022373c585166c8c4f9897c5bdb655f1b5560f2fb1f1506f7cfdf375e3_Device=CPU_Config=() +10692:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fb30e40bed920f35420787b2bd98f04d496df16cc51c355611af5307cadd605d_Device=CPU_Config=() +10504:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1c4aa866633b1381ff8ee36910d91aa4750c9a8dbd05ae159b7e15a65a08bad3_Device=CPU_Config=() +10434:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ce0514ded018b3bde00091b50a98b715da2a3e3c254406b9fb290b930d6f5680_Device=CPU_Config=() +10194:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=f32_Shape=static_IR=dc12f3a61744181707e6cc6f1ed849088cca8ec067eeb2da8a138a69d403c826_Device=CPU_Config=() +10031:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a99922ad73b3ea50f32af50b856d393aeae4b3afe901a2af8fee5aeedec9e9c7_Device=CPU_Config=() +9983:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=24d05884873d69e036ce6647cdd8eb4a82fa7b8d30629e86337a1df10ccf45cd_Device=CPU_Config=() +9945:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=876a77d1e2efb758a87bce1dd2fe35cd8e455c6f3dd7cd2bed8e10504c426de4_Device=CPU_Config=() +9917:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f82842bfa510be994f17d9c00d43b6f67b232b3a41c64ae276e243610d927d9_Device=CPU_Config=() +9843:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=491b849a7ce8fdb2190df5415fe037ff02fc23814efc520c343e872f539d6e55_Device=CPU_Config=() +9744:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=c4e2668f98d5c21fc085695c9b6037f08a1e6710e1854fa73b7465a618e99b95_Device=CPU_Config=() +9657:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3cc6ca8cdfe79957271093055b5e010a76313d2b59db6a6ca9696cda526d0cd3_Device=CPU_Config=() +9517:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cf981b73f7cffceac87c13ff562674f1c6b457bc6275704b4ad29cd943f3a15b_Device=CPU_Config=() +9504:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d492c7eaf897986b3d961ba687b4ddf8cdfcfd946dbece9cad3e75c7a65d2ef5_Device=CPU_Config=() +9453:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=93dee798d72e36c04cf60499e95f84cd6b63d84226d7dd1dc0edcf0875cf301f_Device=CPU_Config=() +9434:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b78ffc69401084763d529e2aee12f9b9793bc92be3eca3df2a97730b9a252ce3_Device=CPU_Config=() +9359:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ce4296dacb13a0d940afd8bd71b9ae0289d446455f3482af3667d22ee70e91d8_Device=CPU_Config=() +9336:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ba97799aeb7eeb6f62c2e09e38a2eb4d4a5a9d47712788d47182b3de43675082_Device=CPU_Config=() +9335:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0c0c04b18975ff24a18715af981baaa3d45e746c73fbc71ecb16eea245197d50_Device=CPU_Config=() +9327:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2c34b5434230e59b65b5e41e29541c4f1de46e8f76604530fb669b21b7f7aa2_Device=CPU_Config=() +9219:conformance_LSTMCell/ReadIRTest.QueryModel/Op=LSTMCell.4_Type=f32_Shape=static_IR=4dd9fa786fdb5a24b9ac201a72429641de305a294bc5cb4ead1e55dc1836592a_Device=CPU_Config=() +9208:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=f32_Shape=static_IR=aea9eaad28967e914b80b64c929fdb29f640c9144d6c5599ed9099264cd2f54f_Device=CPU_Config=() +9193:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=2f7925a034999529ce07a5c8bed2b2c7aeeb7936f74730d9c8ca5a5086dea4cd_Device=CPU_Config=() +9058:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e2581a8fe5100a3dc4212e869ed437e817291a79d77b7dde80700de42fe116a7_Device=CPU_Config=() +9047:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=219ef0bc43f90d459144cdbdb363c5382ed62c90acd319a628190dbf8f0becd9_Device=CPU_Config=() +8969:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=35212486e2fb4ea5f9dc1ed7d7ce580e941006a7e2f67ac4e6c4c4ffb3f514f0_Device=CPU_Config=() +8941:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5953b8e79f64e33e67dd330999ff8e3d8391c8f3fa7eae519b117b1273c8c19f_Device=CPU_Config=() +8790:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eba756a8d0ce89c9a8df50baeaeb82d5b719461bbaa06386db7e1be10ec535f3_Device=CPU_Config=() +8758:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4080ead6d9ec06ff8d7629bdd5eb303e82d35b5cbe53fb11d1a49b671d3e37b4_Device=CPU_Config=() +8655:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2f96ff03126561aa475067ad88e454b2da78fc8f0b816dc6c01ec5c81568288d_Device=CPU_Config=() +8549:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=80938e021a1ae127646a1f7e09de3970f443d853b6efe5116383ae37825f57e8_Device=CPU_Config=() +8447:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f49b212b59261888a5ea4652f9a4cdfe25657c7a0e4d3b6ecc16255e8d2e8cd5_Device=CPU_Config=() +8411:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eace26dff7f6f0403126e78a4c93920ee5e54a721cd580b4b18c2c9989baef86_Device=CPU_Config=() +8403:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d13d862f7b8306948676388381950639ef433dcc4e38f5a6fa8d50575d1aa814_Device=CPU_Config=() +8387:conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=() +8334:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=27dd1a325584acb3e37f6e30b23289b679ab9cfb28c4aaa1999b6ffb2ddae41d_Device=CPU_Config=() +8249:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=87f3815fd73265960ef5910a3b03580b13e96d02784e159a0bf0ebc30bc911d5_Device=CPU_Config=() +8208:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5beb9762188e985c9554ffb0a05fdc1608fb7d970baacebbbd7118186a324617_Device=CPU_Config=() +7901:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=57921f181e48af2b294b923633e457650e5ab2a9ac7f5d4d07930974ad5e03e1_Device=CPU_Config=() +7770:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=eee9a6474efc670ba46cde5daab7dac878055d12b3ec02a3dc524ae68572b02b_Device=CPU_Config=() +7665:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=aea9eaad28967e914b80b64c929fdb29f640c9144d6c5599ed9099264cd2f54f_Device=CPU_Config=() +7557:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=004b6fd9b060324a42aad296dcb21f5b7eb7586c082f98d23f25a6d882f70c14_Device=CPU_Config=() +7521:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2fdc1dd5841fbc3ee03a323fde995a9b51793a170b2c2fcb504ca721ac981fe_Device=CPU_Config=() +7489:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a56e05bb4d67e44e8e5dfd902b97af411de05a0f5b1ae1c07a074286c6636b34_Device=CPU_Config=() +7472:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=abda9df0d20139a837c079060be4bebb2d5c65c2b166341559ae9eb7937593af_Device=CPU_Config=() +7441:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a0f8789f0f95beb6f28efc829bdf2f99d34a3e9397ad1a80d7831aaaf125b5eb_Device=CPU_Config=() +7321:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f51b532391477cec9e0af4bafffe72a630e2f9f91265efa4f491d516190fcc1d_Device=CPU_Config=() +7296:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=29bb3b751638e157d0ba7114cc0e156a4b792a9dbb2bafa3ca124516595f01a2_Device=CPU_Config=() +7156:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=94de295ab12bd6b03bc5de22f9e9c46d5875d111eb942d3ba35f8e2456ece1cd_Device=CPU_Config=() +7111:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=39661d69e883bb7940e185a991f7b6bbd05248637577079fc52794cd1e215062_Device=CPU_Config=() +6943:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=94c0bd6d26bbfc0a8f22050757d17bc051a7af85dc6d6447d51413f2bf779a95_Device=CPU_Config=() +6783:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=71d1d8ec03d4807da4ac2fe5647ff2bb8d1547c070d82a9421216fa9d39166fb_Device=CPU_Config=() +6729:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b46a2ee4f7042328b2496382ed2bb9cf39621c3e3e27fd1d355c9682543effc2_Device=CPU_Config=() +6725:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=61104a3a93d0b36db7f0499ae63420f216e5d7b0171b40c4629f640572f04f2d_Device=CPU_Config=() +6703:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=86d8d42c30e423e801b5d4d832f87cd6837bf9feb3c546f5bf87e04f842a04f1_Device=CPU_Config=() +6612:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=() +6569:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c7b882a2a8948d97135ee2faaec7d11cf59af2bc2398a4b3c4713242fcc04bcc_Device=CPU_Config=() +6437:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5288d099588f5876e907c5cd750c9f0b2191d1ea060881e80af1006cfad259ac_Device=CPU_Config=() +6410:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9c15338e53353041d5e82067a4aaf56dde40144709b2bd04d86bbc7ad22b525b_Device=CPU_Config=() +6403:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d0aad85620a1b97486758b17c69043a6a9cf75a459bf6e283b28ca132e917dcb_Device=CPU_Config=() +6399:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=20af9ae4466332a072f3b04c1219146d272daabf2306b66c755980bfd31f2a76_Device=CPU_Config=() +6304:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=16ccecc11352f2c476db041adea21d67a96e03cf33902b37f4f6855b5113c202_Device=CPU_Config=() +6287:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=08a654f35ce851709d2c0634533645f6910b394b9cbb4bc6ddf20860f3a09c48_Device=CPU_Config=() +6271:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=cd389fc4a9417c7136f75474e42dfb43d1f9cb35fa0e104632ffa69fce2b7e57_Device=CPU_Config=() +6247:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d7fa761d51467b3295cda1fbd4a9865c3f1d1e3d5b8d7a091a66c70c9bcf5b4f_Device=CPU_Config=() +6229:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=dc12f3a61744181707e6cc6f1ed849088cca8ec067eeb2da8a138a69d403c826_Device=CPU_Config=() +6186:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1d1001df575da981792e8444dac2291418d7d493bf10063dadb8b439cd353ff9_Device=CPU_Config=() +6033:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0ddc207725ba9ee303b566526c77f7921016e12230cdef3a724e77e2a9e603f3_Device=CPU_Config=() +5971:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=4e6db028c1ff414e411bc09accf3b7c20cf81e530c903e14586eaad4c21fa111_Device=CPU_Config=() +5927:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f76dea75751ac96986fc17a4d344078ae4aae2fa2304b26e72d81f369986a9eb_Device=CPU_Config=() +5873:conformance_LSTMCell/ReadIRTest.Inference/Op=LSTMCell.4_Type=f32_Shape=static_IR=bb27af2909274aef2392e16e6bf596ea37bfe597bccd28e12caaf56fcbd1ad93_Device=CPU_Config=() +5829:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f6f3c6d199a224ee983f6905aa4f72ea4138e6076d7307c72588dda0cc9c6ed1_Device=CPU_Config=() +5798:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=2b6ad903c5efa29748d41521e0e0ea3c8d814d7de54f7831f0ea12602f265f0a_Device=CPU_Config=() +5756:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=11f515fce08428a29e672f25127e81f6388202d9e971704738d7fb758a615a10_Device=CPU_Config=() +5689:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1026aafc8501f7286a9094f317c551f15bb189bd449c59f1c83c7a4b5f8c9ddd_Device=CPU_Config=() +5664:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=afd856f31f3a815b84c34b66e1ba0a70a313301ce82fdccc2f1b779ad3157d4f_Device=CPU_Config=() +5546:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3d6f722f81b8a23f0dcb2acaea3686f0aebde1d810953e532cad9930a034d050_Device=CPU_Config=() +5467:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=bb5cb4e2a8cb9be32332ed3255c99de478d8d2e31cfb1747aa322df438ebaa49_Device=CPU_Config=() +5422:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=be944d418fd21f00271c405c19022a5e0f2be06fb973cd54ba8bd2610d02f0b2_Device=CPU_Config=() +5416:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4bb7bd2471752f1a62dc15dbcacad87dd329443459a90dc6768b1a34fd00c064_Device=CPU_Config=() +5406:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=55cc5328906cb6089fc9caadabdf3e176ec72c4239effc575aba4cd9c3b39ad1_Device=CPU_Config=() +5396:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6eb80b60b2162fc469f652535ee11822ae34c903ca44191dc95ad7f9678b9337_Device=CPU_Config=() +5185:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=9a21caf0c28c5526e267ca97f248e77babb375ce95d8c3893532d51686c69d23_Device=CPU_Config=() +5157:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6df4880ea064693f638735c7c7818014dcbad51d6d148f6a13477ab069703700_Device=CPU_Config=() +5129:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=81c2956d325aab4a7bfd931d94151e1285083a15326e0890f861b97017a24bb9_Device=CPU_Config=() +5119:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=754ed99b0565f9a10963e61e6fbbcfa64848b11c6a0a68bde7aae90ff9a1e34a_Device=CPU_Config=() +5092:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=97181a6433949eaef7277fdfec4f8f94b27463ee3ed4a6aefc678fdaf7eab4db_Device=CPU_Config=() +5086:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=95f63bbef529a44cd7170b83f4b385f0c1520f117ed7b4767527daa0fe893316_Device=CPU_Config=() +5075:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=92c3646daf445784fceeb022afba2831938fed34660bac5445f033a1efdccc34_Device=CPU_Config=() +5067:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2d88673274bc292b6ff26da9257cdc11b66e89c1f94d38e25ba6e8e74e647533_Device=CPU_Config=() +5029:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=d507892556310f7fe85cbf9245ddf040b219ec8cfe9c779809180a011caab9d6_Device=CPU_Config=() +5012:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=66bf131d73ad3116d698e15ac3c9e48bde66e096228138eb865c0807295c0d4d_Device=CPU_Config=() +4892:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=66a4d902b67742a95e2d41d79b9d2434e57a55c168a88049624a0ccb62df9ca2_Device=CPU_Config=() +4883:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=9a21caf0c28c5526e267ca97f248e77babb375ce95d8c3893532d51686c69d23_Device=CPU_Config=() +4866:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=() +4735:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e7e10785757d3131ebc375ebfd83c556e2c34a72be20965d9dd3e4f24a5ee2f9_Device=CPU_Config=() +4699:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e2d2eef3e776af9379eb35540d8f4c888491082d8333aeb70f58822aa5cee878_Device=CPU_Config=() +4697:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=5a1aa66136ca2be83f714067139e11fcbf672d73f8b28c57d29333b885a17f83_Device=CPU_Config=() +4677:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c21dacbc3d52b5171ebbdb769ee8869a2ea44f1af241b861d0adb92ecf5028cd_Device=CPU_Config=() +4674:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=f32_Shape=static_IR=dc12f3a61744181707e6cc6f1ed849088cca8ec067eeb2da8a138a69d403c826_Device=CPU_Config=() +4636:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=db7378dd474a32c06b89e9b046aaae3caaaa2972d5d6bbe60e70668e0c937388_Device=CPU_Config=() +4635:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=263843a2c307b91ff7d59d9b21cd8b2126e985d787fc18f44df3525a6bfd71f3_Device=CPU_Config=() +4587:conformance_ROIPooling/ReadIRTest.Inference/Op=ROIPooling.2_Type=f32_Shape=static_IR=1a0e3f63698678d2e6bb8968fbadc98227d9ce548e77c53021412d80d7711753_Device=CPU_Config=() +4564:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=945bd465761a4d9b013b0a5e88a3a9e041d8bd8bfa8df8044f28d71ba26f224b_Device=CPU_Config=() +4555:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=95bbf8a23b19badbde31e9ae7f016aa436d50d797f59bd736e220030f645bd9b_Device=CPU_Config=() +4529:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aeabe9639d6dcd5ab6e09f9905ffa8bdfe7cafcc7f5c8598e20e4ff39bdb50a6_Device=CPU_Config=() +4493:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d73edb68da4aee1c052b79ffce030b368f204c04bffd9a9dc01a9b54de932e7_Device=CPU_Config=() +4490:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=997a090766babacae10464bab19af5db238eb28704c6d463cfcba48767a90c8b_Device=CPU_Config=() +4426:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=461dc8aa282946831fdc86d1c024a273ac0f29f5ad615cd55b879feea6d23007_Device=CPU_Config=() +4389:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=08c583b490b8cbd43eddefc35f87cb6a11fa07284d5003b6fe43f66255c380c1_Device=CPU_Config=() +4384:conformance_SpaceToBatch/ReadIRTest.Inference/Op=SpaceToBatch.2_Type=f32_Shape=static_IR=8acd95619121cb22760fd92815b1ba85f541f282d3860e910f73036ed335a9ee_Device=CPU_Config=() +4371:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f55c473236715e5c4e6ec21a9e07d1c73b14d529b57fae0cb38ef9d6cd383b53_Device=CPU_Config=() +4366:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=7cd8ddb895321ccd41cef1f30ab6c09a933366be542b08fd486270c25109012c_Device=CPU_Config=() +4348:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=2a3d6c0476c17897fd4cc6d3623519fc033ac4022a01fbebd40b461f414f6c15_Device=CPU_Config=() +4347:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=f32_Shape=static_IR=aea9eaad28967e914b80b64c929fdb29f640c9144d6c5599ed9099264cd2f54f_Device=CPU_Config=() +4309:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3cc5aa461509250629415c061c909228cfe34e8f773b88badde597ee264be865_Device=CPU_Config=() +4303:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=dc4bcacb769fc4d8f1ef4ff20ca7ba6b3b369d69ea3b1c65733d4cbd2cb0762c_Device=CPU_Config=() +4260:conformance_If/ReadIRTest.Inference/Op=If.8_Type=f32_Shape=static_IR=If-8_886_Device=CPU_Config=() +4250:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=99377bd11138d36797502d82ac9adddc31dfe1e4cbb8bba8684b1479f8a16f26_Device=CPU_Config=() +4248:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=df5ba55412d924fca818d6ac4b1709ab651f12e4b64d6a9555644e8e8b26a0fb_Device=CPU_Config=() +4228:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ec42345583e635cc0f51b20699c340baced5816bd7ea62856d8b3f7e21a164cd_Device=CPU_Config=() +4220:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a2b621c5ea887266d69d70093db3504250f63d502f505c6a29a38ccf88b6fbce_Device=CPU_Config=() +4217:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d9db827de158568b8a10347c13216e92b37ec20d8eac92c38aabd86690114805_Device=CPU_Config=() +4214:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b3e2dec4b768d4a421c0bb36ab5174fc68e4a37655cd7a6f2072e0db9894cd1a_Device=CPU_Config=() +4174:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=02203788eb4b05d20c5873aa7be8b317797503693eee6748e4130ff7ce72ddaf_Device=CPU_Config=() +4138:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=aadbb3768045a0dfddff742fd6ac0940bf0968c7e0b1b22b064503d4081b0a54_Device=CPU_Config=() +4102:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=7cd8ddb895321ccd41cef1f30ab6c09a933366be542b08fd486270c25109012c_Device=CPU_Config=() +4092:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a7ad8306fe632a2d0c45a492ad2d21dbe40f2f9ea55074d602beb6f8dde17982_Device=CPU_Config=() +4090:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a93ade5d0390a07d7f8a6ee0c7099a40b3ba3df0b28a9d72cba7006e4d0191fc_Device=CPU_Config=() +4074:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=69aeb01964c5dc32bbda77681903931df3fed18b0caf978ad5e986ad59c8b4c6_Device=CPU_Config=() +4065:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6d754f7aaf66f59951015d768d438e036e0c598303c67ee404c5f9a4f8aa30b2_Device=CPU_Config=() +4063:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9984b8a3f89c63f522926899b38043623619e9b47918f7835234a4ea5f615c21_Device=CPU_Config=() +4053:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=55cc5328906cb6089fc9caadabdf3e176ec72c4239effc575aba4cd9c3b39ad1_Device=CPU_Config=() +4027:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4a7d98292fd2c8c98ef8f5a0996abf170591dd1d15fb17229c0005b0a30cce4f_Device=CPU_Config=() +3991:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=() +3980:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=93788242c06d787e33afa50ecbef5372898e50024d0c88624056a752535572bf_Device=CPU_Config=() +3971:conformance_GroupConvolutionBackpropData/ReadIRTest.Inference/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=9a92abcc42e0ede56b448e3128ca970cda68fdf27b553430d6d5c5397b7cd59f_Device=CPU_Config=() +3944:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9c4adbd0f6e4ccc612a4906a5e3d0ed20fba39b9521a78b88c95b540ba7a1e3f_Device=CPU_Config=() +3943:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=74ea1727d6d5474136a87786b87f5a9b8923f78ef72d52a0fe9a39dd7d3a293f_Device=CPU_Config=() +3930:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7fc4d09be462fbd17d4bdccc5c6c7014dad92f58c8999c7e78b7475bbc076bd0_Device=CPU_Config=() +3918:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f18fa21106120cecd81f50d635b1c42cbd641877ffbf78e746ef7375ff546d7d_Device=CPU_Config=() +3895:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c531648f3b5841ad892debb2fa2eab6ef35a08d0cd5e9d33bc0a7b442a1fc707_Device=CPU_Config=() +3872:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cc0f83b1e6167e74fe1198511d4fe4de611a24a0daaefec2eb2bac280de9c5a0_Device=CPU_Config=() +3855:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ce13c479a981a68967fe75da84baff1bbc1ccaf0dcee5aa988d71bb49bba14ab_Device=CPU_Config=() +3844:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e3a25054872107eed50b9d6d9d612c46b781ab5ba4fdba17988c2c73a48a37bd_Device=CPU_Config=() +3833:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=() +3827:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=dda009a1f3191e35286b7515f5741905e303f27287041248e2ce15f6954af810_Device=CPU_Config=() +3796:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b83a85737c23e279f8878f6795581dc2b003c55e4eb8baadfbfd73fb0e98758f_Device=CPU_Config=() +3785:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=87a966d3d3b90cb32db3454c5dfb2f67af86b68a5e45fa1c5f4a75c3b5cb452b_Device=CPU_Config=() +3781:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4232c8e7fec9c583f6a244b2b7a8bbad618819f7885f8486a1b2a9e3b36c90a7_Device=CPU_Config=() +3774:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=93a382b4c379f41c5a888ff51ba8ae2cb9e7812ce4c14f1a028fa383051a9feb_Device=CPU_Config=() +3771:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=38b9494dea51a8f26748bfa4be970913acee0bf6d97e526578e40e5e3c04faf7_Device=CPU_Config=() +3753:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=1d7cabddc96cb4ca2ed111c9f7a9c31b76ed9a052fd0b79db6bdc8fc55f24a4b_Device=CPU_Config=() +3695:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=eeb4d5ffc7eb6cdd80079e6b814a1c228e389e4fa01ca368f092b606666bf7c0_Device=CPU_Config=() +3692:conformance_If/ReadIRTest.Inference/Op=If.8_Type=f32_Shape=static_IR=e178ca7afdd75b09f1ee18e50afd30eed0740497637863c3397b5a75c0f8bfd5_Device=CPU_Config=() +3679:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c789d40bdedf25bda58d6d6ce2f690850ec42ff8712abd23f7947a8604b6953a_Device=CPU_Config=() +3671:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=b050ebcbd31acbbc43d657d87a54415e0e52d3e91fa95b57aa1dd0451a5bf50f_Device=CPU_Config=() +3653:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d7e3ea8c5ea46f1b0430b6a2763c85395235c0ac58652e1d269e1257f6dbf7c8_Device=CPU_Config=() +3627:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=14f550bd7e83223ffbf501918141376e6a144484865f03c9768fe9da49a9f06f_Device=CPU_Config=() +3596:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e86061c75b7e9a65644e82de6b8fb2a532ebdfb302f46f378b6ff20af8d1d14b_Device=CPU_Config=() +3593:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c0413244803edff103b95dbbcab27b2c714740372ba215264371a9474355a8c4_Device=CPU_Config=() +3591:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=4e14d87b7667a7900d4427ec46c72eb3c7bfd2e3d86e5bdf92eb2485059b4951_Device=CPU_Config=() +3568:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3ee918ec76a3432c5179480e1417b0bc84da24c2716af490292525a824d1d2ae_Device=CPU_Config=() +3567:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=29d1a1e024ca9bace919909bf537adbeadce2875807ab12a4e3b3499c4c834b5_Device=CPU_Config=() +3550:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3d39ecb890c0070ffbec20a5540c9841a075d29b83113350a2ea7a0bbc984cf1_Device=CPU_Config=() +3495:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d242e8ecc8ae0239fc2e7773fe0f8a1d50792a71ae4aaac4fd439174e87e95b1_Device=CPU_Config=() +3494:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c1146723a7ea4ccf82c8d62c0665aea78976fbda8e1e0bb40c962b95069e8e7e_Device=CPU_Config=() +3458:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c161ff64d4c506fdbe44d0ee76042f958f5dfce778833653628a026de01a3f9f_Device=CPU_Config=() +3444:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8484c5c087ca8317588ef676a0cafb63ded379be5bad862e4d0504f43bc6fb45_Device=CPU_Config=() +3442:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8f731757a7c32fa8e4d602d7197af81a1a82ea228ec05f4baeae7c59eba11f2b_Device=CPU_Config=() +3423:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b4dea8581ef6ba0546774e88cef10aeb80f847b8d227fb0d3981baae1c44c2b8_Device=CPU_Config=() +3396:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cfa4ea6d340205f9fc4db4ec912037243299168e9bfa4e248e530c98a0f8a8ab_Device=CPU_Config=() +3394:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=ae444aa1dc9d87f1610bbf65710d9a5f9710d680848d08afaf54f526f78b0dc2_Device=CPU_Config=() +3381:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8c3b386463bd59945d3c15512b26409dee7da9b1940f153e3ff62d47d6f79d2d_Device=CPU_Config=() +3364:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5bdc625498840e88bafb7d6f58ae8f9f0081a9bd0a6cd71c72a35871ca5b1f12_Device=CPU_Config=() +3357:conformance_LSTMCell/ReadIRTest.ImportExport/Op=LSTMCell.4_Type=f32_Shape=static_IR=bb27af2909274aef2392e16e6bf596ea37bfe597bccd28e12caaf56fcbd1ad93_Device=CPU_Config=() +3342:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a0b3d7813e380f287a758c35e56e8e8edbb72b8c64fab6194a8890dacd5e2f16_Device=CPU_Config=() +3341:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d7ce9fd9d99a7ce9ebb5fdadb4db39f4ea66f74788704b2b9f96660c7403c031_Device=CPU_Config=() +3334:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cdd7ce044f231ae39fc0f7460a55473c0de6934124cd263444a5912b8cbbc0ce_Device=CPU_Config=() +3317:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1adb71d66ee918c5806737933d1c78f93ab48190df44f3cd8c928f5b0aa7d9a1_Device=CPU_Config=() +3309:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4e6262ae12e4f9470a87cc4f1cc1ef2a817a8080e25a79ca4ef67cb60a558b41_Device=CPU_Config=() +3300:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=85ae3a9991f339aa4cae498d33e44fd838b3e3f8e2cff7a64701b62207ccc965_Device=CPU_Config=() +3294:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ce2bcc21fba106cc8be4846179a73cb30f650e7ec48d443fed591f6b479fa9d1_Device=CPU_Config=() +3285:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ee098548fe040592d091ec00999f6f9c4143ba2f8ab4975d7a7daccfc7cf2da3_Device=CPU_Config=() +3275:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d8b8999a17ba375cd8b7bf18f4d9d932fc6f5b6787484633c9b11f6003eb8270_Device=CPU_Config=() +3268:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e1f0357795d5676c5e4a38b6639cc90c924880ab961eb73e407b5ad0142ac0b4_Device=CPU_Config=() +3267:conformance_ROIPooling/ReadIRTest.Inference/Op=ROIPooling.2_Type=f32_Shape=static_IR=556c6863ca3b12d255c4c81d92b4573203f02c5588e064fb22dd4aa23c8283c6_Device=CPU_Config=() +3254:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9ba199e71a3ff06e6bd330e453a1e1103599902893fc267c60da9ae47575a8a0_Device=CPU_Config=() +3253:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=cc8a9d50447be96c4d4738ddd5cdd88356f9e6e73ff8cf3fd90c4a24ebfe153c_Device=CPU_Config=() +3234:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=cda3b9bda63d065b5c27e6bce5ffe20968024d77efe5e174a9f4395db56a30c0_Device=CPU_Config=() +3229:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=670a0d513277b4508e8edcddae6361e98fd03c2fff31293637c36f97e59a6b9c_Device=CPU_Config=() +3215:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=125ec4e4ba4158d3a6d1a7725cda9a18a220926d5ad6ed623a1433688c79b579_Device=CPU_Config=() +3211:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9c66c6a6d93c10149920c3e034d9a0765afbef45dab66083fd5e3d796a57e406_Device=CPU_Config=() +3203:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9991a1b4140ee8e6ed0460fb384b7729f681bc1068315a4d970eea59dcc89950_Device=CPU_Config=() +3200:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=851aa3cf931a01e0188758055b866fd14280bc344f548da6166e4a57ca7c9254_Device=CPU_Config=() +3191:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=cd5756749d3d73dc7b666f7f41dc292c73230e5d31ddbbd43aae77210b86220a_Device=CPU_Config=() +3191:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9795aaeb71c115680b567eab0877df338c0d8971858b489a2636c4483f3512cb_Device=CPU_Config=() +3164:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=78b35bf08a9f69a1b07d5d6ce728839e08f51739c60583cb094e4abfd6fab1e3_Device=CPU_Config=() +3148:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0785cae4389228b343e2620b4fad71e5d1343838d4fe2c766bceb2e337334e6a_Device=CPU_Config=() +3140:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=114c112cd0e9ee76e06605b2c3dca5a6403f6d7c675177b371096087782e06d6_Device=CPU_Config=() +3138:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=83d90ef3fac993f7efba4a8ed369781571b1b536af03ceb0267ae979379e1dd9_Device=CPU_Config=() +3136:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a93352138c144fd004303788d08066d279e5363345d3da2cf16ceb61336d58b9_Device=CPU_Config=() +3134:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9ad22386a62ba639f3d766e8b6657e95fc12bf94b237edf7f75a3062425bb899_Device=CPU_Config=() +3127:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a4929232b06cc35bd37dcbd228c83319db5ff98f120a3995a6806d397e16d33f_Device=CPU_Config=() +3119:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=04db488d856ff6cf4f04ad155967df95830796ad733e589f42c3862224acd874_Device=CPU_Config=() +3113:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=9f7a30c4f90df2edf8e70468ac22f325bc97e99613fa6ee2aced93e71ea5896a_Device=CPU_Config=() +3111:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ae2e7b59de9fc5d689cf677f1ce023fa58235c99d3efa662148d01b2bdfa0e0c_Device=CPU_Config=() +3090:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=81e9c51ff606608d5a0f868a7ff529afc34804e04415b2ec654f31f848a81e1b_Device=CPU_Config=() +3081:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b7983ae70a4e7868ccbf4b25a5d8e795620182c29817ad1151d89f2e932d770b_Device=CPU_Config=() +3073:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e8703e68163db56928e366caccc3d2d89fbd35aba3c95af33a9d615659871d8e_Device=CPU_Config=() +3071:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=94ad9524c175a0e0d2fe22bceeac82b0dc66006caa0942d343d551268e03afec_Device=CPU_Config=() +3070:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b76160001b7c4e0963f942d74ad2114d4205c689a1715f8e0fdad75404d718d9_Device=CPU_Config=() +3066:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9cd66958dfe8db471d48d6ea35f1b4547a413fcdc6c61c804a456befcbb09d15_Device=CPU_Config=() +3063:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a3ae510f07db7c475dbd4500d129e0939bfeb9c8cd5c5090184d501f8c7106d8_Device=CPU_Config=() +3061:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f8eb0c39d812083381ffb5f66921c5eebf3db3f22f6531c7a81346bed8d54369_Device=CPU_Config=() +3054:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=0a7b1efc8d314c5e37062e482a9398f718082ba0528c6ca2d2f6c88e7a4a2bb0_Device=CPU_Config=() +3050:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f5dbf9b79d3887c9207d8971e45282f563af47565ed7a941cf972014e8b5bf05_Device=CPU_Config=() +3034:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c1ffd0690c9370725a30028d2915ec798aff173f86a1864f3dc92a4defefef85_Device=CPU_Config=() +3023:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=() +3023:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e22e40a4f300567612f963b17707be4de09093cb9a248aed62af594e7986f7dc_Device=CPU_Config=() +3020:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d3add9f9496b58c3880dcf71a47c3efa156aa225d6d7faebfdf4c2f8e44d0be2_Device=CPU_Config=() +3018:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4fb0809c5cf2945a097d18f445de6f4f5cd2c124cdb495e6f0a12e9d937e2b80_Device=CPU_Config=() +3018:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=29eeefa6ea54ff2530e2e17153db324026e85d4e45432c053ca066699187bbc5_Device=CPU_Config=() +3015:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a50644dc2d133df429ff4aa6a19ca9bafbf41d2948522e584fc5f417ad16d76c_Device=CPU_Config=() +2997:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=978c328422e3866322f3bdd52955690a47a1fdd47ddb9db66a4707b36a535dbf_Device=CPU_Config=() +2994:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=67c29ca00af28406993de63d8e7782945a32705d95d4e6e4fd36fbf4e468a7f0_Device=CPU_Config=() +2982:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b062486251781b09e932268862ed34f7a6df71ce15ea598ef5344f04f88c006a_Device=CPU_Config=() +2977:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=98a6da6e0972a1b70caa5df788a6921d4e470565dc3880faa59e913fdc15f460_Device=CPU_Config=() +2971:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f0853773e26eae3d051504ed8db7f182c0e90ef7b45625a1a72ac51a73e2208a_Device=CPU_Config=() +2949:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=843bee6f74a42e3303b4bc38b302fc0858c4dea7ec4bc997c6aedfd0cc76ba37_Device=CPU_Config=() +2944:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dc9060efbe22735c22c69f0323c7e6a77a30cfbaae7b79670b9b26fb2be70_Device=CPU_Config=() +2943:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=27a43bf8c20a81f1e244ace4c53f7cd9343a2603ba2c8b50bb041a4046ae6ecd_Device=CPU_Config=() +2942:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bf4d5291899ea4eccf6584f62d4ecdfb39de79edd102e509f840664838f59d19_Device=CPU_Config=() +2932:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9e573f34ccb820a89a27cc243a7cda8ecb2043ae1cc557a8ab7e4670b1d72c0a_Device=CPU_Config=() +2926:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5e98e0dd0eec9f330eaedb43a4d3ee506c10d23283c3e25e753b634e819f460a_Device=CPU_Config=() +2926:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=cb2f89380861307422024c308f636e33a827f32a721e54a380fe2b1c1b74c881_Device=CPU_Config=() +2922:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ed4daec3f69dd307e284f0c8d5c5115144bfb76e8f550f7eb49f3e3da6bb1be8_Device=CPU_Config=() +2921:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7f595d19716e871ad3301526008abcf663271669fa7d55bbf292a853e9ff517d_Device=CPU_Config=() +2915:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6a3f3c1b6e3617139da7a30c725db5dcd70c692ac7eff64c5fa074c2ca0e6f9e_Device=CPU_Config=() +2902:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d46034925bf5b01e31b5a57911fe30f5dd09a8712432312fb1efd844e69913bf_Device=CPU_Config=() +2896:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=edbbf6122999103bb19f5d7d4f694ed72221dbc69fe8912853e01a9125eb46d5_Device=CPU_Config=() +2895:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a848753a720bf9791ee4c239cf08712d714b877bfb6df23805590ad690ceaff7_Device=CPU_Config=() +2891:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a52a8e6ef7bbeacbc1435cde72a1a70bdb8a3abf78b5b971c2ecb1135cb4c136_Device=CPU_Config=() +2891:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4bedf955c6ec574258a05f59e5397225e1360ba68ea49d4fe105d6a62ccb3e97_Device=CPU_Config=() +2879:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f13dcb47235a9516298088a0c45ff56fdb7f95144da257a3dfa1c618c7373ce9_Device=CPU_Config=() +2869:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=ea0fcb3a84306f10c2ff5fd89659a19497da84225280efee670cce6f10755e1a_Device=CPU_Config=() +2863:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a24dd1485e484f31d0c72f3a0c31f373f883f6ca4a751b1d2ce18132913506dc_Device=CPU_Config=() +2860:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b57367632c1064f82de68ae9aac88d8522a6039ced4d1078483cb2c679785f04_Device=CPU_Config=() +2859:conformance_LSTMCell/ReadIRTest.ImportExport/Op=LSTMCell.4_Type=f32_Shape=static_IR=828ac6aeddaaa033842b086b946b507fca3f65a7ea3a9a53bf697da37a889db7_Device=CPU_Config=() +2856:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=556de70b55386fc9a264a24a9000d075a07636de6461cc5f4cd41af639b0597e_Device=CPU_Config=() +2853:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=656a9ec09853506a1b2cebaeb2f64a14880cd860acda34dd13ed3d3433d69971_Device=CPU_Config=() +2851:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=eb014b2651dad2cccd6291bceaca16047a4a7fce1595430520ad8d8601ff29c9_Device=CPU_Config=() +2841:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b77381b3187aeb253a360ff35b4beff6401a89ff07a851230e2dce191c0a136c_Device=CPU_Config=() +2841:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2631bf7f735ccaa382c2ea452c247f8cb4cc1a0a363362256d971d661841d637_Device=CPU_Config=() +2840:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=839faaa50aafa2e3ed38fc682d0759304b694043dac1a242a085e2973aac8091_Device=CPU_Config=() +2827:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=56fa4af7b32a139a903744478ab84858b98dbcd173f4c0f3da01d4ca547e1dd2_Device=CPU_Config=() +2815:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b9bab6ef11eb6ae637924a902a40dff310a45916d50c8f0a4ec667c8d6bde6a6_Device=CPU_Config=() +2808:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b6bb8473f99506737101987d5732d33073de8783b22d891c652653884bab7a87_Device=CPU_Config=() +2804:conformance_GRUSequence/ReadIRTest.Inference/Op=GRUSequence.5_Type=f32_Shape=static_IR=860decd2bf091a335f6f820b2c6b6acc58618fbb6027e30484470ce899bb1591_Device=CPU_Config=() +2797:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=() +2797:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8d9dfab64d8e2b91c6b1429256b5e7c60d19d1891bdb6a519ac91886a6269fd4_Device=CPU_Config=() +2793:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a3d6337c1ea3e8b67256696ea4231da4fc0e9d9f8bea169607a1287233086b3f_Device=CPU_Config=() +2790:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=046798a0cf8d4c3fd8f1dc12bd0363a669628e748a6c964385eb50bb783924fd_Device=CPU_Config=() +2787:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c5c5d09465cec7f1477d5e02f3f1c4cf593c71aa090532c4e43451fedde7c2c5_Device=CPU_Config=() +2783:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f069cbce6f4c3276869b6d9c4a6c843d7a1e1c9d299e8680218636b04339a9dc_Device=CPU_Config=() +2773:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8d8b631421fa4d1ab70cc2916563550c0823dcb04267b3c50b23f3f245e45d98_Device=CPU_Config=() +2771:conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=() +2765:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.1_Type=i64_Shape=static_IR=26d97c755f660ed8ee08a0de8d6ab88598391cc79b239bfaf0a102722ffc4bf7_Device=CPU_Config=() +2758:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f06ff28476f886d4298a83d39f88aff34399d5cd589e0a6d6395e00b0ad96876_Device=CPU_Config=() +2754:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=a3de81c04a0e7d5cab275045415ab4c294ed3270588c2ef704ab6db5514ed0dc_Device=CPU_Config=() +2745:conformance_Erf/ReadIRTest.Inference/Op=Erf.1_Type=f32_Shape=static_IR=906676850a62f56935dbd13792be1013db602488f29eb757a546b411699ccdd5_Device=CPU_Config=() +2732:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f257b78ff2b8efe8020b7e6f23c5e75ed7a3e752bfc44c69648b3450169a9f6d_Device=CPU_Config=() +2730:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8d88e8ad02fb6c2acd45c736689a1de8d5a54f6a2ac5b6618d5fd9b4110874a1_Device=CPU_Config=() +2727:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f43df065734a36674b3fdc7a47fddd1cfa5c1b36bf73e7de86a100c645fbc7d3_Device=CPU_Config=() +2725:conformance_SoftPlus/ReadIRTest.Inference/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=() +2721:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=be67f733f734ca7f0e54076cf1cc39016924607014ae1a312849e8b5cd5b916a_Device=CPU_Config=() +2720:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3c0b9fab07568e0eebb5e5d068cfccdd617ee6e98e4253a0461ea8d3f0f582e8_Device=CPU_Config=() +2719:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b53fa2c9b93d3750c17dfb8ef75e51c43881ee79fddc863d6c1c2adfeaeaba2e_Device=CPU_Config=() +2717:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=23654f4a28ae697d81f49d72568e7f0657d5c15b82e173fd7381760ebcb61cda_Device=CPU_Config=() +2714:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=d141b35e277394511f5635b2e395039c986ac392e6f49c2415da6a5071bee96a_Device=CPU_Config=() +2709:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7f30f8f46d999a18110b8f8f9235b3534249be45e55f1aacb419126ed1eb5851_Device=CPU_Config=() +2706:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=69a9e38799e925044cfd025df20a3593240b2d1145de5eec905d30b3a1ad923a_Device=CPU_Config=() +2702:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e6724e0da81e65cac207d53f3b792b046d3d6dd47230a7cbe0a690baa9f59306_Device=CPU_Config=() +2698:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6587874c50811a2ca7e27f84cb4381e9a06eb4465e940ea877c76dfaeba02753_Device=CPU_Config=() +2690:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=79a28185585166e8c3a7988d1e74df784bd8078df963fd220b97d5624ad8ce76_Device=CPU_Config=() +2688:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d8a0ff565e3467b3d0e2d6f1dd856b2ab812d675a09645b4a3b3bc8f29957453_Device=CPU_Config=() +2687:conformance_HSwish/ReadIRTest.Inference/Op=HSwish.4_Type=f32_Shape=static_IR=98546b7eda390c30f82053a093b5e3855c6dc8c631451b3637eadf95858af2bb_Device=CPU_Config=() +2682:conformance_LSTMCell/ReadIRTest.Inference/Op=LSTMCell.4_Type=f32_Shape=static_IR=e06dc2c56b985c79eb1bfbaafe281ab726a6c1c87c4092d1efad3e16cebd3c47_Device=CPU_Config=() +2678:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=4e6db028c1ff414e411bc09accf3b7c20cf81e530c903e14586eaad4c21fa111_Device=CPU_Config=() +2677:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=64e95307077995f1ccc314b1cfb2254a18895371b5ebe71b521523cb42e456d3_Device=CPU_Config=() +2663:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b60e16251938c61b34dece8f23651a595c8c8744df391c6ba17bc0e0417cb398_Device=CPU_Config=() +2662:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b38f11a07d752c83a5e4fc709d5b78fe9a40ef3394f4b617a30df29c21640338_Device=CPU_Config=() +2662:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=277be9cd89ba817ab595481b040e3435eb08d1a79bcb05a7796110550a071201_Device=CPU_Config=() +2657:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=a714d51739b3d420cf27f476e338bacbeabb40d0ced1e1527587756265253d8a_Device=CPU_Config=() +2655:conformance_If/ReadIRTest.ImportExport/Op=If.8_Type=f32_Shape=static_IR=If-8_886_Device=CPU_Config=() +2654:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=79a6d2a402cdd74cf1277a57ff95b71d61384da394ad2a4d9ebcf422eb5c3258_Device=CPU_Config=() +2647:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=94de295ab12bd6b03bc5de22f9e9c46d5875d111eb942d3ba35f8e2456ece1cd_Device=CPU_Config=() +2644:conformance_HSwish/ReadIRTest.Inference/Op=HSwish.4_Type=f32_Shape=static_IR=1c38a17a13c5c03cfc1eeb147ca2474debea05ae1d6f2357ce40ce23552286fa_Device=CPU_Config=() +2639:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3b9757ef04206894e22a41c20c801743199f098a8899a9ab19228b44dd754fdc_Device=CPU_Config=() +2633:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=a3de81c04a0e7d5cab275045415ab4c294ed3270588c2ef704ab6db5514ed0dc_Device=CPU_Config=() +2627:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a4e797de860d6e4dcec00062050168ba9745d3da953b9c644de654f4d2818b77_Device=CPU_Config=() +2625:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=94693638ec4742dea16dc168eb9323995f1b2a35a53f577cf58ac3a08096892d_Device=CPU_Config=() +2624:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3f836daba711312827fc9f3ee1d7d376e22ad7af24fd156ceaccd5c75678b9bd_Device=CPU_Config=() +2617:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7754523e2d3739481e051eb21a4347f2d157e94db3c37d47f0006ecd8d77d512_Device=CPU_Config=() +2599:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=358a9002c54b7e671e8c11c8e6deb11c8463b81846d305e47c75eb3c63bb5b21_Device=CPU_Config=() +2596:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6a1c4fda6e89fd564d571ee69820791696d016e379dc78c8c55ae0e6934537b5_Device=CPU_Config=() +2589:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=() +2584:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=() +2584:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b0dea4cb6a0cd2380e8657b0b64caab43819c0f8182ed73b2cb12eec608bfa7d_Device=CPU_Config=() +2581:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=f31f6d969e04a7a1c964c02f107a7291c85067ac31d935921bc418363c2a7a46_Device=CPU_Config=() +2580:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a9571d2008f31f55a7c6eb83a7249f5b8bc973bd05b6a845fdb56b15db7ef7fc_Device=CPU_Config=() +2576:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4746fb4d92aab20d21eeb0885d35c88abd50aa250298473f5bd143658eef2316_Device=CPU_Config=() +2575:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=225424666fe2b655277d52f1d551c6e52e36cd5fd6f45f4f29dd0d0f66b4ba40_Device=CPU_Config=() +2573:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=821241f6ca4c3888fcc2043919fa03466266962cfc35369cb9bca51f5ee61b01_Device=CPU_Config=() +2570:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5983b9e38433fb9c767b7885ea749d6e89fe9d3a46f45777097f046611f31fce_Device=CPU_Config=() +2568:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d3e089f773288c135f90d5e2e1d4a667e3c9d1ef6a121e65206dafec5a36740e_Device=CPU_Config=() +2568:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f49b212b59261888a5ea4652f9a4cdfe25657c7a0e4d3b6ecc16255e8d2e8cd5_Device=CPU_Config=() +2564:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=876a77d1e2efb758a87bce1dd2fe35cd8e455c6f3dd7cd2bed8e10504c426de4_Device=CPU_Config=() +2563:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f37f03c3986aa22dcb304445093d34bdadbc67de22cb9c42ec1d6a03f0386d0a_Device=CPU_Config=() +2563:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=285bcc240dec2c32e171f3866ea33107a109566fb8ef39f0dd84e99664aaf8df_Device=CPU_Config=() +2562:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ca5847147325177b69e97415489292ae793cfe1346e23e8a7bad000f9a702d91_Device=CPU_Config=() +2547:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9033954b258cdfa9fa858317ee4588b8c92cc946d7eb305bf130d3ca8ee0f1fe_Device=CPU_Config=() +2545:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=446eb2e8b2bc5f4e6c1da3e9c4b0492fe73408e4749ac3947e39c18b54bd13e5_Device=CPU_Config=() +2536:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2fc01b66086ac5d8272dd81ab731188b62bbe8920bff1efe61bf3261a3a8b3e6_Device=CPU_Config=() +2532:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=876a77d1e2efb758a87bce1dd2fe35cd8e455c6f3dd7cd2bed8e10504c426de4_Device=CPU_Config=() +2530:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=() +2527:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=f645a2275ff33ad614c801a8f2f262ce1ca95417e0ca59e28d4b87cf3289c00b_Device=CPU_Config=() +2526:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1eb25d18fbd1070f2a8ff803d76077d092d493f9e9df80e93e2f58f3621a121f_Device=CPU_Config=() +2524:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=79e0a530c5a64063a9af26b438f208476e3bbf5a267c28ddded0459019a1d8e1_Device=CPU_Config=() +2521:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=d05c1b7fcf976117a23e0284998d9ce21689411ff24530175787f1512ca25879_Device=CPU_Config=() +2521:conformance_Erf/ReadIRTest.Inference/Op=Erf.1_Type=f32_Shape=static_IR=2e5aed1612da0f720adb051e22460983a3911c38cb09184d812ceb949870f450_Device=CPU_Config=() +2518:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=dfb16811d2a3986853d6e5ac937c96cc89e47e20bd3eb443142699dd62ba2890_Device=CPU_Config=() +2514:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=66bf131d73ad3116d698e15ac3c9e48bde66e096228138eb865c0807295c0d4d_Device=CPU_Config=() +2507:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6624c22e3b5d72c4e8d21df59af6f3759fa4d8fa68f2b5f3f92a98d6a943d0b4_Device=CPU_Config=() +2506:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=139cc84777f1e0d489245d058877303e72a93eba3cffbf5f919de21b4514bb0d_Device=CPU_Config=() +2506:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=214e4e8f7de64e9cc8c77c67d214172905cfb4b9fde65e2ef3d32bb7b4ed93f1_Device=CPU_Config=() +2504:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f0af28fe49c157f5f62f72f0ab209c50aa07d97c65477217fde6e3a3d0dc98ef_Device=CPU_Config=() +2501:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=4946bdb7dec06c2bc8eae33d5903d6fa41bbf3654b13a0cb5cfa4af5a4720426_Device=CPU_Config=() +2498:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b654dfb551ec2d83e22a133055d78f13153fc1554728e34aa7f27a3f3c08541_Device=CPU_Config=() +2498:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=8c82cead166c3db4616f034b66c4795cb4bed653de41d2b6dc71b48ce76a296e_Device=CPU_Config=() +2495:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=() +2492:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=dynamic_IR=791be312b2af6da6abd2eadadc6185c7052271efbcf314bb678828313fc58414_Device=CPU_Config=() +2485:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=63de0838ea26e3575f49700f73fffb0d3415ab68b29b1a1da690b84f7a034822_Device=CPU_Config=() +2485:conformance_Mish/ReadIRTest.Inference/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=() +2483:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=178677f6c6e3857b2c3aa8765c8e3186bd25b73154ba6463ff33a9e1c911e6bf_Device=CPU_Config=() +2481:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=23f7f775455e615175f3122ce422ee96de019ca40fe603b5a4605d51f28210b1_Device=CPU_Config=() +2479:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e4ce66856864b395e08ba68b1e0fe9ebeb0777392c288b334e06553898c04743_Device=CPU_Config=() +2475:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9f8fca1ab855d5a71d7acabdefda202e270bf16b559fd581f9e663caa301ffd7_Device=CPU_Config=() +2474:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5d522332a7166265867b633721d8bd8ff23a233e7c8bff59a245bbb24d7be234_Device=CPU_Config=() +2472:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fe70e0ee3f24f0bfe4391da7797647a01f66fcb109b481ca859c9f8f7dc7b411_Device=CPU_Config=() +2471:conformance_LSTMCell/ReadIRTest.ImportExport/Op=LSTMCell.4_Type=f32_Shape=static_IR=e06dc2c56b985c79eb1bfbaafe281ab726a6c1c87c4092d1efad3e16cebd3c47_Device=CPU_Config=() +2470:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c533b2b13f88a1c6296bcb6831a96fdd4d354c69848e02bf3e9a1e632264524c_Device=CPU_Config=() +2467:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c3e5791580edfc2b522c8a3aecd33445b3fa8d771e2b5a8387ef0f303773c848_Device=CPU_Config=() +2467:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f8ee6adb1573c51bcffdd8c24455ecd6b6fbf04f171e9aa5de36c5d6f18babe_Device=CPU_Config=() +2466:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a5247d95c2671970ffbf4c367bbae5fe76245fd6e0db79c9c4fb9b7659dbd4f0_Device=CPU_Config=() +2465:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b391194df168bbb18b31fc1546168c2693ad3387d562e44a102467833fd992a3_Device=CPU_Config=() +2461:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=4946bdb7dec06c2bc8eae33d5903d6fa41bbf3654b13a0cb5cfa4af5a4720426_Device=CPU_Config=() +2458:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7304a384051e1414ef335109147d0dbcc385650751a174440bc9712f89036372_Device=CPU_Config=() +2452:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=33013e27c35451969b0c3c8493a34fb5c81527a7480bb12d793a2d597d712602_Device=CPU_Config=() +2449:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f51b532391477cec9e0af4bafffe72a630e2f9f91265efa4f491d516190fcc1d_Device=CPU_Config=() +2449:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7ab51e173b82572bfb29cac5dfdc326e3689e466c68cf91590dcbdddf1f530de_Device=CPU_Config=() +2447:conformance_Exp/ReadIRTest.Inference/Op=Exp.1_Type=f32_Shape=static_IR=9416264710da7447d7e3bced32d5275e81b03a897ad99eed5291cc94ad77449b_Device=CPU_Config=() +2445:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=f645a2275ff33ad614c801a8f2f262ce1ca95417e0ca59e28d4b87cf3289c00b_Device=CPU_Config=() +2442:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8ec74565f16a2ee1e322b4549ea19aa0b30719787abd90bd957e121705edb268_Device=CPU_Config=() +2440:conformance_LSTMCell/ReadIRTest.Inference/Op=LSTMCell.4_Type=f32_Shape=static_IR=828ac6aeddaaa033842b086b946b507fca3f65a7ea3a9a53bf697da37a889db7_Device=CPU_Config=() +2439:conformance_Erf/ReadIRTest.ImportExport/Op=Erf.1_Type=f32_Shape=static_IR=906676850a62f56935dbd13792be1013db602488f29eb757a546b411699ccdd5_Device=CPU_Config=() +2438:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=2538d525d8f11b9f4961c2a4a8cc36fd27d8b3d97271ef7db4f7eac9732b71f4_Device=CPU_Config=() +2438:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f069cbce6f4c3276869b6d9c4a6c843d7a1e1c9d299e8680218636b04339a9dc_Device=CPU_Config=() +2433:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f36d9467906cadb1202fffaa25f62cacdfb177a962074a358a0eb95cc9b5bfeb_Device=CPU_Config=() +2431:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=e77d1474b4055b15278305f6cf7720f30254a5a4e2f6c101970a226f24e79b94_Device=CPU_Config=() +2430:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f96e0fde526a6672a21a4a485e01f6fd57bab2da7b34ce44915bf354198dc6ff_Device=CPU_Config=() +2426:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=a449aa561efb222cad1a414ee87443f9fec0e5c2f6220f6a57b6705c9ef26cd6_Device=CPU_Config=() +2425:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=662ca1fd253f0a0c29b89eb1310ea5c7c87895533130ca1a8b76f791ef1ad99b_Device=CPU_Config=() +2423:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2e586703f4f8e9285249881d509a2a0b96d4758be5f97d75e7ee4f78951c58e9_Device=CPU_Config=() +2418:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=034fadbf9527892e159709c266c12c4863ba0f7bc559f4248afc517f3c2c6938_Device=CPU_Config=() +2417:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4bbbaf50403494d1f876609b605bfc1382aeb9a1a27d2562083a8bfbe76ffae9_Device=CPU_Config=() +2416:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=885f5721f6c3a7f1335325c7638a8934b00b9ac9d0eedd9e9ccdf25514bf0b2c_Device=CPU_Config=() +2415:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=4c3b0cda20bf6b3c574eaefbce21b9b2b0ed92fa1b37c32af252b111b6466d0e_Device=CPU_Config=() +2414:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=29a633b64671e28103c44b79ec5c329118c0d7c4f70466ad44482116aa2a3b6c_Device=CPU_Config=() +2412:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bba92f0e1fe2ee647564aec64223ab2c5b32d3defae9bad5daa5a24df76aac48_Device=CPU_Config=() +2411:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=6e1207753b08d53b18c551ad07a245243197370051be78218db028f3d3b835a5_Device=CPU_Config=() +2409:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=68c6351cbee22a4783b3c592f69eea3778c17594c48972d5d0d1e9d728f5b47e_Device=CPU_Config=() +2407:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c18f4f45c8ca59e5fcf1d2aa0b6115c7fb6789c4d4a583cf93901e65f4ac692c_Device=CPU_Config=() +2406:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7effebd346cedea6e1196e31b73459e7dc818b4cec52eec6ef54e4812b9c221e_Device=CPU_Config=() +2405:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ab537310012dac035760906bcdd57eecbe645735b70c27eb4ac4c220b37a3147_Device=CPU_Config=() +2400:conformance_Equal/ReadIRTest.Inference/Op=Equal.1_Type=boolean_Shape=static_IR=9e166ed18be64949ce2451a1dc981381040fb109ee60e13a7f47308caac73e24_Device=CPU_Config=() +2395:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=b31dbb99720fd5083e5a7e5b1b626bda91455999e2918eb8e658992cfa6588dc_Device=CPU_Config=() +2392:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=471485ec09e972e7745979a8e3bdee0033b9a2615467df9fad360a82176d4d43_Device=CPU_Config=() +2392:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f2cfa9a58f5df299d524eaef020985f4a1e9e936f39afb25b2c201c4f449e8ec_Device=CPU_Config=() +2391:conformance_LSTMSequence/ReadIRTest.ImportExport/Op=LSTMSequence.5_Type=f32_Shape=static_IR=1f24aeeef6f9f91272546fca89299c1ce448b0008fe43905db434ae3f28a75d0_Device=CPU_Config=() +2388:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f13ce39b60cc25991465a0c02e27edcb35af0523cd28004adf6fd9acd8a5fcb8_Device=CPU_Config=() +2385:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=e020cc29b6ec76cfac0e0b52ed3024458fbeb567c4fe9932eb5257e3ade79b95_Device=CPU_Config=() +2380:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=f6f85e9282e58756d40411508d6edaacc75c0f4e64d4e25021ade07ba17bd8ce_Device=CPU_Config=() +2376:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=b39441c49977534ef3b2d1c4a9d7a5a0aedd66c7ba0a6e1be3446151a8e18317_Device=CPU_Config=() +2372:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=25f55a7cb5f72689bff67eb95af15c64b31c2d29bcde97611e74917fa6724ff3_Device=CPU_Config=() +2371:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=() +2371:conformance_HSwish/ReadIRTest.QueryModel/Op=HSwish.4_Type=f32_Shape=static_IR=1c38a17a13c5c03cfc1eeb147ca2474debea05ae1d6f2357ce40ce23552286fa_Device=CPU_Config=() +2368:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=78525afb2b8be0393b6e50e63464ba4487417fc3634641b055f4878f340fe594_Device=CPU_Config=() +2365:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=28cabba0fd0acde452552a362925344e8cd8c5af033419d83041bf26b1d14d69_Device=CPU_Config=() +2365:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f0472c0e5ff8fb82651424269bd9f77e73eff6c43c70b6192f07303c0d35db8e_Device=CPU_Config=() +2363:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ec42345583e635cc0f51b20699c340baced5816bd7ea62856d8b3f7e21a164cd_Device=CPU_Config=() +2353:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=() +2353:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=72c58b462f61521af4eab9c890e568b5676c7a3194c4e35f8e04f98596013c47_Device=CPU_Config=() +2352:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=() +2350:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=621c7638006b03b7c4ca5de04ae4823584c9c348cc40eca0076b898b72247e48_Device=CPU_Config=() +2349:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=() +2345:conformance_HSwish/ReadIRTest.ImportExport/Op=HSwish.4_Type=f32_Shape=static_IR=98546b7eda390c30f82053a093b5e3855c6dc8c631451b3637eadf95858af2bb_Device=CPU_Config=() +2344:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c6cb68df4177a7385019521efa21e7d2722be7b0ec0462d93f3caf9d20fdf2bd_Device=CPU_Config=() +2344:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=29c89ebfa45163b40be304d7bfc96f3068cd96175db94e6ebda942d3c4af538f_Device=CPU_Config=() +2344:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=622add2dcd72d2e1560e983ef4aad56fd35b48b71964ea8204137026f445d37d_Device=CPU_Config=() +2343:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4e9ae0418fb4f362c008ec90ef89001ecb8d13900c970d3ce051489c69305995_Device=CPU_Config=() +2339:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=77be82cc74d0c8e20faea172f9d02c00030bbb8c33d8fae5b07e8b5e5f93af58_Device=CPU_Config=() +2336:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=() +2335:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bbb0129fbafd6d1874ccef37a1bb60379733012c502d58326dae70f413e387f2_Device=CPU_Config=() +2332:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2bdfd42ec67d330dec8ea2817499b4c2d32a3d91deccede902acba057b050c49_Device=CPU_Config=() +2331:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=() +2330:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d9b9fc6875f06b7dc454279fc5fa4432f514736cfd1a35d2a40cfc82f680c009_Device=CPU_Config=() +2329:conformance_HSwish/ReadIRTest.ImportExport/Op=HSwish.4_Type=f32_Shape=static_IR=ce108d9befa5ee87b0161e969c5ac986c176e468ecae9f66895cdc4fc6bad940_Device=CPU_Config=() +2328:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=6838901bafb44e26f73134e2c0eb2be8f1f777ab794ae340d61b62d891ff3d59_Device=CPU_Config=() +2327:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=14f550bd7e83223ffbf501918141376e6a144484865f03c9768fe9da49a9f06f_Device=CPU_Config=() +2326:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=() +2326:conformance_ConvolutionBackpropData/ReadIRTest.Inference/Op=ConvolutionBackpropData.1_Type=f32_Shape=dynamic_IR=791be312b2af6da6abd2eadadc6185c7052271efbcf314bb678828313fc58414_Device=CPU_Config=() +2322:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4a80814933ec1c6198745b1caa4d5b7c9171395b6d8a53cd791dcdf64fa6c91b_Device=CPU_Config=() +2321:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=58cd9ea3d8db317b6ff7fca55bebcbc6846aebdbe309b1b621f5535b18a70320_Device=CPU_Config=() +2320:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b3cb0ba09807204990d7e1635ef35fc96aa10330de2ffefd95f6483e68dca532_Device=CPU_Config=() +2318:conformance_IDFT/ReadIRTest.ImportExport/Op=IDFT.7_Type=f32_Shape=static_IR=cf47311b142dabf10271ebf5c2e359455d9bcea82d95ad2a1a2d58915c77bb16_Device=CPU_Config=() +2316:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=628975e7be92df698e381e47cb5e28f3f09bfc1d19c7d0e434e538743e50f53b_Device=CPU_Config=() +2316:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f6f3c6d199a224ee983f6905aa4f72ea4138e6076d7307c72588dda0cc9c6ed1_Device=CPU_Config=() +2313:conformance_Exp/ReadIRTest.Inference/Op=Exp.1_Type=f32_Shape=static_IR=67632b67a0834136cf2f3bcd6b3fbaf0d2f2bbffc1da6c33fd5fce0d0b8a763c_Device=CPU_Config=() +2306:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=f76da5edfb7a9e3fa7cec034fa43307bce74eeb0629176ae5dd40d154baf858f_Device=CPU_Config=() +2301:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=4c3b0cda20bf6b3c574eaefbce21b9b2b0ed92fa1b37c32af252b111b6466d0e_Device=CPU_Config=() +2292:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=08a156f89c28d3860b50a10fc3402ee84818806257b897f68135fe177ad1f3c1_Device=CPU_Config=() +2291:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=12c56cc6ebb22e8e31d97e0ef640fecab5f93e5c5b2810c4dde56b09a7ac7f48_Device=CPU_Config=() +2286:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f7271aaaa48555bb6e77b1b22aff8e1507d5a3fd2bff3581d3b6c5c18b6b4963_Device=CPU_Config=() +2277:conformance_GroupNormalization/ReadIRTest.ImportExport/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=() +2276:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=12c56cc6ebb22e8e31d97e0ef640fecab5f93e5c5b2810c4dde56b09a7ac7f48_Device=CPU_Config=() +2273:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=() +2271:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=ba4f511cc4a0870c64cc5027fa39b2bf91a6e7f39ea36cd43a693eb59de6d836_Device=CPU_Config=() +2270:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8b55c14423b60f30029c68c603417fb98119c5922e2827c60c99edc05ea813e1_Device=CPU_Config=() +2266:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1891282a9bf460336bad3c354519aa0d87ba6ef40876d4a07592194d2d678e25_Device=CPU_Config=() +2265:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=476785aa2a9596b31a395347e49b62161f2aa9c33db10c64337eebc3892cfd61_Device=CPU_Config=() +2264:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=469a63c5aee73bdefc9abdf8abd8413713c0b68cc098d16c193399a11c7093c5_Device=CPU_Config=() +2262:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=d066432a0ddac020441582a98f139d063cf5f4e9f34deaa0be5ab9b9f048aa0b_Device=CPU_Config=() +2257:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5bb330e06cd9ca29e3e19f09ba0c9f129025899cbf69af96fffbd58bf1f55ab3_Device=CPU_Config=() +2257:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d99c03088bad009d9be7f29ec5bad7e3b6c7534fe2649f9670b6f713bf017e7e_Device=CPU_Config=() +2253:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=be9d62b38b487f1687abc68e6955b012b030507b9918b4cc95dafcdf403a2b45_Device=CPU_Config=() +2252:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=a7b79789ba2466daa67ce8610753fbd89a2ca372d65e2326802c24cce03f795f_Device=CPU_Config=() +2249:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a99922ad73b3ea50f32af50b856d393aeae4b3afe901a2af8fee5aeedec9e9c7_Device=CPU_Config=() +2246:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ef7c3b91bb41e1db1727794a0435bfa5f38d194b9457d94abf9c19776174ef60_Device=CPU_Config=() +2243:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=() +2243:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bc2b8069a8ae60098e1f1a1fc54f8ca873fb1a5d261acf47ae12ad6ea4bb34d5_Device=CPU_Config=() +2242:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=52f24d64817b922e55c19c85c0d727ec6fdb9cb104f55697330334d1517f0621_Device=CPU_Config=() +2239:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bed7c11a4d039608b3ff58fd136cb1d3dc8438441a37829913b63da7c1c657df_Device=CPU_Config=() +2237:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=4e6db028c1ff414e411bc09accf3b7c20cf81e530c903e14586eaad4c21fa111_Device=CPU_Config=() +2235:conformance_GroupNormalization/ReadIRTest.ImportExport/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=() +2235:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=45d3d98caee5b2666b6f411fa9d42c7d9655fa2baee63c43640bccd7bc472469_Device=CPU_Config=() +2234:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=() +2230:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2076165a2a28f14ff923bf8c44250bc59536d2ffb67b4a4785f480df49c1a243_Device=CPU_Config=() +2226:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=75aed7fbb8f7d7e8a1281d4a16c4fe2e55160dfb9e6a1bc446913a223c5aa0de_Device=CPU_Config=() +2226:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a7b2c196b6ae12252522b2571af40b540eae94513bfbd88e15708fee816869f8_Device=CPU_Config=() +2225:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=12634194f9e192663deb30a2a1af450542d8cb78f1dcbe1f42a169588810636c_Device=CPU_Config=() +2224:conformance_Equal/ReadIRTest.ImportExport/Op=Equal.1_Type=boolean_Shape=static_IR=9e166ed18be64949ce2451a1dc981381040fb109ee60e13a7f47308caac73e24_Device=CPU_Config=() +2223:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=() +2222:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=e77d1474b4055b15278305f6cf7720f30254a5a4e2f6c101970a226f24e79b94_Device=CPU_Config=() +2217:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=634db7c7a580a605f3375f671b3bcb2a1baf5856b32032d2786a5f8061df63c3_Device=CPU_Config=() +2217:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=74139581d469ae7aae17953be58de64b2c8b887b3b7dcf492edb748773a1788b_Device=CPU_Config=() +2216:conformance_Erf/ReadIRTest.QueryModel/Op=Erf.1_Type=f32_Shape=static_IR=906676850a62f56935dbd13792be1013db602488f29eb757a546b411699ccdd5_Device=CPU_Config=() +2216:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e8c2981885674129fedb6fc6a376f3fd3db7bf6f9867ee8a3f4e5aede63ee168_Device=CPU_Config=() +2213:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=ac87d885a27bfd348d3f9fad5a03680b73b7198fad17dfdf08675e6e3d239ca3_Device=CPU_Config=() +2210:conformance_If/ReadIRTest.QueryModel/Op=If.8_Type=f32_Shape=static_IR=e178ca7afdd75b09f1ee18e50afd30eed0740497637863c3397b5a75c0f8bfd5_Device=CPU_Config=() +2209:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=27770ad19af38d01d0238b726d4dd5c3cd32ac743c3b55d186f966658a53f8e5_Device=CPU_Config=() +2209:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=29a633b64671e28103c44b79ec5c329118c0d7c4f70466ad44482116aa2a3b6c_Device=CPU_Config=() +2206:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i32_Shape=static_IR=61760c9c95110bf88cbfb8aa09378cc214d4cbbbd6c39c98feec1dcfbb7d47fb_Device=CPU_Config=() +2205:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1efc6b30d556ce23e43b764ed129522616973e621c0cddb33de66568cc74ffbf_Device=CPU_Config=() +2204:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=3d24c272ca88d4ee24f437a310abc05340e110f8596beb6a1ef96dd18818ebbe_Device=CPU_Config=() +2203:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=22dc864b06ef0c7deb8aecd74a26c7bcf75eee316288284413fb61381d79425f_Device=CPU_Config=() +2203:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=593116ea16692c8f5a8994c0562c47e1c627f9088c519b752a635a7d91973085_Device=CPU_Config=() +2201:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e5249d5630503351688090f1a9d0143b02e750045924aee8f9003072446583f4_Device=CPU_Config=() +2201:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2386bb6412e51aa72e9426e12f9f2b2646e7074413b33fff8d95dde141ee12fc_Device=CPU_Config=() +2200:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=57921f181e48af2b294b923633e457650e5ab2a9ac7f5d4d07930974ad5e03e1_Device=CPU_Config=() +2200:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f2cfa9a58f5df299d524eaef020985f4a1e9e936f39afb25b2c201c4f449e8ec_Device=CPU_Config=() +2199:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9ba199e71a3ff06e6bd330e453a1e1103599902893fc267c60da9ae47575a8a0_Device=CPU_Config=() +2197:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ba5382529d458077147b1f822dae04bb7c6d0634adfa0d1e7a111b5b816ad3f3_Device=CPU_Config=() +2197:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eace26dff7f6f0403126e78a4c93920ee5e54a721cd580b4b18c2c9989baef86_Device=CPU_Config=() +2196:conformance_If/ReadIRTest.ImportExport/Op=If.8_Type=f32_Shape=static_IR=e178ca7afdd75b09f1ee18e50afd30eed0740497637863c3397b5a75c0f8bfd5_Device=CPU_Config=() +2194:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0534fdfa97228a6aacf4ed196a9ace8e09d8e4decdcce058176b0312500b6c07_Device=CPU_Config=() +2193:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=81c2956d325aab4a7bfd931d94151e1285083a15326e0890f861b97017a24bb9_Device=CPU_Config=() +2190:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=10c7f4dedd3c5395744a95834799d05f2b2e014e2acff9ee97ed1fcf6e7100a6_Device=CPU_Config=() +2187:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=64e95307077995f1ccc314b1cfb2254a18895371b5ebe71b521523cb42e456d3_Device=CPU_Config=() +2187:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=234277ecce31161bea52cf4aa2a37aa8cd43f1bbeed281a79a6aa1d07368872c_Device=CPU_Config=() +2185:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=9031b1919c35a9df591ff64fbe4748c02cc837649899099542716f35b5c68cc5_Device=CPU_Config=() +2182:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5dd2854a965fe5894fa2a05ada313f1d7b1a1bf82873873fd1ebd3f8eb812941_Device=CPU_Config=() +2181:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9ce6a2f4787ef120c486a68cc02bacb95d6cb1c4cdb5e2054275cde409a39803_Device=CPU_Config=() +2181:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a8621125339b6631e3531d8e34fd54da8bad6a93020ae127b8da46f72e07bf3a_Device=CPU_Config=() +2179:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0dea457d449893579a3278173eb21eebf0a0cbda95ef159ec186453c4fbb597b_Device=CPU_Config=() +2174:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=5c5e10f28ed3a8d4ee0d3c8af982df5f383a4a1a713baba556dd17ee52e9ef32_Device=CPU_Config=() +2173:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=0138363d3baa37869a3e55e1b059a42a87612507ba318e753361a58549ed5ec1_Device=CPU_Config=() +2171:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=471485ec09e972e7745979a8e3bdee0033b9a2615467df9fad360a82176d4d43_Device=CPU_Config=() +2171:conformance_HSwish/ReadIRTest.QueryModel/Op=HSwish.4_Type=f32_Shape=static_IR=ce108d9befa5ee87b0161e969c5ac986c176e468ecae9f66895cdc4fc6bad940_Device=CPU_Config=() +2170:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7fc4d09be462fbd17d4bdccc5c6c7014dad92f58c8999c7e78b7475bbc076bd0_Device=CPU_Config=() +2170:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=b371481349b8d7897f8b234c64177dad6abc66375bddf4c32c09738dee193184_Device=CPU_Config=() +2169:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=2fda32f5fe8957d151306845ffd0f877b2efad70f7bd4921fab2fd770d78c2a8_Device=CPU_Config=() +2166:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a3370e3b46f385ea6e46137d49d5f1b4158fe08d0a3e9feb47a162f6b3640951_Device=CPU_Config=() +2164:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=28bb0064e4cb56c497227ec69899b08dc09cccbf7d390555416aff617a393f81_Device=CPU_Config=() +2161:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=12b6ad1cd462f676c9add533f2fb2a5d98698e72fc5d0e6dc984abb27f54475d_Device=CPU_Config=() +2160:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=577ff3f9c8d226d1899056073c0223ae2d81dcc940c5fef8b9ce9cf63931e9e2_Device=CPU_Config=() +2159:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=() +2159:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a4772901ff77541ae624f89db89901c7d5a502a0dc5d1e0dc21eb8e08c599525_Device=CPU_Config=() +2158:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f9b090cbcb19663630a1490fe18357b752e430ad793c0e3aaabedcb74ab64934_Device=CPU_Config=() +2157:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c9f0deaa217fa8ad54eb9662bb6d181f7b578008b5c8ff445db32b60ec61b185_Device=CPU_Config=() +2157:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=172f158b0f845ffe5adc879bc825ab5f9d904bef2150cd9cfcb663e090fbc828_Device=CPU_Config=() +2157:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fa169b001a47d2c4cfe07d837ca82977192701fb3f1f557e0c792675f00f8158_Device=CPU_Config=() +2156:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8e41f166e0543ab380f90b0ea86819136cd0a5cf5e8ae0cfca988e81c93ce28c_Device=CPU_Config=() +2155:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3cc5aa461509250629415c061c909228cfe34e8f773b88badde597ee264be865_Device=CPU_Config=() +2154:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b02504c94d7d221fab11078480e29529880bcc09c5bc769c60016e53d0c8529b_Device=CPU_Config=() +2153:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=d05c1b7fcf976117a23e0284998d9ce21689411ff24530175787f1512ca25879_Device=CPU_Config=() +2153:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0da39d97a2f46fcbdf524727d0283243d3bf0c3fab75f76f529b6480c84f67c1_Device=CPU_Config=() +2151:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0cb77146d653391361407152c1320db480d5f737d2918eac934c5ffd371cbaeb_Device=CPU_Config=() +2148:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=() +2146:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=edb315ef0796a043a072730952495a3c1a4e080553efbbef8cde28d14d79ead3_Device=CPU_Config=() +2145:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=boolean_Shape=static_IR=6d34694c9c8e71415be894a80a8ededc6a83657c6e7ce3aaf66dcd6f9ab99226_Device=CPU_Config=() +2143:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1efc6b30d556ce23e43b764ed129522616973e621c0cddb33de66568cc74ffbf_Device=CPU_Config=() +2143:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=299e5f0fc159bf294093a5e1f258f7083fc54a08cbaa3a55b2a2197d29ae780c_Device=CPU_Config=() +2134:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=6c1aeced5aaaecd99f3917a0f38e01902dbe81614ae4dc9a99fc09a379990abc_Device=CPU_Config=() +2130:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=df5481436d81f1468146368ea1fae8d5b80f392bcda640243119a3e639f2b92b_Device=CPU_Config=() +2127:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3209c1cce78c7b856203c0a5676f6fad4d098a3146c7305ee3c0471b3be2e3d5_Device=CPU_Config=() +2123:conformance_FloorMod/ReadIRTest.ImportExport/Op=FloorMod.1_Type=i32_Shape=static_IR=2d09fd84ef3e176a2eae04f1066929ceb3973045b87989e5f0f11b97cab6cc7c_Device=CPU_Config=() +2120:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e5249d5630503351688090f1a9d0143b02e750045924aee8f9003072446583f4_Device=CPU_Config=() +2119:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=256f1706e3c9255a819cce8f22bcf8f6e6bc01e752443461711dd28d5a51946d_Device=CPU_Config=() +2119:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=66a4d902b67742a95e2d41d79b9d2434e57a55c168a88049624a0ccb62df9ca2_Device=CPU_Config=() +2118:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=262ab76d80fd9b35be837e391c9bf6c54e3d9124d25dead135ec19b75b1777be_Device=CPU_Config=() +2117:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=33d8f6d258ae8dfd09b8e6fd39f0e74384eabfb685e0e72a3c798101ea56a1d2_Device=CPU_Config=() +2115:conformance_Floor/ReadIRTest.ImportExport/Op=Floor.1_Type=f32_Shape=static_IR=b064511ab38a9a70b4d203e11a12b990f388a03550ba98c65468be1b85c68fda_Device=CPU_Config=() +2112:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=13b2245278f237db23d5f5cea6e9c464521180559df4059ba49d98669f5227c4_Device=CPU_Config=() +2107:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e7e10785757d3131ebc375ebfd83c556e2c34a72be20965d9dd3e4f24a5ee2f9_Device=CPU_Config=() +2106:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=1366ff72dd5b68a3faf25de8f98e4ac5500663b1aac4941af11532ea2ee769d3_Device=CPU_Config=() +2105:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9e83fbe4b350e0cdf8db8795ba31169b98503108dc45a266c88b734a4f54b3f2_Device=CPU_Config=() +2104:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3464734e2c2dccab82635831d42ab5bfbc954764434eb48f4ad92b46ec26dc46_Device=CPU_Config=() +2100:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=f32_Shape=static_IR=dbc3b2f724614a68d750ae4adfd7d8239c77ced05d30f89deabe272f104a5e75_Device=CPU_Config=() +2100:conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=48256cdbf5a3d19f0b7bb6b0540cbd664a36885a88fa8f5f56da7057de97a608_Device=CPU_Config=() +2097:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a3cc82aecdd732c09bc7a321192c2332367048da54243515649dbf72ad7a4986_Device=CPU_Config=() +2097:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=e77dc4aecdbd4ab3d67fc3c1d9e350a9d259af1d4c0188d680121a31c6ed8ccf_Device=CPU_Config=() +2094:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=97181a6433949eaef7277fdfec4f8f94b27463ee3ed4a6aefc678fdaf7eab4db_Device=CPU_Config=() +2091:conformance_HSwish/ReadIRTest.Inference/Op=HSwish.4_Type=f32_Shape=static_IR=ce108d9befa5ee87b0161e969c5ac986c176e468ecae9f66895cdc4fc6bad940_Device=CPU_Config=() +2091:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=176c218db11ea18f367fdf98a3de14e9a9c65152bbcc39783c38772b37f6e9c2_Device=CPU_Config=() +2085:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=() +2085:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=adee3d4d6728b17fb5ab17a9915c5b7c8808f949ad358e8a16a0bb12dad7c958_Device=CPU_Config=() +2081:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4104a7840dc96c214be896cac75911b70baebb902a42a26f12b281bc2cd87318_Device=CPU_Config=() +2078:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=214e4e8f7de64e9cc8c77c67d214172905cfb4b9fde65e2ef3d32bb7b4ed93f1_Device=CPU_Config=() +2074:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=d575b00d2b6e155319fe7120133d8e0c3dcb5c79bda710b0650fa48543dc5c84_Device=CPU_Config=() +2073:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=dynamic_IR=2af646407076eafcc1ed2d628158fc32eac4ef2fb34fb967962c06f81376d61c_Device=CPU_Config=() +2070:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=643e31750b57de573073bcda3bb324ecb87332a72f1c89af378213de24f5241d_Device=CPU_Config=() +2070:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fb9febc1b0984c7d6887460d058a75a9444bd1ade793c5b945c9b79ad2c63e46_Device=CPU_Config=() +2068:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=() +2068:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=e020cc29b6ec76cfac0e0b52ed3024458fbeb567c4fe9932eb5257e3ade79b95_Device=CPU_Config=() +2068:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=978c328422e3866322f3bdd52955690a47a1fdd47ddb9db66a4707b36a535dbf_Device=CPU_Config=() +2067:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=136768c6c28210cc47eacf6667103eac8106e3f255618e067d351cb700e62cbf_Device=CPU_Config=() +2067:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=2737751bcc195e4aaa63ab6d86d803741817287d78fc864e18a31c328078940d_Device=CPU_Config=() +2066:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=f6f85e9282e58756d40411508d6edaacc75c0f4e64d4e25021ade07ba17bd8ce_Device=CPU_Config=() +2065:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=d507892556310f7fe85cbf9245ddf040b219ec8cfe9c779809180a011caab9d6_Device=CPU_Config=() +2064:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=f5d3b4ec51e032e4df5dae00ecba1a3198c29cba96c72b8c89126c4638b715d3_Device=CPU_Config=() +2062:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8d8b631421fa4d1ab70cc2916563550c0823dcb04267b3c50b23f3f245e45d98_Device=CPU_Config=() +2059:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=65a49a4d063513732033e2f838b45c3c176217b8f801ecb9357c99a35022587b_Device=CPU_Config=() +2059:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=() +2058:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cbff70cde6194997d0bb4a7fe099d60116085fa72b8840e54f79ac61a5b4c1a7_Device=CPU_Config=() +2058:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=i64_Shape=static_IR=7adee81cf21b942334c25378325f61e13e9ee3ac95ae004d4d9efceaab6c0949_Device=CPU_Config=() +2057:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=dynamic_IR=8b79cf070ed44bdefd5afbe86a81199e189fa486c42190795419dbfc7cc26d6b_Device=CPU_Config=() +2057:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=ac87d885a27bfd348d3f9fad5a03680b73b7198fad17dfdf08675e6e3d239ca3_Device=CPU_Config=() +2055:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6fefc3626ba6ef60433d3635bd5abeb3e7025277a86e2fd9d92234ff099c303e_Device=CPU_Config=() +2055:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=966eae58d5c103f24a598a5143d7b3a3c40a12fa2606a65431f0d1aef855cd32_Device=CPU_Config=() +2054:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=282e24ea7ef9130becb8db8f0251c907b02a534119d08162e07091212d67f290_Device=CPU_Config=() +2054:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f780e2914ea358c4b9c3775e3d4876ddea5efb96ee43545cae2592db34bc9d54_Device=CPU_Config=() +2053:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=b61800abac107b248c29df7ba04a73c91d490782b1da46164c1b7d2f8cec3cdf_Device=CPU_Config=() +2052:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=680b155374ac22f8d01e47a3b26f133a20842702d07dbb2d0fe2d1c03333afcf_Device=CPU_Config=() +2052:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=99a80c495a8fb4626995167a3ad2efa0efed7696459f6219125414a2bd20dfc5_Device=CPU_Config=() +2050:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ce4296dacb13a0d940afd8bd71b9ae0289d446455f3482af3667d22ee70e91d8_Device=CPU_Config=() +2050:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5beb9762188e985c9554ffb0a05fdc1608fb7d970baacebbbd7118186a324617_Device=CPU_Config=() +2049:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=461dc8aa282946831fdc86d1c024a273ac0f29f5ad615cd55b879feea6d23007_Device=CPU_Config=() +2049:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=60a41e3bf293fc0a0556993a8e0d339e47f85bda8e98f726367cc6eda681994d_Device=CPU_Config=() +2048:conformance_Erf/ReadIRTest.ImportExport/Op=Erf.1_Type=f32_Shape=static_IR=2e5aed1612da0f720adb051e22460983a3911c38cb09184d812ceb949870f450_Device=CPU_Config=() +2048:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3a3886301663fd20cf2c8c0f74c11d80dfe8b74ac39e41652f0eac1ec9bfa2df_Device=CPU_Config=() +2046:conformance_Equal/ReadIRTest.ImportExport/Op=Equal.1_Type=boolean_Shape=static_IR=857447d7e14c7516667094409cf5ef351000344fe170570671be0f71834d04f9_Device=CPU_Config=() +2045:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1f1ec212e843ba389ab363fc4d7b5a1056b8c5e82147d38f6c151cb31538aaa5_Device=CPU_Config=() +2044:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4a483d870c0607c1102f09322af7a7ca052532a9f6fcf698a66d282c0ea2f278_Device=CPU_Config=() +2044:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5f18fb02adfd683f379dd5a15d38f01cf744e6940754f6a40e2646a1d9c97be8_Device=CPU_Config=() +2044:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=476785aa2a9596b31a395347e49b62161f2aa9c33db10c64337eebc3892cfd61_Device=CPU_Config=() +2040:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=() +2039:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=ace54c326bc8255cd741eec12762e4d8f645fe93d50c037effce893745f8fdb5_Device=CPU_Config=() +2037:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5bdc625498840e88bafb7d6f58ae8f9f0081a9bd0a6cd71c72a35871ca5b1f12_Device=CPU_Config=() +2036:conformance_HSigmoid/ReadIRTest.Inference/Op=HSigmoid.5_Type=f32_Shape=static_IR=4a55e1cc1410675b7789f083f2cd3f6ff851f49c8a0818f5bf0dd27280b197f9_Device=CPU_Config=() +2035:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=5176d95c14be776a4247f25a469708ba7976378b7aa8860a115a28a8bf2c2902_Device=CPU_Config=() +2034:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1fb809952e397a442265bf095e12fff4e88e0e349323813dc40b74aa2fa84924_Device=CPU_Config=() +2033:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ee1f9348ff09a058dc09cd63581663590521d463d14b785a23ccd3cd28110b5b_Device=CPU_Config=() +2032:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=d5f5f2d39bfe4ccc6f12f76e5eca8e2e40ac7ac6c5f38a7cac21970df213d4cc_Device=CPU_Config=() +2030:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=a58fb7847e59bb119656b143af0c6f65e29f8211034fe7aab03666cdb95d7fe1_Device=CPU_Config=() +2030:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dc9060efbe22735c22c69f0323c7e6a77a30cfbaae7b79670b9b26fb2be70_Device=CPU_Config=() +2030:conformance_Floor/ReadIRTest.Inference/Op=Floor.1_Type=f32_Shape=static_IR=b064511ab38a9a70b4d203e11a12b990f388a03550ba98c65468be1b85c68fda_Device=CPU_Config=() +2030:conformance_Erf/ReadIRTest.QueryModel/Op=Erf.1_Type=f32_Shape=dynamic_IR=e6f95710a782b6c7df8397480e5cffbfa773fdf4ef11c93b2b1ac4694313b080_Device=CPU_Config=() +2029:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b9fd9b0043cef8aac8d0cc2e517a3e245eada8fedb7409911cd2867e7ba85ce_Device=CPU_Config=() +2029:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=fe615eeceb735b046b190d844931c56223d45439021da3b6b23227a1f9cb73c7_Device=CPU_Config=() +2029:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43f7d483e462a7714f4607ca0e71b7e7ce0210d3e90c9e6346bba3cb0b25f2ad_Device=CPU_Config=() +2027:conformance_HSigmoid/ReadIRTest.QueryModel/Op=HSigmoid.5_Type=f32_Shape=static_IR=85df90c3ae7b84d89ec4eae30556ebf4af996c318afa45d90dbb219f73033f31_Device=CPU_Config=() +2025:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=9c1e1b695646ea4f56a87b7e5a815c12856f718920e01e86ed78f2dcaf896a37_Device=CPU_Config=() +2024:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2e1857ca8967deccb2baea1810c6931a1b19fc0e963dfaf3ca3ca4fb4e433657_Device=CPU_Config=() +2024:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=cd2470c72fa7d2238d2eca4d067e49a02340ad187681be2fa7e0bac6eab3500b_Device=CPU_Config=() +2024:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=i64_Shape=static_IR=e8fc48c9bceee1462572c6aa8c5afbda94a9d6e8760deea1c9a3d04d1d797fb5_Device=CPU_Config=() +2023:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=() +2023:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f43df065734a36674b3fdc7a47fddd1cfa5c1b36bf73e7de86a100c645fbc7d3_Device=CPU_Config=() +2022:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.1_Type=f32_Shape=static_IR=f735a44db0a337a22f5ebed052a5718168765287ff4e0eca961c3f9fd68586c0_Device=CPU_Config=() +2020:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f82842bfa510be994f17d9c00d43b6f67b232b3a41c64ae276e243610d927d9_Device=CPU_Config=() +2018:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6b1dbd40d09a340628ec975eb623751a161ab5b7773b190e38272c409d8bb4eb_Device=CPU_Config=() +2018:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e8c5e89b62e32721ef30ee1c8f4b05fe5656003c0b5039afe8ffadd8752668e2_Device=CPU_Config=() +2018:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=12b6ad1cd462f676c9add533f2fb2a5d98698e72fc5d0e6dc984abb27f54475d_Device=CPU_Config=() +2017:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=5aa10dbbcee8d7434796180d5fbe8f0a954b772c441c8d6046439c615d3b9011_Device=CPU_Config=() +2017:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=f6f85e9282e58756d40411508d6edaacc75c0f4e64d4e25021ade07ba17bd8ce_Device=CPU_Config=() +2017:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=246f55d43a6e986a8ba35f711c43dd32cfb1ca097598b0a01690d4765e0d5019_Device=CPU_Config=() +2016:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=67a75007dd4cf8ec6b4c3a09d5f4c6901913f86a6512e9970774543cc03d6e32_Device=CPU_Config=() +2015:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a3291bf5a7a531f88e8705193f436682a60f78a4b6cdae2af49aa82b20cdffd1_Device=CPU_Config=() +2014:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=7cd8ddb895321ccd41cef1f30ab6c09a933366be542b08fd486270c25109012c_Device=CPU_Config=() +2013:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2686f1990d367d705eb27e252bf4185704c592225e83c62e5681d3300e9ded18_Device=CPU_Config=() +2011:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d42498673c5356368f655e549ed67f3f43db8730ba9449670054622d361326f5_Device=CPU_Config=() +2011:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6af32fc288bcbd414ea63525c4345aeda74ab21c44aab5910f85b8b7fb5d1179_Device=CPU_Config=() +2011:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=49b1cfd43b9898a5882e93973e26ee3b149efbf3cb75d9ebe9225c61c87662ea_Device=CPU_Config=() +2010:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=725aaeceedd7eba9be6ba4203e31cead733ed80dbafc33e902465d4338dc8f4c_Device=CPU_Config=() +2007:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1c9d69e1a85d03b8599961a8a1b90af7b3b2d43bc5c4f4a6b8d5da3c22166abd_Device=CPU_Config=() +2005:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a3291bf5a7a531f88e8705193f436682a60f78a4b6cdae2af49aa82b20cdffd1_Device=CPU_Config=() +2004:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=i64_Shape=static_IR=68115f3a18f8ea201078166547e9c2a8587a5bb37646adf6f90da976f7298386_Device=CPU_Config=() +2003:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f688cbb25fde53f41bf758ee6d439eee6feb3e289569b4b0d2db6dad9eb1c75d_Device=CPU_Config=() +2001:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ffd182dd2438f8b3907013ef38c64288a16d6f98a9fd206e6f8e3d2db48a3a73_Device=CPU_Config=() +2001:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=b94d2ed6a2b113922805a69578ec5ba2ba3d8f0ea46ca37f095b4ccc94d76b77_Device=CPU_Config=() +2001:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=5fd7b424cb32653589798a45526ac4b3f3aafd29a58e5ed1cef16a958fd4a859_Device=CPU_Config=() +2000:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=7293f99e38d76387b64632d06503c539c369e1ab78d9388e1af42d7071d8230e_Device=CPU_Config=() +2000:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=a0cee5b220a433f1d76460a1f452bfc26aae12f7b84983a063605b4a8cd0a5d4_Device=CPU_Config=() +1998:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=49245e23b8c1c485428d0e490a687e48c541bfb833eb7838efd8c112736a076d_Device=CPU_Config=() +1998:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=299e5f0fc159bf294093a5e1f258f7083fc54a08cbaa3a55b2a2197d29ae780c_Device=CPU_Config=() +1997:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=() +1997:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0ce1ec496e5d71728fc5daaba87809c5922406a65e85823913381de0d2112e01_Device=CPU_Config=() +1996:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=7b9883414482f3b1108e549a9c47bb8a8aa162d962813c7e99411d000e02690e_Device=CPU_Config=() +1992:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7a0968eb49e54c601398168e34cb61a84c9795b06e60d49f21b96b5d462838f9_Device=CPU_Config=() +1991:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=105ef2497841f48e00c64d60affe13b54275083bbf0fd91837d21a4c7c85a1a5_Device=CPU_Config=() +1991:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=29d3ebfbd6a10a5c74102ea71c9edd316f60c2c7a72c81f554f81416f9296c91_Device=CPU_Config=() +1990:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3c7d4160bf883d550620e8d1ceb54b3d78bf1512388b5ee57e1a380949d441e1_Device=CPU_Config=() +1989:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9e21c0af425c90066d92577a0b8aadb6e9fdee50c197b15eea040b89eb715a6a_Device=CPU_Config=() +1989:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=80f2651dfe68b893f390dc18ef997cf1e234a087d016cdacbbf96a91968cce82_Device=CPU_Config=() +1988:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0cd1ed0a25942b7e306b973035f3bbfbaab0fdd913df064809ff363cadbf91b3_Device=CPU_Config=() +1988:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=109afa0426a29179db58e16917b829096af105f0def2375a589ea1391138ee2f_Device=CPU_Config=() +1987:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=31dea0868f4a13f6a25819e26ae172201cf3d52de718fc200edb84cafe7c2cf9_Device=CPU_Config=() +1987:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=427900d25144ee6b8cd4b35cd53c6e9335375018f6328dd01ae4db304846d991_Device=CPU_Config=() +1986:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=508a961c358d40ddb6906694a24f87dc24f74cb4643aab58ee1d6fa28f099e6b_Device=CPU_Config=() +1986:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=7d3d30fa9e2a8a839cf42249de3eb8228681229e8b302ff7f290cc0d00c10a1a_Device=CPU_Config=() +1986:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=66bf131d73ad3116d698e15ac3c9e48bde66e096228138eb865c0807295c0d4d_Device=CPU_Config=() +1986:conformance_Cos/ReadIRTest.ImportExport/Op=Cos.1_Type=f32_Shape=static_IR=e5379d72e978c773e9be98561b316a64f76c6015608d87739211e7c0e8b7bba3_Device=CPU_Config=() +1985:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=d98330d8f9f03556036d103fb4ca3f8436be42fa4f0b21b185aaad3abb2fb53c_Device=CPU_Config=() +1984:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=28dbc474828462a812108c43a47aa4e70fa0d2e8e814bef5916092f3e8c7a2fd_Device=CPU_Config=() +1983:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4104a7840dc96c214be896cac75911b70baebb902a42a26f12b281bc2cd87318_Device=CPU_Config=() +1982:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=f32_Shape=static_IR=c14da825d470c9141af0ea87eb82edd0866a415cb5ac59f1014c2ded35340201_Device=CPU_Config=() +1981:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9b32e763670e7a29b1ed95659051b94c323b70948e5706a00db44200cd27bad0_Device=CPU_Config=() +1981:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7b9adefd0292959469751e813a48fbcefeab3ff1f4b93329783c1b4c6c14a053_Device=CPU_Config=() +1980:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c2db5dd4ed881038f0521cfb566b3773cda95681a2ef8339950d0515616c015d_Device=CPU_Config=() +1979:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4df4ab698c70278594efe8b4349a4c99c8b2ab7c4ee0182c5a4b7673da922ad6_Device=CPU_Config=() +1977:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=025f133a063248650fab4c898fa6dc245e844e4f0c8eec7603403515fd023164_Device=CPU_Config=() +1977:conformance_HSigmoid/ReadIRTest.Inference/Op=HSigmoid.5_Type=f32_Shape=static_IR=cc18959ba7c26661ba0f986207bd00aca503bf924b31c4a2070ac40ac3ec5468_Device=CPU_Config=() +1976:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0973b76264164ca52a9883a69ff5f7df977e28c33a0dbe9095e7e92acd7854bf_Device=CPU_Config=() +1974:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=d507892556310f7fe85cbf9245ddf040b219ec8cfe9c779809180a011caab9d6_Device=CPU_Config=() +1973:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=cd2470c72fa7d2238d2eca4d067e49a02340ad187681be2fa7e0bac6eab3500b_Device=CPU_Config=() +1972:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2c34b5434230e59b65b5e41e29541c4f1de46e8f76604530fb669b21b7f7aa2_Device=CPU_Config=() +1972:conformance_Sin/ReadIRTest.Inference/Op=Sin.1_Type=f32_Shape=static_IR=54a909996c38d86ec830295e37f0fc0070260101390dbaae2cc6eaabea82a7b5_Device=CPU_Config=() +1972:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=7293f99e38d76387b64632d06503c539c369e1ab78d9388e1af42d7071d8230e_Device=CPU_Config=() +1971:conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() +1971:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=680c8c91d6dfdb198ff304245e6da3089da20f6fc5187b80f279c5d56eb66052_Device=CPU_Config=() +1970:conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=() +1969:conformance_Less/ReadIRTest.Inference/Op=Less.1_Type=boolean_Shape=static_IR=953b15e350d9a27c4d048cbae41a278c732f3b3a6e8debd7fd2e75e99a015966_Device=CPU_Config=() +1968:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=a3370e3b46f385ea6e46137d49d5f1b4158fe08d0a3e9feb47a162f6b3640951_Device=CPU_Config=() +1966:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1c4aa866633b1381ff8ee36910d91aa4750c9a8dbd05ae159b7e15a65a08bad3_Device=CPU_Config=() +1966:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9033954b258cdfa9fa858317ee4588b8c92cc946d7eb305bf130d3ca8ee0f1fe_Device=CPU_Config=() +1965:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e003079e1703f756924619f2a77b6c26741ef71bc404419560faec9c56bbfd2d_Device=CPU_Config=() +1965:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fb5525d36d14f54eebc5670c06232ca4e32cf920d309b5777e37d3377d386433_Device=CPU_Config=() +1962:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i32_Shape=static_IR=61760c9c95110bf88cbfb8aa09378cc214d4cbbbd6c39c98feec1dcfbb7d47fb_Device=CPU_Config=() +1958:conformance_Log/ReadIRTest.ImportExport/Op=Log.1_Type=f32_Shape=static_IR=038bd1e152575a3b8ca28bfe18fdcc9cbf19c9489e7bb831b9d5f56f7499cb7c_Device=CPU_Config=() +1956:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=01f8aa116df449130419891bc3387fa263e1ef80b3113fecd83b06fb933efbaa_Device=CPU_Config=() +1954:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=456012168725798035877b2cd860bbb89121fa41add6f7ab78c03247032077fe_Device=CPU_Config=() +1954:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=fb6a053d244fc1bdea6fd5e69e0c05025272ac0da2f676e077c598239b6493c2_Device=CPU_Config=() +1953:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a5d03dc78d3b89cf1aaee33c609a3d52626d3b98827b980422b01eefc32cde03_Device=CPU_Config=() +1953:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a3cc82aecdd732c09bc7a321192c2332367048da54243515649dbf72ad7a4986_Device=CPU_Config=() +1953:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d13d862f7b8306948676388381950639ef433dcc4e38f5a6fa8d50575d1aa814_Device=CPU_Config=() +1952:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a8705f91d4bf4fe876dfb6d2ac2eb9c89808c88942d4beb080e1e2c089d77040_Device=CPU_Config=() +1951:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6aff57130da7904e5d2300c4962f104d31c704872d5c33bbda4bb38efc34d563_Device=CPU_Config=() +1948:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=427900d25144ee6b8cd4b35cd53c6e9335375018f6328dd01ae4db304846d991_Device=CPU_Config=() +1948:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=bc1a7618e707ddd2c4773d1a2234e6dfb39954ad872abdf38a18d653ec35b26f_Device=CPU_Config=() +1945:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=fb8283ecd8934dfc5340a41e9889a0a760b39869e4873efed4ef85606c162ce7_Device=CPU_Config=() +1945:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b0376bbdfc6560184c2eb15a9cff7fc6d6b39c47dd22936fb64629d345e227d0_Device=CPU_Config=() +1945:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b3e2dec4b768d4a421c0bb36ab5174fc68e4a37655cd7a6f2072e0db9894cd1a_Device=CPU_Config=() +1944:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=3688e2a973219245d05c5fa675cebe9036d40777809ebf583c1bae9b9f87eed6_Device=CPU_Config=() +1943:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fe70e0ee3f24f0bfe4391da7797647a01f66fcb109b481ca859c9f8f7dc7b411_Device=CPU_Config=() +1942:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=682ef97686247c6443214e731915927e131f40c22f1cae7f25a038b70eff95ba_Device=CPU_Config=() +1942:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=ed75de35729f20a3285506937672f78d2d5137851a3043d15f4eafc040768fc8_Device=CPU_Config=() +1940:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=9fa81cf001e6c48dfcf4e75aa77f95b3dce4e8d48b6ec3cfc896dcc08006c62e_Device=CPU_Config=() +1940:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e8c2981885674129fedb6fc6a376f3fd3db7bf6f9867ee8a3f4e5aede63ee168_Device=CPU_Config=() +1939:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bee0968c080b9f9f930b23a2c79d957f1c160c34d994e617ea29a641b0e269c7_Device=CPU_Config=() +1939:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1b166178a448888eb82b8f6f5692ed96ca7fb6e52b5235a5ed50446e60566417_Device=CPU_Config=() +1939:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=0138363d3baa37869a3e55e1b059a42a87612507ba318e753361a58549ed5ec1_Device=CPU_Config=() +1938:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=74ea1727d6d5474136a87786b87f5a9b8923f78ef72d52a0fe9a39dd7d3a293f_Device=CPU_Config=() +1938:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=d9eeac72636735d7541c2d0ef14ebfc7d4a1b3598c08c136a9123b2ed89e13ef_Device=CPU_Config=() +1938:conformance_Equal/ReadIRTest.QueryModel/Op=Equal.1_Type=boolean_Shape=static_IR=857447d7e14c7516667094409cf5ef351000344fe170570671be0f71834d04f9_Device=CPU_Config=() +1937:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ea0fcb3a84306f10c2ff5fd89659a19497da84225280efee670cce6f10755e1a_Device=CPU_Config=() +1936:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=3e669c3f90fc7b2209d3d588932f8eff3827309a5928f4b27722139964e2c46f_Device=CPU_Config=() +1933:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=5fd7b424cb32653589798a45526ac4b3f3aafd29a58e5ed1cef16a958fd4a859_Device=CPU_Config=() +1933:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4af234310183dcbe89f887b3282ac2ef10637d5f5580e128c49958c1b5628db2_Device=CPU_Config=() +1933:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0b4b74693c2ec96e714901b1acc772655accc3b29170cdb64ae934003338b296_Device=CPU_Config=() +1932:conformance_NotEqual/ReadIRTest.Inference/Op=NotEqual.1_Type=boolean_Shape=static_IR=8fe4bce2e674753d81a1516280769a06cdde538e658ae548087e4888ffa2905f_Device=CPU_Config=() +1930:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=3d37166487c5c52af657343f8fa10903efc7d580d5b370a519a0ccfbf6fc56bf_Device=CPU_Config=() +1930:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f0853773e26eae3d051504ed8db7f182c0e90ef7b45625a1a72ac51a73e2208a_Device=CPU_Config=() +1928:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cdc993ef8686eb949184e962d0790c38c26bd864e8d415fe06a86abe3bbcb4e7_Device=CPU_Config=() +1928:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=static_IR=da15c9ddbf446de00565c83e95b8a554d400b8b925481e56eb3df41f7efe26d9_Device=CPU_Config=() +1927:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=b9f9ac285915db9ef3e7437728695f2833d165757ffc81afb88242e7b471f434_Device=CPU_Config=() +1926:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5b2d8d57f3d0914e21b47b7e450d2543ce7b7eee6c3eb3bff7da441b15e20d77_Device=CPU_Config=() +1925:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f36d9467906cadb1202fffaa25f62cacdfb177a962074a358a0eb95cc9b5bfeb_Device=CPU_Config=() +1925:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=e894ea68d25e2a0af6fe2e330929c3305710bd07aca8e099b727df78fb26cdf6_Device=CPU_Config=() +1925:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=18788c5143cb21969863f3984fb8c5c9bb4dbb0a1869f5c8988b52ce779ff465_Device=CPU_Config=() +1922:conformance_LogSoftmax/ReadIRTest.Inference/Op=LogSoftmax.5_Type=f32_Shape=static_IR=38bcc7d745ee21a7c6858a161e269f0281d3f41d62d65d10fde9b0a9b80992c4_Device=CPU_Config=() +1921:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c4ae9be783990e398b3e8f0af76cab50d72c40c705677a3fe1c5dea592952d1e_Device=CPU_Config=() +1921:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8e41f166e0543ab380f90b0ea86819136cd0a5cf5e8ae0cfca988e81c93ce28c_Device=CPU_Config=() +1920:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=431db89311a543581d104e2a2c498fe021da2e4026323817834670bf5bee67a2_Device=CPU_Config=() +1919:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8c4eeec465e40ae0a63a47164cf3ca02e4d9a215ba5340bb1df1a5d165d8894e_Device=CPU_Config=() +1919:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d3ad2d022373c585166c8c4f9897c5bdb655f1b5560f2fb1f1506f7cfdf375e3_Device=CPU_Config=() +1919:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a08cb2499595ed0de5c51e3b0feae24d9d5462d227572e771862564e1875b6ef_Device=CPU_Config=() +1919:conformance_FloorMod/ReadIRTest.QueryModel/Op=FloorMod.1_Type=i32_Shape=static_IR=2d09fd84ef3e176a2eae04f1066929ceb3973045b87989e5f0f11b97cab6cc7c_Device=CPU_Config=() +1918:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e1f0357795d5676c5e4a38b6639cc90c924880ab961eb73e407b5ad0142ac0b4_Device=CPU_Config=() +1917:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ccb19a7166645dd3a896b2f1f731dc87da95f98a8f824e46d434dc12f71e663e_Device=CPU_Config=() +1917:conformance_LogSoftmax/ReadIRTest.QueryModel/Op=LogSoftmax.5_Type=f32_Shape=dynamic_IR=a3f02c85607891ecc34c484b433c6a78333e13f3d8cd231e651f8bec26e7d0ce_Device=CPU_Config=() +1916:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4014e6cbcd000f86268253c54f7543e96897c729508d56ab831ee8a2687669db_Device=CPU_Config=() +1914:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f71810b04667907bc88c4a1ecc28b9325fde04026b5e56b5eb0e2d6608f3742_Device=CPU_Config=() +1913:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b0df2409ae133826dfaa59aa1b4612b6667f034acd2fbfb466b486b67c46df29_Device=CPU_Config=() +1913:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ecdaea0a2e3ff82b4695e13b586aef85eb4bbb0df0cf85b13b006d98095995ff_Device=CPU_Config=() +1911:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=4d10da0860e049587221c12f55c3bca9fc587b74dd3fec194c8ba5854a736d93_Device=CPU_Config=() +1911:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=i32_Shape=static_IR=6650e462a4f0086329d8576eb6352979e89825517f48e264fe719c7c5ca276fc_Device=CPU_Config=() +1909:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4023cad1c8e22f448d84a0d7ed783f00a9914bfe546ad07fc16a88b6fc6be3fa_Device=CPU_Config=() +1909:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=94de295ab12bd6b03bc5de22f9e9c46d5875d111eb942d3ba35f8e2456ece1cd_Device=CPU_Config=() +1907:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=ff96b044b0064dcc13dc7c1d80f2b2cddde0ead8c4501d5d741034833079d47b_Device=CPU_Config=() +1907:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=88c7bd909ddf1935966d1937508ebcbd6e56526c7354bb3a40bd9de52aaec142_Device=CPU_Config=() +1906:conformance_Elu/ReadIRTest.Inference/Op=Elu.1_Type=f32_Shape=static_IR=1cb500b61fe11278cc50fca509be3e7b654190294dd581c7862ea3f108e0c192_Device=CPU_Config=() +1905:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=8b8efa859c54f9cf2200c18953de243d469d2f04bf38ba5f3efe441de23ffe45_Device=CPU_Config=() +1904:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f8eb0c39d812083381ffb5f66921c5eebf3db3f22f6531c7a81346bed8d54369_Device=CPU_Config=() +1903:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a7b2c196b6ae12252522b2571af40b540eae94513bfbd88e15708fee816869f8_Device=CPU_Config=() +1902:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7509cd031f0085ad09a30a02057f1c0dff7ba78cd13f43ac124b33ef2cfd303b_Device=CPU_Config=() +1901:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1d41827cafc0ccd8d9b0d1304c302fffafb52f653dedeed1582a9d8c7b88f173_Device=CPU_Config=() +1901:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4232c8e7fec9c583f6a244b2b7a8bbad618819f7885f8486a1b2a9e3b36c90a7_Device=CPU_Config=() +1901:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=baf2ff4e48e3608f42c5a92cdd7fbd8c4a47fc66e47143e52e4db2f83781ed2a_Device=CPU_Config=() +1899:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d82f645d11f396433cad131e1e490842c14fdb9e439d93fb9425752b6a3aff09_Device=CPU_Config=() +1899:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=43c8e8300f01242788a8cfdc37b48779f51f7ee7aef5b28e8de542320ba86e4e_Device=CPU_Config=() +1899:conformance_Exp/ReadIRTest.QueryModel/Op=Exp.1_Type=f32_Shape=static_IR=9416264710da7447d7e3bced32d5275e81b03a897ad99eed5291cc94ad77449b_Device=CPU_Config=() +1898:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.1_Type=i64_Shape=dynamic_IR=45a9a897d75b175e3d805e74ec09322789564e0c0e8d9535724f262a9f534572_Device=CPU_Config=() +1898:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=ae444aa1dc9d87f1610bbf65710d9a5f9710d680848d08afaf54f526f78b0dc2_Device=CPU_Config=() +1897:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=9f4d316675c933ea5d6511324e3d664440a8ba287cb2ffe768517f9cbfb613e7_Device=CPU_Config=() +1895:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4612ce2abf1348d599a331eac37b14624de5994d6c3481e8765f06d344e6ae6a_Device=CPU_Config=() +1894:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=u8_Shape=dynamic_IR=81bbb9658ad214babb825fa4b576aa83a9ceaae7dc0b878a84e42ea194f3ec13_Device=CPU_Config=() +1894:conformance_Less/ReadIRTest.QueryModel/Op=Less.1_Type=boolean_Shape=static_IR=953b15e350d9a27c4d048cbae41a278c732f3b3a6e8debd7fd2e75e99a015966_Device=CPU_Config=() +1894:conformance_HSwish/ReadIRTest.ImportExport/Op=HSwish.4_Type=f32_Shape=static_IR=1c38a17a13c5c03cfc1eeb147ca2474debea05ae1d6f2357ce40ce23552286fa_Device=CPU_Config=() +1893:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2ab325e62a5a8c5f36571bce678481798f4a5f0a854c92db5e834ea4737077c2_Device=CPU_Config=() +1893:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5816a52b5b342411646884cb88eb68a96df7ef3c3cac57c9057da46be4f5d8eb_Device=CPU_Config=() +1893:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=static_IR=f9377788ac0fd1ad0a7f51d16543722cb5acb69640745df17d9f41f5d1d0b544_Device=CPU_Config=() +1893:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=de9827c3efd198893fd6a26bb5efd6a4aef5451447643a69f085f0b6e605097e_Device=CPU_Config=() +1892:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d73edb68da4aee1c052b79ffce030b368f204c04bffd9a9dc01a9b54de932e7_Device=CPU_Config=() +1890:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0cd1ed0a25942b7e306b973035f3bbfbaab0fdd913df064809ff363cadbf91b3_Device=CPU_Config=() +1889:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f3dcab6635e317bee634addec1b7f9664b2f801810997519ab06efaf1d869f81_Device=CPU_Config=() +1889:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=52f24d64817b922e55c19c85c0d727ec6fdb9cb104f55697330334d1517f0621_Device=CPU_Config=() +1889:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2bb16e2257294e3f7d905f66a483a8210f392ea822836e4edcf8910a7fbb4277_Device=CPU_Config=() +1888:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c97ae95062233f4085689c2f5dfcbd9077c16fdb1bd304e3817b76004d85b00d_Device=CPU_Config=() +1888:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d0c2f7eea6a0d6d6d9d97881c8db3649f9e9b713633c9d5698459eb1d2e28345_Device=CPU_Config=() +1887:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=77be82cc74d0c8e20faea172f9d02c00030bbb8c33d8fae5b07e8b5e5f93af58_Device=CPU_Config=() +1886:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=8e098b9c129ab30efc257d55cfbc737d990d2ff0f7931039d3335c42d5f286eb_Device=CPU_Config=() +1885:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=b4f42a7d1252f2dd02b31ac7b0cf4ffcbd452dbf0e508833e7dc709ee04889c3_Device=CPU_Config=() +1883:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=7625f5af6c70a9d4bccb783dc369a11b53ef1f6492df030ae5404452ea0cdc79_Device=CPU_Config=() +1882:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a7b2c196b6ae12252522b2571af40b540eae94513bfbd88e15708fee816869f8_Device=CPU_Config=() +1882:conformance_FakeQuantize/ReadIRTest.ImportExport/Op=FakeQuantize.1_Type=f32_Shape=static_IR=48256cdbf5a3d19f0b7bb6b0540cbd664a36885a88fa8f5f56da7057de97a608_Device=CPU_Config=() +1882:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=547fea7da34d5e65ad7ea069be003753e9ef281110c80dde11520bc350c4ca14_Device=CPU_Config=() +1881:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=299e5f0fc159bf294093a5e1f258f7083fc54a08cbaa3a55b2a2197d29ae780c_Device=CPU_Config=() +1881:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=554e762f2b3a5d9d335e464c65b1c240a9e92e4f765ac8734c438cb698883c8d_Device=CPU_Config=() +1879:conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=() +1878:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=a3add607f5e37633f3298794f8e32e409e3403666af3c0fc57c7d4427b714eca_Device=CPU_Config=() +1878:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=eee9a6474efc670ba46cde5daab7dac878055d12b3ec02a3dc524ae68572b02b_Device=CPU_Config=() +1877:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=dbabd4c2992053ca70e9d6a489b437cf8d1f13807220adb5054204e9bede00e1_Device=CPU_Config=() +1876:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=() +1873:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=473e9027081a81ec0a25821312bd198c9a5e750a87ef249783bcb2c53b2bcffa_Device=CPU_Config=() +1873:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b02504c94d7d221fab11078480e29529880bcc09c5bc769c60016e53d0c8529b_Device=CPU_Config=() +1872:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=3ade42cfc9d970963d8f162b001075864e6967034198986f408ec09ce4093d18_Device=CPU_Config=() +1871:conformance_HSigmoid/ReadIRTest.QueryModel/Op=HSigmoid.5_Type=f32_Shape=static_IR=4a55e1cc1410675b7789f083f2cd3f6ff851f49c8a0818f5bf0dd27280b197f9_Device=CPU_Config=() +1869:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f5db8eb433e162e42a727e4aa0e176753cc4cd1e07aac8224a7b0f878a0ad5a5_Device=CPU_Config=() +1869:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9ebb1862a5e0db4eff08d84e9e56c76c19cdc07e13e634f008ce5e9d709afe35_Device=CPU_Config=() +1867:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=9031b1919c35a9df591ff64fbe4748c02cc837649899099542716f35b5c68cc5_Device=CPU_Config=() +1866:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=66375ff8539da6387946c19b0d20e6b4fd57da25150255e41282458e241963a0_Device=CPU_Config=() +1863:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=() +1861:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=5d791fd5b82a74a42073567349728035c4ac52ea64c1a154a73bd4e61d1b42dd_Device=CPU_Config=() +1861:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=263843a2c307b91ff7d59d9b21cd8b2126e985d787fc18f44df3525a6bfd71f3_Device=CPU_Config=() +1860:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e32d74280a8000202346421945e400d248efb3d72bb67473f81c7a2eafe86fca_Device=CPU_Config=() +1859:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0031aeefe417dada5913585ba3aaf8d0d79706ce509a7cb72ab3c0e9b638d46f_Device=CPU_Config=() +1859:conformance_Exp/ReadIRTest.QueryModel/Op=Exp.1_Type=f32_Shape=static_IR=67632b67a0834136cf2f3bcd6b3fbaf0d2f2bbffc1da6c33fd5fce0d0b8a763c_Device=CPU_Config=() +1858:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=() +1858:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=39930bd67f003081f138d781076ec2d3571ced21865a9cccc81bd9185c151b39_Device=CPU_Config=() +1858:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=725aaeceedd7eba9be6ba4203e31cead733ed80dbafc33e902465d4338dc8f4c_Device=CPU_Config=() +1857:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=8f7dc81bfce05ce39b694fe48197a4fd2aa7933c7061508be3b9dfefef518f75_Device=CPU_Config=() +1857:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=i64_Shape=static_IR=75c36f65570966e7f975e5c839036e0e13fe30e6d24ce4be8e6a0e8449173951_Device=CPU_Config=() +1856:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=2e38326f5f0527299a0385fc3bb6c85c80e12e5bce07fe530624aba7113e82a6_Device=CPU_Config=() +1856:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=f802331401875cb16be10c9f752520406437b2e63a50e022b7d95b732e5296f2_Device=CPU_Config=() +1856:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0c5ac67592b69e8c2b7acbae7a0f877cfed184c572d2fae09eb8fa629e86eeb1_Device=CPU_Config=() +1855:conformance_Cos/ReadIRTest.Inference/Op=Cos.1_Type=f32_Shape=static_IR=e5379d72e978c773e9be98561b316a64f76c6015608d87739211e7c0e8b7bba3_Device=CPU_Config=() +1854:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=574e53e574b1a6e0bc16a7296aadd78785cac535293e956b008b0a2274b7cb36_Device=CPU_Config=() +1854:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=5aa10dbbcee8d7434796180d5fbe8f0a954b772c441c8d6046439c615d3b9011_Device=CPU_Config=() +1852:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=i32_Shape=static_IR=a142d6fb0ae0c0decec2ebeba376ed65852e1c60b1c1abee7bc574d5ef3a6a3e_Device=CPU_Config=() +1852:conformance_FloorMod/ReadIRTest.Inference/Op=FloorMod.1_Type=i32_Shape=static_IR=2d09fd84ef3e176a2eae04f1066929ceb3973045b87989e5f0f11b97cab6cc7c_Device=CPU_Config=() +1852:conformance_FakeQuantize/ReadIRTest.QueryModel/Op=FakeQuantize.1_Type=f32_Shape=static_IR=48256cdbf5a3d19f0b7bb6b0540cbd664a36885a88fa8f5f56da7057de97a608_Device=CPU_Config=() +1851:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=c55846f7a08af86fb1c914c925433852fd4bc735f671c87e965a6db9b6971708_Device=CPU_Config=() +1850:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0783bb527f80cd61cd46b7bc7ec93ca0cc51ec61792cd0fea8eebfbf121ad5bf_Device=CPU_Config=() +1849:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f6340be757a977d5ab8a7c533a56c520f2babe002ccc1ab2537876dc6083c323_Device=CPU_Config=() +1849:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f84bcf4f549ca0d6e75c7905f1463fbace4f3b955032fcae627e46e353b2aee9_Device=CPU_Config=() +1848:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=73d32deb47a4954f7502d431a3346e456cf3d93c6217c9ab8c5fc630cc4e3669_Device=CPU_Config=() +1847:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=8f7dc81bfce05ce39b694fe48197a4fd2aa7933c7061508be3b9dfefef518f75_Device=CPU_Config=() +1847:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=5b1fc9693e4e947bc88a88bf1ad22ee2f59c13bf291626eec3e8ed49b0cef7ed_Device=CPU_Config=() +1847:conformance_LSTMCell/ReadIRTest.QueryModel/Op=LSTMCell.4_Type=f32_Shape=static_IR=e06dc2c56b985c79eb1bfbaafe281ab726a6c1c87c4092d1efad3e16cebd3c47_Device=CPU_Config=() +1846:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=c39d76c89bb03fe251dfffdd9b8eb85c0585904ed9c5bb4660c3dedfdc451efb_Device=CPU_Config=() +1844:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=5c5e10f28ed3a8d4ee0d3c8af982df5f383a4a1a713baba556dd17ee52e9ef32_Device=CPU_Config=() +1844:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=f645a2275ff33ad614c801a8f2f262ce1ca95417e0ca59e28d4b87cf3289c00b_Device=CPU_Config=() +1843:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ce0514ded018b3bde00091b50a98b715da2a3e3c254406b9fb290b930d6f5680_Device=CPU_Config=() +1842:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=81e9c51ff606608d5a0f868a7ff529afc34804e04415b2ec654f31f848a81e1b_Device=CPU_Config=() +1842:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=29d1a1e024ca9bace919909bf537adbeadce2875807ab12a4e3b3499c4c834b5_Device=CPU_Config=() +1841:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b75101615777d246b4d0939e52b257bd293f2e4745ed4a9b307a0d2b3e1852c1_Device=CPU_Config=() +1841:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=df085870336c57084e22afa8b52ece7149abc21b5d1784965a7d36d5ada91e8b_Device=CPU_Config=() +1841:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=5fd7b424cb32653589798a45526ac4b3f3aafd29a58e5ed1cef16a958fd4a859_Device=CPU_Config=() +1840:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b6bb8473f99506737101987d5732d33073de8783b22d891c652653884bab7a87_Device=CPU_Config=() +1839:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=eb014b2651dad2cccd6291bceaca16047a4a7fce1595430520ad8d8601ff29c9_Device=CPU_Config=() +1839:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=817b3db8f96297276bc70f1b4854867cb92c164925c9dce59a1d054e3c315bee_Device=CPU_Config=() +1839:conformance_ReduceProd/ReadIRTest.ImportExport/Op=ReduceProd.1_Type=i64_Shape=static_IR=44e0e688ecb44d7a9e83f7c9e1639fae49b2883dfc1b1ed588c98c5bd1f614fe_Device=CPU_Config=() +1839:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=f32_Shape=static_IR=c18bd3eea12bff29ac733ae5578d28d88d5ed87aef7908aed08a09512e3b77ff_Device=CPU_Config=() +1839:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=b61800abac107b248c29df7ba04a73c91d490782b1da46164c1b7d2f8cec3cdf_Device=CPU_Config=() +1838:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=0d413b2d40036984ce2b85933c4b5ffda416e8779a20b602095d2654db296d58_Device=CPU_Config=() +1837:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=74f34c8b7abfe0f7afe021ba5d4861e29f9f3915beba5cdb2af936f1f2409fb6_Device=CPU_Config=() +1837:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=80e0900e8270dfbd0fc879ad4d065847f767cff9399688bb9e5e03b8531c554e_Device=CPU_Config=() +1836:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=baf2ff4e48e3608f42c5a92cdd7fbd8c4a47fc66e47143e52e4db2f83781ed2a_Device=CPU_Config=() +1835:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=704412b992d55bf9ff00d823458e5d3b3a369e47b3eca3429fed94b87c8da554_Device=CPU_Config=() +1834:conformance_Sin/ReadIRTest.ImportExport/Op=Sin.1_Type=f32_Shape=static_IR=54a909996c38d86ec830295e37f0fc0070260101390dbaae2cc6eaabea82a7b5_Device=CPU_Config=() +1834:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=6e67522f2df32ac8e237fd4de148d082f3c55e6c31ace80cffeaef784dfe75a0_Device=CPU_Config=() +1833:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=d6250086b712a16042ee74438bb61b89fbfaa5bae433049207402d1da4cffaef_Device=CPU_Config=() +1833:conformance_FakeQuantize/ReadIRTest.QueryModel/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() +1832:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=122bf99a807265c6a41a3940f305a6855ecbdef6e03540cc958e1fedaeb06488_Device=CPU_Config=() +1832:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=25f55a7cb5f72689bff67eb95af15c64b31c2d29bcde97611e74917fa6724ff3_Device=CPU_Config=() +1831:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=dynamic_IR=9feb072b58552898ff80a05dffe8f39c880b4f2a2382d56cb24a78e278ea1756_Device=CPU_Config=() +1830:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2acd53645519bc460dcc71923563fd462ed997366cc7ae08cb5a30245302a859_Device=CPU_Config=() +1830:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=cd2470c72fa7d2238d2eca4d067e49a02340ad187681be2fa7e0bac6eab3500b_Device=CPU_Config=() +1830:conformance_Log/ReadIRTest.Inference/Op=Log.1_Type=f32_Shape=static_IR=038bd1e152575a3b8ca28bfe18fdcc9cbf19c9489e7bb831b9d5f56f7499cb7c_Device=CPU_Config=() +1830:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=55cc5328906cb6089fc9caadabdf3e176ec72c4239effc575aba4cd9c3b39ad1_Device=CPU_Config=() +1829:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=1c6cbe8477d09b0b193ddf9a453c1b6a8a79e3d1adcdf1c096709cee7a4866db_Device=CPU_Config=() +1828:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=78525afb2b8be0393b6e50e63464ba4487417fc3634641b055f4878f340fe594_Device=CPU_Config=() +1827:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=c52cc9f84ee56b9ced415f830d9f251e52d1dc56a3cace6548b3d345d2b1e812_Device=CPU_Config=() +1826:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e0f4f91a6470af49c5e2497ae8fa917051879c18dd1e39cae18d159b697e8fec_Device=CPU_Config=() +1826:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=4d10da0860e049587221c12f55c3bca9fc587b74dd3fec194c8ba5854a736d93_Device=CPU_Config=() +1825:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=0832e6deae4ceb25b92cdfa532fb5d5fadfe7fd7a00b79f630ddb5bc011986ab_Device=CPU_Config=() +1825:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=7b702f91c21af6c336654c924011d0f4d149111c503c697fcb85a83cd60b7ab7_Device=CPU_Config=() +1825:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=01d609bdfca9f2a499a564f66ab9dd71b394310593d27b8739283b19980e2dc2_Device=CPU_Config=() +1824:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=be9d62b38b487f1687abc68e6955b012b030507b9918b4cc95dafcdf403a2b45_Device=CPU_Config=() +1822:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f9f264e1e7e84711ec78c28ac19f0c120290cd8cae589996ff10d4096d35f592_Device=CPU_Config=() +1822:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i32_Shape=static_IR=5224ffd078708e8917b14b4118bc4a42317c123dc0a5dca8234ad73d44daf845_Device=CPU_Config=() +1822:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=dynamic_IR=214b1d4be2a141409b6b54847c952a282d9b2d7236d3d8ada3463f7dc8554097_Device=CPU_Config=() +1821:conformance_Equal/ReadIRTest.QueryModel/Op=Equal.1_Type=boolean_Shape=dynamic_IR=0723b6d683bc65225624112929bd8f7a0adde9e9c2265a2ec1a54b10c4433735_Device=CPU_Config=() +1821:conformance_Equal/ReadIRTest.Inference/Op=Equal.1_Type=boolean_Shape=static_IR=857447d7e14c7516667094409cf5ef351000344fe170570671be0f71834d04f9_Device=CPU_Config=() +1820:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=20d41e2e902d25c339d648d9f20a3e7f524320dc7186e989b1cab13e401d768d_Device=CPU_Config=() +1819:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=1366ff72dd5b68a3faf25de8f98e4ac5500663b1aac4941af11532ea2ee769d3_Device=CPU_Config=() +1816:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c4679c052b2077c278e2200b5bcf502b660529c84bc6bcd58f92594a69f6648e_Device=CPU_Config=() +1816:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e098a555ca156806b9c32b2049d750a8610e250d8976d9bf35629e517ea6e85f_Device=CPU_Config=() +1816:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=45959eb5eb391b2bc86455cb1e86aca76799c6b082437e72b15c171037a6206d_Device=CPU_Config=() +1815:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=60ab42bb613fe785777ed45bc99044f41dae00316065ed5e5f07e69f5c861fc4_Device=CPU_Config=() +1815:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=a0cee5b220a433f1d76460a1f452bfc26aae12f7b84983a063605b4a8cd0a5d4_Device=CPU_Config=() +1813:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=3638f7714d7627d7536ec02891656e512fee1ec55d59bb4f68c7409ad82f3879_Device=CPU_Config=() +1813:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e2d2eef3e776af9379eb35540d8f4c888491082d8333aeb70f58822aa5cee878_Device=CPU_Config=() +1812:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f0fc8ad1a674a35de1f2e88a1f17905801a6f083a37f5fe658ecdd6d49d30c40_Device=CPU_Config=() +1812:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=98526403db7eb1f67a41aed2c34fea684d99d8cb8225313136e55be7d326aaaa_Device=CPU_Config=() +1812:conformance_LogSoftmax/ReadIRTest.ImportExport/Op=LogSoftmax.5_Type=f32_Shape=dynamic_IR=a3f02c85607891ecc34c484b433c6a78333e13f3d8cd231e651f8bec26e7d0ce_Device=CPU_Config=() +1811:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i64_Shape=static_IR=def60f5f3fb7a0d22cb3d23253e7c8e502aa9dd2d3756c54dd4343b66c2682ca_Device=CPU_Config=() +1811:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=() +1811:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=114c112cd0e9ee76e06605b2c3dca5a6403f6d7c675177b371096087782e06d6_Device=CPU_Config=() +1810:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=933c6450f6856b32e879034662cf60eca53970c10106f8a11eb925e5621042e9_Device=CPU_Config=() +1810:conformance_LogicalNot/ReadIRTest.Inference/Op=LogicalNot.1_Type=boolean_Shape=static_IR=66b8769b499fa31cfd7545411d16a17b04e1a336bb63a7e907707cd170a30fc9_Device=CPU_Config=() +1809:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=22707f4dd48a39013f543e7eea951a8feb16952bb25f9dd34a0f05dcc28883f6_Device=CPU_Config=() +1809:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=df085870336c57084e22afa8b52ece7149abc21b5d1784965a7d36d5ada91e8b_Device=CPU_Config=() +1809:conformance_HSigmoid/ReadIRTest.ImportExport/Op=HSigmoid.5_Type=f32_Shape=static_IR=cc18959ba7c26661ba0f986207bd00aca503bf924b31c4a2070ac40ac3ec5468_Device=CPU_Config=() +1808:conformance_IDFT/ReadIRTest.QueryModel/Op=IDFT.7_Type=f32_Shape=static_IR=cf47311b142dabf10271ebf5c2e359455d9bcea82d95ad2a1a2d58915c77bb16_Device=CPU_Config=() +1807:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=004b6fd9b060324a42aad296dcb21f5b7eb7586c082f98d23f25a6d882f70c14_Device=CPU_Config=() +1806:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=boolean_Shape=static_IR=6d34694c9c8e71415be894a80a8ededc6a83657c6e7ce3aaf66dcd6f9ab99226_Device=CPU_Config=() +1806:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=dynamic_IR=85a35059512fed9e0c70cdcbd5e73c1e247ef97821d5193cbc4f7f7c3ebbaef8_Device=CPU_Config=() +1806:conformance_Log/ReadIRTest.QueryModel/Op=Log.1_Type=f32_Shape=static_IR=038bd1e152575a3b8ca28bfe18fdcc9cbf19c9489e7bb831b9d5f56f7499cb7c_Device=CPU_Config=() +1804:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3c31856cc439ae60215ceed2dc33dd4427c528e87a5f61a3b920e52ae2c87785_Device=CPU_Config=() +1804:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=b9581fac6848b0c6c9fc9af5fd17eca3f2f64832fb7205f97684f1cc4c1985f0_Device=CPU_Config=() +1803:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=4e14d87b7667a7900d4427ec46c72eb3c7bfd2e3d86e5bdf92eb2485059b4951_Device=CPU_Config=() +1802:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=b371481349b8d7897f8b234c64177dad6abc66375bddf4c32c09738dee193184_Device=CPU_Config=() +1802:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=() +1802:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=1c6cbe8477d09b0b193ddf9a453c1b6a8a79e3d1adcdf1c096709cee7a4866db_Device=CPU_Config=() +1802:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=a6f5b58b1d85e5a99389748ae14e507302127e583c436dd9e6015d3c33ab0536_Device=CPU_Config=() +1801:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4bbbaf50403494d1f876609b605bfc1382aeb9a1a27d2562083a8bfbe76ffae9_Device=CPU_Config=() +1801:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=ea71ab322d6f3d74b0a7bdc3ff5dfd322f2d8c518a1fb5bc9960c5e04808f28e_Device=CPU_Config=() +1800:conformance_NormalizeL2/ReadIRTest.Inference/Op=NormalizeL2.1_Type=f32_Shape=static_IR=3bfa35b53e4bb74a9e450b1220a5d3c061f050e498cf86c8f72118052b7fa252_Device=CPU_Config=() +1800:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=31ce051edcf02344a693eb2d200fa02b53412a5707faaffc2907cadcf81192f4_Device=CPU_Config=() +1799:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3453b13d94c5885206e02df250d0d07ce9930fb3260f992502bd677de9c348fa_Device=CPU_Config=() +1798:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1026aafc8501f7286a9094f317c551f15bb189bd449c59f1c83c7a4b5f8c9ddd_Device=CPU_Config=() +1797:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=41c94561e79611e27aaf339205962d4967188b385d68c169b2bf4557173005d7_Device=CPU_Config=() +1797:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=16ccecc11352f2c476db041adea21d67a96e03cf33902b37f4f6855b5113c202_Device=CPU_Config=() +1796:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c9c03f1be9f6d66301feef3e2ddaff82fc6412c616494f29214d4a6bbf89adcd_Device=CPU_Config=() +1795:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=7b9883414482f3b1108e549a9c47bb8a8aa162d962813c7e99411d000e02690e_Device=CPU_Config=() +1795:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=033c6bc337d14053ae097dcbee99ef5de7cb7728b589cc8d64783467505a8ba7_Device=CPU_Config=() +1794:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=5d791fd5b82a74a42073567349728035c4ac52ea64c1a154a73bd4e61d1b42dd_Device=CPU_Config=() +1794:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=00d924b3557896a41b0be32897f7b7293fcc44d79a285e91695a5fd2f29f3b8c_Device=CPU_Config=() +1794:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=046798a0cf8d4c3fd8f1dc12bd0363a669628e748a6c964385eb50bb783924fd_Device=CPU_Config=() +1793:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b91ccf96246dcf055dd9122c823ccc54ea572f1ad8fcbad3a98c88edb7e454c4_Device=CPU_Config=() +1792:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a82fe43f495f5ad83d1fba98c09af9c14bb09cb506339e5ed48c78c8a6c973f3_Device=CPU_Config=() +1789:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=27504b9cb28c91668f7dafc7db47c7260b0e63c040a9dd5493daa35c8d3b6d16_Device=CPU_Config=() +1788:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9931c7922649d308d88cc08efe90d6e99e06e0234b1b9679ba5c90fb2793613c_Device=CPU_Config=() +1788:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=574e53e574b1a6e0bc16a7296aadd78785cac535293e956b008b0a2274b7cb36_Device=CPU_Config=() +1787:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=189793140439255931ae5b3ea93f68da1569937f3c591ff27de99064829a75ca_Device=CPU_Config=() +1787:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3d918677d26d54494f0b1fe41a32370a3d82612fe8e5d5c17a04b48f63d353f0_Device=CPU_Config=() +1787:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=a3de81c04a0e7d5cab275045415ab4c294ed3270588c2ef704ab6db5514ed0dc_Device=CPU_Config=() +1786:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=0fcad2ddd1c7b81bf5e88ef4d4abb26a33326a37fb0cceb1205c1efd2a2d3615_Device=CPU_Config=() +1786:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=20c2030cdd180dbbfad1e5b8a4f865d1757a9d427c3d5ff21651a429369f4341_Device=CPU_Config=() +1785:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f894fd40780753da9c5cbb224a6981e690368cbc31e132922ad38e4e006f7827_Device=CPU_Config=() +1785:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1820314f222425dcf215be41b7ebee2a1f04535529a9207527de12ae7ab35a58_Device=CPU_Config=() +1785:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b77381b3187aeb253a360ff35b4beff6401a89ff07a851230e2dce191c0a136c_Device=CPU_Config=() +1785:conformance_LSTMSequence/ReadIRTest.QueryModel/Op=LSTMSequence.5_Type=f32_Shape=static_IR=1f24aeeef6f9f91272546fca89299c1ce448b0008fe43905db434ae3f28a75d0_Device=CPU_Config=() +1784:conformance_Less/ReadIRTest.QueryModel/Op=Less.1_Type=boolean_Shape=static_IR=8cac1c4c51c2eb61b9ec75320814acf81b9ac240a88e1cc68f29541f6eb546e7_Device=CPU_Config=() +1783:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=d25e26d9a54a5dc9799e9881e3035bfd5f125d12ea6cb69fb1eb0166e29ec88d_Device=CPU_Config=() +1781:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=923032e47821636c4c8098a7a9afa97b331a47d47357c780b7bced2e46ea9921_Device=CPU_Config=() +1780:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=43c8e8300f01242788a8cfdc37b48779f51f7ee7aef5b28e8de542320ba86e4e_Device=CPU_Config=() +1780:conformance_LSTMCell/ReadIRTest.QueryModel/Op=LSTMCell.4_Type=f32_Shape=static_IR=bb27af2909274aef2392e16e6bf596ea37bfe597bccd28e12caaf56fcbd1ad93_Device=CPU_Config=() +1779:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=075342290aa43542c81f7ed4e804c905f110edc23440452c6d0c0f0c312b65c1_Device=CPU_Config=() +1779:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=ac87d885a27bfd348d3f9fad5a03680b73b7198fad17dfdf08675e6e3d239ca3_Device=CPU_Config=() +1777:conformance_CumSum/ReadIRTest.ImportExport/Op=CumSum.3_Type=f32_Shape=static_IR=d517f63a168293380a1f066313e6a2bacef9eddf961ce164f11ce2609a632b3a_Device=CPU_Config=() +1776:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=7744b2351d112ed761ebe0f43945f7dfd58fd2bfbd94bc5a4737549923caf4ed_Device=CPU_Config=() +1775:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i32_Shape=static_IR=bfcba23960ff2b0b1cc73e04f0447e0de8eab35df3b833823878d3c90bdd2e09_Device=CPU_Config=() +1774:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d3add9f9496b58c3880dcf71a47c3efa156aa225d6d7faebfdf4c2f8e44d0be2_Device=CPU_Config=() +1774:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=i32_Shape=static_IR=5b9cbac8797158a77d5616e8b7e5d8132360e23e26d31d845f0d129df7bfd7b5_Device=CPU_Config=() +1773:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=d4e6cfc9844e29087dc5bb222a1822c26ec71f2e751575790add7c9b98a5a23f_Device=CPU_Config=() +1771:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=() +1771:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=b4f42a7d1252f2dd02b31ac7b0cf4ffcbd452dbf0e508833e7dc709ee04889c3_Device=CPU_Config=() +1771:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i64_Shape=dynamic_IR=2c47f1ee19359a486a72bdafc2614159d48fffc80ddabe0f897212a454a75b18_Device=CPU_Config=() +1770:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=dda9a81656cbcb4ab5484fea52e7172baf67d46babce886726c96eaa1980766d_Device=CPU_Config=() +1770:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=860decd2bf091a335f6f820b2c6b6acc58618fbb6027e30484470ce899bb1591_Device=CPU_Config=() +1769:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e27f0bcb3118a7cdb488f4685707bec982ae54ff8bf7e97aff9ea6ecedd66714_Device=CPU_Config=() +1768:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b0376bbdfc6560184c2eb15a9cff7fc6d6b39c47dd22936fb64629d345e227d0_Device=CPU_Config=() +1768:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=22707f4dd48a39013f543e7eea951a8feb16952bb25f9dd34a0f05dcc28883f6_Device=CPU_Config=() +1768:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cdd7ce044f231ae39fc0f7460a55473c0de6934124cd263444a5912b8cbbc0ce_Device=CPU_Config=() +1768:conformance_Exp/ReadIRTest.ImportExport/Op=Exp.1_Type=f32_Shape=static_IR=9416264710da7447d7e3bced32d5275e81b03a897ad99eed5291cc94ad77449b_Device=CPU_Config=() +1767:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=49a0769fa4a26b3277c225f015ebd6b3bff05f8ab05b271a4fba7ea5a7e57396_Device=CPU_Config=() +1767:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=99e405218c1a96c5f8af65aa814893d8958e8e991d1ed8dbbbd586efa589df39_Device=CPU_Config=() +1766:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=19f9f95d2205816fc002d8eaea7cfb19f19218fbc3528e4932b99f1486b62827_Device=CPU_Config=() +1766:conformance_LSTMSequence/ReadIRTest.ImportExport/Op=LSTMSequence.5_Type=f32_Shape=static_IR=b8e32896d2ab304fb4fdca3924e0110852da92be25307f30709cd7d897c2f038_Device=CPU_Config=() +1763:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f37f03c3986aa22dcb304445093d34bdadbc67de22cb9c42ec1d6a03f0386d0a_Device=CPU_Config=() +1763:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4113a61cf98e226d48988dd52624e716382c5f03426f185f777b6018d77633cf_Device=CPU_Config=() +1762:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=508a961c358d40ddb6906694a24f87dc24f74cb4643aab58ee1d6fa28f099e6b_Device=CPU_Config=() +1761:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a9311932565e68fff052e15c1a0522e1c09270d06521541ca28b67c34184b1c5_Device=CPU_Config=() +1761:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ecdaea0a2e3ff82b4695e13b586aef85eb4bbb0df0cf85b13b006d98095995ff_Device=CPU_Config=() +1761:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=7ad5da9c461223f21afd023e08220eaed788598f50e144e45fcdf3466c0810a3_Device=CPU_Config=() +1761:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=66375ff8539da6387946c19b0d20e6b4fd57da25150255e41282458e241963a0_Device=CPU_Config=() +1760:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=424814fbe4a3ba7a49c506f11509c035212fbdf4ef44fb2bc708c5f201e4e1ec_Device=CPU_Config=() +1760:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=() +1759:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=86decc829c047a5febe7e5d047c689075810441a2f4725088317ef68d6c31239_Device=CPU_Config=() +1758:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=43c8e8300f01242788a8cfdc37b48779f51f7ee7aef5b28e8de542320ba86e4e_Device=CPU_Config=() +1758:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=c18bd3eea12bff29ac733ae5578d28d88d5ed87aef7908aed08a09512e3b77ff_Device=CPU_Config=() +1757:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=dcd71a51a6682c9bc461a6cb72d59082352ab8a020e1f79e64c3cc44a37b55ba_Device=CPU_Config=() +1757:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e22e40a4f300567612f963b17707be4de09093cb9a248aed62af594e7986f7dc_Device=CPU_Config=() +1756:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=a449aa561efb222cad1a414ee87443f9fec0e5c2f6220f6a57b6705c9ef26cd6_Device=CPU_Config=() +1756:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0ce1ec496e5d71728fc5daaba87809c5922406a65e85823913381de0d2112e01_Device=CPU_Config=() +1755:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6ddd9bc0333c5b1ebae36dafbc24444ffcd34d29bdb58a9b20d4e584c2cc63eb_Device=CPU_Config=() +1755:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=9f4d316675c933ea5d6511324e3d664440a8ba287cb2ffe768517f9cbfb613e7_Device=CPU_Config=() +1754:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=146297b05289c3b2445e1e97c744b4eb2d45f9f61b8ee8651e35b59fe1ee4041_Device=CPU_Config=() +1754:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0c5ac67592b69e8c2b7acbae7a0f877cfed184c572d2fae09eb8fa629e86eeb1_Device=CPU_Config=() +1753:conformance_HSigmoid/ReadIRTest.QueryModel/Op=HSigmoid.5_Type=f32_Shape=static_IR=cc18959ba7c26661ba0f986207bd00aca503bf924b31c4a2070ac40ac3ec5468_Device=CPU_Config=() +1752:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=fe80951a0a44625457a6106d8613c9813c9c0b8fe3606fa5ac1c064217c8a0e6_Device=CPU_Config=() +1752:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=d5f5f2d39bfe4ccc6f12f76e5eca8e2e40ac7ac6c5f38a7cac21970df213d4cc_Device=CPU_Config=() +1752:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=() +1751:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=60e017f098b38fe7f824eb78635cd13cfa1ff460387abfcd6420c8a7d559a915_Device=CPU_Config=() +1751:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=db5c391cca1031cb4ec32def18ce3a4776c53f71e861c39b350fe5856da4fa43_Device=CPU_Config=() +1749:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=i64_Shape=static_IR=d4acbcb1930b26610eaa33c0bb8aa7fd866d8142afda9fd007226f0ee6fa5c36_Device=CPU_Config=() +1749:conformance_Elu/ReadIRTest.ImportExport/Op=Elu.1_Type=f32_Shape=static_IR=1cb500b61fe11278cc50fca509be3e7b654190294dd581c7862ea3f108e0c192_Device=CPU_Config=() +1749:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f06ff28476f886d4298a83d39f88aff34399d5cd589e0a6d6395e00b0ad96876_Device=CPU_Config=() +1748:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=i64_Shape=static_IR=d106f0cba8d8311b75f6074c099f45e10400c0829fdd1826292b1310471076cb_Device=CPU_Config=() +1748:conformance_LogSoftmax/ReadIRTest.QueryModel/Op=LogSoftmax.5_Type=f32_Shape=static_IR=38bcc7d745ee21a7c6858a161e269f0281d3f41d62d65d10fde9b0a9b80992c4_Device=CPU_Config=() +1747:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=20af9ae4466332a072f3b04c1219146d272daabf2306b66c755980bfd31f2a76_Device=CPU_Config=() +1747:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6a8fb5f2948de2436a33999ee2a01e239193c268f61634f1e80692b0c45aa3da_Device=CPU_Config=() +1747:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.1_Type=i64_Shape=static_IR=36b9b7be1407243aad0792e7a49ef25f7c3e3791dc1ff93cad40480837ba87cf_Device=CPU_Config=() +1746:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=28dbc474828462a812108c43a47aa4e70fa0d2e8e814bef5916092f3e8c7a2fd_Device=CPU_Config=() +1745:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=29bb3b751638e157d0ba7114cc0e156a4b792a9dbb2bafa3ca124516595f01a2_Device=CPU_Config=() +1745:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7af359181d29634dc797b38c2defd26a52a70073a59a7d027ebdd752b4011d15_Device=CPU_Config=() +1745:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=db5c391cca1031cb4ec32def18ce3a4776c53f71e861c39b350fe5856da4fa43_Device=CPU_Config=() +1745:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=c307ba8fc5f5d81037e40e46cb8ce1057d0bab7433138943596e5b21bb84221e_Device=CPU_Config=() +1745:conformance_LogSoftmax/ReadIRTest.Inference/Op=LogSoftmax.5_Type=f32_Shape=dynamic_IR=a3f02c85607891ecc34c484b433c6a78333e13f3d8cd231e651f8bec26e7d0ce_Device=CPU_Config=() +1743:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=e08e84b17997c1b1279429161d287720e4c7deb0e6d055539149bc577ed3b104_Device=CPU_Config=() +1743:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=a7b79789ba2466daa67ce8610753fbd89a2ca372d65e2326802c24cce03f795f_Device=CPU_Config=() +1742:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8222f4a2e6c27f1bf5455fe495f04e3c7f48118a20687c6c5f6434c1e3d12f3d_Device=CPU_Config=() +1740:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=1e5127a9c21ad1ccabe67dd1f1e28a3730c09ba294ef1f9fc001c6dcd723ec62_Device=CPU_Config=() +1740:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=810f13adb3f7342c7d514bec2aa3f20d7a59527b54c7f6954b038efb194c5ceb_Device=CPU_Config=() +1740:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c1852c534b8b95bf1a9aa2771decf2368fa095c5f5688d38ab9ce0bd86152a19_Device=CPU_Config=() +1739:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=() +1738:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=d98330d8f9f03556036d103fb4ca3f8436be42fa4f0b21b185aaad3abb2fb53c_Device=CPU_Config=() +1737:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a8bd299de91e7b19efaf1e0cf6437b26549b7f99481196b375357bd1a71037e3_Device=CPU_Config=() +1737:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=0832e6deae4ceb25b92cdfa532fb5d5fadfe7fd7a00b79f630ddb5bc011986ab_Device=CPU_Config=() +1737:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=e939c4d2a27e1d7dba93827ab807881c32e47d48b726fec701712bc85c3404a8_Device=CPU_Config=() +1736:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=d683b96d525bc074d4f8c15934a5082a3fba1068b591f67e4b05d605fe5e6aa7_Device=CPU_Config=() +1736:conformance_Proposal/ReadIRTest.Inference/Op=Proposal.4_Type=f32_Shape=static_IR=c0884ce897724cace24b30df395a33443364f8494f1f8495d212f2db20fc49e2_Device=CPU_Config=() +1735:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=36783f31e83ed0f978f00a1cdd87a25b4b881c251fe059e5d2829be3d0b45c5c_Device=CPU_Config=() +1734:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=36783f31e83ed0f978f00a1cdd87a25b4b881c251fe059e5d2829be3d0b45c5c_Device=CPU_Config=() +1733:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=4420cfb7f4a734731dacfe5b0c27db41ccaac2ab8bbff56cac0f99ed96e976f2_Device=CPU_Config=() +1731:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=c98e1e2347c7b6939804dfcfcebbbd57d4c05e8d13b35b2611912290d06107ff_Device=CPU_Config=() +1730:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=i32_Shape=static_IR=201b881bba09ed67334d9489a1a8971e483120bd1cc75a1aa1c9f015f760e002_Device=CPU_Config=() +1730:conformance_If/ReadIRTest.QueryModel/Op=If.8_Type=f32_Shape=static_IR=If-8_886_Device=CPU_Config=() +1729:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=68f6c55980c58f4d6de9e948d1c034b712cf74de509d8fd825fe7f7dfb11550f_Device=CPU_Config=() +1728:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=47c28b32453e7972e5f4a7213522370ec927424c913b5c6d0ec08a00d7a988c9_Device=CPU_Config=() +1728:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f89e84d6fb931cf0cd074acd01a50e50daa47ad88b1b74e4b3671d63bd7889f2_Device=CPU_Config=() +1728:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=6dae5ccb2325826167ff4ec57e51280b4e125801e6405a33f4d95fd9ab9f3fc5_Device=CPU_Config=() +1728:conformance_IDFT/ReadIRTest.Inference/Op=IDFT.7_Type=f32_Shape=static_IR=cf47311b142dabf10271ebf5c2e359455d9bcea82d95ad2a1a2d58915c77bb16_Device=CPU_Config=() +1728:conformance_HSigmoid/ReadIRTest.ImportExport/Op=HSigmoid.5_Type=f32_Shape=static_IR=85df90c3ae7b84d89ec4eae30556ebf4af996c318afa45d90dbb219f73033f31_Device=CPU_Config=() +1727:conformance_ReverseSequence/ReadIRTest.ImportExport/Op=ReverseSequence.1_Type=f32_Shape=static_IR=a5cc0793d73f7f76fc02b5ae04ef2a29bf212ce5c59f9bbef91e0aa5ee17785c_Device=CPU_Config=() +1726:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6b86bf4f834b297dcb461acb5854aeb9783a381521ea1a8e1cf4fbeb60d6d09b_Device=CPU_Config=() +1726:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=static_IR=ca5d2626f2066e0c806addc4b6ffb4b3a71f1183b93783b92f44de62d82faaf8_Device=CPU_Config=() +1726:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=2a3d6c0476c17897fd4cc6d3623519fc033ac4022a01fbebd40b461f414f6c15_Device=CPU_Config=() +1726:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=717ea579a24839ee9c5ba7c59a07af667fea4fd44ee18bf60e8970264852bde7_Device=CPU_Config=() +1725:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=8b8efa859c54f9cf2200c18953de243d469d2f04bf38ba5f3efe441de23ffe45_Device=CPU_Config=() +1724:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=87c65c520de106b146e91222609f5b25cd79e96cdd6b942c3293cddb656617ee_Device=CPU_Config=() +1724:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aeabe9639d6dcd5ab6e09f9905ffa8bdfe7cafcc7f5c8598e20e4ff39bdb50a6_Device=CPU_Config=() +1724:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=dynamic_IR=791be312b2af6da6abd2eadadc6185c7052271efbcf314bb678828313fc58414_Device=CPU_Config=() +1723:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1d1001df575da981792e8444dac2291418d7d493bf10063dadb8b439cd353ff9_Device=CPU_Config=() +1723:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=474c6273d1e48e8e5885966dc93629ad413683ad942e3101452c1a58fb5b5af9_Device=CPU_Config=() +1723:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=20c2030cdd180dbbfad1e5b8a4f865d1757a9d427c3d5ff21651a429369f4341_Device=CPU_Config=() +1723:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=d04bc06efa76ef2937aa1539893ec9c79ac61c765cb50cd4a26dbf5586bfc904_Device=CPU_Config=() +1722:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=4b00183255fde45d5c3b815b552e5a4279284bfe1ceb31389560260ad5546c14_Device=CPU_Config=() +1721:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=d9eeac72636735d7541c2d0ef14ebfc7d4a1b3598c08c136a9123b2ed89e13ef_Device=CPU_Config=() +1720:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=83b83dd13b1733a50ec728ca6e7f09eb75641a573178816d1d33f30390464d87_Device=CPU_Config=() +1720:conformance_ReduceMin/ReadIRTest.QueryModel/Op=ReduceMin.1_Type=i32_Shape=static_IR=a2b9f0b4c044e23f536d137b6e157d1357df657d1af119cb8f71294d7dc098cd_Device=CPU_Config=() +1720:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=d9e0dff8f9df42944191425a99bbcfe45ee352d4a030d0f01994725c982b0c37_Device=CPU_Config=() +1719:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=f32_Shape=static_IR=dbc3b2f724614a68d750ae4adfd7d8239c77ced05d30f89deabe272f104a5e75_Device=CPU_Config=() +1717:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f5db8eb433e162e42a727e4aa0e176753cc4cd1e07aac8224a7b0f878a0ad5a5_Device=CPU_Config=() +1717:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=0b603f9cb63e722122080ea36f76fe45b25da83b0b1e213871140e82dea5f405_Device=CPU_Config=() +1717:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=() +1717:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=2620e86e1e6ce8f0ecb3eebce969f3e7df11f7f86c6f97309aa24993f9036033_Device=CPU_Config=() +1717:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=fe615eeceb735b046b190d844931c56223d45439021da3b6b23227a1f9cb73c7_Device=CPU_Config=() +1717:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=ea71ab322d6f3d74b0a7bdc3ff5dfd322f2d8c518a1fb5bc9960c5e04808f28e_Device=CPU_Config=() +1717:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=68f6c55980c58f4d6de9e948d1c034b712cf74de509d8fd825fe7f7dfb11550f_Device=CPU_Config=() +1716:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=b6a75c5d2a686eae53cc25c6b107630b31a8a4d8c6514980ed1a97754f33bdcd_Device=CPU_Config=() +1715:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c1f0b881be142016d55c77178631a9861407f9c3f889e58c64924e84c039252e_Device=CPU_Config=() +1714:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=i32_Shape=static_IR=a142d6fb0ae0c0decec2ebeba376ed65852e1c60b1c1abee7bc574d5ef3a6a3e_Device=CPU_Config=() +1714:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=7f37f31081476643f5c279fddc3d25eae22d909730b4aca0211aa70fdd572843_Device=CPU_Config=() +1714:conformance_LogSoftmax/ReadIRTest.ImportExport/Op=LogSoftmax.5_Type=f32_Shape=static_IR=38bcc7d745ee21a7c6858a161e269f0281d3f41d62d65d10fde9b0a9b80992c4_Device=CPU_Config=() +1714:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=517a5eeb2f1f21304b8a1d5971f89bfc93aa678252180bdb05144657b1a8619f_Device=CPU_Config=() +1713:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=() +1713:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=bc1a7618e707ddd2c4773d1a2234e6dfb39954ad872abdf38a18d653ec35b26f_Device=CPU_Config=() +1712:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=88c7bd909ddf1935966d1937508ebcbd6e56526c7354bb3a40bd9de52aaec142_Device=CPU_Config=() +1711:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4e9ae0418fb4f362c008ec90ef89001ecb8d13900c970d3ce051489c69305995_Device=CPU_Config=() +1711:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b5d0b3117c15997ddf3779525e849ba35c0096ad654c8e27fd1e87e29cbd61dd_Device=CPU_Config=() +1710:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=264ac1f5ebe805838ff6e76fca75305ba3ecb27f84e44ae7b44e9c01d613df98_Device=CPU_Config=() +1710:conformance_GroupNormalization/ReadIRTest.QueryModel/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=() +1709:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=4892263cb1ea7a434b5771aa16f07885c39710f67fa1411dd9235653a6b8622c_Device=CPU_Config=() +1709:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=f42d85c8e1388cf2cb69f9efb2970255c6535f1c3f904a9b08cc18cbea6aa6c3_Device=CPU_Config=() +1708:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=e1130d42d591780dd2a746ce7ff874a2bf4725ca9fd09803932ba4a7b0b389aa_Device=CPU_Config=() +1707:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=36783f31e83ed0f978f00a1cdd87a25b4b881c251fe059e5d2829be3d0b45c5c_Device=CPU_Config=() +1707:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=c662eb0004f431152ddc69e12826a6c0e7aa66b24be0169acf10ca95f2a63f52_Device=CPU_Config=() +1707:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=() +1706:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=eeb4d5ffc7eb6cdd80079e6b814a1c228e389e4fa01ca368f092b606666bf7c0_Device=CPU_Config=() +1705:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=2e38326f5f0527299a0385fc3bb6c85c80e12e5bce07fe530624aba7113e82a6_Device=CPU_Config=() +1704:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c7aee90a4d266602709c28c5c6fb4e0ecb791e5399fa3077364e660f657752c0_Device=CPU_Config=() +1704:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=447c546ed54e81edcfea77cafa8d18261923bf25c050666029828ea72e3a875c_Device=CPU_Config=() +1703:conformance_ReduceProd/ReadIRTest.ImportExport/Op=ReduceProd.1_Type=i32_Shape=static_IR=e34207bf06e51dbf322bc0db76f3a9828ae018b02dba2b1826ed97004bee8125_Device=CPU_Config=() +1703:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=() +1702:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=cb67c5d0b8712ebac00fe4169f0cad2e0a8c71d7f9603d5d2ce6ff6dd6bc055e_Device=CPU_Config=() +1702:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=78239cbf0f8d473af2209ad3d9297e02208c110efa7af981f8c09ea7d7290032_Device=CPU_Config=() +1701:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=64186bbc89d54f073554e029b8972fbbfba2abce8026a379b7ac3833f84ac9d4_Device=CPU_Config=() +1701:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=81c2956d325aab4a7bfd931d94151e1285083a15326e0890f861b97017a24bb9_Device=CPU_Config=() +1701:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b46a2ee4f7042328b2496382ed2bb9cf39621c3e3e27fd1d355c9682543effc2_Device=CPU_Config=() +1701:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=662ca1fd253f0a0c29b89eb1310ea5c7c87895533130ca1a8b76f791ef1ad99b_Device=CPU_Config=() +1699:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=() +1699:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=i64_Shape=static_IR=68115f3a18f8ea201078166547e9c2a8587a5bb37646adf6f90da976f7298386_Device=CPU_Config=() +1698:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=368972b9c1fd7f33348656101315b2ca3ed44503ce08ed5c9baf75026dec049a_Device=CPU_Config=() +1698:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=ae444aa1dc9d87f1610bbf65710d9a5f9710d680848d08afaf54f526f78b0dc2_Device=CPU_Config=() +1697:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c87c002bc627f4adfa58547da4c2b1f270e07e9961a1b4ae99dda72d88980550_Device=CPU_Config=() +1697:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=a1862e486a20c8de71dd94c12a157098ac5f222ba8ba3e1d3edaf9362331e185_Device=CPU_Config=() +1696:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=77be82cc74d0c8e20faea172f9d02c00030bbb8c33d8fae5b07e8b5e5f93af58_Device=CPU_Config=() +1696:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=eeeaf32688af20dbc39dd3705dc09fc804c0636d4d5807b003c002eaab1e79dd_Device=CPU_Config=() +1695:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=() +1694:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=() +1694:conformance_HSigmoid/ReadIRTest.ImportExport/Op=HSigmoid.5_Type=f32_Shape=static_IR=4a55e1cc1410675b7789f083f2cd3f6ff851f49c8a0818f5bf0dd27280b197f9_Device=CPU_Config=() +1693:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cdc57df56ccf890a00f886c3b83f504d24ea9d4ed5f0ef05f1189879172777f8_Device=CPU_Config=() +1693:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b75101615777d246b4d0939e52b257bd293f2e4745ed4a9b307a0d2b3e1852c1_Device=CPU_Config=() +1692:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=80f2651dfe68b893f390dc18ef997cf1e234a087d016cdacbbf96a91968cce82_Device=CPU_Config=() +1692:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=6289232b1cbbafc963ac3cd787330c81a9cd02def9fefb83d6f6cced249de92f_Device=CPU_Config=() +1692:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e77468c2881ce0c38c14038151d560ccadc7dcbd5eb5f21b68b8e227c89813a7_Device=CPU_Config=() +1691:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2b621c5ea887266d69d70093db3504250f63d502f505c6a29a38ccf88b6fbce_Device=CPU_Config=() +1691:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=625213da165aa2bc036bc690db1a2dd0630d6baa20a5c79e26d52aa2abd97557_Device=CPU_Config=() +1691:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=f3d704d4f0da6c58c39e279d727dd82fe0e59a41dbaf09a3cbaa8f591daf95f7_Device=CPU_Config=() +1690:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=() +1690:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=c61a8f259a8b37e49f9267dbc921d88dd60e5766aa30dd05319f423a01c14aee_Device=CPU_Config=() +1690:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=2737751bcc195e4aaa63ab6d86d803741817287d78fc864e18a31c328078940d_Device=CPU_Config=() +1689:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=() +1688:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7bf0600f459cdcd8d44b0cee600efd18d2319dc459d59314af52cddef6181aa4_Device=CPU_Config=() +1687:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2006e1eaa808a3e78550535058de54c5cd83e9a32a52e488fef1f7883c321a3_Device=CPU_Config=() +1687:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=24e44f75d91fe4e7e28db6c93870a47d536abeb87240841ff5b7e74b40189e42_Device=CPU_Config=() +1686:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3b743fa55fcb61cd34046e3e97d71a05de0f8db98d3abcff4e14426d143771cb_Device=CPU_Config=() +1686:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43aed1509066aa7c839a82c9865228ce3ebdfbe519061649807875ec6e86d715_Device=CPU_Config=() +1685:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=63923bfd18e06b6a4a5f5f975b049eb9a46c9beee83a1759bd99d72483130af6_Device=CPU_Config=() +1685:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5bf1e9348ae0ec7106a2231d8940acc74464f5ecf0cbc6a682defc3a9bc5c2c2_Device=CPU_Config=() +1685:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=0fcad2ddd1c7b81bf5e88ef4d4abb26a33326a37fb0cceb1205c1efd2a2d3615_Device=CPU_Config=() +1685:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=f32_Shape=static_IR=521ab9a51bae271537fd09832298deef71b46d465161e2db579cb503f1ac812b_Device=CPU_Config=() +1684:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f5dbf9b79d3887c9207d8971e45282f563af47565ed7a941cf972014e8b5bf05_Device=CPU_Config=() +1683:conformance_Sin/ReadIRTest.QueryModel/Op=Sin.1_Type=f32_Shape=static_IR=54a909996c38d86ec830295e37f0fc0070260101390dbaae2cc6eaabea82a7b5_Device=CPU_Config=() +1683:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=120cc30794fe9c9d59dc9df6fadbb9791f3a6b99e4b9fdc06c5e01f494b05780_Device=CPU_Config=() +1681:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=76539d5ef8e5f423a8cab413fed102f918a53f68d19bc3c054d01e8a18e41841_Device=CPU_Config=() +1681:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ba515e47066707dc9346b3002df0666bed67bec38ecdb0489943423ffab1a7dc_Device=CPU_Config=() +1681:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=b4f42a7d1252f2dd02b31ac7b0cf4ffcbd452dbf0e508833e7dc709ee04889c3_Device=CPU_Config=() +1681:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=c11313948e0a44512d2e068e2cf89c922a219f8f26a785c5fa34ed34fc7560a4_Device=CPU_Config=() +1681:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=b7b0a0b3921a1e1434a3fef630e32b124c810e8bd15a3e861fe7da79158947b2_Device=CPU_Config=() +1680:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5e98e0dd0eec9f330eaedb43a4d3ee506c10d23283c3e25e753b634e819f460a_Device=CPU_Config=() +1680:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=dda009a1f3191e35286b7515f5741905e303f27287041248e2ce15f6954af810_Device=CPU_Config=() +1679:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=eeeaf32688af20dbc39dd3705dc09fc804c0636d4d5807b003c002eaab1e79dd_Device=CPU_Config=() +1678:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3e5930f1ff4ad9d9e53216b6f8f912fc7ba051bfc85c46ce2dbcddbcd357832c_Device=CPU_Config=() +1678:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=99183013393075553f5cd30818ccd603ff5d3e9e71dd8f42ced0df2377280729_Device=CPU_Config=() +1678:conformance_Erf/ReadIRTest.Inference/Op=Erf.1_Type=f32_Shape=dynamic_IR=e6f95710a782b6c7df8397480e5cffbfa773fdf4ef11c93b2b1ac4694313b080_Device=CPU_Config=() +1677:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b91ccf96246dcf055dd9122c823ccc54ea572f1ad8fcbad3a98c88edb7e454c4_Device=CPU_Config=() +1677:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=() +1677:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=() +1676:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=2686f1990d367d705eb27e252bf4185704c592225e83c62e5681d3300e9ded18_Device=CPU_Config=() +1676:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=i32_Shape=static_IR=75f0349e33d0151c276e3f5ce34f7c1a71f5572331157b2e34f889773d7d8754_Device=CPU_Config=() +1676:conformance_Floor/ReadIRTest.QueryModel/Op=Floor.1_Type=f32_Shape=static_IR=b064511ab38a9a70b4d203e11a12b990f388a03550ba98c65468be1b85c68fda_Device=CPU_Config=() +1676:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=50e01efd1d927b71763f678e29a16ae688a5b0f10ed9cee12f1e7692924d5318_Device=CPU_Config=() +1675:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=a6722b8718b7c028e1bbde4462945c096dfc551775af27bcc7d00967d7d73919_Device=CPU_Config=() +1675:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=c11313948e0a44512d2e068e2cf89c922a219f8f26a785c5fa34ed34fc7560a4_Device=CPU_Config=() +1675:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=0d413b2d40036984ce2b85933c4b5ffda416e8779a20b602095d2654db296d58_Device=CPU_Config=() +1674:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6d754f7aaf66f59951015d768d438e036e0c598303c67ee404c5f9a4f8aa30b2_Device=CPU_Config=() +1674:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6aff57130da7904e5d2300c4962f104d31c704872d5c33bbda4bb38efc34d563_Device=CPU_Config=() +1674:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=c4d8543f8e0b375407e428ef119ba4049d44cc273a10661b57645bcd1d36f5cf_Device=CPU_Config=() +1674:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=59f5de8e6de60b1336848dfcf1878ee5ee5bc8771ff1b93f39c31abfa3685e4b_Device=CPU_Config=() +1673:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=19f9f95d2205816fc002d8eaea7cfb19f19218fbc3528e4932b99f1486b62827_Device=CPU_Config=() +1672:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=i64_Shape=static_IR=d4acbcb1930b26610eaa33c0bb8aa7fd866d8142afda9fd007226f0ee6fa5c36_Device=CPU_Config=() +1672:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=3e669c3f90fc7b2209d3d588932f8eff3827309a5928f4b27722139964e2c46f_Device=CPU_Config=() +1672:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=7685da6dcf91a208b72d5961c2c248d816de501366163d61b1ee3c148787fe77_Device=CPU_Config=() +1672:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=c39d76c89bb03fe251dfffdd9b8eb85c0585904ed9c5bb4660c3dedfdc451efb_Device=CPU_Config=() +1671:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f7271aaaa48555bb6e77b1b22aff8e1507d5a3fd2bff3581d3b6c5c18b6b4963_Device=CPU_Config=() +1671:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=e7ab5b597681da2db03c13a2424b4e0a62135eecfb2f97f4c59b53331afb7f85_Device=CPU_Config=() +1671:conformance_NotEqual/ReadIRTest.ImportExport/Op=NotEqual.1_Type=boolean_Shape=static_IR=8fe4bce2e674753d81a1516280769a06cdde538e658ae548087e4888ffa2905f_Device=CPU_Config=() +1671:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5bb5076aa4e905f00c38eeae688e2624d5a57f8ac7b6ee873943361985e63343_Device=CPU_Config=() +1671:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=a6f5b58b1d85e5a99389748ae14e507302127e583c436dd9e6015d3c33ab0536_Device=CPU_Config=() +1670:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=628975e7be92df698e381e47cb5e28f3f09bfc1d19c7d0e434e538743e50f53b_Device=CPU_Config=() +1670:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=9aba412b059ee77c603bebe3e49240d6f2183168002d25bb7bfe62f1224be2fd_Device=CPU_Config=() +1670:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i32_Shape=static_IR=bfcba23960ff2b0b1cc73e04f0447e0de8eab35df3b833823878d3c90bdd2e09_Device=CPU_Config=() +1670:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=2d6f6b955cd431e0f4786aae35f5a1f7f69a6b627e88c42643ded0477f1cfef7_Device=CPU_Config=() +1670:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=0a7b1efc8d314c5e37062e482a9398f718082ba0528c6ca2d2f6c88e7a4a2bb0_Device=CPU_Config=() +1668:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6167830634e0b253aa78e883453d45bb737cd5df33c849e4b16b99164fd49d5e_Device=CPU_Config=() +1668:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a1e0bbe02c433cb144b4825a9f1b2c30c03743f210830db5462736850b6db383_Device=CPU_Config=() +1667:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=6ac457e9181610da9eb4bf0bec6cd53bf3078e0b84df1211f49921207d81c6e9_Device=CPU_Config=() +1666:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=dynamic_IR=9feb072b58552898ff80a05dffe8f39c880b4f2a2382d56cb24a78e278ea1756_Device=CPU_Config=() +1666:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=cd389fc4a9417c7136f75474e42dfb43d1f9cb35fa0e104632ffa69fce2b7e57_Device=CPU_Config=() +1665:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=fa15f26352d0ced4d5f1b31c382aa71fe9413ce66ba6664ab9bf9a24975ee3be_Device=CPU_Config=() +1665:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=1409169e395a3eb90f9235b74f2f8c94e0e27a63fae33cda153d991ae1cbb68d_Device=CPU_Config=() +1664:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=74f34c8b7abfe0f7afe021ba5d4861e29f9f3915beba5cdb2af936f1f2409fb6_Device=CPU_Config=() +1664:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e995424209defee7f9c521cb07889eb499bd546ed3dde685841d518b2e69da58_Device=CPU_Config=() +1663:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b1bae9ab001e5c3b05f22881494508bed2f623801431b8402e6146e54d692016_Device=CPU_Config=() +1663:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7d3a099a5040e70c73014df347c478d0976123d68b6fcab6bf767f90bbdf8e6a_Device=CPU_Config=() +1663:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=6119edc6e1f969159ce54e6ff4451d96db51485b54fae625a972035414c704ef_Device=CPU_Config=() +1662:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2acd53645519bc460dcc71923563fd462ed997366cc7ae08cb5a30245302a859_Device=CPU_Config=() +1662:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=29d3ebfbd6a10a5c74102ea71c9edd316f60c2c7a72c81f554f81416f9296c91_Device=CPU_Config=() +1662:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=f26c1f41ef689dde33e9d61b0a1066788b8397ba6a170f5eb1362726ba9c0868_Device=CPU_Config=() +1662:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9ba199e71a3ff06e6bd330e453a1e1103599902893fc267c60da9ae47575a8a0_Device=CPU_Config=() +1661:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=029a0a8ba891497790c27ffa1ea50c63536a0c81fc40e06e3ff07e419a8701c6_Device=CPU_Config=() +1660:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=e894ea68d25e2a0af6fe2e330929c3305710bd07aca8e099b727df78fb26cdf6_Device=CPU_Config=() +1659:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9931c7922649d308d88cc08efe90d6e99e06e0234b1b9679ba5c90fb2793613c_Device=CPU_Config=() +1659:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=c66bf2eb0c46ce68b45d052526a613e65f43c69926768fa0df8d1ab412b2b743_Device=CPU_Config=() +1658:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=dynamic_IR=516ad610612780fdaf83c5dc151316e83772eda4700882f934c97b2a2bd86dac_Device=CPU_Config=() +1658:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=3688e2a973219245d05c5fa675cebe9036d40777809ebf583c1bae9b9f87eed6_Device=CPU_Config=() +1658:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=() +1658:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=a7b7ec75e1b343acfa06ea53d7d5b631c06d44c68b1fc92555d7168c77aeadb3_Device=CPU_Config=() +1657:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f64b683dde6fe3d8d6ae0734a986a290edd10869211c7a8c56eb51c170f1a231_Device=CPU_Config=() +1656:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=79dde0b4a7ccb6e275b507d3467b9ad1e02498ca54329e111d06903d57355623_Device=CPU_Config=() +1656:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1d41827cafc0ccd8d9b0d1304c302fffafb52f653dedeed1582a9d8c7b88f173_Device=CPU_Config=() +1656:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5bf1e9348ae0ec7106a2231d8940acc74464f5ecf0cbc6a682defc3a9bc5c2c2_Device=CPU_Config=() +1656:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=70d4da84623a0af3bc8362a828bac5ef13285498b420a3df6bf2e88bf05311db_Device=CPU_Config=() +1656:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=56fb4fb30ec6fd9ddd0ff2e394434eb87546ac7de273f47b663252efa2a380be_Device=CPU_Config=() +1655:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=static_IR=8c82cead166c3db4616f034b66c4795cb4bed653de41d2b6dc71b48ce76a296e_Device=CPU_Config=() +1655:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=() +1655:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=25f55a7cb5f72689bff67eb95af15c64b31c2d29bcde97611e74917fa6724ff3_Device=CPU_Config=() +1653:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=12965dd8a422975f08bb0fc707c666ad7ae2671d09c68757d534e3a1d67efd41_Device=CPU_Config=() +1652:conformance_ReverseSequence/ReadIRTest.Inference/Op=ReverseSequence.1_Type=f32_Shape=static_IR=1ff07d9b87513cab5bbcf5059507b8c998fdb25d2802b267bb6c0b90eb3e231d_Device=CPU_Config=() +1651:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.1_Type=i64_Shape=dynamic_IR=45a9a897d75b175e3d805e74ec09322789564e0c0e8d9535724f262a9f534572_Device=CPU_Config=() +1651:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=2b927ee73187f1c1cbdb071ad3c0a72c9eb8a8631f2e7c6c3a8f8482c301fcf3_Device=CPU_Config=() +1650:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=38b9494dea51a8f26748bfa4be970913acee0bf6d97e526578e40e5e3c04faf7_Device=CPU_Config=() +1650:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=6e53e1fedd57631f3ec70d6825d8d1029ac95905b82b6bef7fd44ba87373e9c6_Device=CPU_Config=() +1650:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=f32_Shape=static_IR=521ab9a51bae271537fd09832298deef71b46d465161e2db579cb503f1ac812b_Device=CPU_Config=() +1649:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=30eb0edc699f72085fb77a6cc31ad4aa9e62cf97befb64273493d234494fc64c_Device=CPU_Config=() +1649:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=a6f5b58b1d85e5a99389748ae14e507302127e583c436dd9e6015d3c33ab0536_Device=CPU_Config=() +1648:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=() +1648:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=c39d76c89bb03fe251dfffdd9b8eb85c0585904ed9c5bb4660c3dedfdc451efb_Device=CPU_Config=() +1648:conformance_Erf/ReadIRTest.ImportExport/Op=Erf.1_Type=f32_Shape=dynamic_IR=e6f95710a782b6c7df8397480e5cffbfa773fdf4ef11c93b2b1ac4694313b080_Device=CPU_Config=() +1645:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=f3d704d4f0da6c58c39e279d727dd82fe0e59a41dbaf09a3cbaa8f591daf95f7_Device=CPU_Config=() +1643:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=56fb4fb30ec6fd9ddd0ff2e394434eb87546ac7de273f47b663252efa2a380be_Device=CPU_Config=() +1643:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=df085870336c57084e22afa8b52ece7149abc21b5d1784965a7d36d5ada91e8b_Device=CPU_Config=() +1642:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=49245e23b8c1c485428d0e490a687e48c541bfb833eb7838efd8c112736a076d_Device=CPU_Config=() +1642:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.1_Type=i64_Shape=static_IR=36b9b7be1407243aad0792e7a49ef25f7c3e3791dc1ff93cad40480837ba87cf_Device=CPU_Config=() +1642:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=31ce051edcf02344a693eb2d200fa02b53412a5707faaffc2907cadcf81192f4_Device=CPU_Config=() +1642:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8ec74565f16a2ee1e322b4549ea19aa0b30719787abd90bd957e121705edb268_Device=CPU_Config=() +1642:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6eb80b60b2162fc469f652535ee11822ae34c903ca44191dc95ad7f9678b9337_Device=CPU_Config=() +1642:conformance_CumSum/ReadIRTest.Inference/Op=CumSum.3_Type=f32_Shape=static_IR=d517f63a168293380a1f066313e6a2bacef9eddf961ce164f11ce2609a632b3a_Device=CPU_Config=() +1641:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=dbabd4c2992053ca70e9d6a489b437cf8d1f13807220adb5054204e9bede00e1_Device=CPU_Config=() +1641:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=27a43bf8c20a81f1e244ace4c53f7cd9343a2603ba2c8b50bb041a4046ae6ecd_Device=CPU_Config=() +1640:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6167830634e0b253aa78e883453d45bb737cd5df33c849e4b16b99164fd49d5e_Device=CPU_Config=() +1640:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=() +1640:conformance_HSigmoid/ReadIRTest.Inference/Op=HSigmoid.5_Type=f32_Shape=static_IR=85df90c3ae7b84d89ec4eae30556ebf4af996c318afa45d90dbb219f73033f31_Device=CPU_Config=() +1639:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=() +1639:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=u8_Shape=dynamic_IR=81bbb9658ad214babb825fa4b576aa83a9ceaae7dc0b878a84e42ea194f3ec13_Device=CPU_Config=() +1639:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=923032e47821636c4c8098a7a9afa97b331a47d47357c780b7bced2e46ea9921_Device=CPU_Config=() +1639:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b584676efc43f08169626742b0af9b96fda041574269fc007d97acf89eed42b3_Device=CPU_Config=() +1637:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=075342290aa43542c81f7ed4e804c905f110edc23440452c6d0c0f0c312b65c1_Device=CPU_Config=() +1637:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f71810b04667907bc88c4a1ecc28b9325fde04026b5e56b5eb0e2d6608f3742_Device=CPU_Config=() +1636:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cfd594e916dbe86e473f1a80da2913bbbc365130d9bac66c0be9531ad40ba673_Device=CPU_Config=() +1636:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=461bf15d226b7ee3cbdcbc8cf1806e98267c5f14f0aef49dfb9de094f56347b7_Device=CPU_Config=() +1636:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=7685da6dcf91a208b72d5961c2c248d816de501366163d61b1ee3c148787fe77_Device=CPU_Config=() +1636:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eba756a8d0ce89c9a8df50baeaeb82d5b719461bbaa06386db7e1be10ec535f3_Device=CPU_Config=() +1636:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=acaf36c12445c608b306074ac4e2be9cfde2f5550905993d4b5bd1714dc96aaa_Device=CPU_Config=() +1635:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=14b4e3996d76ae6417a36fef160b520b771b4fa1beca9e271c649f69a59403e4_Device=CPU_Config=() +1635:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c6cb68df4177a7385019521efa21e7d2722be7b0ec0462d93f3caf9d20fdf2bd_Device=CPU_Config=() +1635:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=i64_Shape=static_IR=6590ae34a784f81de25c016454fcc919ae1f9eab672c78c9da0daf83dcdaf1bc_Device=CPU_Config=() +1634:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=491b849a7ce8fdb2190df5415fe037ff02fc23814efc520c343e872f539d6e55_Device=CPU_Config=() +1634:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=a0cee5b220a433f1d76460a1f452bfc26aae12f7b84983a063605b4a8cd0a5d4_Device=CPU_Config=() +1633:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=2f23f1158754aa494abbf61ab15118173a7ccfe90523b2b9ab7cc3a6fdaa0e37_Device=CPU_Config=() +1633:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.1_Type=f32_Shape=static_IR=a4fe57973b0bba01e6038a8050f07b8ad1bf6871c1ad86270920f9084dc84905_Device=CPU_Config=() +1633:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=e0641a7f9e64123d0d51a75e576fbd0e405105b8ead44a618068e77d2b4bf933_Device=CPU_Config=() +1632:conformance_NonZero/ReadIRTest.Inference/Op=NonZero.3_Type=i64_Shape=dynamic_IR=7d0265450b8fc92464273ac05d685952ea3877be45b4d745959f2f373fef1431_Device=CPU_Config=() +1631:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0dafd9117cb3fba3a335f7cd28aaa3fbd9276878383657b357210e135a93d916_Device=CPU_Config=() +1631:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f8b98c32d45c0915f84ca2c09cafb629a540a6a02ec989d09f239a5cecb64001_Device=CPU_Config=() +1631:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=a7b79789ba2466daa67ce8610753fbd89a2ca372d65e2326802c24cce03f795f_Device=CPU_Config=() +1630:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=i32_Shape=static_IR=75f0349e33d0151c276e3f5ce34f7c1a71f5572331157b2e34f889773d7d8754_Device=CPU_Config=() +1630:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=a2450d07c12669e586815e60d9a2b568f88a49c9b63730c898b9eae907b5ec4a_Device=CPU_Config=() +1630:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=9a21caf0c28c5526e267ca97f248e77babb375ce95d8c3893532d51686c69d23_Device=CPU_Config=() +1629:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=9c1e1b695646ea4f56a87b7e5a815c12856f718920e01e86ed78f2dcaf896a37_Device=CPU_Config=() +1629:conformance_SpaceToBatch/ReadIRTest.ImportExport/Op=SpaceToBatch.2_Type=f32_Shape=static_IR=8acd95619121cb22760fd92815b1ba85f541f282d3860e910f73036ed335a9ee_Device=CPU_Config=() +1628:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8971df6b980fb10a4fcc262ef6d3616ee0b0f32841dbb8a4869eaf5848243fc0_Device=CPU_Config=() +1628:conformance_GroupNormalization/ReadIRTest.QueryModel/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=() +1626:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1ee4e453beffb322abb75896695a160ca8b14b0fed69999731588374e6ea4b93_Device=CPU_Config=() +1626:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=() +1626:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=dynamic_IR=8029d5dae7f4721807eb717310512bad44630efdd0a64962496a0fd802a12325_Device=CPU_Config=() +1625:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=a29bdaa31edbcf7b3dc392625c0aa0a27e827e1363d52519858c93defbf9ebac_Device=CPU_Config=() +1625:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=4d9f16ede014da56824607d45502439f71b57275c332fbf15c6ba2ec1496466f_Device=CPU_Config=() +1624:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=823c1bd1ce8ee0ae28410bcea9f3c33ef9f9271e8f41f0871a7d6eb6b2850757_Device=CPU_Config=() +1624:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=70a452909b242f5920ff1e78eea212c720242ed5fe9c22cd1149e3f9847167c1_Device=CPU_Config=() +1624:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f13dcb47235a9516298088a0c45ff56fdb7f95144da257a3dfa1c618c7373ce9_Device=CPU_Config=() +1623:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=df5481436d81f1468146368ea1fae8d5b80f392bcda640243119a3e639f2b92b_Device=CPU_Config=() +1623:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=b288dfcaf8fd8fefe24212a70255bb280e7e695badf6fad6538042701d77073e_Device=CPU_Config=() +1623:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=05d14a25a72424a0290894aaa67c6a1581b34ab0c07cc2acc7739f837b432068_Device=CPU_Config=() +1622:conformance_Proposal/ReadIRTest.QueryModel/Op=Proposal.4_Type=f32_Shape=static_IR=c0884ce897724cace24b30df395a33443364f8494f1f8495d212f2db20fc49e2_Device=CPU_Config=() +1622:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=b729ddf6b689006067cfce88ec7d9e89268dd6cd904e4596717016541632b13b_Device=CPU_Config=() +1621:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d4c59fb1b2e6f27da249cc36d5d1a4c867d0fb17e9354f63b69f61f74780f8d0_Device=CPU_Config=() +1620:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=9f7a30c4f90df2edf8e70468ac22f325bc97e99613fa6ee2aced93e71ea5896a_Device=CPU_Config=() +1619:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8b9ae72303fcba7808c28f788e0187827b2f548efcd6d023e6ad28047121216e_Device=CPU_Config=() +1619:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=858bc9246515c70bfc3ea024102604566e53cd6f618059fa1f6d0046d0de9565_Device=CPU_Config=() +1619:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=caad691eb2d7c291cbb0078e861cb3f1a79f6c321b092365dc9612b2140a76a6_Device=CPU_Config=() +1618:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=14b4e3996d76ae6417a36fef160b520b771b4fa1beca9e271c649f69a59403e4_Device=CPU_Config=() +1618:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=81313f6065af987d98f37a1709f149d804bc1a36bb0a5c4a11223b29c6ccc3d2_Device=CPU_Config=() +1617:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=e7e985d4d02762d236131e74fd867acff1828bcd4c4eb32e190de20eadb831fb_Device=CPU_Config=() +1617:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=() +1617:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a4e797de860d6e4dcec00062050168ba9745d3da953b9c644de654f4d2818b77_Device=CPU_Config=() +1616:conformance_SpaceToBatch/ReadIRTest.QueryModel/Op=SpaceToBatch.2_Type=f32_Shape=static_IR=8acd95619121cb22760fd92815b1ba85f541f282d3860e910f73036ed335a9ee_Device=CPU_Config=() +1616:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=21a3318957d920b39d8b3d84c76cfd2a5ad98515824f88145326deead0961486_Device=CPU_Config=() +1615:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=69f4c39c3fb2dfc55714893e1e45761238e74bf28ecfadbee3f4965b5a379888_Device=CPU_Config=() +1615:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=dynamic_IR=85a35059512fed9e0c70cdcbd5e73c1e247ef97821d5193cbc4f7f7c3ebbaef8_Device=CPU_Config=() +1614:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7d12962a8acd41f85ff8ff280e7f843fa1d5ecb4fca79d5d15d0d858dd9617ad_Device=CPU_Config=() +1614:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=7b702f91c21af6c336654c924011d0f4d149111c503c697fcb85a83cd60b7ab7_Device=CPU_Config=() +1614:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=f5d3b4ec51e032e4df5dae00ecba1a3198c29cba96c72b8c89126c4638b715d3_Device=CPU_Config=() +1613:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=592176a8c97f4d759a0c6b3ef56c3610df4a0df4743f3be7ba3ed2ffb5dcfaed_Device=CPU_Config=() +1613:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=7744b2351d112ed761ebe0f43945f7dfd58fd2bfbd94bc5a4737549923caf4ed_Device=CPU_Config=() +1613:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=99183013393075553f5cd30818ccd603ff5d3e9e71dd8f42ced0df2377280729_Device=CPU_Config=() +1612:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=dynamic_IR=a9636e6e43bc01f8b1cfcfcd8e60e4ffba20837d0d3b80429c93f23cd8da89e0_Device=CPU_Config=() +1612:conformance_CumSum/ReadIRTest.QueryModel/Op=CumSum.3_Type=f32_Shape=static_IR=d517f63a168293380a1f066313e6a2bacef9eddf961ce164f11ce2609a632b3a_Device=CPU_Config=() +1611:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=9fa81cf001e6c48dfcf4e75aa77f95b3dce4e8d48b6ec3cfc896dcc08006c62e_Device=CPU_Config=() +1611:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=c1c38223834d99f4481cb74db2bc302710629de5807b4f08381fd01655b9d44a_Device=CPU_Config=() +1610:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0d52cdcce6bd2a9335a6262a5dad29d924e0b1bc0caa81eb0b73c153d7b27e00_Device=CPU_Config=() +1610:conformance_Proposal/ReadIRTest.ImportExport/Op=Proposal.4_Type=f32_Shape=static_IR=b169d6330e4006909e4deaaf78b03e789ccd9538c5b59d9d41e05f878bb60704_Device=CPU_Config=() +1610:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=() +1610:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=() +1609:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6964f870fd6bf44d1d5ee5925eee8892230b8928aeee1966db73b6c4fcd5acf8_Device=CPU_Config=() +1608:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2f96ff03126561aa475067ad88e454b2da78fc8f0b816dc6c01ec5c81568288d_Device=CPU_Config=() +1608:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=821241f6ca4c3888fcc2043919fa03466266962cfc35369cb9bca51f5ee61b01_Device=CPU_Config=() +1608:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=823c1bd1ce8ee0ae28410bcea9f3c33ef9f9271e8f41f0871a7d6eb6b2850757_Device=CPU_Config=() +1607:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i32_Shape=static_IR=53f0fb6a39e6f296be9d041e6caf93cf34a3916218a07dddacf4985b93943ae6_Device=CPU_Config=() +1607:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=d8432e7d31bcf4d95ff7ab845a6858ea67cf751c7ef0fca60a9bab1d187fe3cf_Device=CPU_Config=() +1606:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=27770ad19af38d01d0238b726d4dd5c3cd32ac743c3b55d186f966658a53f8e5_Device=CPU_Config=() +1606:conformance_Proposal/ReadIRTest.Inference/Op=Proposal.4_Type=f32_Shape=static_IR=ea8cc682a9a36cc61498573e967ec64d289af84a9e3da1911085b1de4fea4c82_Device=CPU_Config=() +1606:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=98526403db7eb1f67a41aed2c34fea684d99d8cb8225313136e55be7d326aaaa_Device=CPU_Config=() +1605:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=30eb0edc699f72085fb77a6cc31ad4aa9e62cf97befb64273493d234494fc64c_Device=CPU_Config=() +1605:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=8368b4f6e208aa4cfbf0aeaa648e9408c281a71d98d15ee09407d26274fb349f_Device=CPU_Config=() +1605:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=c55846f7a08af86fb1c914c925433852fd4bc735f671c87e965a6db9b6971708_Device=CPU_Config=() +1604:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2fdc1dd5841fbc3ee03a323fde995a9b51793a170b2c2fcb504ca721ac981fe_Device=CPU_Config=() +1604:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=debf36fea706c02dc67354edf761f0dc931ebcccbed285f186164fc4b9532766_Device=CPU_Config=() +1603:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=aadbb3768045a0dfddff742fd6ac0940bf0968c7e0b1b22b064503d4081b0a54_Device=CPU_Config=() +1603:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0534fdfa97228a6aacf4ed196a9ace8e09d8e4decdcce058176b0312500b6c07_Device=CPU_Config=() +1601:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=() +1601:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9b3e0ee4798456a9c4e3702faa07c17887739405c56f00425ddd05cfc8ab2a11_Device=CPU_Config=() +1601:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=fb8283ecd8934dfc5340a41e9889a0a760b39869e4873efed4ef85606c162ce7_Device=CPU_Config=() +1601:conformance_ScatterUpdate/ReadIRTest.Inference/Op=ScatterUpdate.3_Type=f32_Shape=static_IR=537f04d52049add01923acd0c57cee03462926f9ce213a4fc9774496f5f66398_Device=CPU_Config=() +1601:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=e08e84b17997c1b1279429161d287720e4c7deb0e6d055539149bc577ed3b104_Device=CPU_Config=() +1601:conformance_HSwish/ReadIRTest.QueryModel/Op=HSwish.4_Type=f32_Shape=static_IR=98546b7eda390c30f82053a093b5e3855c6dc8c631451b3637eadf95858af2bb_Device=CPU_Config=() +1601:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=acaf36c12445c608b306074ac4e2be9cfde2f5550905993d4b5bd1714dc96aaa_Device=CPU_Config=() +1601:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3eb4c7774dc1ab314492cbf1475d0c47d4138ac05336b249ab5e8588eb7bb143_Device=CPU_Config=() +1600:conformance_Proposal/ReadIRTest.QueryModel/Op=Proposal.4_Type=f32_Shape=static_IR=b169d6330e4006909e4deaaf78b03e789ccd9538c5b59d9d41e05f878bb60704_Device=CPU_Config=() +1600:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f257b78ff2b8efe8020b7e6f23c5e75ed7a3e752bfc44c69648b3450169a9f6d_Device=CPU_Config=() +1599:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f6340be757a977d5ab8a7c533a56c520f2babe002ccc1ab2537876dc6083c323_Device=CPU_Config=() +1599:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6a8fb5f2948de2436a33999ee2a01e239193c268f61634f1e80692b0c45aa3da_Device=CPU_Config=() +1599:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=edb5dc5a42b36879d5ced77fc2db7d8b331c888534602893ffb277f742da1005_Device=CPU_Config=() +1599:conformance_Proposal/ReadIRTest.QueryModel/Op=Proposal.4_Type=f32_Shape=static_IR=ea8cc682a9a36cc61498573e967ec64d289af84a9e3da1911085b1de4fea4c82_Device=CPU_Config=() +1599:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=776018866cd0a06171706794dcd0d7bb13b5960fd98a66b306ecfac7595feec9_Device=CPU_Config=() +1598:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=9aba412b059ee77c603bebe3e49240d6f2183168002d25bb7bfe62f1224be2fd_Device=CPU_Config=() +1597:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=64186bbc89d54f073554e029b8972fbbfba2abce8026a379b7ac3833f84ac9d4_Device=CPU_Config=() +1597:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=57921f181e48af2b294b923633e457650e5ab2a9ac7f5d4d07930974ad5e03e1_Device=CPU_Config=() +1597:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=9a92abcc42e0ede56b448e3128ca970cda68fdf27b553430d6d5c5397b7cd59f_Device=CPU_Config=() +1596:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a4e73a0235c7b64a58687dbaaf8530e902e4d714a509dc9fc3ff499467c2fd05_Device=CPU_Config=() +1596:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=625213da165aa2bc036bc690db1a2dd0630d6baa20a5c79e26d52aa2abd97557_Device=CPU_Config=() +1595:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=139cc84777f1e0d489245d058877303e72a93eba3cffbf5f919de21b4514bb0d_Device=CPU_Config=() +1593:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=8f7dc81bfce05ce39b694fe48197a4fd2aa7933c7061508be3b9dfefef518f75_Device=CPU_Config=() +1593:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=817b3db8f96297276bc70f1b4854867cb92c164925c9dce59a1d054e3c315bee_Device=CPU_Config=() +1592:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=85d1eaa250a32acf89b675cc50f513ef3c7df50ed9d68f2cff2fc89db41b63f2_Device=CPU_Config=() +1592:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=033c6bc337d14053ae097dcbee99ef5de7cb7728b589cc8d64783467505a8ba7_Device=CPU_Config=() +1591:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=c1c38223834d99f4481cb74db2bc302710629de5807b4f08381fd01655b9d44a_Device=CPU_Config=() +1591:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=62b8aaf25e8c93387362b0c657886c31c39a7330cf3455486b8943a1e375ef5c_Device=CPU_Config=() +1591:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a7d9ffa60c8d1f330ec303edf6a6c0f8d8e0fe8657c561431bfb91a94c2639e8_Device=CPU_Config=() +1590:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=621c7638006b03b7c4ca5de04ae4823584c9c348cc40eca0076b898b72247e48_Device=CPU_Config=() +1590:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0bfc53d275267687d8d081e1b2174196a0c1aa18bab9ba84a08fe1735336c42f_Device=CPU_Config=() +1589:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=47276c4baef1814b69d8ce1a1353b2bdc02ead92a476e9d278db1d3093c5b0c1_Device=CPU_Config=() +1589:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7d12962a8acd41f85ff8ff280e7f843fa1d5ecb4fca79d5d15d0d858dd9617ad_Device=CPU_Config=() +1589:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=6e8dbb054c99609e5aedd642130e867c22091118e0bb7ddd870a66dcfd11452f_Device=CPU_Config=() +1589:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=abd733caa05592feccf41344f138de6625efce4afe605efeea57e0748d7b2e07_Device=CPU_Config=() +1588:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=a1862e486a20c8de71dd94c12a157098ac5f222ba8ba3e1d3edaf9362331e185_Device=CPU_Config=() +1588:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=e7b766e89f08e80fd96ba40dac738561546ca7210c4566b727ca8cb49528c823_Device=CPU_Config=() +1588:conformance_LogicalNot/ReadIRTest.QueryModel/Op=LogicalNot.1_Type=boolean_Shape=static_IR=66b8769b499fa31cfd7545411d16a17b04e1a336bb63a7e907707cd170a30fc9_Device=CPU_Config=() +1588:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=boolean_Shape=static_IR=4da22853b6e4b853fa57b9dce8f5a26920d079a74055831d651c10f48ee96e8f_Device=CPU_Config=() +1587:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e32d74280a8000202346421945e400d248efb3d72bb67473f81c7a2eafe86fca_Device=CPU_Config=() +1587:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=474c6273d1e48e8e5885966dc93629ad413683ad942e3101452c1a58fb5b5af9_Device=CPU_Config=() +1587:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=3bfc4cff938f4386af23d87ce10f8680a62a25ce1fa9178874f212edf45ee045_Device=CPU_Config=() +1587:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9ad22386a62ba639f3d766e8b6657e95fc12bf94b237edf7f75a3062425bb899_Device=CPU_Config=() +1586:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=4df317952d546ce966e5273b7fcc7a611c641b1cddeebc74d1b66ea80567ee89_Device=CPU_Config=() +1585:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8596cca11141e34e75c884b1be9a75be19663caf4c0b1b4275f6035a73d62e_Device=CPU_Config=() +1585:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=d3155499ccf835bc57e4ca19c25ca32fc63ecede0a2c43ab2a3e43ba4a6a4dcc_Device=CPU_Config=() +1584:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=11f515fce08428a29e672f25127e81f6388202d9e971704738d7fb758a615a10_Device=CPU_Config=() +1584:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5f18fb02adfd683f379dd5a15d38f01cf744e6940754f6a40e2646a1d9c97be8_Device=CPU_Config=() +1584:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=dynamic_IR=85a35059512fed9e0c70cdcbd5e73c1e247ef97821d5193cbc4f7f7c3ebbaef8_Device=CPU_Config=() +1584:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=d05c1b7fcf976117a23e0284998d9ce21689411ff24530175787f1512ca25879_Device=CPU_Config=() +1583:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5ba879b46e93286e4c880a726e28d6956a1c8415508733b5349079f899462679_Device=CPU_Config=() +1583:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=() +1583:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7b9adefd0292959469751e813a48fbcefeab3ff1f4b93329783c1b4c6c14a053_Device=CPU_Config=() +1582:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f1f5ced67e3605021d51e7e29d94b4f0fc3ac4542f527f8cd437f44859981e83_Device=CPU_Config=() +1582:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7bf0600f459cdcd8d44b0cee600efd18d2319dc459d59314af52cddef6181aa4_Device=CPU_Config=() +1582:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=bd927dd60e7b65e84d03c2c01d29c6932961f801bed1312124c2212b5e22a921_Device=CPU_Config=() +1582:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=1f7f2d40b938416773b13282d8ac09d81a50e4d5d7548f42fc5fd575f84e1385_Device=CPU_Config=() +1579:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=659cd025e440fdc633859089f52f7f38cab5701c63c79d1e8d1837c217b8cf75_Device=CPU_Config=() +1578:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0849107336e2dcb62f494696f297a85dec4fb5d71f1f9422313faa5c23ae4cdd_Device=CPU_Config=() +1578:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i32_Shape=static_IR=53f0fb6a39e6f296be9d041e6caf93cf34a3916218a07dddacf4985b93943ae6_Device=CPU_Config=() +1577:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6af32fc288bcbd414ea63525c4345aeda74ab21c44aab5910f85b8b7fb5d1179_Device=CPU_Config=() +1577:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=06c968fe2f2949b4262f4f600b728609b2c2a389fc5fb02bbe4764da6caef616_Device=CPU_Config=() +1576:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=246f55d43a6e986a8ba35f711c43dd32cfb1ca097598b0a01690d4765e0d5019_Device=CPU_Config=() +1575:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=86decc829c047a5febe7e5d047c689075810441a2f4725088317ef68d6c31239_Device=CPU_Config=() +1575:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0d40552a1b6c1945765ada16284a0c03f5c1454fb12f226a34dee8a07b14f17f_Device=CPU_Config=() +1575:conformance_NonZero/ReadIRTest.ImportExport/Op=NonZero.3_Type=i64_Shape=dynamic_IR=31f428e60ddfdb3cb3c98c2cc858d0409fd35c5e6e97f9dcdfbb20a876c475a6_Device=CPU_Config=() +1575:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=c4d1a1fdd0a336620be37a8ce7578ca0dd0c74f89fdb32ee86e7004792aa8445_Device=CPU_Config=() +1575:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=d98330d8f9f03556036d103fb4ca3f8436be42fa4f0b21b185aaad3abb2fb53c_Device=CPU_Config=() +1575:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e0ae8d59ba587db8057e6d8a9304e9d9b946d338db08ea5311182b6adfed4478_Device=CPU_Config=() +1574:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c531648f3b5841ad892debb2fa2eab6ef35a08d0cd5e9d33bc0a7b442a1fc707_Device=CPU_Config=() +1573:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=bbf75e5f7aa9f20f890a8eb204ddb5f159ca5eae0616fb99ee0b5169b165d595_Device=CPU_Config=() +1573:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=6dae5ccb2325826167ff4ec57e51280b4e125801e6405a33f4d95fd9ab9f3fc5_Device=CPU_Config=() +1573:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=05f8a9ef1ef4b191dff5dedd1fa79abad9603ee87a49306ad26c5d20ad067448_Device=CPU_Config=() +1571:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e62245706f4242ff86bcb70d4d221bf49aa31db3807698d574125166bff5f8aa_Device=CPU_Config=() +1570:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=2c5e9a1cd59ec2d5786132697bfcb1519a7857cdfe06038bb39abed39c09e9a2_Device=CPU_Config=() +1569:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ef7c3b91bb41e1db1727794a0435bfa5f38d194b9457d94abf9c19776174ef60_Device=CPU_Config=() +1569:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=136768c6c28210cc47eacf6667103eac8106e3f255618e067d351cb700e62cbf_Device=CPU_Config=() +1569:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=1bde2f2a7294810531e23de80f25a451b3033487b5919c949b708b273dc3973c_Device=CPU_Config=() +1569:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=ba4f511cc4a0870c64cc5027fa39b2bf91a6e7f39ea36cd43a693eb59de6d836_Device=CPU_Config=() +1569:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=1c6cbe8477d09b0b193ddf9a453c1b6a8a79e3d1adcdf1c096709cee7a4866db_Device=CPU_Config=() +1568:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=dynamic_IR=c838ac42d5464130a9049a63f7020166b34e2ef974c257a4060fa02c3b70ff76_Device=CPU_Config=() +1568:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=33d84638f606d759354e190991899e47d2f4c63b0e378aac985e5fb9132dcd01_Device=CPU_Config=() +1568:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=99820651f05bae979a287a8644f1b739637d684efad288b48044c2a664e43a3f_Device=CPU_Config=() +1568:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d43dd8a9fd4a11c5383a3ea9545967aa0e330ab33dc88a0754c84fa63641dc6_Device=CPU_Config=() +1567:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=9c1e1b695646ea4f56a87b7e5a815c12856f718920e01e86ed78f2dcaf896a37_Device=CPU_Config=() +1567:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=ddacee38f2bf3dd45ddd36ba236440ae28b9737487e0fb186c2b9777c0b557e9_Device=CPU_Config=() +1567:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=() +1566:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d82f645d11f396433cad131e1e490842c14fdb9e439d93fb9425752b6a3aff09_Device=CPU_Config=() +1566:conformance_SpaceToDepth/ReadIRTest.QueryModel/Op=SpaceToDepth.1_Type=f32_Shape=static_IR=9296c80cc93d8ab7448140ad2f31b3b47a0759c383d1bc045704985503732195_Device=CPU_Config=() +1566:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=b39441c49977534ef3b2d1c4a9d7a5a0aedd66c7ba0a6e1be3446151a8e18317_Device=CPU_Config=() +1565:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=79e8f7fcf25912270ec9b6d16206e5f54a678fbd174a31781524e7a976e500b8_Device=CPU_Config=() +1565:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0fdf62ef06a0a9225c0746379b89495e737a2e5f95077bb92600ce14f19fed40_Device=CPU_Config=() +1565:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=b6984001a616b3dd3ef4b835b2dc6a48bcaf8882bfde7761b4e141733364f66a_Device=CPU_Config=() +1565:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=() +1565:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43e52f7bd4989711336d4aa524aff731d1f968eb65e8b5e07e1a16db29e55337_Device=CPU_Config=() +1564:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=767873fb6967801da9fcbc8dda360a2d30ba207cb97cbabc82a509799c40a882_Device=CPU_Config=() +1564:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=bc90fb9a95a74efb937b6cf808584dd1e91aa6c4d774640b51f4325f0aca6b42_Device=CPU_Config=() +1563:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=static_IR=7065a836f4fd77a07431ecff6bcc591ef9b0160cb5366a8f3c8b8fe5f83f7be1_Device=CPU_Config=() +1562:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8710c3eaa10d25119059f4e15970d8a6381f978cd905fc8eb1b4d43a36d1d5f6_Device=CPU_Config=() +1562:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=dynamic_IR=848de524e27e13a1e5b33e5db3cdf2710ba4566c3219a018e878f998c07dd718_Device=CPU_Config=() +1562:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=ff96b044b0064dcc13dc7c1d80f2b2cddde0ead8c4501d5d741034833079d47b_Device=CPU_Config=() +1562:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=i64_Shape=static_IR=32ab4bca2ccc66d25b8b9ac449dbc58666434d98aa5b789e1aa28726c530986e_Device=CPU_Config=() +1562:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d7ce9fd9d99a7ce9ebb5fdadb4db39f4ea66f74788704b2b9f96660c7403c031_Device=CPU_Config=() +1561:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=4892263cb1ea7a434b5771aa16f07885c39710f67fa1411dd9235653a6b8622c_Device=CPU_Config=() +1561:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=dynamic_IR=33e67497d576ce6af4a214d55862646d034effd328ef5beed8d7b0f380b6b689_Device=CPU_Config=() +1560:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f0ea143c11c6a4cda8cfcc01f0532c256b592f807ddceebebda7e9eb8f01d919_Device=CPU_Config=() +1560:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=47276c4baef1814b69d8ce1a1353b2bdc02ead92a476e9d278db1d3093c5b0c1_Device=CPU_Config=() +1560:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=564cd54b2564c7e39fda0c5e580c274b7bf99603760f6c66f03b4450f23cc4bf_Device=CPU_Config=() +1560:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=2b927ee73187f1c1cbdb071ad3c0a72c9eb8a8631f2e7c6c3a8f8482c301fcf3_Device=CPU_Config=() +1559:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=7c1b4dfda36336bb1a943fec9786d89e220f2a811159fe9cbed7d51186f8fdfe_Device=CPU_Config=() +1559:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=() +1559:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=27e8804992c0d74c18c958f0876c06be6c7eda2b36fe7de3ab616b577dce13c6_Device=CPU_Config=() +1559:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=c98e1e2347c7b6939804dfcfcebbbd57d4c05e8d13b35b2611912290d06107ff_Device=CPU_Config=() +1558:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=19a94fc5cfe3ab1b4e169b342ec8d9f0fdc4ef19484c8c34d6ab938c6e7bf5fd_Device=CPU_Config=() +1558:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d7e3ea8c5ea46f1b0430b6a2763c85395235c0ac58652e1d269e1257f6dbf7c8_Device=CPU_Config=() +1557:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=49a0769fa4a26b3277c225f015ebd6b3bff05f8ab05b271a4fba7ea5a7e57396_Device=CPU_Config=() +1557:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=i64_Shape=dynamic_IR=84a8c7a897894ee6bb1c03759bced74ea6d773a2cb8335efdc8d193a534f3833_Device=CPU_Config=() +1557:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=59d58e41f9b928f4ea5563a09f847b2d2a5b709267e3a0c03ac91305e0c2b0cd_Device=CPU_Config=() +1557:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=() +1556:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=dfb16811d2a3986853d6e5ac937c96cc89e47e20bd3eb443142699dd62ba2890_Device=CPU_Config=() +1556:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=2233a83397f11ea3c674c4845409c4f27f8bffbb8d0295712a2525c9e93d6041_Device=CPU_Config=() +1556:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=2b6ad903c5efa29748d41521e0e0ea3c8d814d7de54f7831f0ea12602f265f0a_Device=CPU_Config=() +1556:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=b9f9ac285915db9ef3e7437728695f2833d165757ffc81afb88242e7b471f434_Device=CPU_Config=() +1556:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c21dacbc3d52b5171ebbdb769ee8869a2ea44f1af241b861d0adb92ecf5028cd_Device=CPU_Config=() +1556:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=() +1556:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=718269cf894ffbb59c15a1c688fd7bf726a87899dd7ef6dc0c9c8731f2b33293_Device=CPU_Config=() +1555:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5f2924e748f389c659aeeb2dd9899519d96db396695abd625520a5ec60d6ba5e_Device=CPU_Config=() +1555:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=22dc864b06ef0c7deb8aecd74a26c7bcf75eee316288284413fb61381d79425f_Device=CPU_Config=() +1555:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9c15338e53353041d5e82067a4aaf56dde40144709b2bd04d86bbc7ad22b525b_Device=CPU_Config=() +1555:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=7a1d8cbdb446c3330ed845d7a81e20d9b7c7662d532f4d816d4fc1c56822fa81_Device=CPU_Config=() +1554:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8584e2e87ecb2b209221a133f2e3761834562a7b74e7cebe203759f3bd5d40ec_Device=CPU_Config=() +1554:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=810f13adb3f7342c7d514bec2aa3f20d7a59527b54c7f6954b038efb194c5ceb_Device=CPU_Config=() +1554:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=66375ff8539da6387946c19b0d20e6b4fd57da25150255e41282458e241963a0_Device=CPU_Config=() +1553:conformance_Swish/ReadIRTest.Inference/Op=Swish.4_Type=f32_Shape=static_IR=d79b47022a50437c9df095b34e515c53eb042c9813fcf6dc7bcdb96962818ddf_Device=CPU_Config=() +1553:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i64_Shape=static_IR=def60f5f3fb7a0d22cb3d23253e7c8e502aa9dd2d3756c54dd4343b66c2682ca_Device=CPU_Config=() +1553:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=f7e1aae2dbc817ca8f64a6bb0742e476055c239cc6e31a4233b7580205feeb41_Device=CPU_Config=() +1553:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=fbb85f74ecfa0ffc50b9e6ce637911b406f1fd6ad054a886b9c6ddc6bc898739_Device=CPU_Config=() +1553:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=447c546ed54e81edcfea77cafa8d18261923bf25c050666029828ea72e3a875c_Device=CPU_Config=() +1552:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=dynamic_IR=dac2c804cd13d69a51906319a3648ac0edd87764c686c99fb47179f379cecf7d_Device=CPU_Config=() +1552:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=29c89ebfa45163b40be304d7bfc96f3068cd96175db94e6ebda942d3c4af538f_Device=CPU_Config=() +1552:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a1e0bbe02c433cb144b4825a9f1b2c30c03743f210830db5462736850b6db383_Device=CPU_Config=() +1551:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c9f0deaa217fa8ad54eb9662bb6d181f7b578008b5c8ff445db32b60ec61b185_Device=CPU_Config=() +1550:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=a58fb7847e59bb119656b143af0c6f65e29f8211034fe7aab03666cdb95d7fe1_Device=CPU_Config=() +1550:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=4946bdb7dec06c2bc8eae33d5903d6fa41bbf3654b13a0cb5cfa4af5a4720426_Device=CPU_Config=() +1550:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1b0fd4a9f8f0e48f90969f08b37568a86ed12126d15ed17492cf1f241c5a90a4_Device=CPU_Config=() +1548:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=59d58e41f9b928f4ea5563a09f847b2d2a5b709267e3a0c03ac91305e0c2b0cd_Device=CPU_Config=() +1548:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=() +1548:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=6745937b3d592b8cc1729ab2af1888ce58502379a33f0ae5d5a3eb0e70c0bc87_Device=CPU_Config=() +1548:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fb5525d36d14f54eebc5670c06232ca4e32cf920d309b5777e37d3377d386433_Device=CPU_Config=() +1547:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=597a8a56fae623dd0684f6e4040ffd6ce90166e43e47adbcbcedf1dc5136ec23_Device=CPU_Config=() +1547:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c90b6f528b750f144ddd29be0059c202d46b3bac799c0d70893f2f4f9f05f64c_Device=CPU_Config=() +1546:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=9f4d316675c933ea5d6511324e3d664440a8ba287cb2ffe768517f9cbfb613e7_Device=CPU_Config=() +1546:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=i32_Shape=static_IR=5b9cbac8797158a77d5616e8b7e5d8132360e23e26d31d845f0d129df7bfd7b5_Device=CPU_Config=() +1545:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4746fb4d92aab20d21eeb0885d35c88abd50aa250298473f5bd143658eef2316_Device=CPU_Config=() +1545:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i64_Shape=static_IR=def60f5f3fb7a0d22cb3d23253e7c8e502aa9dd2d3756c54dd4343b66c2682ca_Device=CPU_Config=() +1545:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=3c7c072c9e4ee694e049a5f256cf0e72caf85384291ee8d399ce136d22c575a3_Device=CPU_Config=() +1545:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=a5a2ba7fff85401feb05248462e85d334440769790e7e6ba1a75ffb413f7fc64_Device=CPU_Config=() +1544:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=dynamic_IR=8c78da5f8bf9c1a4cd7f89cde9d61eb6500fa10ea0454e36a585466ed97fb12d_Device=CPU_Config=() +1543:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c1f0b881be142016d55c77178631a9861407f9c3f889e58c64924e84c039252e_Device=CPU_Config=() +1542:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=6e8dbb054c99609e5aedd642130e867c22091118e0bb7ddd870a66dcfd11452f_Device=CPU_Config=() +1542:conformance_Greater/ReadIRTest.Inference/Op=Greater.1_Type=boolean_Shape=static_IR=dce38966c13ac9886c7480261e3483d822355a9bf3835d00795e7627744a60d7_Device=CPU_Config=() +1542:conformance_FakeQuantize/ReadIRTest.ImportExport/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() +1541:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a956d2fb1fd17e2d864b3eaa8915cc0c4f9a768e35fdf5bf20cf6bc7f41aa130_Device=CPU_Config=() +1540:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7af359181d29634dc797b38c2defd26a52a70073a59a7d027ebdd752b4011d15_Device=CPU_Config=() +1540:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=dcd71a51a6682c9bc461a6cb72d59082352ab8a020e1f79e64c3cc44a37b55ba_Device=CPU_Config=() +1540:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=6d5907929d59d1f99e85183238e29d6602c84721d099284dcb8900ae5fc3c45f_Device=CPU_Config=() +1540:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=b16650eec74ddd46ff3bffc9eedb340b6bad99a338fbe6b11f7eca3098a324d2_Device=CPU_Config=() +1539:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=3801fd5b86bf772977c131734d8356c8dfa41b9056091937473be600e332fbee_Device=CPU_Config=() +1538:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7f5e90bf4696bbe503abe4ed3337d44ec48775276b9fc9b10e87e48e788b2fc7_Device=CPU_Config=() +1537:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=i64_Shape=static_IR=7adee81cf21b942334c25378325f61e13e9ee3ac95ae004d4d9efceaab6c0949_Device=CPU_Config=() +1537:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=fbdf008803736374dd213f1d7e0a041fc0e9b3f025c212a588fa05842ee5ee56_Device=CPU_Config=() +1537:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5953b8e79f64e33e67dd330999ff8e3d8391c8f3fa7eae519b117b1273c8c19f_Device=CPU_Config=() +1536:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=aa757ffed4165beb3074da6ad09422d7823a1d0d6c8a654adc56343d0e43dc66_Device=CPU_Config=() +1536:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=cbd1111f323b8e6d78b59b531708defef64b90463f973f64f52251795ac5a7dc_Device=CPU_Config=() +1535:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f3dcab6635e317bee634addec1b7f9664b2f801810997519ab06efaf1d869f81_Device=CPU_Config=() +1535:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=cb2f89380861307422024c308f636e33a827f32a721e54a380fe2b1c1b74c881_Device=CPU_Config=() +1535:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=() +1535:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0bb9a29f02d37ba32dc29b4284f58e10ce59571799f58381d449c77655c795d6_Device=CPU_Config=() +1534:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=1c91956bf0130fd338f8f11cf76a08dcf5fe3c6c42239fa6a6aeb517eeabba36_Device=CPU_Config=() +1533:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5eb341117f8535a929c96a55b0a932c37b1254f07a03af2a05a0862c7c2675aa_Device=CPU_Config=() +1533:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=39b885728130b88ac11ea98537acb5a081ec3a27e12092f3bfd8776dae1da93c_Device=CPU_Config=() +1533:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=33d8f6d258ae8dfd09b8e6fd39f0e74384eabfb685e0e72a3c798101ea56a1d2_Device=CPU_Config=() +1533:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f55c473236715e5c4e6ec21a9e07d1c73b14d529b57fae0cb38ef9d6cd383b53_Device=CPU_Config=() +1532:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=554cea5d4f8f21234b429ebe1c4365bed5b6a6a309da5d607b45b301beb90828_Device=CPU_Config=() +1532:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5288d099588f5876e907c5cd750c9f0b2191d1ea060881e80af1006cfad259ac_Device=CPU_Config=() +1531:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=858bc9246515c70bfc3ea024102604566e53cd6f618059fa1f6d0046d0de9565_Device=CPU_Config=() +1531:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c03bca3c44df7946fcf273e9d79309b7bf33b465206eb9caf76750735e1ad19b_Device=CPU_Config=() +1531:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=48a273073ced3efa39d01e5ce40c30b2901e8a3dff0b414911282b8fdfc0b09f_Device=CPU_Config=() +1530:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e6724e0da81e65cac207d53f3b792b046d3d6dd47230a7cbe0a690baa9f59306_Device=CPU_Config=() +1530:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a8f0d5db2a6af7cd4d166c066f3d987d7a25edbb3047fd26551e1b68d9c179d2_Device=CPU_Config=() +1530:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=206184d6fe0a3ab9fe71914c66d3804e145caed7cf3ac09cb1d50183144d6ac7_Device=CPU_Config=() +1530:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=4212a754718adff414309fb1da18c4361792b5478366bfdc0994490c7bc716e3_Device=CPU_Config=() +1530:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=bf7feb979b2eab03afc780965804a3f6b8471b574c36125654fcaf3ebc2c30f5_Device=CPU_Config=() +1529:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5c0ed2041d97a9387b2c2f31ea1f5ab3e98edcaeda47d184555677418853dffe_Device=CPU_Config=() +1529:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=66abbc2c605a0f866880bd4730865ae6b5401a1f4beb242f346bf6f2f8138eb6_Device=CPU_Config=() +1529:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=21a3318957d920b39d8b3d84c76cfd2a5ad98515824f88145326deead0961486_Device=CPU_Config=() +1528:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a8621125339b6631e3531d8e34fd54da8bad6a93020ae127b8da46f72e07bf3a_Device=CPU_Config=() +1527:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=e9539332df9388555564db1da36679acc7b505b8c1fa687731f2052999bfe1fd_Device=CPU_Config=() +1527:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=9aba412b059ee77c603bebe3e49240d6f2183168002d25bb7bfe62f1224be2fd_Device=CPU_Config=() +1527:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=66df22ce11e7009aea35ba6a11b4294eda44815bf041eed0721499a3d2c484b1_Device=CPU_Config=() +1527:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d671a241de6d46bd5562def47a92602d2c9ba076568feed303765168433ee89b_Device=CPU_Config=() +1525:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c789d40bdedf25bda58d6d6ce2f690850ec42ff8712abd23f7947a8604b6953a_Device=CPU_Config=() +1525:conformance_SpaceToDepth/ReadIRTest.Inference/Op=SpaceToDepth.1_Type=f32_Shape=static_IR=9296c80cc93d8ab7448140ad2f31b3b47a0759c383d1bc045704985503732195_Device=CPU_Config=() +1525:conformance_SpaceToDepth/ReadIRTest.ImportExport/Op=SpaceToDepth.1_Type=f32_Shape=static_IR=9296c80cc93d8ab7448140ad2f31b3b47a0759c383d1bc045704985503732195_Device=CPU_Config=() +1525:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=13c78a6d628bed4392d2577f132f924d9e17a7e29a2171dafebc0a596d2ade04_Device=CPU_Config=() +1524:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=debf36fea706c02dc67354edf761f0dc931ebcccbed285f186164fc4b9532766_Device=CPU_Config=() +1523:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0031aeefe417dada5913585ba3aaf8d0d79706ce509a7cb72ab3c0e9b638d46f_Device=CPU_Config=() +1523:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=07cc41d5a7be27466beff227bce7deae470e9bc82d30963618d5279c646d0b04_Device=CPU_Config=() +1522:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=74ea1727d6d5474136a87786b87f5a9b8923f78ef72d52a0fe9a39dd7d3a293f_Device=CPU_Config=() +1522:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=ad5c5df7cea37955709ef71d9967828ce3f0011e68aa1c6085984f1422944058_Device=CPU_Config=() +1521:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8971df6b980fb10a4fcc262ef6d3616ee0b0f32841dbb8a4869eaf5848243fc0_Device=CPU_Config=() +1521:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b65d46a8038b26d7ec9a5691744a9324aecf33bd3e89152e5f5c067ee4a56606_Device=CPU_Config=() +1521:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=874c0fa19029457645c4cff20769f66ba7aaa1a35ade84c948f83aaa9c1ead19_Device=CPU_Config=() +1520:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=ed75de35729f20a3285506937672f78d2d5137851a3043d15f4eafc040768fc8_Device=CPU_Config=() +1519:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=b94d2ed6a2b113922805a69578ec5ba2ba3d8f0ea46ca37f095b4ccc94d76b77_Device=CPU_Config=() +1519:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=a6b0532b200874d6d1c57719b46f2b301c368ebc35042df00796dfb87eed618b_Device=CPU_Config=() +1518:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=be944d418fd21f00271c405c19022a5e0f2be06fb973cd54ba8bd2610d02f0b2_Device=CPU_Config=() +1518:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0783bb527f80cd61cd46b7bc7ec93ca0cc51ec61792cd0fea8eebfbf121ad5bf_Device=CPU_Config=() +1518:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=707190f77491e910ce61476cd3a9d5dc275e7c5ad820cd3894a37c348c2995ff_Device=CPU_Config=() +1518:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=8919e05ab2b0d545cabc2e2732828fa693c8f364e9d4d03faf7097f787d4f628_Device=CPU_Config=() +1518:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=d9231cf5e3e491e318f16514e771cfdee4b781b42fc9d45088da850ab48079cc_Device=CPU_Config=() +1518:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=i64_Shape=static_IR=e8fc48c9bceee1462572c6aa8c5afbda94a9d6e8760deea1c9a3d04d1d797fb5_Device=CPU_Config=() +1517:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=a5dc3f8dd6385eb7f6d4052af82e27b7af7e8a58bdcb6092ec79ea3087f141c6_Device=CPU_Config=() +1517:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=() +1516:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=ff96b044b0064dcc13dc7c1d80f2b2cddde0ead8c4501d5d741034833079d47b_Device=CPU_Config=() +1515:conformance_Round/ReadIRTest.ImportExport/Op=Round.5_Type=f32_Shape=static_IR=f4cc9554ddbd189f18575e3a80afe6e8f8bce613dc8852a48d4171ab6916e087_Device=CPU_Config=() +1515:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=12b6ad1cd462f676c9add533f2fb2a5d98698e72fc5d0e6dc984abb27f54475d_Device=CPU_Config=() +1514:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5ba879b46e93286e4c880a726e28d6956a1c8415508733b5349079f899462679_Device=CPU_Config=() +1513:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9b3e0ee4798456a9c4e3702faa07c17887739405c56f00425ddd05cfc8ab2a11_Device=CPU_Config=() +1513:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i64_Shape=static_IR=38f6cef69f6a7d9886b5d38902fb76e4ae41385fb3c95e229be4b44456ab2e87_Device=CPU_Config=() +1513:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=bf7feb979b2eab03afc780965804a3f6b8471b574c36125654fcaf3ebc2c30f5_Device=CPU_Config=() +1511:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=997a090766babacae10464bab19af5db238eb28704c6d463cfcba48767a90c8b_Device=CPU_Config=() +1510:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=c7a696f3217515ef4ff5eb46fbd15af6533f0fcd268398fbd434f105c0a11328_Device=CPU_Config=() +1510:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f13ce39b60cc25991465a0c02e27edcb35af0523cd28004adf6fd9acd8a5fcb8_Device=CPU_Config=() +1509:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d4b1dbc565a45f6c9f60cd4a73bb15c0f9e05baadfd3acdcd5e133d782c54cbb_Device=CPU_Config=() +1508:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=28cabba0fd0acde452552a362925344e8cd8c5af033419d83041bf26b1d14d69_Device=CPU_Config=() +1508:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=70d4da84623a0af3bc8362a828bac5ef13285498b420a3df6bf2e88bf05311db_Device=CPU_Config=() +1507:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=78069dcce6d7d8dcb87e840286aabf2c6fb8727525b625653096be38f0291101_Device=CPU_Config=() +1507:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=0832e6deae4ceb25b92cdfa532fb5d5fadfe7fd7a00b79f630ddb5bc011986ab_Device=CPU_Config=() +1507:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=i32_Shape=static_IR=a142d6fb0ae0c0decec2ebeba376ed65852e1c60b1c1abee7bc574d5ef3a6a3e_Device=CPU_Config=() +1506:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=d5f5f2d39bfe4ccc6f12f76e5eca8e2e40ac7ac6c5f38a7cac21970df213d4cc_Device=CPU_Config=() +1505:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=538935936007865ddd2f8ef5f2a5b1eb0e7a372163b2f13e068a3309374e19c5_Device=CPU_Config=() +1505:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.1_Type=i64_Shape=static_IR=26d97c755f660ed8ee08a0de8d6ab88598391cc79b239bfaf0a102722ffc4bf7_Device=CPU_Config=() +1505:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=060423427a9100b6a38aad12a83043441f8af436c1d2502350ae867f45bd721f_Device=CPU_Config=() +1504:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b062486251781b09e932268862ed34f7a6df71ce15ea598ef5344f04f88c006a_Device=CPU_Config=() +1504:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b53fa2c9b93d3750c17dfb8ef75e51c43881ee79fddc863d6c1c2adfeaeaba2e_Device=CPU_Config=() +1503:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f64b683dde6fe3d8d6ae0734a986a290edd10869211c7a8c56eb51c170f1a231_Device=CPU_Config=() +1502:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8d8b631421fa4d1ab70cc2916563550c0823dcb04267b3c50b23f3f245e45d98_Device=CPU_Config=() +1502:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d42498673c5356368f655e549ed67f3f43db8730ba9449670054622d361326f5_Device=CPU_Config=() +1502:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=efbe921ab3c27a093f20ff704fd02e5c610e7507d94a2d2092379c5a99743380_Device=CPU_Config=() +1501:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c90b6f528b750f144ddd29be0059c202d46b3bac799c0d70893f2f4f9f05f64c_Device=CPU_Config=() +1501:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=6ac457e9181610da9eb4bf0bec6cd53bf3078e0b84df1211f49921207d81c6e9_Device=CPU_Config=() +1500:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8a0e61f6a4798574ca428449e75e3f3cda5bd116975466cff3733cbde1a2408a_Device=CPU_Config=() +1500:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4b00183255fde45d5c3b815b552e5a4279284bfe1ceb31389560260ad5546c14_Device=CPU_Config=() +1499:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=5b1fc9693e4e947bc88a88bf1ad22ee2f59c13bf291626eec3e8ed49b0cef7ed_Device=CPU_Config=() +1499:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=() +1499:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d4f7d35516f95fa128d0cc3d63ab95c2dba96c29977a88a6573d5e90c3b89271_Device=CPU_Config=() +1498:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a9571d2008f31f55a7c6eb83a7249f5b8bc973bd05b6a845fdb56b15db7ef7fc_Device=CPU_Config=() +1498:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=d683b96d525bc074d4f8c15934a5082a3fba1068b591f67e4b05d605fe5e6aa7_Device=CPU_Config=() +1498:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=dynamic_IR=43ceadf05184954dd8697d4f737de323ec2ee75f93e0d33d60dab2acc995f3b6_Device=CPU_Config=() +1497:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=c4d1a1fdd0a336620be37a8ce7578ca0dd0c74f89fdb32ee86e7004792aa8445_Device=CPU_Config=() +1497:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=7293f99e38d76387b64632d06503c539c369e1ab78d9388e1af42d7071d8230e_Device=CPU_Config=() +1497:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=98a6da6e0972a1b70caa5df788a6921d4e470565dc3880faa59e913fdc15f460_Device=CPU_Config=() +1496:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=39b885728130b88ac11ea98537acb5a081ec3a27e12092f3bfd8776dae1da93c_Device=CPU_Config=() +1496:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=08ba7fbf736896f373ea81dd727940aefae22a39e217e84dfc5617ed62133d10_Device=CPU_Config=() +1496:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4bedf955c6ec574258a05f59e5397225e1360ba68ea49d4fe105d6a62ccb3e97_Device=CPU_Config=() +1496:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f51b532391477cec9e0af4bafffe72a630e2f9f91265efa4f491d516190fcc1d_Device=CPU_Config=() +1495:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=86c848e55f2afda40170f7cfcc9c260f896ebe2c73819f75a124dcb67cdd6a75_Device=CPU_Config=() +1495:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=008827517eea396c81f651f8dc2f2a43e2cf000f96e28cc8eb0ec7008f1e11e3_Device=CPU_Config=() +1495:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=63bf42d0ab3a502b446b21489f7320d954a2f4f00a1e11da7d9b948fa1f6cc90_Device=CPU_Config=() +1494:conformance_ROIPooling/ReadIRTest.ImportExport/Op=ROIPooling.2_Type=f32_Shape=static_IR=556c6863ca3b12d255c4c81d92b4573203f02c5588e064fb22dd4aa23c8283c6_Device=CPU_Config=() +1493:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a8ca0b23e0a0f66247fc693c6a8982e4f7daa11e14da296db0dbc9277fcad4df_Device=CPU_Config=() +1493:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=abd733caa05592feccf41344f138de6625efce4afe605efeea57e0748d7b2e07_Device=CPU_Config=() +1493:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=362638bf065f1917d2b4dac3008a8f46f8f8d64a80d2442c1ad98f4fb943cff9_Device=CPU_Config=() +1492:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=122bf99a807265c6a41a3940f305a6855ecbdef6e03540cc958e1fedaeb06488_Device=CPU_Config=() +1492:conformance_NormalizeL2/ReadIRTest.ImportExport/Op=NormalizeL2.1_Type=f32_Shape=static_IR=e177da00e93cb595c18d142e92898135415f0de01a3b1ea763f3ffef3d7ce96b_Device=CPU_Config=() +1492:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=80e0900e8270dfbd0fc879ad4d065847f767cff9399688bb9e5e03b8531c554e_Device=CPU_Config=() +1491:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=2d6f6b955cd431e0f4786aae35f5a1f7f69a6b627e88c42643ded0477f1cfef7_Device=CPU_Config=() +1491:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=6c1aeced5aaaecd99f3917a0f38e01902dbe81614ae4dc9a99fc09a379990abc_Device=CPU_Config=() +1491:conformance_ROIPooling/ReadIRTest.ImportExport/Op=ROIPooling.2_Type=f32_Shape=static_IR=1a0e3f63698678d2e6bb8968fbadc98227d9ce548e77c53021412d80d7711753_Device=CPU_Config=() +1491:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f780e2914ea358c4b9c3775e3d4876ddea5efb96ee43545cae2592db34bc9d54_Device=CPU_Config=() +1490:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=424814fbe4a3ba7a49c506f11509c035212fbdf4ef44fb2bc708c5f201e4e1ec_Device=CPU_Config=() +1489:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=() +1489:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=e894ea68d25e2a0af6fe2e330929c3305710bd07aca8e099b727df78fb26cdf6_Device=CPU_Config=() +1488:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ac619545b2ef19185f57aba7a31752da1029c572269af4a3e0d95dec2c9e64e1_Device=CPU_Config=() +1488:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=ddacee38f2bf3dd45ddd36ba236440ae28b9737487e0fb186c2b9777c0b557e9_Device=CPU_Config=() +1488:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=97a94ab826d2992013df32a4f93f6adbc38ad17a26503005046f68904adf53d1_Device=CPU_Config=() +1487:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0c0c04b18975ff24a18715af981baaa3d45e746c73fbc71ecb16eea245197d50_Device=CPU_Config=() +1486:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=() +1486:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=() +1486:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=739517c4c613063fc5ef734443f0a599400dec31cd5a56686735f3165b2dc2d0_Device=CPU_Config=() +1485:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=static_IR=bcb10a9124f9b0471012f9e22d4aed5c2a47a55e652312e8a8382dc0d809a23e_Device=CPU_Config=() +1485:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=707190f77491e910ce61476cd3a9d5dc275e7c5ad820cd3894a37c348c2995ff_Device=CPU_Config=() +1485:conformance_ROIPooling/ReadIRTest.Inference/Op=ROIPooling.2_Type=f32_Shape=static_IR=baa256d53878b528f6bdba95bf1837cc570dd83b577220f95d9c24cb26d37c35_Device=CPU_Config=() +1485:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=ae817dcac1ed2395cc4098f67bf6d2bcbecd8b7e91ef7592622d1ee75ed4a3cc_Device=CPU_Config=() +1483:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=df5481436d81f1468146368ea1fae8d5b80f392bcda640243119a3e639f2b92b_Device=CPU_Config=() +1483:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=de3da71f184001d4023831fe48fe316da81a312cb66747fa283da0c0b101dea6_Device=CPU_Config=() +1483:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6a16663e3760c233a39f49948fbc5e2b41658e0e9fbb86e8a5d0cc16dfac33bb_Device=CPU_Config=() +1483:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0667c865b35e65d521f8edcad5e99d49ba8e55fac0c439ae095cb50de75fe8a9_Device=CPU_Config=() +1483:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=2d6f6b955cd431e0f4786aae35f5a1f7f69a6b627e88c42643ded0477f1cfef7_Device=CPU_Config=() +1482:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=static_IR=8834a8881c2da907f6ae38d4c45100dde754e653f3e4994cf9add141c217c781_Device=CPU_Config=() +1481:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=469a63c5aee73bdefc9abdf8abd8413713c0b68cc098d16c193399a11c7093c5_Device=CPU_Config=() +1481:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=static_IR=ca5d2626f2066e0c806addc4b6ffb4b3a71f1183b93783b92f44de62d82faaf8_Device=CPU_Config=() +1481:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=03c3e6567da3c139c19e0ce0d301a6076b2e2446d191216c7bf38bc030ea7855_Device=CPU_Config=() +1481:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=377acd11b0f7dfb4f3e57baec8a6c8a84737857b7e794614542f139982feaf73_Device=CPU_Config=() +1481:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9cd66958dfe8db471d48d6ea35f1b4547a413fcdc6c61c804a456befcbb09d15_Device=CPU_Config=() +1480:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7fc4d09be462fbd17d4bdccc5c6c7014dad92f58c8999c7e78b7475bbc076bd0_Device=CPU_Config=() +1480:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=683b86794b415f893e4d426a8c68aa38f46c250e4c31bc5f5807a86c20ffb34b_Device=CPU_Config=() +1479:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=1942042c790c3fc6053ad91fa5e45f8ebf3c11bff7e3427a71b8fdc1bc5db053_Device=CPU_Config=() +1479:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d8b8999a17ba375cd8b7bf18f4d9d932fc6f5b6787484633c9b11f6003eb8270_Device=CPU_Config=() +1478:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=10f9a2b62a6505b51206efc6d6fc6ae5aea9bebb43abeae7e0a46a2c6cf50e16_Device=CPU_Config=() +1478:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=73d32deb47a4954f7502d431a3346e456cf3d93c6217c9ab8c5fc630cc4e3669_Device=CPU_Config=() +1478:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=() +1477:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a93352138c144fd004303788d08066d279e5363345d3da2cf16ceb61336d58b9_Device=CPU_Config=() +1477:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ba97799aeb7eeb6f62c2e09e38a2eb4d4a5a9d47712788d47182b3de43675082_Device=CPU_Config=() +1477:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7b9adefd0292959469751e813a48fbcefeab3ff1f4b93329783c1b4c6c14a053_Device=CPU_Config=() +1476:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cbff70cde6194997d0bb4a7fe099d60116085fa72b8840e54f79ac61a5b4c1a7_Device=CPU_Config=() +1476:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=ba1a7c4cca6d39b8bc7be7d52a0680d055e33a776f4048ecf38335a2ccdd8d51_Device=CPU_Config=() +1476:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=b39441c49977534ef3b2d1c4a9d7a5a0aedd66c7ba0a6e1be3446151a8e18317_Device=CPU_Config=() +1476:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=c4e2668f98d5c21fc085695c9b6037f08a1e6710e1854fa73b7465a618e99b95_Device=CPU_Config=() +1475:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.1_Type=i64_Shape=static_IR=36b9b7be1407243aad0792e7a49ef25f7c3e3791dc1ff93cad40480837ba87cf_Device=CPU_Config=() +1475:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i32_Shape=static_IR=22a8f509c3f76bc2dd6bc9a26ec4ab92a5b9ae4678532c886c1438669d627323_Device=CPU_Config=() +1474:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=12965dd8a422975f08bb0fc707c666ad7ae2671d09c68757d534e3a1d67efd41_Device=CPU_Config=() +1474:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=14f550bd7e83223ffbf501918141376e6a144484865f03c9768fe9da49a9f06f_Device=CPU_Config=() +1473:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=dynamic_IR=f550a37ab884668f47ed232e7119c2a2baa814c98fbbcfa3129e7a00feebde0b_Device=CPU_Config=() +1473:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=5a1aa66136ca2be83f714067139e11fcbf672d73f8b28c57d29333b885a17f83_Device=CPU_Config=() +1472:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=146297b05289c3b2445e1e97c744b4eb2d45f9f61b8ee8651e35b59fe1ee4041_Device=CPU_Config=() +1472:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=a6722b8718b7c028e1bbde4462945c096dfc551775af27bcc7d00967d7d73919_Device=CPU_Config=() +1471:conformance_ScatterElementsUpdate/ReadIRTest.QueryModel/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=() +1471:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=() +1470:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d9b9fc6875f06b7dc454279fc5fa4432f514736cfd1a35d2a40cfc82f680c009_Device=CPU_Config=() +1470:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9e2233439aaed8d4d48bfa36955feddb30531b843b5ed4a9c2acac5a8d815c69_Device=CPU_Config=() +1470:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=94693638ec4742dea16dc168eb9323995f1b2a35a53f577cf58ac3a08096892d_Device=CPU_Config=() +1470:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=72373e9c2bc4cdf2f0aa0a5d14e30ed1a5e0545d9a96f4ab675f3b9dc69d8cf4_Device=CPU_Config=() +1470:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=f802331401875cb16be10c9f752520406437b2e63a50e022b7d95b732e5296f2_Device=CPU_Config=() +1470:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=d9e0dff8f9df42944191425a99bbcfe45ee352d4a030d0f01994725c982b0c37_Device=CPU_Config=() +1469:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9991a1b4140ee8e6ed0460fb384b7729f681bc1068315a4d970eea59dcc89950_Device=CPU_Config=() +1469:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=06a1a9e9cd13f69334ecb05bddbdc5d186b85e138c5597d2e85222c4b735980b_Device=CPU_Config=() +1468:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0d40552a1b6c1945765ada16284a0c03f5c1454fb12f226a34dee8a07b14f17f_Device=CPU_Config=() +1468:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e7a4e6690e4897a569e29f61636fb4a99f645229fbfd2a68ecbf83b21058dcdf_Device=CPU_Config=() +1467:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a83bda80fe7800f61bcbba992511f20b4adb5da4097179f2188797871abb73ca_Device=CPU_Config=() +1467:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=() +1466:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=439b811941d57ad9e80586b01be64ddcb153c31ceba4d83303e0479b2933e8a3_Device=CPU_Config=() +1465:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9fbc81d8fdfc1359ee050d6931424547e2786637bb616a9703ab84291933a863_Device=CPU_Config=() +1465:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=() +1465:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=static_IR=a8525e823aa40fdd01829391b7ec4c4070aac21306c2b356ad746629316fb994_Device=CPU_Config=() +1464:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=d9eeac72636735d7541c2d0ef14ebfc7d4a1b3598c08c136a9123b2ed89e13ef_Device=CPU_Config=() +1464:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=84f6f3544adcc7c68df5ca411844cf36c2232c1b6c820094e5693a444faa143d_Device=CPU_Config=() +1464:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8484c5c087ca8317588ef676a0cafb63ded379be5bad862e4d0504f43bc6fb45_Device=CPU_Config=() +1463:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=5d791fd5b82a74a42073567349728035c4ac52ea64c1a154a73bd4e61d1b42dd_Device=CPU_Config=() +1463:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=dynamic_IR=848de524e27e13a1e5b33e5db3cdf2710ba4566c3219a018e878f998c07dd718_Device=CPU_Config=() +1463:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=() +1462:conformance_Elu/ReadIRTest.QueryModel/Op=Elu.1_Type=f32_Shape=static_IR=1cb500b61fe11278cc50fca509be3e7b654190294dd581c7862ea3f108e0c192_Device=CPU_Config=() +1462:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=b7b0a0b3921a1e1434a3fef630e32b124c810e8bd15a3e861fe7da79158947b2_Device=CPU_Config=() +1461:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=f73224b14c094974e582d3d903cc332f5c1da138368692e5d0be93127f1bf753_Device=CPU_Config=() +1460:conformance_ROIPooling/ReadIRTest.QueryModel/Op=ROIPooling.2_Type=f32_Shape=static_IR=baa256d53878b528f6bdba95bf1837cc570dd83b577220f95d9c24cb26d37c35_Device=CPU_Config=() +1459:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=db7378dd474a32c06b89e9b046aaae3caaaa2972d5d6bbe60e70668e0c937388_Device=CPU_Config=() +1459:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=aebf91fbdf6124d046e8016cfe5d5a5a967f7c4130642e9dc4b812ad067ecbf8_Device=CPU_Config=() +1459:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=59d132b45e2ac60a670eb43efafa43f065bb43d492208ac670fc8234b4f618c9_Device=CPU_Config=() +1459:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=c11313948e0a44512d2e068e2cf89c922a219f8f26a785c5fa34ed34fc7560a4_Device=CPU_Config=() +1459:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=d4e6cfc9844e29087dc5bb222a1822c26ec71f2e751575790add7c9b98a5a23f_Device=CPU_Config=() +1459:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=df5ba55412d924fca818d6ac4b1709ab651f12e4b64d6a9555644e8e8b26a0fb_Device=CPU_Config=() +1459:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6e508ca44667fb311f5b6d634584d2751c3fb15fc034626765c90695b7de9619_Device=CPU_Config=() +1458:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bcaccd02132919b356b3d4928fa5f1dc4bb2902748fe238f849e557a42e7a879_Device=CPU_Config=() +1458:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=8b759b2f1999be207aeb39763bde3eba4aee028e9369a86a87493ff86f3fa014_Device=CPU_Config=() +1458:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=dbabd4c2992053ca70e9d6a489b437cf8d1f13807220adb5054204e9bede00e1_Device=CPU_Config=() +1458:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=() +1457:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e5092af5c0f683044b1df5a45f211f4a692436d1112181a5d613bbf335941684_Device=CPU_Config=() +1457:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=3326cf79d426d1a669158c4db8256fdd956fa4725b0d6fb9e8ab5e5206612eef_Device=CPU_Config=() +1457:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=68c6351cbee22a4783b3c592f69eea3778c17594c48972d5d0d1e9d728f5b47e_Device=CPU_Config=() +1456:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9f8fca1ab855d5a71d7acabdefda202e270bf16b559fd581f9e663caa301ffd7_Device=CPU_Config=() +1456:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=136768c6c28210cc47eacf6667103eac8106e3f255618e067d351cb700e62cbf_Device=CPU_Config=() +1456:conformance_Round/ReadIRTest.QueryModel/Op=Round.5_Type=f32_Shape=static_IR=f4cc9554ddbd189f18575e3a80afe6e8f8bce613dc8852a48d4171ab6916e087_Device=CPU_Config=() +1456:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=() +1455:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=8fc296db9f7dd10289217cb81cdf5991c6b5f3c89369936a94c8ac484702bfa3_Device=CPU_Config=() +1455:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=i64_Shape=dynamic_IR=84a8c7a897894ee6bb1c03759bced74ea6d773a2cb8335efdc8d193a534f3833_Device=CPU_Config=() +1454:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e4c6d363cce1031b198de7bd1133cc023f1ff118a9dcc787d5a5f57593e6795d_Device=CPU_Config=() +1454:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=e7e985d4d02762d236131e74fd867acff1828bcd4c4eb32e190de20eadb831fb_Device=CPU_Config=() +1454:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5953b8e79f64e33e67dd330999ff8e3d8391c8f3fa7eae519b117b1273c8c19f_Device=CPU_Config=() +1454:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=98a6da6e0972a1b70caa5df788a6921d4e470565dc3880faa59e913fdc15f460_Device=CPU_Config=() +1454:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f2cfa9a58f5df299d524eaef020985f4a1e9e936f39afb25b2c201c4f449e8ec_Device=CPU_Config=() +1453:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=c7ce41820be10f17c8d48c005703d536d18e4f49b1d2022ac58f77b7b9afadec_Device=CPU_Config=() +1452:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4023cad1c8e22f448d84a0d7ed783f00a9914bfe546ad07fc16a88b6fc6be3fa_Device=CPU_Config=() +1452:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=634db7c7a580a605f3375f671b3bcb2a1baf5856b32032d2786a5f8061df63c3_Device=CPU_Config=() +1452:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=05d14a25a72424a0290894aaa67c6a1581b34ab0c07cc2acc7739f837b432068_Device=CPU_Config=() +1452:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=i64_Shape=static_IR=e8fc48c9bceee1462572c6aa8c5afbda94a9d6e8760deea1c9a3d04d1d797fb5_Device=CPU_Config=() +1451:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8dcce54a5f8ee92f5cb0f376b6baa4513e2f5bc0b6b7487ca85bf6f8c2a02c3a_Device=CPU_Config=() +1451:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=1366ff72dd5b68a3faf25de8f98e4ac5500663b1aac4941af11532ea2ee769d3_Device=CPU_Config=() +1451:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=377acd11b0f7dfb4f3e57baec8a6c8a84737857b7e794614542f139982feaf73_Device=CPU_Config=() +1451:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=() +1450:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=static_IR=2e3f53e7b949e1dd0ab38890b0c9fc9e770dfb68569e37fa5cdd4e3ef03d6eb0_Device=CPU_Config=() +1450:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=d8432e7d31bcf4d95ff7ab845a6858ea67cf751c7ef0fca60a9bab1d187fe3cf_Device=CPU_Config=() +1450:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=f32_Shape=static_IR=c18bd3eea12bff29ac733ae5578d28d88d5ed87aef7908aed08a09512e3b77ff_Device=CPU_Config=() +1449:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8d9dfab64d8e2b91c6b1429256b5e7c60d19d1891bdb6a519ac91886a6269fd4_Device=CPU_Config=() +1449:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5d5b6e996a1c477f211ce82bdadd3228788cea988eebf25d5f40ae1a745418e0_Device=CPU_Config=() +1449:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=b6a75c5d2a686eae53cc25c6b107630b31a8a4d8c6514980ed1a97754f33bdcd_Device=CPU_Config=() +1449:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=69f4c39c3fb2dfc55714893e1e45761238e74bf28ecfadbee3f4965b5a379888_Device=CPU_Config=() +1449:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=727e029d6373e823f7500e6bdfd1c07ba87fdb3ba428fd0a089885d7a1e91552_Device=CPU_Config=() +1449:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=28675c37d06426cf6895e7ffc15d6c212ef8be1b278fd199d1bfbd0678f825fa_Device=CPU_Config=() +1449:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=f8b14e90b051624d56678dbe68f15e6db94e22878b22914d0be241047d1a3783_Device=CPU_Config=() +1449:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=08ba7fbf736896f373ea81dd727940aefae22a39e217e84dfc5617ed62133d10_Device=CPU_Config=() +1448:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e86061c75b7e9a65644e82de6b8fb2a532ebdfb302f46f378b6ff20af8d1d14b_Device=CPU_Config=() +1448:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=730427f186dab4c4268e164d10b32a50afb588c1100af2de2c3293454e7c71fa_Device=CPU_Config=() +1448:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=697bdfc59094203ea1616203d64759a40193f1a23a4a51f11340a7912e355cd1_Device=CPU_Config=() +1448:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=12965dd8a422975f08bb0fc707c666ad7ae2671d09c68757d534e3a1d67efd41_Device=CPU_Config=() +1447:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=dfc4ce58920e58666fe95d2b0c2d7020e887fa9955e392519946b08ade090373_Device=CPU_Config=() +1447:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=e9539332df9388555564db1da36679acc7b505b8c1fa687731f2052999bfe1fd_Device=CPU_Config=() +1447:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=3638f7714d7627d7536ec02891656e512fee1ec55d59bb4f68c7409ad82f3879_Device=CPU_Config=() +1447:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=a65e17fc28c74df4f3b1bad89635ccfc376a857f2d92ba646ca830b03eafab7c_Device=CPU_Config=() +1446:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=02d773fa3ded668594339c08735173e7435442663aefc405993d5191e5b8bcc3_Device=CPU_Config=() +1446:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=00d6c2465c4fa7ddab80d30c2fd8099a684bcc47cf9bdba89a39560beed737f6_Device=CPU_Config=() +1445:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1b166178a448888eb82b8f6f5692ed96ca7fb6e52b5235a5ed50446e60566417_Device=CPU_Config=() +1445:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=static_IR=2055c46f29a25953e331656839e227b0472b10695ea23410b64428d14232345a_Device=CPU_Config=() +1444:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=670a0d513277b4508e8edcddae6361e98fd03c2fff31293637c36f97e59a6b9c_Device=CPU_Config=() +1444:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=() +1444:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=313740a93070bb3cb89143685b7521ea0ace30c3f6d510a4d83ed809808caeac_Device=CPU_Config=() +1444:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=417040fb77f62e577234ea0b8c1ef58ee0583e1a3c643af1da5c61838c2ff1bc_Device=CPU_Config=() +1443:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=67a75007dd4cf8ec6b4c3a09d5f4c6901913f86a6512e9970774543cc03d6e32_Device=CPU_Config=() +1443:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=static_IR=2b026a0d21a35251b07099e31ec58c459b848602575d2afa67e55830e8f3f411_Device=CPU_Config=() +1443:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=670a0d513277b4508e8edcddae6361e98fd03c2fff31293637c36f97e59a6b9c_Device=CPU_Config=() +1443:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=c7ce41820be10f17c8d48c005703d536d18e4f49b1d2022ac58f77b7b9afadec_Device=CPU_Config=() +1442:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=78239cbf0f8d473af2209ad3d9297e02208c110efa7af981f8c09ea7d7290032_Device=CPU_Config=() +1442:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=b9f9ac285915db9ef3e7437728695f2833d165757ffc81afb88242e7b471f434_Device=CPU_Config=() +1442:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=0b0005b038a938c698489da595fd89a45d2f685c831bc172d81b2afc09658dae_Device=CPU_Config=() +1440:conformance_Swish/ReadIRTest.ImportExport/Op=Swish.4_Type=f32_Shape=static_IR=d79b47022a50437c9df095b34e515c53eb042c9813fcf6dc7bcdb96962818ddf_Device=CPU_Config=() +1440:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43a00b4dc097228af52c00054951dd5b57d8e0086207f11a8996e5ac880c8980_Device=CPU_Config=() +1439:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=725aaeceedd7eba9be6ba4203e31cead733ed80dbafc33e902465d4338dc8f4c_Device=CPU_Config=() +1439:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=50a0e83d438a3220ed14dd8ae783e92c96381f645b10719669054ea944297244_Device=CPU_Config=() +1438:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=461bf15d226b7ee3cbdcbc8cf1806e98267c5f14f0aef49dfb9de094f56347b7_Device=CPU_Config=() +1438:conformance_ReduceProd/ReadIRTest.ImportExport/Op=ReduceProd.1_Type=i64_Shape=static_IR=7dba7222be56b8fcef943fc63ab00cfb3c7e0fb4467aeac96fd43aa4421cba86_Device=CPU_Config=() +1438:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=33d84638f606d759354e190991899e47d2f4c63b0e378aac985e5fb9132dcd01_Device=CPU_Config=() +1438:conformance_ROIPooling/ReadIRTest.ImportExport/Op=ROIPooling.2_Type=f32_Shape=static_IR=baa256d53878b528f6bdba95bf1837cc570dd83b577220f95d9c24cb26d37c35_Device=CPU_Config=() +1437:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0fdf62ef06a0a9225c0746379b89495e737a2e5f95077bb92600ce14f19fed40_Device=CPU_Config=() +1437:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=936ac30f388261cb12776b5e94062a9b5f7b81aa16c9aa5d8f994b8d69231c40_Device=CPU_Config=() +1437:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=c61a8f259a8b37e49f9267dbc921d88dd60e5766aa30dd05319f423a01c14aee_Device=CPU_Config=() +1437:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=() +1437:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=3ade42cfc9d970963d8f162b001075864e6967034198986f408ec09ce4093d18_Device=CPU_Config=() +1436:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3f836daba711312827fc9f3ee1d7d376e22ad7af24fd156ceaccd5c75678b9bd_Device=CPU_Config=() +1436:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=dynamic_IR=0b30cc6cee9ce5400085a0e78b44763bc169eeea93357f22fd716564f20226db_Device=CPU_Config=() +1436:conformance_ReverseSequence/ReadIRTest.ImportExport/Op=ReverseSequence.1_Type=f32_Shape=static_IR=1ff07d9b87513cab5bbcf5059507b8c998fdb25d2802b267bb6c0b90eb3e231d_Device=CPU_Config=() +1436:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=02d773fa3ded668594339c08735173e7435442663aefc405993d5191e5b8bcc3_Device=CPU_Config=() +1436:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=68c6351cbee22a4783b3c592f69eea3778c17594c48972d5d0d1e9d728f5b47e_Device=CPU_Config=() +1435:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4a7d98292fd2c8c98ef8f5a0996abf170591dd1d15fb17229c0005b0a30cce4f_Device=CPU_Config=() +1435:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=e1130d42d591780dd2a746ce7ff874a2bf4725ca9fd09803932ba4a7b0b389aa_Device=CPU_Config=() +1435:conformance_NotEqual/ReadIRTest.QueryModel/Op=NotEqual.1_Type=boolean_Shape=static_IR=8fe4bce2e674753d81a1516280769a06cdde538e658ae548087e4888ffa2905f_Device=CPU_Config=() +1434:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=7ad5da9c461223f21afd023e08220eaed788598f50e144e45fcdf3466c0810a3_Device=CPU_Config=() +1434:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=29a633b64671e28103c44b79ec5c329118c0d7c4f70466ad44482116aa2a3b6c_Device=CPU_Config=() +1433:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b6bb8473f99506737101987d5732d33073de8783b22d891c652653884bab7a87_Device=CPU_Config=() +1433:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=67a75007dd4cf8ec6b4c3a09d5f4c6901913f86a6512e9970774543cc03d6e32_Device=CPU_Config=() +1433:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f76dea75751ac96986fc17a4d344078ae4aae2fa2304b26e72d81f369986a9eb_Device=CPU_Config=() +1433:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=97181a6433949eaef7277fdfec4f8f94b27463ee3ed4a6aefc678fdaf7eab4db_Device=CPU_Config=() +1432:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c03bca3c44df7946fcf273e9d79309b7bf33b465206eb9caf76750735e1ad19b_Device=CPU_Config=() +1432:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9e573f34ccb820a89a27cc243a7cda8ecb2043ae1cc557a8ab7e4670b1d72c0a_Device=CPU_Config=() +1432:conformance_ReduceProd/ReadIRTest.QueryModel/Op=ReduceProd.1_Type=i64_Shape=static_IR=7dba7222be56b8fcef943fc63ab00cfb3c7e0fb4467aeac96fd43aa4421cba86_Device=CPU_Config=() +1431:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=20c2030cdd180dbbfad1e5b8a4f865d1757a9d427c3d5ff21651a429369f4341_Device=CPU_Config=() +1430:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=7e88dcf638caa6058b01dd6c31ba40efb0fca8077cc295ca63c2ebe4c7298926_Device=CPU_Config=() +1430:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=2ef8d38ce64fd0460d641e6f3bfcb1654bbe3d2c25f9dd244ae259eaa4b6941b_Device=CPU_Config=() +1430:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=5038017e90f931327d5159938d422b2afc229aa4d776a4ac80a946724fee357d_Device=CPU_Config=() +1430:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=ad5c5df7cea37955709ef71d9967828ce3f0011e68aa1c6085984f1422944058_Device=CPU_Config=() +1430:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=5150e1785d97b052a42873f9e9d23a511027248ff4b13ba7c269c8c3d4639e45_Device=CPU_Config=() +1430:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=ed75de35729f20a3285506937672f78d2d5137851a3043d15f4eafc040768fc8_Device=CPU_Config=() +1429:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8a0e61f6a4798574ca428449e75e3f3cda5bd116975466cff3733cbde1a2408a_Device=CPU_Config=() +1429:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ee098548fe040592d091ec00999f6f9c4143ba2f8ab4975d7a7daccfc7cf2da3_Device=CPU_Config=() +1428:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f6097dacc8a374d3c93eeecca54dfa436bec5a0882f38fdf192b63b49988b7cb_Device=CPU_Config=() +1428:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=e14dc7fb2cf0b63fd08f616d407511ff2036109a3e105dcb87398053d1c334d0_Device=CPU_Config=() +1428:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=i64_Shape=static_IR=056c07f9ad8e27e01b269b5136ee29b4cb4d1229a009cda07e4fd32c45d4e97f_Device=CPU_Config=() +1427:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6b1dbd40d09a340628ec975eb623751a161ab5b7773b190e38272c409d8bb4eb_Device=CPU_Config=() +1427:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c4679c052b2077c278e2200b5bcf502b660529c84bc6bcd58f92594a69f6648e_Device=CPU_Config=() +1427:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=12634194f9e192663deb30a2a1af450542d8cb78f1dcbe1f42a169588810636c_Device=CPU_Config=() +1427:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=6e8dbb054c99609e5aedd642130e867c22091118e0bb7ddd870a66dcfd11452f_Device=CPU_Config=() +1427:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=a7b7ec75e1b343acfa06ea53d7d5b631c06d44c68b1fc92555d7168c77aeadb3_Device=CPU_Config=() +1426:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f465651ea8ac7c2c141595f8d91a6061beffbe8d714e253a91dd12e00502ac47_Device=CPU_Config=() +1426:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i32_Shape=static_IR=bfcba23960ff2b0b1cc73e04f0447e0de8eab35df3b833823878d3c90bdd2e09_Device=CPU_Config=() +1426:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=f42d85c8e1388cf2cb69f9efb2970255c6535f1c3f904a9b08cc18cbea6aa6c3_Device=CPU_Config=() +1426:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=61f5318f717a5e0eedebd7dbc15069fc98f70247111220da32b449508ea00abe_Device=CPU_Config=() +1425:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=static_IR=da15c9ddbf446de00565c83e95b8a554d400b8b925481e56eb3df41f7efe26d9_Device=CPU_Config=() +1425:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=1c91956bf0130fd338f8f11cf76a08dcf5fe3c6c42239fa6a6aeb517eeabba36_Device=CPU_Config=() +1424:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=ace54c326bc8255cd741eec12762e4d8f645fe93d50c037effce893745f8fdb5_Device=CPU_Config=() +1424:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=ba1a7c4cca6d39b8bc7be7d52a0680d055e33a776f4048ecf38335a2ccdd8d51_Device=CPU_Config=() +1424:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=66df22ce11e7009aea35ba6a11b4294eda44815bf041eed0721499a3d2c484b1_Device=CPU_Config=() +1423:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=() +1422:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=d7fbbe9f8f446b009ea2de8594e4cfaad46432734cba27596e3fa721f04c04ee_Device=CPU_Config=() +1422:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=2f842d4b64513c6df5748c54a1166a3f14436dc1ca59b7a28530bcafcdcde2f6_Device=CPU_Config=() +1422:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=() +1421:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a0f8789f0f95beb6f28efc829bdf2f99d34a3e9397ad1a80d7831aaaf125b5eb_Device=CPU_Config=() +1421:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7d706b614d2b5d59c5e152bbb61a8fd558686bb3b8e9fda199c499ca49f03042_Device=CPU_Config=() +1421:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=85d1eaa250a32acf89b675cc50f513ef3c7df50ed9d68f2cff2fc89db41b63f2_Device=CPU_Config=() +1421:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f688cbb25fde53f41bf758ee6d439eee6feb3e289569b4b0d2db6dad9eb1c75d_Device=CPU_Config=() +1420:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3f836daba711312827fc9f3ee1d7d376e22ad7af24fd156ceaccd5c75678b9bd_Device=CPU_Config=() +1420:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=1696523c5dd3a701251583b9c9f29e43f852383cec3dde5a93e6f7f7cabf3398_Device=CPU_Config=() +1420:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=4212a754718adff414309fb1da18c4361792b5478366bfdc0994490c7bc716e3_Device=CPU_Config=() +1420:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3c7d4160bf883d550620e8d1ceb54b3d78bf1512388b5ee57e1a380949d441e1_Device=CPU_Config=() +1419:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0402d5c12674452050553b4b26ffea14a2107eff83f28b23c10a0a6f847bab71_Device=CPU_Config=() +1419:conformance_Cos/ReadIRTest.QueryModel/Op=Cos.1_Type=f32_Shape=static_IR=e5379d72e978c773e9be98561b316a64f76c6015608d87739211e7c0e8b7bba3_Device=CPU_Config=() +1418:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=bff490cc95cf384b15409e96ee7d0995aa91640e23409cda381b85b2fef69e01_Device=CPU_Config=() +1418:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=() +1417:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5b11b7154cade198918ce564fd66b7009aa6ddbf42a0cf155f16aef886c476f1_Device=CPU_Config=() +1417:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=static_IR=a8525e823aa40fdd01829391b7ec4c4070aac21306c2b356ad746629316fb994_Device=CPU_Config=() +1417:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=7ad5da9c461223f21afd023e08220eaed788598f50e144e45fcdf3466c0810a3_Device=CPU_Config=() +1417:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=718d6ff3b19f498cf4edeb9f7f4a7528fef578dd6fc7edb0796d476505472e46_Device=CPU_Config=() +1415:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=969cc6013dda0bdba994bcc071d5b24e2cbb5621539ca38140bc9ccc55f471ba_Device=CPU_Config=() +1415:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=7e386c35d9d397e043876a23a2b9e5885964cee59bf46f1ae0660e6a84641ea4_Device=CPU_Config=() +1414:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=49b1cfd43b9898a5882e93973e26ee3b149efbf3cb75d9ebe9225c61c87662ea_Device=CPU_Config=() +1413:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=static_IR=ca5d2626f2066e0c806addc4b6ffb4b3a71f1183b93783b92f44de62d82faaf8_Device=CPU_Config=() +1413:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=ea71ab322d6f3d74b0a7bdc3ff5dfd322f2d8c518a1fb5bc9960c5e04808f28e_Device=CPU_Config=() +1412:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=146297b05289c3b2445e1e97c744b4eb2d45f9f61b8ee8651e35b59fe1ee4041_Device=CPU_Config=() +1412:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=1d7cabddc96cb4ca2ed111c9f7a9c31b76ed9a052fd0b79db6bdc8fc55f24a4b_Device=CPU_Config=() +1411:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=554cea5d4f8f21234b429ebe1c4365bed5b6a6a309da5d607b45b301beb90828_Device=CPU_Config=() +1410:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=77b3b21d35d3742f7abc1097b99d510453f42ebe921681685fbc457d2fa9912a_Device=CPU_Config=() +1410:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=71d1d8ec03d4807da4ac2fe5647ff2bb8d1547c070d82a9421216fa9d39166fb_Device=CPU_Config=() +1408:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=282e24ea7ef9130becb8db8f0251c907b02a534119d08162e07091212d67f290_Device=CPU_Config=() +1407:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=f8b14e90b051624d56678dbe68f15e6db94e22878b22914d0be241047d1a3783_Device=CPU_Config=() +1406:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bd1eabf7e4126b68490c086db76a9a27e0b55e7047080ccf96158337c8a9e74b_Device=CPU_Config=() +1406:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0dea457d449893579a3278173eb21eebf0a0cbda95ef159ec186453c4fbb597b_Device=CPU_Config=() +1405:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=bbf75e5f7aa9f20f890a8eb204ddb5f159ca5eae0616fb99ee0b5169b165d595_Device=CPU_Config=() +1405:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=e7ab5b597681da2db03c13a2424b4e0a62135eecfb2f97f4c59b53331afb7f85_Device=CPU_Config=() +1404:conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=() +1403:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=i64_Shape=static_IR=68115f3a18f8ea201078166547e9c2a8587a5bb37646adf6f90da976f7298386_Device=CPU_Config=() +1403:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=() +1403:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=75aed7fbb8f7d7e8a1281d4a16c4fe2e55160dfb9e6a1bc446913a223c5aa0de_Device=CPU_Config=() +1403:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=c61a8f259a8b37e49f9267dbc921d88dd60e5766aa30dd05319f423a01c14aee_Device=CPU_Config=() +1402:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a24f79f450b9e5ddba709c6df05f77362e7f3ba6dfba01eaed77564700f46958_Device=CPU_Config=() +1402:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f84bcf4f549ca0d6e75c7905f1463fbace4f3b955032fcae627e46e353b2aee9_Device=CPU_Config=() +1402:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=d2759b52de5dc9f1fa494c243d08ac40cf4e877c51323d53dbfa02abc1564e45_Device=CPU_Config=() +1402:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=7df296e0e156bb36cb643a292802f9db374c77035c6a05ee4a865fbe2c6ef92b_Device=CPU_Config=() +1402:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=() +1401:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=23f7f775455e615175f3122ce422ee96de019ca40fe603b5a4605d51f28210b1_Device=CPU_Config=() +1401:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=823c1bd1ce8ee0ae28410bcea9f3c33ef9f9271e8f41f0871a7d6eb6b2850757_Device=CPU_Config=() +1400:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=969cc6013dda0bdba994bcc071d5b24e2cbb5621539ca38140bc9ccc55f471ba_Device=CPU_Config=() +1400:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=f7e1aae2dbc817ca8f64a6bb0742e476055c239cc6e31a4233b7580205feeb41_Device=CPU_Config=() +1400:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=9f19f32ddff44c1c8f7dc3b9b244a9191a15fef9874e016666fe6a817937f699_Device=CPU_Config=() +1400:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=1696523c5dd3a701251583b9c9f29e43f852383cec3dde5a93e6f7f7cabf3398_Device=CPU_Config=() +1400:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=810f13adb3f7342c7d514bec2aa3f20d7a59527b54c7f6954b038efb194c5ceb_Device=CPU_Config=() +1399:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=d575b00d2b6e155319fe7120133d8e0c3dcb5c79bda710b0650fa48543dc5c84_Device=CPU_Config=() +1398:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=98526403db7eb1f67a41aed2c34fea684d99d8cb8225313136e55be7d326aaaa_Device=CPU_Config=() +1398:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=32537f045cce3d13cb28dd292a0ebe06e13002877d9ed2e5b25d3ebdf5afcb58_Device=CPU_Config=() +1398:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=() +1397:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a7bded06602c3d42bdffa7e21822a12759cdd54ff8803c8502ffe1b2348b1f8e_Device=CPU_Config=() +1397:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=2b927ee73187f1c1cbdb071ad3c0a72c9eb8a8631f2e7c6c3a8f8482c301fcf3_Device=CPU_Config=() +1397:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=() +1397:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4612ce2abf1348d599a331eac37b14624de5994d6c3481e8765f06d344e6ae6a_Device=CPU_Config=() +1396:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3c0b9fab07568e0eebb5e5d068cfccdd617ee6e98e4253a0461ea8d3f0f582e8_Device=CPU_Config=() +1396:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=98c467c06ecdfe13b1f3b90237bd32041a11c553f544328ed9b181bbc3201f6c_Device=CPU_Config=() +1396:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ab537310012dac035760906bcdd57eecbe645735b70c27eb4ac4c220b37a3147_Device=CPU_Config=() +1395:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=643e31750b57de573073bcda3bb324ecb87332a72f1c89af378213de24f5241d_Device=CPU_Config=() +1395:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=7798cef9c8734d0908103b3c42fd7fc791806ad61d35dc680dc43d9597c6f1fb_Device=CPU_Config=() +1395:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=() +1395:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=b61800abac107b248c29df7ba04a73c91d490782b1da46164c1b7d2f8cec3cdf_Device=CPU_Config=() +1395:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fe70e0ee3f24f0bfe4391da7797647a01f66fcb109b481ca859c9f8f7dc7b411_Device=CPU_Config=() +1394:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=static_IR=a8525e823aa40fdd01829391b7ec4c4070aac21306c2b356ad746629316fb994_Device=CPU_Config=() +1394:conformance_ReverseSequence/ReadIRTest.Inference/Op=ReverseSequence.1_Type=f32_Shape=static_IR=a5cc0793d73f7f76fc02b5ae04ef2a29bf212ce5c59f9bbef91e0aa5ee17785c_Device=CPU_Config=() +1393:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=7c1b4dfda36336bb1a943fec9786d89e220f2a811159fe9cbed7d51186f8fdfe_Device=CPU_Config=() +1393:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=f3d704d4f0da6c58c39e279d727dd82fe0e59a41dbaf09a3cbaa8f591daf95f7_Device=CPU_Config=() +1393:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1180dfe50d43ef6b95980bafd3b84816f6d249f8341b03a6f67d20bd8f8ba6a4_Device=CPU_Config=() +1392:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=178677f6c6e3857b2c3aa8765c8e3186bd25b73154ba6463ff33a9e1c911e6bf_Device=CPU_Config=() +1392:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5bb330e06cd9ca29e3e19f09ba0c9f129025899cbf69af96fffbd58bf1f55ab3_Device=CPU_Config=() +1392:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=27e8804992c0d74c18c958f0876c06be6c7eda2b36fe7de3ab616b577dce13c6_Device=CPU_Config=() +1392:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1a01e1932e9e30974342c0a6e382d829af6ca776db39be738e54a55a09732ed2_Device=CPU_Config=() +1391:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a74540730c27b2cb9437e4ba730bfb555be123f25f1709f2863d50cdaaa21c7f_Device=CPU_Config=() +1391:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=06a1a9e9cd13f69334ecb05bddbdc5d186b85e138c5597d2e85222c4b735980b_Device=CPU_Config=() +1391:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=69c87ccfa0080f65ed28b9a088343db5ceef524ae917b8e259b1865a017df22f_Device=CPU_Config=() +1391:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=a29bdaa31edbcf7b3dc392625c0aa0a27e827e1363d52519858c93defbf9ebac_Device=CPU_Config=() +1390:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=7201a55d869ac6072af38ff89dfac3cfd2e6720d25f7607c6cc5f80040a8e82a_Device=CPU_Config=() +1390:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d3e089f773288c135f90d5e2e1d4a667e3c9d1ef6a121e65206dafec5a36740e_Device=CPU_Config=() +1389:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4bae2ff9aaa35cf3821fd34e05a504bab2caf5e9a2fa8b280810d6ac40ea07a0_Device=CPU_Config=() +1389:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=105ef2497841f48e00c64d60affe13b54275083bbf0fd91837d21a4c7c85a1a5_Device=CPU_Config=() +1389:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=874c0fa19029457645c4cff20769f66ba7aaa1a35ade84c948f83aaa9c1ead19_Device=CPU_Config=() +1389:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6a1c4fda6e89fd564d571ee69820791696d016e379dc78c8c55ae0e6934537b5_Device=CPU_Config=() +1388:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=12c56cc6ebb22e8e31d97e0ef640fecab5f93e5c5b2810c4dde56b09a7ac7f48_Device=CPU_Config=() +1388:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=99183013393075553f5cd30818ccd603ff5d3e9e71dd8f42ced0df2377280729_Device=CPU_Config=() +1388:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=77b3b21d35d3742f7abc1097b99d510453f42ebe921681685fbc457d2fa9912a_Device=CPU_Config=() +1388:conformance_Equal/ReadIRTest.ImportExport/Op=Equal.1_Type=boolean_Shape=dynamic_IR=0723b6d683bc65225624112929bd8f7a0adde9e9c2265a2ec1a54b10c4433735_Device=CPU_Config=() +1387:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=4c3b0cda20bf6b3c574eaefbce21b9b2b0ed92fa1b37c32af252b111b6466d0e_Device=CPU_Config=() +1386:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=b94b5361ee75b3684455c2b871b656a50c72e325564787c302a714f222845b26_Device=CPU_Config=() +1386:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=521ab9a51bae271537fd09832298deef71b46d465161e2db579cb503f1ac812b_Device=CPU_Config=() +1386:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=69aeb01964c5dc32bbda77681903931df3fed18b0caf978ad5e986ad59c8b4c6_Device=CPU_Config=() +1385:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a7bded06602c3d42bdffa7e21822a12759cdd54ff8803c8502ffe1b2348b1f8e_Device=CPU_Config=() +1385:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=41ea59b807081adea7869609c65776a42f88079ec22180807905d5c2e8ca0777_Device=CPU_Config=() +1385:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=10cf1b7a4de1231ad721c9660697d6ee17bcaa2151f08eef596b41e6e3aa1b2f_Device=CPU_Config=() +1385:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f8ee6adb1573c51bcffdd8c24455ecd6b6fbf04f171e9aa5de36c5d6f18babe_Device=CPU_Config=() +1384:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5bf1e9348ae0ec7106a2231d8940acc74464f5ecf0cbc6a682defc3a9bc5c2c2_Device=CPU_Config=() +1383:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3ad94046aabf97af320725b888d1b85ad5d47cac065d8f6c54cdd5244bc0ac32_Device=CPU_Config=() +1383:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=be67f733f734ca7f0e54076cf1cc39016924607014ae1a312849e8b5cd5b916a_Device=CPU_Config=() +1383:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=dynamic_IR=f550a37ab884668f47ed232e7119c2a2baa814c98fbbcfa3129e7a00feebde0b_Device=CPU_Config=() +1383:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=313740a93070bb3cb89143685b7521ea0ace30c3f6d510a4d83ed809808caeac_Device=CPU_Config=() +1383:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=a7b7ec75e1b343acfa06ea53d7d5b631c06d44c68b1fc92555d7168c77aeadb3_Device=CPU_Config=() +1382:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=109afa0426a29179db58e16917b829096af105f0def2375a589ea1391138ee2f_Device=CPU_Config=() +1381:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f19b9ae15030aed3c709b020b9539e197d260ee35c50d6f9b807201e939cc758_Device=CPU_Config=() +1380:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3147f462ceda9b383de633ac08d6014a7779e74b169d3745990fa2b2799b1dbd_Device=CPU_Config=() +1380:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=feeeccadf83749f2827985b49721a9b8c5a0c9c90a709193e27002e5dd7f0bc0_Device=CPU_Config=() +1380:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=df303191a733f2e33492260b5a1c6aea1db7c5d0063f1516f49de923a176a64e_Device=CPU_Config=() +1380:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=d04bc06efa76ef2937aa1539893ec9c79ac61c765cb50cd4a26dbf5586bfc904_Device=CPU_Config=() +1380:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a9b0552d84d057a656080c8e302afa30962dc02105abe7136cfd77f0433eec18_Device=CPU_Config=() +1379:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ed4daec3f69dd307e284f0c8d5c5115144bfb76e8f550f7eb49f3e3da6bb1be8_Device=CPU_Config=() +1379:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7a5b4de9e365b548d2bfc06db9bc63ec0dc941689701f984326d837bf152347c_Device=CPU_Config=() +1379:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=7685da6dcf91a208b72d5961c2c248d816de501366163d61b1ee3c148787fe77_Device=CPU_Config=() +1378:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=3bfc4cff938f4386af23d87ce10f8680a62a25ce1fa9178874f212edf45ee045_Device=CPU_Config=() +1377:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=08c583b490b8cbd43eddefc35f87cb6a11fa07284d5003b6fe43f66255c380c1_Device=CPU_Config=() +1377:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6aff57130da7904e5d2300c4962f104d31c704872d5c33bbda4bb38efc34d563_Device=CPU_Config=() +1377:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=427900d25144ee6b8cd4b35cd53c6e9335375018f6328dd01ae4db304846d991_Device=CPU_Config=() +1376:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=98c467c06ecdfe13b1f3b90237bd32041a11c553f544328ed9b181bbc3201f6c_Device=CPU_Config=() +1376:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=u8_Shape=dynamic_IR=b12ccd794c23494b994608015d049eec0f2ca30dc319bd35c1adddb3e4b8e631_Device=CPU_Config=() +1376:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=dynamic_IR=43ceadf05184954dd8697d4f737de323ec2ee75f93e0d33d60dab2acc995f3b6_Device=CPU_Config=() +1375:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=dynamic_IR=848de524e27e13a1e5b33e5db3cdf2710ba4566c3219a018e878f998c07dd718_Device=CPU_Config=() +1375:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=0b603f9cb63e722122080ea36f76fe45b25da83b0b1e213871140e82dea5f405_Device=CPU_Config=() +1375:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=0db5765bcfeb7716699abd0cee850918cf5ef18e2cfdf1614b463734ca35a20f_Device=CPU_Config=() +1374:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ba5382529d458077147b1f822dae04bb7c6d0634adfa0d1e7a111b5b816ad3f3_Device=CPU_Config=() +1374:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=abeadd9ea4814d6b3d678af4ec0853b8392165cc6270ae2b1a1f6f9d04d3cf4d_Device=CPU_Config=() +1374:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=b050ebcbd31acbbc43d657d87a54415e0e52d3e91fa95b57aa1dd0451a5bf50f_Device=CPU_Config=() +1373:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=9fc3d18a9496df4681f38d330d3d1ff7b83b29b8f4e08e19c26a0107c4b69157_Device=CPU_Config=() +1373:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=b371481349b8d7897f8b234c64177dad6abc66375bddf4c32c09738dee193184_Device=CPU_Config=() +1373:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=f42d85c8e1388cf2cb69f9efb2970255c6535f1c3f904a9b08cc18cbea6aa6c3_Device=CPU_Config=() +1372:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=1bde2f2a7294810531e23de80f25a451b3033487b5919c949b708b273dc3973c_Device=CPU_Config=() +1372:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a08cb2499595ed0de5c51e3b0feae24d9d5462d227572e771862564e1875b6ef_Device=CPU_Config=() +1372:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5bb5076aa4e905f00c38eeae688e2624d5a57f8ac7b6ee873943361985e63343_Device=CPU_Config=() +1372:conformance_Greater/ReadIRTest.Inference/Op=Greater.1_Type=boolean_Shape=static_IR=aed960e9b7608b89973346cc2ab23c7ff65e72275fa55daa8b13f925a3779701_Device=CPU_Config=() +1372:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=e0641a7f9e64123d0d51a75e576fbd0e405105b8ead44a618068e77d2b4bf933_Device=CPU_Config=() +1371:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=() +1371:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=256f1706e3c9255a819cce8f22bcf8f6e6bc01e752443461711dd28d5a51946d_Device=CPU_Config=() +1371:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6df4880ea064693f638735c7c7818014dcbad51d6d148f6a13477ab069703700_Device=CPU_Config=() +1371:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=b434cd386e4c5e688aac8da3425d2ed0d72961223eaaa1cf2ff951a88a5fa001_Device=CPU_Config=() +1370:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=8ea778d7d98fd08efe4b2efa501ef3599df00ca9bd036980ce86e0d6dc454b96_Device=CPU_Config=() +1370:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=7df296e0e156bb36cb643a292802f9db374c77035c6a05ee4a865fbe2c6ef92b_Device=CPU_Config=() +1370:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=9caff6e502635d35017973f6026a64d02feb4d470d43b7ccd7d85090006247d2_Device=CPU_Config=() +1370:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=e0641a7f9e64123d0d51a75e576fbd0e405105b8ead44a618068e77d2b4bf933_Device=CPU_Config=() +1369:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=24d05884873d69e036ce6647cdd8eb4a82fa7b8d30629e86337a1df10ccf45cd_Device=CPU_Config=() +1369:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0849107336e2dcb62f494696f297a85dec4fb5d71f1f9422313faa5c23ae4cdd_Device=CPU_Config=() +1369:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=() +1368:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cfa4ea6d340205f9fc4db4ec912037243299168e9bfa4e248e530c98a0f8a8ab_Device=CPU_Config=() +1368:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=() +1368:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=9bb8728e6e9f68cf68a9e39d1aa4c618c4aca4187d4262f735c0647d680c0506_Device=CPU_Config=() +1368:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=78239cbf0f8d473af2209ad3d9297e02208c110efa7af981f8c09ea7d7290032_Device=CPU_Config=() +1367:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=1942042c790c3fc6053ad91fa5e45f8ebf3c11bff7e3427a71b8fdc1bc5db053_Device=CPU_Config=() +1367:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=33aa0d800115f94b07bce9c6ca8b4447f2c4f442bff77cb9b02b23d2ddabcc01_Device=CPU_Config=() +1367:conformance_Negative/ReadIRTest.QueryModel/Op=Negative.1_Type=f32_Shape=static_IR=c29451ffff103b5e965a1bbea7994ef6da6394060855ee071b9e7a3a4702141f_Device=CPU_Config=() +1364:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=bff490cc95cf384b15409e96ee7d0995aa91640e23409cda381b85b2fef69e01_Device=CPU_Config=() +1364:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0f61e4837d11be2b01f69947cd0b424a45d2e548d9c70ae53b07c43fa1237cd0_Device=CPU_Config=() +1363:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=96117baf3ff208c696a9796404eec467b613c37977067ff0cc62e39355856d30_Device=CPU_Config=() +1362:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=29bb3b751638e157d0ba7114cc0e156a4b792a9dbb2bafa3ca124516595f01a2_Device=CPU_Config=() +1362:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=dfc4ce58920e58666fe95d2b0c2d7020e887fa9955e392519946b08ade090373_Device=CPU_Config=() +1362:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6a3f3c1b6e3617139da7a30c725db5dcd70c692ac7eff64c5fa074c2ca0e6f9e_Device=CPU_Config=() +1362:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i32_Shape=static_IR=61760c9c95110bf88cbfb8aa09378cc214d4cbbbd6c39c98feec1dcfbb7d47fb_Device=CPU_Config=() +1361:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=4fe95284f224758c29c5198a8b2e6f97e8e737435d36cb94b9cdf0bca3c89dc1_Device=CPU_Config=() +1360:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=67650b86e9d46be859e1c38e6996a26522f6645036ca823e4f8d194626ef2884_Device=CPU_Config=() +1360:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=fe615eeceb735b046b190d844931c56223d45439021da3b6b23227a1f9cb73c7_Device=CPU_Config=() +1360:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=i32_Shape=static_IR=5b9cbac8797158a77d5616e8b7e5d8132360e23e26d31d845f0d129df7bfd7b5_Device=CPU_Config=() +1359:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=680b155374ac22f8d01e47a3b26f133a20842702d07dbb2d0fe2d1c03333afcf_Device=CPU_Config=() +1359:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=431db89311a543581d104e2a2c498fe021da2e4026323817834670bf5bee67a2_Device=CPU_Config=() +1358:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=i32_Shape=static_IR=f777fb31e1669cd58cc77e2a04c3f9a804b654b6d710432641a3dc34504460b4_Device=CPU_Config=() +1358:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=7e88dcf638caa6058b01dd6c31ba40efb0fca8077cc295ca63c2ebe4c7298926_Device=CPU_Config=() +1357:conformance_ScatterElementsUpdate/ReadIRTest.ImportExport/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=() +1357:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=b729ddf6b689006067cfce88ec7d9e89268dd6cd904e4596717016541632b13b_Device=CPU_Config=() +1357:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=075342290aa43542c81f7ed4e804c905f110edc23440452c6d0c0f0c312b65c1_Device=CPU_Config=() +1357:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=6daca83f4b162285c00c695825e255cbafce9cf9c9cea68b969a301105475303_Device=CPU_Config=() +1356:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9d667416103520d22b2328feb82905999d9d34664283e3bc754131126f9dea8a_Device=CPU_Config=() +1356:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=79dde0b4a7ccb6e275b507d3467b9ad1e02498ca54329e111d06903d57355623_Device=CPU_Config=() +1356:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=19a94fc5cfe3ab1b4e169b342ec8d9f0fdc4ef19484c8c34d6ab938c6e7bf5fd_Device=CPU_Config=() +1356:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=60ab42bb613fe785777ed45bc99044f41dae00316065ed5e5f07e69f5c861fc4_Device=CPU_Config=() +1356:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1180dfe50d43ef6b95980bafd3b84816f6d249f8341b03a6f67d20bd8f8ba6a4_Device=CPU_Config=() +1355:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5b2d8d57f3d0914e21b47b7e450d2543ce7b7eee6c3eb3bff7da441b15e20d77_Device=CPU_Config=() +1355:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=3801fd5b86bf772977c131734d8356c8dfa41b9056091937473be600e332fbee_Device=CPU_Config=() +1354:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=f32_Shape=static_IR=dbc3b2f724614a68d750ae4adfd7d8239c77ced05d30f89deabe272f104a5e75_Device=CPU_Config=() +1354:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=56fa4af7b32a139a903744478ab84858b98dbcd173f4c0f3da01d4ca547e1dd2_Device=CPU_Config=() +1353:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a8705f91d4bf4fe876dfb6d2ac2eb9c89808c88942d4beb080e1e2c089d77040_Device=CPU_Config=() +1351:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=() +1351:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0dea457d449893579a3278173eb21eebf0a0cbda95ef159ec186453c4fbb597b_Device=CPU_Config=() +1351:conformance_Greater/ReadIRTest.QueryModel/Op=Greater.1_Type=boolean_Shape=static_IR=aed960e9b7608b89973346cc2ab23c7ff65e72275fa55daa8b13f925a3779701_Device=CPU_Config=() +1351:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=754ed99b0565f9a10963e61e6fbbcfa64848b11c6a0a68bde7aae90ff9a1e34a_Device=CPU_Config=() +1350:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ef05cedf5dbaee70082962e6459d8391c8358cccf43e33695d15184215d26d8c_Device=CPU_Config=() +1349:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=67650b86e9d46be859e1c38e6996a26522f6645036ca823e4f8d194626ef2884_Device=CPU_Config=() +1349:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=93a382b4c379f41c5a888ff51ba8ae2cb9e7812ce4c14f1a028fa383051a9feb_Device=CPU_Config=() +1349:conformance_ScatterElementsUpdate/ReadIRTest.ImportExport/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=() +1348:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9fbc81d8fdfc1359ee050d6931424547e2786637bb616a9703ab84291933a863_Device=CPU_Config=() +1348:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9ce6a2f4787ef120c486a68cc02bacb95d6cb1c4cdb5e2054275cde409a39803_Device=CPU_Config=() +1348:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=51390fa8c8a5680ae4a8de4f655083caefbb8445dac8814d2b1827e2bd43f470_Device=CPU_Config=() +1348:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=4541365c567e68739f0733edba54e889f231026025e6866f805446392c575960_Device=CPU_Config=() +1348:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=debf36fea706c02dc67354edf761f0dc931ebcccbed285f186164fc4b9532766_Device=CPU_Config=() +1348:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=5aa10dbbcee8d7434796180d5fbe8f0a954b772c441c8d6046439c615d3b9011_Device=CPU_Config=() +1348:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=b6984001a616b3dd3ef4b835b2dc6a48bcaf8882bfde7761b4e141733364f66a_Device=CPU_Config=() +1348:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0f61e4837d11be2b01f69947cd0b424a45d2e548d9c70ae53b07c43fa1237cd0_Device=CPU_Config=() +1347:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=2ad5b63ed56c3966570062970125d1cac16629595e9ac34c6613cf00d6dec0aa_Device=CPU_Config=() +1347:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=727e029d6373e823f7500e6bdfd1c07ba87fdb3ba428fd0a089885d7a1e91552_Device=CPU_Config=() +1347:conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=i64_Shape=static_IR=1c06ff77487507dddcddf290d75d4812bfc8a7b2c9bc78176da5212eab029966_Device=CPU_Config=() +1346:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a82fe43f495f5ad83d1fba98c09af9c14bb09cb506339e5ed48c78c8a6c973f3_Device=CPU_Config=() +1346:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=fbb85f74ecfa0ffc50b9e6ce637911b406f1fd6ad054a886b9c6ddc6bc898739_Device=CPU_Config=() +1345:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=1942042c790c3fc6053ad91fa5e45f8ebf3c11bff7e3427a71b8fdc1bc5db053_Device=CPU_Config=() +1345:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=034fadbf9527892e159709c266c12c4863ba0f7bc559f4248afc517f3c2c6938_Device=CPU_Config=() +1345:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=81313f6065af987d98f37a1709f149d804bc1a36bb0a5c4a11223b29c6ccc3d2_Device=CPU_Config=() +1345:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=24e44f75d91fe4e7e28db6c93870a47d536abeb87240841ff5b7e74b40189e42_Device=CPU_Config=() +1345:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=eeeaf32688af20dbc39dd3705dc09fc804c0636d4d5807b003c002eaab1e79dd_Device=CPU_Config=() +1345:conformance_Less/ReadIRTest.Inference/Op=Less.1_Type=boolean_Shape=static_IR=8cac1c4c51c2eb61b9ec75320814acf81b9ac240a88e1cc68f29541f6eb546e7_Device=CPU_Config=() +1344:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=21950c433f50ded0f662b9e0591e756a8dd685bc11a8296bcacc57ca1a4968b4_Device=CPU_Config=() +1344:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.1_Type=f32_Shape=static_IR=a4fe57973b0bba01e6038a8050f07b8ad1bf6871c1ad86270920f9084dc84905_Device=CPU_Config=() +1344:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=22707f4dd48a39013f543e7eea951a8feb16952bb25f9dd34a0f05dcc28883f6_Device=CPU_Config=() +1343:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f1f5ced67e3605021d51e7e29d94b4f0fc3ac4542f527f8cd437f44859981e83_Device=CPU_Config=() +1343:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4a8cdbce9473e7bc24866edf0f5ec0f5a95475da63cea7ef68a4fef7b9fac1c4_Device=CPU_Config=() +1343:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=d1d0510ce6d862a5512bf4c5c588f84548f1aed0226eca6850b5e2d470a5ee84_Device=CPU_Config=() +1343:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=() +1343:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=d683b96d525bc074d4f8c15934a5082a3fba1068b591f67e4b05d605fe5e6aa7_Device=CPU_Config=() +1343:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=99a80c495a8fb4626995167a3ad2efa0efed7696459f6219125414a2bd20dfc5_Device=CPU_Config=() +1342:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=abda9df0d20139a837c079060be4bebb2d5c65c2b166341559ae9eb7937593af_Device=CPU_Config=() +1342:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=dynamic_IR=516ad610612780fdaf83c5dc151316e83772eda4700882f934c97b2a2bd86dac_Device=CPU_Config=() +1342:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=a65e17fc28c74df4f3b1bad89635ccfc376a857f2d92ba646ca830b03eafab7c_Device=CPU_Config=() +1341:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=03c30e9e1651c6554fe73bc933149c65271a948db07a6d5062b5e8d55ef0437b_Device=CPU_Config=() +1341:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=b288dfcaf8fd8fefe24212a70255bb280e7e695badf6fad6538042701d77073e_Device=CPU_Config=() +1340:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9ad22386a62ba639f3d766e8b6657e95fc12bf94b237edf7f75a3062425bb899_Device=CPU_Config=() +1340:conformance_Greater/ReadIRTest.ImportExport/Op=Greater.1_Type=boolean_Shape=static_IR=dce38966c13ac9886c7480261e3483d822355a9bf3835d00795e7627744a60d7_Device=CPU_Config=() +1340:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=cda3b9bda63d065b5c27e6bce5ffe20968024d77efe5e174a9f4395db56a30c0_Device=CPU_Config=() +1339:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=5bfbbb826bcb2c9e7b5364fcc5da23e737953150029c2ea7455ad4b09caaf01d_Device=CPU_Config=() +1339:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=14108fac0139d5bb39f6b2106857e1ac91c8d44ef9156e4e0873facf9d932316_Device=CPU_Config=() +1338:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8d9dfab64d8e2b91c6b1429256b5e7c60d19d1891bdb6a519ac91886a6269fd4_Device=CPU_Config=() +1338:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f96e0fde526a6672a21a4a485e01f6fd57bab2da7b34ce44915bf354198dc6ff_Device=CPU_Config=() +1338:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=() +1338:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=923032e47821636c4c8098a7a9afa97b331a47d47357c780b7bced2e46ea9921_Device=CPU_Config=() +1337:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=815d7fd8018e49525b4d4642c1ee3cb828dcf4c6fb696ffb1fc5513490df02fd_Device=CPU_Config=() +1337:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f688cbb25fde53f41bf758ee6d439eee6feb3e289569b4b0d2db6dad9eb1c75d_Device=CPU_Config=() +1335:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=474c6273d1e48e8e5885966dc93629ad413683ad942e3101452c1a58fb5b5af9_Device=CPU_Config=() +1335:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=8fc296db9f7dd10289217cb81cdf5991c6b5f3c89369936a94c8ac484702bfa3_Device=CPU_Config=() +1335:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=c18d3d2fd8001cb07daaa5000258b36352807e3e81999d2d80a668e4d6add085_Device=CPU_Config=() +1335:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=ee49657e646466b0c22aff01740a48c1cc271a828a8c3e10a21d75b04f511cb1_Device=CPU_Config=() +1335:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=313740a93070bb3cb89143685b7521ea0ace30c3f6d510a4d83ed809808caeac_Device=CPU_Config=() +1334:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=439b811941d57ad9e80586b01be64ddcb153c31ceba4d83303e0479b2933e8a3_Device=CPU_Config=() +1334:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=static_IR=f9377788ac0fd1ad0a7f51d16543722cb5acb69640745df17d9f41f5d1d0b544_Device=CPU_Config=() +1333:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=c7ce41820be10f17c8d48c005703d536d18e4f49b1d2022ac58f77b7b9afadec_Device=CPU_Config=() +1332:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4cf0a180eb5154fca591a8d3239f3bde9024ef2b347a70c3b10341243e679177_Device=CPU_Config=() +1332:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i32_Shape=static_IR=53f0fb6a39e6f296be9d041e6caf93cf34a3916218a07dddacf4985b93943ae6_Device=CPU_Config=() +1332:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=2233a83397f11ea3c674c4845409c4f27f8bffbb8d0295712a2525c9e93d6041_Device=CPU_Config=() +1332:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=62b8aaf25e8c93387362b0c657886c31c39a7330cf3455486b8943a1e375ef5c_Device=CPU_Config=() +1332:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=() +1331:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=dcd71a51a6682c9bc461a6cb72d59082352ab8a020e1f79e64c3cc44a37b55ba_Device=CPU_Config=() +1330:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=afd856f31f3a815b84c34b66e1ba0a70a313301ce82fdccc2f1b779ad3157d4f_Device=CPU_Config=() +1329:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eace26dff7f6f0403126e78a4c93920ee5e54a721cd580b4b18c2c9989baef86_Device=CPU_Config=() +1328:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ca5847147325177b69e97415489292ae793cfe1346e23e8a7bad000f9a702d91_Device=CPU_Config=() +1328:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3ad94046aabf97af320725b888d1b85ad5d47cac065d8f6c54cdd5244bc0ac32_Device=CPU_Config=() +1327:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=008827517eea396c81f651f8dc2f2a43e2cf000f96e28cc8eb0ec7008f1e11e3_Device=CPU_Config=() +1327:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=8fc5ce53f1f6b924371ab2cf156ddbf7aea234b17befdcb6206ba51a7ad988c9_Device=CPU_Config=() +1327:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=7fb9c2cdb4c82a4b65d110fc84c03948917cc1921c372cc645cab00a3377fad8_Device=CPU_Config=() +1327:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=18697d690af0de3ff8365a5aafa6ebc7d8e14418c3ab5dd55b3b505d2445ac86_Device=CPU_Config=() +1327:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=3c7c072c9e4ee694e049a5f256cf0e72caf85384291ee8d399ce136d22c575a3_Device=CPU_Config=() +1327:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=2f842d4b64513c6df5748c54a1166a3f14436dc1ca59b7a28530bcafcdcde2f6_Device=CPU_Config=() +1326:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=5f8b64ad8dd9ccd202ae8d5080ce166fe9f47b909e803da49546dbffdfb4ab3d_Device=CPU_Config=() +1326:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=4341385bd87226eb41493c667323e8c1c39817983a48025192209270750eed06_Device=CPU_Config=() +1326:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=d4e6cfc9844e29087dc5bb222a1822c26ec71f2e751575790add7c9b98a5a23f_Device=CPU_Config=() +1326:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=80e0900e8270dfbd0fc879ad4d065847f767cff9399688bb9e5e03b8531c554e_Device=CPU_Config=() +1325:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2e834fff42b38f5e5dfa3c3e756cc51789a286876665de46d98a504961c24c88_Device=CPU_Config=() +1325:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=38d935b0aa7266960b3d349b60c97bb15f535faed953fbe3ff24ae2560828f04_Device=CPU_Config=() +1325:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=3326cf79d426d1a669158c4db8256fdd956fa4725b0d6fb9e8ab5e5206612eef_Device=CPU_Config=() +1325:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9c4adbd0f6e4ccc612a4906a5e3d0ed20fba39b9521a78b88c95b540ba7a1e3f_Device=CPU_Config=() +1324:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b0376bbdfc6560184c2eb15a9cff7fc6d6b39c47dd22936fb64629d345e227d0_Device=CPU_Config=() +1324:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=() +1324:conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=() +1324:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=d9e0dff8f9df42944191425a99bbcfe45ee352d4a030d0f01994725c982b0c37_Device=CPU_Config=() +1323:conformance_ReduceMax/ReadIRTest.Inference/Op=ReduceMax.1_Type=f32_Shape=static_IR=590a910a27283b92d7a4650bba546a3bec08a6ded604bbe8523ab3c6d734c70b_Device=CPU_Config=() +1323:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5beb9762188e985c9554ffb0a05fdc1608fb7d970baacebbbd7118186a324617_Device=CPU_Config=() +1323:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=16ccecc11352f2c476db041adea21d67a96e03cf33902b37f4f6855b5113c202_Device=CPU_Config=() +1322:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=172f158b0f845ffe5adc879bc825ab5f9d904bef2150cd9cfcb663e090fbc828_Device=CPU_Config=() +1322:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a3291bf5a7a531f88e8705193f436682a60f78a4b6cdae2af49aa82b20cdffd1_Device=CPU_Config=() +1321:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=47c28b32453e7972e5f4a7213522370ec927424c913b5c6d0ec08a00d7a988c9_Device=CPU_Config=() +1321:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=6c1aeced5aaaecd99f3917a0f38e01902dbe81614ae4dc9a99fc09a379990abc_Device=CPU_Config=() +1321:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=45e4a607b0964915174f6a14de049a61a5740f258a4a71817e5aae1b93be5ae7_Device=CPU_Config=() +1321:conformance_LogicalNot/ReadIRTest.ImportExport/Op=LogicalNot.1_Type=boolean_Shape=static_IR=66b8769b499fa31cfd7545411d16a17b04e1a336bb63a7e907707cd170a30fc9_Device=CPU_Config=() +1321:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a78437a93ab424a706d064188d1bc0971b2e1afc98a74fea979a6f8b99036597_Device=CPU_Config=() +1321:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=a35667a1c5401fb3102a59ce0fa67d0ea4829f8ce282c43767517ce025469bac_Device=CPU_Config=() +1320:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=815d7fd8018e49525b4d4642c1ee3cb828dcf4c6fb696ffb1fc5513490df02fd_Device=CPU_Config=() +1320:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=() +1320:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=fb8064c0836e50254162e2a9cab01514f76b19f78084410b6d1b69bd54f93168_Device=CPU_Config=() +1320:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4014e6cbcd000f86268253c54f7543e96897c729508d56ab831ee8a2687669db_Device=CPU_Config=() +1319:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a9311932565e68fff052e15c1a0522e1c09270d06521541ca28b67c34184b1c5_Device=CPU_Config=() +1319:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=() +1319:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0785cae4389228b343e2620b4fad71e5d1343838d4fe2c766bceb2e337334e6a_Device=CPU_Config=() +1319:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i32_Shape=static_IR=77c86205d7dd4dd882adb5a28b03ae2ed9c80004b42d4df1cabfab96f3168d72_Device=CPU_Config=() +1319:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=634db7c7a580a605f3375f671b3bcb2a1baf5856b32032d2786a5f8061df63c3_Device=CPU_Config=() +1319:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d56533ce961113b2ca0baf02f3ff9f8ff210264343f6bebf26418a35ecf36b02_Device=CPU_Config=() +1319:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=e85722360042c3ad04d04157759bf404452b789f30eb1174cbd59a5d7451df30_Device=CPU_Config=() +1317:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ffe64e2ecd6d3ed3128559b89dd2a26ed439c533f6ebeb969ebeac62f80dc12e_Device=CPU_Config=() +1317:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=51390fa8c8a5680ae4a8de4f655083caefbb8445dac8814d2b1827e2bd43f470_Device=CPU_Config=() +1316:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e4c6d363cce1031b198de7bd1133cc023f1ff118a9dcc787d5a5f57593e6795d_Device=CPU_Config=() +1316:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=bec81407211db6e10d7c8811bc58b53c23c8aafa0e2083f262204f345b9bcfc6_Device=CPU_Config=() +1315:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=697bdfc59094203ea1616203d64759a40193f1a23a4a51f11340a7912e355cd1_Device=CPU_Config=() +1315:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=() +1315:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=b1477d38842775944964d18c13278454256d9610e0ef880fbce0cc87e5977556_Device=CPU_Config=() +1314:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c7aee90a4d266602709c28c5c6fb4e0ecb791e5399fa3077364e660f657752c0_Device=CPU_Config=() +1314:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=2f8c5775d77906707d4d8dfc991f73e4a780d87571fe695725e131e833049370_Device=CPU_Config=() +1314:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5f18fb02adfd683f379dd5a15d38f01cf744e6940754f6a40e2646a1d9c97be8_Device=CPU_Config=() +1314:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=d25e26d9a54a5dc9799e9881e3035bfd5f125d12ea6cb69fb1eb0166e29ec88d_Device=CPU_Config=() +1314:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=01b095b8763565527be0de9edff565070949485db907493e99e95c2cddf6abaf_Device=CPU_Config=() +1314:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=() +1314:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=6e67522f2df32ac8e237fd4de148d082f3c55e6c31ace80cffeaef784dfe75a0_Device=CPU_Config=() +1314:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=fb6a053d244fc1bdea6fd5e69e0c05025272ac0da2f676e077c598239b6493c2_Device=CPU_Config=() +1313:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8596cca11141e34e75c884b1be9a75be19663caf4c0b1b4275f6035a73d62e_Device=CPU_Config=() +1313:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fb9febc1b0984c7d6887460d058a75a9444bd1ade793c5b945c9b79ad2c63e46_Device=CPU_Config=() +1312:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1d41827cafc0ccd8d9b0d1304c302fffafb52f653dedeed1582a9d8c7b88f173_Device=CPU_Config=() +1312:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=df303191a733f2e33492260b5a1c6aea1db7c5d0063f1516f49de923a176a64e_Device=CPU_Config=() +1312:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i32_Shape=static_IR=77c86205d7dd4dd882adb5a28b03ae2ed9c80004b42d4df1cabfab96f3168d72_Device=CPU_Config=() +1312:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=d50dd7c19583071293118e8b98f2bc749ef3e34ab8eb0149138e6b9fe49a153c_Device=CPU_Config=() +1311:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=28cabba0fd0acde452552a362925344e8cd8c5af033419d83041bf26b1d14d69_Device=CPU_Config=() +1311:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f89e84d6fb931cf0cd074acd01a50e50daa47ad88b1b74e4b3671d63bd7889f2_Device=CPU_Config=() +1311:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=e08e84b17997c1b1279429161d287720e4c7deb0e6d055539149bc577ed3b104_Device=CPU_Config=() +1311:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=46b077d7466eecbadbb7ceba5ed90724db3d9e216d22171f5dee02e44b9a5377_Device=CPU_Config=() +1311:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=659cd025e440fdc633859089f52f7f38cab5701c63c79d1e8d1837c217b8cf75_Device=CPU_Config=() +1311:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f71810b04667907bc88c4a1ecc28b9325fde04026b5e56b5eb0e2d6608f3742_Device=CPU_Config=() +1310:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=b9581fac6848b0c6c9fc9af5fd17eca3f2f64832fb7205f97684f1cc4c1985f0_Device=CPU_Config=() +1310:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=c98e1e2347c7b6939804dfcfcebbbd57d4c05e8d13b35b2611912290d06107ff_Device=CPU_Config=() +1309:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=db5c391cca1031cb4ec32def18ce3a4776c53f71e861c39b350fe5856da4fa43_Device=CPU_Config=() +1309:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=dynamic_IR=fc75aba0dd172d6628de0b473569c672b52f070ac3c446cc3342cb1184ef076a_Device=CPU_Config=() +1309:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=b1477d38842775944964d18c13278454256d9610e0ef880fbce0cc87e5977556_Device=CPU_Config=() +1308:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=885f5721f6c3a7f1335325c7638a8934b00b9ac9d0eedd9e9ccdf25514bf0b2c_Device=CPU_Config=() +1308:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=45c9fd0289649c455939587c623f1884a4e675e2f970192d9ac2f60a65e6da9a_Device=CPU_Config=() +1307:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=() +1307:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=a5a2ba7fff85401feb05248462e85d334440769790e7e6ba1a75ffb413f7fc64_Device=CPU_Config=() +1306:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=03c30e9e1651c6554fe73bc933149c65271a948db07a6d5062b5e8d55ef0437b_Device=CPU_Config=() +1306:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b4dea8581ef6ba0546774e88cef10aeb80f847b8d227fb0d3981baae1c44c2b8_Device=CPU_Config=() +1306:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=dda9a81656cbcb4ab5484fea52e7172baf67d46babce886726c96eaa1980766d_Device=CPU_Config=() +1306:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=70a452909b242f5920ff1e78eea212c720242ed5fe9c22cd1149e3f9847167c1_Device=CPU_Config=() +1305:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=eeb4d5ffc7eb6cdd80079e6b814a1c228e389e4fa01ca368f092b606666bf7c0_Device=CPU_Config=() +1305:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c7aee90a4d266602709c28c5c6fb4e0ecb791e5399fa3077364e660f657752c0_Device=CPU_Config=() +1305:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a3ae510f07db7c475dbd4500d129e0939bfeb9c8cd5c5090184d501f8c7106d8_Device=CPU_Config=() +1305:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aeabe9639d6dcd5ab6e09f9905ffa8bdfe7cafcc7f5c8598e20e4ff39bdb50a6_Device=CPU_Config=() +1304:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cf981b73f7cffceac87c13ff562674f1c6b457bc6275704b4ad29cd943f3a15b_Device=CPU_Config=() +1304:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5f0ff4c88ede5deb6d12935a74027fd8e9a1c966e03e064f0a94cbcc11415918_Device=CPU_Config=() +1304:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=473e9027081a81ec0a25821312bd198c9a5e750a87ef249783bcb2c53b2bcffa_Device=CPU_Config=() +1304:conformance_ROIPooling/ReadIRTest.QueryModel/Op=ROIPooling.2_Type=f32_Shape=static_IR=1a0e3f63698678d2e6bb8968fbadc98227d9ce548e77c53021412d80d7711753_Device=CPU_Config=() +1304:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=b434cd386e4c5e688aac8da3425d2ed0d72961223eaaa1cf2ff951a88a5fa001_Device=CPU_Config=() +1304:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3a3886301663fd20cf2c8c0f74c11d80dfe8b74ac39e41652f0eac1ec9bfa2df_Device=CPU_Config=() +1303:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3b9757ef04206894e22a41c20c801743199f098a8899a9ab19228b44dd754fdc_Device=CPU_Config=() +1303:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=75aed7fbb8f7d7e8a1281d4a16c4fe2e55160dfb9e6a1bc446913a223c5aa0de_Device=CPU_Config=() +1303:conformance_Proposal/ReadIRTest.ImportExport/Op=Proposal.4_Type=f32_Shape=static_IR=c0884ce897724cace24b30df395a33443364f8494f1f8495d212f2db20fc49e2_Device=CPU_Config=() +1303:conformance_LSTMCell/ReadIRTest.QueryModel/Op=LSTMCell.4_Type=f32_Shape=static_IR=828ac6aeddaaa033842b086b946b507fca3f65a7ea3a9a53bf697da37a889db7_Device=CPU_Config=() +1302:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=d6be1de020bbe6277d8cacd77eece21f766e5e39badb520ef29e880d52e3604b_Device=CPU_Config=() +1302:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=b288dfcaf8fd8fefe24212a70255bb280e7e695badf6fad6538042701d77073e_Device=CPU_Config=() +1301:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=8b759b2f1999be207aeb39763bde3eba4aee028e9369a86a87493ff86f3fa014_Device=CPU_Config=() +1301:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=c66bf2eb0c46ce68b45d052526a613e65f43c69926768fa0df8d1ab412b2b743_Device=CPU_Config=() +1301:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=() +1301:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=9caff6e502635d35017973f6026a64d02feb4d470d43b7ccd7d85090006247d2_Device=CPU_Config=() +1301:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=3effc90c24c0eb76bbc89809d34c6541654366a02e21378a668dd932a6cc7756_Device=CPU_Config=() +1301:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4a80814933ec1c6198745b1caa4d5b7c9171395b6d8a53cd791dcdf64fa6c91b_Device=CPU_Config=() +1300:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=582f7347a93cb2c9e51ade6c405ff25b23d009bdcd3d7a3c49902e627a041252_Device=CPU_Config=() +1300:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=456012168725798035877b2cd860bbb89121fa41add6f7ab78c03247032077fe_Device=CPU_Config=() +1300:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=aa757ffed4165beb3074da6ad09422d7823a1d0d6c8a654adc56343d0e43dc66_Device=CPU_Config=() +1300:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=966eae58d5c103f24a598a5143d7b3a3c40a12fa2606a65431f0d1aef855cd32_Device=CPU_Config=() +1300:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0973b76264164ca52a9883a69ff5f7df977e28c33a0dbe9095e7e92acd7854bf_Device=CPU_Config=() +1299:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=9f19f32ddff44c1c8f7dc3b9b244a9191a15fef9874e016666fe6a817937f699_Device=CPU_Config=() +1299:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=2b6ad903c5efa29748d41521e0e0ea3c8d814d7de54f7831f0ea12602f265f0a_Device=CPU_Config=() +1298:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2fc01b66086ac5d8272dd81ab731188b62bbe8920bff1efe61bf3261a3a8b3e6_Device=CPU_Config=() +1298:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=20d41e2e902d25c339d648d9f20a3e7f524320dc7186e989b1cab13e401d768d_Device=CPU_Config=() +1297:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5b9fd9b0043cef8aac8d0cc2e517a3e245eada8fedb7409911cd2867e7ba85ce_Device=CPU_Config=() +1297:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d56533ce961113b2ca0baf02f3ff9f8ff210264343f6bebf26418a35ecf36b02_Device=CPU_Config=() +1297:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a76c4cc0a1f2294a3ceb18dd5d214d842cf37c08d2e34770c66c29b44ee92e48_Device=CPU_Config=() +1296:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3d6f722f81b8a23f0dcb2acaea3686f0aebde1d810953e532cad9930a034d050_Device=CPU_Config=() +1296:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=1f7f2d40b938416773b13282d8ac09d81a50e4d5d7548f42fc5fd575f84e1385_Device=CPU_Config=() +1295:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=f1e43476084575ad240db6631f433a61ba2076d1ca95e44a0e4471ea9d6f66df_Device=CPU_Config=() +1295:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=ace54c326bc8255cd741eec12762e4d8f645fe93d50c037effce893745f8fdb5_Device=CPU_Config=() +1295:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a7242174afe3f7c2e95d31cd14d56ceb0a566e2e8d65ba97e07d004200f4f517_Device=CPU_Config=() +1295:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=45e4a607b0964915174f6a14de049a61a5740f258a4a71817e5aae1b93be5ae7_Device=CPU_Config=() +1295:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=caad691eb2d7c291cbb0078e861cb3f1a79f6c321b092365dc9612b2140a76a6_Device=CPU_Config=() +1295:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6d96cbf402de4085be87bac94f42f06f28049e17188cb3467dc8010e8e99f698_Device=CPU_Config=() +1294:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f89e84d6fb931cf0cd074acd01a50e50daa47ad88b1b74e4b3671d63bd7889f2_Device=CPU_Config=() +1294:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.1_Type=i64_Shape=dynamic_IR=45a9a897d75b175e3d805e74ec09322789564e0c0e8d9535724f262a9f534572_Device=CPU_Config=() +1294:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=ba4f511cc4a0870c64cc5027fa39b2bf91a6e7f39ea36cd43a693eb59de6d836_Device=CPU_Config=() +1294:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=c8ec200fa8fd8ec9c185d9d45ee1380be5e0e4a6f3157e5900401e9fce999553_Device=CPU_Config=() +1293:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=592176a8c97f4d759a0c6b3ef56c3610df4a0df4743f3be7ba3ed2ffb5dcfaed_Device=CPU_Config=() +1293:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=() +1293:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a7ad8306fe632a2d0c45a492ad2d21dbe40f2f9ea55074d602beb6f8dde17982_Device=CPU_Config=() +1292:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=() +1292:conformance_LSTMSequence/ReadIRTest.QueryModel/Op=LSTMSequence.5_Type=f32_Shape=static_IR=b8e32896d2ab304fb4fdca3924e0110852da92be25307f30709cd7d897c2f038_Device=CPU_Config=() +1291:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=39661d69e883bb7940e185a991f7b6bbd05248637577079fc52794cd1e215062_Device=CPU_Config=() +1291:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=85d1eaa250a32acf89b675cc50f513ef3c7df50ed9d68f2cff2fc89db41b63f2_Device=CPU_Config=() +1291:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=a6722b8718b7c028e1bbde4462945c096dfc551775af27bcc7d00967d7d73919_Device=CPU_Config=() +1291:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=() +1291:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f18fa21106120cecd81f50d635b1c42cbd641877ffbf78e746ef7375ff546d7d_Device=CPU_Config=() +1290:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4bae2ff9aaa35cf3821fd34e05a504bab2caf5e9a2fa8b280810d6ac40ea07a0_Device=CPU_Config=() +1290:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8596cca11141e34e75c884b1be9a75be19663caf4c0b1b4275f6035a73d62e_Device=CPU_Config=() +1289:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5983b9e38433fb9c767b7885ea749d6e89fe9d3a46f45777097f046611f31fce_Device=CPU_Config=() +1289:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=dynamic_IR=2af646407076eafcc1ed2d628158fc32eac4ef2fb34fb967962c06f81376d61c_Device=CPU_Config=() +1289:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=static_IR=591cc5abb16f22cfa720e53be695097b83c42a971536fb5b79d0b02cc4ad328b_Device=CPU_Config=() +1288:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bed7c11a4d039608b3ff58fd136cb1d3dc8438441a37829913b63da7c1c657df_Device=CPU_Config=() +1288:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=046798a0cf8d4c3fd8f1dc12bd0363a669628e748a6c964385eb50bb783924fd_Device=CPU_Config=() +1287:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7f5e90bf4696bbe503abe4ed3337d44ec48775276b9fc9b10e87e48e788b2fc7_Device=CPU_Config=() +1287:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6ddd9bc0333c5b1ebae36dafbc24444ffcd34d29bdb58a9b20d4e584c2cc63eb_Device=CPU_Config=() +1287:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=461bf15d226b7ee3cbdcbc8cf1806e98267c5f14f0aef49dfb9de094f56347b7_Device=CPU_Config=() +1287:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=12d0999f6ddfb04654b91fe374a7b55fb33014f3c7477cdd03c76730327d97bf_Device=CPU_Config=() +1286:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f0af28fe49c157f5f62f72f0ab209c50aa07d97c65477217fde6e3a3d0dc98ef_Device=CPU_Config=() +1286:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=67650b86e9d46be859e1c38e6996a26522f6645036ca823e4f8d194626ef2884_Device=CPU_Config=() +1286:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=564cd54b2564c7e39fda0c5e580c274b7bf99603760f6c66f03b4450f23cc4bf_Device=CPU_Config=() +1286:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=78a5e7f340d63660dc0710d0e390dea2d3f68ac98f16e8dbc11b4c28ac0440e0_Device=CPU_Config=() +1285:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=dynamic_IR=a99a5ab2de2d408c2e40ad5734c9bd5ab4d1d221f4dd24572e05538b134ef88c_Device=CPU_Config=() +1284:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=60a41e3bf293fc0a0556993a8e0d339e47f85bda8e98f726367cc6eda681994d_Device=CPU_Config=() +1283:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a83bda80fe7800f61bcbba992511f20b4adb5da4097179f2188797871abb73ca_Device=CPU_Config=() +1283:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=dynamic_IR=9feb072b58552898ff80a05dffe8f39c880b4f2a2382d56cb24a78e278ea1756_Device=CPU_Config=() +1282:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=05c2f891e743416ad510bf0ebf713738bd41258123cc4bbdc5cf067f251e35d8_Device=CPU_Config=() +1282:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=d6250086b712a16042ee74438bb61b89fbfaa5bae433049207402d1da4cffaef_Device=CPU_Config=() +1282:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=53108cff3836c47360380f3898c5de245a566a5d98040820d78befd46e56955b_Device=CPU_Config=() +1281:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3b9757ef04206894e22a41c20c801743199f098a8899a9ab19228b44dd754fdc_Device=CPU_Config=() +1281:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=61104a3a93d0b36db7f0499ae63420f216e5d7b0171b40c4629f640572f04f2d_Device=CPU_Config=() +1281:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=fb8283ecd8934dfc5340a41e9889a0a760b39869e4873efed4ef85606c162ce7_Device=CPU_Config=() +1281:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=00d6c2465c4fa7ddab80d30c2fd8099a684bcc47cf9bdba89a39560beed737f6_Device=CPU_Config=() +1280:conformance_ShuffleChannels/ReadIRTest.QueryModel/Op=ShuffleChannels.1_Type=f32_Shape=static_IR=46e851dee1f7bead1a6e2459157df33266c45559375a1caff90a2732cacaf881_Device=CPU_Config=() +1280:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1c9d69e1a85d03b8599961a8a1b90af7b3b2d43bc5c4f4a6b8d5da3c22166abd_Device=CPU_Config=() +1279:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=264ac1f5ebe805838ff6e76fca75305ba3ecb27f84e44ae7b44e9c01d613df98_Device=CPU_Config=() +1279:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=72373e9c2bc4cdf2f0aa0a5d14e30ed1a5e0545d9a96f4ab675f3b9dc69d8cf4_Device=CPU_Config=() +1279:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=944072d96554abf3ceac6b928cc00ea1705d5e0dfae8e9a0662de4e56fb3e62f_Device=CPU_Config=() +1278:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=945bd465761a4d9b013b0a5e88a3a9e041d8bd8bfa8df8044f28d71ba26f224b_Device=CPU_Config=() +1278:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=08a654f35ce851709d2c0634533645f6910b394b9cbb4bc6ddf20860f3a09c48_Device=CPU_Config=() +1278:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=9fc3d18a9496df4681f38d330d3d1ff7b83b29b8f4e08e19c26a0107c4b69157_Device=CPU_Config=() +1278:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e8703e68163db56928e366caccc3d2d89fbd35aba3c95af33a9d615659871d8e_Device=CPU_Config=() +1277:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=01f8aa116df449130419891bc3387fa263e1ef80b3113fecd83b06fb933efbaa_Device=CPU_Config=() +1277:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=662ca1fd253f0a0c29b89eb1310ea5c7c87895533130ca1a8b76f791ef1ad99b_Device=CPU_Config=() +1277:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3837a665cc6a05b0f8981a4670a4611739b070db2f5ce97ad05cb256eed5c994_Device=CPU_Config=() +1276:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=fa15f26352d0ced4d5f1b31c382aa71fe9413ce66ba6664ab9bf9a24975ee3be_Device=CPU_Config=() +1276:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=9fa81cf001e6c48dfcf4e75aa77f95b3dce4e8d48b6ec3cfc896dcc08006c62e_Device=CPU_Config=() +1276:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=() +1275:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4b386237f65fdaa6fdcc6826f3c331a945b8a7c0ab860e83f60fe2cb24e3277b_Device=CPU_Config=() +1275:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f465651ea8ac7c2c141595f8d91a6061beffbe8d714e253a91dd12e00502ac47_Device=CPU_Config=() +1275:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=u8_Shape=dynamic_IR=81bbb9658ad214babb825fa4b576aa83a9ceaae7dc0b878a84e42ea194f3ec13_Device=CPU_Config=() +1275:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.1_Type=i64_Shape=static_IR=26d97c755f660ed8ee08a0de8d6ab88598391cc79b239bfaf0a102722ffc4bf7_Device=CPU_Config=() +1275:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=120cc30794fe9c9d59dc9df6fadbb9791f3a6b99e4b9fdc06c5e01f494b05780_Device=CPU_Config=() +1275:conformance_Less/ReadIRTest.ImportExport/Op=Less.1_Type=boolean_Shape=static_IR=8cac1c4c51c2eb61b9ec75320814acf81b9ac240a88e1cc68f29541f6eb546e7_Device=CPU_Config=() +1274:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5816a52b5b342411646884cb88eb68a96df7ef3c3cac57c9057da46be4f5d8eb_Device=CPU_Config=() +1274:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3464734e2c2dccab82635831d42ab5bfbc954764434eb48f4ad92b46ec26dc46_Device=CPU_Config=() +1274:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=4341385bd87226eb41493c667323e8c1c39817983a48025192209270750eed06_Device=CPU_Config=() +1274:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=7fb9c2cdb4c82a4b65d110fc84c03948917cc1921c372cc645cab00a3377fad8_Device=CPU_Config=() +1274:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e3a25054872107eed50b9d6d9d612c46b781ab5ba4fdba17988c2c73a48a37bd_Device=CPU_Config=() +1273:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=125ec4e4ba4158d3a6d1a7725cda9a18a220926d5ad6ed623a1433688c79b579_Device=CPU_Config=() +1273:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b76160001b7c4e0963f942d74ad2114d4205c689a1715f8e0fdad75404d718d9_Device=CPU_Config=() +1273:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=03c3e6567da3c139c19e0ce0d301a6076b2e2446d191216c7bf38bc030ea7855_Device=CPU_Config=() +1273:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=() +1272:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=368972b9c1fd7f33348656101315b2ca3ed44503ce08ed5c9baf75026dec049a_Device=CPU_Config=() +1271:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b299e012ad30cf620f5c9ba0c33c79a406d0e39f84cb9d1efdc4b4c8dd82f347_Device=CPU_Config=() +1271:conformance_SoftPlus/ReadIRTest.QueryModel/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=() +1271:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=i32_Shape=static_IR=6650e462a4f0086329d8576eb6352979e89825517f48e264fe719c7c5ca276fc_Device=CPU_Config=() +1270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9b32e763670e7a29b1ed95659051b94c323b70948e5706a00db44200cd27bad0_Device=CPU_Config=() +1270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=827eabaef75593763cce8084a77e9ab8c8aee3de527727acafbffcdf5efc2766_Device=CPU_Config=() +1270:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=c662eb0004f431152ddc69e12826a6c0e7aa66b24be0169acf10ca95f2a63f52_Device=CPU_Config=() +1270:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d8a48dc7581c2ece0179d0ad668e8caebdddddfe492e365ea2e0e5f3a7302eea_Device=CPU_Config=() +1269:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=8832b317ba58dd0efd1e8fa5238d35644d8468a03c9b35809a20ae64098dc986_Device=CPU_Config=() +1269:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=c66bf2eb0c46ce68b45d052526a613e65f43c69926768fa0df8d1ab412b2b743_Device=CPU_Config=() +1269:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b9bab6ef11eb6ae637924a902a40dff310a45916d50c8f0a4ec667c8d6bde6a6_Device=CPU_Config=() +1268:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=9f19f32ddff44c1c8f7dc3b9b244a9191a15fef9874e016666fe6a817937f699_Device=CPU_Config=() +1268:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4a80814933ec1c6198745b1caa4d5b7c9171395b6d8a53cd791dcdf64fa6c91b_Device=CPU_Config=() +1267:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=0fcad2ddd1c7b81bf5e88ef4d4abb26a33326a37fb0cceb1205c1efd2a2d3615_Device=CPU_Config=() +1267:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8f731757a7c32fa8e4d602d7197af81a1a82ea228ec05f4baeae7c59eba11f2b_Device=CPU_Config=() +1266:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=be944d418fd21f00271c405c19022a5e0f2be06fb973cd54ba8bd2610d02f0b2_Device=CPU_Config=() +1266:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=1bde2f2a7294810531e23de80f25a451b3033487b5919c949b708b273dc3973c_Device=CPU_Config=() +1266:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9b6b036dbdc251b786d53d5f0aca9c57b72afeece113f9b2d8935020ed697166_Device=CPU_Config=() +1266:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=eee9a6474efc670ba46cde5daab7dac878055d12b3ec02a3dc524ae68572b02b_Device=CPU_Config=() +1265:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d56533ce961113b2ca0baf02f3ff9f8ff210264343f6bebf26418a35ecf36b02_Device=CPU_Config=() +1265:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=7d3d30fa9e2a8a839cf42249de3eb8228681229e8b302ff7f290cc0d00c10a1a_Device=CPU_Config=() +1265:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=45d3d98caee5b2666b6f411fa9d42c7d9655fa2baee63c43640bccd7bc472469_Device=CPU_Config=() +1264:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7af359181d29634dc797b38c2defd26a52a70073a59a7d027ebdd752b4011d15_Device=CPU_Config=() +1264:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fd62dfe7f4707f12da18744aa57795baf078b77819fd22b889cd02559e70d7d6_Device=CPU_Config=() +1264:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=189793140439255931ae5b3ea93f68da1569937f3c591ff27de99064829a75ca_Device=CPU_Config=() +1264:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=7fb9c2cdb4c82a4b65d110fc84c03948917cc1921c372cc645cab00a3377fad8_Device=CPU_Config=() +1264:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=c5b83fb7df33573c55e1177d717a1b7222d1c09e86cfef73d51a44d7354c2402_Device=CPU_Config=() +1264:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=() +1263:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c7b882a2a8948d97135ee2faaec7d11cf59af2bc2398a4b3c4713242fcc04bcc_Device=CPU_Config=() +1262:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b11b7154cade198918ce564fd66b7009aa6ddbf42a0cf155f16aef886c476f1_Device=CPU_Config=() +1262:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d492c7eaf897986b3d961ba687b4ddf8cdfcfd946dbece9cad3e75c7a65d2ef5_Device=CPU_Config=() +1262:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i64_Shape=static_IR=38f6cef69f6a7d9886b5d38902fb76e4ae41385fb3c95e229be4b44456ab2e87_Device=CPU_Config=() +1262:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=cb67c5d0b8712ebac00fe4169f0cad2e0a8c71d7f9603d5d2ce6ff6dd6bc055e_Device=CPU_Config=() +1262:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=99377bd11138d36797502d82ac9adddc31dfe1e4cbb8bba8684b1479f8a16f26_Device=CPU_Config=() +1262:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=57ba21d45369359487dc3b6a8feb0aa2b6fb21ffa328dc8e8eed58ee2896fdad_Device=CPU_Config=() +1261:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0d52cdcce6bd2a9335a6262a5dad29d924e0b1bc0caa81eb0b73c153d7b27e00_Device=CPU_Config=() +1261:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c4ae9be783990e398b3e8f0af76cab50d72c40c705677a3fe1c5dea592952d1e_Device=CPU_Config=() +1261:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=682ef97686247c6443214e731915927e131f40c22f1cae7f25a038b70eff95ba_Device=CPU_Config=() +1261:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=0a5f9fad12bf5e2592c6f720232bb38d94a5fb9ac1fdc5a8f7d474ed9e9d2504_Device=CPU_Config=() +1261:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=i64_Shape=static_IR=32ab4bca2ccc66d25b8b9ac449dbc58666434d98aa5b789e1aa28726c530986e_Device=CPU_Config=() +1259:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c3e5791580edfc2b522c8a3aecd33445b3fa8d771e2b5a8387ef0f303773c848_Device=CPU_Config=() +1259:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=static_IR=7798cef9c8734d0908103b3c42fd7fc791806ad61d35dc680dc43d9597c6f1fb_Device=CPU_Config=() +1259:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=i32_Shape=static_IR=201b881bba09ed67334d9489a1a8971e483120bd1cc75a1aa1c9f015f760e002_Device=CPU_Config=() +1259:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=a2450d07c12669e586815e60d9a2b568f88a49c9b63730c898b9eae907b5ec4a_Device=CPU_Config=() +1258:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=() +1258:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f894fd40780753da9c5cbb224a6981e690368cbc31e132922ad38e4e006f7827_Device=CPU_Config=() +1258:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d7fa761d51467b3295cda1fbd4a9865c3f1d1e3d5b8d7a091a66c70c9bcf5b4f_Device=CPU_Config=() +1258:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=574e53e574b1a6e0bc16a7296aadd78785cac535293e956b008b0a2274b7cb36_Device=CPU_Config=() +1258:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=680c8c91d6dfdb198ff304245e6da3089da20f6fc5187b80f279c5d56eb66052_Device=CPU_Config=() +1258:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f6f3c6d199a224ee983f6905aa4f72ea4138e6076d7307c72588dda0cc9c6ed1_Device=CPU_Config=() +1257:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=bc90fb9a95a74efb937b6cf808584dd1e91aa6c4d774640b51f4325f0aca6b42_Device=CPU_Config=() +1257:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=28675c37d06426cf6895e7ffc15d6c212ef8be1b278fd199d1bfbd0678f825fa_Device=CPU_Config=() +1257:conformance_Erf/ReadIRTest.QueryModel/Op=Erf.1_Type=f32_Shape=static_IR=2e5aed1612da0f720adb051e22460983a3911c38cb09184d812ceb949870f450_Device=CPU_Config=() +1256:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=874c0fa19029457645c4cff20769f66ba7aaa1a35ade84c948f83aaa9c1ead19_Device=CPU_Config=() +1256:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6167830634e0b253aa78e883453d45bb737cd5df33c849e4b16b99164fd49d5e_Device=CPU_Config=() +1256:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=510b36fcb991c73abd98b488eff26715dde08a322b7b9429cd897dce6976dab9_Device=CPU_Config=() +1256:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=3fec5c6f9e39d8a15d58c5800a889e1660adb375cb7660af1526cd31e69f7cdc_Device=CPU_Config=() +1255:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=67c29ca00af28406993de63d8e7782945a32705d95d4e6e4fd36fbf4e468a7f0_Device=CPU_Config=() +1254:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=ad5c5df7cea37955709ef71d9967828ce3f0011e68aa1c6085984f1422944058_Device=CPU_Config=() +1253:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9e21c0af425c90066d92577a0b8aadb6e9fdee50c197b15eea040b89eb715a6a_Device=CPU_Config=() +1253:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=81eb5381e1d4d3dc7cf0d83a9cd787813d3267c99b31cc9a3cb0cf9b01727c0e_Device=CPU_Config=() +1253:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=23389586e5eb8cacb13f6355565cddaf542d2d26439bd3d4b577fd716a37b53b_Device=CPU_Config=() +1252:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=edb5dc5a42b36879d5ced77fc2db7d8b331c888534602893ffb277f742da1005_Device=CPU_Config=() +1252:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=7201a55d869ac6072af38ff89dfac3cfd2e6720d25f7607c6cc5f80040a8e82a_Device=CPU_Config=() +1252:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b83a85737c23e279f8878f6795581dc2b003c55e4eb8baadfbfd73fb0e98758f_Device=CPU_Config=() +1252:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a848753a720bf9791ee4c239cf08712d714b877bfb6df23805590ad690ceaff7_Device=CPU_Config=() +1251:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=dynamic_IR=0b30cc6cee9ce5400085a0e78b44763bc169eeea93357f22fd716564f20226db_Device=CPU_Config=() +1251:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=cd5756749d3d73dc7b666f7f41dc292c73230e5d31ddbbd43aae77210b86220a_Device=CPU_Config=() +1250:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=38b9494dea51a8f26748bfa4be970913acee0bf6d97e526578e40e5e3c04faf7_Device=CPU_Config=() +1249:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4bbbaf50403494d1f876609b605bfc1382aeb9a1a27d2562083a8bfbe76ffae9_Device=CPU_Config=() +1249:conformance_Swish/ReadIRTest.QueryModel/Op=Swish.4_Type=f32_Shape=static_IR=d79b47022a50437c9df095b34e515c53eb042c9813fcf6dc7bcdb96962818ddf_Device=CPU_Config=() +1249:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=bff490cc95cf384b15409e96ee7d0995aa91640e23409cda381b85b2fef69e01_Device=CPU_Config=() +1249:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c1ffd0690c9370725a30028d2915ec798aff173f86a1864f3dc92a4defefef85_Device=CPU_Config=() +1248:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=7744b2351d112ed761ebe0f43945f7dfd58fd2bfbd94bc5a4737549923caf4ed_Device=CPU_Config=() +1248:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=21a3318957d920b39d8b3d84c76cfd2a5ad98515824f88145326deead0961486_Device=CPU_Config=() +1248:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=717ea579a24839ee9c5ba7c59a07af667fea4fd44ee18bf60e8970264852bde7_Device=CPU_Config=() +1248:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=851aa3cf931a01e0188758055b866fd14280bc344f548da6166e4a57ca7c9254_Device=CPU_Config=() +1247:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=d93633fac99f9472435ede6fcdb9c72475b68bf1352d58b33e8cbdf9ca74ac50_Device=CPU_Config=() +1247:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=944072d96554abf3ceac6b928cc00ea1705d5e0dfae8e9a0662de4e56fb3e62f_Device=CPU_Config=() +1247:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=45e4a607b0964915174f6a14de049a61a5740f258a4a71817e5aae1b93be5ae7_Device=CPU_Config=() +1246:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7509cd031f0085ad09a30a02057f1c0dff7ba78cd13f43ac124b33ef2cfd303b_Device=CPU_Config=() +1246:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i64_Shape=dynamic_IR=2c47f1ee19359a486a72bdafc2614159d48fffc80ddabe0f897212a454a75b18_Device=CPU_Config=() +1246:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=7f37f31081476643f5c279fddc3d25eae22d909730b4aca0211aa70fdd572843_Device=CPU_Config=() +1246:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a8ca0b23e0a0f66247fc693c6a8982e4f7daa11e14da296db0dbc9277fcad4df_Device=CPU_Config=() +1246:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f8ee6adb1573c51bcffdd8c24455ecd6b6fbf04f171e9aa5de36c5d6f18babe_Device=CPU_Config=() +1246:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=dc4bcacb769fc4d8f1ef4ff20ca7ba6b3b369d69ea3b1c65733d4cbd2cb0762c_Device=CPU_Config=() +1245:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f5f514f0e9ac5f357ad8b35c991975751b7481abfef63fbc338232ef15bdf7bf_Device=CPU_Config=() +1245:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=3bfc4cff938f4386af23d87ce10f8680a62a25ce1fa9178874f212edf45ee045_Device=CPU_Config=() +1245:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=fcaed70a044afad6974286c0d3e90f463ca73c7d1d8714c627be2fdfa341f87b_Device=CPU_Config=() +1244:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=491b849a7ce8fdb2190df5415fe037ff02fc23814efc520c343e872f539d6e55_Device=CPU_Config=() +1243:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ca5847147325177b69e97415489292ae793cfe1346e23e8a7bad000f9a702d91_Device=CPU_Config=() +1243:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3147f462ceda9b383de633ac08d6014a7779e74b169d3745990fa2b2799b1dbd_Device=CPU_Config=() +1243:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=936ac30f388261cb12776b5e94062a9b5f7b81aa16c9aa5d8f994b8d69231c40_Device=CPU_Config=() +1243:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=() +1243:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=0b0005b038a938c698489da595fd89a45d2f685c831bc172d81b2afc09658dae_Device=CPU_Config=() +1242:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=e939c4d2a27e1d7dba93827ab807881c32e47d48b726fec701712bc85c3404a8_Device=CPU_Config=() +1242:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=e1d727df48a0a74d8b9865c00e5c39c9d53a5023d83da3c58f281b6b1411b696_Device=CPU_Config=() +1242:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=14108fac0139d5bb39f6b2106857e1ac91c8d44ef9156e4e0873facf9d932316_Device=CPU_Config=() +1241:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=a3370e3b46f385ea6e46137d49d5f1b4158fe08d0a3e9feb47a162f6b3640951_Device=CPU_Config=() +1241:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dc9060efbe22735c22c69f0323c7e6a77a30cfbaae7b79670b9b26fb2be70_Device=CPU_Config=() +1240:conformance_ReduceProd/ReadIRTest.Inference/Op=ReduceProd.1_Type=i64_Shape=static_IR=7dba7222be56b8fcef943fc63ab00cfb3c7e0fb4467aeac96fd43aa4421cba86_Device=CPU_Config=() +1240:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=() +1239:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=49a0769fa4a26b3277c225f015ebd6b3bff05f8ab05b271a4fba7ea5a7e57396_Device=CPU_Config=() +1239:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=83e2d01e24eebe910418ed24fb506852c37576ce70c18d27de197f675f49c9d2_Device=CPU_Config=() +1239:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=262ab76d80fd9b35be837e391c9bf6c54e3d9124d25dead135ec19b75b1777be_Device=CPU_Config=() +1238:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=d6be1de020bbe6277d8cacd77eece21f766e5e39badb520ef29e880d52e3604b_Device=CPU_Config=() +1237:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ac619545b2ef19185f57aba7a31752da1029c572269af4a3e0d95dec2c9e64e1_Device=CPU_Config=() +1237:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=01b095b8763565527be0de9edff565070949485db907493e99e95c2cddf6abaf_Device=CPU_Config=() +1237:conformance_NormalizeL2/ReadIRTest.ImportExport/Op=NormalizeL2.1_Type=f32_Shape=static_IR=3bfa35b53e4bb74a9e450b1220a5d3c061f050e498cf86c8f72118052b7fa252_Device=CPU_Config=() +1237:conformance_Equal/ReadIRTest.QueryModel/Op=Equal.1_Type=boolean_Shape=static_IR=9e166ed18be64949ce2451a1dc981381040fb109ee60e13a7f47308caac73e24_Device=CPU_Config=() +1237:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2a819b46a29c8bd965ec330a28b5c163dd0a06fa2717d71bd16493ad460e8dad_Device=CPU_Config=() +1235:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=c7a696f3217515ef4ff5eb46fbd15af6533f0fcd268398fbd434f105c0a11328_Device=CPU_Config=() +1235:conformance_ReverseSequence/ReadIRTest.QueryModel/Op=ReverseSequence.1_Type=f32_Shape=static_IR=a5cc0793d73f7f76fc02b5ae04ef2a29bf212ce5c59f9bbef91e0aa5ee17785c_Device=CPU_Config=() +1235:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b3cb0ba09807204990d7e1635ef35fc96aa10330de2ffefd95f6483e68dca532_Device=CPU_Config=() +1234:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a3bc997e1de8be5fd5b66a48e1a9ef4bf9e4143cb12313b2d9adf3dc12ae0111_Device=CPU_Config=() +1234:conformance_ScatterUpdate/ReadIRTest.ImportExport/Op=ScatterUpdate.3_Type=f32_Shape=static_IR=537f04d52049add01923acd0c57cee03462926f9ce213a4fc9774496f5f66398_Device=CPU_Config=() +1234:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=3fbff9f870428a19ed434cdf72834eec251edc3dddd149491c94319d63a8438e_Device=CPU_Config=() +1233:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=8368b4f6e208aa4cfbf0aeaa648e9408c281a71d98d15ee09407d26274fb349f_Device=CPU_Config=() +1233:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=edb5dc5a42b36879d5ced77fc2db7d8b331c888534602893ffb277f742da1005_Device=CPU_Config=() +1233:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=68f6c55980c58f4d6de9e948d1c034b712cf74de509d8fd825fe7f7dfb11550f_Device=CPU_Config=() +1232:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c3e5791580edfc2b522c8a3aecd33445b3fa8d771e2b5a8387ef0f303773c848_Device=CPU_Config=() +1232:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8fce2d85c65eb0e8b40c2923338675276902296daf8744322876552dcd68f7_Device=CPU_Config=() +1232:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=508a961c358d40ddb6906694a24f87dc24f74cb4643aab58ee1d6fa28f099e6b_Device=CPU_Config=() +1232:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=cbb80f496fd705f24fdb25f6de3734bb2a2b7f49c984bdb32c4f62ec4640797a_Device=CPU_Config=() +1232:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a56e05bb4d67e44e8e5dfd902b97af411de05a0f5b1ae1c07a074286c6636b34_Device=CPU_Config=() +1232:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f55c473236715e5c4e6ec21a9e07d1c73b14d529b57fae0cb38ef9d6cd383b53_Device=CPU_Config=() +1231:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cc0f83b1e6167e74fe1198511d4fe4de611a24a0daaefec2eb2bac280de9c5a0_Device=CPU_Config=() +1231:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=31dea0868f4a13f6a25819e26ae172201cf3d52de718fc200edb84cafe7c2cf9_Device=CPU_Config=() +1231:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=0138363d3baa37869a3e55e1b059a42a87612507ba318e753361a58549ed5ec1_Device=CPU_Config=() +1230:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=i64_Shape=static_IR=6590ae34a784f81de25c016454fcc919ae1f9eab672c78c9da0daf83dcdaf1bc_Device=CPU_Config=() +1230:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=246f55d43a6e986a8ba35f711c43dd32cfb1ca097598b0a01690d4765e0d5019_Device=CPU_Config=() +1229:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=7f37f31081476643f5c279fddc3d25eae22d909730b4aca0211aa70fdd572843_Device=CPU_Config=() +1229:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=i64_Shape=static_IR=6590ae34a784f81de25c016454fcc919ae1f9eab672c78c9da0daf83dcdaf1bc_Device=CPU_Config=() +1228:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=d1d0510ce6d862a5512bf4c5c588f84548f1aed0226eca6850b5e2d470a5ee84_Device=CPU_Config=() +1228:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f84bcf4f549ca0d6e75c7905f1463fbace4f3b955032fcae627e46e353b2aee9_Device=CPU_Config=() +1228:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=933c6450f6856b32e879034662cf60eca53970c10106f8a11eb925e5621042e9_Device=CPU_Config=() +1227:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=e77dc4aecdbd4ab3d67fc3c1d9e350a9d259af1d4c0188d680121a31c6ed8ccf_Device=CPU_Config=() +1226:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a99922ad73b3ea50f32af50b856d393aeae4b3afe901a2af8fee5aeedec9e9c7_Device=CPU_Config=() +1226:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=6d5907929d59d1f99e85183238e29d6602c84721d099284dcb8900ae5fc3c45f_Device=CPU_Config=() +1226:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=53108cff3836c47360380f3898c5de245a566a5d98040820d78befd46e56955b_Device=CPU_Config=() +1226:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=510b36fcb991c73abd98b488eff26715dde08a322b7b9429cd897dce6976dab9_Device=CPU_Config=() +1226:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d242e8ecc8ae0239fc2e7773fe0f8a1d50792a71ae4aaac4fd439174e87e95b1_Device=CPU_Config=() +1226:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1adb71d66ee918c5806737933d1c78f93ab48190df44f3cd8c928f5b0aa7d9a1_Device=CPU_Config=() +1226:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0e78ae14fcef33de9637ac99e87f672b3247ea32c221a4b555b2e5bbdff88788_Device=CPU_Config=() +1225:conformance_Round/ReadIRTest.Inference/Op=Round.5_Type=f32_Shape=static_IR=f4cc9554ddbd189f18575e3a80afe6e8f8bce613dc8852a48d4171ab6916e087_Device=CPU_Config=() +1224:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0402d5c12674452050553b4b26ffea14a2107eff83f28b23c10a0a6f847bab71_Device=CPU_Config=() +1224:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=b94d2ed6a2b113922805a69578ec5ba2ba3d8f0ea46ca37f095b4ccc94d76b77_Device=CPU_Config=() +1224:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=97a94ab826d2992013df32a4f93f6adbc38ad17a26503005046f68904adf53d1_Device=CPU_Config=() +1224:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eba756a8d0ce89c9a8df50baeaeb82d5b719461bbaa06386db7e1be10ec535f3_Device=CPU_Config=() +1223:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=4541365c567e68739f0733edba54e889f231026025e6866f805446392c575960_Device=CPU_Config=() +1222:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=b91a183b8c36d6e8358dad7056638b8091005393dd1ee6813728f25cd3e6a9f5_Device=CPU_Config=() +1222:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=72c58b462f61521af4eab9c890e568b5676c7a3194c4e35f8e04f98596013c47_Device=CPU_Config=() +1222:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=a3add607f5e37633f3298794f8e32e409e3403666af3c0fc57c7d4427b714eca_Device=CPU_Config=() +1221:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=745c0804609863998b4bcc6956b1e78fc221e0e4f1535ab09b89a9c966a16995_Device=CPU_Config=() +1221:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c90b6f528b750f144ddd29be0059c202d46b3bac799c0d70893f2f4f9f05f64c_Device=CPU_Config=() +1221:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=d7fbbe9f8f446b009ea2de8594e4cfaad46432734cba27596e3fa721f04c04ee_Device=CPU_Config=() +1221:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a46f51b7498c921515a53b67480ec4d413ed43ff809e1fa6a4deb7365f4a0460_Device=CPU_Config=() +1221:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7754523e2d3739481e051eb21a4347f2d157e94db3c37d47f0006ecd8d77d512_Device=CPU_Config=() +1220:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=0d413b2d40036984ce2b85933c4b5ffda416e8779a20b602095d2654db296d58_Device=CPU_Config=() +1220:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=91281faa51b78893f7106cd8fd05ab98460a328bf6cf64d930aa5635d2f90c90_Device=CPU_Config=() +1219:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=79e8f7fcf25912270ec9b6d16206e5f54a678fbd174a31781524e7a976e500b8_Device=CPU_Config=() +1219:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=7a1d8cbdb446c3330ed845d7a81e20d9b7c7662d532f4d816d4fc1c56822fa81_Device=CPU_Config=() +1219:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=3ca9994321c7492af9bff158852a484636638e711ae39a6acb66d273f696906e_Device=CPU_Config=() +1219:conformance_Gelu/ReadIRTest.Inference/Op=Gelu.7_Type=f32_Shape=static_IR=8876bc4ad78a178f235f48e06e705a7dbd3f7ca06e3ea5052e6136811da69d20_Device=CPU_Config=() +1218:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f8e0d0e358dfa2f404e60abbb4cf7a170f79a17291f48b69743d6da0635e8a98_Device=CPU_Config=() +1218:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=dda9a81656cbcb4ab5484fea52e7172baf67d46babce886726c96eaa1980766d_Device=CPU_Config=() +1218:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=f45b24f3bf21a2c94bc89cdc3d20c283d47f4e6ea386444897330e232bd7d90f_Device=CPU_Config=() +1218:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=f31f6d969e04a7a1c964c02f107a7291c85067ac31d935921bc418363c2a7a46_Device=CPU_Config=() +1218:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f9b090cbcb19663630a1490fe18357b752e430ad793c0e3aaabedcb74ab64934_Device=CPU_Config=() +1217:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6af32fc288bcbd414ea63525c4345aeda74ab21c44aab5910f85b8b7fb5d1179_Device=CPU_Config=() +1217:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=00d6c2465c4fa7ddab80d30c2fd8099a684bcc47cf9bdba89a39560beed737f6_Device=CPU_Config=() +1216:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=95f63bbef529a44cd7170b83f4b385f0c1520f117ed7b4767527daa0fe893316_Device=CPU_Config=() +1216:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=4420cfb7f4a734731dacfe5b0c27db41ccaac2ab8bbff56cac0f99ed96e976f2_Device=CPU_Config=() +1216:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=62b8aaf25e8c93387362b0c657886c31c39a7330cf3455486b8943a1e375ef5c_Device=CPU_Config=() +1216:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=d066432a0ddac020441582a98f139d063cf5f4e9f34deaa0be5ab9b9f048aa0b_Device=CPU_Config=() +1216:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=c4e2668f98d5c21fc085695c9b6037f08a1e6710e1854fa73b7465a618e99b95_Device=CPU_Config=() +1215:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=() +1213:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e7a4e6690e4897a569e29f61636fb4a99f645229fbfd2a68ecbf83b21058dcdf_Device=CPU_Config=() +1212:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=817b3db8f96297276bc70f1b4854867cb92c164925c9dce59a1d054e3c315bee_Device=CPU_Config=() +1212:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=33d8f6d258ae8dfd09b8e6fd39f0e74384eabfb685e0e72a3c798101ea56a1d2_Device=CPU_Config=() +1211:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b94603cd976e1acfa5a3f8310be1e05800114009541c22ed53c0c07cd0816685_Device=CPU_Config=() +1211:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8b55c14423b60f30029c68c603417fb98119c5922e2827c60c99edc05ea813e1_Device=CPU_Config=() +1211:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9984b8a3f89c63f522926899b38043623619e9b47918f7835234a4ea5f615c21_Device=CPU_Config=() +1211:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=6ab37e1d52328b5ce1204cfe13977b06dcfabeb4acff9821d65ffc91bd3cf09d_Device=CPU_Config=() +1211:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=efbe921ab3c27a093f20ff704fd02e5c610e7507d94a2d2092379c5a99743380_Device=CPU_Config=() +1211:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=c18d3d2fd8001cb07daaa5000258b36352807e3e81999d2d80a668e4d6add085_Device=CPU_Config=() +1211:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=ee49657e646466b0c22aff01740a48c1cc271a828a8c3e10a21d75b04f511cb1_Device=CPU_Config=() +1210:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=af74e05cf6032c57a3ecd980402b9694581a8823946e3f1c76716692a7747d4a_Device=CPU_Config=() +1210:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=034fadbf9527892e159709c266c12c4863ba0f7bc559f4248afc517f3c2c6938_Device=CPU_Config=() +1210:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43aed1509066aa7c839a82c9865228ce3ebdfbe519061649807875ec6e86d715_Device=CPU_Config=() +1209:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e8c5e89b62e32721ef30ee1c8f4b05fe5656003c0b5039afe8ffadd8752668e2_Device=CPU_Config=() +1209:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a59a3375ee8c7a9958b6d66c5d199df2a05bb1815063f149a063c09f6b288e9a_Device=CPU_Config=() +1209:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b91ccf96246dcf055dd9122c823ccc54ea572f1ad8fcbad3a98c88edb7e454c4_Device=CPU_Config=() +1209:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=3e669c3f90fc7b2209d3d588932f8eff3827309a5928f4b27722139964e2c46f_Device=CPU_Config=() +1209:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f0472c0e5ff8fb82651424269bd9f77e73eff6c43c70b6192f07303c0d35db8e_Device=CPU_Config=() +1208:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=63bf42d0ab3a502b446b21489f7320d954a2f4f00a1e11da7d9b948fa1f6cc90_Device=CPU_Config=() +1208:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a78437a93ab424a706d064188d1bc0971b2e1afc98a74fea979a6f8b99036597_Device=CPU_Config=() +1208:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4af234310183dcbe89f887b3282ac2ef10637d5f5580e128c49958c1b5628db2_Device=CPU_Config=() +1207:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=8832b317ba58dd0efd1e8fa5238d35644d8468a03c9b35809a20ae64098dc986_Device=CPU_Config=() +1207:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=38d935b0aa7266960b3d349b60c97bb15f535faed953fbe3ff24ae2560828f04_Device=CPU_Config=() +1206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2c34b5434230e59b65b5e41e29541c4f1de46e8f76604530fb669b21b7f7aa2_Device=CPU_Config=() +1206:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0c5ac67592b69e8c2b7acbae7a0f877cfed184c572d2fae09eb8fa629e86eeb1_Device=CPU_Config=() +1205:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=d6be1de020bbe6277d8cacd77eece21f766e5e39badb520ef29e880d52e3604b_Device=CPU_Config=() +1205:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=d25e26d9a54a5dc9799e9881e3035bfd5f125d12ea6cb69fb1eb0166e29ec88d_Device=CPU_Config=() +1205:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=01d609bdfca9f2a499a564f66ab9dd71b394310593d27b8739283b19980e2dc2_Device=CPU_Config=() +1205:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=24e44f75d91fe4e7e28db6c93870a47d536abeb87240841ff5b7e74b40189e42_Device=CPU_Config=() +1205:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=2c5e9a1cd59ec2d5786132697bfcb1519a7857cdfe06038bb39abed39c09e9a2_Device=CPU_Config=() +1205:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=c4d8543f8e0b375407e428ef119ba4049d44cc273a10661b57645bcd1d36f5cf_Device=CPU_Config=() +1204:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=d1d0510ce6d862a5512bf4c5c588f84548f1aed0226eca6850b5e2d470a5ee84_Device=CPU_Config=() +1204:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=2ad5b63ed56c3966570062970125d1cac16629595e9ac34c6613cf00d6dec0aa_Device=CPU_Config=() +1204:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=1e5127a9c21ad1ccabe67dd1f1e28a3730c09ba294ef1f9fc001c6dcd723ec62_Device=CPU_Config=() +1204:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=3c7c072c9e4ee694e049a5f256cf0e72caf85384291ee8d399ce136d22c575a3_Device=CPU_Config=() +1203:conformance_NormalizeL2/ReadIRTest.QueryModel/Op=NormalizeL2.1_Type=f32_Shape=static_IR=e177da00e93cb595c18d142e92898135415f0de01a3b1ea763f3ffef3d7ce96b_Device=CPU_Config=() +1203:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=c8ec200fa8fd8ec9c185d9d45ee1380be5e0e4a6f3157e5900401e9fce999553_Device=CPU_Config=() +1202:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3e5930f1ff4ad9d9e53216b6f8f912fc7ba051bfc85c46ce2dbcddbcd357832c_Device=CPU_Config=() +1202:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=745c0804609863998b4bcc6956b1e78fc221e0e4f1535ab09b89a9c966a16995_Device=CPU_Config=() +1202:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=static_IR=da15c9ddbf446de00565c83e95b8a554d400b8b925481e56eb3df41f7efe26d9_Device=CPU_Config=() +1202:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=a29bdaa31edbcf7b3dc392625c0aa0a27e827e1363d52519858c93defbf9ebac_Device=CPU_Config=() +1202:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=776018866cd0a06171706794dcd0d7bb13b5960fd98a66b306ecfac7595feec9_Device=CPU_Config=() +1202:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0bb9a29f02d37ba32dc29b4284f58e10ce59571799f58381d449c77655c795d6_Device=CPU_Config=() +1201:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=00d924b3557896a41b0be32897f7b7293fcc44d79a285e91695a5fd2f29f3b8c_Device=CPU_Config=() +1201:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=f5d3b4ec51e032e4df5dae00ecba1a3198c29cba96c72b8c89126c4638b715d3_Device=CPU_Config=() +1200:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5b654dfb551ec2d83e22a133055d78f13153fc1554728e34aa7f27a3f3c08541_Device=CPU_Config=() +1200:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=91281faa51b78893f7106cd8fd05ab98460a328bf6cf64d930aa5635d2f90c90_Device=CPU_Config=() +1199:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9931c7922649d308d88cc08efe90d6e99e06e0234b1b9679ba5c90fb2793613c_Device=CPU_Config=() +1199:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=134ff6b704123c583b694d7023c99cbcfd10a1afc48819ef35b46dc4d0bca500_Device=CPU_Config=() +1199:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=134ff6b704123c583b694d7023c99cbcfd10a1afc48819ef35b46dc4d0bca500_Device=CPU_Config=() +1199:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d8a48dc7581c2ece0179d0ad668e8caebdddddfe492e365ea2e0e5f3a7302eea_Device=CPU_Config=() +1199:conformance_ReduceProd/ReadIRTest.QueryModel/Op=ReduceProd.1_Type=i64_Shape=static_IR=44e0e688ecb44d7a9e83f7c9e1639fae49b2883dfc1b1ed588c98c5bd1f614fe_Device=CPU_Config=() +1199:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=10cf1b7a4de1231ad721c9660697d6ee17bcaa2151f08eef596b41e6e3aa1b2f_Device=CPU_Config=() +1199:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=() +1199:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e3a25054872107eed50b9d6d9d612c46b781ab5ba4fdba17988c2c73a48a37bd_Device=CPU_Config=() +1197:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=134ff6b704123c583b694d7023c99cbcfd10a1afc48819ef35b46dc4d0bca500_Device=CPU_Config=() +1197:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=5840000517cf6690e3b881e338ab887afae81129e22bb0e3c71b049e42ccd68e_Device=CPU_Config=() +1197:conformance_ScatterElementsUpdate/ReadIRTest.ImportExport/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=() +1197:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=cbb80f496fd705f24fdb25f6de3734bb2a2b7f49c984bdb32c4f62ec4640797a_Device=CPU_Config=() +1196:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=99a80c495a8fb4626995167a3ad2efa0efed7696459f6219125414a2bd20dfc5_Device=CPU_Config=() +1196:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=dynamic_IR=214b1d4be2a141409b6b54847c952a282d9b2d7236d3d8ada3463f7dc8554097_Device=CPU_Config=() +1195:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=49401e607e42aa23290f59c3d3d64d54eeff9afcdf99177506283d43b6a43928_Device=CPU_Config=() +1195:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=87c65c520de106b146e91222609f5b25cd79e96cdd6b942c3293cddb656617ee_Device=CPU_Config=() +1195:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=166d8442037dcf0469f0b14ab83676b30bce53edd79494c52a575e3744920c4d_Device=CPU_Config=() +1195:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=77b3b21d35d3742f7abc1097b99d510453f42ebe921681685fbc457d2fa9912a_Device=CPU_Config=() +1195:conformance_Exp/ReadIRTest.ImportExport/Op=Exp.1_Type=f32_Shape=static_IR=67632b67a0834136cf2f3bcd6b3fbaf0d2f2bbffc1da6c33fd5fce0d0b8a763c_Device=CPU_Config=() +1195:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=417040fb77f62e577234ea0b8c1ef58ee0583e1a3c643af1da5c61838c2ff1bc_Device=CPU_Config=() +1195:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=27dd1a325584acb3e37f6e30b23289b679ab9cfb28c4aaa1999b6ffb2ddae41d_Device=CPU_Config=() +1192:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=dynamic_IR=2af646407076eafcc1ed2d628158fc32eac4ef2fb34fb967962c06f81376d61c_Device=CPU_Config=() +1192:conformance_Negative/ReadIRTest.Inference/Op=Negative.1_Type=f32_Shape=static_IR=c29451ffff103b5e965a1bbea7994ef6da6394060855ee071b9e7a3a4702141f_Device=CPU_Config=() +1192:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e8703e68163db56928e366caccc3d2d89fbd35aba3c95af33a9d615659871d8e_Device=CPU_Config=() +1192:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=dynamic_IR=8029d5dae7f4721807eb717310512bad44630efdd0a64962496a0fd802a12325_Device=CPU_Config=() +1191:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=178677f6c6e3857b2c3aa8765c8e3186bd25b73154ba6463ff33a9e1c911e6bf_Device=CPU_Config=() +1191:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i32_Shape=static_IR=5224ffd078708e8917b14b4118bc4a42317c123dc0a5dca8234ad73d44daf845_Device=CPU_Config=() +1190:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=94365490bb772d689007e25754e20090137a936cbe1a6a3739b573c644f3f318_Device=CPU_Config=() +1190:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=bc90fb9a95a74efb937b6cf808584dd1e91aa6c4d774640b51f4325f0aca6b42_Device=CPU_Config=() +1190:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=d50dd7c19583071293118e8b98f2bc749ef3e34ab8eb0149138e6b9fe49a153c_Device=CPU_Config=() +1190:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=5bfbbb826bcb2c9e7b5364fcc5da23e737953150029c2ea7455ad4b09caaf01d_Device=CPU_Config=() +1189:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f76dea75751ac96986fc17a4d344078ae4aae2fa2304b26e72d81f369986a9eb_Device=CPU_Config=() +1188:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=fe80951a0a44625457a6106d8613c9813c9c0b8fe3606fa5ac1c064217c8a0e6_Device=CPU_Config=() +1188:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=3d37166487c5c52af657343f8fa10903efc7d580d5b370a519a0ccfbf6fc56bf_Device=CPU_Config=() +1188:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=6e1207753b08d53b18c551ad07a245243197370051be78218db028f3d3b835a5_Device=CPU_Config=() +1188:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=() +1188:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2ef3273b8c144dedd6cc2d2b8c2d2921d999fa286b10d90aa796fa188dc52cef_Device=CPU_Config=() +1187:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b57367632c1064f82de68ae9aac88d8522a6039ced4d1078483cb2c679785f04_Device=CPU_Config=() +1187:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bba92f0e1fe2ee647564aec64223ab2c5b32d3defae9bad5daa5a24df76aac48_Device=CPU_Config=() +1186:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=fb8064c0836e50254162e2a9cab01514f76b19f78084410b6d1b69bd54f93168_Device=CPU_Config=() +1185:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=12634194f9e192663deb30a2a1af450542d8cb78f1dcbe1f42a169588810636c_Device=CPU_Config=() +1185:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0ddc207725ba9ee303b566526c77f7921016e12230cdef3a724e77e2a9e603f3_Device=CPU_Config=() +1185:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=8b8efa859c54f9cf2200c18953de243d469d2f04bf38ba5f3efe441de23ffe45_Device=CPU_Config=() +1181:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=66ab5cfd788be1a5ebe89e70a1318d6b905d3600d0ac5a967d07a0ad6828e7df_Device=CPU_Config=() +1181:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=() +1181:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=64186bbc89d54f073554e029b8972fbbfba2abce8026a379b7ac3833f84ac9d4_Device=CPU_Config=() +1180:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=f1e43476084575ad240db6631f433a61ba2076d1ca95e44a0e4471ea9d6f66df_Device=CPU_Config=() +1180:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=ae817dcac1ed2395cc4098f67bf6d2bcbecd8b7e91ef7592622d1ee75ed4a3cc_Device=CPU_Config=() +1179:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8d88e8ad02fb6c2acd45c736689a1de8d5a54f6a2ac5b6618d5fd9b4110874a1_Device=CPU_Config=() +1179:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=00c74cd8491e5a74d86270cb7657f9a7e431f820cc7c6421a5cc278cd8f13fe9_Device=CPU_Config=() +1179:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=i64_Shape=static_IR=d4acbcb1930b26610eaa33c0bb8aa7fd866d8142afda9fd007226f0ee6fa5c36_Device=CPU_Config=() +1179:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=bbf75e5f7aa9f20f890a8eb204ddb5f159ca5eae0616fb99ee0b5169b165d595_Device=CPU_Config=() +1179:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=168e02701204a8f0e325fa1a2a4407612df10c3218c9431981fa6f1f8300eec2_Device=CPU_Config=() +1179:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6fefc3626ba6ef60433d3635bd5abeb3e7025277a86e2fd9d92234ff099c303e_Device=CPU_Config=() +1178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=08a654f35ce851709d2c0634533645f6910b394b9cbb4bc6ddf20860f3a09c48_Device=CPU_Config=() +1178:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b391194df168bbb18b31fc1546168c2693ad3387d562e44a102467833fd992a3_Device=CPU_Config=() +1178:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=f32_Shape=static_IR=c14da825d470c9141af0ea87eb82edd0866a415cb5ac59f1014c2ded35340201_Device=CPU_Config=() +1178:conformance_Range/ReadIRTest.QueryModel/Op=Range.4_Type=i32_Shape=static_IR=8d3863956a8a6a5067c45d40ae0207b14b9f1736bdf2a5b8c01979fbc012a5e9_Device=CPU_Config=() +1177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5eb341117f8535a929c96a55b0a932c37b1254f07a03af2a05a0862c7c2675aa_Device=CPU_Config=() +1177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b4c9edcf320dc72ad463dcf64da84add367d2ea5eaf1a8524793f37a5eae7c7c_Device=CPU_Config=() +1177:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=78b35bf08a9f69a1b07d5d6ce728839e08f51739c60583cb094e4abfd6fab1e3_Device=CPU_Config=() +1176:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7257c42699a127367a2904db71c700c5cc94b265e3132a6737f5503950f90fcb_Device=CPU_Config=() +1176:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=9031b1919c35a9df591ff64fbe4748c02cc837649899099542716f35b5c68cc5_Device=CPU_Config=() +1176:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=d93633fac99f9472435ede6fcdb9c72475b68bf1352d58b33e8cbdf9ca74ac50_Device=CPU_Config=() +1175:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=00c74cd8491e5a74d86270cb7657f9a7e431f820cc7c6421a5cc278cd8f13fe9_Device=CPU_Config=() +1175:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=56fb4fb30ec6fd9ddd0ff2e394434eb87546ac7de273f47b663252efa2a380be_Device=CPU_Config=() +1175:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d73edb68da4aee1c052b79ffce030b368f204c04bffd9a9dc01a9b54de932e7_Device=CPU_Config=() +1175:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=717ea579a24839ee9c5ba7c59a07af667fea4fd44ee18bf60e8970264852bde7_Device=CPU_Config=() +1174:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i64_Shape=dynamic_IR=2c47f1ee19359a486a72bdafc2614159d48fffc80ddabe0f897212a454a75b18_Device=CPU_Config=() +1173:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=adee3d4d6728b17fb5ab17a9915c5b7c8808f949ad358e8a16a0bb12dad7c958_Device=CPU_Config=() +1173:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=f31f6d969e04a7a1c964c02f107a7291c85067ac31d935921bc418363c2a7a46_Device=CPU_Config=() +1172:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=47276c4baef1814b69d8ce1a1353b2bdc02ead92a476e9d278db1d3093c5b0c1_Device=CPU_Config=() +1172:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d8b8999a17ba375cd8b7bf18f4d9d932fc6f5b6787484633c9b11f6003eb8270_Device=CPU_Config=() +1171:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=8fc5ce53f1f6b924371ab2cf156ddbf7aea234b17befdcb6206ba51a7ad988c9_Device=CPU_Config=() +1171:conformance_ScatterUpdate/ReadIRTest.QueryModel/Op=ScatterUpdate.3_Type=f32_Shape=static_IR=537f04d52049add01923acd0c57cee03462926f9ce213a4fc9774496f5f66398_Device=CPU_Config=() +1170:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=2233a83397f11ea3c674c4845409c4f27f8bffbb8d0295712a2525c9e93d6041_Device=CPU_Config=() +1170:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=18697d690af0de3ff8365a5aafa6ebc7d8e14418c3ab5dd55b3b505d2445ac86_Device=CPU_Config=() +1170:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=b11ede8f1aee40577413d8bbe89704e02252e3f02805fcc0ded624857ddb8280_Device=CPU_Config=() +1169:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=5f8b64ad8dd9ccd202ae8d5080ce166fe9f47b909e803da49546dbffdfb4ab3d_Device=CPU_Config=() +1169:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=2ef8d38ce64fd0460d641e6f3bfcb1654bbe3d2c25f9dd244ae259eaa4b6941b_Device=CPU_Config=() +1169:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=27e8804992c0d74c18c958f0876c06be6c7eda2b36fe7de3ab616b577dce13c6_Device=CPU_Config=() +1169:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=9bb8728e6e9f68cf68a9e39d1aa4c618c4aca4187d4262f735c0647d680c0506_Device=CPU_Config=() +1168:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=b7b0a0b3921a1e1434a3fef630e32b124c810e8bd15a3e861fe7da79158947b2_Device=CPU_Config=() +1167:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f0fc8ad1a674a35de1f2e88a1f17905801a6f083a37f5fe658ecdd6d49d30c40_Device=CPU_Config=() +1167:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=625213da165aa2bc036bc690db1a2dd0630d6baa20a5c79e26d52aa2abd97557_Device=CPU_Config=() +1167:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=dynamic_IR=a9636e6e43bc01f8b1cfcfcd8e60e4ffba20837d0d3b80429c93f23cd8da89e0_Device=CPU_Config=() +1167:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=c4d8543f8e0b375407e428ef119ba4049d44cc273a10661b57645bcd1d36f5cf_Device=CPU_Config=() +1166:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6eb80b60b2162fc469f652535ee11822ae34c903ca44191dc95ad7f9678b9337_Device=CPU_Config=() +1165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e8c5e89b62e32721ef30ee1c8f4b05fe5656003c0b5039afe8ffadd8752668e2_Device=CPU_Config=() +1165:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8584e2e87ecb2b209221a133f2e3761834562a7b74e7cebe203759f3bd5d40ec_Device=CPU_Config=() +1165:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=697bdfc59094203ea1616203d64759a40193f1a23a4a51f11340a7912e355cd1_Device=CPU_Config=() +1165:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=69f4c39c3fb2dfc55714893e1e45761238e74bf28ecfadbee3f4965b5a379888_Device=CPU_Config=() +1165:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=f73224b14c094974e582d3d903cc332f5c1da138368692e5d0be93127f1bf753_Device=CPU_Config=() +1165:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=79a6d2a402cdd74cf1277a57ff95b71d61384da394ad2a4d9ebcf422eb5c3258_Device=CPU_Config=() +1164:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7f595d19716e871ad3301526008abcf663271669fa7d55bbf292a853e9ff517d_Device=CPU_Config=() +1164:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=3837a665cc6a05b0f8981a4670a4611739b070db2f5ce97ad05cb256eed5c994_Device=CPU_Config=() +1163:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=edbbf6122999103bb19f5d7d4f694ed72221dbc69fe8912853e01a9125eb46d5_Device=CPU_Config=() +1163:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a08cb2499595ed0de5c51e3b0feae24d9d5462d227572e771862564e1875b6ef_Device=CPU_Config=() +1162:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=83e2d01e24eebe910418ed24fb506852c37576ce70c18d27de197f675f49c9d2_Device=CPU_Config=() +1162:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=033c6bc337d14053ae097dcbee99ef5de7cb7728b589cc8d64783467505a8ba7_Device=CPU_Config=() +1162:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=6dae5ccb2325826167ff4ec57e51280b4e125801e6405a33f4d95fd9ab9f3fc5_Device=CPU_Config=() +1162:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=84f6f3544adcc7c68df5ca411844cf36c2232c1b6c820094e5693a444faa143d_Device=CPU_Config=() +1161:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e1f0357795d5676c5e4a38b6639cc90c924880ab961eb73e407b5ad0142ac0b4_Device=CPU_Config=() +1161:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=a3add607f5e37633f3298794f8e32e409e3403666af3c0fc57c7d4427b714eca_Device=CPU_Config=() +1161:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=dda009a1f3191e35286b7515f5741905e303f27287041248e2ce15f6954af810_Device=CPU_Config=() +1160:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=79e0a530c5a64063a9af26b438f208476e3bbf5a267c28ddded0459019a1d8e1_Device=CPU_Config=() +1159:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1efc6b30d556ce23e43b764ed129522616973e621c0cddb33de66568cc74ffbf_Device=CPU_Config=() +1159:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4a8cdbce9473e7bc24866edf0f5ec0f5a95475da63cea7ef68a4fef7b9fac1c4_Device=CPU_Config=() +1159:conformance_ReverseSequence/ReadIRTest.QueryModel/Op=ReverseSequence.1_Type=f32_Shape=static_IR=1ff07d9b87513cab5bbcf5059507b8c998fdb25d2802b267bb6c0b90eb3e231d_Device=CPU_Config=() +1158:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e32d74280a8000202346421945e400d248efb3d72bb67473f81c7a2eafe86fca_Device=CPU_Config=() +1158:conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=f32_Shape=static_IR=f735a44db0a337a22f5ebed052a5718168765287ff4e0eca961c3f9fd68586c0_Device=CPU_Config=() +1157:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ac12549a897d099d4b2e7c3872b9b9588639b7bc484648662121cffefd6c04a8_Device=CPU_Config=() +1157:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=94c0bd6d26bbfc0a8f22050757d17bc051a7af85dc6d6447d51413f2bf779a95_Device=CPU_Config=() +1157:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=12e7ea655764a32069a93a3f7ab147983bceeacc8a2bc88fbb2def005a1596b3_Device=CPU_Config=() +1156:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=84d3a33f9325d947a72b4e26d046e3e3f9cf41091f7c8e1c654899b3088ce6e5_Device=CPU_Config=() +1156:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=5f8b64ad8dd9ccd202ae8d5080ce166fe9f47b909e803da49546dbffdfb4ab3d_Device=CPU_Config=() +1156:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=6e1207753b08d53b18c551ad07a245243197370051be78218db028f3d3b835a5_Device=CPU_Config=() +1156:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=5840000517cf6690e3b881e338ab887afae81129e22bb0e3c71b049e42ccd68e_Device=CPU_Config=() +1156:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=fb8064c0836e50254162e2a9cab01514f76b19f78084410b6d1b69bd54f93168_Device=CPU_Config=() +1156:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=5a1aa66136ca2be83f714067139e11fcbf672d73f8b28c57d29333b885a17f83_Device=CPU_Config=() +1156:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1fb809952e397a442265bf095e12fff4e88e0e349323813dc40b74aa2fa84924_Device=CPU_Config=() +1155:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=66df22ce11e7009aea35ba6a11b4294eda44815bf041eed0721499a3d2c484b1_Device=CPU_Config=() +1155:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=53192c27f09bf3c756e64820ae6b0a01c5e48535df5d5b91ef6dbd6d954eb6dc_Device=CPU_Config=() +1154:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=65a5483c793396983edaf7f2cc2c13898507525bd84a8469e97b2d662b5df782_Device=CPU_Config=() +1154:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=80938e021a1ae127646a1f7e09de3970f443d853b6efe5116383ae37825f57e8_Device=CPU_Config=() +1154:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2d88673274bc292b6ff26da9257cdc11b66e89c1f94d38e25ba6e8e74e647533_Device=CPU_Config=() +1154:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=() +1154:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=61091e18fb5e9eddcab243ec79234ef3b93a5d01d9b2611a3a0e027eed4e4b31_Device=CPU_Config=() +1154:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=i64_Shape=static_IR=32ab4bca2ccc66d25b8b9ac449dbc58666434d98aa5b789e1aa28726c530986e_Device=CPU_Config=() +1153:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=93dee798d72e36c04cf60499e95f84cd6b63d84226d7dd1dc0edcf0875cf301f_Device=CPU_Config=() +1153:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=86c848e55f2afda40170f7cfcc9c260f896ebe2c73819f75a124dcb67cdd6a75_Device=CPU_Config=() +1153:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=6ab37e1d52328b5ce1204cfe13977b06dcfabeb4acff9821d65ffc91bd3cf09d_Device=CPU_Config=() +1152:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fb30e40bed920f35420787b2bd98f04d496df16cc51c355611af5307cadd605d_Device=CPU_Config=() +1152:conformance_ROIAlign/ReadIRTest.QueryModel/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=() +1152:conformance_NonZero/ReadIRTest.QueryModel/Op=NonZero.3_Type=i64_Shape=dynamic_IR=31f428e60ddfdb3cb3c98c2cc858d0409fd35c5e6e97f9dcdfbb20a876c475a6_Device=CPU_Config=() +1151:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=4541365c567e68739f0733edba54e889f231026025e6866f805446392c575960_Device=CPU_Config=() +1151:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=b434cd386e4c5e688aac8da3425d2ed0d72961223eaaa1cf2ff951a88a5fa001_Device=CPU_Config=() +1151:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=() +1151:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=e0422b2fb57587a85d9ce1532f7fc28a6bd01e72a325d42d9045419dda4bbba5_Device=CPU_Config=() +1151:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=95ea118f8053f6bd18c8f34bbc475c00921bab5dc3af177492829d5cba16aa39_Device=CPU_Config=() +1151:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=176c218db11ea18f367fdf98a3de14e9a9c65152bbcc39783c38772b37f6e9c2_Device=CPU_Config=() +1150:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=ba1a7c4cca6d39b8bc7be7d52a0680d055e33a776f4048ecf38335a2ccdd8d51_Device=CPU_Config=() +1150:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=() +1150:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=6119edc6e1f969159ce54e6ff4451d96db51485b54fae625a972035414c704ef_Device=CPU_Config=() +1150:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=447c546ed54e81edcfea77cafa8d18261923bf25c050666029828ea72e3a875c_Device=CPU_Config=() +1149:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=8368b4f6e208aa4cfbf0aeaa648e9408c281a71d98d15ee09407d26274fb349f_Device=CPU_Config=() +1149:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=3688e2a973219245d05c5fa675cebe9036d40777809ebf583c1bae9b9f87eed6_Device=CPU_Config=() +1149:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=ddacee38f2bf3dd45ddd36ba236440ae28b9737487e0fb186c2b9777c0b557e9_Device=CPU_Config=() +1149:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f13dcb47235a9516298088a0c45ff56fdb7f95144da257a3dfa1c618c7373ce9_Device=CPU_Config=() +1147:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=dynamic_IR=c838ac42d5464130a9049a63f7020166b34e2ef974c257a4060fa02c3b70ff76_Device=CPU_Config=() +1147:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b0dea4cb6a0cd2380e8657b0b64caab43819c0f8182ed73b2cb12eec608bfa7d_Device=CPU_Config=() +1146:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a3ae510f07db7c475dbd4500d129e0939bfeb9c8cd5c5090184d501f8c7106d8_Device=CPU_Config=() +1146:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=538935936007865ddd2f8ef5f2a5b1eb0e7a372163b2f13e068a3309374e19c5_Device=CPU_Config=() +1146:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4df4ab698c70278594efe8b4349a4c99c8b2ab7c4ee0182c5a4b7673da922ad6_Device=CPU_Config=() +1146:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=4420cfb7f4a734731dacfe5b0c27db41ccaac2ab8bbff56cac0f99ed96e976f2_Device=CPU_Config=() +1146:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=0a5f9fad12bf5e2592c6f720232bb38d94a5fb9ac1fdc5a8f7d474ed9e9d2504_Device=CPU_Config=() +1145:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=e9539332df9388555564db1da36679acc7b505b8c1fa687731f2052999bfe1fd_Device=CPU_Config=() +1145:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fa2eea1b545d6b876282ed0165fb935f0af249c713e3f20fd97cc06118e615eb_Device=CPU_Config=() +1145:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=2737751bcc195e4aaa63ab6d86d803741817287d78fc864e18a31c328078940d_Device=CPU_Config=() +1144:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=() +1143:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=() +1143:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=19f9f95d2205816fc002d8eaea7cfb19f19218fbc3528e4932b99f1486b62827_Device=CPU_Config=() +1143:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=120cc30794fe9c9d59dc9df6fadbb9791f3a6b99e4b9fdc06c5e01f494b05780_Device=CPU_Config=() +1142:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=f2df871f255156043f03f34333d59d9213fd52ea24f69dda1b04888ed269acad_Device=CPU_Config=() +1142:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=c4d1a1fdd0a336620be37a8ce7578ca0dd0c74f89fdb32ee86e7004792aa8445_Device=CPU_Config=() +1142:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e7e10785757d3131ebc375ebfd83c556e2c34a72be20965d9dd3e4f24a5ee2f9_Device=CPU_Config=() +1141:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e0f4f91a6470af49c5e2497ae8fa917051879c18dd1e39cae18d159b697e8fec_Device=CPU_Config=() +1141:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bed7c11a4d039608b3ff58fd136cb1d3dc8438441a37829913b63da7c1c657df_Device=CPU_Config=() +1141:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e7a4e6690e4897a569e29f61636fb4a99f645229fbfd2a68ecbf83b21058dcdf_Device=CPU_Config=() +1141:conformance_ShuffleChannels/ReadIRTest.ImportExport/Op=ShuffleChannels.1_Type=f32_Shape=static_IR=46e851dee1f7bead1a6e2459157df33266c45559375a1caff90a2732cacaf881_Device=CPU_Config=() +1138:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5ba879b46e93286e4c880a726e28d6956a1c8415508733b5349079f899462679_Device=CPU_Config=() +1138:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=i32_Shape=static_IR=f777fb31e1669cd58cc77e2a04c3f9a804b654b6d710432641a3dc34504460b4_Device=CPU_Config=() +1138:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=static_IR=bcb10a9124f9b0471012f9e22d4aed5c2a47a55e652312e8a8382dc0d809a23e_Device=CPU_Config=() +1138:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=i64_Shape=static_IR=d106f0cba8d8311b75f6074c099f45e10400c0829fdd1826292b1310471076cb_Device=CPU_Config=() +1138:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=f802331401875cb16be10c9f752520406437b2e63a50e022b7d95b732e5296f2_Device=CPU_Config=() +1138:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=c55846f7a08af86fb1c914c925433852fd4bc735f671c87e965a6db9b6971708_Device=CPU_Config=() +1138:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=53108cff3836c47360380f3898c5de245a566a5d98040820d78befd46e56955b_Device=CPU_Config=() +1138:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=282e24ea7ef9130becb8db8f0251c907b02a534119d08162e07091212d67f290_Device=CPU_Config=() +1137:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f5dbf9b79d3887c9207d8971e45282f563af47565ed7a941cf972014e8b5bf05_Device=CPU_Config=() +1137:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=385190d3bc54bfee5cfd98858a99a50146f755735ce9e86804b0d50f2191bd8c_Device=CPU_Config=() +1137:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=u8_Shape=dynamic_IR=b12ccd794c23494b994608015d049eec0f2ca30dc319bd35c1adddb3e4b8e631_Device=CPU_Config=() +1136:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8fce2d85c65eb0e8b40c2923338675276902296daf8744322876552dcd68f7_Device=CPU_Config=() +1136:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=41ea59b807081adea7869609c65776a42f88079ec22180807905d5c2e8ca0777_Device=CPU_Config=() +1135:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=72373e9c2bc4cdf2f0aa0a5d14e30ed1a5e0545d9a96f4ab675f3b9dc69d8cf4_Device=CPU_Config=() +1135:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=81313f6065af987d98f37a1709f149d804bc1a36bb0a5c4a11223b29c6ccc3d2_Device=CPU_Config=() +1135:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=109afa0426a29179db58e16917b829096af105f0def2375a589ea1391138ee2f_Device=CPU_Config=() +1134:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7d12962a8acd41f85ff8ff280e7f843fa1d5ecb4fca79d5d15d0d858dd9617ad_Device=CPU_Config=() +1133:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=05e9fdd5183bd179e5ef996ebcdc53f239900ca46a8122ee8bb1e885c2c091ce_Device=CPU_Config=() +1133:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=b11ede8f1aee40577413d8bbe89704e02252e3f02805fcc0ded624857ddb8280_Device=CPU_Config=() +1132:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=d2759b52de5dc9f1fa494c243d08ac40cf4e877c51323d53dbfa02abc1564e45_Device=CPU_Config=() +1132:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=b81d993247e604272e6df01b8c4ba016be7f60263c892e8469deef67a8a6afba_Device=CPU_Config=() +1132:conformance_Gelu/ReadIRTest.ImportExport/Op=Gelu.7_Type=f32_Shape=static_IR=4ee688aa25b818f6e6986c7070e544d0eef9ce888124d85c0e5e126802213a46_Device=CPU_Config=() +1132:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=57ba21d45369359487dc3b6a8feb0aa2b6fb21ffa328dc8e8eed58ee2896fdad_Device=CPU_Config=() +1131:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=582f7347a93cb2c9e51ade6c405ff25b23d009bdcd3d7a3c49902e627a041252_Device=CPU_Config=() +1131:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.1_Type=f32_Shape=static_IR=a4fe57973b0bba01e6038a8050f07b8ad1bf6871c1ad86270920f9084dc84905_Device=CPU_Config=() +1131:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=() +1131:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=81eb5381e1d4d3dc7cf0d83a9cd787813d3267c99b31cc9a3cb0cf9b01727c0e_Device=CPU_Config=() +1131:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d932ccb58823509e768be954dc85ef1162d9456db17138d650a2a883e31b99ed_Device=CPU_Config=() +1130:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=i64_Shape=static_IR=7adee81cf21b942334c25378325f61e13e9ee3ac95ae004d4d9efceaab6c0949_Device=CPU_Config=() +1130:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=28dbc474828462a812108c43a47aa4e70fa0d2e8e814bef5916092f3e8c7a2fd_Device=CPU_Config=() +1129:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=81e9c51ff606608d5a0f868a7ff529afc34804e04415b2ec654f31f848a81e1b_Device=CPU_Config=() +1129:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a59a3375ee8c7a9958b6d66c5d199df2a05bb1815063f149a063c09f6b288e9a_Device=CPU_Config=() +1129:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f5db8eb433e162e42a727e4aa0e176753cc4cd1e07aac8224a7b0f878a0ad5a5_Device=CPU_Config=() +1129:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=f7e1aae2dbc817ca8f64a6bb0742e476055c239cc6e31a4233b7580205feeb41_Device=CPU_Config=() +1129:conformance_GatherND/ReadIRTest.ImportExport/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=() +1129:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bc2b8069a8ae60098e1f1a1fc54f8ca873fb1a5d261acf47ae12ad6ea4bb34d5_Device=CPU_Config=() +1129:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=843bee6f74a42e3303b4bc38b302fc0858c4dea7ec4bc997c6aedfd0cc76ba37_Device=CPU_Config=() +1128:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7bf0600f459cdcd8d44b0cee600efd18d2319dc459d59314af52cddef6181aa4_Device=CPU_Config=() +1128:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=b1477d38842775944964d18c13278454256d9610e0ef880fbce0cc87e5977556_Device=CPU_Config=() +1128:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=cc8a9d50447be96c4d4738ddd5cdd88356f9e6e73ff8cf3fd90c4a24ebfe153c_Device=CPU_Config=() +1128:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c1852c534b8b95bf1a9aa2771decf2368fa095c5f5688d38ab9ce0bd86152a19_Device=CPU_Config=() +1127:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=7a1d8cbdb446c3330ed845d7a81e20d9b7c7662d532f4d816d4fc1c56822fa81_Device=CPU_Config=() +1127:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=i32_Shape=static_IR=6650e462a4f0086329d8576eb6352979e89825517f48e264fe719c7c5ca276fc_Device=CPU_Config=() +1127:conformance_NormalizeL2/ReadIRTest.QueryModel/Op=NormalizeL2.1_Type=f32_Shape=static_IR=3bfa35b53e4bb74a9e450b1220a5d3c061f050e498cf86c8f72118052b7fa252_Device=CPU_Config=() +1126:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b1bae9ab001e5c3b05f22881494508bed2f623801431b8402e6146e54d692016_Device=CPU_Config=() +1126:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=2a3d6c0476c17897fd4cc6d3623519fc033ac4022a01fbebd40b461f414f6c15_Device=CPU_Config=() +1125:conformance_NonMaxSuppression/ReadIRTest.Inference/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=() +1125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c1146723a7ea4ccf82c8d62c0665aea78976fbda8e1e0bb40c962b95069e8e7e_Device=CPU_Config=() +1124:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f8e0d0e358dfa2f404e60abbb4cf7a170f79a17291f48b69743d6da0635e8a98_Device=CPU_Config=() +1123:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=60ab42bb613fe785777ed45bc99044f41dae00316065ed5e5f07e69f5c861fc4_Device=CPU_Config=() +1122:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=e1d727df48a0a74d8b9865c00e5c39c9d53a5023d83da3c58f281b6b1411b696_Device=CPU_Config=() +1121:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=3d37166487c5c52af657343f8fa10903efc7d580d5b370a519a0ccfbf6fc56bf_Device=CPU_Config=() +1121:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=dynamic_IR=a99a5ab2de2d408c2e40ad5734c9bd5ab4d1d221f4dd24572e05538b134ef88c_Device=CPU_Config=() +1120:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=aadbb3768045a0dfddff742fd6ac0940bf0968c7e0b1b22b064503d4081b0a54_Device=CPU_Config=() +1119:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=5840000517cf6690e3b881e338ab887afae81129e22bb0e3c71b049e42ccd68e_Device=CPU_Config=() +1119:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=f8b14e90b051624d56678dbe68f15e6db94e22878b22914d0be241047d1a3783_Device=CPU_Config=() +1119:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=0a7b1efc8d314c5e37062e482a9398f718082ba0528c6ca2d2f6c88e7a4a2bb0_Device=CPU_Config=() +1119:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f257b78ff2b8efe8020b7e6f23c5e75ed7a3e752bfc44c69648b3450169a9f6d_Device=CPU_Config=() +1118:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=7e386c35d9d397e043876a23a2b9e5885964cee59bf46f1ae0660e6a84641ea4_Device=CPU_Config=() +1118:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=659cd025e440fdc633859089f52f7f38cab5701c63c79d1e8d1837c217b8cf75_Device=CPU_Config=() +1117:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=static_IR=7065a836f4fd77a07431ecff6bcc591ef9b0160cb5366a8f3c8b8fe5f83f7be1_Device=CPU_Config=() +1117:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=41c94561e79611e27aaf339205962d4967188b385d68c169b2bf4557173005d7_Device=CPU_Config=() +1117:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=d93633fac99f9472435ede6fcdb9c72475b68bf1352d58b33e8cbdf9ca74ac50_Device=CPU_Config=() +1117:conformance_ReduceMin/ReadIRTest.Inference/Op=ReduceMin.1_Type=f32_Shape=static_IR=61bca82940fd4a54bcb587a88272b81c191b8feeab37bfafa044ef768240977c_Device=CPU_Config=() +1116:conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=() +1115:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=87c65c520de106b146e91222609f5b25cd79e96cdd6b942c3293cddb656617ee_Device=CPU_Config=() +1115:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=0d6cc305ea05df2178e3b4ea61ba2f296655e77af08556491e0dc8dfd46bdc6f_Device=CPU_Config=() +1115:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b78ffc69401084763d529e2aee12f9b9793bc92be3eca3df2a97730b9a252ce3_Device=CPU_Config=() +1114:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=86d8d42c30e423e801b5d4d832f87cd6837bf9feb3c546f5bf87e04f842a04f1_Device=CPU_Config=() +1114:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a24f79f450b9e5ddba709c6df05f77362e7f3ba6dfba01eaed77564700f46958_Device=CPU_Config=() +1114:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=029a0a8ba891497790c27ffa1ea50c63536a0c81fc40e06e3ff07e419a8701c6_Device=CPU_Config=() +1114:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i64_Shape=static_IR=38f6cef69f6a7d9886b5d38902fb76e4ae41385fb3c95e229be4b44456ab2e87_Device=CPU_Config=() +1114:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=a72b942dc1915ccee8af871c00b16647db7c8935100b012f91ebd799bbe8d416_Device=CPU_Config=() +1114:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2bb16e2257294e3f7d905f66a483a8210f392ea822836e4edcf8910a7fbb4277_Device=CPU_Config=() +1113:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f8b98c32d45c0915f84ca2c09cafb629a540a6a02ec989d09f239a5cecb64001_Device=CPU_Config=() +1113:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=582f7347a93cb2c9e51ade6c405ff25b23d009bdcd3d7a3c49902e627a041252_Device=CPU_Config=() +1112:conformance_ShuffleChannels/ReadIRTest.Inference/Op=ShuffleChannels.1_Type=f32_Shape=static_IR=46e851dee1f7bead1a6e2459157df33266c45559375a1caff90a2732cacaf881_Device=CPU_Config=() +1112:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=a58fb7847e59bb119656b143af0c6f65e29f8211034fe7aab03666cdb95d7fe1_Device=CPU_Config=() +1112:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d141b35e277394511f5635b2e395039c986ac392e6f49c2415da6a5071bee96a_Device=CPU_Config=() +1111:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a9311932565e68fff052e15c1a0522e1c09270d06521541ca28b67c34184b1c5_Device=CPU_Config=() +1111:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=bd927dd60e7b65e84d03c2c01d29c6932961f801bed1312124c2212b5e22a921_Device=CPU_Config=() +1111:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=() +1110:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=69c87ccfa0080f65ed28b9a088343db5ceef524ae917b8e259b1865a017df22f_Device=CPU_Config=() +1110:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=168e02701204a8f0e325fa1a2a4407612df10c3218c9431981fa6f1f8300eec2_Device=CPU_Config=() +1110:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=b6a75c5d2a686eae53cc25c6b107630b31a8a4d8c6514980ed1a97754f33bdcd_Device=CPU_Config=() +1110:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=0a5f9fad12bf5e2592c6f720232bb38d94a5fb9ac1fdc5a8f7d474ed9e9d2504_Device=CPU_Config=() +1109:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a74540730c27b2cb9437e4ba730bfb555be123f25f1709f2863d50cdaaa21c7f_Device=CPU_Config=() +1109:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i32_Shape=static_IR=77c86205d7dd4dd882adb5a28b03ae2ed9c80004b42d4df1cabfab96f3168d72_Device=CPU_Config=() +1109:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=707190f77491e910ce61476cd3a9d5dc275e7c5ad820cd3894a37c348c2995ff_Device=CPU_Config=() +1109:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=() +1109:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=3ca9994321c7492af9bff158852a484636638e711ae39a6acb66d273f696906e_Device=CPU_Config=() +1109:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=b459cd78b41e36a6c3823301811fd3322a77f802ffc3399eefdfd8ffa4ce6e6c_Device=CPU_Config=() +1109:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=61091e18fb5e9eddcab243ec79234ef3b93a5d01d9b2611a3a0e027eed4e4b31_Device=CPU_Config=() +1109:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=49b1cfd43b9898a5882e93973e26ee3b149efbf3cb75d9ebe9225c61c87662ea_Device=CPU_Config=() +1108:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d20696b7743fb5d47628ddc4be77a3627b2848014e649db977ca1028586cd3b5_Device=CPU_Config=() +1108:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=14108fac0139d5bb39f6b2106857e1ac91c8d44ef9156e4e0873facf9d932316_Device=CPU_Config=() +1107:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9d606780b6c646a5fc037250cae9a636436e56e277c95eadad5ce23fa09d8b13_Device=CPU_Config=() +1107:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=41c94561e79611e27aaf339205962d4967188b385d68c169b2bf4557173005d7_Device=CPU_Config=() +1107:conformance_Gelu/ReadIRTest.Inference/Op=Gelu.7_Type=f32_Shape=static_IR=4ee688aa25b818f6e6986c7070e544d0eef9ce888124d85c0e5e126802213a46_Device=CPU_Config=() +1106:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6a8fb5f2948de2436a33999ee2a01e239193c268f61634f1e80692b0c45aa3da_Device=CPU_Config=() +1106:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=63de0838ea26e3575f49700f73fffb0d3415ab68b29b1a1da690b84f7a034822_Device=CPU_Config=() +1106:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=4341385bd87226eb41493c667323e8c1c39817983a48025192209270750eed06_Device=CPU_Config=() +1106:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=bd927dd60e7b65e84d03c2c01d29c6932961f801bed1312124c2212b5e22a921_Device=CPU_Config=() +1106:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e2581a8fe5100a3dc4212e869ed437e817291a79d77b7dde80700de42fe116a7_Device=CPU_Config=() +1106:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d0aad85620a1b97486758b17c69043a6a9cf75a459bf6e283b28ca132e917dcb_Device=CPU_Config=() +1105:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3d39ecb890c0070ffbec20a5540c9841a075d29b83113350a2ea7a0bbc984cf1_Device=CPU_Config=() +1105:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=69c87ccfa0080f65ed28b9a088343db5ceef524ae917b8e259b1865a017df22f_Device=CPU_Config=() +1105:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=21950c433f50ded0f662b9e0591e756a8dd685bc11a8296bcacc57ca1a4968b4_Device=CPU_Config=() +1104:conformance_ROIAlign/ReadIRTest.Inference/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=() +1104:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f49b212b59261888a5ea4652f9a4cdfe25657c7a0e4d3b6ecc16255e8d2e8cd5_Device=CPU_Config=() +1103:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=dbee34cd3b708559af1ceb5fcf89aac35add00fc1b9e3eda2beebb2d5b629fc1_Device=CPU_Config=() +1103:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=dbee34cd3b708559af1ceb5fcf89aac35add00fc1b9e3eda2beebb2d5b629fc1_Device=CPU_Config=() +1103:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=boolean_Shape=static_IR=4da22853b6e4b853fa57b9dce8f5a26920d079a74055831d651c10f48ee96e8f_Device=CPU_Config=() +1102:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=dynamic_IR=fc75aba0dd172d6628de0b473569c672b52f070ac3c446cc3342cb1184ef076a_Device=CPU_Config=() +1101:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=9a92abcc42e0ede56b448e3128ca970cda68fdf27b553430d6d5c5397b7cd59f_Device=CPU_Config=() +1100:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=06fdd8a11a7ec3d8a9fc5d188f881cc6bbcc5b1bc669ceaf88751a03806257ae_Device=CPU_Config=() +1100:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=97a94ab826d2992013df32a4f93f6adbc38ad17a26503005046f68904adf53d1_Device=CPU_Config=() +1100:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=06c968fe2f2949b4262f4f600b728609b2c2a389fc5fb02bbe4764da6caef616_Device=CPU_Config=() +1100:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=04db488d856ff6cf4f04ad155967df95830796ad733e589f42c3862224acd874_Device=CPU_Config=() +1099:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=dynamic_IR=0f5965e2daa2a1f6b050813850956d9a4bbd771cb234ec814617099e1541ea0c_Device=CPU_Config=() +1099:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=() +1098:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=58cd9ea3d8db317b6ff7fca55bebcbc6846aebdbe309b1b621f5535b18a70320_Device=CPU_Config=() +1098:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2fda32f5fe8957d151306845ffd0f877b2efad70f7bd4921fab2fd770d78c2a8_Device=CPU_Config=() +1097:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=cd389fc4a9417c7136f75474e42dfb43d1f9cb35fa0e104632ffa69fce2b7e57_Device=CPU_Config=() +1096:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3c7d4160bf883d550620e8d1ceb54b3d78bf1512388b5ee57e1a380949d441e1_Device=CPU_Config=() +1096:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=d3155499ccf835bc57e4ca19c25ca32fc63ecede0a2c43ab2a3e43ba4a6a4dcc_Device=CPU_Config=() +1095:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=01f8aa116df449130419891bc3387fa263e1ef80b3113fecd83b06fb933efbaa_Device=CPU_Config=() +1095:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=439b811941d57ad9e80586b01be64ddcb153c31ceba4d83303e0479b2933e8a3_Device=CPU_Config=() +1095:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=dynamic_IR=502fbd3f8c0e9c0a9523269a9df9b0fbd83d59ca94f373fd543048429a957f5c_Device=CPU_Config=() +1095:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d7ce9fd9d99a7ce9ebb5fdadb4db39f4ea66f74788704b2b9f96660c7403c031_Device=CPU_Config=() +1094:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=() +1093:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=33aa0d800115f94b07bce9c6ca8b4447f2c4f442bff77cb9b02b23d2ddabcc01_Device=CPU_Config=() +1093:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=b81d993247e604272e6df01b8c4ba016be7f60263c892e8469deef67a8a6afba_Device=CPU_Config=() +1093:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0bfc53d275267687d8d081e1b2174196a0c1aa18bab9ba84a08fe1735336c42f_Device=CPU_Config=() +1093:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e2581a8fe5100a3dc4212e869ed437e817291a79d77b7dde80700de42fe116a7_Device=CPU_Config=() +1092:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=() +1092:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=166d8442037dcf0469f0b14ab83676b30bce53edd79494c52a575e3744920c4d_Device=CPU_Config=() +1091:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b227737b26850463ce87153061b94dcd71131aa06e3032b7f775a64e1c271f93_Device=CPU_Config=() +1091:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9ebb1862a5e0db4eff08d84e9e56c76c19cdc07e13e634f008ce5e9d709afe35_Device=CPU_Config=() +1090:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=dc4bcacb769fc4d8f1ef4ff20ca7ba6b3b369d69ea3b1c65733d4cbd2cb0762c_Device=CPU_Config=() +1089:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=e7ab5b597681da2db03c13a2424b4e0a62135eecfb2f97f4c59b53331afb7f85_Device=CPU_Config=() +1089:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=1c91956bf0130fd338f8f11cf76a08dcf5fe3c6c42239fa6a6aeb517eeabba36_Device=CPU_Config=() +1089:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=990cce0ce92df99ae74ad8840f7b89d1c48c0044deb9cb71619b44a565eed911_Device=CPU_Config=() +1088:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ce2bcc21fba106cc8be4846179a73cb30f650e7ec48d443fed591f6b479fa9d1_Device=CPU_Config=() +1088:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43e52f7bd4989711336d4aa524aff731d1f968eb65e8b5e07e1a16db29e55337_Device=CPU_Config=() +1087:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b299e012ad30cf620f5c9ba0c33c79a406d0e39f84cb9d1efdc4b4c8dd82f347_Device=CPU_Config=() +1087:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=776ce5493890837f137a7abc7851ff04164468d7c13ef1022f73f1f68e058c1c_Device=CPU_Config=() +1087:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=223a34e46344a0dff7f35a637c9bd08e2a76a552ca87e5bf0134c9fc6d6be41d_Device=CPU_Config=() +1087:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=8b759b2f1999be207aeb39763bde3eba4aee028e9369a86a87493ff86f3fa014_Device=CPU_Config=() +1087:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e8c2981885674129fedb6fc6a376f3fd3db7bf6f9867ee8a3f4e5aede63ee168_Device=CPU_Config=() +1086:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b94603cd976e1acfa5a3f8310be1e05800114009541c22ed53c0c07cd0816685_Device=CPU_Config=() +1086:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=c662eb0004f431152ddc69e12826a6c0e7aa66b24be0169acf10ca95f2a63f52_Device=CPU_Config=() +1085:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=8919e05ab2b0d545cabc2e2732828fa693c8f364e9d4d03faf7097f787d4f628_Device=CPU_Config=() +1083:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=84d3a33f9325d947a72b4e26d046e3e3f9cf41091f7c8e1c654899b3088ce6e5_Device=CPU_Config=() +1083:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=static_IR=2055c46f29a25953e331656839e227b0472b10695ea23410b64428d14232345a_Device=CPU_Config=() +1083:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=4892263cb1ea7a434b5771aa16f07885c39710f67fa1411dd9235653a6b8622c_Device=CPU_Config=() +1082:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=dynamic_IR=0b30cc6cee9ce5400085a0e78b44763bc169eeea93357f22fd716564f20226db_Device=CPU_Config=() +1082:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a52a8e6ef7bbeacbc1435cde72a1a70bdb8a3abf78b5b971c2ecb1135cb4c136_Device=CPU_Config=() +1082:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7effebd346cedea6e1196e31b73459e7dc818b4cec52eec6ef54e4812b9c221e_Device=CPU_Config=() +1081:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c6cb68df4177a7385019521efa21e7d2722be7b0ec0462d93f3caf9d20fdf2bd_Device=CPU_Config=() +1081:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=static_IR=2e3f53e7b949e1dd0ab38890b0c9fc9e770dfb68569e37fa5cdd4e3ef03d6eb0_Device=CPU_Config=() +1081:conformance_Mish/ReadIRTest.ImportExport/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=() +1080:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=() +1080:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f8eb0c39d812083381ffb5f66921c5eebf3db3f22f6531c7a81346bed8d54369_Device=CPU_Config=() +1079:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9795aaeb71c115680b567eab0877df338c0d8971858b489a2636c4483f3512cb_Device=CPU_Config=() +1078:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=() +1078:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=57ba21d45369359487dc3b6a8feb0aa2b6fb21ffa328dc8e8eed58ee2896fdad_Device=CPU_Config=() +1078:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=07cc41d5a7be27466beff227bce7deae470e9bc82d30963618d5279c646d0b04_Device=CPU_Config=() +1077:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=94693638ec4742dea16dc168eb9323995f1b2a35a53f577cf58ac3a08096892d_Device=CPU_Config=() +1077:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5f0ff4c88ede5deb6d12935a74027fd8e9a1c966e03e064f0a94cbcc11415918_Device=CPU_Config=() +1077:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=() +1077:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=bec81407211db6e10d7c8811bc58b53c23c8aafa0e2083f262204f345b9bcfc6_Device=CPU_Config=() +1077:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=1d7cabddc96cb4ca2ed111c9f7a9c31b76ed9a052fd0b79db6bdc8fc55f24a4b_Device=CPU_Config=() +1077:conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=() +1077:conformance_NonZero/ReadIRTest.QueryModel/Op=NonZero.3_Type=i64_Shape=dynamic_IR=7d0265450b8fc92464273ac05d685952ea3877be45b4d745959f2f373fef1431_Device=CPU_Config=() +1076:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ffd182dd2438f8b3907013ef38c64288a16d6f98a9fd206e6f8e3d2db48a3a73_Device=CPU_Config=() +1076:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=() +1076:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=static_IR=7798cef9c8734d0908103b3c42fd7fc791806ad61d35dc680dc43d9597c6f1fb_Device=CPU_Config=() +1075:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c87c002bc627f4adfa58547da4c2b1f270e07e9961a1b4ae99dda72d88980550_Device=CPU_Config=() +1075:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=683b86794b415f893e4d426a8c68aa38f46c250e4c31bc5f5807a86c20ffb34b_Device=CPU_Config=() +1075:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=48a273073ced3efa39d01e5ce40c30b2901e8a3dff0b414911282b8fdfc0b09f_Device=CPU_Config=() +1074:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0849107336e2dcb62f494696f297a85dec4fb5d71f1f9422313faa5c23ae4cdd_Device=CPU_Config=() +1074:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=fe80951a0a44625457a6106d8613c9813c9c0b8fe3606fa5ac1c064217c8a0e6_Device=CPU_Config=() +1074:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=dynamic_IR=dac2c804cd13d69a51906319a3648ac0edd87764c686c99fb47179f379cecf7d_Device=CPU_Config=() +1073:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f19b9ae15030aed3c709b020b9539e197d260ee35c50d6f9b807201e939cc758_Device=CPU_Config=() +1073:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=f2df871f255156043f03f34333d59d9213fd52ea24f69dda1b04888ed269acad_Device=CPU_Config=() +1073:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=96117baf3ff208c696a9796404eec467b613c37977067ff0cc62e39355856d30_Device=CPU_Config=() +1073:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=99e405218c1a96c5f8af65aa814893d8958e8e991d1ed8dbbbd586efa589df39_Device=CPU_Config=() +1073:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d9db827de158568b8a10347c13216e92b37ec20d8eac92c38aabd86690114805_Device=CPU_Config=() +1072:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5bdc625498840e88bafb7d6f58ae8f9f0081a9bd0a6cd71c72a35871ca5b1f12_Device=CPU_Config=() +1072:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=boolean_Shape=static_IR=6d34694c9c8e71415be894a80a8ededc6a83657c6e7ce3aaf66dcd6f9ab99226_Device=CPU_Config=() +1072:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b3e2dec4b768d4a421c0bb36ab5174fc68e4a37655cd7a6f2072e0db9894cd1a_Device=CPU_Config=() +1071:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=a5a2ba7fff85401feb05248462e85d334440769790e7e6ba1a75ffb413f7fc64_Device=CPU_Config=() +1070:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c97ae95062233f4085689c2f5dfcbd9077c16fdb1bd304e3817b76004d85b00d_Device=CPU_Config=() +1070:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=bc1a7618e707ddd2c4773d1a2234e6dfb39954ad872abdf38a18d653ec35b26f_Device=CPU_Config=() +1070:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ae2e7b59de9fc5d689cf677f1ce023fa58235c99d3efa662148d01b2bdfa0e0c_Device=CPU_Config=() +1069:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=() +1069:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=2f23f1158754aa494abbf61ab15118173a7ccfe90523b2b9ab7cc3a6fdaa0e37_Device=CPU_Config=() +1069:conformance_Range/ReadIRTest.QueryModel/Op=Range.4_Type=i64_Shape=dynamic_IR=0d660483dfd9c9975f102d300ec98da49785fcb6484b379c45df8a61e1292797_Device=CPU_Config=() +1068:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=adee3d4d6728b17fb5ab17a9915c5b7c8808f949ad358e8a16a0bb12dad7c958_Device=CPU_Config=() +1067:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=7e386c35d9d397e043876a23a2b9e5885964cee59bf46f1ae0660e6a84641ea4_Device=CPU_Config=() +1067:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=() +1067:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=i64_Shape=static_IR=056c07f9ad8e27e01b269b5136ee29b4cb4d1229a009cda07e4fd32c45d4e97f_Device=CPU_Config=() +1066:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=3638f7714d7627d7536ec02891656e512fee1ec55d59bb4f68c7409ad82f3879_Device=CPU_Config=() +1066:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ea0fcb3a84306f10c2ff5fd89659a19497da84225280efee670cce6f10755e1a_Device=CPU_Config=() +1065:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=a2450d07c12669e586815e60d9a2b568f88a49c9b63730c898b9eae907b5ec4a_Device=CPU_Config=() +1065:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=35212486e2fb4ea5f9dc1ed7d7ce580e941006a7e2f67ac4e6c4c4ffb3f514f0_Device=CPU_Config=() +1065:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=df5ba55412d924fca818d6ac4b1709ab651f12e4b64d6a9555644e8e8b26a0fb_Device=CPU_Config=() +1064:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=94c0bd6d26bbfc0a8f22050757d17bc051a7af85dc6d6447d51413f2bf779a95_Device=CPU_Config=() +1064:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3453b13d94c5885206e02df250d0d07ce9930fb3260f992502bd677de9c348fa_Device=CPU_Config=() +1064:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=b459cd78b41e36a6c3823301811fd3322a77f802ffc3399eefdfd8ffa4ce6e6c_Device=CPU_Config=() +1064:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=7625f5af6c70a9d4bccb783dc369a11b53ef1f6492df030ae5404452ea0cdc79_Device=CPU_Config=() +1064:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43a00b4dc097228af52c00054951dd5b57d8e0086207f11a8996e5ac880c8980_Device=CPU_Config=() +1063:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f8b98c32d45c0915f84ca2c09cafb629a540a6a02ec989d09f239a5cecb64001_Device=CPU_Config=() +1063:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=f45b24f3bf21a2c94bc89cdc3d20c283d47f4e6ea386444897330e232bd7d90f_Device=CPU_Config=() +1062:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=() +1060:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=9fc3d18a9496df4681f38d330d3d1ff7b83b29b8f4e08e19c26a0107c4b69157_Device=CPU_Config=() +1060:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=d575b00d2b6e155319fe7120133d8e0c3dcb5c79bda710b0650fa48543dc5c84_Device=CPU_Config=() +1059:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e5092af5c0f683044b1df5a45f211f4a692436d1112181a5d613bbf335941684_Device=CPU_Config=() +1059:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1ee4e453beffb322abb75896695a160ca8b14b0fed69999731588374e6ea4b93_Device=CPU_Config=() +1059:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1d1001df575da981792e8444dac2291418d7d493bf10063dadb8b439cd353ff9_Device=CPU_Config=() +1059:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=27504b9cb28c91668f7dafc7db47c7260b0e63c040a9dd5493daa35c8d3b6d16_Device=CPU_Config=() +1059:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=7e88dcf638caa6058b01dd6c31ba40efb0fca8077cc295ca63c2ebe4c7298926_Device=CPU_Config=() +1059:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=a35667a1c5401fb3102a59ce0fa67d0ea4829f8ce282c43767517ce025469bac_Device=CPU_Config=() +1059:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=29d8ef1a41f51b6fed0300f97d17a3795a97e4ffb3ef3abda37f790f5f53b389_Device=CPU_Config=() +1058:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=i32_Shape=static_IR=75f0349e33d0151c276e3f5ce34f7c1a71f5572331157b2e34f889773d7d8754_Device=CPU_Config=() +1058:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=944072d96554abf3ceac6b928cc00ea1705d5e0dfae8e9a0662de4e56fb3e62f_Device=CPU_Config=() +1058:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=fbdf008803736374dd213f1d7e0a041fc0e9b3f025c212a588fa05842ee5ee56_Device=CPU_Config=() +1058:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=d9231cf5e3e491e318f16514e771cfdee4b781b42fc9d45088da850ab48079cc_Device=CPU_Config=() +1057:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=() +1057:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=dynamic_IR=43ceadf05184954dd8697d4f737de323ec2ee75f93e0d33d60dab2acc995f3b6_Device=CPU_Config=() +1057:conformance_Negative/ReadIRTest.ImportExport/Op=Negative.1_Type=f32_Shape=static_IR=c29451ffff103b5e965a1bbea7994ef6da6394060855ee071b9e7a3a4702141f_Device=CPU_Config=() +1056:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d46034925bf5b01e31b5a57911fe30f5dd09a8712432312fb1efd844e69913bf_Device=CPU_Config=() +1056:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=025f133a063248650fab4c898fa6dc245e844e4f0c8eec7603403515fd023164_Device=CPU_Config=() +1056:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=dynamic_IR=8c78da5f8bf9c1a4cd7f89cde9d61eb6500fa10ea0454e36a585466ed97fb12d_Device=CPU_Config=() +1056:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=c18d3d2fd8001cb07daaa5000258b36352807e3e81999d2d80a668e4d6add085_Device=CPU_Config=() +1055:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0d52cdcce6bd2a9335a6262a5dad29d924e0b1bc0caa81eb0b73c153d7b27e00_Device=CPU_Config=() +1055:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=static_IR=bcb10a9124f9b0471012f9e22d4aed5c2a47a55e652312e8a8382dc0d809a23e_Device=CPU_Config=() +1055:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=2620e86e1e6ce8f0ecb3eebce969f3e7df11f7f86c6f97309aa24993f9036033_Device=CPU_Config=() +1054:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=static_IR=7065a836f4fd77a07431ecff6bcc591ef9b0160cb5366a8f3c8b8fe5f83f7be1_Device=CPU_Config=() +1054:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=0b603f9cb63e722122080ea36f76fe45b25da83b0b1e213871140e82dea5f405_Device=CPU_Config=() +1054:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=166d8442037dcf0469f0b14ab83676b30bce53edd79494c52a575e3744920c4d_Device=CPU_Config=() +1054:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=53192c27f09bf3c756e64820ae6b0a01c5e48535df5d5b91ef6dbd6d954eb6dc_Device=CPU_Config=() +1054:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=33013e27c35451969b0c3c8493a34fb5c81527a7480bb12d793a2d597d712602_Device=CPU_Config=() +1053:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=dfc4ce58920e58666fe95d2b0c2d7020e887fa9955e392519946b08ade090373_Device=CPU_Config=() +1053:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0667c865b35e65d521f8edcad5e99d49ba8e55fac0c439ae095cb50de75fe8a9_Device=CPU_Config=() +1053:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=50e01efd1d927b71763f678e29a16ae688a5b0f10ed9cee12f1e7692924d5318_Device=CPU_Config=() +1052:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1026aafc8501f7286a9094f317c551f15bb189bd449c59f1c83c7a4b5f8c9ddd_Device=CPU_Config=() +1052:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1eb25d18fbd1070f2a8ff803d76077d092d493f9e9df80e93e2f58f3621a121f_Device=CPU_Config=() +1051:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=a714d51739b3d420cf27f476e338bacbeabb40d0ced1e1527587756265253d8a_Device=CPU_Config=() +1050:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ef05cedf5dbaee70082962e6459d8391c8358cccf43e33695d15184215d26d8c_Device=CPU_Config=() +1050:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=c52cc9f84ee56b9ced415f830d9f251e52d1dc56a3cace6548b3d345d2b1e812_Device=CPU_Config=() +1050:conformance_NonZero/ReadIRTest.Inference/Op=NonZero.3_Type=i64_Shape=dynamic_IR=31f428e60ddfdb3cb3c98c2cc858d0409fd35c5e6e97f9dcdfbb20a876c475a6_Device=CPU_Config=() +1049:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=10c7f4dedd3c5395744a95834799d05f2b2e014e2acff9ee97ed1fcf6e7100a6_Device=CPU_Config=() +1049:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=b94b5361ee75b3684455c2b871b656a50c72e325564787c302a714f222845b26_Device=CPU_Config=() +1049:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=32537f045cce3d13cb28dd292a0ebe06e13002877d9ed2e5b25d3ebdf5afcb58_Device=CPU_Config=() +1048:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ef7c3b91bb41e1db1727794a0435bfa5f38d194b9457d94abf9c19776174ef60_Device=CPU_Config=() +1048:conformance_Range/ReadIRTest.ImportExport/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=() +1048:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=5038017e90f931327d5159938d422b2afc229aa4d776a4ac80a946724fee357d_Device=CPU_Config=() +1047:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=727e029d6373e823f7500e6bdfd1c07ba87fdb3ba428fd0a089885d7a1e91552_Device=CPU_Config=() +1047:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=() +1047:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=() +1046:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bd1eabf7e4126b68490c086db76a9a27e0b55e7047080ccf96158337c8a9e74b_Device=CPU_Config=() +1045:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c2db5dd4ed881038f0521cfb566b3773cda95681a2ef8339950d0515616c015d_Device=CPU_Config=() +1044:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0ddc207725ba9ee303b566526c77f7921016e12230cdef3a724e77e2a9e603f3_Device=CPU_Config=() +1044:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=377acd11b0f7dfb4f3e57baec8a6c8a84737857b7e794614542f139982feaf73_Device=CPU_Config=() +1044:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4113a61cf98e226d48988dd52624e716382c5f03426f185f777b6018d77633cf_Device=CPU_Config=() +1044:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4bb7bd2471752f1a62dc15dbcacad87dd329443459a90dc6768b1a34fd00c064_Device=CPU_Config=() +1043:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=125ec4e4ba4158d3a6d1a7725cda9a18a220926d5ad6ed623a1433688c79b579_Device=CPU_Config=() +1042:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8b9ae72303fcba7808c28f788e0187827b2f548efcd6d023e6ad28047121216e_Device=CPU_Config=() +1042:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=d066432a0ddac020441582a98f139d063cf5f4e9f34deaa0be5ab9b9f048aa0b_Device=CPU_Config=() +1041:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=b6984001a616b3dd3ef4b835b2dc6a48bcaf8882bfde7761b4e141733364f66a_Device=CPU_Config=() +1039:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9c15338e53353041d5e82067a4aaf56dde40144709b2bd04d86bbc7ad22b525b_Device=CPU_Config=() +1039:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6ddd9bc0333c5b1ebae36dafbc24444ffcd34d29bdb58a9b20d4e584c2cc63eb_Device=CPU_Config=() +1038:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ce13c479a981a68967fe75da84baff1bbc1ccaf0dcee5aa988d71bb49bba14ab_Device=CPU_Config=() +1038:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=f2df871f255156043f03f34333d59d9213fd52ea24f69dda1b04888ed269acad_Device=CPU_Config=() +1038:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=b91a183b8c36d6e8358dad7056638b8091005393dd1ee6813728f25cd3e6a9f5_Device=CPU_Config=() +1038:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=93788242c06d787e33afa50ecbef5372898e50024d0c88624056a752535572bf_Device=CPU_Config=() +1037:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=a5dc3f8dd6385eb7f6d4052af82e27b7af7e8a58bdcb6092ec79ea3087f141c6_Device=CPU_Config=() +1037:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=431db89311a543581d104e2a2c498fe021da2e4026323817834670bf5bee67a2_Device=CPU_Config=() +1037:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=e85722360042c3ad04d04157759bf404452b789f30eb1174cbd59a5d7451df30_Device=CPU_Config=() +1037:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a7d9ffa60c8d1f330ec303edf6a6c0f8d8e0fe8657c561431bfb91a94c2639e8_Device=CPU_Config=() +1037:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d671a241de6d46bd5562def47a92602d2c9ba076568feed303765168433ee89b_Device=CPU_Config=() +1036:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9e83fbe4b350e0cdf8db8795ba31169b98503108dc45a266c88b734a4f54b3f2_Device=CPU_Config=() +1036:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5983b9e38433fb9c767b7885ea749d6e89fe9d3a46f45777097f046611f31fce_Device=CPU_Config=() +1036:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=3326cf79d426d1a669158c4db8256fdd956fa4725b0d6fb9e8ab5e5206612eef_Device=CPU_Config=() +1036:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=() +1036:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=cbb80f496fd705f24fdb25f6de3734bb2a2b7f49c984bdb32c4f62ec4640797a_Device=CPU_Config=() +1035:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=a714d51739b3d420cf27f476e338bacbeabb40d0ced1e1527587756265253d8a_Device=CPU_Config=() +1034:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=() +1034:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=a6b0532b200874d6d1c57719b46f2b301c368ebc35042df00796dfb87eed618b_Device=CPU_Config=() +1033:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2acd53645519bc460dcc71923563fd462ed997366cc7ae08cb5a30245302a859_Device=CPU_Config=() +1033:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b02504c94d7d221fab11078480e29529880bcc09c5bc769c60016e53d0c8529b_Device=CPU_Config=() +1033:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=static_IR=2055c46f29a25953e331656839e227b0472b10695ea23410b64428d14232345a_Device=CPU_Config=() +1033:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=9bb8728e6e9f68cf68a9e39d1aa4c618c4aca4187d4262f735c0647d680c0506_Device=CPU_Config=() +1032:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e003079e1703f756924619f2a77b6c26741ef71bc404419560faec9c56bbfd2d_Device=CPU_Config=() +1032:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=aa757ffed4165beb3074da6ad09422d7823a1d0d6c8a654adc56343d0e43dc66_Device=CPU_Config=() +1032:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=622add2dcd72d2e1560e983ef4aad56fd35b48b71964ea8204137026f445d37d_Device=CPU_Config=() +1031:conformance_GatherND/ReadIRTest.ImportExport/Op=GatherND.8_Type=f32_Shape=static_IR=58581d0746e5bf56df7df18df87d35371d41ff69ba09c7850c8e96354c7910b4_Device=CPU_Config=() +1031:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=boolean_Shape=static_IR=4da22853b6e4b853fa57b9dce8f5a26920d079a74055831d651c10f48ee96e8f_Device=CPU_Config=() +1031:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=547fea7da34d5e65ad7ea069be003753e9ef281110c80dde11520bc350c4ca14_Device=CPU_Config=() +1030:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3c31856cc439ae60215ceed2dc33dd4427c528e87a5f61a3b920e52ae2c87785_Device=CPU_Config=() +1030:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3eb4c7774dc1ab314492cbf1475d0c47d4138ac05336b249ab5e8588eb7bb143_Device=CPU_Config=() +1029:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3e5930f1ff4ad9d9e53216b6f8f912fc7ba051bfc85c46ce2dbcddbcd357832c_Device=CPU_Config=() +1029:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=dynamic_IR=516ad610612780fdaf83c5dc151316e83772eda4700882f934c97b2a2bd86dac_Device=CPU_Config=() +1029:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=ae7b6a45a538bb7f65d5895f2f7941fd9048645482faa40adb1f773e282a946c_Device=CPU_Config=() +1029:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=718269cf894ffbb59c15a1c688fd7bf726a87899dd7ef6dc0c9c8731f2b33293_Device=CPU_Config=() +1028:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=74139581d469ae7aae17953be58de64b2c8b887b3b7dcf492edb748773a1788b_Device=CPU_Config=() +1027:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1820314f222425dcf215be41b7ebee2a1f04535529a9207527de12ae7ab35a58_Device=CPU_Config=() +1027:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5d5b6e996a1c477f211ce82bdadd3228788cea988eebf25d5f40ae1a745418e0_Device=CPU_Config=() +1027:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=10f9a2b62a6505b51206efc6d6fc6ae5aea9bebb43abeae7e0a46a2c6cf50e16_Device=CPU_Config=() +1027:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=de9827c3efd198893fd6a26bb5efd6a4aef5451447643a69f085f0b6e605097e_Device=CPU_Config=() +1026:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=105ef2497841f48e00c64d60affe13b54275083bbf0fd91837d21a4c7c85a1a5_Device=CPU_Config=() +1025:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f6097dacc8a374d3c93eeecca54dfa436bec5a0882f38fdf192b63b49988b7cb_Device=CPU_Config=() +1025:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ba515e47066707dc9346b3002df0666bed67bec38ecdb0489943423ffab1a7dc_Device=CPU_Config=() +1025:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i32_Shape=static_IR=5224ffd078708e8917b14b4118bc4a42317c123dc0a5dca8234ad73d44daf845_Device=CPU_Config=() +1025:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=91281faa51b78893f7106cd8fd05ab98460a328bf6cf64d930aa5635d2f90c90_Device=CPU_Config=() +1025:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=61091e18fb5e9eddcab243ec79234ef3b93a5d01d9b2611a3a0e027eed4e4b31_Device=CPU_Config=() +1024:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8222f4a2e6c27f1bf5455fe495f04e3c7f48118a20687c6c5f6434c1e3d12f3d_Device=CPU_Config=() +1024:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=() +1024:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f465651ea8ac7c2c141595f8d91a6061beffbe8d714e253a91dd12e00502ac47_Device=CPU_Config=() +1023:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=38d935b0aa7266960b3d349b60c97bb15f535faed953fbe3ff24ae2560828f04_Device=CPU_Config=() +1023:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=00d924b3557896a41b0be32897f7b7293fcc44d79a285e91695a5fd2f29f3b8c_Device=CPU_Config=() +1023:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=42f3f3a5b34aacb93147f9c77ad5709cf7436ae8cad9318434a9b6ff6852982d_Device=CPU_Config=() +1022:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=bf7feb979b2eab03afc780965804a3f6b8471b574c36125654fcaf3ebc2c30f5_Device=CPU_Config=() +1022:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=effa926dbd9beaa9b2b7b660288ceab99da8cfb440c4b01b7779d1bc25be336f_Device=CPU_Config=() +1022:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a50644dc2d133df429ff4aa6a19ca9bafbf41d2948522e584fc5f417ad16d76c_Device=CPU_Config=() +1021:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=() +1020:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=264ac1f5ebe805838ff6e76fca75305ba3ecb27f84e44ae7b44e9c01d613df98_Device=CPU_Config=() +1020:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=static_IR=591cc5abb16f22cfa720e53be695097b83c42a971536fb5b79d0b02cc4ad328b_Device=CPU_Config=() +1020:conformance_ReduceMax/ReadIRTest.ImportExport/Op=ReduceMax.1_Type=f32_Shape=static_IR=590a910a27283b92d7a4650bba546a3bec08a6ded604bbe8523ab3c6d734c70b_Device=CPU_Config=() +1020:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=() +1019:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=feeeccadf83749f2827985b49721a9b8c5a0c9c90a709193e27002e5dd7f0bc0_Device=CPU_Config=() +1019:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1b166178a448888eb82b8f6f5692ed96ca7fb6e52b5235a5ed50446e60566417_Device=CPU_Config=() +1019:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=dynamic_IR=08776190d0fddfcb15ad75cdbf6892de03f79e89d57e02b7c3e80b4a7a125d35_Device=CPU_Config=() +1018:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=b459cd78b41e36a6c3823301811fd3322a77f802ffc3399eefdfd8ffa4ce6e6c_Device=CPU_Config=() +1018:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c161ff64d4c506fdbe44d0ee76042f958f5dfce778833653628a026de01a3f9f_Device=CPU_Config=() +1017:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=6745937b3d592b8cc1729ab2af1888ce58502379a33f0ae5d5a3eb0e70c0bc87_Device=CPU_Config=() +1017:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b91f26a0b7b56224c507de772631016119cd0bc3fd49527013f571e2db477402_Device=CPU_Config=() +1017:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b7983ae70a4e7868ccbf4b25a5d8e795620182c29817ad1151d89f2e932d770b_Device=CPU_Config=() +1016:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f9c575f17138032804a74bbc18e420d0084e6e09c89b13de1f4f73d145887313_Device=CPU_Config=() +1016:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=86fb2ad636e51f682c83919d64217835cd9ab458695e3bdab295c4107516e733_Device=CPU_Config=() +1015:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e2d2eef3e776af9379eb35540d8f4c888491082d8333aeb70f58822aa5cee878_Device=CPU_Config=() +1013:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9984b8a3f89c63f522926899b38043623619e9b47918f7835234a4ea5f615c21_Device=CPU_Config=() +1013:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=dynamic_IR=f550a37ab884668f47ed232e7119c2a2baa814c98fbbcfa3129e7a00feebde0b_Device=CPU_Config=() +1013:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=6b2c79edda9cc9cce61c98552d6a0d3a3555c9ccac3a56c6692f536a0abdb61e_Device=CPU_Config=() +1013:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bf4d5291899ea4eccf6584f62d4ecdfb39de79edd102e509f840664838f59d19_Device=CPU_Config=() +1013:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f43df065734a36674b3fdc7a47fddd1cfa5c1b36bf73e7de86a100c645fbc7d3_Device=CPU_Config=() +1012:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=efbe921ab3c27a093f20ff704fd02e5c610e7507d94a2d2092379c5a99743380_Device=CPU_Config=() +1011:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=49401e607e42aa23290f59c3d3d64d54eeff9afcdf99177506283d43b6a43928_Device=CPU_Config=() +1011:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=de3da71f184001d4023831fe48fe316da81a312cb66747fa283da0c0b101dea6_Device=CPU_Config=() +1011:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=9337e101d74f6d35bf81e9be895ffba9e972cdab9d79b2802f1c1ec0f4d34a83_Device=CPU_Config=() +1011:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=49b05f6b6a636d84beca451fdc1fc81e3411a100ea105fbcd49ef72ef1fa0934_Device=CPU_Config=() +1011:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=92c3646daf445784fceeb022afba2831938fed34660bac5445f033a1efdccc34_Device=CPU_Config=() +1010:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a82fe43f495f5ad83d1fba98c09af9c14bb09cb506339e5ed48c78c8a6c973f3_Device=CPU_Config=() +1010:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=21950c433f50ded0f662b9e0591e756a8dd685bc11a8296bcacc57ca1a4968b4_Device=CPU_Config=() +1010:conformance_Range/ReadIRTest.ImportExport/Op=Range.4_Type=i32_Shape=static_IR=8d3863956a8a6a5067c45d40ae0207b14b9f1736bdf2a5b8c01979fbc012a5e9_Device=CPU_Config=() +1010:conformance_Gelu/ReadIRTest.ImportExport/Op=Gelu.7_Type=f32_Shape=static_IR=8876bc4ad78a178f235f48e06e705a7dbd3f7ca06e3ea5052e6136811da69d20_Device=CPU_Config=() +1010:conformance_GatherND/ReadIRTest.QueryModel/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=() +1009:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=20af9ae4466332a072f3b04c1219146d272daabf2306b66c755980bfd31f2a76_Device=CPU_Config=() +1009:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=8fc296db9f7dd10289217cb81cdf5991c6b5f3c89369936a94c8ac484702bfa3_Device=CPU_Config=() +1009:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d8a48dc7581c2ece0179d0ad668e8caebdddddfe492e365ea2e0e5f3a7302eea_Device=CPU_Config=() +1008:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=94ad9524c175a0e0d2fe22bceeac82b0dc66006caa0942d343d551268e03afec_Device=CPU_Config=() +1007:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=05c2f891e743416ad510bf0ebf713738bd41258123cc4bbdc5cf067f251e35d8_Device=CPU_Config=() +1007:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=fbdf008803736374dd213f1d7e0a041fc0e9b3f025c212a588fa05842ee5ee56_Device=CPU_Config=() +1006:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1c4aa866633b1381ff8ee36910d91aa4750c9a8dbd05ae159b7e15a65a08bad3_Device=CPU_Config=() +1006:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=592176a8c97f4d759a0c6b3ef56c3610df4a0df4743f3be7ba3ed2ffb5dcfaed_Device=CPU_Config=() +1006:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=baf2ff4e48e3608f42c5a92cdd7fbd8c4a47fc66e47143e52e4db2f83781ed2a_Device=CPU_Config=() +1005:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=656a9ec09853506a1b2cebaeb2f64a14880cd860acda34dd13ed3d3433d69971_Device=CPU_Config=() +1005:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.1_Type=f32_Shape=static_IR=f735a44db0a337a22f5ebed052a5718168765287ff4e0eca961c3f9fd68586c0_Device=CPU_Config=() +1005:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=4e14d87b7667a7900d4427ec46c72eb3c7bfd2e3d86e5bdf92eb2485059b4951_Device=CPU_Config=() +1005:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e4ce66856864b395e08ba68b1e0fe9ebeb0777392c288b334e06553898c04743_Device=CPU_Config=() +1004:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a0b3d7813e380f287a758c35e56e8e8edbb72b8c64fab6194a8890dacd5e2f16_Device=CPU_Config=() +1003:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=385190d3bc54bfee5cfd98858a99a50146f755735ce9e86804b0d50f2191bd8c_Device=CPU_Config=() +1003:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=e939c4d2a27e1d7dba93827ab807881c32e47d48b726fec701712bc85c3404a8_Device=CPU_Config=() +1003:conformance_Proposal/ReadIRTest.ImportExport/Op=Proposal.4_Type=f32_Shape=static_IR=ea8cc682a9a36cc61498573e967ec64d289af84a9e3da1911085b1de4fea4c82_Device=CPU_Config=() +1002:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=7c1b4dfda36336bb1a943fec9786d89e220f2a811159fe9cbed7d51186f8fdfe_Device=CPU_Config=() +1001:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a4e73a0235c7b64a58687dbaaf8530e902e4d714a509dc9fc3ff499467c2fd05_Device=CPU_Config=() +1000:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3d918677d26d54494f0b1fe41a32370a3d82612fe8e5d5c17a04b48f63d353f0_Device=CPU_Config=() +1000:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=776018866cd0a06171706794dcd0d7bb13b5960fd98a66b306ecfac7595feec9_Device=CPU_Config=() +999:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f1f5ced67e3605021d51e7e29d94b4f0fc3ac4542f527f8cd437f44859981e83_Device=CPU_Config=() +999:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=static_IR=f9377788ac0fd1ad0a7f51d16543722cb5acb69640745df17d9f41f5d1d0b544_Device=CPU_Config=() +999:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=20d41e2e902d25c339d648d9f20a3e7f524320dc7186e989b1cab13e401d768d_Device=CPU_Config=() +998:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=() +998:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ce13c479a981a68967fe75da84baff1bbc1ccaf0dcee5aa988d71bb49bba14ab_Device=CPU_Config=() +997:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=767873fb6967801da9fcbc8dda360a2d30ba207cb97cbabc82a509799c40a882_Device=CPU_Config=() +997:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=static_IR=2b026a0d21a35251b07099e31ec58c459b848602575d2afa67e55830e8f3f411_Device=CPU_Config=() +997:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=a449aa561efb222cad1a414ee87443f9fec0e5c2f6220f6a57b6705c9ef26cd6_Device=CPU_Config=() +995:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=static_IR=2e3f53e7b949e1dd0ab38890b0c9fc9e770dfb68569e37fa5cdd4e3ef03d6eb0_Device=CPU_Config=() +994:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=dynamic_IR=33e67497d576ce6af4a214d55862646d034effd328ef5beed8d7b0f380b6b689_Device=CPU_Config=() +994:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b60e16251938c61b34dece8f23651a595c8c8744df391c6ba17bc0e0417cb398_Device=CPU_Config=() +993:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2e834fff42b38f5e5dfa3c3e756cc51789a286876665de46d98a504961c24c88_Device=CPU_Config=() +993:conformance_Range/ReadIRTest.ImportExport/Op=Range.4_Type=i64_Shape=dynamic_IR=0d660483dfd9c9975f102d300ec98da49785fcb6484b379c45df8a61e1292797_Device=CPU_Config=() +993:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=9caff6e502635d35017973f6026a64d02feb4d470d43b7ccd7d85090006247d2_Device=CPU_Config=() +992:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ecdaea0a2e3ff82b4695e13b586aef85eb4bbb0df0cf85b13b006d98095995ff_Device=CPU_Config=() +991:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4e6262ae12e4f9470a87cc4f1cc1ef2a817a8080e25a79ca4ef67cb60a558b41_Device=CPU_Config=() +991:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1f1ec212e843ba389ab363fc4d7b5a1056b8c5e82147d38f6c151cb31538aaa5_Device=CPU_Config=() +990:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=() +990:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=() +990:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=6d5907929d59d1f99e85183238e29d6602c84721d099284dcb8900ae5fc3c45f_Device=CPU_Config=() +990:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.1_Type=i64_Shape=static_IR=1c06ff77487507dddcddf290d75d4812bfc8a7b2c9bc78176da5212eab029966_Device=CPU_Config=() +989:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4df4ab698c70278594efe8b4349a4c99c8b2ab7c4ee0182c5a4b7673da922ad6_Device=CPU_Config=() +989:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=8fc5ce53f1f6b924371ab2cf156ddbf7aea234b17befdcb6206ba51a7ad988c9_Device=CPU_Config=() +988:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c18f4f45c8ca59e5fcf1d2aa0b6115c7fb6789c4d4a583cf93901e65f4ac692c_Device=CPU_Config=() +987:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f5f514f0e9ac5f357ad8b35c991975751b7481abfef63fbc338232ef15bdf7bf_Device=CPU_Config=() +987:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b77381b3187aeb253a360ff35b4beff6401a89ff07a851230e2dce191c0a136c_Device=CPU_Config=() +987:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e995424209defee7f9c521cb07889eb499bd546ed3dde685841d518b2e69da58_Device=CPU_Config=() +987:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e098a555ca156806b9c32b2049d750a8610e250d8976d9bf35629e517ea6e85f_Device=CPU_Config=() +985:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=355bfa53a1f9e712db4df6642a51970e96e3612583b2ec90e7a8170e45b1625c_Device=CPU_Config=() +984:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=2ef8d38ce64fd0460d641e6f3bfcb1654bbe3d2c25f9dd244ae259eaa4b6941b_Device=CPU_Config=() +984:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=() +984:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=a72b942dc1915ccee8af871c00b16647db7c8935100b012f91ebd799bbe8d416_Device=CPU_Config=() +984:conformance_Mish/ReadIRTest.QueryModel/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=() +982:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=() +982:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a8ca0b23e0a0f66247fc693c6a8982e4f7daa11e14da296db0dbc9277fcad4df_Device=CPU_Config=() +982:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b46a2ee4f7042328b2496382ed2bb9cf39621c3e3e27fd1d355c9682543effc2_Device=CPU_Config=() +982:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e1aca62d840d626a9f0b30aa19a251616a698bfec39e4ae679e50345edfdd4e8_Device=CPU_Config=() +981:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fb9febc1b0984c7d6887460d058a75a9444bd1ade793c5b945c9b79ad2c63e46_Device=CPU_Config=() +980:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2fdc1dd5841fbc3ee03a323fde995a9b51793a170b2c2fcb504ca721ac981fe_Device=CPU_Config=() +980:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=() +980:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=839faaa50aafa2e3ed38fc682d0759304b694043dac1a242a085e2973aac8091_Device=CPU_Config=() +980:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=593116ea16692c8f5a8994c0562c47e1c627f9088c519b752a635a7d91973085_Device=CPU_Config=() +979:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4113a61cf98e226d48988dd52624e716382c5f03426f185f777b6018d77633cf_Device=CPU_Config=() +979:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8c3b386463bd59945d3c15512b26409dee7da9b1940f153e3ff62d47d6f79d2d_Device=CPU_Config=() +979:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e0ae8d59ba587db8057e6d8a9304e9d9b946d338db08ea5311182b6adfed4478_Device=CPU_Config=() +978:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=01b095b8763565527be0de9edff565070949485db907493e99e95c2cddf6abaf_Device=CPU_Config=() +978:conformance_Proposal/ReadIRTest.Inference/Op=Proposal.4_Type=f32_Shape=static_IR=b169d6330e4006909e4deaaf78b03e789ccd9538c5b59d9d41e05f878bb60704_Device=CPU_Config=() +977:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f894fd40780753da9c5cbb224a6981e690368cbc31e132922ad38e4e006f7827_Device=CPU_Config=() +977:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=9337e101d74f6d35bf81e9be895ffba9e972cdab9d79b2802f1c1ec0f4d34a83_Device=CPU_Config=() +977:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=33aa0d800115f94b07bce9c6ca8b4447f2c4f442bff77cb9b02b23d2ddabcc01_Device=CPU_Config=() +977:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=46b077d7466eecbadbb7ceba5ed90724db3d9e216d22171f5dee02e44b9a5377_Device=CPU_Config=() +977:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f82842bfa510be994f17d9c00d43b6f67b232b3a41c64ae276e243610d927d9_Device=CPU_Config=() +976:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=6ab37e1d52328b5ce1204cfe13977b06dcfabeb4acff9821d65ffc91bd3cf09d_Device=CPU_Config=() +976:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=e1130d42d591780dd2a746ce7ff874a2bf4725ca9fd09803932ba4a7b0b389aa_Device=CPU_Config=() +976:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=e14dc7fb2cf0b63fd08f616d407511ff2036109a3e105dcb87398053d1c334d0_Device=CPU_Config=() +976:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=static_IR=8834a8881c2da907f6ae38d4c45100dde754e653f3e4994cf9add141c217c781_Device=CPU_Config=() +976:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=2c5e9a1cd59ec2d5786132697bfcb1519a7857cdfe06038bb39abed39c09e9a2_Device=CPU_Config=() +975:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=6e53e1fedd57631f3ec70d6825d8d1029ac95905b82b6bef7fd44ba87373e9c6_Device=CPU_Config=() +975:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=060423427a9100b6a38aad12a83043441f8af436c1d2502350ae867f45bd721f_Device=CPU_Config=() +974:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7ab51e173b82572bfb29cac5dfdc326e3689e466c68cf91590dcbdddf1f530de_Device=CPU_Config=() +973:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=0db5765bcfeb7716699abd0cee850918cf5ef18e2cfdf1614b463734ca35a20f_Device=CPU_Config=() +973:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=3d24c272ca88d4ee24f437a310abc05340e110f8596beb6a1ef96dd18818ebbe_Device=CPU_Config=() +973:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=69a9e38799e925044cfd025df20a3593240b2d1145de5eec905d30b3a1ad923a_Device=CPU_Config=() +972:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cf981b73f7cffceac87c13ff562674f1c6b457bc6275704b4ad29cd943f3a15b_Device=CPU_Config=() +972:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=cb67c5d0b8712ebac00fe4169f0cad2e0a8c71d7f9603d5d2ce6ff6dd6bc055e_Device=CPU_Config=() +972:conformance_ROIPooling/ReadIRTest.QueryModel/Op=ROIPooling.2_Type=f32_Shape=static_IR=556c6863ca3b12d255c4c81d92b4573203f02c5588e064fb22dd4aa23c8283c6_Device=CPU_Config=() +972:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=6289232b1cbbafc963ac3cd787330c81a9cd02def9fefb83d6f6cced249de92f_Device=CPU_Config=() +971:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9e83fbe4b350e0cdf8db8795ba31169b98503108dc45a266c88b734a4f54b3f2_Device=CPU_Config=() +971:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=() +970:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=c307ba8fc5f5d81037e40e46cb8ce1057d0bab7433138943596e5b21bb84221e_Device=CPU_Config=() +970:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6624c22e3b5d72c4e8d21df59af6f3759fa4d8fa68f2b5f3f92a98d6a943d0b4_Device=CPU_Config=() +969:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=01d609bdfca9f2a499a564f66ab9dd71b394310593d27b8739283b19980e2dc2_Device=CPU_Config=() +969:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=() +969:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=263843a2c307b91ff7d59d9b21cd8b2126e985d787fc18f44df3525a6bfd71f3_Device=CPU_Config=() +967:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b062486251781b09e932268862ed34f7a6df71ce15ea598ef5344f04f88c006a_Device=CPU_Config=() +967:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=745c0804609863998b4bcc6956b1e78fc221e0e4f1535ab09b89a9c966a16995_Device=CPU_Config=() +967:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=a1862e486a20c8de71dd94c12a157098ac5f222ba8ba3e1d3edaf9362331e185_Device=CPU_Config=() +967:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=fcaed70a044afad6974286c0d3e90f463ca73c7d1d8714c627be2fdfa341f87b_Device=CPU_Config=() +967:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1245c8dbd9027cc56d2eeb58e1bd23774ce945522f66a17ecc3c03ca1ca163b0_Device=CPU_Config=() +965:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=11f515fce08428a29e672f25127e81f6388202d9e971704738d7fb758a615a10_Device=CPU_Config=() +965:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=27770ad19af38d01d0238b726d4dd5c3cd32ac743c3b55d186f966658a53f8e5_Device=CPU_Config=() +965:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=87a966d3d3b90cb32db3454c5dfb2f67af86b68a5e45fa1c5f4a75c3b5cb452b_Device=CPU_Config=() +964:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9e573f34ccb820a89a27cc243a7cda8ecb2043ae1cc557a8ab7e4670b1d72c0a_Device=CPU_Config=() +964:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=368972b9c1fd7f33348656101315b2ca3ed44503ce08ed5c9baf75026dec049a_Device=CPU_Config=() +963:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ffe64e2ecd6d3ed3128559b89dd2a26ed439c533f6ebeb969ebeac62f80dc12e_Device=CPU_Config=() +963:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7304a384051e1414ef335109147d0dbcc385650751a174440bc9712f89036372_Device=CPU_Config=() +963:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=b94b5361ee75b3684455c2b871b656a50c72e325564787c302a714f222845b26_Device=CPU_Config=() +963:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=dynamic_IR=502fbd3f8c0e9c0a9523269a9df9b0fbd83d59ca94f373fd543048429a957f5c_Device=CPU_Config=() +963:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=3effc90c24c0eb76bbc89809d34c6541654366a02e21378a668dd932a6cc7756_Device=CPU_Config=() +962:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ac619545b2ef19185f57aba7a31752da1029c572269af4a3e0d95dec2c9e64e1_Device=CPU_Config=() +962:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=61104a3a93d0b36db7f0499ae63420f216e5d7b0171b40c4629f640572f04f2d_Device=CPU_Config=() +962:conformance_ReduceProd/ReadIRTest.QueryModel/Op=ReduceProd.1_Type=i32_Shape=static_IR=e34207bf06e51dbf322bc0db76f3a9828ae018b02dba2b1826ed97004bee8125_Device=CPU_Config=() +962:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=66a4d902b67742a95e2d41d79b9d2434e57a55c168a88049624a0ccb62df9ca2_Device=CPU_Config=() +961:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=597a8a56fae623dd0684f6e4040ffd6ce90166e43e47adbcbcedf1dc5136ec23_Device=CPU_Config=() +961:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=static_IR=8c82cead166c3db4616f034b66c4795cb4bed653de41d2b6dc71b48ce76a296e_Device=CPU_Config=() +961:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=05d14a25a72424a0290894aaa67c6a1581b34ab0c07cc2acc7739f837b432068_Device=CPU_Config=() +961:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=1409169e395a3eb90f9235b74f2f8c94e0e27a63fae33cda153d991ae1cbb68d_Device=CPU_Config=() +960:conformance_ReduceProd/ReadIRTest.Inference/Op=ReduceProd.1_Type=i64_Shape=static_IR=44e0e688ecb44d7a9e83f7c9e1639fae49b2883dfc1b1ed588c98c5bd1f614fe_Device=CPU_Config=() +960:conformance_GatherND/ReadIRTest.QueryModel/Op=GatherND.8_Type=f32_Shape=static_IR=58581d0746e5bf56df7df18df87d35371d41ff69ba09c7850c8e96354c7910b4_Device=CPU_Config=() +959:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3c0b9fab07568e0eebb5e5d068cfccdd617ee6e98e4253a0461ea8d3f0f582e8_Device=CPU_Config=() +958:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a956d2fb1fd17e2d864b3eaa8915cc0c4f9a768e35fdf5bf20cf6bc7f41aa130_Device=CPU_Config=() +958:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=74310de2f35ad8a1bf7388138114655c2c74f1e85fb8cde4584f3d7905345140_Device=CPU_Config=() +958:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=25ae6295f4d206fa9069e20bc659dbd87c20aaa15c3f149ab25d003641c738c5_Device=CPU_Config=() +958:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f0853773e26eae3d051504ed8db7f182c0e90ef7b45625a1a72ac51a73e2208a_Device=CPU_Config=() +957:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c9c03f1be9f6d66301feef3e2ddaff82fc6412c616494f29214d4a6bbf89adcd_Device=CPU_Config=() +957:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=12d0999f6ddfb04654b91fe374a7b55fb33014f3c7477cdd03c76730327d97bf_Device=CPU_Config=() +957:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=05f8a9ef1ef4b191dff5dedd1fa79abad9603ee87a49306ad26c5d20ad067448_Device=CPU_Config=() +956:conformance_Range/ReadIRTest.QueryModel/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=() +955:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7f5e90bf4696bbe503abe4ed3337d44ec48775276b9fc9b10e87e48e788b2fc7_Device=CPU_Config=() +955:conformance_ReduceMin/ReadIRTest.QueryModel/Op=ReduceMin.1_Type=f32_Shape=static_IR=61bca82940fd4a54bcb587a88272b81c191b8feeab37bfafa044ef768240977c_Device=CPU_Config=() +955:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=cbd1111f323b8e6d78b59b531708defef64b90463f973f64f52251795ac5a7dc_Device=CPU_Config=() +954:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0dafd9117cb3fba3a335f7cd28aaa3fbd9276878383657b357210e135a93d916_Device=CPU_Config=() +954:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f5f514f0e9ac5f357ad8b35c991975751b7481abfef63fbc338232ef15bdf7bf_Device=CPU_Config=() +954:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4a483d870c0607c1102f09322af7a7ca052532a9f6fcf698a66d282c0ea2f278_Device=CPU_Config=() +954:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=1e5127a9c21ad1ccabe67dd1f1e28a3730c09ba294ef1f9fc001c6dcd723ec62_Device=CPU_Config=() +954:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=5b1fc9693e4e947bc88a88bf1ad22ee2f59c13bf291626eec3e8ed49b0cef7ed_Device=CPU_Config=() +953:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e86061c75b7e9a65644e82de6b8fb2a532ebdfb302f46f378b6ff20af8d1d14b_Device=CPU_Config=() +953:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7a0968eb49e54c601398168e34cb61a84c9795b06e60d49f21b96b5d462838f9_Device=CPU_Config=() +953:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=83b83dd13b1733a50ec728ca6e7f09eb75641a573178816d1d33f30390464d87_Device=CPU_Config=() +953:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=70d4da84623a0af3bc8362a828bac5ef13285498b420a3df6bf2e88bf05311db_Device=CPU_Config=() +953:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=() +952:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8fce2d85c65eb0e8b40c2923338675276902296daf8744322876552dcd68f7_Device=CPU_Config=() +952:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=2620e86e1e6ce8f0ecb3eebce969f3e7df11f7f86c6f97309aa24993f9036033_Device=CPU_Config=() +952:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a46f51b7498c921515a53b67480ec4d413ed43ff809e1fa6a4deb7365f4a0460_Device=CPU_Config=() +951:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=fcaed70a044afad6974286c0d3e90f463ca73c7d1d8714c627be2fdfa341f87b_Device=CPU_Config=() +951:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=1f7f2d40b938416773b13282d8ac09d81a50e4d5d7548f42fc5fd575f84e1385_Device=CPU_Config=() +950:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=990cce0ce92df99ae74ad8840f7b89d1c48c0044deb9cb71619b44a565eed911_Device=CPU_Config=() +950:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=99820651f05bae979a287a8644f1b739637d684efad288b48044c2a664e43a3f_Device=CPU_Config=() +948:conformance_NonMaxSuppression/ReadIRTest.QueryModel/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=() +948:conformance_GatherND/ReadIRTest.Inference/Op=GatherND.8_Type=f32_Shape=static_IR=58581d0746e5bf56df7df18df87d35371d41ff69ba09c7850c8e96354c7910b4_Device=CPU_Config=() +948:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e4ce66856864b395e08ba68b1e0fe9ebeb0777392c288b334e06553898c04743_Device=CPU_Config=() +947:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=30eb0edc699f72085fb77a6cc31ad4aa9e62cf97befb64273493d234494fc64c_Device=CPU_Config=() +947:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=28675c37d06426cf6895e7ffc15d6c212ef8be1b278fd199d1bfbd0678f825fa_Device=CPU_Config=() +947:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d0aad85620a1b97486758b17c69043a6a9cf75a459bf6e283b28ca132e917dcb_Device=CPU_Config=() +946:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=ae7b6a45a538bb7f65d5895f2f7941fd9048645482faa40adb1f773e282a946c_Device=CPU_Config=() +946:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=acaf36c12445c608b306074ac4e2be9cfde2f5550905993d4b5bd1714dc96aaa_Device=CPU_Config=() +945:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=65a49a4d063513732033e2f838b45c3c176217b8f801ecb9357c99a35022587b_Device=CPU_Config=() +945:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=31dea0868f4a13f6a25819e26ae172201cf3d52de718fc200edb84cafe7c2cf9_Device=CPU_Config=() +945:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b4c9edcf320dc72ad463dcf64da84add367d2ea5eaf1a8524793f37a5eae7c7c_Device=CPU_Config=() +945:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=static_IR=591cc5abb16f22cfa720e53be695097b83c42a971536fb5b79d0b02cc4ad328b_Device=CPU_Config=() +945:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=683b86794b415f893e4d426a8c68aa38f46c250e4c31bc5f5807a86c20ffb34b_Device=CPU_Config=() +945:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=99e405218c1a96c5f8af65aa814893d8958e8e991d1ed8dbbbd586efa589df39_Device=CPU_Config=() +944:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fa169b001a47d2c4cfe07d837ca82977192701fb3f1f557e0c792675f00f8158_Device=CPU_Config=() +944:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=d8432e7d31bcf4d95ff7ab845a6858ea67cf751c7ef0fca60a9bab1d187fe3cf_Device=CPU_Config=() +944:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=f26c1f41ef689dde33e9d61b0a1066788b8397ba6a170f5eb1362726ba9c0868_Device=CPU_Config=() +943:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=936ac30f388261cb12776b5e94062a9b5f7b81aa16c9aa5d8f994b8d69231c40_Device=CPU_Config=() +943:conformance_ScatterElementsUpdate/ReadIRTest.QueryModel/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=() +943:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=32537f045cce3d13cb28dd292a0ebe06e13002877d9ed2e5b25d3ebdf5afcb58_Device=CPU_Config=() +943:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=556de70b55386fc9a264a24a9000d075a07636de6461cc5f4cd41af639b0597e_Device=CPU_Config=() +941:conformance_ReduceMin/ReadIRTest.ImportExport/Op=ReduceMin.1_Type=i32_Shape=static_IR=a2b9f0b4c044e23f536d137b6e157d1357df657d1af119cb8f71294d7dc098cd_Device=CPU_Config=() +940:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=6b2c79edda9cc9cce61c98552d6a0d3a3555c9ccac3a56c6692f536a0abdb61e_Device=CPU_Config=() +940:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5dd2854a965fe5894fa2a05ada313f1d7b1a1bf82873873fd1ebd3f8eb812941_Device=CPU_Config=() +939:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=70a452909b242f5920ff1e78eea212c720242ed5fe9c22cd1149e3f9847167c1_Device=CPU_Config=() +939:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2bb16e2257294e3f7d905f66a483a8210f392ea822836e4edcf8910a7fbb4277_Device=CPU_Config=() +939:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4080ead6d9ec06ff8d7629bdd5eb303e82d35b5cbe53fb11d1a49b671d3e37b4_Device=CPU_Config=() +938:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c03bca3c44df7946fcf273e9d79309b7bf33b465206eb9caf76750735e1ad19b_Device=CPU_Config=() +938:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.1_Type=i64_Shape=static_IR=1c06ff77487507dddcddf290d75d4812bfc8a7b2c9bc78176da5212eab029966_Device=CPU_Config=() +938:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=206184d6fe0a3ab9fe71914c66d3804e145caed7cf3ac09cb1d50183144d6ac7_Device=CPU_Config=() +938:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=358a9002c54b7e671e8c11c8e6deb11c8463b81846d305e47c75eb3c63bb5b21_Device=CPU_Config=() +938:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2dd63d58c85301d765882b95995de97f4eff14bbb3c933c4e4b8ee5fbc2e9e71_Device=CPU_Config=() +937:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7f595d19716e871ad3301526008abcf663271669fa7d55bbf292a853e9ff517d_Device=CPU_Config=() +937:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7509cd031f0085ad09a30a02057f1c0dff7ba78cd13f43ac124b33ef2cfd303b_Device=CPU_Config=() +937:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4023cad1c8e22f448d84a0d7ed783f00a9914bfe546ad07fc16a88b6fc6be3fa_Device=CPU_Config=() +937:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ed872c2ef0d35af97e7f9be84d83eee6d42f2fb279b71f4feaa1aecefb450a28_Device=CPU_Config=() +937:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=7df296e0e156bb36cb643a292802f9db374c77035c6a05ee4a865fbe2c6ef92b_Device=CPU_Config=() +937:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=554e762f2b3a5d9d335e464c65b1c240a9e92e4f765ac8734c438cb698883c8d_Device=CPU_Config=() +936:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ac12549a897d099d4b2e7c3872b9b9588639b7bc484648662121cffefd6c04a8_Device=CPU_Config=() +936:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=fa15f26352d0ced4d5f1b31c382aa71fe9413ce66ba6664ab9bf9a24975ee3be_Device=CPU_Config=() +936:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=538935936007865ddd2f8ef5f2a5b1eb0e7a372163b2f13e068a3309374e19c5_Device=CPU_Config=() +936:conformance_NonMaxSuppression/ReadIRTest.Inference/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=() +936:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1245c8dbd9027cc56d2eeb58e1bd23774ce945522f66a17ecc3c03ca1ca163b0_Device=CPU_Config=() +935:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=() +935:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=c5b83fb7df33573c55e1177d717a1b7222d1c09e86cfef73d51a44d7354c2402_Device=CPU_Config=() +935:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=abd733caa05592feccf41344f138de6625efce4afe605efeea57e0748d7b2e07_Device=CPU_Config=() +935:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=f26c1f41ef689dde33e9d61b0a1066788b8397ba6a170f5eb1362726ba9c0868_Device=CPU_Config=() +934:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ba515e47066707dc9346b3002df0666bed67bec38ecdb0489943423ffab1a7dc_Device=CPU_Config=() +934:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=() +933:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fb61da088a1643592479d343650408e3ec6518afaf1f38d808feda9c222f7564_Device=CPU_Config=() +933:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9d606780b6c646a5fc037250cae9a636436e56e277c95eadad5ce23fa09d8b13_Device=CPU_Config=() +933:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=dynamic_IR=dac2c804cd13d69a51906319a3648ac0edd87764c686c99fb47179f379cecf7d_Device=CPU_Config=() +932:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=i64_Shape=dynamic_IR=84a8c7a897894ee6bb1c03759bced74ea6d773a2cb8335efdc8d193a534f3833_Device=CPU_Config=() +932:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=dynamic_IR=08776190d0fddfcb15ad75cdbf6892de03f79e89d57e02b7c3e80b4a7a125d35_Device=CPU_Config=() +932:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=139cc84777f1e0d489245d058877303e72a93eba3cffbf5f919de21b4514bb0d_Device=CPU_Config=() +931:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d3add9f9496b58c3880dcf71a47c3efa156aa225d6d7faebfdf4c2f8e44d0be2_Device=CPU_Config=() +931:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=dynamic_IR=0f5965e2daa2a1f6b050813850956d9a4bbd771cb234ec814617099e1541ea0c_Device=CPU_Config=() +931:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a93ade5d0390a07d7f8a6ee0c7099a40b3ba3df0b28a9d72cba7006e4d0191fc_Device=CPU_Config=() +930:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ccb19a7166645dd3a896b2f1f731dc87da95f98a8f824e46d434dc12f71e663e_Device=CPU_Config=() +930:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=223a34e46344a0dff7f35a637c9bd08e2a76a552ca87e5bf0134c9fc6d6be41d_Device=CPU_Config=() +930:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=dynamic_IR=08776190d0fddfcb15ad75cdbf6892de03f79e89d57e02b7c3e80b4a7a125d35_Device=CPU_Config=() +929:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=() +929:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4bae2ff9aaa35cf3821fd34e05a504bab2caf5e9a2fa8b280810d6ac40ea07a0_Device=CPU_Config=() +928:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fd62dfe7f4707f12da18744aa57795baf078b77819fd22b889cd02559e70d7d6_Device=CPU_Config=() +928:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=static_IR=8834a8881c2da907f6ae38d4c45100dde754e653f3e4994cf9add141c217c781_Device=CPU_Config=() +928:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=13c78a6d628bed4392d2577f132f924d9e17a7e29a2171dafebc0a596d2ade04_Device=CPU_Config=() +927:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a238be92ae9af3847efd5c18c494e648745ccbaa22e358b663de4c4f2b733bb9_Device=CPU_Config=() +927:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=dynamic_IR=a99a5ab2de2d408c2e40ad5734c9bd5ab4d1d221f4dd24572e05538b134ef88c_Device=CPU_Config=() +927:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=18697d690af0de3ff8365a5aafa6ebc7d8e14418c3ab5dd55b3b505d2445ac86_Device=CPU_Config=() +927:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=() +925:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=d6250086b712a16042ee74438bb61b89fbfaa5bae433049207402d1da4cffaef_Device=CPU_Config=() +925:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=704412b992d55bf9ff00d823458e5d3b3a369e47b3eca3429fed94b87c8da554_Device=CPU_Config=() +925:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=d9231cf5e3e491e318f16514e771cfdee4b781b42fc9d45088da850ab48079cc_Device=CPU_Config=() +924:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a956d2fb1fd17e2d864b3eaa8915cc0c4f9a768e35fdf5bf20cf6bc7f41aa130_Device=CPU_Config=() +924:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4b386237f65fdaa6fdcc6826f3c331a945b8a7c0ab860e83f60fe2cb24e3277b_Device=CPU_Config=() +924:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d13d862f7b8306948676388381950639ef433dcc4e38f5a6fa8d50575d1aa814_Device=CPU_Config=() +924:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=5c5e10f28ed3a8d4ee0d3c8af982df5f383a4a1a713baba556dd17ee52e9ef32_Device=CPU_Config=() +923:conformance_ReduceProd/ReadIRTest.Inference/Op=ReduceProd.1_Type=i32_Shape=static_IR=e34207bf06e51dbf322bc0db76f3a9828ae018b02dba2b1826ed97004bee8125_Device=CPU_Config=() +923:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1a01e1932e9e30974342c0a6e382d829af6ca776db39be738e54a55a09732ed2_Device=CPU_Config=() +921:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=577ff3f9c8d226d1899056073c0223ae2d81dcc940c5fef8b9ce9cf63931e9e2_Device=CPU_Config=() +921:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0fb6a7848271e000d49d4966647edf55e65f181523883089f43147c14cfb9871_Device=CPU_Config=() +920:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=7b702f91c21af6c336654c924011d0f4d149111c503c697fcb85a83cd60b7ab7_Device=CPU_Config=() +920:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a24dd1485e484f31d0c72f3a0c31f373f883f6ca4a751b1d2ce18132913506dc_Device=CPU_Config=() +919:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=51390fa8c8a5680ae4a8de4f655083caefbb8445dac8814d2b1827e2bd43f470_Device=CPU_Config=() +919:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=b11ede8f1aee40577413d8bbe89704e02252e3f02805fcc0ded624857ddb8280_Device=CPU_Config=() +918:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8c4eeec465e40ae0a63a47164cf3ca02e4d9a215ba5340bb1df1a5d165d8894e_Device=CPU_Config=() +918:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=ae7b6a45a538bb7f65d5895f2f7941fd9048645482faa40adb1f773e282a946c_Device=CPU_Config=() +918:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=990cce0ce92df99ae74ad8840f7b89d1c48c0044deb9cb71619b44a565eed911_Device=CPU_Config=() +918:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=5498e895212b57b42748644679c1dd67936f230d2c61998ca6bee31d527035cc_Device=CPU_Config=() +917:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=() +917:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=b050ebcbd31acbbc43d657d87a54415e0e52d3e91fa95b57aa1dd0451a5bf50f_Device=CPU_Config=() +917:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=99377bd11138d36797502d82ac9adddc31dfe1e4cbb8bba8684b1479f8a16f26_Device=CPU_Config=() +917:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3209c1cce78c7b856203c0a5676f6fad4d098a3146c7305ee3c0471b3be2e3d5_Device=CPU_Config=() +916:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=47c28b32453e7972e5f4a7213522370ec927424c913b5c6d0ec08a00d7a988c9_Device=CPU_Config=() +916:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=6e53e1fedd57631f3ec70d6825d8d1029ac95905b82b6bef7fd44ba87373e9c6_Device=CPU_Config=() +916:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=5150e1785d97b052a42873f9e9d23a511027248ff4b13ba7c269c8c3d4639e45_Device=CPU_Config=() +916:conformance_GatherND/ReadIRTest.Inference/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=() +916:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=5498e895212b57b42748644679c1dd67936f230d2c61998ca6bee31d527035cc_Device=CPU_Config=() +915:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=2538d525d8f11b9f4961c2a4a8cc36fd27d8b3d97271ef7db4f7eac9732b71f4_Device=CPU_Config=() +914:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=59d132b45e2ac60a670eb43efafa43f065bb43d492208ac670fc8234b4f618c9_Device=CPU_Config=() +914:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=d50dd7c19583071293118e8b98f2bc749ef3e34ab8eb0149138e6b9fe49a153c_Device=CPU_Config=() +913:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a7242174afe3f7c2e95d31cd14d56ceb0a566e2e8d65ba97e07d004200f4f517_Device=CPU_Config=() +912:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e62245706f4242ff86bcb70d4d221bf49aa31db3807698d574125166bff5f8aa_Device=CPU_Config=() +912:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=80f2651dfe68b893f390dc18ef997cf1e234a087d016cdacbbf96a91968cce82_Device=CPU_Config=() +912:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=c307ba8fc5f5d81037e40e46cb8ce1057d0bab7433138943596e5b21bb84221e_Device=CPU_Config=() +912:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=10cf1b7a4de1231ad721c9660697d6ee17bcaa2151f08eef596b41e6e3aa1b2f_Device=CPU_Config=() +912:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=243bd2256612673dd04651521ed8d3fa4087c90af7b85e1a4aa381c074bacd47_Device=CPU_Config=() +911:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a4e797de860d6e4dcec00062050168ba9745d3da953b9c644de654f4d2818b77_Device=CPU_Config=() +910:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=8832b317ba58dd0efd1e8fa5238d35644d8468a03c9b35809a20ae64098dc986_Device=CPU_Config=() +910:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=03c3e6567da3c139c19e0ce0d301a6076b2e2446d191216c7bf38bc030ea7855_Device=CPU_Config=() +910:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=96117baf3ff208c696a9796404eec467b613c37977067ff0cc62e39355856d30_Device=CPU_Config=() +909:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=24d05884873d69e036ce6647cdd8eb4a82fa7b8d30629e86337a1df10ccf45cd_Device=CPU_Config=() +909:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=2e38326f5f0527299a0385fc3bb6c85c80e12e5bce07fe530624aba7113e82a6_Device=CPU_Config=() +909:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=effa926dbd9beaa9b2b7b660288ceab99da8cfb440c4b01b7779d1bc25be336f_Device=CPU_Config=() +909:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b0a418fb8ec50f25147079b3aef1b13095ea626a9e52a643600c39972982ff9c_Device=CPU_Config=() +907:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=60e017f098b38fe7f824eb78635cd13cfa1ff460387abfcd6420c8a7d559a915_Device=CPU_Config=() +907:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3d918677d26d54494f0b1fe41a32370a3d82612fe8e5d5c17a04b48f63d353f0_Device=CPU_Config=() +906:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4e6262ae12e4f9470a87cc4f1cc1ef2a817a8080e25a79ca4ef67cb60a558b41_Device=CPU_Config=() +906:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c4679c052b2077c278e2200b5bcf502b660529c84bc6bcd58f92594a69f6648e_Device=CPU_Config=() +906:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=262ab76d80fd9b35be837e391c9bf6c54e3d9124d25dead135ec19b75b1777be_Device=CPU_Config=() +906:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f9c575f17138032804a74bbc18e420d0084e6e09c89b13de1f4f73d145887313_Device=CPU_Config=() +905:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=362638bf065f1917d2b4dac3008a8f46f8f8d64a80d2442c1ad98f4fb943cff9_Device=CPU_Config=() +905:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1891282a9bf460336bad3c354519aa0d87ba6ef40876d4a07592194d2d678e25_Device=CPU_Config=() +904:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d4c59fb1b2e6f27da249cc36d5d1a4c867d0fb17e9354f63b69f61f74780f8d0_Device=CPU_Config=() +904:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c0413244803edff103b95dbbcab27b2c714740372ba215264371a9474355a8c4_Device=CPU_Config=() +903:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=2ad5b63ed56c3966570062970125d1cac16629595e9ac34c6613cf00d6dec0aa_Device=CPU_Config=() +903:conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i64_Shape=dynamic_IR=0d660483dfd9c9975f102d300ec98da49785fcb6484b379c45df8a61e1292797_Device=CPU_Config=() +902:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cdc993ef8686eb949184e962d0790c38c26bd864e8d415fe06a86abe3bbcb4e7_Device=CPU_Config=() +902:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2e834fff42b38f5e5dfa3c3e756cc51789a286876665de46d98a504961c24c88_Device=CPU_Config=() +902:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=63de0838ea26e3575f49700f73fffb0d3415ab68b29b1a1da690b84f7a034822_Device=CPU_Config=() +902:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=c5b83fb7df33573c55e1177d717a1b7222d1c09e86cfef73d51a44d7354c2402_Device=CPU_Config=() +902:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=dynamic_IR=502fbd3f8c0e9c0a9523269a9df9b0fbd83d59ca94f373fd543048429a957f5c_Device=CPU_Config=() +901:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0785cae4389228b343e2620b4fad71e5d1343838d4fe2c766bceb2e337334e6a_Device=CPU_Config=() +901:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=i32_Shape=static_IR=f777fb31e1669cd58cc77e2a04c3f9a804b654b6d710432641a3dc34504460b4_Device=CPU_Config=() +901:conformance_ScatterElementsUpdate/ReadIRTest.QueryModel/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=() +901:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=84f6f3544adcc7c68df5ca411844cf36c2232c1b6c820094e5693a444faa143d_Device=CPU_Config=() +901:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=e85722360042c3ad04d04157759bf404452b789f30eb1174cbd59a5d7451df30_Device=CPU_Config=() +901:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=23389586e5eb8cacb13f6355565cddaf542d2d26439bd3d4b577fd716a37b53b_Device=CPU_Config=() +900:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5b654dfb551ec2d83e22a133055d78f13153fc1554728e34aa7f27a3f3c08541_Device=CPU_Config=() +900:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=e14dc7fb2cf0b63fd08f616d407511ff2036109a3e105dcb87398053d1c334d0_Device=CPU_Config=() +899:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=static_IR=2b026a0d21a35251b07099e31ec58c459b848602575d2afa67e55830e8f3f411_Device=CPU_Config=() +899:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=dynamic_IR=fc75aba0dd172d6628de0b473569c672b52f070ac3c446cc3342cb1184ef076a_Device=CPU_Config=() +899:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=4fe95284f224758c29c5198a8b2e6f97e8e737435d36cb94b9cdf0bca3c89dc1_Device=CPU_Config=() +898:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d82f645d11f396433cad131e1e490842c14fdb9e439d93fb9425752b6a3aff09_Device=CPU_Config=() +898:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=a6b0532b200874d6d1c57719b46f2b301c368ebc35042df00796dfb87eed618b_Device=CPU_Config=() +898:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6587874c50811a2ca7e27f84cb4381e9a06eb4465e940ea877c76dfaeba02753_Device=CPU_Config=() +896:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3ee918ec76a3432c5179480e1417b0bc84da24c2716af490292525a824d1d2ae_Device=CPU_Config=() +896:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=() +896:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=02d773fa3ded668594339c08735173e7435442663aefc405993d5191e5b8bcc3_Device=CPU_Config=() +895:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=f1e43476084575ad240db6631f433a61ba2076d1ca95e44a0e4471ea9d6f66df_Device=CPU_Config=() +895:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i32_Shape=static_IR=22a8f509c3f76bc2dd6bc9a26ec4ab92a5b9ae4678532c886c1438669d627323_Device=CPU_Config=() +895:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1245c8dbd9027cc56d2eeb58e1bd23774ce945522f66a17ecc3c03ca1ca163b0_Device=CPU_Config=() +894:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0cb77146d653391361407152c1320db480d5f737d2918eac934c5ffd371cbaeb_Device=CPU_Config=() +894:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=43da553b4ed22d425e5b43a911992715161b9d57d481149f00551c7f47e3c048_Device=CPU_Config=() +894:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6fefc3626ba6ef60433d3635bd5abeb3e7025277a86e2fd9d92234ff099c303e_Device=CPU_Config=() +894:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=() +894:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=64e95307077995f1ccc314b1cfb2254a18895371b5ebe71b521523cb42e456d3_Device=CPU_Config=() +892:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=3ca9994321c7492af9bff158852a484636638e711ae39a6acb66d273f696906e_Device=CPU_Config=() +890:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4e9ae0418fb4f362c008ec90ef89001ecb8d13900c970d3ce051489c69305995_Device=CPU_Config=() +890:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=06fdd8a11a7ec3d8a9fc5d188f881cc6bbcc5b1bc669ceaf88751a03806257ae_Device=CPU_Config=() +890:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=476785aa2a9596b31a395347e49b62161f2aa9c33db10c64337eebc3892cfd61_Device=CPU_Config=() +890:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=() +889:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=() +887:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a238be92ae9af3847efd5c18c494e648745ccbaa22e358b663de4c4f2b733bb9_Device=CPU_Config=() +887:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=10f9a2b62a6505b51206efc6d6fc6ae5aea9bebb43abeae7e0a46a2c6cf50e16_Device=CPU_Config=() +887:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=d246ad7201844e04821cf31a7d0650c362d6684da5e02f625d28b1afc3789127_Device=CPU_Config=() +887:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=83d90ef3fac993f7efba4a8ed369781571b1b536af03ceb0267ae979379e1dd9_Device=CPU_Config=() +886:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=84d3a33f9325d947a72b4e26d046e3e3f9cf41091f7c8e1c654899b3088ce6e5_Device=CPU_Config=() +886:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=be9d62b38b487f1687abc68e6955b012b030507b9918b4cc95dafcdf403a2b45_Device=CPU_Config=() +886:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=718d6ff3b19f498cf4edeb9f7f4a7528fef578dd6fc7edb0796d476505472e46_Device=CPU_Config=() +885:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=28bb0064e4cb56c497227ec69899b08dc09cccbf7d390555416aff617a393f81_Device=CPU_Config=() +885:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=469a63c5aee73bdefc9abdf8abd8413713c0b68cc098d16c193399a11c7093c5_Device=CPU_Config=() +885:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=c52cc9f84ee56b9ced415f830d9f251e52d1dc56a3cace6548b3d345d2b1e812_Device=CPU_Config=() +885:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=caad691eb2d7c291cbb0078e861cb3f1a79f6c321b092365dc9612b2140a76a6_Device=CPU_Config=() +884:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f36d9467906cadb1202fffaa25f62cacdfb177a962074a358a0eb95cc9b5bfeb_Device=CPU_Config=() +883:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f6340be757a977d5ab8a7c533a56c520f2babe002ccc1ab2537876dc6083c323_Device=CPU_Config=() +883:conformance_NormalizeL2/ReadIRTest.Inference/Op=NormalizeL2.1_Type=f32_Shape=static_IR=e177da00e93cb595c18d142e92898135415f0de01a3b1ea763f3ffef3d7ce96b_Device=CPU_Config=() +883:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1396dd3cb903e42ed4ef83843ffa16a65203a07192ac9ba8160fdf02ed26632f_Device=CPU_Config=() +882:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=4d10da0860e049587221c12f55c3bca9fc587b74dd3fec194c8ba5854a736d93_Device=CPU_Config=() +882:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=c7a696f3217515ef4ff5eb46fbd15af6533f0fcd268398fbd434f105c0a11328_Device=CPU_Config=() +881:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4232c8e7fec9c583f6a244b2b7a8bbad618819f7885f8486a1b2a9e3b36c90a7_Device=CPU_Config=() +881:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=5150e1785d97b052a42873f9e9d23a511027248ff4b13ba7c269c8c3d4639e45_Device=CPU_Config=() +880:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0667c865b35e65d521f8edcad5e99d49ba8e55fac0c439ae095cb50de75fe8a9_Device=CPU_Config=() +880:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=168e02701204a8f0e325fa1a2a4407612df10c3218c9431981fa6f1f8300eec2_Device=CPU_Config=() +880:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=i64_Shape=static_IR=75c36f65570966e7f975e5c839036e0e13fe30e6d24ce4be8e6a0e8449173951_Device=CPU_Config=() +880:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a46f51b7498c921515a53b67480ec4d413ed43ff809e1fa6a4deb7365f4a0460_Device=CPU_Config=() +879:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=f76da5edfb7a9e3fa7cec034fa43307bce74eeb0629176ae5dd40d154baf858f_Device=CPU_Config=() +879:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=d246ad7201844e04821cf31a7d0650c362d6684da5e02f625d28b1afc3789127_Device=CPU_Config=() +878:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5c0ed2041d97a9387b2c2f31ea1f5ab3e98edcaeda47d184555677418853dffe_Device=CPU_Config=() +877:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=f32_Shape=static_IR=c14da825d470c9141af0ea87eb82edd0866a415cb5ac59f1014c2ded35340201_Device=CPU_Config=() +877:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8ec74565f16a2ee1e322b4549ea19aa0b30719787abd90bd957e121705edb268_Device=CPU_Config=() +876:conformance_ROIAlign/ReadIRTest.ImportExport/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=() +875:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f64b683dde6fe3d8d6ae0734a986a290edd10869211c7a8c56eb51c170f1a231_Device=CPU_Config=() +873:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=86d8d42c30e423e801b5d4d832f87cd6837bf9feb3c546f5bf87e04f842a04f1_Device=CPU_Config=() +873:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=bec81407211db6e10d7c8811bc58b53c23c8aafa0e2083f262204f345b9bcfc6_Device=CPU_Config=() +873:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=284de068bb05428358d75ba098c74615e828fd9223970fdea43d02fa028419fa_Device=CPU_Config=() +872:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=afd856f31f3a815b84c34b66e1ba0a70a313301ce82fdccc2f1b779ad3157d4f_Device=CPU_Config=() +871:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=8ea778d7d98fd08efe4b2efa501ef3599df00ca9bd036980ce86e0d6dc454b96_Device=CPU_Config=() +871:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=b81d993247e604272e6df01b8c4ba016be7f60263c892e8469deef67a8a6afba_Device=CPU_Config=() +870:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=i64_Shape=static_IR=d106f0cba8d8311b75f6074c099f45e10400c0829fdd1826292b1310471076cb_Device=CPU_Config=() +869:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=0d6cc305ea05df2178e3b4ea61ba2f296655e77af08556491e0dc8dfd46bdc6f_Device=CPU_Config=() +868:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=b31dbb99720fd5083e5a7e5b1b626bda91455999e2918eb8e658992cfa6588dc_Device=CPU_Config=() +867:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=43da553b4ed22d425e5b43a911992715161b9d57d481149f00551c7f47e3c048_Device=CPU_Config=() +867:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=a35667a1c5401fb3102a59ce0fa67d0ea4829f8ce282c43767517ce025469bac_Device=CPU_Config=() +866:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=e1d727df48a0a74d8b9865c00e5c39c9d53a5023d83da3c58f281b6b1411b696_Device=CPU_Config=() +866:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=d04bc06efa76ef2937aa1539893ec9c79ac61c765cb50cd4a26dbf5586bfc904_Device=CPU_Config=() +866:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=dynamic_IR=a9636e6e43bc01f8b1cfcfcd8e60e4ffba20837d0d3b80429c93f23cd8da89e0_Device=CPU_Config=() +865:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ce0514ded018b3bde00091b50a98b715da2a3e3c254406b9fb290b930d6f5680_Device=CPU_Config=() +865:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0cd1ed0a25942b7e306b973035f3bbfbaab0fdd913df064809ff363cadbf91b3_Device=CPU_Config=() +864:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cbff70cde6194997d0bb4a7fe099d60116085fa72b8840e54f79ac61a5b4c1a7_Device=CPU_Config=() +863:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=13b2245278f237db23d5f5cea6e9c464521180559df4059ba49d98669f5227c4_Device=CPU_Config=() +861:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6017d3f7ee3d7e667e8e7e4881f9aae335d47c8617c92b18ec370aa0770314d9_Device=CPU_Config=() +860:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=80938e021a1ae127646a1f7e09de3970f443d853b6efe5116383ae37825f57e8_Device=CPU_Config=() +860:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=95f63bbef529a44cd7170b83f4b385f0c1520f117ed7b4767527daa0fe893316_Device=CPU_Config=() +860:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=d3155499ccf835bc57e4ca19c25ca32fc63ecede0a2c43ab2a3e43ba4a6a4dcc_Device=CPU_Config=() +859:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=00c74cd8491e5a74d86270cb7657f9a7e431f820cc7c6421a5cc278cd8f13fe9_Device=CPU_Config=() +859:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=u8_Shape=dynamic_IR=b12ccd794c23494b994608015d049eec0f2ca30dc319bd35c1adddb3e4b8e631_Device=CPU_Config=() +859:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=88c7bd909ddf1935966d1937508ebcbd6e56526c7354bb3a40bd9de52aaec142_Device=CPU_Config=() +858:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=86c848e55f2afda40170f7cfcc9c260f896ebe2c73819f75a124dcb67cdd6a75_Device=CPU_Config=() +857:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=256f1706e3c9255a819cce8f22bcf8f6e6bc01e752443461711dd28d5a51946d_Device=CPU_Config=() +857:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=34069e6a539019d1d06ed15853842399d30a3c7931488d2e03dbbc9eb4c189fc_Device=CPU_Config=() +856:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2ab325e62a5a8c5f36571bce678481798f4a5f0a854c92db5e834ea4737077c2_Device=CPU_Config=() +856:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=564cd54b2564c7e39fda0c5e580c274b7bf99603760f6c66f03b4450f23cc4bf_Device=CPU_Config=() +856:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=81eb5381e1d4d3dc7cf0d83a9cd787813d3267c99b31cc9a3cb0cf9b01727c0e_Device=CPU_Config=() +856:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=4fe95284f224758c29c5198a8b2e6f97e8e737435d36cb94b9cdf0bca3c89dc1_Device=CPU_Config=() +854:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=de3da71f184001d4023831fe48fe316da81a312cb66747fa283da0c0b101dea6_Device=CPU_Config=() +854:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b38f11a07d752c83a5e4fc709d5b78fe9a40ef3394f4b617a30df29c21640338_Device=CPU_Config=() +853:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=827eabaef75593763cce8084a77e9ab8c8aee3de527727acafbffcdf5efc2766_Device=CPU_Config=() +853:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a3bc997e1de8be5fd5b66a48e1a9ef4bf9e4143cb12313b2d9adf3dc12ae0111_Device=CPU_Config=() +853:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=08ba7fbf736896f373ea81dd727940aefae22a39e217e84dfc5617ed62133d10_Device=CPU_Config=() +852:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c789d40bdedf25bda58d6d6ce2f690850ec42ff8712abd23f7947a8604b6953a_Device=CPU_Config=() +852:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=86decc829c047a5febe7e5d047c689075810441a2f4725088317ef68d6c31239_Device=CPU_Config=() +852:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=dynamic_IR=c838ac42d5464130a9049a63f7020166b34e2ef974c257a4060fa02c3b70ff76_Device=CPU_Config=() +852:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=a65e17fc28c74df4f3b1bad89635ccfc376a857f2d92ba646ca830b03eafab7c_Device=CPU_Config=() +851:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=86fb2ad636e51f682c83919d64217835cd9ab458695e3bdab295c4107516e733_Device=CPU_Config=() +850:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=206184d6fe0a3ab9fe71914c66d3804e145caed7cf3ac09cb1d50183144d6ac7_Device=CPU_Config=() +850:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=dynamic_IR=8029d5dae7f4721807eb717310512bad44630efdd0a64962496a0fd802a12325_Device=CPU_Config=() +849:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5f2924e748f389c659aeeb2dd9899519d96db396695abd625520a5ec60d6ba5e_Device=CPU_Config=() +849:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=223a34e46344a0dff7f35a637c9bd08e2a76a552ca87e5bf0134c9fc6d6be41d_Device=CPU_Config=() +849:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=() +848:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i32_Shape=static_IR=22a8f509c3f76bc2dd6bc9a26ec4ab92a5b9ae4678532c886c1438669d627323_Device=CPU_Config=() +847:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fb30e40bed920f35420787b2bd98f04d496df16cc51c355611af5307cadd605d_Device=CPU_Config=() +846:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e5249d5630503351688090f1a9d0143b02e750045924aee8f9003072446583f4_Device=CPU_Config=() +846:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=99820651f05bae979a287a8644f1b739637d684efad288b48044c2a664e43a3f_Device=CPU_Config=() +846:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=b729ddf6b689006067cfce88ec7d9e89268dd6cd904e4596717016541632b13b_Device=CPU_Config=() +845:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=dynamic_IR=214b1d4be2a141409b6b54847c952a282d9b2d7236d3d8ada3463f7dc8554097_Device=CPU_Config=() +845:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bbb0129fbafd6d1874ccef37a1bb60379733012c502d58326dae70f413e387f2_Device=CPU_Config=() +844:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=b91a183b8c36d6e8358dad7056638b8091005393dd1ee6813728f25cd3e6a9f5_Device=CPU_Config=() +844:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9360fbacf32f2208bd7f241535752ccaf434551d16bd8fd46d0422cd1cafc3c6_Device=CPU_Config=() +844:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=225424666fe2b655277d52f1d551c6e52e36cd5fd6f45f4f29dd0d0f66b4ba40_Device=CPU_Config=() +843:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a8bd299de91e7b19efaf1e0cf6437b26549b7f99481196b375357bd1a71037e3_Device=CPU_Config=() +843:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4cf0a180eb5154fca591a8d3239f3bde9024ef2b347a70c3b10341243e679177_Device=CPU_Config=() +843:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=3ade42cfc9d970963d8f162b001075864e6967034198986f408ec09ce4093d18_Device=CPU_Config=() +843:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=45c9fd0289649c455939587c623f1884a4e675e2f970192d9ac2f60a65e6da9a_Device=CPU_Config=() +842:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ef05cedf5dbaee70082962e6459d8391c8358cccf43e33695d15184215d26d8c_Device=CPU_Config=() +842:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f96e0fde526a6672a21a4a485e01f6fd57bab2da7b34ce44915bf354198dc6ff_Device=CPU_Config=() +842:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=a72b942dc1915ccee8af871c00b16647db7c8935100b012f91ebd799bbe8d416_Device=CPU_Config=() +842:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2fc01b66086ac5d8272dd81ab731188b62bbe8920bff1efe61bf3261a3a8b3e6_Device=CPU_Config=() +840:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cc0f83b1e6167e74fe1198511d4fe4de611a24a0daaefec2eb2bac280de9c5a0_Device=CPU_Config=() +840:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5bb330e06cd9ca29e3e19f09ba0c9f129025899cbf69af96fffbd58bf1f55ab3_Device=CPU_Config=() +840:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=fbb85f74ecfa0ffc50b9e6ce637911b406f1fd6ad054a886b9c6ddc6bc898739_Device=CPU_Config=() +838:conformance_SoftPlus/ReadIRTest.ImportExport/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=() +837:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=83b83dd13b1733a50ec728ca6e7f09eb75641a573178816d1d33f30390464d87_Device=CPU_Config=() +837:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=0d6cc305ea05df2178e3b4ea61ba2f296655e77af08556491e0dc8dfd46bdc6f_Device=CPU_Config=() +836:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0dafd9117cb3fba3a335f7cd28aaa3fbd9276878383657b357210e135a93d916_Device=CPU_Config=() +836:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c7b882a2a8948d97135ee2faaec7d11cf59af2bc2398a4b3c4713242fcc04bcc_Device=CPU_Config=() +836:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7a5b4de9e365b548d2bfc06db9bc63ec0dc941689701f984326d837bf152347c_Device=CPU_Config=() +836:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=1696523c5dd3a701251583b9c9f29e43f852383cec3dde5a93e6f7f7cabf3398_Device=CPU_Config=() +836:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=d246ad7201844e04821cf31a7d0650c362d6684da5e02f625d28b1afc3789127_Device=CPU_Config=() +836:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=e0422b2fb57587a85d9ce1532f7fc28a6bd01e72a325d42d9045419dda4bbba5_Device=CPU_Config=() +834:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=ae817dcac1ed2395cc4098f67bf6d2bcbecd8b7e91ef7592622d1ee75ed4a3cc_Device=CPU_Config=() +834:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a4929232b06cc35bd37dcbd228c83319db5ff98f120a3995a6806d397e16d33f_Device=CPU_Config=() +833:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8e41f166e0543ab380f90b0ea86819136cd0a5cf5e8ae0cfca988e81c93ce28c_Device=CPU_Config=() +833:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=d7fbbe9f8f446b009ea2de8594e4cfaad46432734cba27596e3fa721f04c04ee_Device=CPU_Config=() +833:conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=() +833:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e77468c2881ce0c38c14038151d560ccadc7dcbd5eb5f21b68b8e227c89813a7_Device=CPU_Config=() +832:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=be67f733f734ca7f0e54076cf1cc39016924607014ae1a312849e8b5cd5b916a_Device=CPU_Config=() +832:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f06ff28476f886d4298a83d39f88aff34399d5cd589e0a6d6395e00b0ad96876_Device=CPU_Config=() +832:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=596d0b6cfe8b39e0ceaa665f1fa82aeeeff78d09315fca7cef031b6dc210a1f3_Device=CPU_Config=() +831:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=() +831:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0031aeefe417dada5913585ba3aaf8d0d79706ce509a7cb72ab3c0e9b638d46f_Device=CPU_Config=() +831:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=3801fd5b86bf772977c131734d8356c8dfa41b9056091937473be600e332fbee_Device=CPU_Config=() +831:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=86fb2ad636e51f682c83919d64217835cd9ab458695e3bdab295c4107516e733_Device=CPU_Config=() +830:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=5498e895212b57b42748644679c1dd67936f230d2c61998ca6bee31d527035cc_Device=CPU_Config=() +829:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=cb2f89380861307422024c308f636e33a827f32a721e54a380fe2b1c1b74c881_Device=CPU_Config=() +829:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bd1eabf7e4126b68490c086db76a9a27e0b55e7047080ccf96158337c8a9e74b_Device=CPU_Config=() +829:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=12d0999f6ddfb04654b91fe374a7b55fb33014f3c7477cdd03c76730327d97bf_Device=CPU_Config=() +828:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0c0c04b18975ff24a18715af981baaa3d45e746c73fbc71ecb16eea245197d50_Device=CPU_Config=() +828:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=d2759b52de5dc9f1fa494c243d08ac40cf4e877c51323d53dbfa02abc1564e45_Device=CPU_Config=() +828:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=() +827:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fb61da088a1643592479d343650408e3ec6518afaf1f38d808feda9c222f7564_Device=CPU_Config=() +827:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=004b6fd9b060324a42aad296dcb21f5b7eb7586c082f98d23f25a6d882f70c14_Device=CPU_Config=() +826:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0402d5c12674452050553b4b26ffea14a2107eff83f28b23c10a0a6f847bab71_Device=CPU_Config=() +826:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=e7e985d4d02762d236131e74fd867acff1828bcd4c4eb32e190de20eadb831fb_Device=CPU_Config=() +826:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0534fdfa97228a6aacf4ed196a9ace8e09d8e4decdcce058176b0312500b6c07_Device=CPU_Config=() +825:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=2f23f1158754aa494abbf61ab15118173a7ccfe90523b2b9ab7cc3a6fdaa0e37_Device=CPU_Config=() +825:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ce2bcc21fba106cc8be4846179a73cb30f650e7ec48d443fed591f6b479fa9d1_Device=CPU_Config=() +824:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=025f133a063248650fab4c898fa6dc245e844e4f0c8eec7603403515fd023164_Device=CPU_Config=() +824:conformance_ReduceMin/ReadIRTest.ImportExport/Op=ReduceMin.1_Type=f32_Shape=static_IR=61bca82940fd4a54bcb587a88272b81c191b8feeab37bfafa044ef768240977c_Device=CPU_Config=() +823:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cfa4ea6d340205f9fc4db4ec912037243299168e9bfa4e248e530c98a0f8a8ab_Device=CPU_Config=() +823:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e003079e1703f756924619f2a77b6c26741ef71bc404419560faec9c56bbfd2d_Device=CPU_Config=() +822:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=85ae3a9991f339aa4cae498d33e44fd838b3e3f8e2cff7a64701b62207ccc965_Device=CPU_Config=() +821:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=285bcc240dec2c32e171f3866ea33107a109566fb8ef39f0dd84e99664aaf8df_Device=CPU_Config=() +820:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=08a156f89c28d3860b50a10fc3402ee84818806257b897f68135fe177ad1f3c1_Device=CPU_Config=() +819:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b227737b26850463ce87153061b94dcd71131aa06e3032b7f775a64e1c271f93_Device=CPU_Config=() +819:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=abda9df0d20139a837c079060be4bebb2d5c65c2b166341559ae9eb7937593af_Device=CPU_Config=() +819:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=eb014b2651dad2cccd6291bceaca16047a4a7fce1595430520ad8d8601ff29c9_Device=CPU_Config=() +818:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e6724e0da81e65cac207d53f3b792b046d3d6dd47230a7cbe0a690baa9f59306_Device=CPU_Config=() +817:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=05e9fdd5183bd179e5ef996ebcdc53f239900ca46a8122ee8bb1e885c2c091ce_Device=CPU_Config=() +817:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=() +817:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=0db5765bcfeb7716699abd0cee850918cf5ef18e2cfdf1614b463734ca35a20f_Device=CPU_Config=() +815:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b57367632c1064f82de68ae9aac88d8522a6039ced4d1078483cb2c679785f04_Device=CPU_Config=() +814:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4cf0a180eb5154fca591a8d3239f3bde9024ef2b347a70c3b10341243e679177_Device=CPU_Config=() +814:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f8e0d0e358dfa2f404e60abbb4cf7a170f79a17291f48b69743d6da0635e8a98_Device=CPU_Config=() +814:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=219ef0bc43f90d459144cdbdb363c5382ed62c90acd319a628190dbf8f0becd9_Device=CPU_Config=() +812:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=dynamic_IR=0f5965e2daa2a1f6b050813850956d9a4bbd771cb234ec814617099e1541ea0c_Device=CPU_Config=() +812:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0ce1ec496e5d71728fc5daaba87809c5922406a65e85823913381de0d2112e01_Device=CPU_Config=() +812:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ee1f9348ff09a058dc09cd63581663590521d463d14b785a23ccd3cd28110b5b_Device=CPU_Config=() +810:conformance_Equal/ReadIRTest.Inference/Op=Equal.1_Type=boolean_Shape=dynamic_IR=0723b6d683bc65225624112929bd8f7a0adde9e9c2265a2ec1a54b10c4433735_Device=CPU_Config=() +809:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=() +809:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=63bf42d0ab3a502b446b21489f7320d954a2f4f00a1e11da7d9b948fa1f6cc90_Device=CPU_Config=() +809:conformance_ReduceMax/ReadIRTest.QueryModel/Op=ReduceMax.1_Type=f32_Shape=static_IR=590a910a27283b92d7a4650bba546a3bec08a6ded604bbe8523ab3c6d734c70b_Device=CPU_Config=() +809:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=() +809:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f069cbce6f4c3276869b6d9c4a6c843d7a1e1c9d299e8680218636b04339a9dc_Device=CPU_Config=() +807:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0d40552a1b6c1945765ada16284a0c03f5c1454fb12f226a34dee8a07b14f17f_Device=CPU_Config=() +807:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a78437a93ab424a706d064188d1bc0971b2e1afc98a74fea979a6f8b99036597_Device=CPU_Config=() +806:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=29d3ebfbd6a10a5c74102ea71c9edd316f60c2c7a72c81f554f81416f9296c91_Device=CPU_Config=() +806:conformance_NonMaxSuppression/ReadIRTest.QueryModel/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=() +805:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5e98e0dd0eec9f330eaedb43a4d3ee506c10d23283c3e25e753b634e819f460a_Device=CPU_Config=() +804:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5d5b6e996a1c477f211ce82bdadd3228788cea988eebf25d5f40ae1a745418e0_Device=CPU_Config=() +803:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f0ea143c11c6a4cda8cfcc01f0532c256b592f807ddceebebda7e9eb8f01d919_Device=CPU_Config=() +803:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=12e7ea655764a32069a93a3f7ab147983bceeacc8a2bc88fbb2def005a1596b3_Device=CPU_Config=() +802:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=cda3b9bda63d065b5c27e6bce5ffe20968024d77efe5e174a9f4395db56a30c0_Device=CPU_Config=() +801:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=8ea778d7d98fd08efe4b2efa501ef3599df00ca9bd036980ce86e0d6dc454b96_Device=CPU_Config=() +801:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2bdfd42ec67d330dec8ea2817499b4c2d32a3d91deccede902acba057b050c49_Device=CPU_Config=() +800:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=() +800:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=23654f4a28ae697d81f49d72568e7f0657d5c15b82e173fd7381760ebcb61cda_Device=CPU_Config=() +800:conformance_Abs/ReadIRTest.Inference/Op=Abs.1_Type=f32_Shape=static_IR=5713be8dd761def00c701c74d0aa913d259206eff1103b9fa6de0f6f1a25e566_Device=CPU_Config=() +799:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9991a1b4140ee8e6ed0460fb384b7729f681bc1068315a4d970eea59dcc89950_Device=CPU_Config=() +797:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c4ae9be783990e398b3e8f0af76cab50d72c40c705677a3fe1c5dea592952d1e_Device=CPU_Config=() +797:conformance_Greater/ReadIRTest.ImportExport/Op=Greater.1_Type=boolean_Shape=static_IR=aed960e9b7608b89973346cc2ab23c7ff65e72275fa55daa8b13f925a3779701_Device=CPU_Config=() +794:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ba97799aeb7eeb6f62c2e09e38a2eb4d4a5a9d47712788d47182b3de43675082_Device=CPU_Config=() +794:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=93a382b4c379f41c5a888ff51ba8ae2cb9e7812ce4c14f1a028fa383051a9feb_Device=CPU_Config=() +794:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=446eb2e8b2bc5f4e6c1da3e9c4b0492fe73408e4749ac3947e39c18b54bd13e5_Device=CPU_Config=() +793:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5aa3e3ebd200b6e711e72c5af6e13edc0b956656d479f25f85d6d76377c1767e_Device=CPU_Config=() +793:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=60a41e3bf293fc0a0556993a8e0d339e47f85bda8e98f726367cc6eda681994d_Device=CPU_Config=() +792:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=67396728229ab01facbaa211eeb0a7213b6a9e32d99709bd6320863fc63d1c4f_Device=CPU_Config=() +791:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5c0ed2041d97a9387b2c2f31ea1f5ab3e98edcaeda47d184555677418853dffe_Device=CPU_Config=() +789:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f0fc8ad1a674a35de1f2e88a1f17905801a6f083a37f5fe658ecdd6d49d30c40_Device=CPU_Config=() +789:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=4df317952d546ce966e5273b7fcc7a611c641b1cddeebc74d1b66ea80567ee89_Device=CPU_Config=() +788:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ccb19a7166645dd3a896b2f1f731dc87da95f98a8f824e46d434dc12f71e663e_Device=CPU_Config=() +787:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cdc57df56ccf890a00f886c3b83f504d24ea9d4ed5f0ef05f1189879172777f8_Device=CPU_Config=() +787:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=39661d69e883bb7940e185a991f7b6bbd05248637577079fc52794cd1e215062_Device=CPU_Config=() +787:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3ad94046aabf97af320725b888d1b85ad5d47cac065d8f6c54cdd5244bc0ac32_Device=CPU_Config=() +787:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9c66c6a6d93c10149920c3e034d9a0765afbef45dab66083fd5e3d796a57e406_Device=CPU_Config=() +786:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=64efb6dd46c36bec02b92148d178bc032417c8c2d999ff7b0a24ba08af365f91_Device=CPU_Config=() +785:conformance_Gelu/ReadIRTest.QueryModel/Op=Gelu.7_Type=f32_Shape=static_IR=8876bc4ad78a178f235f48e06e705a7dbd3f7ca06e3ea5052e6136811da69d20_Device=CPU_Config=() +785:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6964f870fd6bf44d1d5ee5925eee8892230b8928aeee1966db73b6c4fcd5acf8_Device=CPU_Config=() +785:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=61f5318f717a5e0eedebd7dbc15069fc98f70247111220da32b449508ea00abe_Device=CPU_Config=() +784:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8c4eeec465e40ae0a63a47164cf3ca02e4d9a215ba5340bb1df1a5d165d8894e_Device=CPU_Config=() +784:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=277be9cd89ba817ab595481b040e3435eb08d1a79bcb05a7796110550a071201_Device=CPU_Config=() +783:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0783bb527f80cd61cd46b7bc7ec93ca0cc51ec61792cd0fea8eebfbf121ad5bf_Device=CPU_Config=() +782:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=33d84638f606d759354e190991899e47d2f4c63b0e378aac985e5fb9132dcd01_Device=CPU_Config=() +782:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5adf6fcb72c0d6086a95fbbc5744e7d02dfb32490e0f42c62b57bc98489b801c_Device=CPU_Config=() +781:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5d522332a7166265867b633721d8bd8ff23a233e7c8bff59a245bbb24d7be234_Device=CPU_Config=() +780:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=dynamic_IR=8b79cf070ed44bdefd5afbe86a81199e189fa486c42190795419dbfc7cc26d6b_Device=CPU_Config=() +780:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=19a94fc5cfe3ab1b4e169b342ec8d9f0fdc4ef19484c8c34d6ab938c6e7bf5fd_Device=CPU_Config=() +780:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=978c328422e3866322f3bdd52955690a47a1fdd47ddb9db66a4707b36a535dbf_Device=CPU_Config=() +779:conformance_Less/ReadIRTest.ImportExport/Op=Less.1_Type=boolean_Shape=static_IR=953b15e350d9a27c4d048cbae41a278c732f3b3a6e8debd7fd2e75e99a015966_Device=CPU_Config=() +778:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=008827517eea396c81f651f8dc2f2a43e2cf000f96e28cc8eb0ec7008f1e11e3_Device=CPU_Config=() +778:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b0a418fb8ec50f25147079b3aef1b13095ea626a9e52a643600c39972982ff9c_Device=CPU_Config=() +777:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6d754f7aaf66f59951015d768d438e036e0c598303c67ee404c5f9a4f8aa30b2_Device=CPU_Config=() +777:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2f96ff03126561aa475067ad88e454b2da78fc8f0b816dc6c01ec5c81568288d_Device=CPU_Config=() +777:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a238be92ae9af3847efd5c18c494e648745ccbaa22e358b663de4c4f2b733bb9_Device=CPU_Config=() +777:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bee0968c080b9f9f930b23a2c79d957f1c160c34d994e617ea29a641b0e269c7_Device=CPU_Config=() +776:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9fbf4ccaa68a81191afe2432a2212ee1a559df380d602459ebd2d0266053d82d_Device=CPU_Config=() +775:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=e7b766e89f08e80fd96ba40dac738561546ca7210c4566b727ca8cb49528c823_Device=CPU_Config=() +774:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3cc5aa461509250629415c061c909228cfe34e8f773b88badde597ee264be865_Device=CPU_Config=() +774:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=79a28185585166e8c3a7988d1e74df784bd8078df963fd220b97d5624ad8ce76_Device=CPU_Config=() +771:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5aa3e3ebd200b6e711e72c5af6e13edc0b956656d479f25f85d6d76377c1767e_Device=CPU_Config=() +771:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=2538d525d8f11b9f4961c2a4a8cc36fd27d8b3d97271ef7db4f7eac9732b71f4_Device=CPU_Config=() +770:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=189793140439255931ae5b3ea93f68da1569937f3c591ff27de99064829a75ca_Device=CPU_Config=() +770:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=06fdd8a11a7ec3d8a9fc5d188f881cc6bbcc5b1bc669ceaf88751a03806257ae_Device=CPU_Config=() +770:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=effa926dbd9beaa9b2b7b660288ceab99da8cfb440c4b01b7779d1bc25be336f_Device=CPU_Config=() +767:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2006e1eaa808a3e78550535058de54c5cd83e9a32a52e488fef1f7883c321a3_Device=CPU_Config=() +767:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=98c467c06ecdfe13b1f3b90237bd32041a11c553f544328ed9b181bbc3201f6c_Device=CPU_Config=() +767:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=66ab5cfd788be1a5ebe89e70a1318d6b905d3600d0ac5a967d07a0ad6828e7df_Device=CPU_Config=() +767:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ec42345583e635cc0f51b20699c340baced5816bd7ea62856d8b3f7e21a164cd_Device=CPU_Config=() +766:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6b1dbd40d09a340628ec975eb623751a161ab5b7773b190e38272c409d8bb4eb_Device=CPU_Config=() +766:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a7bded06602c3d42bdffa7e21822a12759cdd54ff8803c8502ffe1b2348b1f8e_Device=CPU_Config=() +766:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=4d9f16ede014da56824607d45502439f71b57275c332fbf15c6ba2ec1496466f_Device=CPU_Config=() +765:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f3dcab6635e317bee634addec1b7f9664b2f801810997519ab06efaf1d869f81_Device=CPU_Config=() +765:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5288d099588f5876e907c5cd750c9f0b2191d1ea060881e80af1006cfad259ac_Device=CPU_Config=() +765:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2e1857ca8967deccb2baea1810c6931a1b19fc0e963dfaf3ca3ca4fb4e433657_Device=CPU_Config=() +765:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=f73224b14c094974e582d3d903cc332f5c1da138368692e5d0be93127f1bf753_Device=CPU_Config=() +765:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=517a5eeb2f1f21304b8a1d5971f89bfc93aa678252180bdb05144657b1a8619f_Device=CPU_Config=() +764:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=933c6450f6856b32e879034662cf60eca53970c10106f8a11eb925e5621042e9_Device=CPU_Config=() +764:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d141b35e277394511f5635b2e395039c986ac392e6f49c2415da6a5071bee96a_Device=CPU_Config=() +763:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cfd594e916dbe86e473f1a80da2913bbbc365130d9bac66c0be9531ad40ba673_Device=CPU_Config=() +763:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=b5a1e5c47a0597ee9c9d0c0aca9909c596cbe71ebb069254460c2e97acfc1c0c_Device=CPU_Config=() +762:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f19b9ae15030aed3c709b020b9539e197d260ee35c50d6f9b807201e939cc758_Device=CPU_Config=() +762:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9e2233439aaed8d4d48bfa36955feddb30531b843b5ed4a9c2acac5a8d815c69_Device=CPU_Config=() +762:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a9b0552d84d057a656080c8e302afa30962dc02105abe7136cfd77f0433eec18_Device=CPU_Config=() +762:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d932ccb58823509e768be954dc85ef1162d9456db17138d650a2a883e31b99ed_Device=CPU_Config=() +761:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ed872c2ef0d35af97e7f9be84d83eee6d42f2fb279b71f4feaa1aecefb450a28_Device=CPU_Config=() +761:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d7fa761d51467b3295cda1fbd4a9865c3f1d1e3d5b8d7a091a66c70c9bcf5b4f_Device=CPU_Config=() +760:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=730427f186dab4c4268e164d10b32a50afb588c1100af2de2c3293454e7c71fa_Device=CPU_Config=() +760:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b227737b26850463ce87153061b94dcd71131aa06e3032b7f775a64e1c271f93_Device=CPU_Config=() +759:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=49b05f6b6a636d84beca451fdc1fc81e3411a100ea105fbcd49ef72ef1fa0934_Device=CPU_Config=() +759:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=453c1f5bb6c2e9c81a04475c49696c6e9e94f77853ef961e1839b541de7c7e21_Device=CPU_Config=() +759:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=02203788eb4b05d20c5873aa7be8b317797503693eee6748e4130ff7ce72ddaf_Device=CPU_Config=() +758:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9033954b258cdfa9fa858317ee4588b8c92cc946d7eb305bf130d3ca8ee0f1fe_Device=CPU_Config=() +757:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=49401e607e42aa23290f59c3d3d64d54eeff9afcdf99177506283d43b6a43928_Device=CPU_Config=() +757:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=225aaa01462e6e43c0c12cff65f96e7d9c07d368a820ff3c1b2939fefe86d492_Device=CPU_Config=() +756:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4a8cdbce9473e7bc24866edf0f5ec0f5a95475da63cea7ef68a4fef7b9fac1c4_Device=CPU_Config=() +756:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=() +756:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=() +756:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=e7b766e89f08e80fd96ba40dac738561546ca7210c4566b727ca8cb49528c823_Device=CPU_Config=() +756:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=6e67522f2df32ac8e237fd4de148d082f3c55e6c31ace80cffeaef784dfe75a0_Device=CPU_Config=() +756:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b584676efc43f08169626742b0af9b96fda041574269fc007d97acf89eed42b3_Device=CPU_Config=() +755:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=945bd465761a4d9b013b0a5e88a3a9e041d8bd8bfa8df8044f28d71ba26f224b_Device=CPU_Config=() +755:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d43dd8a9fd4a11c5383a3ea9545967aa0e330ab33dc88a0754c84fa63641dc6_Device=CPU_Config=() +754:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d20696b7743fb5d47628ddc4be77a3627b2848014e649db977ca1028586cd3b5_Device=CPU_Config=() +754:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=621c7638006b03b7c4ca5de04ae4823584c9c348cc40eca0076b898b72247e48_Device=CPU_Config=() +754:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ee098548fe040592d091ec00999f6f9c4143ba2f8ab4975d7a7daccfc7cf2da3_Device=CPU_Config=() +754:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a9571d2008f31f55a7c6eb83a7249f5b8bc973bd05b6a845fdb56b15db7ef7fc_Device=CPU_Config=() +754:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a8f0d5db2a6af7cd4d166c066f3d987d7a25edbb3047fd26551e1b68d9c179d2_Device=CPU_Config=() +753:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d99c03088bad009d9be7f29ec5bad7e3b6c7534fe2649f9670b6f713bf017e7e_Device=CPU_Config=() +752:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d0c2f7eea6a0d6d6d9d97881c8db3649f9e9b713633c9d5698459eb1d2e28345_Device=CPU_Config=() +752:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=66abbc2c605a0f866880bd4730865ae6b5401a1f4beb242f346bf6f2f8138eb6_Device=CPU_Config=() +752:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=6daca83f4b162285c00c695825e255cbafce9cf9c9cea68b969a301105475303_Device=CPU_Config=() +751:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=5bfbbb826bcb2c9e7b5364fcc5da23e737953150029c2ea7455ad4b09caaf01d_Device=CPU_Config=() +751:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43f7d483e462a7714f4607ca0e71b7e7ce0210d3e90c9e6346bba3cb0b25f2ad_Device=CPU_Config=() +749:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=67c29ca00af28406993de63d8e7782945a32705d95d4e6e4fd36fbf4e468a7f0_Device=CPU_Config=() +749:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=05c2f891e743416ad510bf0ebf713738bd41258123cc4bbdc5cf067f251e35d8_Device=CPU_Config=() +747:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bee0968c080b9f9f930b23a2c79d957f1c160c34d994e617ea29a641b0e269c7_Device=CPU_Config=() +747:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=59d58e41f9b928f4ea5563a09f847b2d2a5b709267e3a0c03ac91305e0c2b0cd_Device=CPU_Config=() +747:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=() +746:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=46b077d7466eecbadbb7ceba5ed90724db3d9e216d22171f5dee02e44b9a5377_Device=CPU_Config=() +746:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d43dd8a9fd4a11c5383a3ea9545967aa0e330ab33dc88a0754c84fa63641dc6_Device=CPU_Config=() +744:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3b743fa55fcb61cd34046e3e97d71a05de0f8db98d3abcff4e14426d143771cb_Device=CPU_Config=() +744:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=6ac457e9181610da9eb4bf0bec6cd53bf3078e0b84df1211f49921207d81c6e9_Device=CPU_Config=() +743:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=76539d5ef8e5f423a8cab413fed102f918a53f68d19bc3c054d01e8a18e41841_Device=CPU_Config=() +743:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=2f8c5775d77906707d4d8dfc991f73e4a780d87571fe695725e131e833049370_Device=CPU_Config=() +743:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a59a3375ee8c7a9958b6d66c5d199df2a05bb1815063f149a063c09f6b288e9a_Device=CPU_Config=() +743:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=9337e101d74f6d35bf81e9be895ffba9e972cdab9d79b2802f1c1ec0f4d34a83_Device=CPU_Config=() +742:conformance_BatchNormInference/ReadIRTest.Inference/Op=BatchNormInference.5_Type=f32_Shape=static_IR=8f1629e9b003409304f12c3e315e8ae8246b3bc80208c3f612d5c5c179082a7b_Device=CPU_Config=() +741:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c5c5d09465cec7f1477d5e02f3f1c4cf593c71aa090532c4e43451fedde7c2c5_Device=CPU_Config=() +741:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9b6b036dbdc251b786d53d5f0aca9c57b72afeece113f9b2d8935020ed697166_Device=CPU_Config=() +740:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=74310de2f35ad8a1bf7388138114655c2c74f1e85fb8cde4584f3d7905345140_Device=CPU_Config=() +739:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=08c583b490b8cbd43eddefc35f87cb6a11fa07284d5003b6fe43f66255c380c1_Device=CPU_Config=() +739:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4080ead6d9ec06ff8d7629bdd5eb303e82d35b5cbe53fb11d1a49b671d3e37b4_Device=CPU_Config=() +738:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=df303191a733f2e33492260b5a1c6aea1db7c5d0063f1516f49de923a176a64e_Device=CPU_Config=() +737:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2d88673274bc292b6ff26da9257cdc11b66e89c1f94d38e25ba6e8e74e647533_Device=CPU_Config=() +736:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=510b36fcb991c73abd98b488eff26715dde08a322b7b9429cd897dce6976dab9_Device=CPU_Config=() +735:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0fdf62ef06a0a9225c0746379b89495e737a2e5f95077bb92600ce14f19fed40_Device=CPU_Config=() +735:conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i32_Shape=static_IR=8d3863956a8a6a5067c45d40ae0207b14b9f1736bdf2a5b8c01979fbc012a5e9_Device=CPU_Config=() +733:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8d88e8ad02fb6c2acd45c736689a1de8d5a54f6a2ac5b6618d5fd9b4110874a1_Device=CPU_Config=() +733:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7d3a099a5040e70c73014df347c478d0976123d68b6fcab6bf767f90bbdf8e6a_Device=CPU_Config=() +733:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6b86bf4f834b297dcb461acb5854aeb9783a381521ea1a8e1cf4fbeb60d6d09b_Device=CPU_Config=() +733:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=94365490bb772d689007e25754e20090137a936cbe1a6a3739b573c644f3f318_Device=CPU_Config=() +733:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=78a5e7f340d63660dc0710d0e390dea2d3f68ac98f16e8dbc11b4c28ac0440e0_Device=CPU_Config=() +732:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d4b1dbc565a45f6c9f60cd4a73bb15c0f9e05baadfd3acdcd5e133d782c54cbb_Device=CPU_Config=() +732:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=23f7f775455e615175f3122ce422ee96de019ca40fe603b5a4605d51f28210b1_Device=CPU_Config=() +732:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c531648f3b5841ad892debb2fa2eab6ef35a08d0cd5e9d33bc0a7b442a1fc707_Device=CPU_Config=() +731:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ce4296dacb13a0d940afd8bd71b9ae0289d446455f3482af3667d22ee70e91d8_Device=CPU_Config=() +731:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6df4880ea064693f638735c7c7818014dcbad51d6d148f6a13477ab069703700_Device=CPU_Config=() +730:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=997a090766babacae10464bab19af5db238eb28704c6d463cfcba48767a90c8b_Device=CPU_Config=() +729:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=bb5cb4e2a8cb9be32332ed3255c99de478d8d2e31cfb1747aa322df438ebaa49_Device=CPU_Config=() +727:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=() +727:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=() +726:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=315fa20f952b6c7678cc93dbfd340097847826fea7928eabcec46d7ccacdb224_Device=CPU_Config=() +725:conformance_NonZero/ReadIRTest.ImportExport/Op=NonZero.3_Type=i64_Shape=dynamic_IR=7d0265450b8fc92464273ac05d685952ea3877be45b4d745959f2f373fef1431_Device=CPU_Config=() +723:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=03c30e9e1651c6554fe73bc933149c65271a948db07a6d5062b5e8d55ef0437b_Device=CPU_Config=() +721:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5b2d8d57f3d0914e21b47b7e450d2543ce7b7eee6c3eb3bff7da441b15e20d77_Device=CPU_Config=() +719:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9fbc81d8fdfc1359ee050d6931424547e2786637bb616a9703ab84291933a863_Device=CPU_Config=() +719:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=27dd1a325584acb3e37f6e30b23289b679ab9cfb28c4aaa1999b6ffb2ddae41d_Device=CPU_Config=() +718:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a93352138c144fd004303788d08066d279e5363345d3da2cf16ceb61336d58b9_Device=CPU_Config=() +718:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a8621125339b6631e3531d8e34fd54da8bad6a93020ae127b8da46f72e07bf3a_Device=CPU_Config=() +718:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=29d8ef1a41f51b6fed0300f97d17a3795a97e4ffb3ef3abda37f790f5f53b389_Device=CPU_Config=() +717:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=656a9ec09853506a1b2cebaeb2f64a14880cd860acda34dd13ed3d3433d69971_Device=CPU_Config=() +717:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=43da553b4ed22d425e5b43a911992715161b9d57d481149f00551c7f47e3c048_Device=CPU_Config=() +716:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=dynamic_IR=fb6a053d244fc1bdea6fd5e69e0c05025272ac0da2f676e077c598239b6493c2_Device=CPU_Config=() +716:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=4520f02da2bc674bf781c84ea3cca92375a1eeaa77f4f4f7e4cfc3ef75fb2964_Device=CPU_Config=() +715:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=776ce5493890837f137a7abc7851ff04164468d7c13ef1022f73f1f68e058c1c_Device=CPU_Config=() +715:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=48a273073ced3efa39d01e5ce40c30b2901e8a3dff0b414911282b8fdfc0b09f_Device=CPU_Config=() +715:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0b4b74693c2ec96e714901b1acc772655accc3b29170cdb64ae934003338b296_Device=CPU_Config=() +714:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=13e9472dcdeb5e6ce2928191ed13dde08b6cdd62c82c94e77469d8a3ed94e39b_Device=CPU_Config=() +713:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=45959eb5eb391b2bc86455cb1e86aca76799c6b082437e72b15c171037a6206d_Device=CPU_Config=() +713:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c1ffd0690c9370725a30028d2915ec798aff173f86a1864f3dc92a4defefef85_Device=CPU_Config=() +712:conformance_Greater/ReadIRTest.QueryModel/Op=Greater.1_Type=boolean_Shape=static_IR=dce38966c13ac9886c7480261e3483d822355a9bf3835d00795e7627744a60d7_Device=CPU_Config=() +710:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a5247d95c2671970ffbf4c367bbae5fe76245fd6e0db79c9c4fb9b7659dbd4f0_Device=CPU_Config=() +710:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=969cc6013dda0bdba994bcc071d5b24e2cbb5621539ca38140bc9ccc55f471ba_Device=CPU_Config=() +709:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b1bae9ab001e5c3b05f22881494508bed2f623801431b8402e6146e54d692016_Device=CPU_Config=() +709:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=49245e23b8c1c485428d0e490a687e48c541bfb833eb7838efd8c112736a076d_Device=CPU_Config=() +709:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=2f842d4b64513c6df5748c54a1166a3f14436dc1ca59b7a28530bcafcdcde2f6_Device=CPU_Config=() +709:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=25ae6295f4d206fa9069e20bc659dbd87c20aaa15c3f149ab25d003641c738c5_Device=CPU_Config=() +709:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=053d601716750db93af5ae01d67213086ed987370f9ff59723824dcd0a6c2462_Device=CPU_Config=() +708:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d42498673c5356368f655e549ed67f3f43db8730ba9449670054622d361326f5_Device=CPU_Config=() +708:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=358a9002c54b7e671e8c11c8e6deb11c8463b81846d305e47c75eb3c63bb5b21_Device=CPU_Config=() +707:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8a0e61f6a4798574ca428449e75e3f3cda5bd116975466cff3733cbde1a2408a_Device=CPU_Config=() +707:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=643e31750b57de573073bcda3bb324ecb87332a72f1c89af378213de24f5241d_Device=CPU_Config=() +707:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7a5b4de9e365b548d2bfc06db9bc63ec0dc941689701f984326d837bf152347c_Device=CPU_Config=() +706:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b0df2409ae133826dfaa59aa1b4612b6667f034acd2fbfb466b486b67c46df29_Device=CPU_Config=() +705:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2e1857ca8967deccb2baea1810c6931a1b19fc0e963dfaf3ca3ca4fb4e433657_Device=CPU_Config=() +705:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=94365490bb772d689007e25754e20090137a936cbe1a6a3739b573c644f3f318_Device=CPU_Config=() +705:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=7b9883414482f3b1108e549a9c47bb8a8aa162d962813c7e99411d000e02690e_Device=CPU_Config=() +703:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c533b2b13f88a1c6296bcb6831a96fdd4d354c69848e02bf3e9a1e632264524c_Device=CPU_Config=() +703:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=65a5483c793396983edaf7f2cc2c13898507525bd84a8469e97b2d662b5df782_Device=CPU_Config=() +702:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=() +701:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=93dee798d72e36c04cf60499e95f84cd6b63d84226d7dd1dc0edcf0875cf301f_Device=CPU_Config=() +700:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=05e9fdd5183bd179e5ef996ebcdc53f239900ca46a8122ee8bb1e885c2c091ce_Device=CPU_Config=() +700:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=() +699:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1820314f222425dcf215be41b7ebee2a1f04535529a9207527de12ae7ab35a58_Device=CPU_Config=() +698:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=63923bfd18e06b6a4a5f5f975b049eb9a46c9beee83a1759bd99d72483130af6_Device=CPU_Config=() +697:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9ce6a2f4787ef120c486a68cc02bacb95d6cb1c4cdb5e2054275cde409a39803_Device=CPU_Config=() +697:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=67396728229ab01facbaa211eeb0a7213b6a9e32d99709bd6320863fc63d1c4f_Device=CPU_Config=() +697:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3cc6ca8cdfe79957271093055b5e010a76313d2b59db6a6ca9696cda526d0cd3_Device=CPU_Config=() +696:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=6faa91bd8e7037c9233825cde9313cfd2afafa21ff423a00544eaa36d734332e_Device=CPU_Config=() +695:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ed4daec3f69dd307e284f0c8d5c5115144bfb76e8f550f7eb49f3e3da6bb1be8_Device=CPU_Config=() +693:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=6838901bafb44e26f73134e2c0eb2be8f1f777ab794ae340d61b62d891ff3d59_Device=CPU_Config=() +692:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=i64_Shape=static_IR=056c07f9ad8e27e01b269b5136ee29b4cb4d1229a009cda07e4fd32c45d4e97f_Device=CPU_Config=() +691:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f37f03c3986aa22dcb304445093d34bdadbc67de22cb9c42ec1d6a03f0386d0a_Device=CPU_Config=() +691:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=424814fbe4a3ba7a49c506f11509c035212fbdf4ef44fb2bc708c5f201e4e1ec_Device=CPU_Config=() +690:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=1409169e395a3eb90f9235b74f2f8c94e0e27a63fae33cda153d991ae1cbb68d_Device=CPU_Config=() +689:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b4dea8581ef6ba0546774e88cef10aeb80f847b8d227fb0d3981baae1c44c2b8_Device=CPU_Config=() +689:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=2f7925a034999529ce07a5c8bed2b2c7aeeb7936f74730d9c8ca5a5086dea4cd_Device=CPU_Config=() +688:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=() +688:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=dynamic_IR=8b79cf070ed44bdefd5afbe86a81199e189fa486c42190795419dbfc7cc26d6b_Device=CPU_Config=() +687:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a9b0552d84d057a656080c8e302afa30962dc02105abe7136cfd77f0433eec18_Device=CPU_Config=() +686:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=edb315ef0796a043a072730952495a3c1a4e080553efbbef8cde28d14d79ead3_Device=CPU_Config=() +686:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4a7d98292fd2c8c98ef8f5a0996abf170591dd1d15fb17229c0005b0a30cce4f_Device=CPU_Config=() +686:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f18fa21106120cecd81f50d635b1c42cbd641877ffbf78e746ef7375ff546d7d_Device=CPU_Config=() +686:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=453c1f5bb6c2e9c81a04475c49696c6e9e94f77853ef961e1839b541de7c7e21_Device=CPU_Config=() +685:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5b9fd9b0043cef8aac8d0cc2e517a3e245eada8fedb7409911cd2867e7ba85ce_Device=CPU_Config=() +685:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=a5dc3f8dd6385eb7f6d4052af82e27b7af7e8a58bdcb6092ec79ea3087f141c6_Device=CPU_Config=() +684:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c1852c534b8b95bf1a9aa2771decf2368fa095c5f5688d38ab9ce0bd86152a19_Device=CPU_Config=() +681:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c9f0deaa217fa8ad54eb9662bb6d181f7b578008b5c8ff445db32b60ec61b185_Device=CPU_Config=() +681:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=() +681:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=95bbf8a23b19badbde31e9ae7f016aa436d50d797f59bd736e220030f645bd9b_Device=CPU_Config=() +681:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2631bf7f735ccaa382c2ea452c247f8cb4cc1a0a363362256d971d661841d637_Device=CPU_Config=() +681:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d242e8ecc8ae0239fc2e7773fe0f8a1d50792a71ae4aaac4fd439174e87e95b1_Device=CPU_Config=() +681:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=8411c0432159fb60adefa760384515552240bc6220800a736556d7461765eb60_Device=CPU_Config=() +680:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=682ef97686247c6443214e731915927e131f40c22f1cae7f25a038b70eff95ba_Device=CPU_Config=() +680:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=i32_Shape=static_IR=201b881bba09ed67334d9489a1a8971e483120bd1cc75a1aa1c9f015f760e002_Device=CPU_Config=() +679:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f9c575f17138032804a74bbc18e420d0084e6e09c89b13de1f4f73d145887313_Device=CPU_Config=() +679:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ab537310012dac035760906bcdd57eecbe645735b70c27eb4ac4c220b37a3147_Device=CPU_Config=() +679:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e5092af5c0f683044b1df5a45f211f4a692436d1112181a5d613bbf335941684_Device=CPU_Config=() +679:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5bb5076aa4e905f00c38eeae688e2624d5a57f8ac7b6ee873943361985e63343_Device=CPU_Config=() +679:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=cd5756749d3d73dc7b666f7f41dc292c73230e5d31ddbbd43aae77210b86220a_Device=CPU_Config=() +677:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=8919e05ab2b0d545cabc2e2732828fa693c8f364e9d4d03faf7097f787d4f628_Device=CPU_Config=() +676:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=02f589480d24784ece323ba30be856c7cc718151d3588f683ef4825a407749ac_Device=CPU_Config=() +675:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4a483d870c0607c1102f09322af7a7ca052532a9f6fcf698a66d282c0ea2f278_Device=CPU_Config=() +674:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9b32e763670e7a29b1ed95659051b94c323b70948e5706a00db44200cd27bad0_Device=CPU_Config=() +673:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7304a384051e1414ef335109147d0dbcc385650751a174440bc9712f89036372_Device=CPU_Config=() +673:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=8ef34b5ce0dd0100a8efad53b3b71e87f76ed69496cb6f030e76478d7daddf69_Device=CPU_Config=() +672:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a24f79f450b9e5ddba709c6df05f77362e7f3ba6dfba01eaed77564700f46958_Device=CPU_Config=() +671:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c97ae95062233f4085689c2f5dfcbd9077c16fdb1bd304e3817b76004d85b00d_Device=CPU_Config=() +671:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8584e2e87ecb2b209221a133f2e3761834562a7b74e7cebe203759f3bd5d40ec_Device=CPU_Config=() +671:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a8705f91d4bf4fe876dfb6d2ac2eb9c89808c88942d4beb080e1e2c089d77040_Device=CPU_Config=() +671:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=dynamic_IR=33e67497d576ce6af4a214d55862646d034effd328ef5beed8d7b0f380b6b689_Device=CPU_Config=() +670:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c21dacbc3d52b5171ebbdb769ee8869a2ea44f1af241b861d0adb92ecf5028cd_Device=CPU_Config=() +669:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=471485ec09e972e7745979a8e3bdee0033b9a2615467df9fad360a82176d4d43_Device=CPU_Config=() +669:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=a3d8e1343e43c666358304b530278c73bc7c52a0d7fff38977154b6f7c456731_Device=CPU_Config=() +668:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=704412b992d55bf9ff00d823458e5d3b3a369e47b3eca3429fed94b87c8da554_Device=CPU_Config=() +668:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=34069e6a539019d1d06ed15853842399d30a3c7931488d2e03dbbc9eb4c189fc_Device=CPU_Config=() +667:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7a0968eb49e54c601398168e34cb61a84c9795b06e60d49f21b96b5d462838f9_Device=CPU_Config=() +667:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=i64_Shape=static_IR=75c36f65570966e7f975e5c839036e0e13fe30e6d24ce4be8e6a0e8449173951_Device=CPU_Config=() +667:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=8e098b9c129ab30efc257d55cfbc737d990d2ff0f7931039d3335c42d5f286eb_Device=CPU_Config=() +667:conformance_Gelu/ReadIRTest.QueryModel/Op=Gelu.7_Type=f32_Shape=static_IR=4ee688aa25b818f6e6986c7070e544d0eef9ce888124d85c0e5e126802213a46_Device=CPU_Config=() +667:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c0413244803edff103b95dbbcab27b2c714740372ba215264371a9474355a8c4_Device=CPU_Config=() +666:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9e2233439aaed8d4d48bfa36955feddb30531b843b5ed4a9c2acac5a8d815c69_Device=CPU_Config=() +665:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5816a52b5b342411646884cb88eb68a96df7ef3c3cac57c9057da46be4f5d8eb_Device=CPU_Config=() +662:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e1aca62d840d626a9f0b30aa19a251616a698bfec39e4ae679e50345edfdd4e8_Device=CPU_Config=() +662:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6587874c50811a2ca7e27f84cb4381e9a06eb4465e940ea877c76dfaeba02753_Device=CPU_Config=() +662:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=b5a1e5c47a0597ee9c9d0c0aca9909c596cbe71ebb069254460c2e97acfc1c0c_Device=CPU_Config=() +661:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=b005a58abf8192face35451602a847d378849223e4d433924581d28ef8141303_Device=CPU_Config=() +661:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=6b69e46c11a2a82ac7ad6697cd768d88da6e870e75f489779bbd1714bad23450_Device=CPU_Config=() +660:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b83a85737c23e279f8878f6795581dc2b003c55e4eb8baadfbfd73fb0e98758f_Device=CPU_Config=() +659:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=2686f1990d367d705eb27e252bf4185704c592225e83c62e5681d3300e9ded18_Device=CPU_Config=() +659:conformance_ReduceMin/ReadIRTest.Inference/Op=ReduceMin.1_Type=i32_Shape=static_IR=a2b9f0b4c044e23f536d137b6e157d1357df657d1af119cb8f71294d7dc098cd_Device=CPU_Config=() +659:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=() +658:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6a3f3c1b6e3617139da7a30c725db5dcd70c692ac7eff64c5fa074c2ca0e6f9e_Device=CPU_Config=() +658:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=87f3815fd73265960ef5910a3b03580b13e96d02784e159a0bf0ebc30bc911d5_Device=CPU_Config=() +658:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=03ebf297344daffba82d04292a767fcd7c959f56788ede32ff0d7c5af06ea504_Device=CPU_Config=() +658:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=b92112b2ea2f233a6fb6ee512363082a49db0f85ab23f89dc29ad907e6ab408f_Device=CPU_Config=() +657:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b76160001b7c4e0963f942d74ad2114d4205c689a1715f8e0fdad75404d718d9_Device=CPU_Config=() +657:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=dbee34cd3b708559af1ceb5fcf89aac35add00fc1b9e3eda2beebb2d5b629fc1_Device=CPU_Config=() +657:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d7e3ea8c5ea46f1b0430b6a2763c85395235c0ac58652e1d269e1257f6dbf7c8_Device=CPU_Config=() +657:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=2c2cec03b3ec1da29ad4d5fbb3530ee7343a436e27be923ee1f9dd97d29731a3_Device=CPU_Config=() +656:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d8a0ff565e3467b3d0e2d6f1dd856b2ab812d675a09645b4a3b3bc8f29957453_Device=CPU_Config=() +656:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=6838901bafb44e26f73134e2c0eb2be8f1f777ab794ae340d61b62d891ff3d59_Device=CPU_Config=() +653:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=122bf99a807265c6a41a3940f305a6855ecbdef6e03540cc958e1fedaeb06488_Device=CPU_Config=() +653:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=() +653:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2386bb6412e51aa72e9426e12f9f2b2646e7074413b33fff8d95dde141ee12fc_Device=CPU_Config=() +653:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9c66c6a6d93c10149920c3e034d9a0765afbef45dab66083fd5e3d796a57e406_Device=CPU_Config=() +652:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4fb0809c5cf2945a097d18f445de6f4f5cd2c124cdb495e6f0a12e9d937e2b80_Device=CPU_Config=() +652:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=73623637f6155bde0a4735dcd904e5b491d7d459bef5f8d3f66f02f9558937a1_Device=CPU_Config=() +651:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=79e8f7fcf25912270ec9b6d16206e5f54a678fbd174a31781524e7a976e500b8_Device=CPU_Config=() +651:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=78069dcce6d7d8dcb87e840286aabf2c6fb8727525b625653096be38f0291101_Device=CPU_Config=() +651:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f6097dacc8a374d3c93eeecca54dfa436bec5a0882f38fdf192b63b49988b7cb_Device=CPU_Config=() +650:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7f30f8f46d999a18110b8f8f9235b3534249be45e55f1aacb419126ed1eb5851_Device=CPU_Config=() +650:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=c70693ee2f825a40f3e1fc8dd2ce9355690bc33ff27030f674d082a0cb343cc9_Device=CPU_Config=() +649:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=9d26a7c321db2d87b29b93baeca20dd25357e7777261ea6a4cbf968a203969ea_Device=CPU_Config=() +648:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=04db488d856ff6cf4f04ad155967df95830796ad733e589f42c3862224acd874_Device=CPU_Config=() +647:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=c1c38223834d99f4481cb74db2bc302710629de5807b4f08381fd01655b9d44a_Device=CPU_Config=() +647:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e22e40a4f300567612f963b17707be4de09093cb9a248aed62af594e7986f7dc_Device=CPU_Config=() +647:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=dd366f3f5b63fbfce3d9378cf0d8bfa4a909a973bc3e5e97eaa9d346c5cbf1d4_Device=CPU_Config=() +647:conformance/OpImplCheckTest.checkPluginImplementation/Function=MulticlassNms_opset9_Device=CPU_Config=() +646:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=53192c27f09bf3c756e64820ae6b0a01c5e48535df5d5b91ef6dbd6d954eb6dc_Device=CPU_Config=() +645:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6624c22e3b5d72c4e8d21df59af6f3759fa4d8fa68f2b5f3f92a98d6a943d0b4_Device=CPU_Config=() +645:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0bb9a29f02d37ba32dc29b4284f58e10ce59571799f58381d449c77655c795d6_Device=CPU_Config=() +644:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b5d0b3117c15997ddf3779525e849ba35c0096ad654c8e27fd1e87e29cbd61dd_Device=CPU_Config=() +644:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fa2eea1b545d6b876282ed0165fb935f0af249c713e3f20fd97cc06118e615eb_Device=CPU_Config=() +644:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=d435aa8d2d045d69b2d187147f90c879205f27346ac991765ba97bd47d4fe0f6_Device=CPU_Config=() +643:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a0b3d7813e380f287a758c35e56e8e8edbb72b8c64fab6194a8890dacd5e2f16_Device=CPU_Config=() +643:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a74540730c27b2cb9437e4ba730bfb555be123f25f1709f2863d50cdaaa21c7f_Device=CPU_Config=() +641:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c5c5d09465cec7f1477d5e02f3f1c4cf593c71aa090532c4e43451fedde7c2c5_Device=CPU_Config=() +641:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=6d7cce19ff10d7690177fe1e3200d872ef5d8827b7ff49e6c9994e597a15dab2_Device=CPU_Config=() +641:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=3fec5c6f9e39d8a15d58c5800a889e1660adb375cb7660af1526cd31e69f7cdc_Device=CPU_Config=() +640:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=453c1f5bb6c2e9c81a04475c49696c6e9e94f77853ef961e1839b541de7c7e21_Device=CPU_Config=() +640:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2ef3273b8c144dedd6cc2d2b8c2d2921d999fa286b10d90aa796fa188dc52cef_Device=CPU_Config=() +640:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceL1_opset4_Device=CPU_Config=() +639:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=ee49657e646466b0c22aff01740a48c1cc271a828a8c3e10a21d75b04f511cb1_Device=CPU_Config=() +639:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=d38ac6654882078aafe169f6d1280279fa81e646529f6f2bd621338a756046a0_Device=CPU_Config=() +638:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=628975e7be92df698e381e47cb5e28f3f09bfc1d19c7d0e434e538743e50f53b_Device=CPU_Config=() +638:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1396dd3cb903e42ed4ef83843ffa16a65203a07192ac9ba8160fdf02ed26632f_Device=CPU_Config=() +638:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=b2dd13c363e41fef66b0dcc3e21e77b9a97e413c1c89f8c8a53179b05f01c2cd_Device=CPU_Config=() +637:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2ab325e62a5a8c5f36571bce678481798f4a5f0a854c92db5e834ea4737077c2_Device=CPU_Config=() +636:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d3e089f773288c135f90d5e2e1d4a667e3c9d1ef6a121e65206dafec5a36740e_Device=CPU_Config=() +636:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=78b35bf08a9f69a1b07d5d6ce728839e08f51739c60583cb094e4abfd6fab1e3_Device=CPU_Config=() +636:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=a7f6c704686f1b0e6fd4ab522930aa3fb5b4cd4683b204aa31e5c73b427e7058_Device=CPU_Config=() +635:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c87c002bc627f4adfa58547da4c2b1f270e07e9961a1b4ae99dda72d88980550_Device=CPU_Config=() +635:conformance/OpImplCheckTest.checkPluginImplementation/Function=RNNSequence_opset5_Device=CPU_Config=() +634:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=49b05f6b6a636d84beca451fdc1fc81e3411a100ea105fbcd49ef72ef1fa0934_Device=CPU_Config=() +633:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=72c58b462f61521af4eab9c890e568b5676c7a3194c4e35f8e04f98596013c47_Device=CPU_Config=() +633:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2386bb6412e51aa72e9426e12f9f2b2646e7074413b33fff8d95dde141ee12fc_Device=CPU_Config=() +633:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=d661093ec9006177e5d47e7f666d7c98353f9c3d5290ba6284145f60822f2573_Device=CPU_Config=() +633:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=2e70eb484f4bac4cd11e9f643d2531cd0e78994af07c015183edf9d62a709d47_Device=CPU_Config=() +632:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=821241f6ca4c3888fcc2043919fa03466266962cfc35369cb9bca51f5ee61b01_Device=CPU_Config=() +632:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=6faa91bd8e7037c9233825cde9313cfd2afafa21ff423a00544eaa36d734332e_Device=CPU_Config=() +632:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=3907faf4268b3626cbe1ace65bee013eb8a06a2e1ca045bcf12d774117625c84_Device=CPU_Config=() +631:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=739517c4c613063fc5ef734443f0a599400dec31cd5a56686735f3165b2dc2d0_Device=CPU_Config=() +631:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=284de068bb05428358d75ba098c74615e828fd9223970fdea43d02fa028419fa_Device=CPU_Config=() +630:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3464734e2c2dccab82635831d42ab5bfbc954764434eb48f4ad92b46ec26dc46_Device=CPU_Config=() +630:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=81973bc511c12f7470f620b3484f6f7c82077975f916e080091dcd4757268b17_Device=CPU_Config=() +629:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=af74e05cf6032c57a3ecd980402b9694581a8823946e3f1c76716692a7747d4a_Device=CPU_Config=() +628:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=234277ecce31161bea52cf4aa2a37aa8cd43f1bbeed281a79a6aa1d07368872c_Device=CPU_Config=() +628:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=99866ef63c9a2e7e2d9b7f00d11a4c177775bef9cfdf074e83f56318c143e6a3_Device=CPU_Config=() +626:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=5038017e90f931327d5159938d422b2afc229aa4d776a4ac80a946724fee357d_Device=CPU_Config=() +625:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b65d46a8038b26d7ec9a5691744a9324aecf33bd3e89152e5f5c067ee4a56606_Device=CPU_Config=() +625:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9d667416103520d22b2328feb82905999d9d34664283e3bc754131126f9dea8a_Device=CPU_Config=() +625:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d3ad2d022373c585166c8c4f9897c5bdb655f1b5560f2fb1f1506f7cfdf375e3_Device=CPU_Config=() +624:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=446eb2e8b2bc5f4e6c1da3e9c4b0492fe73408e4749ac3947e39c18b54bd13e5_Device=CPU_Config=() +624:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=029a0a8ba891497790c27ffa1ea50c63536a0c81fc40e06e3ff07e419a8701c6_Device=CPU_Config=() +624:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=269ec3789c76e21789e01e31f13f0f1a4895905b3f131e710e663ed2a0d8f632_Device=CPU_Config=() +624:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=5e7e2adae49fae3a376e9a5a971513a9b23b5fe4008ce51814e0fa1fd91f1f22_Device=CPU_Config=() +622:conformance_BatchToSpace/ReadIRTest.Inference/Op=BatchToSpace.2_Type=f32_Shape=static_IR=f118f5911730937f9dab91ad5eb6f78cb1af6de7bae1dc745dab2d4f02257fff_Device=CPU_Config=() +620:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=b9581fac6848b0c6c9fc9af5fd17eca3f2f64832fb7205f97684f1cc4c1985f0_Device=CPU_Config=() +619:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=c8ec200fa8fd8ec9c185d9d45ee1380be5e0e4a6f3157e5900401e9fce999553_Device=CPU_Config=() +618:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=b8e37f2c8e2574b3f3554578b72e9df771c290c1bb47238fc4de9754c6e6f126_Device=CPU_Config=() +617:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=db7378dd474a32c06b89e9b046aaae3caaaa2972d5d6bbe60e70668e0c937388_Device=CPU_Config=() +617:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=3d24c272ca88d4ee24f437a310abc05340e110f8596beb6a1ef96dd18818ebbe_Device=CPU_Config=() +617:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=4e2e2e9dd89aad4bc14634b85c94336a7250dbb8ff61cb451c9507753f54a102_Device=CPU_Config=() +617:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=6b2c79edda9cc9cce61c98552d6a0d3a3555c9ccac3a56c6692f536a0abdb61e_Device=CPU_Config=() +616:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=4e2e2e9dd89aad4bc14634b85c94336a7250dbb8ff61cb451c9507753f54a102_Device=CPU_Config=() +616:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=static_IR=7aacf3576c3d114915bc3aa48c8ee4ac9e94bc00928709d86461877a8d2d84fa_Device=CPU_Config=() +615:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b391194df168bbb18b31fc1546168c2693ad3387d562e44a102467833fd992a3_Device=CPU_Config=() +615:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=8411c0432159fb60adefa760384515552240bc6220800a736556d7461765eb60_Device=CPU_Config=() +615:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=4ccf5cecf790d27400fb95526a993f8a1a28cd4f3120b897cf45bbe78f087ab2_Device=CPU_Config=() +615:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=b99ba096eea2f3725fa98eabc2a941fa895c0a58bcd7a8ea68d2a245ce913113_Device=CPU_Config=() +614:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9360fbacf32f2208bd7f241535752ccaf434551d16bd8fd46d0422cd1cafc3c6_Device=CPU_Config=() +614:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=57d49137431cc7fe4364cc2fef13111fb9f7a5a908b2d7b6f5663100ba5d636c_Device=CPU_Config=() +614:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=d294c71f3796d2e2b88f819f6512ed03942eab440681a5bc5b092e5a34192107_Device=CPU_Config=() +613:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6a16663e3760c233a39f49948fbc5e2b41658e0e9fbb86e8a5d0cc16dfac33bb_Device=CPU_Config=() +613:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=172f158b0f845ffe5adc879bc825ab5f9d904bef2150cd9cfcb663e090fbc828_Device=CPU_Config=() +613:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=851aa3cf931a01e0188758055b866fd14280bc344f548da6166e4a57ca7c9254_Device=CPU_Config=() +613:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=577ff3f9c8d226d1899056073c0223ae2d81dcc940c5fef8b9ce9cf63931e9e2_Device=CPU_Config=() +613:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=681b1f284fb69c16681d3efd2081d7f812496e3a027baef35a75bb0aeb9c003b_Device=CPU_Config=() +611:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=99fbf009fb26eae6bfc372a5b3d9bef89d6f82e5fa45c62cc5ece995bcc71079_Device=CPU_Config=() +611:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=() +611:conformance/OpImplCheckTest.checkPluginImplementation/Function=I420toRGB_opset8_Device=CPU_Config=() +610:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=() +610:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=78525afb2b8be0393b6e50e63464ba4487417fc3634641b055f4878f340fe594_Device=CPU_Config=() +610:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=c0c33bc628fffda062b4f013c7d41d0f9080f14f41e084ac547099384a9b3d20_Device=CPU_Config=() +609:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b299e012ad30cf620f5c9ba0c33c79a406d0e39f84cb9d1efdc4b4c8dd82f347_Device=CPU_Config=() +609:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=75bf24e3b7a4c4374c5c92331d9e48423d734d35b5cafb951222e39ea4c29613_Device=CPU_Config=() +609:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e8a26a33d6dbe0bb560820295fb6b8aafc3da0d2b78e29199d2f09e952722efe_Device=CPU_Config=() +609:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=dabed23c3f30d92c6fcca7a6845160022837de8cbfa1077c222e6f1224b745e1_Device=CPU_Config=() +609:conformance/OpImplCheckTest.checkPluginImplementation/Function=FakeConvert_opset13_Device=CPU_Config=() +608:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=e4388b1379e224ea4849e6052827ef17b490cab3718159195ea2b2986719bb4a_Device=CPU_Config=() +608:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=b005a58abf8192face35451602a847d378849223e4d433924581d28ef8141303_Device=CPU_Config=() +607:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=024107902d4ca8a36f9b9c3e5c99bb04e0cf481b5e81fcae35513b9ce76ef751_Device=CPU_Config=() +606:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4746fb4d92aab20d21eeb0885d35c88abd50aa250298473f5bd143658eef2316_Device=CPU_Config=() +606:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=74139581d469ae7aae17953be58de64b2c8b887b3b7dcf492edb748773a1788b_Device=CPU_Config=() +605:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a3cc82aecdd732c09bc7a321192c2332367048da54243515649dbf72ad7a4986_Device=CPU_Config=() +605:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=59f5de8e6de60b1336848dfcf1878ee5ee5bc8771ff1b93f39c31abfa3685e4b_Device=CPU_Config=() +605:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=e4388b1379e224ea4849e6052827ef17b490cab3718159195ea2b2986719bb4a_Device=CPU_Config=() +603:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bba92f0e1fe2ee647564aec64223ab2c5b32d3defae9bad5daa5a24df76aac48_Device=CPU_Config=() +603:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=35212486e2fb4ea5f9dc1ed7d7ce580e941006a7e2f67ac4e6c4c4ffb3f514f0_Device=CPU_Config=() +603:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=99b432aa5821136994e06b4e3c690a4e298bc5a496740ea2c5fe6aa300edacf8_Device=CPU_Config=() +603:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=bd3ed1b35506cb92c8e587acb102c70abbe02bdaa75f76e5792d48d8e1f2f33f_Device=CPU_Config=() +603:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=4d14510ef37733d7ca3d69697626c173feb05638f5036c49b060f6a80aea9ada_Device=CPU_Config=() +602:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9b3e0ee4798456a9c4e3702faa07c17887739405c56f00425ddd05cfc8ab2a11_Device=CPU_Config=() +602:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=25ae6295f4d206fa9069e20bc659dbd87c20aaa15c3f149ab25d003641c738c5_Device=CPU_Config=() +602:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6d96cbf402de4085be87bac94f42f06f28049e17188cb3467dc8010e8e99f698_Device=CPU_Config=() +602:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=56fa4af7b32a139a903744478ab84858b98dbcd173f4c0f3da01d4ca547e1dd2_Device=CPU_Config=() +602:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=417040fb77f62e577234ea0b8c1ef58ee0583e1a3c643af1da5c61838c2ff1bc_Device=CPU_Config=() +602:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=4a64918e1c0c648268ad4a1c2147889b2578b4513693737ec2ea1c7ff81dbc52_Device=CPU_Config=() +601:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b75101615777d246b4d0939e52b257bd293f2e4745ed4a9b307a0d2b3e1852c1_Device=CPU_Config=() +600:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f9f264e1e7e84711ec78c28ac19f0c120290cd8cae589996ff10d4096d35f592_Device=CPU_Config=() +600:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a0f8789f0f95beb6f28efc829bdf2f99d34a3e9397ad1a80d7831aaaf125b5eb_Device=CPU_Config=() +600:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0182ad6b02d77803accd2ebe55d87b679950570d1dcfef2940adcbb5fb9f1a24_Device=CPU_Config=() +600:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d4f7d35516f95fa128d0cc3d63ab95c2dba96c29977a88a6573d5e90c3b89271_Device=CPU_Config=() +600:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=b93daedfdba7331025c12a5eb4b881bd7df445d80bd4fac34833087fe6d65bf5_Device=CPU_Config=() +600:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseRightShift_opset15_Device=CPU_Config=() +599:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9f8fca1ab855d5a71d7acabdefda202e270bf16b559fd581f9e663caa301ffd7_Device=CPU_Config=() +599:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9ebb1862a5e0db4eff08d84e9e56c76c19cdc07e13e634f008ce5e9d709afe35_Device=CPU_Config=() +599:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=52f24d64817b922e55c19c85c0d727ec6fdb9cb104f55697330334d1517f0621_Device=CPU_Config=() +598:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=64efb6dd46c36bec02b92148d178bc032417c8c2d999ff7b0a24ba08af365f91_Device=CPU_Config=() +598:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1891282a9bf460336bad3c354519aa0d87ba6ef40876d4a07592194d2d678e25_Device=CPU_Config=() +598:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=41bcf70f8013164bdfeb7e348c05e6d43d9a1afc49087c49745679bc3aaf1e10_Device=CPU_Config=() +597:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=dfb16811d2a3986853d6e5ac937c96cc89e47e20bd3eb443142699dd62ba2890_Device=CPU_Config=() +597:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=79738eda1d37027e5fe69a728ba8112851351b5994db7e537f38a6f7f109329e_Device=CPU_Config=() +597:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=d435aa8d2d045d69b2d187147f90c879205f27346ac991765ba97bd47d4fe0f6_Device=CPU_Config=() +597:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=bd99ad9e1d756435cca9c6309caf45043f34c6c3c844f60e17deb8dfef4234f4_Device=CPU_Config=() +596:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c1f0b881be142016d55c77178631a9861407f9c3f889e58c64924e84c039252e_Device=CPU_Config=() +596:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=() +596:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=18788c5143cb21969863f3984fb8c5c9bb4dbb0a1869f5c8988b52ce779ff465_Device=CPU_Config=() +596:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=8337ad383956ad96ca95f4aeb967e05c694fe586b4ed6e46547e3ffa0217c59b_Device=CPU_Config=() +595:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=cc8a9d50447be96c4d4738ddd5cdd88356f9e6e73ff8cf3fd90c4a24ebfe153c_Device=CPU_Config=() +595:conformance_CTCGreedyDecoderSeqLen/ReadIRTest.Inference/Op=CTCGreedyDecoderSeqLen.6_Type=i64_Shape=static_IR=117fa486a51d9715d9ba1ad90cb5d6741e762cb36ea55a91129f1947b4886649_Device=CPU_Config=() +594:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2076165a2a28f14ff923bf8c44250bc59536d2ffb67b4a4785f480df49c1a243_Device=CPU_Config=() +594:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5176d95c14be776a4247f25a469708ba7976378b7aa8860a115a28a8bf2c2902_Device=CPU_Config=() +594:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2e586703f4f8e9285249881d509a2a0b96d4758be5f97d75e7ee4f78951c58e9_Device=CPU_Config=() +594:conformance/OpImplCheckTest.checkPluginImplementation/Function=MVN_opset2_Device=CPU_Config=() +593:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=75bf24e3b7a4c4374c5c92331d9e48423d734d35b5cafb951222e39ea4c29613_Device=CPU_Config=() +593:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=93ce70e605eb712479090e3a266e86eb7422bf0fdd3acb1c38a0b92a9c381e2c_Device=CPU_Config=() +593:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=6e614b9877c6dd3bf1ebd731443e5a1e0b7492edbc3a4683adcff53c965ca1bb_Device=CPU_Config=() +593:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=922e194a5ae53e76be5ae624754d3c1fe5ea0d8c564410062bd9c30afc48ffe0_Device=CPU_Config=() +593:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=c0c1a43608279d8870258be63005b38e23fe5501876c87840cc16a0bb2cf8dfe_Device=CPU_Config=() +592:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3eb4c7774dc1ab314492cbf1475d0c47d4138ac05336b249ab5e8588eb7bb143_Device=CPU_Config=() +592:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b78ffc69401084763d529e2aee12f9b9793bc92be3eca3df2a97730b9a252ce3_Device=CPU_Config=() +592:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=4a64918e1c0c648268ad4a1c2147889b2578b4513693737ec2ea1c7ff81dbc52_Device=CPU_Config=() +592:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=a0336bba08291ea34d6271c83816fb349d163fc5989171b07fe1bce50a2f3ea9_Device=CPU_Config=() +592:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=489201dc4d1a937b4387f1b7d01f75fa42ff02d7035d39ac6a7f56536b0d3a20_Device=CPU_Config=() +592:conformance/OpImplCheckTest.checkPluginImplementation/Function=TopK_opset11_Device=CPU_Config=() +591:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a93ade5d0390a07d7f8a6ee0c7099a40b3ba3df0b28a9d72cba7006e4d0191fc_Device=CPU_Config=() +591:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a50644dc2d133df429ff4aa6a19ca9bafbf41d2948522e584fc5f417ad16d76c_Device=CPU_Config=() +591:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=315fa20f952b6c7678cc93dbfd340097847826fea7928eabcec46d7ccacdb224_Device=CPU_Config=() +591:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=() +590:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4104a7840dc96c214be896cac75911b70baebb902a42a26f12b281bc2cd87318_Device=CPU_Config=() +590:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=14b4e3996d76ae6417a36fef160b520b771b4fa1beca9e271c649f69a59403e4_Device=CPU_Config=() +590:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a3d6337c1ea3e8b67256696ea4231da4fc0e9d9f8bea169607a1287233086b3f_Device=CPU_Config=() +590:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=00d8728cd472d05b1eebf4b4d0ffa4a5d7c7dd34b3a99055b0f8ff5b0173af53_Device=CPU_Config=() +589:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=() +589:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=30680a7972de02e47d59c768730b8a64a06b011dc8b5be4fd25f190662cf1c1d_Device=CPU_Config=() +587:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d492c7eaf897986b3d961ba687b4ddf8cdfcfd946dbece9cad3e75c7a65d2ef5_Device=CPU_Config=() +587:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7d706b614d2b5d59c5e152bbb61a8fd558686bb3b8e9fda199c499ca49f03042_Device=CPU_Config=() +587:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=3effc90c24c0eb76bbc89809d34c6541654366a02e21378a668dd932a6cc7756_Device=CPU_Config=() +587:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=71d1d8ec03d4807da4ac2fe5647ff2bb8d1547c070d82a9421216fa9d39166fb_Device=CPU_Config=() +587:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=1988b645a87be14c17740085aa8c4a38e88cd2111f0ba294f77ed0bf856b0561_Device=CPU_Config=() +586:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1b0fd4a9f8f0e48f90969f08b37568a86ed12126d15ed17492cf1f241c5a90a4_Device=CPU_Config=() +586:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3209c1cce78c7b856203c0a5676f6fad4d098a3146c7305ee3c0471b3be2e3d5_Device=CPU_Config=() +586:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=1f29402ea664e850ea05d5f2e500f087a6165f1f4c9b3e5102b5509c020f0f6d_Device=CPU_Config=() +586:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=d435aa8d2d045d69b2d187147f90c879205f27346ac991765ba97bd47d4fe0f6_Device=CPU_Config=() +585:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=597a8a56fae623dd0684f6e4040ffd6ce90166e43e47adbcbcedf1dc5136ec23_Device=CPU_Config=() +585:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bc2b8069a8ae60098e1f1a1fc54f8ca873fb1a5d261acf47ae12ad6ea4bb34d5_Device=CPU_Config=() +585:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=d442b2d9df68f25f567a3e8da8d87866c200d391624cf1c339554a57a9a527a4_Device=CPU_Config=() +584:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=50e01efd1d927b71763f678e29a16ae688a5b0f10ed9cee12f1e7692924d5318_Device=CPU_Config=() +584:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=50a0e83d438a3220ed14dd8ae783e92c96381f645b10719669054ea944297244_Device=CPU_Config=() +584:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=33013e27c35451969b0c3c8493a34fb5c81527a7480bb12d793a2d597d712602_Device=CPU_Config=() +584:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=922699707423c4110bf8a551eaf7dc3689fd3673fff79cca21442cda90c22dda_Device=CPU_Config=() +583:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=aebf91fbdf6124d046e8016cfe5d5a5a967f7c4130642e9dc4b812ad067ecbf8_Device=CPU_Config=() +583:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8dcce54a5f8ee92f5cb0f376b6baa4513e2f5bc0b6b7487ca85bf6f8c2a02c3a_Device=CPU_Config=() +583:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=d46d4fc3e7b3b2cea07f7ba710f77f7d99b4799e7fb0d3127ea6862f3f731ae9_Device=CPU_Config=() +583:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=4d14510ef37733d7ca3d69697626c173feb05638f5036c49b060f6a80aea9ada_Device=CPU_Config=() +582:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a5d03dc78d3b89cf1aaee33c609a3d52626d3b98827b980422b01eefc32cde03_Device=CPU_Config=() +582:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=586094b4ff6617c08c87a53c7be1ca26aae40657c8d964d81eda731dbb27e848_Device=CPU_Config=() +581:conformance/OpImplCheckTest.checkPluginImplementation/Function=MulticlassNms_opset8_Device=CPU_Config=() +580:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=885f5721f6c3a7f1335325c7638a8934b00b9ac9d0eedd9e9ccdf25514bf0b2c_Device=CPU_Config=() +580:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=674e2446a2f5929d12d36f14451d68e7b55ad61d2d8df755e85c27c4a52943e3_Device=CPU_Config=() +580:conformance/OpImplCheckTest.checkPluginImplementation/Function=Mod_opset1_Device=CPU_Config=() +579:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=39b885728130b88ac11ea98537acb5a081ec3a27e12092f3bfd8776dae1da93c_Device=CPU_Config=() +579:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=be4d557c62a3a43e7f309d2276cd7549bf1976ca8593bf2be752e60c42237a19_Device=CPU_Config=() +579:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=a937747c04b70351d3632aab91189200e2c0a69b6467ed856b7075885c54d83a_Device=CPU_Config=() +578:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=73d32deb47a4954f7502d431a3346e456cf3d93c6217c9ab8c5fc630cc4e3669_Device=CPU_Config=() +578:conformance/OpImplCheckTest.checkPluginImplementation/Function=IsInf_opset10_Device=CPU_Config=() +577:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=554e762f2b3a5d9d335e464c65b1c240a9e92e4f765ac8734c438cb698883c8d_Device=CPU_Config=() +577:conformance_CTCGreedyDecoderSeqLen/ReadIRTest.QueryModel/Op=CTCGreedyDecoderSeqLen.6_Type=i64_Shape=static_IR=117fa486a51d9715d9ba1ad90cb5d6741e762cb36ea55a91129f1947b4886649_Device=CPU_Config=() +577:conformance_Abs/ReadIRTest.ImportExport/Op=Abs.1_Type=f32_Shape=static_IR=5713be8dd761def00c701c74d0aa913d259206eff1103b9fa6de0f6f1a25e566_Device=CPU_Config=() +577:conformance/OpImplCheckTest.checkPluginImplementation/Function=TensorIterator_opset1_Device=CPU_Config=() +576:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=07b257862a62290d7e8ae939147bb7422992528bf54209b8d1bff500b99b6f4b_Device=CPU_Config=() +576:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=769e7bb56fd0d0fa75fed14765279f68841e300b1450909cdcc802d347446b52_Device=CPU_Config=() +576:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterElementsUpdate_opset3_Device=CPU_Config=() +575:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8710c3eaa10d25119059f4e15970d8a6381f978cd905fc8eb1b4d43a36d1d5f6_Device=CPU_Config=() +575:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=41ea59b807081adea7869609c65776a42f88079ec22180807905d5c2e8ca0777_Device=CPU_Config=() +575:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c1146723a7ea4ccf82c8d62c0665aea78976fbda8e1e0bb40c962b95069e8e7e_Device=CPU_Config=() +575:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=234277ecce31161bea52cf4aa2a37aa8cd43f1bbeed281a79a6aa1d07368872c_Device=CPU_Config=() +575:conformance/OpImplCheckTest.checkPluginImplementation/Function=Mish_opset4_Device=CPU_Config=() +575:conformance/OpImplCheckTest.checkPluginImplementation/Function=DeformableConvolution_opset8_Device=CPU_Config=() +574:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=456012168725798035877b2cd860bbb89121fa41add6f7ab78c03247032077fe_Device=CPU_Config=() +574:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=06a1a9e9cd13f69334ecb05bddbdc5d186b85e138c5597d2e85222c4b735980b_Device=CPU_Config=() +574:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2e586703f4f8e9285249881d509a2a0b96d4758be5f97d75e7ee4f78951c58e9_Device=CPU_Config=() +574:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=ca0d551f3da549b28475d996906bfa5202402be286f59f9bf53ac809c9fceb49_Device=CPU_Config=() +574:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=9b915f1788d3d4768839d2cefe4fbba2f8b2d8aa4c22f9ad574335c22d0db1a2_Device=CPU_Config=() +574:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=3fec5c6f9e39d8a15d58c5800a889e1660adb375cb7660af1526cd31e69f7cdc_Device=CPU_Config=() +573:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=8b8121ebbd51ee995f98531f595145a01ba70ce026ad0bee588733c33e70272d_Device=CPU_Config=() +573:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=c808434d1d2cbd9ea66373f22c7e635c5bb2e3a6294f93421d1d9d34ac62515d_Device=CPU_Config=() +573:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=00b85178c2e7f891c89e99a6692b94a56ab0882f4a30167997e104db1429a9c9_Device=CPU_Config=() +572:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c161ff64d4c506fdbe44d0ee76042f958f5dfce778833653628a026de01a3f9f_Device=CPU_Config=() +572:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=dynamic_IR=6a0218ea2e7eb0329e4915f2f6a7c215742d2469e868a4a8e43c683c2dddc01d_Device=CPU_Config=() +571:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=899cf50d8feefa9c5e02f6fe88b79e66b59c4a53478755d51b3e82570683613b_Device=CPU_Config=() +570:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a7d9ffa60c8d1f330ec303edf6a6c0f8d8e0fe8657c561431bfb91a94c2639e8_Device=CPU_Config=() +570:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5176d95c14be776a4247f25a469708ba7976378b7aa8860a115a28a8bf2c2902_Device=CPU_Config=() +570:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3a3886301663fd20cf2c8c0f74c11d80dfe8b74ac39e41652f0eac1ec9bfa2df_Device=CPU_Config=() +570:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=c56cf3dc39ed0072f3e5a8cadd1502fef904b32de3b7760ee4c6964c0e505ac9_Device=CPU_Config=() +570:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=bd3ed1b35506cb92c8e587acb102c70abbe02bdaa75f76e5792d48d8e1f2f33f_Device=CPU_Config=() +570:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=1e95665a92aa6efcc7e06d24fbe4cb2afa07d75374cea3ea928658a270ef489b_Device=CPU_Config=() +570:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=6b69e46c11a2a82ac7ad6697cd768d88da6e870e75f489779bbd1714bad23450_Device=CPU_Config=() +570:conformance/OpImplCheckTest.checkPluginImplementation/Function=Cos_opset1_Device=CPU_Config=() +569:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=() +569:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b38f11a07d752c83a5e4fc709d5b78fe9a40ef3394f4b617a30df29c21640338_Device=CPU_Config=() +569:conformance_BatchToSpace/ReadIRTest.ImportExport/Op=BatchToSpace.2_Type=f32_Shape=static_IR=f118f5911730937f9dab91ad5eb6f78cb1af6de7bae1dc745dab2d4f02257fff_Device=CPU_Config=() +568:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0256d48640841a9233553afa85e34dca797e6b5eedbd772f606c1a0e6f8e91a1_Device=CPU_Config=() +567:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a83bda80fe7800f61bcbba992511f20b4adb5da4097179f2188797871abb73ca_Device=CPU_Config=() +567:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=554cea5d4f8f21234b429ebe1c4365bed5b6a6a309da5d607b45b301beb90828_Device=CPU_Config=() +566:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e27f0bcb3118a7cdb488f4685707bec982ae54ff8bf7e97aff9ea6ecedd66714_Device=CPU_Config=() +566:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=593116ea16692c8f5a8994c0562c47e1c627f9088c519b752a635a7d91973085_Device=CPU_Config=() +566:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=fced0ff647e4ea9a4b1673016b017f68ed75cdc778cad156dbd6cc379bb815f9_Device=CPU_Config=() +566:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReverseSequence_opset1_Device=CPU_Config=() +565:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=622add2dcd72d2e1560e983ef4aad56fd35b48b71964ea8204137026f445d37d_Device=CPU_Config=() +565:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=30466048a7da9db59d20a210af1979341f7b9552362e64a89357d650102a213e_Device=CPU_Config=() +565:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=() +565:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=30680a7972de02e47d59c768730b8a64a06b011dc8b5be4fd25f190662cf1c1d_Device=CPU_Config=() +564:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=42f3f3a5b34aacb93147f9c77ad5709cf7436ae8cad9318434a9b6ff6852982d_Device=CPU_Config=() +564:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=243bd2256612673dd04651521ed8d3fa4087c90af7b85e1a4aa381c074bacd47_Device=CPU_Config=() +564:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=899cf50d8feefa9c5e02f6fe88b79e66b59c4a53478755d51b3e82570683613b_Device=CPU_Config=() +564:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=6e6c053ee1974a5d036c6d549508f6d43586d501c72db05df9930639ad745bc4_Device=CPU_Config=() +564:conformance/OpImplCheckTest.checkPluginImplementation/Function=Range_opset4_Device=CPU_Config=() +564:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherND_opset5_Device=CPU_Config=() +563:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=e0422b2fb57587a85d9ce1532f7fc28a6bd01e72a325d42d9045419dda4bbba5_Device=CPU_Config=() +563:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5dd2854a965fe5894fa2a05ada313f1d7b1a1bf82873873fd1ebd3f8eb812941_Device=CPU_Config=() +563:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=4d14510ef37733d7ca3d69697626c173feb05638f5036c49b060f6a80aea9ada_Device=CPU_Config=() +563:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=6ddb35aeda2a6cb63282d2fcf6503aa02135ad60e23c752280ef82aaf6a31191_Device=CPU_Config=() +563:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=ef6e4b3910cac801199b1f6be74902b42105d23de549d426b1c4bcdd7361f79a_Device=CPU_Config=() +563:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=29eeefa6ea54ff2530e2e17153db324026e85d4e45432c053ca066699187bbc5_Device=CPU_Config=() +562:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ae2e7b59de9fc5d689cf677f1ce023fa58235c99d3efa662148d01b2bdfa0e0c_Device=CPU_Config=() +562:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=static_IR=7aacf3576c3d114915bc3aa48c8ee4ac9e94bc00928709d86461877a8d2d84fa_Device=CPU_Config=() +562:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=87523dfccb2a9c8334d6810e33c2a2d3b6bc09db7623e7ae93ba4cea89b66a06_Device=CPU_Config=() +562:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingBagPackedSum_opset3_Device=CPU_Config=() +561:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=4e2e2e9dd89aad4bc14634b85c94336a7250dbb8ff61cb451c9507753f54a102_Device=CPU_Config=() +561:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b91f26a0b7b56224c507de772631016119cd0bc3fd49527013f571e2db477402_Device=CPU_Config=() +561:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=5d68272f8318c073e481b5353e6e4350e6b3b5e120f389a98859dbd5af43db9d_Device=CPU_Config=() +560:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9e21c0af425c90066d92577a0b8aadb6e9fdee50c197b15eea040b89eb715a6a_Device=CPU_Config=() +560:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=() +560:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6964f870fd6bf44d1d5ee5925eee8892230b8928aeee1966db73b6c4fcd5acf8_Device=CPU_Config=() +560:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=3e016da7faeea7044ea204d1c3a2f1729d3d7ef0be27f5b769484bc7aebea5ab_Device=CPU_Config=() +560:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=c202ffc0e1805a36e48ee4b06d06b68a9f179eef00dc353a092a13818e8ebbe9_Device=CPU_Config=() 560:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=769e7bb56fd0d0fa75fed14765279f68841e300b1450909cdcc802d347446b52_Device=CPU_Config=() -559:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e1f0357795d5676c5e4a38b6639cc90c924880ab961eb73e407b5ad0142ac0b4_Device=CPU_Config=() -559:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6a7aa747b98a21c0469c7edf7ef78a050e1279d891b0c69ddc071befafd42c76_Device=CPU_Config=() -558:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=() -558:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=1f429cd9b96a0ae8b336e874e911d2cdb79820b76030c61de8a1c057a0c33168_Device=CPU_Config=() -558:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=() -557:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f13dcb47235a9516298088a0c45ff56fdb7f95144da257a3dfa1c618c7373ce9_Device=CPU_Config=() -557:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=75bf24e3b7a4c4374c5c92331d9e48423d734d35b5cafb951222e39ea4c29613_Device=CPU_Config=() -556:conformance_ROIPooling/ReadIRTest.Inference/Op=ROIPooling.2_Type=f32_Shape=static_IR=baa256d53878b528f6bdba95bf1837cc570dd83b577220f95d9c24cb26d37c35_Device=CPU_Config=() -556:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bba92f0e1fe2ee647564aec64223ab2c5b32d3defae9bad5daa5a24df76aac48_Device=CPU_Config=() -556:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9fbf4ccaa68a81191afe2432a2212ee1a559df380d602459ebd2d0266053d82d_Device=CPU_Config=() -556:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=d294c71f3796d2e2b88f819f6512ed03942eab440681a5bc5b092e5a34192107_Device=CPU_Config=() -555:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=1f7f2d40b938416773b13282d8ac09d81a50e4d5d7548f42fc5fd575f84e1385_Device=CPU_Config=() -555:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=0c491c1a451ad85717879e05678f7d1c85cc35d95b108087dd241b9b24b39ddc_Device=CPU_Config=() -554:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=43d871d4b2b3346c08f8582b892ba0c0017d77688e16fd6d69f83f8101e12a69_Device=CPU_Config=() -554:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=43aed1509066aa7c839a82c9865228ce3ebdfbe519061649807875ec6e86d715_Device=CPU_Config=() -553:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=4555fb7029260c7e46403e1fbc99a3815a94373b7b08d2408277976173facc37_Device=CPU_Config=() -550:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f2293320b7533e95bf000229d2458244fb9af573cd737ca0088a00674df1ac52_Device=CPU_Config=() -550:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7a3cae38e357ee1e5b0400c7e1256cc8a2d78da81911fbbb3ae6d9e510d78aac_Device=CPU_Config=() -550:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f069cbce6f4c3276869b6d9c4a6c843d7a1e1c9d299e8680218636b04339a9dc_Device=CPU_Config=() -548:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=023f3573ef77fb592345c68ee5e6a79191b120f9cb68f81194381da2cf68f21a_Device=CPU_Config=() -548:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9650ac479045f70fd763f5c95d0c27c3b3cc4d6fc00b43e8ad627d16f817f342_Device=CPU_Config=() -548:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=8f3e3716e8a1e8647454d124d7538ac1faacdc1b95873ccc1a760e09d48c30d3_Device=CPU_Config=() -548:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=315fa20f952b6c7678cc93dbfd340097847826fea7928eabcec46d7ccacdb224_Device=CPU_Config=() -547:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=f61b45eec10f28e255a0f82842384e1c947830dc5d5618bf00c6385cecbab8d5_Device=CPU_Config=() -546:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=899cf50d8feefa9c5e02f6fe88b79e66b59c4a53478755d51b3e82570683613b_Device=CPU_Config=() -545:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a917525b3e5a37fc2be5f35fd5a3d50b57627cd9b985333e082b169c29f848f3_Device=CPU_Config=() -545:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=94ad9524c175a0e0d2fe22bceeac82b0dc66006caa0942d343d551268e03afec_Device=CPU_Config=() -544:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=53108cff3836c47360380f3898c5de245a566a5d98040820d78befd46e56955b_Device=CPU_Config=() -544:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7f30f8f46d999a18110b8f8f9235b3534249be45e55f1aacb419126ed1eb5851_Device=CPU_Config=() -544:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=593116ea16692c8f5a8994c0562c47e1c627f9088c519b752a635a7d91973085_Device=CPU_Config=() -541:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f1f52703006b7d81ccadfa1c54db42d8b19ac7b8beb3ee88f2d7252170358d90_Device=CPU_Config=() -540:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=576ef0e9eaf8fefade547928d4592bc2b341ff1100c3de5104f0a63b2fbeeca0_Device=CPU_Config=() -540:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=43e58b152a871421132d25894025e9f4e2b5294f4b22923ca549bb0f2b8ab50d_Device=CPU_Config=() -540:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=508a961c358d40ddb6906694a24f87dc24f74cb4643aab58ee1d6fa28f099e6b_Device=CPU_Config=() -540:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1e56a3e2379d29d81af93174e56ef91408af41dfc085d4851ff58dbec781b8fa_Device=CPU_Config=() -540:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=83cdc5670c74aa0db5a1c14e70c45552cdba1c9e1f4d55c83398ce51abf80393_Device=CPU_Config=() -540:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=243bd2256612673dd04651521ed8d3fa4087c90af7b85e1a4aa381c074bacd47_Device=CPU_Config=() -539:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f1ffa9874732c1aa88e04fd55fbc864c9c6986877d3d52045fa6ae7f18dba62b_Device=CPU_Config=() -539:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d9b3427efacda497c4fb86cebe89023b322722167d0c32de8a2602a80b23580b_Device=CPU_Config=() -537:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8c3b386463bd59945d3c15512b26409dee7da9b1940f153e3ff62d47d6f79d2d_Device=CPU_Config=() -536:conformance_ReduceProd/ReadIRTest.Inference/Op=ReduceProd.1_Type=i32_Shape=static_IR=e34207bf06e51dbf322bc0db76f3a9828ae018b02dba2b1826ed97004bee8125_Device=CPU_Config=() -536:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=dd366f3f5b63fbfce3d9378cf0d8bfa4a909a973bc3e5e97eaa9d346c5cbf1d4_Device=CPU_Config=() -536:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=b99ba096eea2f3725fa98eabc2a941fa895c0a58bcd7a8ea68d2a245ce913113_Device=CPU_Config=() -535:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=952a43f4c368721e0c69418b71fe89982ef1eb2be0671653cb1200e34cb4bda3_Device=CPU_Config=() -535:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i64_Shape=static_IR=def60f5f3fb7a0d22cb3d23253e7c8e502aa9dd2d3756c54dd4343b66c2682ca_Device=CPU_Config=() -535:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8596cca11141e34e75c884b1be9a75be19663caf4c0b1b4275f6035a73d62e_Device=CPU_Config=() -535:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=651e5fbc222577151cf14e9c8e9bdf9e155f1e0d277206887160d65b532caf53_Device=CPU_Config=() -535:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0f61e4837d11be2b01f69947cd0b424a45d2e548d9c70ae53b07c43fa1237cd0_Device=CPU_Config=() -534:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=180e9c4ce23626df8010b5b79a28ecc4c6c75b65dea91938fa99025a65411239_Device=CPU_Config=() -534:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=() -534:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0bc2bfc4481de7733f5503750d21376d00de6bfa699ecff3ee0c4333d9515db8_Device=CPU_Config=() -533:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=fd10c1c5d33aef77d3428fb5c9789f3c2c2463ab9f6cb51184ad37951578320a_Device=CPU_Config=() -533:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=f645a2275ff33ad614c801a8f2f262ce1ca95417e0ca59e28d4b87cf3289c00b_Device=CPU_Config=() -533:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=81973bc511c12f7470f620b3484f6f7c82077975f916e080091dcd4757268b17_Device=CPU_Config=() -532:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8710c3eaa10d25119059f4e15970d8a6381f978cd905fc8eb1b4d43a36d1d5f6_Device=CPU_Config=() -532:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0d40552a1b6c1945765ada16284a0c03f5c1454fb12f226a34dee8a07b14f17f_Device=CPU_Config=() -532:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=59c0e972ae75900cd8c802aa7be9b6c13c96cb10417ff417eb1aafbc49b891ea_Device=CPU_Config=() -532:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=cccecd6fd3e8f3d84fb98f219b212cd2b55ae0e4e34c099a25a1028e9e2f83e7_Device=CPU_Config=() -531:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e77468c2881ce0c38c14038151d560ccadc7dcbd5eb5f21b68b8e227c89813a7_Device=CPU_Config=() -531:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a52a8e6ef7bbeacbc1435cde72a1a70bdb8a3abf78b5b971c2ecb1135cb4c136_Device=CPU_Config=() -530:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3500be960a489d618c1ff6345c1d6788d17c43786c10a7e7b630586920bce356_Device=CPU_Config=() -530:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6903ceb67d029d79d90687340dee0204830d5df1f1ea6fbb09f14a6eca234739_Device=CPU_Config=() -530:conformance_LogSoftmax/ReadIRTest.ImportExport/Op=LogSoftmax.5_Type=f32_Shape=static_IR=38bcc7d745ee21a7c6858a161e269f0281d3f41d62d65d10fde9b0a9b80992c4_Device=CPU_Config=() -529:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=34784838e98e93a6b024109ef3a8a5d4e1fc7f89b98ca23c81cf085f19acc663_Device=CPU_Config=() -529:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=30eb0edc699f72085fb77a6cc31ad4aa9e62cf97befb64273493d234494fc64c_Device=CPU_Config=() -529:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=f6f85e9282e58756d40411508d6edaacc75c0f4e64d4e25021ade07ba17bd8ce_Device=CPU_Config=() -529:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6b87ee29001d1d3b17ec72a66638e954796b7d6ec1d6f6be86890c7d5a3bcceb_Device=CPU_Config=() -528:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8484c5c087ca8317588ef676a0cafb63ded379be5bad862e4d0504f43bc6fb45_Device=CPU_Config=() -528:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=19d36388bdf9535fef89243d6dfce670fc91377062ed4b3095ea55b88e4f296a_Device=CPU_Config=() -528:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=df62dbfb022ab001a9df6b16311f57e744e8674fa8751b4e3a7ffee872fecc20_Device=CPU_Config=() -527:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=e4388b1379e224ea4849e6052827ef17b490cab3718159195ea2b2986719bb4a_Device=CPU_Config=() -526:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=fad6766f10f7a0ffee665be437521766f5dd56b673293920d8b469bdcef8e7f8_Device=CPU_Config=() -526:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=46a3135a1078cd8732e84754fa66872648997791d16caa379a179e1a90960608_Device=CPU_Config=() -525:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9403397dde8b4f6a240bdc928d0f080dfb42f6442f281d6b3fe8b6e348ccacfd_Device=CPU_Config=() -525:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c219261f655fdb1bcfbcc367ca8f6c4bdf0dc1fbeb7413343a3f0bdd74a70857_Device=CPU_Config=() -525:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=() -525:conformance_HSwish/ReadIRTest.Inference/Op=HSwish.4_Type=f32_Shape=static_IR=1c38a17a13c5c03cfc1eeb147ca2474debea05ae1d6f2357ce40ce23552286fa_Device=CPU_Config=() -524:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e0f4f91a6470af49c5e2497ae8fa917051879c18dd1e39cae18d159b697e8fec_Device=CPU_Config=() -524:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b63e04695c1e6145a3fa9835130a4919df52ff3a420d3c800bddff65af7dd76e_Device=CPU_Config=() -524:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=b5a1e5c47a0597ee9c9d0c0aca9909c596cbe71ebb069254460c2e97acfc1c0c_Device=CPU_Config=() -524:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=0c491c1a451ad85717879e05678f7d1c85cc35d95b108087dd241b9b24b39ddc_Device=CPU_Config=() -524:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=() -523:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c14aca93b401d9d2325a5396c1489e1fa29aaa57f592cd2b4e6792ba5af90a90_Device=CPU_Config=() -523:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0e9ccd2a8aded784ff21758802648777721176f1d112ff60aaf3f150d6292156_Device=CPU_Config=() -522:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=06069a23d29d9bb6910729ac49ce1466e4fc6185c6ca31fa54fe7dd3289c41f7_Device=CPU_Config=() -522:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=f5d3b4ec51e032e4df5dae00ecba1a3198c29cba96c72b8c89126c4638b715d3_Device=CPU_Config=() -521:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c90b6f528b750f144ddd29be0059c202d46b3bac799c0d70893f2f4f9f05f64c_Device=CPU_Config=() -521:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=2c2cec03b3ec1da29ad4d5fbb3530ee7343a436e27be923ee1f9dd97d29731a3_Device=CPU_Config=() -520:conformance_ReduceProd/ReadIRTest.ImportExport/Op=ReduceProd.1_Type=i64_Shape=static_IR=7dba7222be56b8fcef943fc63ab00cfb3c7e0fb4467aeac96fd43aa4421cba86_Device=CPU_Config=() -520:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f13ce39b60cc25991465a0c02e27edcb35af0523cd28004adf6fd9acd8a5fcb8_Device=CPU_Config=() -520:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=adabeb9321a0770cb065345aca787cbf7d1adef68132cc5c7d8df885ea64ab2c_Device=CPU_Config=() -519:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=64551d094520cf00d40fe514f573f5f37f61416bd456474f4b0a21788c4ffd3a_Device=CPU_Config=() -519:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=2f7925a034999529ce07a5c8bed2b2c7aeeb7936f74730d9c8ca5a5086dea4cd_Device=CPU_Config=() -517:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bf235091db192c86756347e70771b4b00a6ac2c8852b93079749ba718d57d022_Device=CPU_Config=() -517:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0fe2c94f8e2ed43edc0deb92ffe044a089c6920f886dcf6985ee910e7a4ffaed_Device=CPU_Config=() -517:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=b93daedfdba7331025c12a5eb4b881bd7df445d80bd4fac34833087fe6d65bf5_Device=CPU_Config=() -516:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e05af92d21ebd869cf6e9554a4aa0bfc60c8b0c64baebee798f0be5a0a01019e_Device=CPU_Config=() -515:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9730f247ba4a13fb03274850f295de500156107d33db957188846fe49c2f4566_Device=CPU_Config=() -515:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=95ea118f8053f6bd18c8f34bbc475c00921bab5dc3af177492829d5cba16aa39_Device=CPU_Config=() -515:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5adf6fcb72c0d6086a95fbbc5744e7d02dfb32490e0f42c62b57bc98489b801c_Device=CPU_Config=() -514:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3dcf824c36c868d06d715e3fe24587c31eb7cad18ae9f9e044c7f6abfd261651_Device=CPU_Config=() -514:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=() -514:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2bb16e2257294e3f7d905f66a483a8210f392ea822836e4edcf8910a7fbb4277_Device=CPU_Config=() -514:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=04db488d856ff6cf4f04ad155967df95830796ad733e589f42c3862224acd874_Device=CPU_Config=() -514:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=dynamic_IR=1af860b153ea667f413c7de4c98752d48ed8ac1fc7f90889009a2916e2ab1026_Device=CPU_Config=() -513:conformance_If/ReadIRTest.ImportExport/Op=If.8_Type=f32_Shape=static_IR=If-8_707_Device=CPU_Config=() -513:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e15d2825807b2c7fda150b7b7b4e2c6914fab2d4af4313e959abaff56dffe6d2_Device=CPU_Config=() -513:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=f8662769a2f3a5fb20582ccbb1931b7e3fa73ec7713eca30362b0e7c0baf829a_Device=CPU_Config=() -513:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=2ce56cfc77884dfc61f7e9fab9a0ce04a4b016f9b3d13465cde1576b9374a2a6_Device=CPU_Config=() -512:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d99c03088bad009d9be7f29ec5bad7e3b6c7534fe2649f9670b6f713bf017e7e_Device=CPU_Config=() -512:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2d38082f8971dd7614234070dc9cb8c9b6b12fee7dc918503f0e256ab32d2fef_Device=CPU_Config=() -510:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f8a096633b64512b865ea5e4a57529cbf621afedcb873285bd5e24cdb199a46_Device=CPU_Config=() -510:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=346617ba1990b67ca1fec8ec219645b16aafa6c94a4a0f752c2f3633b85df679_Device=CPU_Config=() -509:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=32537f045cce3d13cb28dd292a0ebe06e13002877d9ed2e5b25d3ebdf5afcb58_Device=CPU_Config=() -508:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=af1f864a9f4bc94bdb713b0fed3f4c39dbd290cf7464f3cee8f1aded11981d4d_Device=CPU_Config=() -508:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=69c87ccfa0080f65ed28b9a088343db5ceef524ae917b8e259b1865a017df22f_Device=CPU_Config=() -507:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9bae5a53011ecba6327961e6496f3312134c81e148523434968c3c56b5e0c491_Device=CPU_Config=() -507:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d8fc538fc2b9ca150eb22763e4c7416c002b5c7fa6481314201540178e940a78_Device=CPU_Config=() -507:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=b0e3e542180f521cfd4651ae18d3a58962751d3c6de9265240be6d4fe9745bf0_Device=CPU_Config=() -507:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=83cdc5670c74aa0db5a1c14e70c45552cdba1c9e1f4d55c83398ce51abf80393_Device=CPU_Config=() -507:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=718d6ff3b19f498cf4edeb9f7f4a7528fef578dd6fc7edb0796d476505472e46_Device=CPU_Config=() -506:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=bc1a7618e707ddd2c4773d1a2234e6dfb39954ad872abdf38a18d653ec35b26f_Device=CPU_Config=() -505:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=eb33c5485ec10ae4f1268ab19db6a4ef86812d4c92680b43791274bb055e2220_Device=CPU_Config=() -505:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=2606bb36cbc87d845c9f678ac84e47c0893f0b86a3b675e70018d1e535234875_Device=CPU_Config=() -505:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5953b8e79f64e33e67dd330999ff8e3d8391c8f3fa7eae519b117b1273c8c19f_Device=CPU_Config=() -504:conformance_ReduceProd/ReadIRTest.Inference/Op=ReduceProd.1_Type=i64_Shape=static_IR=7dba7222be56b8fcef943fc63ab00cfb3c7e0fb4467aeac96fd43aa4421cba86_Device=CPU_Config=() -504:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=81c2956d325aab4a7bfd931d94151e1285083a15326e0890f861b97017a24bb9_Device=CPU_Config=() -504:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2bdfd42ec67d330dec8ea2817499b4c2d32a3d91deccede902acba057b050c49_Device=CPU_Config=() -504:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=4a64918e1c0c648268ad4a1c2147889b2578b4513693737ec2ea1c7ff81dbc52_Device=CPU_Config=() -503:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9ce6a2f4787ef120c486a68cc02bacb95d6cb1c4cdb5e2054275cde409a39803_Device=CPU_Config=() -503:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9c66c6a6d93c10149920c3e034d9a0765afbef45dab66083fd5e3d796a57e406_Device=CPU_Config=() -503:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=8c3b386463bd59945d3c15512b26409dee7da9b1940f153e3ff62d47d6f79d2d_Device=CPU_Config=() -503:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5176d95c14be776a4247f25a469708ba7976378b7aa8860a115a28a8bf2c2902_Device=CPU_Config=() -502:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e6aa73efa73e8b557d46457037aea3d6ba037b67ac1b52437354c2823abf2be8_Device=CPU_Config=() -502:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=01d609bdfca9f2a499a564f66ab9dd71b394310593d27b8739283b19980e2dc2_Device=CPU_Config=() -502:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=ad5c5df7cea37955709ef71d9967828ce3f0011e68aa1c6085984f1422944058_Device=CPU_Config=() -502:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=11477a6d571446d4e895d1cc6b0155c36606963d5c4a3a0a516802063a60906f_Device=CPU_Config=() -502:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=8f3e3716e8a1e8647454d124d7538ac1faacdc1b95873ccc1a760e09d48c30d3_Device=CPU_Config=() -502:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=68ae288409f3972b9f52f4ea76573a81d764758059915949e76dc5f20e6952bf_Device=CPU_Config=() -501:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=a1862e486a20c8de71dd94c12a157098ac5f222ba8ba3e1d3edaf9362331e185_Device=CPU_Config=() -501:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=00d8728cd472d05b1eebf4b4d0ffa4a5d7c7dd34b3a99055b0f8ff5b0173af53_Device=CPU_Config=() -500:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e4523b73661dc593224b91713f8f20f1c87513a62e3b8ee8265e1136eb74f9ed_Device=CPU_Config=() -500:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e4be028a5a300682b79da2f015dd1c1b13381b38b19bb76951e1f26439173212_Device=CPU_Config=() -500:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7c8594e723d769f8817c58fc16146033afb91d821bc941dff944223796029f8b_Device=CPU_Config=() -500:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a9fdcbd778622e442a42d8d2a1a12a1be0cf7e9d79c4d7ad56d5802c7a84d337_Device=CPU_Config=() -500:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=boolean_Shape=static_IR=0702c04c1d16f65b7d552044e66732886a0b389702aa43f4c845e2460ddff1c4_Device=CPU_Config=() -500:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=4d14510ef37733d7ca3d69697626c173feb05638f5036c49b060f6a80aea9ada_Device=CPU_Config=() -499:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=afc2cb913bcb4e4badd203c9cdf491ea1e6ed4f1cd835e7507889a9bba25b958_Device=CPU_Config=() -499:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=6dae5ccb2325826167ff4ec57e51280b4e125801e6405a33f4d95fd9ab9f3fc5_Device=CPU_Config=() -499:conformance_BatchNormInference/ReadIRTest.Inference/Op=BatchNormInference.5_Type=f32_Shape=dynamic_IR=694ab408745deafb90f8515e002a393e790a8b1f83e58519081b983067d76967_Device=CPU_Config=() -498:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=582f7347a93cb2c9e51ade6c405ff25b23d009bdcd3d7a3c49902e627a041252_Device=CPU_Config=() -498:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=aa2c77112641e46dd617356a9cae765813b93353cd8a0f0508b915e0b03eede4_Device=CPU_Config=() -498:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fbd54c37e1db9cd3cd3fc7c571117f65c26d9f5ff0674711a326e02ebd3f9d57_Device=CPU_Config=() +560:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseOr_opset13_Device=CPU_Config=() +559:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=cbd1111f323b8e6d78b59b531708defef64b90463f973f64f52251795ac5a7dc_Device=CPU_Config=() +559:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=87a966d3d3b90cb32db3454c5dfb2f67af86b68a5e45fa1c5f4a75c3b5cb452b_Device=CPU_Config=() +559:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=45959eb5eb391b2bc86455cb1e86aca76799c6b082437e72b15c171037a6206d_Device=CPU_Config=() +559:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3837a665cc6a05b0f8981a4670a4611739b070db2f5ce97ad05cb256eed5c994_Device=CPU_Config=() +559:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=19d36388bdf9535fef89243d6dfce670fc91377062ed4b3095ea55b88e4f296a_Device=CPU_Config=() +559:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=df62dbfb022ab001a9df6b16311f57e744e8674fa8751b4e3a7ffee872fecc20_Device=CPU_Config=() +558:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=7b8eedb1c6be0db4a0c041ec3b04498d6dc68b326c35533ae16258e750f21e3f_Device=CPU_Config=() +558:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=b16650eec74ddd46ff3bffc9eedb340b6bad99a338fbe6b11f7eca3098a324d2_Device=CPU_Config=() +557:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0182ad6b02d77803accd2ebe55d87b679950570d1dcfef2940adcbb5fb9f1a24_Device=CPU_Config=() +557:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=() +557:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=34404b0d0f956acd1827f417b44bc1cf1a085d6517d5d81a6c6d38ee27c745e7_Device=CPU_Config=() +556:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8971df6b980fb10a4fcc262ef6d3616ee0b0f32841dbb8a4869eaf5848243fc0_Device=CPU_Config=() +556:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a3d6337c1ea3e8b67256696ea4231da4fc0e9d9f8bea169607a1287233086b3f_Device=CPU_Config=() +556:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0e78ae14fcef33de9637ac99e87f672b3247ea32c221a4b555b2e5bbdff88788_Device=CPU_Config=() +556:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=c7998d9fa7e16dedd52f8cbe3d0814f2f3b30ee6d728881d64c4743e0ff6fae0_Device=CPU_Config=() +556:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=6daaaff289d357ea77e7a8656dc7ce8d368771abebee6641a097def0a8170b8b_Device=CPU_Config=() +556:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=5be0b1c69be525cbddd7996b695c1a4a9f380173d03f291e8570df76c050678b_Device=CPU_Config=() +556:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=586094b4ff6617c08c87a53c7be1ca26aae40657c8d964d81eda731dbb27e848_Device=CPU_Config=() +555:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=f76da5edfb7a9e3fa7cec034fa43307bce74eeb0629176ae5dd40d154baf858f_Device=CPU_Config=() +555:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bf4d5291899ea4eccf6584f62d4ecdfb39de79edd102e509f840664838f59d19_Device=CPU_Config=() +555:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=79a28185585166e8c3a7988d1e74df784bd8078df963fd220b97d5624ad8ce76_Device=CPU_Config=() +555:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceMax_opset1_Device=CPU_Config=() +554:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=0c491c1a451ad85717879e05678f7d1c85cc35d95b108087dd241b9b24b39ddc_Device=CPU_Config=() +553:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7f30f8f46d999a18110b8f8f9235b3534249be45e55f1aacb419126ed1eb5851_Device=CPU_Config=() +553:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=355bfa53a1f9e712db4df6642a51970e96e3612583b2ec90e7a8170e45b1625c_Device=CPU_Config=() +553:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2dd63d58c85301d765882b95995de97f4eff14bbb3c933c4e4b8ee5fbc2e9e71_Device=CPU_Config=() +553:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=33199e062b7b59c8244477fd2682a08876e72126701842265efc0c9fb4a90c94_Device=CPU_Config=() +553:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=cee58d2e3f2d6ef0061c5b245a15c60f0a26a58474c015f71dbdbc0c171b2a8b_Device=CPU_Config=() +553:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=c5f54dc9ad0b693c13c07d44fe5572bd91852b0edd57f8f06314df3e71f3659b_Device=CPU_Config=() +553:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=eed21ac7c17920ba437332691e231037113367ee3d256b4db1380c8d2e0db84f_Device=CPU_Config=() +553:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset5_Device=CPU_Config=() +553:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset1_Device=CPU_Config=() +552:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=39930bd67f003081f138d781076ec2d3571ced21865a9cccc81bd9185c151b39_Device=CPU_Config=() +552:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=87f3815fd73265960ef5910a3b03580b13e96d02784e159a0bf0ebc30bc911d5_Device=CPU_Config=() +552:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9fbf4ccaa68a81191afe2432a2212ee1a559df380d602459ebd2d0266053d82d_Device=CPU_Config=() +552:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e365913541918ae265939740fd9930d4f5d919773ce47a4e896a264bd8f86460_Device=CPU_Config=() +552:conformance_Abs/ReadIRTest.QueryModel/Op=Abs.1_Type=f32_Shape=static_IR=5713be8dd761def00c701c74d0aa913d259206eff1103b9fa6de0f6f1a25e566_Device=CPU_Config=() +551:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=() +551:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=19d36388bdf9535fef89243d6dfce670fc91377062ed4b3095ea55b88e4f296a_Device=CPU_Config=() +551:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=8ef34b5ce0dd0100a8efad53b3b71e87f76ed69496cb6f030e76478d7daddf69_Device=CPU_Config=() +551:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=bd99ad9e1d756435cca9c6309caf45043f34c6c3c844f60e17deb8dfef4234f4_Device=CPU_Config=() +550:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f0af28fe49c157f5f62f72f0ab209c50aa07d97c65477217fde6e3a3d0dc98ef_Device=CPU_Config=() +550:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a76c4cc0a1f2294a3ceb18dd5d214d842cf37c08d2e34770c66c29b44ee92e48_Device=CPU_Config=() +550:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=79e0a530c5a64063a9af26b438f208476e3bbf5a267c28ddded0459019a1d8e1_Device=CPU_Config=() +550:conformance_BatchNormInference/ReadIRTest.QueryModel/Op=BatchNormInference.5_Type=f32_Shape=static_IR=8f1629e9b003409304f12c3e315e8ae8246b3bc80208c3f612d5c5c179082a7b_Device=CPU_Config=() +550:conformance_BatchNormInference/ReadIRTest.ImportExport/Op=BatchNormInference.5_Type=f32_Shape=static_IR=8f1629e9b003409304f12c3e315e8ae8246b3bc80208c3f612d5c5c179082a7b_Device=CPU_Config=() +550:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=1c0ac850b5e9b69e2e30303d623c5e0634622fc9764374217f3c892655349c12_Device=CPU_Config=() +549:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=95ea118f8053f6bd18c8f34bbc475c00921bab5dc3af177492829d5cba16aa39_Device=CPU_Config=() +549:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43f7d483e462a7714f4607ca0e71b7e7ce0210d3e90c9e6346bba3cb0b25f2ad_Device=CPU_Config=() +549:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=30466048a7da9db59d20a210af1979341f7b9552362e64a89357d650102a213e_Device=CPU_Config=() +548:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1a01e1932e9e30974342c0a6e382d829af6ca776db39be738e54a55a09732ed2_Device=CPU_Config=() +548:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=6e6c053ee1974a5d036c6d549508f6d43586d501c72db05df9930639ad745bc4_Device=CPU_Config=() +548:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i32_Shape=static_IR=a3f2389f6a8a495885efa87742d53e1e154f58f8fd6e83df89bddf5922247095_Device=CPU_Config=() +547:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=3e4364d93433ea741efe178b0c83cfb13c46259888aec468f59f77cd3f1bb39f_Device=CPU_Config=() +546:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43e52f7bd4989711336d4aa524aff731d1f968eb65e8b5e07e1a16db29e55337_Device=CPU_Config=() +546:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0fb6a7848271e000d49d4966647edf55e65f181523883089f43147c14cfb9871_Device=CPU_Config=() +546:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=486675b6412030beffb4209c326672af07d343d5e1bbca31b9bfeed3cc339e3d_Device=CPU_Config=() +546:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=f826a40d2d5d59d35300a911a15dfd8022c0fc486ecdc7f00c06a26f5dc44338_Device=CPU_Config=() +546:conformance/OpImplCheckTest.checkPluginImplementation/Function=Equal_opset1_Device=CPU_Config=() +545:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=10c7f4dedd3c5395744a95834799d05f2b2e014e2acff9ee97ed1fcf6e7100a6_Device=CPU_Config=() +545:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=85ae3a9991f339aa4cae498d33e44fd838b3e3f8e2cff7a64701b62207ccc965_Device=CPU_Config=() +545:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=176c218db11ea18f367fdf98a3de14e9a9c65152bbcc39783c38772b37f6e9c2_Device=CPU_Config=() +545:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=a815b68b6a8d36546d3ac0112c60283bd69ae1059e8deeb98b21f538c8089beb_Device=CPU_Config=() +545:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0df360e6d6391827cd65ceefd3201c263a829e50ed375522d4e8700f3879de09_Device=CPU_Config=() +545:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=785551399ba4bb8eb76271bf698b3ca795b8388338f110843d5c78c03009625d_Device=CPU_Config=() +544:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=a0336bba08291ea34d6271c83816fb349d163fc5989171b07fe1bce50a2f3ea9_Device=CPU_Config=() +544:conformance/OpImplCheckTest.checkPluginImplementation/Function=FloorMod_opset1_Device=CPU_Config=() +543:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b0df2409ae133826dfaa59aa1b4612b6667f034acd2fbfb466b486b67c46df29_Device=CPU_Config=() +543:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=54a5630072fb0e0127611a4ae63db14b7c0fa0979f4d2be7bfec548b5291a0af_Device=CPU_Config=() +543:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=c808434d1d2cbd9ea66373f22c7e635c5bb2e3a6294f93421d1d9d34ac62515d_Device=CPU_Config=() +543:conformance/OpImplCheckTest.checkPluginImplementation/Function=IsFinite_opset10_Device=CPU_Config=() +542:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=b6417017678573faaf72824d1bec40bcccd73ae0007aef24b089dc3743276b14_Device=CPU_Config=() +542:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=30dd450fadb8a1081c1315cd0e5234728862b4de39b097a5a3248d551369b60a_Device=CPU_Config=() +542:conformance/OpImplCheckTest.checkPluginImplementation/Function=SoftPlus_opset4_Device=CPU_Config=() +541:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=dynamic_IR=8c78da5f8bf9c1a4cd7f89cde9d61eb6500fa10ea0454e36a585466ed97fb12d_Device=CPU_Config=() +541:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=79a6d2a402cdd74cf1277a57ff95b71d61384da394ad2a4d9ebcf422eb5c3258_Device=CPU_Config=() +541:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=55d83e2240e88295a78084f92162888c9b0beef46ae468cd7ab93a1c0a432835_Device=CPU_Config=() +541:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gather_opset1_Device=CPU_Config=() +540:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=27504b9cb28c91668f7dafc7db47c7260b0e63c040a9dd5493daa35c8d3b6d16_Device=CPU_Config=() +540:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=45d3d98caee5b2666b6f411fa9d42c7d9655fa2baee63c43640bccd7bc472469_Device=CPU_Config=() +540:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=99fbf009fb26eae6bfc372a5b3d9bef89d6f82e5fa45c62cc5ece995bcc71079_Device=CPU_Config=() +540:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=b6417017678573faaf72824d1bec40bcccd73ae0007aef24b089dc3743276b14_Device=CPU_Config=() +540:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=7b2199d0ea56102a7c6737be2334b9717ee292c13cdb692d07fddfd173ea5b82_Device=CPU_Config=() +540:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=46a3135a1078cd8732e84754fa66872648997791d16caa379a179e1a90960608_Device=CPU_Config=() +540:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i32_Shape=static_IR=cd4d566c041357cdd7f8539933888956fff5cfd15e3c42872df59d9890c169b3_Device=CPU_Config=() +539:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=718d6ff3b19f498cf4edeb9f7f4a7528fef578dd6fc7edb0796d476505472e46_Device=CPU_Config=() +539:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2fda32f5fe8957d151306845ffd0f877b2efad70f7bd4921fab2fd770d78c2a8_Device=CPU_Config=() +538:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=b35fe21330bf6e76f55ad27b71fb0422a737d0c400255fd6cf2cdb3252d3617f_Device=CPU_Config=() +538:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=87523dfccb2a9c8334d6810e33c2a2d3b6bc09db7623e7ae93ba4cea89b66a06_Device=CPU_Config=() +538:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=6e6c053ee1974a5d036c6d549508f6d43586d501c72db05df9930639ad745bc4_Device=CPU_Config=() +538:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=29eeefa6ea54ff2530e2e17153db324026e85d4e45432c053ca066699187bbc5_Device=CPU_Config=() +537:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=58b9cf97229bd8293e747a47979c3d98261275f9da473dc942b746a06a1fa214_Device=CPU_Config=() +537:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=674e2446a2f5929d12d36f14451d68e7b55ad61d2d8df755e85c27c4a52943e3_Device=CPU_Config=() +537:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=3fbff9f870428a19ed434cdf72834eec251edc3dddd149491c94319d63a8438e_Device=CPU_Config=() +537:conformance/OpImplCheckTest.checkPluginImplementation/Function=NotEqual_opset1_Device=CPU_Config=() +536:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b9bab6ef11eb6ae637924a902a40dff310a45916d50c8f0a4ec667c8d6bde6a6_Device=CPU_Config=() +536:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=839faaa50aafa2e3ed38fc682d0759304b694043dac1a242a085e2973aac8091_Device=CPU_Config=() +536:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2bdfd42ec67d330dec8ea2817499b4c2d32a3d91deccede902acba057b050c49_Device=CPU_Config=() +536:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=1988b645a87be14c17740085aa8c4a38e88cd2111f0ba294f77ed0bf856b0561_Device=CPU_Config=() +536:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=efeea353bf41d0aac1f5400e451346d6cb407610566018f368726328cafca221_Device=CPU_Config=() +536:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=0662f4c4f222a79755532ac9eed43118b2ebd0faf0fbb9b400f9047ca1071b5f_Device=CPU_Config=() +536:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=1c63f30ce7cb977ac945ee25eb97f3c472a81b999eacbcdd4b3bfd253f25cb51_Device=CPU_Config=() +536:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=9b915f1788d3d4768839d2cefe4fbba2f8b2d8aa4c22f9ad574335c22d0db1a2_Device=CPU_Config=() +535:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=58b9cf97229bd8293e747a47979c3d98261275f9da473dc942b746a06a1fa214_Device=CPU_Config=() +535:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=() +535:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=adabeb9321a0770cb065345aca787cbf7d1adef68132cc5c7d8df885ea64ab2c_Device=CPU_Config=() +535:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=7e1801bf4ef7ad1b27663dfb399f318ccb2526e925d48e3d30e2ab837824b217_Device=CPU_Config=() +535:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=cccecd6fd3e8f3d84fb98f219b212cd2b55ae0e4e34c099a25a1028e9e2f83e7_Device=CPU_Config=() +534:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=6daaaff289d357ea77e7a8656dc7ce8d368771abebee6641a097def0a8170b8b_Device=CPU_Config=() +534:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=2ce56cfc77884dfc61f7e9fab9a0ce04a4b016f9b3d13465cde1576b9374a2a6_Device=CPU_Config=() +533:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=06c968fe2f2949b4262f4f600b728609b2c2a389fc5fb02bbe4764da6caef616_Device=CPU_Config=() +533:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=c985b086d155654f9db8470da3af5245c4fbb0139015d049b8b3b20f393c2545_Device=CPU_Config=() +533:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=1da672197f2c962a6cdfb059e9d09c10a03c3b082838f53d2faf6a761fee0637_Device=CPU_Config=() +532:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=69a9e38799e925044cfd025df20a3593240b2d1145de5eec905d30b3a1ad923a_Device=CPU_Config=() +532:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=30dd450fadb8a1081c1315cd0e5234728862b4de39b097a5a3248d551369b60a_Device=CPU_Config=() +532:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=46a3135a1078cd8732e84754fa66872648997791d16caa379a179e1a90960608_Device=CPU_Config=() +531:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=be4d557c62a3a43e7f309d2276cd7549bf1976ca8593bf2be752e60c42237a19_Device=CPU_Config=() +531:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=5b466c4e4b53a5ea739df517da47f0764f9e31197b7d30fd9dabf17d1b33a489_Device=CPU_Config=() +531:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gelu_opset7_Device=CPU_Config=() +531:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherTree_opset1_Device=CPU_Config=() +530:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a7ad8306fe632a2d0c45a492ad2d21dbe40f2f9ea55074d602beb6f8dde17982_Device=CPU_Config=() +530:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4af234310183dcbe89f887b3282ac2ef10637d5f5580e128c49958c1b5628db2_Device=CPU_Config=() +530:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=3d5c8f5c1545419050f982e8555a6ef9e5dcc06545b1a8573d710e8bc2375a6b_Device=CPU_Config=() +530:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=cc989fde083332a75d3066112105028a711bdac4fc44463d098022774da752b7_Device=CPU_Config=() +530:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=15d323a190bbeb1834cfa08a3afc633a2c203e44e2660bff4e98453c02ea4cfc_Device=CPU_Config=() +530:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=ef6e4b3910cac801199b1f6be74902b42105d23de549d426b1c4bcdd7361f79a_Device=CPU_Config=() +530:conformance/OpImplCheckTest.checkPluginImplementation/Function=ShuffleChannels_opset1_Device=CPU_Config=() +529:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=2aa586a55098e1960c204572ca9704bb3b8b9a3baab5fcf08200594261f7bef7_Device=CPU_Config=() +529:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=256f748d7b98b0eb70cc659403910bac929d62a2b153e63438f8746f602a83fa_Device=CPU_Config=() +529:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=beb6b43d96ce20db13ecf6abc53742fdc20d2221ea66af01e3c945348acf9bd4_Device=CPU_Config=() +528:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=83d90ef3fac993f7efba4a8ed369781571b1b536af03ceb0267ae979379e1dd9_Device=CPU_Config=() +528:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=277be9cd89ba817ab595481b040e3435eb08d1a79bcb05a7796110550a071201_Device=CPU_Config=() +528:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=41bcf70f8013164bdfeb7e348c05e6d43d9a1afc49087c49745679bc3aaf1e10_Device=CPU_Config=() +528:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=b8e37f2c8e2574b3f3554578b72e9df771c290c1bb47238fc4de9754c6e6f126_Device=CPU_Config=() +528:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=028177a440f430edc5dfd7a7f0f2c0dded422876a98b6da66a647ad9aca10e57_Device=CPU_Config=() +528:conformance/OpImplCheckTest.checkPluginImplementation/Function=Atanh_opset4_Device=CPU_Config=() +527:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=4ccf5cecf790d27400fb95526a993f8a1a28cd4f3120b897cf45bbe78f087ab2_Device=CPU_Config=() +527:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=bd99ad9e1d756435cca9c6309caf45043f34c6c3c844f60e17deb8dfef4234f4_Device=CPU_Config=() +527:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=2c2cec03b3ec1da29ad4d5fbb3530ee7343a436e27be923ee1f9dd97d29731a3_Device=CPU_Config=() +527:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=b92112b2ea2f233a6fb6ee512363082a49db0f85ab23f89dc29ad907e6ab408f_Device=CPU_Config=() +526:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5adf6fcb72c0d6086a95fbbc5744e7d02dfb32490e0f42c62b57bc98489b801c_Device=CPU_Config=() +526:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43aed1509066aa7c839a82c9865228ce3ebdfbe519061649807875ec6e86d715_Device=CPU_Config=() +526:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=40876e66f31053b621aea004baaba7607b9131d4fff8e8b00ed7e1e58204988c_Device=CPU_Config=() +526:conformance_BatchNormInference/ReadIRTest.QueryModel/Op=BatchNormInference.5_Type=f32_Shape=dynamic_IR=694ab408745deafb90f8515e002a393e790a8b1f83e58519081b983067d76967_Device=CPU_Config=() +526:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=3907faf4268b3626cbe1ace65bee013eb8a06a2e1ca045bcf12d774117625c84_Device=CPU_Config=() +526:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i32_Shape=static_IR=a3f2389f6a8a495885efa87742d53e1e154f58f8fd6e83df89bddf5922247095_Device=CPU_Config=() +526:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=c5f54dc9ad0b693c13c07d44fe5572bd91852b0edd57f8f06314df3e71f3659b_Device=CPU_Config=() +526:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceProd_opset1_Device=CPU_Config=() +525:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=7147d6ead151efc24a53c196b63fc441e240c34b41ad2226a535580eb2a3f3d2_Device=CPU_Config=() +524:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9c4adbd0f6e4ccc612a4906a5e3d0ed20fba39b9521a78b88c95b540ba7a1e3f_Device=CPU_Config=() +524:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1adb71d66ee918c5806737933d1c78f93ab48190df44f3cd8c928f5b0aa7d9a1_Device=CPU_Config=() +524:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0b4b74693c2ec96e714901b1acc772655accc3b29170cdb64ae934003338b296_Device=CPU_Config=() +524:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=1988b645a87be14c17740085aa8c4a38e88cd2111f0ba294f77ed0bf856b0561_Device=CPU_Config=() +523:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8b55c14423b60f30029c68c603417fb98119c5922e2827c60c99edc05ea813e1_Device=CPU_Config=() +523:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=473e9027081a81ec0a25821312bd198c9a5e750a87ef249783bcb2c53b2bcffa_Device=CPU_Config=() +523:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=6e614b9877c6dd3bf1ebd731443e5a1e0b7492edbc3a4683adcff53c965ca1bb_Device=CPU_Config=() +523:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=boolean_Shape=static_IR=0702c04c1d16f65b7d552044e66732886a0b389702aa43f4c845e2460ddff1c4_Device=CPU_Config=() +523:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=b005a58abf8192face35451602a847d378849223e4d433924581d28ef8141303_Device=CPU_Config=() +523:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=69ca2cf8f4d548a3d5a031c503acb5d830b490f0035255a175ef5698de7e5fa7_Device=CPU_Config=() +523:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=0c6a844f626f6628628034d332ccb6d520e0447e4b616048c7efb516d0fd87bb_Device=CPU_Config=() +523:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=c8bb865a43a3782b3b85e05c3e86388fac07473697ed45a7b04f60010555a3c9_Device=CPU_Config=() +523:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceLogicalAnd_opset1_Device=CPU_Config=() +523:conformance/OpImplCheckTest.checkPluginImplementation/Function=MatrixNms_opset8_Device=CPU_Config=() +522:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e365913541918ae265939740fd9930d4f5d919773ce47a4e896a264bd8f86460_Device=CPU_Config=() +522:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=1da672197f2c962a6cdfb059e9d09c10a03c3b082838f53d2faf6a761fee0637_Device=CPU_Config=() +521:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cdd7ce044f231ae39fc0f7460a55473c0de6934124cd263444a5912b8cbbc0ce_Device=CPU_Config=() +521:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=() +521:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4b00183255fde45d5c3b815b552e5a4279284bfe1ceb31389560260ad5546c14_Device=CPU_Config=() +521:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=() +521:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=4ccf5cecf790d27400fb95526a993f8a1a28cd4f3120b897cf45bbe78f087ab2_Device=CPU_Config=() +521:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0bc2bfc4481de7733f5503750d21376d00de6bfa699ecff3ee0c4333d9515db8_Device=CPU_Config=() +520:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3d39ecb890c0070ffbec20a5540c9841a075d29b83113350a2ea7a0bbc984cf1_Device=CPU_Config=() +520:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7ab51e173b82572bfb29cac5dfdc326e3689e466c68cf91590dcbdddf1f530de_Device=CPU_Config=() +520:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4bb7bd2471752f1a62dc15dbcacad87dd329443459a90dc6768b1a34fd00c064_Device=CPU_Config=() +520:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=346617ba1990b67ca1fec8ec219645b16aafa6c94a4a0f752c2f3633b85df679_Device=CPU_Config=() +520:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=bc52d884c8eb9ffc1a5c6af9467b8f285933b715def03c4e5cadf426ba186c3a_Device=CPU_Config=() +520:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=3f0c39b97aeab67748bd4039950e926a9d9f33b6d3261c4d65d048500adb5b7f_Device=CPU_Config=() +520:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=1c0ac850b5e9b69e2e30303d623c5e0634622fc9764374217f3c892655349c12_Device=CPU_Config=() +519:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3d6f722f81b8a23f0dcb2acaea3686f0aebde1d810953e532cad9930a034d050_Device=CPU_Config=() +519:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b60e16251938c61b34dece8f23651a595c8c8744df391c6ba17bc0e0417cb398_Device=CPU_Config=() +519:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7effebd346cedea6e1196e31b73459e7dc818b4cec52eec6ef54e4812b9c221e_Device=CPU_Config=() +519:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=680c8c91d6dfdb198ff304245e6da3089da20f6fc5187b80f279c5d56eb66052_Device=CPU_Config=() +519:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=61f5318f717a5e0eedebd7dbc15069fc98f70247111220da32b449508ea00abe_Device=CPU_Config=() +519:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0256d48640841a9233553afa85e34dca797e6b5eedbd772f606c1a0e6f8e91a1_Device=CPU_Config=() +519:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=0662f4c4f222a79755532ac9eed43118b2ebd0faf0fbb9b400f9047ca1071b5f_Device=CPU_Config=() +519:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=7244cd4799e0eab987f823edc7d6038b76afa7585e4663278be826124c5596ed_Device=CPU_Config=() +519:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=0add7fb1bf1500ea125aa6d245bad577d6dea18d038c020d18c2dcd56704c671_Device=CPU_Config=() +519:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=9d26a7c321db2d87b29b93baeca20dd25357e7777261ea6a4cbf968a203969ea_Device=CPU_Config=() +519:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=5d68272f8318c073e481b5353e6e4350e6b3b5e120f389a98859dbd5af43db9d_Device=CPU_Config=() +519:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=941fa6fdaa34b8082171350da966423497232e44077f333cf3a46488bf237aeb_Device=CPU_Config=() +519:conformance/OpImplCheckTest.checkPluginImplementation/Function=PRelu_opset1_Device=CPU_Config=() +518:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=13c78a6d628bed4392d2577f132f924d9e17a7e29a2171dafebc0a596d2ade04_Device=CPU_Config=() +518:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=fabbe8bc510b0d1afb64f2fbe68d755be05fdccfadec5fe845dc6b3c4e6a2767_Device=CPU_Config=() +518:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=1f29402ea664e850ea05d5f2e500f087a6165f1f4c9b3e5102b5509c020f0f6d_Device=CPU_Config=() +518:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=03e7b025285b1369ca39bcf887783a843fe06ea29f7f394efc8201d1b7ad3a09_Device=CPU_Config=() +518:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=6ddb35aeda2a6cb63282d2fcf6503aa02135ad60e23c752280ef82aaf6a31191_Device=CPU_Config=() +518:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=586094b4ff6617c08c87a53c7be1ca26aae40657c8d964d81eda731dbb27e848_Device=CPU_Config=() +518:conformance/OpImplCheckTest.checkPluginImplementation/Function=IDFT_opset7_Device=CPU_Config=() +518:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gelu_opset2_Device=CPU_Config=() +517:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=73623637f6155bde0a4735dcd904e5b491d7d459bef5f8d3f66f02f9558937a1_Device=CPU_Config=() +517:conformance_Ceiling/ReadIRTest.ImportExport/Op=Ceiling.1_Type=f32_Shape=static_IR=fb5c74aa3b17b4a8d5e1603b9179b60bf3f0b8301c74a8fb632b6869896439d6_Device=CPU_Config=() +516:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=754ed99b0565f9a10963e61e6fbbcfa64848b11c6a0a68bde7aae90ff9a1e34a_Device=CPU_Config=() +516:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=219ef0bc43f90d459144cdbdb363c5382ed62c90acd319a628190dbf8f0becd9_Device=CPU_Config=() +516:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1eb25d18fbd1070f2a8ff803d76077d092d493f9e9df80e93e2f58f3621a121f_Device=CPU_Config=() +516:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=0c491c1a451ad85717879e05678f7d1c85cc35d95b108087dd241b9b24b39ddc_Device=CPU_Config=() +516:conformance_BatchNormInference/ReadIRTest.ImportExport/Op=BatchNormInference.5_Type=f32_Shape=static_IR=c602b01c85ee95a1d7deb1498c5f0494a5ee727ce8874d5beded8bf33631d0b4_Device=CPU_Config=() +516:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=281f1852405ad37d0606184e81d8534d769f50b3fe99f5f17ebfda6954f4a584_Device=CPU_Config=() +515:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a7242174afe3f7c2e95d31cd14d56ceb0a566e2e8d65ba97e07d004200f4f517_Device=CPU_Config=() +515:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8f731757a7c32fa8e4d602d7197af81a1a82ea228ec05f4baeae7c59eba11f2b_Device=CPU_Config=() +515:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=58cd9ea3d8db317b6ff7fca55bebcbc6846aebdbe309b1b621f5535b18a70320_Device=CPU_Config=() +515:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=81973bc511c12f7470f620b3484f6f7c82077975f916e080091dcd4757268b17_Device=CPU_Config=() +515:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=681b1f284fb69c16681d3efd2081d7f812496e3a027baef35a75bb0aeb9c003b_Device=CPU_Config=() +515:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=5be0b1c69be525cbddd7996b695c1a4a9f380173d03f291e8570df76c050678b_Device=CPU_Config=() +515:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=cee58d2e3f2d6ef0061c5b245a15c60f0a26a58474c015f71dbdbc0c171b2a8b_Device=CPU_Config=() +515:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=4520f02da2bc674bf781c84ea3cca92375a1eeaa77f4f4f7e4cfc3ef75fb2964_Device=CPU_Config=() +514:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=dd366f3f5b63fbfce3d9378cf0d8bfa4a909a973bc3e5e97eaa9d346c5cbf1d4_Device=CPU_Config=() +514:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=75bf24e3b7a4c4374c5c92331d9e48423d734d35b5cafb951222e39ea4c29613_Device=CPU_Config=() +514:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=7e1801bf4ef7ad1b27663dfb399f318ccb2526e925d48e3d30e2ab837824b217_Device=CPU_Config=() +514:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=15d323a190bbeb1834cfa08a3afc633a2c203e44e2660bff4e98453c02ea4cfc_Device=CPU_Config=() +514:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=cee58d2e3f2d6ef0061c5b245a15c60f0a26a58474c015f71dbdbc0c171b2a8b_Device=CPU_Config=() +514:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=() +514:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=a3e2f08143425d4c6ed46ee301de31c5942694f79af0d297e4d1801e9a6a0ff8_Device=CPU_Config=() +514:conformance/OpImplCheckTest.checkPluginImplementation/Function=Round_opset5_Device=CPU_Config=() +514:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceLogicalOr_opset1_Device=CPU_Config=() +513:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=99b432aa5821136994e06b4e3c690a4e298bc5a496740ea2c5fe6aa300edacf8_Device=CPU_Config=() +513:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=f826a40d2d5d59d35300a911a15dfd8022c0fc486ecdc7f00c06a26f5dc44338_Device=CPU_Config=() +513:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=256f748d7b98b0eb70cc659403910bac929d62a2b153e63438f8746f602a83fa_Device=CPU_Config=() +512:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=0b0005b038a938c698489da595fd89a45d2f685c831bc172d81b2afc09658dae_Device=CPU_Config=() +512:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=59f5de8e6de60b1336848dfcf1878ee5ee5bc8771ff1b93f39c31abfa3685e4b_Device=CPU_Config=() +512:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=08a156f89c28d3860b50a10fc3402ee84818806257b897f68135fe177ad1f3c1_Device=CPU_Config=() +512:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=23389586e5eb8cacb13f6355565cddaf542d2d26439bd3d4b577fd716a37b53b_Device=CPU_Config=() +512:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=028177a440f430edc5dfd7a7f0f2c0dded422876a98b6da66a647ad9aca10e57_Device=CPU_Config=() +512:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=2c114b0035075d866c028f9a1168725375feac9a666a881ae6b7db6e9066bb3f_Device=CPU_Config=() +512:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=024107902d4ca8a36f9b9c3e5c99bb04e0cf481b5e81fcae35513b9ce76ef751_Device=CPU_Config=() +512:conformance/OpImplCheckTest.checkPluginImplementation/Function=Proposal_opset4_Device=CPU_Config=() +512:conformance/OpImplCheckTest.checkPluginImplementation/Function=Cosh_opset1_Device=CPU_Config=() +511:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=95bbf8a23b19badbde31e9ae7f016aa436d50d797f59bd736e220030f645bd9b_Device=CPU_Config=() +511:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=517a5eeb2f1f21304b8a1d5971f89bfc93aa678252180bdb05144657b1a8619f_Device=CPU_Config=() +511:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3cc6ca8cdfe79957271093055b5e010a76313d2b59db6a6ca9696cda526d0cd3_Device=CPU_Config=() +511:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=edb39965b8843a3b48f2478c204a8dafdab8eb2ff76dbbbe82dca6ee3b4589af_Device=CPU_Config=() +511:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=d38ac6654882078aafe169f6d1280279fa81e646529f6f2bd621338a756046a0_Device=CPU_Config=() +511:conformance/OpImplCheckTest.checkPluginImplementation/Function=Softmax_opset8_Device=CPU_Config=() +511:conformance/OpImplCheckTest.checkPluginImplementation/Function=ShapeOf_opset3_Device=CPU_Config=() +510:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6017d3f7ee3d7e667e8e7e4881f9aae335d47c8617c92b18ec370aa0770314d9_Device=CPU_Config=() +510:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=a3e2f08143425d4c6ed46ee301de31c5942694f79af0d297e4d1801e9a6a0ff8_Device=CPU_Config=() +510:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=3f0c39b97aeab67748bd4039950e926a9d9f33b6d3261c4d65d048500adb5b7f_Device=CPU_Config=() +510:conformance/OpImplCheckTest.checkPluginImplementation/Function=DFT_opset7_Device=CPU_Config=() +510:conformance/OpImplCheckTest.checkPluginImplementation/Function=CTCGreedyDecoder_opset1_Device=CPU_Config=() +509:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b53fa2c9b93d3750c17dfb8ef75e51c43881ee79fddc863d6c1c2adfeaeaba2e_Device=CPU_Config=() +509:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4612ce2abf1348d599a331eac37b14624de5994d6c3481e8765f06d344e6ae6a_Device=CPU_Config=() +509:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=8b9cabc6a44ece744453092791ef63b8d6ca4d83af7e8635f2f4ad78186e5184_Device=CPU_Config=() +509:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=edb39965b8843a3b48f2478c204a8dafdab8eb2ff76dbbbe82dca6ee3b4589af_Device=CPU_Config=() +509:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0df360e6d6391827cd65ceefd3201c263a829e50ed375522d4e8700f3879de09_Device=CPU_Config=() +509:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=d442b2d9df68f25f567a3e8da8d87866c200d391624cf1c339554a57a9a527a4_Device=CPU_Config=() +508:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5b11b7154cade198918ce564fd66b7009aa6ddbf42a0cf155f16aef886c476f1_Device=CPU_Config=() +508:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=df62dbfb022ab001a9df6b16311f57e744e8674fa8751b4e3a7ffee872fecc20_Device=CPU_Config=() +508:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=a3d8e1343e43c666358304b530278c73bc7c52a0d7fff38977154b6f7c456731_Device=CPU_Config=() +508:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=c808434d1d2cbd9ea66373f22c7e635c5bb2e3a6294f93421d1d9d34ac62515d_Device=CPU_Config=() +508:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=024107902d4ca8a36f9b9c3e5c99bb04e0cf481b5e81fcae35513b9ce76ef751_Device=CPU_Config=() +507:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6a1c4fda6e89fd564d571ee69820791696d016e379dc78c8c55ae0e6934537b5_Device=CPU_Config=() +507:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=81973bc511c12f7470f620b3484f6f7c82077975f916e080091dcd4757268b17_Device=CPU_Config=() +507:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=8ef34b5ce0dd0100a8efad53b3b71e87f76ed69496cb6f030e76478d7daddf69_Device=CPU_Config=() +507:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=00d8728cd472d05b1eebf4b4d0ffa4a5d7c7dd34b3a99055b0f8ff5b0173af53_Device=CPU_Config=() +507:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=3c1c8bc7ce009c03509ca9d6a86f3d5cff89be49439e7513edcde4e62fbfb8ce_Device=CPU_Config=() +507:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=7244cd4799e0eab987f823edc7d6038b76afa7585e4663278be826124c5596ed_Device=CPU_Config=() +507:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=f7bc08f4bc2edb455c7afc9cecba3666df1150bf4e3a67a20061714f867ddb0f_Device=CPU_Config=() +507:conformance/OpImplCheckTest.checkPluginImplementation/Function=ConvolutionBackpropData_opset1_Device=CPU_Config=() +506:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=547fea7da34d5e65ad7ea069be003753e9ef281110c80dde11520bc350c4ca14_Device=CPU_Config=() +506:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=9b9521ed73100b54a3c5920107db944380157eea1b72f4e4d94f8e2ced1f2e4f_Device=CPU_Config=() +506:conformance/OpImplCheckTest.checkPluginImplementation/Function=CTCLoss_opset4_Device=CPU_Config=() +505:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ba5382529d458077147b1f822dae04bb7c6d0634adfa0d1e7a111b5b816ad3f3_Device=CPU_Config=() +505:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9d606780b6c646a5fc037250cae9a636436e56e277c95eadad5ce23fa09d8b13_Device=CPU_Config=() +505:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=78a5e7f340d63660dc0710d0e390dea2d3f68ac98f16e8dbc11b4c28ac0440e0_Device=CPU_Config=() +505:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=6745937b3d592b8cc1729ab2af1888ce58502379a33f0ae5d5a3eb0e70c0bc87_Device=CPU_Config=() +505:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6e508ca44667fb311f5b6d634584d2751c3fb15fc034626765c90695b7de9619_Device=CPU_Config=() +505:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=dynamic_IR=1af860b153ea667f413c7de4c98752d48ed8ac1fc7f90889009a2916e2ab1026_Device=CPU_Config=() +505:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=785551399ba4bb8eb76271bf698b3ca795b8388338f110843d5c78c03009625d_Device=CPU_Config=() +505:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=2e70eb484f4bac4cd11e9f643d2531cd0e78994af07c015183edf9d62a709d47_Device=CPU_Config=() +505:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=a3032224f3e9c096102921fd8571966d23c21cba931b9d5e31ba41e9698d07b6_Device=CPU_Config=() +505:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=d673fdf688abaeaf4cc6239ff762f8df557ab445bf9f031ab3bd87782717f2ef_Device=CPU_Config=() +505:conformance/OpImplCheckTest.checkPluginImplementation/Function=TopK_opset3_Device=CPU_Config=() +505:conformance/OpImplCheckTest.checkPluginImplementation/Function=Less_opset1_Device=CPU_Config=() +504:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1fb809952e397a442265bf095e12fff4e88e0e349323813dc40b74aa2fa84924_Device=CPU_Config=() +504:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=c202ffc0e1805a36e48ee4b06d06b68a9f179eef00dc353a092a13818e8ebbe9_Device=CPU_Config=() +504:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=b6417017678573faaf72824d1bec40bcccd73ae0007aef24b089dc3743276b14_Device=CPU_Config=() +504:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=b2dd13c363e41fef66b0dcc3e21e77b9a97e413c1c89f8c8a53179b05f01c2cd_Device=CPU_Config=() +503:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=22dc864b06ef0c7deb8aecd74a26c7bcf75eee316288284413fb61381d79425f_Device=CPU_Config=() +503:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=() +503:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=b35fe21330bf6e76f55ad27b71fb0422a737d0c400255fd6cf2cdb3252d3617f_Device=CPU_Config=() +503:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=8f3e3716e8a1e8647454d124d7538ac1faacdc1b95873ccc1a760e09d48c30d3_Device=CPU_Config=() +503:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=fabbe8bc510b0d1afb64f2fbe68d755be05fdccfadec5fe845dc6b3c4e6a2767_Device=CPU_Config=() +503:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=922e194a5ae53e76be5ae624754d3c1fe5ea0d8c564410062bd9c30afc48ffe0_Device=CPU_Config=() +503:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=0add7fb1bf1500ea125aa6d245bad577d6dea18d038c020d18c2dcd56704c671_Device=CPU_Config=() +503:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=0cc60631ab50733ce6b7a2256c0db1f9d9338505ae85b30fee02026c28511383_Device=CPU_Config=() +503:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=c0c33bc628fffda062b4f013c7d41d0f9080f14f41e084ac547099384a9b3d20_Device=CPU_Config=() +502:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2b621c5ea887266d69d70093db3504250f63d502f505c6a29a38ccf88b6fbce_Device=CPU_Config=() +502:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9795aaeb71c115680b567eab0877df338c0d8971858b489a2636c4483f3512cb_Device=CPU_Config=() +502:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=d76cd25e23d34af8e58f6447a49a50d66cc28592d3432577c240e75e00d5a765_Device=CPU_Config=() +502:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=c7998d9fa7e16dedd52f8cbe3d0814f2f3b30ee6d728881d64c4743e0ff6fae0_Device=CPU_Config=() +502:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=488c8e933df63c1368e021869a92fd48929ac252863ed4c2acfab7174b449581_Device=CPU_Config=() +502:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=d673fdf688abaeaf4cc6239ff762f8df557ab445bf9f031ab3bd87782717f2ef_Device=CPU_Config=() +502:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=941fa6fdaa34b8082171350da966423497232e44077f333cf3a46488bf237aeb_Device=CPU_Config=() +502:conformance/OpImplCheckTest.checkPluginImplementation/Function=Interpolate_opset11_Device=CPU_Config=() +501:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=33199e062b7b59c8244477fd2682a08876e72126701842265efc0c9fb4a90c94_Device=CPU_Config=() +501:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=93ce70e605eb712479090e3a266e86eb7422bf0fdd3acb1c38a0b92a9c381e2c_Device=CPU_Config=() +501:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=bc52d884c8eb9ffc1a5c6af9467b8f285933b715def03c4e5cadf426ba186c3a_Device=CPU_Config=() +501:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherND_opset8_Device=CPU_Config=() +500:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0da39d97a2f46fcbdf524727d0283243d3bf0c3fab75f76f529b6480c84f67c1_Device=CPU_Config=() +500:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=ca0d551f3da549b28475d996906bfa5202402be286f59f9bf53ac809c9fceb49_Device=CPU_Config=() +500:conformance/OpImplCheckTest.checkPluginImplementation/Function=PriorBoxClustered_opset1_Device=CPU_Config=() +499:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0bfc53d275267687d8d081e1b2174196a0c1aa18bab9ba84a08fe1735336c42f_Device=CPU_Config=() +499:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=efeea353bf41d0aac1f5400e451346d6cb407610566018f368726328cafca221_Device=CPU_Config=() +499:conformance/OpImplCheckTest.checkPluginImplementation/Function=RDFT_opset9_Device=CPU_Config=() +498:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=461dc8aa282946831fdc86d1c024a273ac0f29f5ad615cd55b879feea6d23007_Device=CPU_Config=() 498:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a848753a720bf9791ee4c239cf08712d714b877bfb6df23805590ad690ceaff7_Device=CPU_Config=() -498:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=dynamic_IR=60bd170e816e0c2345a1658fd88459775fe8b7cce5de31a16e4e6cdea199f264_Device=CPU_Config=() -498:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=bc52d884c8eb9ffc1a5c6af9467b8f285933b715def03c4e5cadf426ba186c3a_Device=CPU_Config=() -497:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=f9f031e1fb61fcf87468eb1f4b2005e7cecc5f073eca95c161fe62fbbfc983f4_Device=CPU_Config=() -497:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5d522332a7166265867b633721d8bd8ff23a233e7c8bff59a245bbb24d7be234_Device=CPU_Config=() -496:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=df8ed5b481f6b03ca63572f2059d20911d3a7757f4c032455bef9933f2c1dc35_Device=CPU_Config=() -496:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=8b8121ebbd51ee995f98531f595145a01ba70ce026ad0bee588733c33e70272d_Device=CPU_Config=() -496:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=9ec0516350dc25e0dff22b12b65f761cd4e2744881c1f356f9ab50680eee1a69_Device=CPU_Config=() -496:conformance_BatchNormInference/ReadIRTest.ImportExport/Op=BatchNormInference.5_Type=f32_Shape=static_IR=8f1629e9b003409304f12c3e315e8ae8246b3bc80208c3f612d5c5c179082a7b_Device=CPU_Config=() -495:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=315fa20f952b6c7678cc93dbfd340097847826fea7928eabcec46d7ccacdb224_Device=CPU_Config=() -495:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=55d83e2240e88295a78084f92162888c9b0beef46ae468cd7ab93a1c0a432835_Device=CPU_Config=() -495:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=be4d557c62a3a43e7f309d2276cd7549bf1976ca8593bf2be752e60c42237a19_Device=CPU_Config=() -495:conformance/OpImplCheckTest.checkPluginImplementation/Function=Divide_opset1_Device=CPU_Config=() -494:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=98932a2171e1c93b2bec3991892faaac027e1c319e91b9008ef0d0f469bcb0e7_Device=CPU_Config=() -494:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=e7e985d4d02762d236131e74fd867acff1828bcd4c4eb32e190de20eadb831fb_Device=CPU_Config=() -494:conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=f32_Shape=static_IR=f735a44db0a337a22f5ebed052a5718168765287ff4e0eca961c3f9fd68586c0_Device=CPU_Config=() -494:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2e586703f4f8e9285249881d509a2a0b96d4758be5f97d75e7ee4f78951c58e9_Device=CPU_Config=() -494:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=073dca39b0ed99c8af202a5e272db241f95de1f64a7a1611e83853b92e7f7f09_Device=CPU_Config=() -492:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=525ed9b2af76610bf0ee3d11cb1dcfd46059335968359c143d0da7465736ac2e_Device=CPU_Config=() -492:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b53fa2c9b93d3750c17dfb8ef75e51c43881ee79fddc863d6c1c2adfeaeaba2e_Device=CPU_Config=() -492:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=622add2dcd72d2e1560e983ef4aad56fd35b48b71964ea8204137026f445d37d_Device=CPU_Config=() -492:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=1f29402ea664e850ea05d5f2e500f087a6165f1f4c9b3e5102b5509c020f0f6d_Device=CPU_Config=() -491:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=37a75b89894d8a024fe6d1808e0674b4fb59534cd319f4bcd07c6d9caaaf97a5_Device=CPU_Config=() -491:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2b59c9f67435c46699dc1c66ee7ddbdd333bfa544d0aef7bd1389db2635868c7_Device=CPU_Config=() -491:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=e4baf41ae9a77441993eb0f95c3d7335e9a719e5eac8b1ffaf60d8f515f769a1_Device=CPU_Config=() -491:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=df085870336c57084e22afa8b52ece7149abc21b5d1784965a7d36d5ada91e8b_Device=CPU_Config=() -491:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=de3245d77d2e004bea85af29c91e1668ae1b6905fe2cdabb92711adbde6406a9_Device=CPU_Config=() -491:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=be59de0f93d8a22736d98d0aab618839905eb9a04f79c8d88d7ef08c7267f4ec_Device=CPU_Config=() -490:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2006e1eaa808a3e78550535058de54c5cd83e9a32a52e488fef1f7883c321a3_Device=CPU_Config=() -490:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=78db1c0e2c0fd4f0d351e66ce9cd31f7a6ee804cd23bc686b8c9081125b7142e_Device=CPU_Config=() -490:conformance_LRN/ReadIRTest.Inference/Op=LRN.1_Type=f32_Shape=static_IR=c1a0f6661ad306b82e66063988835c1a17072608792f3423bb058fe38c4b14d1_Device=CPU_Config=() -490:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=6faa91bd8e7037c9233825cde9313cfd2afafa21ff423a00544eaa36d734332e_Device=CPU_Config=() -489:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6453d2955ad3344d5e021f97d71691ddd7c27ffc0d9044b724c9a6b5c20cb427_Device=CPU_Config=() -489:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8de274a65748ff76511a53b614cfb33651d2b51720714851a16976fc1ee2b6ea_Device=CPU_Config=() -489:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=017d4b1dac18731e05634414942698ecbc750e306eb86e773ffe5007bfa9feee_Device=CPU_Config=() -489:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0182ad6b02d77803accd2ebe55d87b679950570d1dcfef2940adcbb5fb9f1a24_Device=CPU_Config=() -489:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=14598e053d7dee616de43f2b160e780b4bb53decaea53b31db58341464b82e48_Device=CPU_Config=() -488:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f5a74749f6c90dccecbb5e4a7d0fee72cca6247f0084487b5ca7d94d098c9b9b_Device=CPU_Config=() -488:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=445a2c47e85b116d03e5f6fe43863a39778b78ca5175fba1bb0eec669f7610cf_Device=CPU_Config=() -488:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=00d8728cd472d05b1eebf4b4d0ffa4a5d7c7dd34b3a99055b0f8ff5b0173af53_Device=CPU_Config=() -488:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=1d8577d7a316c5a2726f3be79b4f8b22d6dccdd5491a4c7896a7c9de37330e77_Device=CPU_Config=() -487:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=95bbf8a23b19badbde31e9ae7f016aa436d50d797f59bd736e220030f645bd9b_Device=CPU_Config=() -487:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3374f930d0ffd26ccd7cb542638f2386ae5f803b5bdce4d848ba1e93b4a173a8_Device=CPU_Config=() -487:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=d661093ec9006177e5d47e7f666d7c98353f9c3d5290ba6284145f60822f2573_Device=CPU_Config=() -486:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ef702f626a20bec33a58f2596e4e6e15f105860ebfff1d6f42116a514d853c4a_Device=CPU_Config=() -486:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8198512c1849e0efe931509147ac4dfed4ddc7ea8d0736a7defb4fce81e2ea28_Device=CPU_Config=() -486:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=089d73af2221696ce3755a9f33124c9af87fd3e860a1d4f229995eb01ff46703_Device=CPU_Config=() -486:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bb610d59221e7c5d8e96f971519b7ef27bda7bbb9be329b873a901a1e749b9cc_Device=CPU_Config=() -486:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b3cb0ba09807204990d7e1635ef35fc96aa10330de2ffefd95f6483e68dca532_Device=CPU_Config=() -485:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e27641fd09143d736ece2166cc3156e80c190d5def706b86358f49fe980cf9b7_Device=CPU_Config=() -485:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=45b3506bf3dbe053fcb290dd1040a9d125c56086b37223e8480647bdd9b9372d_Device=CPU_Config=() -485:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=4e6db028c1ff414e411bc09accf3b7c20cf81e530c903e14586eaad4c21fa111_Device=CPU_Config=() -485:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b12c40f6d576482396a94e28e0814488b87eb6844583bc87384ed385d45bd6e0_Device=CPU_Config=() -484:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b42c98b6313e56a7a012553eeabae92f0672c0bde6f9895d10fb459796448b75_Device=CPU_Config=() -484:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4722375e4770c972f87bc89a8ca16871aa57251a9c01ab2a14adc11f885cac91_Device=CPU_Config=() -484:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=() -484:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=f03721e9c346ede7ba78d0a2466e38cec6d1e08b3395b38c8f47ebcbfba35d3e_Device=CPU_Config=() -484:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=static_IR=7aacf3576c3d114915bc3aa48c8ee4ac9e94bc00928709d86461877a8d2d84fa_Device=CPU_Config=() -484:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=30680a7972de02e47d59c768730b8a64a06b011dc8b5be4fd25f190662cf1c1d_Device=CPU_Config=() -483:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=df8ed5b481f6b03ca63572f2059d20911d3a7757f4c032455bef9933f2c1dc35_Device=CPU_Config=() -483:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=37337436d0d481c689caabec3bbc8f21ecec65560c70de4dd1f5b0ed9e444bf9_Device=CPU_Config=() -483:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c2539b8a06e5dd0e01933c6861e366f8ed565e5956b8b2546647b55e966e7755_Device=CPU_Config=() -483:conformance_ROIAlign/ReadIRTest.Inference/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=() -481:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=349d64660bcbb9269f88067431a4b8fc31fcfd09ffb1afa9f3ecf4bc37e8c4ca_Device=CPU_Config=() -481:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=785551399ba4bb8eb76271bf698b3ca795b8388338f110843d5c78c03009625d_Device=CPU_Config=() -481:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=a3032224f3e9c096102921fd8571966d23c21cba931b9d5e31ba41e9698d07b6_Device=CPU_Config=() -480:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=81954ff76e3fd04ec3b3e3c26e28a79ac259c9b255f90ebe3cc0772fb673874e_Device=CPU_Config=() -480:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3f830d5ee243ca3f56d027f95929bbadd427e4954e286e6c890ddd60f9c5c2d0_Device=CPU_Config=() -480:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=152333527a542f3e2228bac5d0fd4ed288dde9205632a318b9b22b64e43be329_Device=CPU_Config=() -480:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fb5525d36d14f54eebc5670c06232ca4e32cf920d309b5777e37d3377d386433_Device=CPU_Config=() -480:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=23ad83652d315aa08ee781b0fc81c0eb737265280c85a86a4f08cad71b33e74a_Device=CPU_Config=() -480:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=488c8e933df63c1368e021869a92fd48929ac252863ed4c2acfab7174b449581_Device=CPU_Config=() -479:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=033c6bc337d14053ae097dcbee99ef5de7cb7728b589cc8d64783467505a8ba7_Device=CPU_Config=() -479:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=f110ef35c9642ecd941cd85a67a12b616353d4a8cd33f9770d532759e2846255_Device=CPU_Config=() -479:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a093f44f22a851366eec46b6ed80fcecd2a4a96ca797c2caf288922a2fae1fd1_Device=CPU_Config=() -479:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=2aa586a55098e1960c204572ca9704bb3b8b9a3baab5fcf08200594261f7bef7_Device=CPU_Config=() -479:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0da39d97a2f46fcbdf524727d0283243d3bf0c3fab75f76f529b6480c84f67c1_Device=CPU_Config=() -478:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a956d2fb1fd17e2d864b3eaa8915cc0c4f9a768e35fdf5bf20cf6bc7f41aa130_Device=CPU_Config=() -478:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8198512c1849e0efe931509147ac4dfed4ddc7ea8d0736a7defb4fce81e2ea28_Device=CPU_Config=() -478:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f01152d615a3092ffd4ad1059779ea183d7a62c1ab5b970d940f3f537e6f12db_Device=CPU_Config=() -478:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=49ed5fbacb5510d9cb3970dee136271e98ad5322b95217c6dc41026e583f3bcc_Device=CPU_Config=() -478:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=53108cff3836c47360380f3898c5de245a566a5d98040820d78befd46e56955b_Device=CPU_Config=() -478:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=cd5756749d3d73dc7b666f7f41dc292c73230e5d31ddbbd43aae77210b86220a_Device=CPU_Config=() -477:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=62409191ca760efe019eed9d1923c8df9ab545d39f90b1230a58d1747d3143b1_Device=CPU_Config=() -477:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=90f882a97d637e527900edfb1b7c277b65544832793d08efdf8454be21a2f496_Device=CPU_Config=() -477:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=355bfa53a1f9e712db4df6642a51970e96e3612583b2ec90e7a8170e45b1625c_Device=CPU_Config=() -477:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=8b9cabc6a44ece744453092791ef63b8d6ca4d83af7e8635f2f4ad78186e5184_Device=CPU_Config=() -477:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=df62dbfb022ab001a9df6b16311f57e744e8674fa8751b4e3a7ffee872fecc20_Device=CPU_Config=() -476:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f0145ffb8d2846d866b1a89c8217d54209830e6d3d0d10913e75af42f2510c74_Device=CPU_Config=() -476:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8a5bf21112b4a458a3323e615dfce41a8627c89ac692e1d568786634667849ab_Device=CPU_Config=() -476:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=d9231cf5e3e491e318f16514e771cfdee4b781b42fc9d45088da850ab48079cc_Device=CPU_Config=() -476:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c5c5d09465cec7f1477d5e02f3f1c4cf593c71aa090532c4e43451fedde7c2c5_Device=CPU_Config=() -476:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=074ab76268ab5d03283f03f4e228a7cf73ab5a18fc0e7366778cf8c45286f18a_Device=CPU_Config=() -476:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=dynamic_IR=e46ec3487f18188d1da4c029a2981033018c1f8f273f60d3f7d1bcbdae18c2c5_Device=CPU_Config=() -476:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=c7998d9fa7e16dedd52f8cbe3d0814f2f3b30ee6d728881d64c4743e0ff6fae0_Device=CPU_Config=() -476:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=ca0d551f3da549b28475d996906bfa5202402be286f59f9bf53ac809c9fceb49_Device=CPU_Config=() -476:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=68ae288409f3972b9f52f4ea76573a81d764758059915949e76dc5f20e6952bf_Device=CPU_Config=() -476:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=dynamic_IR=edf223c654667e60869d97d2fb6a2bdf356db8d7e997b4b9a66e56445bc24f30_Device=CPU_Config=() -475:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=53828d433bfa231cac709949db0e4ff72010e5cf9df167ecda7ac72bd5a69e10_Device=CPU_Config=() -475:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a110c620d27325938e9febcd9d757a5525c421bc29450fea960403fbca3507f4_Device=CPU_Config=() -475:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=9337e101d74f6d35bf81e9be895ffba9e972cdab9d79b2802f1c1ec0f4d34a83_Device=CPU_Config=() -475:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b7983ae70a4e7868ccbf4b25a5d8e795620182c29817ad1151d89f2e932d770b_Device=CPU_Config=() -475:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9cd66958dfe8db471d48d6ea35f1b4547a413fcdc6c61c804a456befcbb09d15_Device=CPU_Config=() -475:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=225aaa01462e6e43c0c12cff65f96e7d9c07d368a820ff3c1b2939fefe86d492_Device=CPU_Config=() -474:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5ba879b46e93286e4c880a726e28d6956a1c8415508733b5349079f899462679_Device=CPU_Config=() -474:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=abefab3b34ee5f7da347f3c86a1a0b7b17617de416051dc18c3aee80862c3000_Device=CPU_Config=() -474:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=u8_Shape=dynamic_IR=4d2c49ebbc46b60233510b63e280442319496782da33185f7c2d6003611f937e_Device=CPU_Config=() -474:conformance_ShuffleChannels/ReadIRTest.Inference/Op=ShuffleChannels.1_Type=f32_Shape=static_IR=46e851dee1f7bead1a6e2459157df33266c45559375a1caff90a2732cacaf881_Device=CPU_Config=() -474:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.1_Type=i64_Shape=static_IR=26d97c755f660ed8ee08a0de8d6ab88598391cc79b239bfaf0a102722ffc4bf7_Device=CPU_Config=() -474:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=98526403db7eb1f67a41aed2c34fea684d99d8cb8225313136e55be7d326aaaa_Device=CPU_Config=() -474:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=23654f4a28ae697d81f49d72568e7f0657d5c15b82e173fd7381760ebcb61cda_Device=CPU_Config=() -474:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=adabeb9321a0770cb065345aca787cbf7d1adef68132cc5c7d8df885ea64ab2c_Device=CPU_Config=() -473:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=f89eecd15ff45d6929f82696f96a68adfd694043ec3f859952d80080bd140627_Device=CPU_Config=() -473:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=() -473:conformance_BatchNormInference/ReadIRTest.ImportExport/Op=BatchNormInference.5_Type=f32_Shape=dynamic_IR=694ab408745deafb90f8515e002a393e790a8b1f83e58519081b983067d76967_Device=CPU_Config=() -472:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=eb33c5485ec10ae4f1268ab19db6a4ef86812d4c92680b43791274bb055e2220_Device=CPU_Config=() -472:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6eeea9355df867c7fc97af81dae6d02799239ec1e480dc2c975a60761fc5f7be_Device=CPU_Config=() -472:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=59d132b45e2ac60a670eb43efafa43f065bb43d492208ac670fc8234b4f618c9_Device=CPU_Config=() -472:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=0d62db1843ef7e470a613f9f4d4999ce0e6c94365bd667b78c283cb9406e915d_Device=CPU_Config=() -472:conformance_Erf/ReadIRTest.Inference/Op=Erf.1_Type=f32_Shape=static_IR=906676850a62f56935dbd13792be1013db602488f29eb757a546b411699ccdd5_Device=CPU_Config=() -472:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=7b8d235013affb9589d57a8f99b36858d739258b787cffc7cec85d1dca567261_Device=CPU_Config=() -472:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=b5a1e5c47a0597ee9c9d0c0aca9909c596cbe71ebb069254460c2e97acfc1c0c_Device=CPU_Config=() -472:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=29624e785b9377dbf03b9aae46e7d0049e93a94655059ec37a0fe308ff7cb9a3_Device=CPU_Config=() -471:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=05690f7225eecae70805d45641cd02c02c46bc61f9fa4cf91d3ec7ce94f6fd3f_Device=CPU_Config=() -471:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2cc5f8b67a407507c1d59a08981887766d377c7368b53cb0a18ec71df291b1f2_Device=CPU_Config=() -471:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=() -471:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=9b915f1788d3d4768839d2cefe4fbba2f8b2d8aa4c22f9ad574335c22d0db1a2_Device=CPU_Config=() -471:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=f64585bfa3951a93f76c18fbc795f3ef82176e270c9f37161bdfe48e094c1d39_Device=CPU_Config=() -470:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=51d309244d7c90039cf86929d62320f5e5c5df8b1390c6b1241d8389eb6914e2_Device=CPU_Config=() -469:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=37b1b14a23dbc309d75fbd98158648e1a7fd246684b96e1ebb10a75c3f5b03b6_Device=CPU_Config=() -469:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d69304b651805edf18138147ec5a4c16e883ad5e5d9828db849a35249c28b263_Device=CPU_Config=() -469:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b66a71c512cd06f5dc1d1a254ba0128b606c1c41b860f272dc1d2514502c2350_Device=CPU_Config=() -469:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5a82d5761e70d13623af2cc6a6eab20a7a0657ac28f38223e34b63d6cbc1224b_Device=CPU_Config=() -469:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=94de295ab12bd6b03bc5de22f9e9c46d5875d111eb942d3ba35f8e2456ece1cd_Device=CPU_Config=() -469:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=9b915f1788d3d4768839d2cefe4fbba2f8b2d8aa4c22f9ad574335c22d0db1a2_Device=CPU_Config=() -467:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e27f0bcb3118a7cdb488f4685707bec982ae54ff8bf7e97aff9ea6ecedd66714_Device=CPU_Config=() -467:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=ca0d551f3da549b28475d996906bfa5202402be286f59f9bf53ac809c9fceb49_Device=CPU_Config=() -466:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=060423427a9100b6a38aad12a83043441f8af436c1d2502350ae867f45bd721f_Device=CPU_Config=() -466:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0fb6a7848271e000d49d4966647edf55e65f181523883089f43147c14cfb9871_Device=CPU_Config=() -466:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0edbc14a5d5ac1265a4b880131348aa16e284012547556ddedb36b185d833284_Device=CPU_Config=() -465:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=28bb0064e4cb56c497227ec69899b08dc09cccbf7d390555416aff617a393f81_Device=CPU_Config=() -465:conformance_ReduceProd/ReadIRTest.ImportExport/Op=ReduceProd.1_Type=i64_Shape=static_IR=44e0e688ecb44d7a9e83f7c9e1639fae49b2883dfc1b1ed588c98c5bd1f614fe_Device=CPU_Config=() -465:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=075342290aa43542c81f7ed4e804c905f110edc23440452c6d0c0f0c312b65c1_Device=CPU_Config=() -465:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b4c737aec2f47947d1afbe26d9d8cd124c6fdd24e30cab1f563d91310d1b62c7_Device=CPU_Config=() -465:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f0853773e26eae3d051504ed8db7f182c0e90ef7b45625a1a72ac51a73e2208a_Device=CPU_Config=() -465:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=02f589480d24784ece323ba30be856c7cc718151d3588f683ef4825a407749ac_Device=CPU_Config=() -464:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=87baad85c649084e386ca502375581e9dc47c68c076bacae5e5ac1ddbaaa7830_Device=CPU_Config=() -464:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=2ad5b63ed56c3966570062970125d1cac16629595e9ac34c6613cf00d6dec0aa_Device=CPU_Config=() -464:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=4946bdb7dec06c2bc8eae33d5903d6fa41bbf3654b13a0cb5cfa4af5a4720426_Device=CPU_Config=() -464:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0ac57f7cc81a683585f810885288fdaa174de2497d00156b85e067653aad3a56_Device=CPU_Config=() -464:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=bd99ad9e1d756435cca9c6309caf45043f34c6c3c844f60e17deb8dfef4234f4_Device=CPU_Config=() -464:conformance/OpImplCheckTest.checkPluginImplementation/Function=GreaterEqual_opset1_Device=CPU_Config=() -463:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=() -463:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=427900d25144ee6b8cd4b35cd53c6e9335375018f6328dd01ae4db304846d991_Device=CPU_Config=() -463:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=dynamic_IR=0f5965e2daa2a1f6b050813850956d9a4bbd771cb234ec814617099e1541ea0c_Device=CPU_Config=() -463:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b9bab6ef11eb6ae637924a902a40dff310a45916d50c8f0a4ec667c8d6bde6a6_Device=CPU_Config=() -463:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=8411c0432159fb60adefa760384515552240bc6220800a736556d7461765eb60_Device=CPU_Config=() -463:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=boolean_Shape=static_IR=0702c04c1d16f65b7d552044e66732886a0b389702aa43f4c845e2460ddff1c4_Device=CPU_Config=() -463:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=ef6e4b3910cac801199b1f6be74902b42105d23de549d426b1c4bcdd7361f79a_Device=CPU_Config=() -462:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=dynamic_IR=516ad610612780fdaf83c5dc151316e83772eda4700882f934c97b2a2bd86dac_Device=CPU_Config=() -462:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=d683b96d525bc074d4f8c15934a5082a3fba1068b591f67e4b05d605fe5e6aa7_Device=CPU_Config=() -462:conformance_ReduceProd/ReadIRTest.Inference/Op=ReduceProd.1_Type=i64_Shape=static_IR=44e0e688ecb44d7a9e83f7c9e1639fae49b2883dfc1b1ed588c98c5bd1f614fe_Device=CPU_Config=() -462:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=f6f85e9282e58756d40411508d6edaacc75c0f4e64d4e25021ade07ba17bd8ce_Device=CPU_Config=() -462:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=29a544bbefe85bdabe1d5d36d83d8ee1d80c71f8b98ff6e898e1062671daa8ad_Device=CPU_Config=() -462:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=dynamic_IR=70c260fea7c5ff6d2d1e9580ecf6c6a8a26c0e688b4f8dc4540888526bc13e76_Device=CPU_Config=() -461:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fffd24bb56af50d2e56fb2abdc6c0c96fceb21f00a9a1556b3890bdc50840352_Device=CPU_Config=() -461:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=6289232b1cbbafc963ac3cd787330c81a9cd02def9fefb83d6f6cced249de92f_Device=CPU_Config=() -461:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=99866ef63c9a2e7e2d9b7f00d11a4c177775bef9cfdf074e83f56318c143e6a3_Device=CPU_Config=() -461:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=57d49137431cc7fe4364cc2fef13111fb9f7a5a908b2d7b6f5663100ba5d636c_Device=CPU_Config=() -461:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=static_IR=7aacf3576c3d114915bc3aa48c8ee4ac9e94bc00928709d86461877a8d2d84fa_Device=CPU_Config=() -461:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=d38ac6654882078aafe169f6d1280279fa81e646529f6f2bd621338a756046a0_Device=CPU_Config=() -460:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3fb25dbf33700d0b8ebc3c53fe328f2ee9f45c5a090240eec120b954998d17ce_Device=CPU_Config=() -460:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=952ad9af4561d61157cc5e73bbc5608bf8cbea1473c52a566ad1ae7252bcb35f_Device=CPU_Config=() -460:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=a72b942dc1915ccee8af871c00b16647db7c8935100b012f91ebd799bbe8d416_Device=CPU_Config=() -460:conformance_GroupNormalization/ReadIRTest.QueryModel/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=() -460:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b9bab6ef11eb6ae637924a902a40dff310a45916d50c8f0a4ec667c8d6bde6a6_Device=CPU_Config=() -460:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=14598e053d7dee616de43f2b160e780b4bb53decaea53b31db58341464b82e48_Device=CPU_Config=() -460:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=d46d4fc3e7b3b2cea07f7ba710f77f7d99b4799e7fb0d3127ea6862f3f731ae9_Device=CPU_Config=() -460:conformance_BatchNormInference/ReadIRTest.ImportExport/Op=BatchNormInference.5_Type=f32_Shape=static_IR=c602b01c85ee95a1d7deb1498c5f0494a5ee727ce8874d5beded8bf33631d0b4_Device=CPU_Config=() -459:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=23f7f775455e615175f3122ce422ee96de019ca40fe603b5a4605d51f28210b1_Device=CPU_Config=() -459:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=7147d6ead151efc24a53c196b63fc441e240c34b41ad2226a535580eb2a3f3d2_Device=CPU_Config=() -458:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2ca34430931dd41f08f2b3cb8163ea5c1889a23b53d0f3b7d26b7a8af1acef3_Device=CPU_Config=() -458:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=5df86bdcc255998a0b5b18e64e3059afb2c80e37b5695208d04a6fc0f1410b50_Device=CPU_Config=() -458:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=30680a7972de02e47d59c768730b8a64a06b011dc8b5be4fd25f190662cf1c1d_Device=CPU_Config=() -457:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7cfdc0a97fd79a5d272b29850c24dad4a0a8f147ea89b7683c98fa203a448c52_Device=CPU_Config=() -457:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3888863c4f725445490846561b2aef4a5498ef1583903b365fb864e387eb9641_Device=CPU_Config=() -457:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=592176a8c97f4d759a0c6b3ef56c3610df4a0df4743f3be7ba3ed2ffb5dcfaed_Device=CPU_Config=() -457:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=ac87d885a27bfd348d3f9fad5a03680b73b7198fad17dfdf08675e6e3d239ca3_Device=CPU_Config=() -457:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=81973bc511c12f7470f620b3484f6f7c82077975f916e080091dcd4757268b17_Device=CPU_Config=() +498:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=23654f4a28ae697d81f49d72568e7f0657d5c15b82e173fd7381760ebcb61cda_Device=CPU_Config=() +498:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=2c2cec03b3ec1da29ad4d5fbb3530ee7343a436e27be923ee1f9dd97d29731a3_Device=CPU_Config=() +498:conformance/OpImplCheckTest.checkPluginImplementation/Function=Log_opset1_Device=CPU_Config=() +497:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8484c5c087ca8317588ef676a0cafb63ded379be5bad862e4d0504f43bc6fb45_Device=CPU_Config=() +497:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=07cc41d5a7be27466beff227bce7deae470e9bc82d30963618d5279c646d0b04_Device=CPU_Config=() +497:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0256d48640841a9233553afa85e34dca797e6b5eedbd772f606c1a0e6f8e91a1_Device=CPU_Config=() +497:conformance_Ceiling/ReadIRTest.QueryModel/Op=Ceiling.1_Type=f32_Shape=static_IR=fb5c74aa3b17b4a8d5e1603b9179b60bf3f0b8301c74a8fb632b6869896439d6_Device=CPU_Config=() +497:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=0cc60631ab50733ce6b7a2256c0db1f9d9338505ae85b30fee02026c28511383_Device=CPU_Config=() +497:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=15d323a190bbeb1834cfa08a3afc633a2c203e44e2660bff4e98453c02ea4cfc_Device=CPU_Config=() +497:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=b16650eec74ddd46ff3bffc9eedb340b6bad99a338fbe6b11f7eca3098a324d2_Device=CPU_Config=() +497:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=02f589480d24784ece323ba30be856c7cc718151d3588f683ef4825a407749ac_Device=CPU_Config=() +497:conformance/OpImplCheckTest.checkPluginImplementation/Function=GridSample_opset9_Device=CPU_Config=() +497:conformance/OpImplCheckTest.checkPluginImplementation/Function=Assign_opset3_Device=CPU_Config=() +496:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7257c42699a127367a2904db71c700c5cc94b265e3132a6737f5503950f90fcb_Device=CPU_Config=() +496:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=f286960ead5b83e3e4015ee5751b114a9d70e90aa788e0fb004ac50b95a8fa2d_Device=CPU_Config=() +496:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=fced0ff647e4ea9a4b1673016b017f68ed75cdc778cad156dbd6cc379bb815f9_Device=CPU_Config=() +496:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherElements_opset6_Device=CPU_Config=() +496:conformance/OpImplCheckTest.checkPluginImplementation/Function=Convolution_opset1_Device=CPU_Config=() +495:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=99866ef63c9a2e7e2d9b7f00d11a4c177775bef9cfdf074e83f56318c143e6a3_Device=CPU_Config=() +495:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2631bf7f735ccaa382c2ea452c247f8cb4cc1a0a363362256d971d661841d637_Device=CPU_Config=() +495:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1b0fd4a9f8f0e48f90969f08b37568a86ed12126d15ed17492cf1f241c5a90a4_Device=CPU_Config=() +495:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=40876e66f31053b621aea004baaba7607b9131d4fff8e8b00ed7e1e58204988c_Device=CPU_Config=() +495:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=dynamic_IR=70c260fea7c5ff6d2d1e9580ecf6c6a8a26c0e688b4f8dc4540888526bc13e76_Device=CPU_Config=() +495:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=8f3e3716e8a1e8647454d124d7538ac1faacdc1b95873ccc1a760e09d48c30d3_Device=CPU_Config=() +495:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=33297e2649e2f0c53b0bfb5e349d83ede580471764202480855e3f1efc8017a5_Device=CPU_Config=() +495:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=b7973bf8dd344289b971d9b47575d6793643f503e13bb83c4e9c2a2863570b7a_Device=CPU_Config=() +495:conformance/OpImplCheckTest.checkPluginImplementation/Function=GroupNormalization_opset12_Device=CPU_Config=() +495:conformance/OpImplCheckTest.checkPluginImplementation/Function=GRN_opset1_Device=CPU_Config=() +494:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9cd66958dfe8db471d48d6ea35f1b4547a413fcdc6c61c804a456befcbb09d15_Device=CPU_Config=() +494:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=285bcc240dec2c32e171f3866ea33107a109566fb8ef39f0dd84e99664aaf8df_Device=CPU_Config=() +494:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=u64_Shape=dynamic_IR=5f87db7fc306440f807b413acb7eb175932f29f59d1b5eb4a9df8945b9aef9d4_Device=CPU_Config=() +494:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=41bcf70f8013164bdfeb7e348c05e6d43d9a1afc49087c49745679bc3aaf1e10_Device=CPU_Config=() +494:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=0c491c1a451ad85717879e05678f7d1c85cc35d95b108087dd241b9b24b39ddc_Device=CPU_Config=() +494:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=b35fe21330bf6e76f55ad27b71fb0422a737d0c400255fd6cf2cdb3252d3617f_Device=CPU_Config=() +494:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=a815b68b6a8d36546d3ac0112c60283bd69ae1059e8deeb98b21f538c8089beb_Device=CPU_Config=() +494:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=33199e062b7b59c8244477fd2682a08876e72126701842265efc0c9fb4a90c94_Device=CPU_Config=() +494:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=cccecd6fd3e8f3d84fb98f219b212cd2b55ae0e4e34c099a25a1028e9e2f83e7_Device=CPU_Config=() +494:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=c5f54dc9ad0b693c13c07d44fe5572bd91852b0edd57f8f06314df3e71f3659b_Device=CPU_Config=() +494:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=489201dc4d1a937b4387f1b7d01f75fa42ff02d7035d39ac6a7f56536b0d3a20_Device=CPU_Config=() +494:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=e2d1f4fde3dc1889d4f86004173ea34a9d9836f645730727f5cdf90bc0738361_Device=CPU_Config=() +493:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=02203788eb4b05d20c5873aa7be8b317797503693eee6748e4130ff7ce72ddaf_Device=CPU_Config=() +493:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=9ec078619d1ab35cd4e6a1a176bcbb2bd0e493689929a7fb1ab9a526e9ba6bd2_Device=CPU_Config=() +493:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=3c1c8bc7ce009c03509ca9d6a86f3d5cff89be49439e7513edcde4e62fbfb8ce_Device=CPU_Config=() +493:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=3e016da7faeea7044ea204d1c3a2f1729d3d7ef0be27f5b769484bc7aebea5ab_Device=CPU_Config=() +493:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=5c513c27d089910165e78a92df11852007d7c5332246fdce490b3c6dbc16b44c_Device=CPU_Config=() +493:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=f64585bfa3951a93f76c18fbc795f3ef82176e270c9f37161bdfe48e094c1d39_Device=CPU_Config=() +493:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIAlignRotated_opset15_Device=CPU_Config=() +493:conformance/OpImplCheckTest.checkPluginImplementation/Function=DeformablePSROIPooling_opset1_Device=CPU_Config=() +492:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=8b9cabc6a44ece744453092791ef63b8d6ca4d83af7e8635f2f4ad78186e5184_Device=CPU_Config=() +492:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=f64585bfa3951a93f76c18fbc795f3ef82176e270c9f37161bdfe48e094c1d39_Device=CPU_Config=() +492:conformance/OpImplCheckTest.checkPluginImplementation/Function=Elu_opset1_Device=CPU_Config=() +491:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a52a8e6ef7bbeacbc1435cde72a1a70bdb8a3abf78b5b971c2ecb1135cb4c136_Device=CPU_Config=() +491:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a24dd1485e484f31d0c72f3a0c31f373f883f6ca4a751b1d2ce18132913506dc_Device=CPU_Config=() +491:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=225424666fe2b655277d52f1d551c6e52e36cd5fd6f45f4f29dd0d0f66b4ba40_Device=CPU_Config=() +491:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=u64_Shape=dynamic_IR=5f87db7fc306440f807b413acb7eb175932f29f59d1b5eb4a9df8945b9aef9d4_Device=CPU_Config=() +491:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=d661093ec9006177e5d47e7f666d7c98353f9c3d5290ba6284145f60822f2573_Device=CPU_Config=() +491:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=87523dfccb2a9c8334d6810e33c2a2d3b6bc09db7623e7ae93ba4cea89b66a06_Device=CPU_Config=() +491:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterNDUpdate_opset4_Device=CPU_Config=() +491:conformance/OpImplCheckTest.checkPluginImplementation/Function=Interpolate_opset1_Device=CPU_Config=() +491:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingSegmentsSum_opset3_Device=CPU_Config=() +491:conformance/OpImplCheckTest.checkPluginImplementation/Function=ConvertLike_opset1_Device=CPU_Config=() +490:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2a819b46a29c8bd965ec330a28b5c163dd0a06fa2717d71bd16493ad460e8dad_Device=CPU_Config=() +490:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=eabe482de99e120ef1260cc91a746df95f8db04fa1cf6832dc45b3ee1b38f9c5_Device=CPU_Config=() +490:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=68ae288409f3972b9f52f4ea76573a81d764758059915949e76dc5f20e6952bf_Device=CPU_Config=() +490:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=2ce56cfc77884dfc61f7e9fab9a0ce04a4b016f9b3d13465cde1576b9374a2a6_Device=CPU_Config=() +490:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=f7bc08f4bc2edb455c7afc9cecba3666df1150bf4e3a67a20061714f867ddb0f_Device=CPU_Config=() +490:conformance/OpImplCheckTest.checkPluginImplementation/Function=LessEqual_opset1_Device=CPU_Config=() +490:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronTopKROIs_opset6_Device=CPU_Config=() +489:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=18788c5143cb21969863f3984fb8c5c9bb4dbb0a1869f5c8988b52ce779ff465_Device=CPU_Config=() +489:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=57d49137431cc7fe4364cc2fef13111fb9f7a5a908b2d7b6f5663100ba5d636c_Device=CPU_Config=() +489:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=3d5c8f5c1545419050f982e8555a6ef9e5dcc06545b1a8573d710e8bc2375a6b_Device=CPU_Config=() +489:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=boolean_Shape=static_IR=0702c04c1d16f65b7d552044e66732886a0b389702aa43f4c845e2460ddff1c4_Device=CPU_Config=() +489:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=d81ef130a76622c79592b0b42acf5cd6dd357ccec28958dec6eb02a654beb9ab_Device=CPU_Config=() +489:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=() +489:conformance/OpImplCheckTest.checkPluginImplementation/Function=Inverse_opset14_Device=CPU_Config=() +488:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=6faa91bd8e7037c9233825cde9313cfd2afafa21ff423a00544eaa36d734332e_Device=CPU_Config=() +488:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=03e7b025285b1369ca39bcf887783a843fe06ea29f7f394efc8201d1b7ad3a09_Device=CPU_Config=() +488:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=eabe482de99e120ef1260cc91a746df95f8db04fa1cf6832dc45b3ee1b38f9c5_Device=CPU_Config=() +488:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=efeea353bf41d0aac1f5400e451346d6cb407610566018f368726328cafca221_Device=CPU_Config=() +488:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=() +488:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingBagOffsets_opset15_Device=CPU_Config=() +488:conformance/OpImplCheckTest.checkPluginImplementation/Function=Assign_opset6_Device=CPU_Config=() +487:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=8411c0432159fb60adefa760384515552240bc6220800a736556d7461765eb60_Device=CPU_Config=() +487:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=fda1f84f5e911136f8daaf4fcebfb989f3216c066ddc1cae578882a41ca0f5bf_Device=CPU_Config=() +487:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e61665bc5590265246ab882bb55b9487e81412012ed98ac9cb16154bc8eddd17_Device=CPU_Config=() +487:conformance_Abs/ReadIRTest.QueryModel/Op=Abs.1_Type=f32_Shape=static_IR=083771171646a2eadcbb3384bd457e04d74ce8ea771813cdf67c56f7bbf20c69_Device=CPU_Config=() +487:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterUpdate_opset3_Device=CPU_Config=() +487:conformance/OpImplCheckTest.checkPluginImplementation/Function=NV12toRGB_opset8_Device=CPU_Config=() +487:conformance/OpImplCheckTest.checkPluginImplementation/Function=Exp_opset1_Device=CPU_Config=() +486:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b0dea4cb6a0cd2380e8657b0b64caab43819c0f8182ed73b2cb12eec608bfa7d_Device=CPU_Config=() +486:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=8337ad383956ad96ca95f4aeb967e05c694fe586b4ed6e46547e3ffa0217c59b_Device=CPU_Config=() +486:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=fda1f84f5e911136f8daaf4fcebfb989f3216c066ddc1cae578882a41ca0f5bf_Device=CPU_Config=() +486:conformance_CTCGreedyDecoderSeqLen/ReadIRTest.ImportExport/Op=CTCGreedyDecoderSeqLen.6_Type=i64_Shape=static_IR=117fa486a51d9715d9ba1ad90cb5d6741e762cb36ea55a91129f1947b4886649_Device=CPU_Config=() +486:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=() +486:conformance/OpImplCheckTest.checkPluginImplementation/Function=GroupConvolution_opset1_Device=CPU_Config=() +486:conformance/OpImplCheckTest.checkPluginImplementation/Function=Clamp_opset1_Device=CPU_Config=() +485:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1c9d69e1a85d03b8599961a8a1b90af7b3b2d43bc5c4f4a6b8d5da3c22166abd_Device=CPU_Config=() +485:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=dynamic_IR=1af860b153ea667f413c7de4c98752d48ed8ac1fc7f90889009a2916e2ab1026_Device=CPU_Config=() +485:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=c56cf3dc39ed0072f3e5a8cadd1502fef904b32de3b7760ee4c6964c0e505ac9_Device=CPU_Config=() +485:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=66cff13148d62809cced5a381c251525486476f7178eddd3c8e45eeed40afd06_Device=CPU_Config=() +484:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5d522332a7166265867b633721d8bd8ff23a233e7c8bff59a245bbb24d7be234_Device=CPU_Config=() +484:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=03ebf297344daffba82d04292a767fcd7c959f56788ede32ff0d7c5af06ea504_Device=CPU_Config=() +484:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i32_Shape=static_IR=a3f2389f6a8a495885efa87742d53e1e154f58f8fd6e83df89bddf5922247095_Device=CPU_Config=() +484:conformance/OpImplCheckTest.checkPluginImplementation/Function=Tanh_opset1_Device=CPU_Config=() +484:conformance/OpImplCheckTest.checkPluginImplementation/Function=GreaterEqual_opset1_Device=CPU_Config=() +483:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bbb0129fbafd6d1874ccef37a1bb60379733012c502d58326dae70f413e387f2_Device=CPU_Config=() +483:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=3907faf4268b3626cbe1ace65bee013eb8a06a2e1ca045bcf12d774117625c84_Device=CPU_Config=() +483:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=053d601716750db93af5ae01d67213086ed987370f9ff59723824dcd0a6c2462_Device=CPU_Config=() +483:conformance/OpImplCheckTest.checkPluginImplementation/Function=Proposal_opset1_Device=CPU_Config=() +483:conformance/OpImplCheckTest.checkPluginImplementation/Function=Parameter_opset1_Device=CPU_Config=() +483:conformance/OpImplCheckTest.checkPluginImplementation/Function=HSigmoid_opset5_Device=CPU_Config=() +482:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1f1ec212e843ba389ab363fc4d7b5a1056b8c5e82147d38f6c151cb31538aaa5_Device=CPU_Config=() +482:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=d76cd25e23d34af8e58f6447a49a50d66cc28592d3432577c240e75e00d5a765_Device=CPU_Config=() +481:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=abeadd9ea4814d6b3d678af4ec0853b8392165cc6270ae2b1a1f6f9d04d3cf4d_Device=CPU_Config=() +481:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=99fbf009fb26eae6bfc372a5b3d9bef89d6f82e5fa45c62cc5ece995bcc71079_Device=CPU_Config=() +481:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=f8662769a2f3a5fb20582ccbb1931b7e3fa73ec7713eca30362b0e7c0baf829a_Device=CPU_Config=() +481:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=cc989fde083332a75d3066112105028a711bdac4fc44463d098022774da752b7_Device=CPU_Config=() +481:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=13e9472dcdeb5e6ce2928191ed13dde08b6cdd62c82c94e77469d8a3ed94e39b_Device=CPU_Config=() +481:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=b2dd13c363e41fef66b0dcc3e21e77b9a97e413c1c89f8c8a53179b05f01c2cd_Device=CPU_Config=() +481:conformance/OpImplCheckTest.checkPluginImplementation/Function=RegionYolo_opset1_Device=CPU_Config=() +481:conformance/OpImplCheckTest.checkPluginImplementation/Function=Loop_opset5_Device=CPU_Config=() +481:conformance/OpImplCheckTest.checkPluginImplementation/Function=GroupConvolutionBackpropData_opset1_Device=CPU_Config=() +480:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d9db827de158568b8a10347c13216e92b37ec20d8eac92c38aabd86690114805_Device=CPU_Config=() +480:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a56e05bb4d67e44e8e5dfd902b97af411de05a0f5b1ae1c07a074286c6636b34_Device=CPU_Config=() +480:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=00b85178c2e7f891c89e99a6692b94a56ab0882f4a30167997e104db1429a9c9_Device=CPU_Config=() +480:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=c8bb865a43a3782b3b85e05c3e86388fac07473697ed45a7b04f60010555a3c9_Device=CPU_Config=() +480:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset9_Device=CPU_Config=() +479:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=815d7fd8018e49525b4d4642c1ee3cb828dcf4c6fb696ffb1fc5513490df02fd_Device=CPU_Config=() +479:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a4929232b06cc35bd37dcbd228c83319db5ff98f120a3995a6806d397e16d33f_Device=CPU_Config=() +479:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8c3b386463bd59945d3c15512b26409dee7da9b1940f153e3ff62d47d6f79d2d_Device=CPU_Config=() +479:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=69aeb01964c5dc32bbda77681903931df3fed18b0caf978ad5e986ad59c8b4c6_Device=CPU_Config=() +479:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=8f3e3716e8a1e8647454d124d7538ac1faacdc1b95873ccc1a760e09d48c30d3_Device=CPU_Config=() +479:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=57d49137431cc7fe4364cc2fef13111fb9f7a5a908b2d7b6f5663100ba5d636c_Device=CPU_Config=() +479:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=5df86bdcc255998a0b5b18e64e3059afb2c80e37b5695208d04a6fc0f1410b50_Device=CPU_Config=() +479:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=a7f6c704686f1b0e6fd4ab522930aa3fb5b4cd4683b204aa31e5c73b427e7058_Device=CPU_Config=() +479:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=dynamic_IR=79cffe28ff617b42488d33b204b0f50bcf4e304c74d2a11820c830e091c6383e_Device=CPU_Config=() +479:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=f64585bfa3951a93f76c18fbc795f3ef82176e270c9f37161bdfe48e094c1d39_Device=CPU_Config=() +479:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=b7973bf8dd344289b971d9b47575d6793643f503e13bb83c4e9c2a2863570b7a_Device=CPU_Config=() +479:conformance/OpImplCheckTest.checkPluginImplementation/Function=LRN_opset1_Device=CPU_Config=() +479:conformance/OpImplCheckTest.checkPluginImplementation/Function=DeformableConvolution_opset1_Device=CPU_Config=() +478:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=ca0d551f3da549b28475d996906bfa5202402be286f59f9bf53ac809c9fceb49_Device=CPU_Config=() +478:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=f7bc08f4bc2edb455c7afc9cecba3666df1150bf4e3a67a20061714f867ddb0f_Device=CPU_Config=() +478:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=2c114b0035075d866c028f9a1168725375feac9a666a881ae6b7db6e9066bb3f_Device=CPU_Config=() +478:conformance/OpImplCheckTest.checkPluginImplementation/Function=Softmax_opset1_Device=CPU_Config=() +478:conformance/OpImplCheckTest.checkPluginImplementation/Function=Range_opset1_Device=CPU_Config=() +477:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=860decd2bf091a335f6f820b2c6b6acc58618fbb6027e30484470ce899bb1591_Device=CPU_Config=() +477:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=94ad9524c175a0e0d2fe22bceeac82b0dc66006caa0942d343d551268e03afec_Device=CPU_Config=() +477:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b0a418fb8ec50f25147079b3aef1b13095ea626a9e52a643600c39972982ff9c_Device=CPU_Config=() +477:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=() +477:conformance_BatchNormInference/ReadIRTest.QueryModel/Op=BatchNormInference.5_Type=f32_Shape=static_IR=c602b01c85ee95a1d7deb1498c5f0494a5ee727ce8874d5beded8bf33631d0b4_Device=CPU_Config=() +477:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=e2d1f4fde3dc1889d4f86004173ea34a9d9836f645730727f5cdf90bc0738361_Device=CPU_Config=() +477:conformance/OpImplCheckTest.checkPluginImplementation/Function=Result_opset1_Device=CPU_Config=() +477:conformance/OpImplCheckTest.checkPluginImplementation/Function=IRDFT_opset9_Device=CPU_Config=() +476:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=13b2245278f237db23d5f5cea6e9c464521180559df4059ba49d98669f5227c4_Device=CPU_Config=() +476:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=c985b086d155654f9db8470da3af5245c4fbb0139015d049b8b3b20f393c2545_Device=CPU_Config=() +476:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=eabe482de99e120ef1260cc91a746df95f8db04fa1cf6832dc45b3ee1b38f9c5_Device=CPU_Config=() +476:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=2f7925a034999529ce07a5c8bed2b2c7aeeb7936f74730d9c8ca5a5086dea4cd_Device=CPU_Config=() +476:conformance/OpImplCheckTest.checkPluginImplementation/Function=Tile_opset1_Device=CPU_Config=() +476:conformance/OpImplCheckTest.checkPluginImplementation/Function=Reshape_opset1_Device=CPU_Config=() +476:conformance/OpImplCheckTest.checkPluginImplementation/Function=CTCGreedyDecoderSeqLen_opset6_Device=CPU_Config=() +475:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=7b8eedb1c6be0db4a0c041ec3b04498d6dc68b326c35533ae16258e750f21e3f_Device=CPU_Config=() +475:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=68ae288409f3972b9f52f4ea76573a81d764758059915949e76dc5f20e6952bf_Device=CPU_Config=() +475:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=2aa586a55098e1960c204572ca9704bb3b8b9a3baab5fcf08200594261f7bef7_Device=CPU_Config=() +475:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=488c8e933df63c1368e021869a92fd48929ac252863ed4c2acfab7174b449581_Device=CPU_Config=() +475:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=fced0ff647e4ea9a4b1673016b017f68ed75cdc778cad156dbd6cc379bb815f9_Device=CPU_Config=() +474:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=64bd2f48b3326db083653b5993c9a75d21be515cbc5af67c62c981e9744e2f0b_Device=CPU_Config=() +474:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=cc989fde083332a75d3066112105028a711bdac4fc44463d098022774da752b7_Device=CPU_Config=() +474:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=bc52d884c8eb9ffc1a5c6af9467b8f285933b715def03c4e5cadf426ba186c3a_Device=CPU_Config=() +474:conformance_BatchNormInference/ReadIRTest.Inference/Op=BatchNormInference.5_Type=f32_Shape=dynamic_IR=694ab408745deafb90f8515e002a393e790a8b1f83e58519081b983067d76967_Device=CPU_Config=() +474:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=cc13aaec2a2bbe9b760651d358622114b4b0a20cb106472bd8519f0fade61dcd_Device=CPU_Config=() +474:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=dynamic_IR=edf223c654667e60869d97d2fb6a2bdf356db8d7e997b4b9a66e56445bc24f30_Device=CPU_Config=() +474:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=e2d1f4fde3dc1889d4f86004173ea34a9d9836f645730727f5cdf90bc0738361_Device=CPU_Config=() +474:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset4_Device=CPU_Config=() +474:conformance/OpImplCheckTest.checkPluginImplementation/Function=GRUCell_opset3_Device=CPU_Config=() +473:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=922699707423c4110bf8a551eaf7dc3689fd3673fff79cca21442cda90c22dda_Device=CPU_Config=() +473:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=46a3135a1078cd8732e84754fa66872648997791d16caa379a179e1a90960608_Device=CPU_Config=() +473:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=f286960ead5b83e3e4015ee5751b114a9d70e90aa788e0fb004ac50b95a8fa2d_Device=CPU_Config=() +473:conformance/OpImplCheckTest.checkPluginImplementation/Function=Roll_opset7_Device=CPU_Config=() +473:conformance/OpImplCheckTest.checkPluginImplementation/Function=NMSRotated_opset13_Device=CPU_Config=() +472:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=00d8728cd472d05b1eebf4b4d0ffa4a5d7c7dd34b3a99055b0f8ff5b0173af53_Device=CPU_Config=() +472:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=3e016da7faeea7044ea204d1c3a2f1729d3d7ef0be27f5b769484bc7aebea5ab_Device=CPU_Config=() +472:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=0cc60631ab50733ce6b7a2256c0db1f9d9338505ae85b30fee02026c28511383_Device=CPU_Config=() +472:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=cccecd6fd3e8f3d84fb98f219b212cd2b55ae0e4e34c099a25a1028e9e2f83e7_Device=CPU_Config=() +472:conformance/OpImplCheckTest.checkPluginImplementation/Function=Unique_opset10_Device=CPU_Config=() +472:conformance/OpImplCheckTest.checkPluginImplementation/Function=Transpose_opset1_Device=CPU_Config=() +471:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=edbbf6122999103bb19f5d7d4f694ed72221dbc69fe8912853e01a9125eb46d5_Device=CPU_Config=() +471:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=dynamic_IR=1af860b153ea667f413c7de4c98752d48ed8ac1fc7f90889009a2916e2ab1026_Device=CPU_Config=() +471:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=dynamic_IR=6b70264ed3eb3831e0e034230813ce1a1e71c157a302822b56335e587bd200b3_Device=CPU_Config=() +471:conformance_Ceiling/ReadIRTest.Inference/Op=Ceiling.1_Type=f32_Shape=static_IR=fb5c74aa3b17b4a8d5e1603b9179b60bf3f0b8301c74a8fb632b6869896439d6_Device=CPU_Config=() +471:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=ef6e4b3910cac801199b1f6be74902b42105d23de549d426b1c4bcdd7361f79a_Device=CPU_Config=() +471:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=ea860537d420b0d1afe0ec9a10192912ec59d8f4ba01b27add362ce50fd6b380_Device=CPU_Config=() +471:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=2e70eb484f4bac4cd11e9f643d2531cd0e78994af07c015183edf9d62a709d47_Device=CPU_Config=() +471:conformance/OpImplCheckTest.checkPluginImplementation/Function=Tan_opset1_Device=CPU_Config=() +471:conformance/OpImplCheckTest.checkPluginImplementation/Function=MaxPool_opset1_Device=CPU_Config=() +471:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseNot_opset13_Device=CPU_Config=() +470:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e05af92d21ebd869cf6e9554a4aa0bfc60c8b0c64baebee798f0be5a0a01019e_Device=CPU_Config=() +470:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=9c6d5cdaf19c92d1f994e4ae6cfdecf5a9ff04e47a2e0e68f3a08ec8f6e74479_Device=CPU_Config=() +470:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=7b2199d0ea56102a7c6737be2334b9717ee292c13cdb692d07fddfd173ea5b82_Device=CPU_Config=() +470:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0d782801290370c7c390ad549171ec3500ab344b8b34ce4b8fd8b05339fe5557_Device=CPU_Config=() +470:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=7e1801bf4ef7ad1b27663dfb399f318ccb2526e925d48e3d30e2ab837824b217_Device=CPU_Config=() +470:conformance/OpImplCheckTest.checkPluginImplementation/Function=PriorBox_opset8_Device=CPU_Config=() +469:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=19d36388bdf9535fef89243d6dfce670fc91377062ed4b3095ea55b88e4f296a_Device=CPU_Config=() +469:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=9c6d5cdaf19c92d1f994e4ae6cfdecf5a9ff04e47a2e0e68f3a08ec8f6e74479_Device=CPU_Config=() +469:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=dynamic_IR=79cffe28ff617b42488d33b204b0f50bcf4e304c74d2a11820c830e091c6383e_Device=CPU_Config=() +469:conformance/OpImplCheckTest.checkPluginImplementation/Function=PriorBox_opset1_Device=CPU_Config=() +468:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=8b8121ebbd51ee995f98531f595145a01ba70ce026ad0bee588733c33e70272d_Device=CPU_Config=() +468:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=5d68272f8318c073e481b5353e6e4350e6b3b5e120f389a98859dbd5af43db9d_Device=CPU_Config=() +468:conformance/OpImplCheckTest.checkPluginImplementation/Function=Reverse_opset1_Device=CPU_Config=() +468:conformance/OpImplCheckTest.checkPluginImplementation/Function=RandomUniform_opset8_Device=CPU_Config=() +468:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalOr_opset1_Device=CPU_Config=() +467:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=() +467:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=55d83e2240e88295a78084f92162888c9b0beef46ae468cd7ab93a1c0a432835_Device=CPU_Config=() +467:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=7b2199d0ea56102a7c6737be2334b9717ee292c13cdb692d07fddfd173ea5b82_Device=CPU_Config=() +467:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=07b257862a62290d7e8ae939147bb7422992528bf54209b8d1bff500b99b6f4b_Device=CPU_Config=() +467:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=09dd33f661a07095dc47e3e5205c9fc6dceda72526e79be0751c34823c7e7cf1_Device=CPU_Config=() +467:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReadValue_opset6_Device=CPU_Config=() +466:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=de9827c3efd198893fd6a26bb5efd6a4aef5451447643a69f085f0b6e605097e_Device=CPU_Config=() +466:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=cbfc33348aff4daf15fb7926884243c7ffe38aa29e60eceda90fa9b8aadad5b1_Device=CPU_Config=() +466:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=a3e2f08143425d4c6ed46ee301de31c5942694f79af0d297e4d1801e9a6a0ff8_Device=CPU_Config=() +466:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceL2_opset4_Device=CPU_Config=() +466:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMSequence_opset5_Device=CPU_Config=() +465:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=dynamic_IR=e46ec3487f18188d1da4c029a2981033018c1f8f273f60d3f7d1bcbdae18c2c5_Device=CPU_Config=() +465:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=b93daedfdba7331025c12a5eb4b881bd7df445d80bd4fac34833087fe6d65bf5_Device=CPU_Config=() +465:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=30dd450fadb8a1081c1315cd0e5234728862b4de39b097a5a3248d551369b60a_Device=CPU_Config=() +465:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=c7998d9fa7e16dedd52f8cbe3d0814f2f3b30ee6d728881d64c4743e0ff6fae0_Device=CPU_Config=() +465:conformance_BatchNormInference/ReadIRTest.ImportExport/Op=BatchNormInference.5_Type=f32_Shape=dynamic_IR=694ab408745deafb90f8515e002a393e790a8b1f83e58519081b983067d76967_Device=CPU_Config=() +465:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScaledDotProductAttention_opset13_Device=CPU_Config=() +465:conformance/OpImplCheckTest.checkPluginImplementation/Function=If_opset8_Device=CPU_Config=() +464:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=843bee6f74a42e3303b4bc38b302fc0858c4dea7ec4bc997c6aedfd0cc76ba37_Device=CPU_Config=() +464:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=54a5630072fb0e0127611a4ae63db14b7c0fa0979f4d2be7bfec548b5291a0af_Device=CPU_Config=() +464:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=3d5c8f5c1545419050f982e8555a6ef9e5dcc06545b1a8573d710e8bc2375a6b_Device=CPU_Config=() +464:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=b93daedfdba7331025c12a5eb4b881bd7df445d80bd4fac34833087fe6d65bf5_Device=CPU_Config=() +464:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=0662f4c4f222a79755532ac9eed43118b2ebd0faf0fbb9b400f9047ca1071b5f_Device=CPU_Config=() +464:conformance_Ceiling/ReadIRTest.QueryModel/Op=Ceiling.1_Type=f32_Shape=static_IR=1484c3d0a5a8b6d1daa002e27b07bb8ba0b5d83aae50b0a3b3bea08483815d55_Device=CPU_Config=() +464:conformance_BatchToSpace/ReadIRTest.QueryModel/Op=BatchToSpace.2_Type=f32_Shape=static_IR=f118f5911730937f9dab91ad5eb6f78cb1af6de7bae1dc745dab2d4f02257fff_Device=CPU_Config=() +464:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=eed21ac7c17920ba437332691e231037113367ee3d256b4db1380c8d2e0db84f_Device=CPU_Config=() +464:conformance_Abs/ReadIRTest.Inference/Op=Abs.1_Type=f32_Shape=static_IR=083771171646a2eadcbb3384bd457e04d74ce8ea771813cdf67c56f7bbf20c69_Device=CPU_Config=() +464:conformance/OpImplCheckTest.checkPluginImplementation/Function=SquaredDifference_opset1_Device=CPU_Config=() +464:conformance/OpImplCheckTest.checkPluginImplementation/Function=GenerateProposals_opset9_Device=CPU_Config=() +464:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gather_opset7_Device=CPU_Config=() +464:conformance/OpImplCheckTest.checkPluginImplementation/Function=Floor_opset1_Device=CPU_Config=() +464:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronPriorGridGenerator_opset6_Device=CPU_Config=() +463:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=362638bf065f1917d2b4dac3008a8f46f8f8d64a80d2442c1ad98f4fb943cff9_Device=CPU_Config=() +463:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=() +463:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=03e7b025285b1369ca39bcf887783a843fe06ea29f7f394efc8201d1b7ad3a09_Device=CPU_Config=() +463:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=7244cd4799e0eab987f823edc7d6038b76afa7585e4663278be826124c5596ed_Device=CPU_Config=() +463:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=c0bba39370340d37250a2107758b1374125465ee32317f5632f5bb64842c9d7a_Device=CPU_Config=() +463:conformance/OpImplCheckTest.checkPluginImplementation/Function=Greater_opset1_Device=CPU_Config=() +463:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingBagOffsetsSum_opset3_Device=CPU_Config=() +462:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=dynamic_IR=e306da3fedc4369302fb21159f2bbbe65849661eabe5bb83efdad3e83f64fd68_Device=CPU_Config=() +462:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=785551399ba4bb8eb76271bf698b3ca795b8388338f110843d5c78c03009625d_Device=CPU_Config=() +462:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=489201dc4d1a937b4387f1b7d01f75fa42ff02d7035d39ac6a7f56536b0d3a20_Device=CPU_Config=() +462:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=c8bb865a43a3782b3b85e05c3e86388fac07473697ed45a7b04f60010555a3c9_Device=CPU_Config=() +462:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=14f4dcbc8e714fdb791d15b62646db0da2cf647d431dd6ea044ca6976ef51753_Device=CPU_Config=() +462:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=5e7e2adae49fae3a376e9a5a971513a9b23b5fe4008ce51814e0fa1fd91f1f22_Device=CPU_Config=() +462:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceMin_opset1_Device=CPU_Config=() +462:conformance/OpImplCheckTest.checkPluginImplementation/Function=Broadcast_opset3_Device=CPU_Config=() +461:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=b5a1e5c47a0597ee9c9d0c0aca9909c596cbe71ebb069254460c2e97acfc1c0c_Device=CPU_Config=() +461:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e61665bc5590265246ab882bb55b9487e81412012ed98ac9cb16154bc8eddd17_Device=CPU_Config=() +461:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=be4d557c62a3a43e7f309d2276cd7549bf1976ca8593bf2be752e60c42237a19_Device=CPU_Config=() +461:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=486675b6412030beffb4209c326672af07d343d5e1bbca31b9bfeed3cc339e3d_Device=CPU_Config=() +461:conformance_Ceiling/ReadIRTest.ImportExport/Op=Ceiling.1_Type=f32_Shape=static_IR=1484c3d0a5a8b6d1daa002e27b07bb8ba0b5d83aae50b0a3b3bea08483815d55_Device=CPU_Config=() +461:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=cc13aaec2a2bbe9b760651d358622114b4b0a20cb106472bd8519f0fade61dcd_Device=CPU_Config=() +461:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=9b9521ed73100b54a3c5920107db944380157eea1b72f4e4d94f8e2ced1f2e4f_Device=CPU_Config=() +461:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=1e95665a92aa6efcc7e06d24fbe4cb2afa07d75374cea3ea928658a270ef489b_Device=CPU_Config=() +461:conformance/OpImplCheckTest.checkPluginImplementation/Function=AvgPool_opset14_Device=CPU_Config=() +460:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=739517c4c613063fc5ef734443f0a599400dec31cd5a56686735f3165b2dc2d0_Device=CPU_Config=() +460:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=5b466c4e4b53a5ea739df517da47f0764f9e31197b7d30fd9dabf17d1b33a489_Device=CPU_Config=() +460:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=f826a40d2d5d59d35300a911a15dfd8022c0fc486ecdc7f00c06a26f5dc44338_Device=CPU_Config=() +460:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=34404b0d0f956acd1827f417b44bc1cf1a085d6517d5d81a6c6d38ee27c745e7_Device=CPU_Config=() +460:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=0c6a844f626f6628628034d332ccb6d520e0447e4b616048c7efb516d0fd87bb_Device=CPU_Config=() +460:conformance/OpImplCheckTest.checkPluginImplementation/Function=HSwish_opset4_Device=CPU_Config=() +459:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a8f0d5db2a6af7cd4d166c066f3d987d7a25edbb3047fd26551e1b68d9c179d2_Device=CPU_Config=() +459:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=a937747c04b70351d3632aab91189200e2c0a69b6467ed856b7075885c54d83a_Device=CPU_Config=() +459:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=ea860537d420b0d1afe0ec9a10192912ec59d8f4ba01b27add362ce50fd6b380_Device=CPU_Config=() +459:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=09dd33f661a07095dc47e3e5205c9fc6dceda72526e79be0751c34823c7e7cf1_Device=CPU_Config=() +459:conformance_BatchNormInference/ReadIRTest.Inference/Op=BatchNormInference.5_Type=f32_Shape=static_IR=c602b01c85ee95a1d7deb1498c5f0494a5ee727ce8874d5beded8bf33631d0b4_Device=CPU_Config=() +459:conformance/OpImplCheckTest.checkPluginImplementation/Function=SoftSign_opset9_Device=CPU_Config=() +459:conformance/OpImplCheckTest.checkPluginImplementation/Function=MaxPool_opset14_Device=CPU_Config=() +458:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=() +458:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e61665bc5590265246ab882bb55b9487e81412012ed98ac9cb16154bc8eddd17_Device=CPU_Config=() +458:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=29624e785b9377dbf03b9aae46e7d0049e93a94655059ec37a0fe308ff7cb9a3_Device=CPU_Config=() +458:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=dynamic_IR=79cffe28ff617b42488d33b204b0f50bcf4e304c74d2a11820c830e091c6383e_Device=CPU_Config=() +458:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=34404b0d0f956acd1827f417b44bc1cf1a085d6517d5d81a6c6d38ee27c745e7_Device=CPU_Config=() +458:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sin_opset1_Device=CPU_Config=() +458:conformance/OpImplCheckTest.checkPluginImplementation/Function=Power_opset1_Device=CPU_Config=() +458:conformance/OpImplCheckTest.checkPluginImplementation/Function=MatMul_opset1_Device=CPU_Config=() +457:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=7b8eedb1c6be0db4a0c041ec3b04498d6dc68b326c35533ae16258e750f21e3f_Device=CPU_Config=() 457:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=c202ffc0e1805a36e48ee4b06d06b68a9f179eef00dc353a092a13818e8ebbe9_Device=CPU_Config=() -456:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f0af28fe49c157f5f62f72f0ab209c50aa07d97c65477217fde6e3a3d0dc98ef_Device=CPU_Config=() -456:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=0c491c1a451ad85717879e05678f7d1c85cc35d95b108087dd241b9b24b39ddc_Device=CPU_Config=() -456:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=8411c0432159fb60adefa760384515552240bc6220800a736556d7461765eb60_Device=CPU_Config=() -456:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=a0336bba08291ea34d6271c83816fb349d163fc5989171b07fe1bce50a2f3ea9_Device=CPU_Config=() -456:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=1c63f30ce7cb977ac945ee25eb97f3c472a81b999eacbcdd4b3bfd253f25cb51_Device=CPU_Config=() -455:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=8042d30c9796e8eca03cb2e3651f84b5167204aaf186ad08ad5f74a9b0a26b9d_Device=CPU_Config=() -455:conformance_ScatterUpdate/ReadIRTest.ImportExport/Op=ScatterUpdate.3_Type=i64_Shape=static_IR=f5ad439e65ed1e090d3d5744e9e5bcd9b8fed6ac6a191735cbb1cdd9af8bccf4_Device=CPU_Config=() -455:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=81eb5381e1d4d3dc7cf0d83a9cd787813d3267c99b31cc9a3cb0cf9b01727c0e_Device=CPU_Config=() -455:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=5bfbbb826bcb2c9e7b5364fcc5da23e737953150029c2ea7455ad4b09caaf01d_Device=CPU_Config=() -455:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=12b6ad1cd462f676c9add533f2fb2a5d98698e72fc5d0e6dc984abb27f54475d_Device=CPU_Config=() -455:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bfd899e1dd2a03f99d8b55d9fa5ab04c6e4576358c910e9bda97cf497f0418a4_Device=CPU_Config=() -455:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=64efb6dd46c36bec02b92148d178bc032417c8c2d999ff7b0a24ba08af365f91_Device=CPU_Config=() -454:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=16b3235d5271e534a1bc725f80e2bfcb837a1c6f144bcfe8211a3e5359644441_Device=CPU_Config=() -454:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=bca72a16df5bcf81d10dfbbb0e53aceb2a8a70ec94d4247d47333679de7214c5_Device=CPU_Config=() -454:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=6d5907929d59d1f99e85183238e29d6602c84721d099284dcb8900ae5fc3c45f_Device=CPU_Config=() -454:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=8ef34b5ce0dd0100a8efad53b3b71e87f76ed69496cb6f030e76478d7daddf69_Device=CPU_Config=() -453:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=87f3815fd73265960ef5910a3b03580b13e96d02784e159a0bf0ebc30bc911d5_Device=CPU_Config=() -453:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=73623637f6155bde0a4735dcd904e5b491d7d459bef5f8d3f66f02f9558937a1_Device=CPU_Config=() -453:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=4a64918e1c0c648268ad4a1c2147889b2578b4513693737ec2ea1c7ff81dbc52_Device=CPU_Config=() -453:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=a937747c04b70351d3632aab91189200e2c0a69b6467ed856b7075885c54d83a_Device=CPU_Config=() -452:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f89a1dfd0ef8b50a998962d5a4f4b54451ea4c533476a2e3d42c04e9e645afaa_Device=CPU_Config=() -452:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a0f8789f0f95beb6f28efc829bdf2f99d34a3e9397ad1a80d7831aaaf125b5eb_Device=CPU_Config=() -452:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0aa7024ee856fc832b1e639fbed60e1382c8e1b84f7cf2d33447f4bbd9ce75ec_Device=CPU_Config=() -452:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=644274eaea5cff1fa9976380a2c024a8510f88826d0c1a6036aea3b18e3ecd8e_Device=CPU_Config=() -452:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9c651eeba5c3e7b07a8cd0d4ba479fe8c5aaa2c4df9b18ab022e775ea01dd867_Device=CPU_Config=() -452:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=dynamic_IR=6a0218ea2e7eb0329e4915f2f6a7c215742d2469e868a4a8e43c683c2dddc01d_Device=CPU_Config=() -452:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=6ddb35aeda2a6cb63282d2fcf6503aa02135ad60e23c752280ef82aaf6a31191_Device=CPU_Config=() -451:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7efae3e9c1a0419670b3967f8b2dda53fb0200f946a3d529b8da235ee14690ff_Device=CPU_Config=() -451:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=1c9d69e1a85d03b8599961a8a1b90af7b3b2d43bc5c4f4a6b8d5da3c22166abd_Device=CPU_Config=() -450:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9aac77567d944de6632688fd3de80c0b3da1ee741da639897c2104d3121d690b_Device=CPU_Config=() -450:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=23f7f775455e615175f3122ce422ee96de019ca40fe603b5a4605d51f28210b1_Device=CPU_Config=() -450:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=28675c37d06426cf6895e7ffc15d6c212ef8be1b278fd199d1bfbd0678f825fa_Device=CPU_Config=() -450:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=120cc30794fe9c9d59dc9df6fadbb9791f3a6b99e4b9fdc06c5e01f494b05780_Device=CPU_Config=() -450:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=704412b992d55bf9ff00d823458e5d3b3a369e47b3eca3429fed94b87c8da554_Device=CPU_Config=() -450:conformance_Log/ReadIRTest.Inference/Op=Log.1_Type=f32_Shape=static_IR=038bd1e152575a3b8ca28bfe18fdcc9cbf19c9489e7bb831b9d5f56f7499cb7c_Device=CPU_Config=() -450:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=753b524e2aad8fde7e7206fa8c3e7ca15c52c49f22f41d48cfb6b4d814cb40af_Device=CPU_Config=() -449:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=67ed6a8048424f4e44f40c542faf7a2a2d2419e81aa982fe32a054af05caf309_Device=CPU_Config=() -449:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=6e53e1fedd57631f3ec70d6825d8d1029ac95905b82b6bef7fd44ba87373e9c6_Device=CPU_Config=() -449:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=d93633fac99f9472435ede6fcdb9c72475b68bf1352d58b33e8cbdf9ca74ac50_Device=CPU_Config=() -449:conformance_ROIPooling/ReadIRTest.ImportExport/Op=ROIPooling.2_Type=f32_Shape=static_IR=556c6863ca3b12d255c4c81d92b4573203f02c5588e064fb22dd4aa23c8283c6_Device=CPU_Config=() -449:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=e1a894c49294c6930cb8f8c857ec745fa2c6d18cc3607389c89af4d13df4e411_Device=CPU_Config=() -449:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0a2311ddc09b949cceb73fd0e09bbdcc2932c2635fee3a2c411bec27a30e9439_Device=CPU_Config=() -448:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4df4ab698c70278594efe8b4349a4c99c8b2ab7c4ee0182c5a4b7673da922ad6_Device=CPU_Config=() -448:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=97f8a2367c5590d5fe7e405d32ec48e5318a6cb3c0862f2b0e8705a7842e8105_Device=CPU_Config=() -448:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0e58762b5cd9926391cba6f63db3c7db49285b900ad0abc93b4d05d4baec800c_Device=CPU_Config=() -448:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a7ad8306fe632a2d0c45a492ad2d21dbe40f2f9ea55074d602beb6f8dde17982_Device=CPU_Config=() -448:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=7b2199d0ea56102a7c6737be2334b9717ee292c13cdb692d07fddfd173ea5b82_Device=CPU_Config=() -447:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=b08690e29e0249d5a6a30f2ad886ec714067df994bc4d8cbd82d0d02af6335bf_Device=CPU_Config=() -447:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f99caac2fbfafe61a686cc29c0df0779eae1a0a1826f5bcb820048ec3c148207_Device=CPU_Config=() -447:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=7ad5da9c461223f21afd023e08220eaed788598f50e144e45fcdf3466c0810a3_Device=CPU_Config=() -447:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f3b3afbedffce0d70b40d78f882a0061ba05e26e385c37cf902aec88ea43a649_Device=CPU_Config=() -447:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=79a6d2a402cdd74cf1277a57ff95b71d61384da394ad2a4d9ebcf422eb5c3258_Device=CPU_Config=() -447:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=593116ea16692c8f5a8994c0562c47e1c627f9088c519b752a635a7d91973085_Device=CPU_Config=() -447:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseXor_opset13_Device=CPU_Config=() -446:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f2685b40efb789012e69252fa0fe30803c68be724a52dbcda9b2cb796138ea57_Device=CPU_Config=() -446:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=b61800abac107b248c29df7ba04a73c91d490782b1da46164c1b7d2f8cec3cdf_Device=CPU_Config=() -446:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f43df065734a36674b3fdc7a47fddd1cfa5c1b36bf73e7de86a100c645fbc7d3_Device=CPU_Config=() -446:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=dynamic_IR=6b70264ed3eb3831e0e034230813ce1a1e71c157a302822b56335e587bd200b3_Device=CPU_Config=() -445:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=c4d1a1fdd0a336620be37a8ce7578ca0dd0c74f89fdb32ee86e7004792aa8445_Device=CPU_Config=() -445:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=d294c71f3796d2e2b88f819f6512ed03942eab440681a5bc5b092e5a34192107_Device=CPU_Config=() -444:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e86061c75b7e9a65644e82de6b8fb2a532ebdfb302f46f378b6ff20af8d1d14b_Device=CPU_Config=() -444:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=6ab37e1d52328b5ce1204cfe13977b06dcfabeb4acff9821d65ffc91bd3cf09d_Device=CPU_Config=() -444:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=5aa10dbbcee8d7434796180d5fbe8f0a954b772c441c8d6046439c615d3b9011_Device=CPU_Config=() -444:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=99183013393075553f5cd30818ccd603ff5d3e9e71dd8f42ced0df2377280729_Device=CPU_Config=() -444:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=21f786ad25c17eff66f16501d160439b96636a7d5d8512c1bd3db5fb5d5e6987_Device=CPU_Config=() -444:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fb83c1c4a2ce0a8860479916f23f3961a5c20481e62de79390573dd7859c09f0_Device=CPU_Config=() -444:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7ab51e173b82572bfb29cac5dfdc326e3689e466c68cf91590dcbdddf1f530de_Device=CPU_Config=() -444:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=8337ad383956ad96ca95f4aeb967e05c694fe586b4ed6e46547e3ffa0217c59b_Device=CPU_Config=() -443:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=abefab3b34ee5f7da347f3c86a1a0b7b17617de416051dc18c3aee80862c3000_Device=CPU_Config=() -443:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=3d37166487c5c52af657343f8fa10903efc7d580d5b370a519a0ccfbf6fc56bf_Device=CPU_Config=() -443:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=4e6db028c1ff414e411bc09accf3b7c20cf81e530c903e14586eaad4c21fa111_Device=CPU_Config=() -443:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6f2159bf315f062962fe87512c15ed5cacf09f898397a92b690c32caf147e50e_Device=CPU_Config=() -442:conformance_Round/ReadIRTest.Inference/Op=Round.5_Type=f32_Shape=static_IR=f4cc9554ddbd189f18575e3a80afe6e8f8bce613dc8852a48d4171ab6916e087_Device=CPU_Config=() -442:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=8c5831a53b504e86ce404e5a521921ef86bf4e130e79819c1abdb0e88a6543c5_Device=CPU_Config=() -442:conformance_NonMaxSuppression/ReadIRTest.Inference/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=() -442:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6964f870fd6bf44d1d5ee5925eee8892230b8928aeee1966db73b6c4fcd5acf8_Device=CPU_Config=() -442:conformance_Clamp/ReadIRTest.Inference/Op=Clamp.1_Type=f32_Shape=static_IR=0662f4c4f222a79755532ac9eed43118b2ebd0faf0fbb9b400f9047ca1071b5f_Device=CPU_Config=() -441:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4ef9d8687805658001fa7650e660620d74bab09868b356603c268bc8cdf7a5c7_Device=CPU_Config=() -441:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=77316b4db1518258304408714d1b57a023070cefb5c1b141b6721028258f5744_Device=CPU_Config=() -441:conformance_IDFT/ReadIRTest.QueryModel/Op=IDFT.7_Type=f32_Shape=static_IR=cf47311b142dabf10271ebf5c2e359455d9bcea82d95ad2a1a2d58915c77bb16_Device=CPU_Config=() -441:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=dynamic_IR=50ebc9636f3321fe9bc87cbfe301c8ca3ea27f56cf429c983ceed6ae63bb3885_Device=CPU_Config=() -441:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=d76cd25e23d34af8e58f6447a49a50d66cc28592d3432577c240e75e00d5a765_Device=CPU_Config=() -441:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=c0c33bc628fffda062b4f013c7d41d0f9080f14f41e084ac547099384a9b3d20_Device=CPU_Config=() -440:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1d52baa348f922bf85866fbfaa488c1ca33e01f0b79bd6a25fb430e8b7fc8b06_Device=CPU_Config=() -440:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=90f981f067c23b4fd3d2df838af8e6d11ae1c5e9465b566501628c7f3d63674d_Device=CPU_Config=() -440:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=19d36388bdf9535fef89243d6dfce670fc91377062ed4b3095ea55b88e4f296a_Device=CPU_Config=() -440:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=c56cf3dc39ed0072f3e5a8cadd1502fef904b32de3b7760ee4c6964c0e505ac9_Device=CPU_Config=() -439:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5a82d5761e70d13623af2cc6a6eab20a7a0657ac28f38223e34b63d6cbc1224b_Device=CPU_Config=() -439:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=5f8b64ad8dd9ccd202ae8d5080ce166fe9f47b909e803da49546dbffdfb4ab3d_Device=CPU_Config=() -439:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=4e14d87b7667a7900d4427ec46c72eb3c7bfd2e3d86e5bdf92eb2485059b4951_Device=CPU_Config=() -439:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=48a273073ced3efa39d01e5ce40c30b2901e8a3dff0b414911282b8fdfc0b09f_Device=CPU_Config=() -438:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.1_Type=i64_Shape=dynamic_IR=45a9a897d75b175e3d805e74ec09322789564e0c0e8d9535724f262a9f534572_Device=CPU_Config=() -438:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=d81ef130a76622c79592b0b42acf5cd6dd357ccec28958dec6eb02a654beb9ab_Device=CPU_Config=() -437:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f166c58732107cb0c82859af62b8fc0d3d144468ab66ff4615a1eb4bd325d3c4_Device=CPU_Config=() -437:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=b6e3f37ddee609d492f47b36b8fe937ee401d01e6d43d7e0b7c06d1a1781b501_Device=CPU_Config=() -437:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=e020cc29b6ec76cfac0e0b52ed3024458fbeb567c4fe9932eb5257e3ade79b95_Device=CPU_Config=() -437:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=7b2199d0ea56102a7c6737be2334b9717ee292c13cdb692d07fddfd173ea5b82_Device=CPU_Config=() -436:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6ea8e16cab0d6f60ef13562706c941f5ba3c90d3a65447ab3844e100cec5a0ad_Device=CPU_Config=() -436:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3421ca968a9f4061cea0492ac3920fe1a29fb35093314cbb56a78bbb136d8fc7_Device=CPU_Config=() -436:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=952ad9af4561d61157cc5e73bbc5608bf8cbea1473c52a566ad1ae7252bcb35f_Device=CPU_Config=() -436:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f9b090cbcb19663630a1490fe18357b752e430ad793c0e3aaabedcb74ab64934_Device=CPU_Config=() -436:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2386bb6412e51aa72e9426e12f9f2b2646e7074413b33fff8d95dde141ee12fc_Device=CPU_Config=() -436:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=9c6d5cdaf19c92d1f994e4ae6cfdecf5a9ff04e47a2e0e68f3a08ec8f6e74479_Device=CPU_Config=() -436:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=a3d8e1343e43c666358304b530278c73bc7c52a0d7fff38977154b6f7c456731_Device=CPU_Config=() -435:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=21534d0488c3f7c8bd40bc81476832e866000c97ee6892359826c7877905d733_Device=CPU_Config=() -435:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=f8b14e90b051624d56678dbe68f15e6db94e22878b22914d0be241047d1a3783_Device=CPU_Config=() -435:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=b81d993247e604272e6df01b8c4ba016be7f60263c892e8469deef67a8a6afba_Device=CPU_Config=() -435:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=() -435:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8fdd77d8381b78b82c04360bc3f05a358bd690bd8204e2cdaa2c0a65bff61a41_Device=CPU_Config=() -435:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=31e75a7408a46928e1a3a8babe3da21bccc6d442f87291c0b2bf57b29e18face_Device=CPU_Config=() -435:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1b59316585dcbdfdbef9fd71e2681207498cc867a2285eff20d125c4fca0502c_Device=CPU_Config=() -435:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=efeea353bf41d0aac1f5400e451346d6cb407610566018f368726328cafca221_Device=CPU_Config=() -434:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=86a9c310cdd99d5c2fc0b7239080c9cff89efd37662cb38da28bc9e2a1471d7a_Device=CPU_Config=() -434:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=cbfc33348aff4daf15fb7926884243c7ffe38aa29e60eceda90fa9b8aadad5b1_Device=CPU_Config=() -434:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMSequence_opset1_Device=CPU_Config=() -433:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=41bcf70f8013164bdfeb7e348c05e6d43d9a1afc49087c49745679bc3aaf1e10_Device=CPU_Config=() -433:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=9ec0516350dc25e0dff22b12b65f761cd4e2744881c1f356f9ab50680eee1a69_Device=CPU_Config=() -432:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6e9fb2accb692c69349a88158442052e6350143ca7dc28f2525d8e8df29f8c78_Device=CPU_Config=() -432:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5b6503944921be5fa3feb0b7647c6715465af16702c645dec4e2f2556d8d679c_Device=CPU_Config=() -432:conformance_HSwish/ReadIRTest.ImportExport/Op=HSwish.4_Type=f32_Shape=static_IR=ce108d9befa5ee87b0161e969c5ac986c176e468ecae9f66895cdc4fc6bad940_Device=CPU_Config=() -432:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c1852c534b8b95bf1a9aa2771decf2368fa095c5f5688d38ab9ce0bd86152a19_Device=CPU_Config=() -432:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7754523e2d3739481e051eb21a4347f2d157e94db3c37d47f0006ecd8d77d512_Device=CPU_Config=() -432:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=dynamic_IR=1af860b153ea667f413c7de4c98752d48ed8ac1fc7f90889009a2916e2ab1026_Device=CPU_Config=() -432:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=86a9c310cdd99d5c2fc0b7239080c9cff89efd37662cb38da28bc9e2a1471d7a_Device=CPU_Config=() -432:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=80a8c850ad3eec3e8fd00d2ac09695a0f87a10e4b80b9022f49ddcd9805eb2d1_Device=CPU_Config=() -432:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=f2995592ad35fbaf52873e0180081397916db8165b9596166e8d449e44b57169_Device=CPU_Config=() -431:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=7df296e0e156bb36cb643a292802f9db374c77035c6a05ee4a865fbe2c6ef92b_Device=CPU_Config=() -431:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a46f51b7498c921515a53b67480ec4d413ed43ff809e1fa6a4deb7365f4a0460_Device=CPU_Config=() -430:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=392b855febfc39fd1b2a9fa43270f58bae53e0d210525e8700edc15a10d28d33_Device=CPU_Config=() -430:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=57c57d85bad2b76d3d65d88baf2b3677dca6e5d534121e87efd618efbe5b1547_Device=CPU_Config=() -430:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=0832e6deae4ceb25b92cdfa532fb5d5fadfe7fd7a00b79f630ddb5bc011986ab_Device=CPU_Config=() -430:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=72373e9c2bc4cdf2f0aa0a5d14e30ed1a5e0545d9a96f4ab675f3b9dc69d8cf4_Device=CPU_Config=() -430:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseOr_opset13_Device=CPU_Config=() -429:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=526afcc4dff58aaa019466b0440b94dbd2d5f14c060d47b8ec40183deafecd83_Device=CPU_Config=() -429:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=8216637727ccef527454bfdea7ab22ccd4e5e29709494bf96dde5af3b4a7eaaf_Device=CPU_Config=() -429:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=fced0ff647e4ea9a4b1673016b017f68ed75cdc778cad156dbd6cc379bb815f9_Device=CPU_Config=() -428:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=a7b79789ba2466daa67ce8610753fbd89a2ca372d65e2326802c24cce03f795f_Device=CPU_Config=() -428:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=876a77d1e2efb758a87bce1dd2fe35cd8e455c6f3dd7cd2bed8e10504c426de4_Device=CPU_Config=() -428:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c161ff64d4c506fdbe44d0ee76042f958f5dfce778833653628a026de01a3f9f_Device=CPU_Config=() -428:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b78ffc69401084763d529e2aee12f9b9793bc92be3eca3df2a97730b9a252ce3_Device=CPU_Config=() -428:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=d76cd25e23d34af8e58f6447a49a50d66cc28592d3432577c240e75e00d5a765_Device=CPU_Config=() -428:conformance/OpImplCheckTest.checkPluginImplementation/Function=Assign_opset6_Device=CPU_Config=() -427:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=a94e0bbcae35d7cb33efba2c6df3275f7bca8520ddb37eeeab81829906fc8964_Device=CPU_Config=() -427:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=a3de81c04a0e7d5cab275045415ab4c294ed3270588c2ef704ab6db5514ed0dc_Device=CPU_Config=() -427:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b04f836c4ed5b0403f4b7fdf9c5cb8d11ff9f65105ab9bde39f80191a65f7f17_Device=CPU_Config=() -427:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=46282ba6f0eb5aac6acc1e114a2408cc301300a027c6d7a05691928b5e6dd9dd_Device=CPU_Config=() -427:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=99fbf009fb26eae6bfc372a5b3d9bef89d6f82e5fa45c62cc5ece995bcc71079_Device=CPU_Config=() -426:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=53da49d7aaa81cbb7c3a3dbc8ea938bbffabda14bd106fa6c2b6abe244ba5cda_Device=CPU_Config=() -426:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=b729ddf6b689006067cfce88ec7d9e89268dd6cd904e4596717016541632b13b_Device=CPU_Config=() -426:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9cb8bb36dacdb562fddf77e93890fba560c6cdf038921e057e21f3e5e458c88e_Device=CPU_Config=() -426:conformance/OpImplCheckTest.checkPluginImplementation/Function=SpaceToDepth_opset1_Device=CPU_Config=() -425:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=ace54c326bc8255cd741eec12762e4d8f645fe93d50c037effce893745f8fdb5_Device=CPU_Config=() -425:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=933c6450f6856b32e879034662cf60eca53970c10106f8a11eb925e5621042e9_Device=CPU_Config=() -425:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=dynamic_IR=5c05bbc013fc857a8f2b340df778f3ad5bdbc1b7273cf41b23d6da410205c612_Device=CPU_Config=() -425:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b0a418fb8ec50f25147079b3aef1b13095ea626a9e52a643600c39972982ff9c_Device=CPU_Config=() -424:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=63de0838ea26e3575f49700f73fffb0d3415ab68b29b1a1da690b84f7a034822_Device=CPU_Config=() -424:conformance_ScatterUpdate/ReadIRTest.ImportExport/Op=ScatterUpdate.3_Type=i64_Shape=static_IR=b5f5ffd783aa251498c2011f19a63c1d68991e426384ef9728bc0b46587faa2f_Device=CPU_Config=() -424:conformance_ReduceMax/ReadIRTest.ImportExport/Op=ReduceMax.1_Type=f32_Shape=static_IR=590a910a27283b92d7a4650bba546a3bec08a6ded604bbe8523ab3c6d734c70b_Device=CPU_Config=() -424:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.1_Type=f32_Shape=static_IR=f735a44db0a337a22f5ebed052a5718168765287ff4e0eca961c3f9fd68586c0_Device=CPU_Config=() -424:conformance_Negative/ReadIRTest.QueryModel/Op=Negative.1_Type=f32_Shape=static_IR=c29451ffff103b5e965a1bbea7994ef6da6394060855ee071b9e7a3a4702141f_Device=CPU_Config=() -424:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=14f550bd7e83223ffbf501918141376e6a144484865f03c9768fe9da49a9f06f_Device=CPU_Config=() -424:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0c5ac67592b69e8c2b7acbae7a0f877cfed184c572d2fae09eb8fa629e86eeb1_Device=CPU_Config=() -423:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=45ce409a7078c7e732a092633cee36d6a0aa80fa9249cc98dce44e5b4bfc1693_Device=CPU_Config=() -423:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=004b6fd9b060324a42aad296dcb21f5b7eb7586c082f98d23f25a6d882f70c14_Device=CPU_Config=() -423:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=b050ebcbd31acbbc43d657d87a54415e0e52d3e91fa95b57aa1dd0451a5bf50f_Device=CPU_Config=() -423:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=b35fe21330bf6e76f55ad27b71fb0422a737d0c400255fd6cf2cdb3252d3617f_Device=CPU_Config=() -422:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=() -422:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=() -422:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1bae1a851b5bf95921ad7666e48803dae416315a20a3ddbcc1c81243cb5bdede_Device=CPU_Config=() -422:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=u8_Shape=dynamic_IR=5de1e1eb337f4eff857dccbc075ec7079425a50de3096d4f81d25f0118acc6fd_Device=CPU_Config=() -422:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=223a34e46344a0dff7f35a637c9bd08e2a76a552ca87e5bf0134c9fc6d6be41d_Device=CPU_Config=() -422:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=() -422:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b91f26a0b7b56224c507de772631016119cd0bc3fd49527013f571e2db477402_Device=CPU_Config=() -422:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=b4fecfa9b5d565a02a9f0d0ed19a11127ea9c8c4e70a0e5f7b920701e0665d51_Device=CPU_Config=() -422:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=1d8577d7a316c5a2726f3be79b4f8b22d6dccdd5491a4c7896a7c9de37330e77_Device=CPU_Config=() -421:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=6e67522f2df32ac8e237fd4de148d082f3c55e6c31ace80cffeaef784dfe75a0_Device=CPU_Config=() -421:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=81eb5381e1d4d3dc7cf0d83a9cd787813d3267c99b31cc9a3cb0cf9b01727c0e_Device=CPU_Config=() -421:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=() -421:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4bedf955c6ec574258a05f59e5397225e1360ba68ea49d4fe105d6a62ccb3e97_Device=CPU_Config=() -421:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=1f29402ea664e850ea05d5f2e500f087a6165f1f4c9b3e5102b5509c020f0f6d_Device=CPU_Config=() -420:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=86d8d42c30e423e801b5d4d832f87cd6837bf9feb3c546f5bf87e04f842a04f1_Device=CPU_Config=() -420:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=c307ba8fc5f5d81037e40e46cb8ce1057d0bab7433138943596e5b21bb84221e_Device=CPU_Config=() -420:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=6119edc6e1f969159ce54e6ff4451d96db51485b54fae625a972035414c704ef_Device=CPU_Config=() -420:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=95884fb8d74cae609a67146ef94a84eadda8f3bd6369a9cb465bc413264a1d0a_Device=CPU_Config=() -420:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c0413244803edff103b95dbbcab27b2c714740372ba215264371a9474355a8c4_Device=CPU_Config=() -420:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8f731757a7c32fa8e4d602d7197af81a1a82ea228ec05f4baeae7c59eba11f2b_Device=CPU_Config=() -420:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=4ccf5cecf790d27400fb95526a993f8a1a28cd4f3120b897cf45bbe78f087ab2_Device=CPU_Config=() -420:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=5e7e2adae49fae3a376e9a5a971513a9b23b5fe4008ce51814e0fa1fd91f1f22_Device=CPU_Config=() -420:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=c8bb865a43a3782b3b85e05c3e86388fac07473697ed45a7b04f60010555a3c9_Device=CPU_Config=() -419:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d77f317dd01a80955f901d0da2930aa1f82531848f4bf22d839c60a84941e6c4_Device=CPU_Config=() -419:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=08b46b9b2881764fde87811d2462a361d75c30fcec74f631f116f010953daced_Device=CPU_Config=() -419:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=24e44f75d91fe4e7e28db6c93870a47d536abeb87240841ff5b7e74b40189e42_Device=CPU_Config=() -419:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=ba4f511cc4a0870c64cc5027fa39b2bf91a6e7f39ea36cd43a693eb59de6d836_Device=CPU_Config=() -419:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2ef3273b8c144dedd6cc2d2b8c2d2921d999fa286b10d90aa796fa188dc52cef_Device=CPU_Config=() -418:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a9c40d7a1ada834400ffbdff779b9970c83bd576891dfa7f637182cadf9e9681_Device=CPU_Config=() -418:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=28cabba0fd0acde452552a362925344e8cd8c5af033419d83041bf26b1d14d69_Device=CPU_Config=() -418:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6aff57130da7904e5d2300c4962f104d31c704872d5c33bbda4bb38efc34d563_Device=CPU_Config=() -418:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=() -418:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3a3886301663fd20cf2c8c0f74c11d80dfe8b74ac39e41652f0eac1ec9bfa2df_Device=CPU_Config=() -418:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=11477a6d571446d4e895d1cc6b0155c36606963d5c4a3a0a516802063a60906f_Device=CPU_Config=() -417:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=776b4b6d6b102654bbc08df901869e4d16af505a5dff7f2d27686874bd20ccc1_Device=CPU_Config=() -417:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5f18fb02adfd683f379dd5a15d38f01cf744e6940754f6a40e2646a1d9c97be8_Device=CPU_Config=() -417:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=d1d0510ce6d862a5512bf4c5c588f84548f1aed0226eca6850b5e2d470a5ee84_Device=CPU_Config=() -417:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=461bf15d226b7ee3cbdcbc8cf1806e98267c5f14f0aef49dfb9de094f56347b7_Device=CPU_Config=() -417:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=00d924b3557896a41b0be32897f7b7293fcc44d79a285e91695a5fd2f29f3b8c_Device=CPU_Config=() -417:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=08393711dca608a5beec54493fa162068673eb746a6223b6dab2640d411570c0_Device=CPU_Config=() -417:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=d50dd7c19583071293118e8b98f2bc749ef3e34ab8eb0149138e6b9fe49a153c_Device=CPU_Config=() -417:conformance_LSTMSequence/ReadIRTest.ImportExport/Op=LSTMSequence.5_Type=f32_Shape=static_IR=b8e32896d2ab304fb4fdca3924e0110852da92be25307f30709cd7d897c2f038_Device=CPU_Config=() -417:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=03e7b025285b1369ca39bcf887783a843fe06ea29f7f394efc8201d1b7ad3a09_Device=CPU_Config=() -417:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=586094b4ff6617c08c87a53c7be1ca26aae40657c8d964d81eda731dbb27e848_Device=CPU_Config=() -416:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c5637c5151109c002830514b8b1450092dc52df14146ecee467dc54469a77718_Device=CPU_Config=() -416:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=e8df0b3ab9e127c1d37881f4c250ca0fd0dd2ec822cd24bf95e7860484fe9b8a_Device=CPU_Config=() -416:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=9f4964a8b6440cdec94781121b408df16f0ef2283b0355583eb934b3cd2bcb66_Device=CPU_Config=() -416:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=a449aa561efb222cad1a414ee87443f9fec0e5c2f6220f6a57b6705c9ef26cd6_Device=CPU_Config=() -416:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=7f37f31081476643f5c279fddc3d25eae22d909730b4aca0211aa70fdd572843_Device=CPU_Config=() -416:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=41c94561e79611e27aaf339205962d4967188b385d68c169b2bf4557173005d7_Device=CPU_Config=() -416:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=ac87d885a27bfd348d3f9fad5a03680b73b7198fad17dfdf08675e6e3d239ca3_Device=CPU_Config=() -416:conformance_GroupNormalization/ReadIRTest.ImportExport/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=() -416:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b38f11a07d752c83a5e4fc709d5b78fe9a40ef3394f4b617a30df29c21640338_Device=CPU_Config=() -416:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=d76cd25e23d34af8e58f6447a49a50d66cc28592d3432577c240e75e00d5a765_Device=CPU_Config=() -415:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f2293320b7533e95bf000229d2458244fb9af573cd737ca0088a00674df1ac52_Device=CPU_Config=() -415:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=aa6c3816ce7ce49f40be5edbe957468e80910a8eb5a3956f54d89fdf7c264b44_Device=CPU_Config=() -415:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fb9febc1b0984c7d6887460d058a75a9444bd1ade793c5b945c9b79ad2c63e46_Device=CPU_Config=() -415:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e22e40a4f300567612f963b17707be4de09093cb9a248aed62af594e7986f7dc_Device=CPU_Config=() -415:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=76ef553ce6e6b782a200e030fcb744ed737623fc3a8c9c8faeb0e05691c5a55c_Device=CPU_Config=() -415:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=13c78a6d628bed4392d2577f132f924d9e17a7e29a2171dafebc0a596d2ade04_Device=CPU_Config=() -415:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=5b466c4e4b53a5ea739df517da47f0764f9e31197b7d30fd9dabf17d1b33a489_Device=CPU_Config=() -414:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4104a7840dc96c214be896cac75911b70baebb902a42a26f12b281bc2cd87318_Device=CPU_Config=() -414:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3e1e1cd684c1bcfcf06febedcb4eb0f4f62b5c0920098fa0715c828e9a9761a7_Device=CPU_Config=() -414:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3147f462ceda9b383de633ac08d6014a7779e74b169d3745990fa2b2799b1dbd_Device=CPU_Config=() -414:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=a5dc3f8dd6385eb7f6d4052af82e27b7af7e8a58bdcb6092ec79ea3087f141c6_Device=CPU_Config=() -414:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=8973f2f4c2be5d0ed57c94e1aed24bf809e51854c03c2abd73ea37ef7221d328_Device=CPU_Config=() -414:conformance_ROIAlign/ReadIRTest.ImportExport/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=() -414:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=() -414:conformance_HSwish/ReadIRTest.ImportExport/Op=HSwish.4_Type=f32_Shape=static_IR=1c38a17a13c5c03cfc1eeb147ca2474debea05ae1d6f2357ce40ce23552286fa_Device=CPU_Config=() -414:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9033954b258cdfa9fa858317ee4588b8c92cc946d7eb305bf130d3ca8ee0f1fe_Device=CPU_Config=() -414:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e8a26a33d6dbe0bb560820295fb6b8aafc3da0d2b78e29199d2f09e952722efe_Device=CPU_Config=() -414:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=5df86bdcc255998a0b5b18e64e3059afb2c80e37b5695208d04a6fc0f1410b50_Device=CPU_Config=() -413:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=910dee337e395f94d7673f664a3e58647ead8bcedf50ea1439250bdfe8da25dc_Device=CPU_Config=() -413:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=15995a372d69998eb6a001f53486201fa9bbc89fb608c7d2a447203a404713ea_Device=CPU_Config=() -413:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d13d862f7b8306948676388381950639ef433dcc4e38f5a6fa8d50575d1aa814_Device=CPU_Config=() -413:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a7242174afe3f7c2e95d31cd14d56ceb0a566e2e8d65ba97e07d004200f4f517_Device=CPU_Config=() -413:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fe70e0ee3f24f0bfe4391da7797647a01f66fcb109b481ca859c9f8f7dc7b411_Device=CPU_Config=() -413:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=42f3f3a5b34aacb93147f9c77ad5709cf7436ae8cad9318434a9b6ff6852982d_Device=CPU_Config=() -413:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=234277ecce31161bea52cf4aa2a37aa8cd43f1bbeed281a79a6aa1d07368872c_Device=CPU_Config=() -413:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=51d309244d7c90039cf86929d62320f5e5c5df8b1390c6b1241d8389eb6914e2_Device=CPU_Config=() -412:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9257d329b4cc9eff8545270d1693734adac9ac4ee44dcbaa21c774287e84aadd_Device=CPU_Config=() -412:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b339277c7465442a5163600e784319030de12cab4005f43c0b903bcd0c46e87f_Device=CPU_Config=() -412:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=1e5127a9c21ad1ccabe67dd1f1e28a3730c09ba294ef1f9fc001c6dcd723ec62_Device=CPU_Config=() -412:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=6b2c79edda9cc9cce61c98552d6a0d3a3555c9ccac3a56c6692f536a0abdb61e_Device=CPU_Config=() -412:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0fe2c94f8e2ed43edc0deb92ffe044a089c6920f886dcf6985ee910e7a4ffaed_Device=CPU_Config=() -412:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=b35fe21330bf6e76f55ad27b71fb0422a737d0c400255fd6cf2cdb3252d3617f_Device=CPU_Config=() -412:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=899cf50d8feefa9c5e02f6fe88b79e66b59c4a53478755d51b3e82570683613b_Device=CPU_Config=() -412:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=b2dd13c363e41fef66b0dcc3e21e77b9a97e413c1c89f8c8a53179b05f01c2cd_Device=CPU_Config=() -411:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ed872c2ef0d35af97e7f9be84d83eee6d42f2fb279b71f4feaa1aecefb450a28_Device=CPU_Config=() -411:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=d04bc06efa76ef2937aa1539893ec9c79ac61c765cb50cd4a26dbf5586bfc904_Device=CPU_Config=() -411:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=3801fd5b86bf772977c131734d8356c8dfa41b9056091937473be600e332fbee_Device=CPU_Config=() -411:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=335e78458fe959fc5a9669069890bcc67c1f1eabf21dbfb6011cc80b8322e9c0_Device=CPU_Config=() -411:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=b6417017678573faaf72824d1bec40bcccd73ae0007aef24b089dc3743276b14_Device=CPU_Config=() -411:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0256d48640841a9233553afa85e34dca797e6b5eedbd772f606c1a0e6f8e91a1_Device=CPU_Config=() -411:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=d435aa8d2d045d69b2d187147f90c879205f27346ac991765ba97bd47d4fe0f6_Device=CPU_Config=() -410:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=ddacee38f2bf3dd45ddd36ba236440ae28b9737487e0fb186c2b9777c0b557e9_Device=CPU_Config=() -410:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=02f589480d24784ece323ba30be856c7cc718151d3588f683ef4825a407749ac_Device=CPU_Config=() -409:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d27e8ca8280dc9219f4b76a2c8f47cf526b32a58710126c7549e2c04026944de_Device=CPU_Config=() -409:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=992d8967c619d96c75985952485fcd79b943ac5e71c40457eafad4b71bf56a4a_Device=CPU_Config=() -409:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=i64_Shape=static_IR=d106f0cba8d8311b75f6074c099f45e10400c0829fdd1826292b1310471076cb_Device=CPU_Config=() -409:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=77b3b21d35d3742f7abc1097b99d510453f42ebe921681685fbc457d2fa9912a_Device=CPU_Config=() -409:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=424814fbe4a3ba7a49c506f11509c035212fbdf4ef44fb2bc708c5f201e4e1ec_Device=CPU_Config=() -409:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=4c3b0cda20bf6b3c574eaefbce21b9b2b0ed92fa1b37c32af252b111b6466d0e_Device=CPU_Config=() -409:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6624c22e3b5d72c4e8d21df59af6f3759fa4d8fa68f2b5f3f92a98d6a943d0b4_Device=CPU_Config=() -409:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=577ff3f9c8d226d1899056073c0223ae2d81dcc940c5fef8b9ce9cf63931e9e2_Device=CPU_Config=() -409:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=150b1e03f5e8abf76f88e68ae56a3afc3cb3ae110fcb12af35192aaf93b20f5b_Device=CPU_Config=() -409:conformance/OpImplCheckTest.checkPluginImplementation/Function=PSROIPooling_opset1_Device=CPU_Config=() -408:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=bf802641cd9b20a23b73202f401f4b32903ac7083d0ac7026098cfb4311b35c5_Device=CPU_Config=() -408:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=28e31d83986a1435f11ba6355b98472025fcf2c3c6e090103283d9486356b5de_Device=CPU_Config=() -408:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=8c5831a53b504e86ce404e5a521921ef86bf4e130e79819c1abdb0e88a6543c5_Device=CPU_Config=() -408:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=c55846f7a08af86fb1c914c925433852fd4bc735f671c87e965a6db9b6971708_Device=CPU_Config=() -408:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=cb67c5d0b8712ebac00fe4169f0cad2e0a8c71d7f9603d5d2ce6ff6dd6bc055e_Device=CPU_Config=() -408:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9c63b760d92c46d2ba731cb9edc4cf19a96848e4f3c354797f10a7a1bb9edf8c_Device=CPU_Config=() -408:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=87a966d3d3b90cb32db3454c5dfb2f67af86b68a5e45fa1c5f4a75c3b5cb452b_Device=CPU_Config=() -408:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=fda1f84f5e911136f8daaf4fcebfb989f3216c066ddc1cae578882a41ca0f5bf_Device=CPU_Config=() -408:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e365913541918ae265939740fd9930d4f5d919773ce47a4e896a264bd8f86460_Device=CPU_Config=() -408:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=68ae288409f3972b9f52f4ea76573a81d764758059915949e76dc5f20e6952bf_Device=CPU_Config=() -408:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=ea860537d420b0d1afe0ec9a10192912ec59d8f4ba01b27add362ce50fd6b380_Device=CPU_Config=() -407:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8a5bf21112b4a458a3323e615dfce41a8627c89ac692e1d568786634667849ab_Device=CPU_Config=() -407:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=990cce0ce92df99ae74ad8840f7b89d1c48c0044deb9cb71619b44a565eed911_Device=CPU_Config=() -407:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8596cca11141e34e75c884b1be9a75be19663caf4c0b1b4275f6035a73d62e_Device=CPU_Config=() -407:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=46b077d7466eecbadbb7ceba5ed90724db3d9e216d22171f5dee02e44b9a5377_Device=CPU_Config=() -407:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=c18d3d2fd8001cb07daaa5000258b36352807e3e81999d2d80a668e4d6add085_Device=CPU_Config=() -407:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=static_IR=f9377788ac0fd1ad0a7f51d16543722cb5acb69640745df17d9f41f5d1d0b544_Device=CPU_Config=() -407:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=f3d84b4cb7f301c6b64c64927dd1e8c20e144671419843ed3d20692f0773445c_Device=CPU_Config=() -406:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1837f66989053233e19b617ab462b5c608981c0be175b57a2366fd41ca1a9fdb_Device=CPU_Config=() -406:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8dfd99ad2ffed2573598829ff34a62deccbd70f5337c1fec4c2962cef1992595_Device=CPU_Config=() -406:conformance_ScatterElementsUpdate/ReadIRTest.ImportExport/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=() -406:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=3bfc4cff938f4386af23d87ce10f8680a62a25ce1fa9178874f212edf45ee045_Device=CPU_Config=() -406:conformance_If/ReadIRTest.QueryModel/Op=If.8_Type=f32_Shape=static_IR=If-8_707_Device=CPU_Config=() -406:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f6f3c6d199a224ee983f6905aa4f72ea4138e6076d7307c72588dda0cc9c6ed1_Device=CPU_Config=() -406:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=45c9fd0289649c455939587c623f1884a4e675e2f970192d9ac2f60a65e6da9a_Device=CPU_Config=() -406:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=c985b086d155654f9db8470da3af5245c4fbb0139015d049b8b3b20f393c2545_Device=CPU_Config=() -405:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=36783f31e83ed0f978f00a1cdd87a25b4b881c251fe059e5d2829be3d0b45c5c_Device=CPU_Config=() -405:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i64_Shape=dynamic_IR=2c47f1ee19359a486a72bdafc2614159d48fffc80ddabe0f897212a454a75b18_Device=CPU_Config=() -405:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=static_IR=8834a8881c2da907f6ae38d4c45100dde754e653f3e4994cf9add141c217c781_Device=CPU_Config=() -405:conformance_If/ReadIRTest.QueryModel/Op=If.8_Type=f32_Shape=static_IR=e178ca7afdd75b09f1ee18e50afd30eed0740497637863c3397b5a75c0f8bfd5_Device=CPU_Config=() -405:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=de3245d77d2e004bea85af29c91e1668ae1b6905fe2cdabb92711adbde6406a9_Device=CPU_Config=() -405:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9795aaeb71c115680b567eab0877df338c0d8971858b489a2636c4483f3512cb_Device=CPU_Config=() -405:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0bc2bfc4481de7733f5503750d21376d00de6bfa699ecff3ee0c4333d9515db8_Device=CPU_Config=() -405:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=1c63f30ce7cb977ac945ee25eb97f3c472a81b999eacbcdd4b3bfd253f25cb51_Device=CPU_Config=() -404:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=d51bc4204bb6079e79da8d0cf95ab8a3454c90a040aee0fc6fedb00f0795c577_Device=CPU_Config=() -404:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=17472505b59f6bcf4f5570eb83b2225b056a403bf2d165562edabb8501fad1e7_Device=CPU_Config=() -404:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=3638f7714d7627d7536ec02891656e512fee1ec55d59bb4f68c7409ad82f3879_Device=CPU_Config=() -404:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=2d6f6b955cd431e0f4786aae35f5a1f7f69a6b627e88c42643ded0477f1cfef7_Device=CPU_Config=() -404:conformance_ReduceMin/ReadIRTest.ImportExport/Op=ReduceMin.1_Type=i32_Shape=static_IR=a2b9f0b4c044e23f536d137b6e157d1357df657d1af119cb8f71294d7dc098cd_Device=CPU_Config=() -404:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=dynamic_IR=33e67497d576ce6af4a214d55862646d034effd328ef5beed8d7b0f380b6b689_Device=CPU_Config=() -404:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b15fd62115a849e0b5226ebe9162cda9371ad2783637a518f2a8724d24710253_Device=CPU_Config=() -404:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2dd63d58c85301d765882b95995de97f4eff14bbb3c933c4e4b8ee5fbc2e9e71_Device=CPU_Config=() -404:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0973b76264164ca52a9883a69ff5f7df977e28c33a0dbe9095e7e92acd7854bf_Device=CPU_Config=() -404:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=33297e2649e2f0c53b0bfb5e349d83ede580471764202480855e3f1efc8017a5_Device=CPU_Config=() -403:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=12e571ef61251520c35bd8c0429b1ee71277033ae88101f08dd769a300d86c5c_Device=CPU_Config=() -403:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=de46537615051a46fea66871c5fc6ef3417b577ce42bd1f7e239d821e1ed5c51_Device=CPU_Config=() -402:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e5249d5630503351688090f1a9d0143b02e750045924aee8f9003072446583f4_Device=CPU_Config=() -402:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=aa14d6e18f8580015dd7d32b167fba6ee137133b87fd617eab4599f407a51b69_Device=CPU_Config=() -402:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=8ea778d7d98fd08efe4b2efa501ef3599df00ca9bd036980ce86e0d6dc454b96_Device=CPU_Config=() -402:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=ae817dcac1ed2395cc4098f67bf6d2bcbecd8b7e91ef7592622d1ee75ed4a3cc_Device=CPU_Config=() -402:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=19a94fc5cfe3ab1b4e169b342ec8d9f0fdc4ef19484c8c34d6ab938c6e7bf5fd_Device=CPU_Config=() -402:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=f645a2275ff33ad614c801a8f2f262ce1ca95417e0ca59e28d4b87cf3289c00b_Device=CPU_Config=() -402:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=eaac8b3d6a4920fa2ac101965805d140502fb409e230821d5c2a370aec15eed8_Device=CPU_Config=() -402:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=6d7cce19ff10d7690177fe1e3200d872ef5d8827b7ff49e6c9994e597a15dab2_Device=CPU_Config=() -402:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=8ef34b5ce0dd0100a8efad53b3b71e87f76ed69496cb6f030e76478d7daddf69_Device=CPU_Config=() -402:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=30dd450fadb8a1081c1315cd0e5234728862b4de39b097a5a3248d551369b60a_Device=CPU_Config=() -402:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=73623637f6155bde0a4735dcd904e5b491d7d459bef5f8d3f66f02f9558937a1_Device=CPU_Config=() -401:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=dynamic_IR=fc75aba0dd172d6628de0b473569c672b52f070ac3c446cc3342cb1184ef076a_Device=CPU_Config=() -401:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=bff490cc95cf384b15409e96ee7d0995aa91640e23409cda381b85b2fef69e01_Device=CPU_Config=() -401:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=e48a363cfdabe0b62509e21641bb1cc88edaaa7d2eb82bf3ce747cab8355ff3b_Device=CPU_Config=() -401:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=static_IR=2e3f53e7b949e1dd0ab38890b0c9fc9e770dfb68569e37fa5cdd4e3ef03d6eb0_Device=CPU_Config=() -401:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6017d3f7ee3d7e667e8e7e4881f9aae335d47c8617c92b18ec370aa0770314d9_Device=CPU_Config=() -401:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=bd3ed1b35506cb92c8e587acb102c70abbe02bdaa75f76e5792d48d8e1f2f33f_Device=CPU_Config=() -401:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=7581193e4db43b0e50c6a1a52f8b348d88587040bf38d1b780ac660781e3d3a4_Device=CPU_Config=() -401:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherElements_opset6_Device=CPU_Config=() -400:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0d74ee98934e32799620ac90fd3ae8335bca026b9225782458949c64139d89c3_Device=CPU_Config=() -400:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=() -400:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=dynamic_IR=8b79cf070ed44bdefd5afbe86a81199e189fa486c42190795419dbfc7cc26d6b_Device=CPU_Config=() -400:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=b6a75c5d2a686eae53cc25c6b107630b31a8a4d8c6514980ed1a97754f33bdcd_Device=CPU_Config=() -400:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=i64_Shape=static_IR=d106f0cba8d8311b75f6074c099f45e10400c0829fdd1826292b1310471076cb_Device=CPU_Config=() -400:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=a6722b8718b7c028e1bbde4462945c096dfc551775af27bcc7d00967d7d73919_Device=CPU_Config=() -400:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=57921f181e48af2b294b923633e457650e5ab2a9ac7f5d4d07930974ad5e03e1_Device=CPU_Config=() -400:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=6838901bafb44e26f73134e2c0eb2be8f1f777ab794ae340d61b62d891ff3d59_Device=CPU_Config=() -400:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=439308ddb64edf02f96ade09e7888cf89f422fbdb8c8242521ecc3f93e61bdd7_Device=CPU_Config=() -400:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=596d0b6cfe8b39e0ceaa665f1fa82aeeeff78d09315fca7cef031b6dc210a1f3_Device=CPU_Config=() -400:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=7581193e4db43b0e50c6a1a52f8b348d88587040bf38d1b780ac660781e3d3a4_Device=CPU_Config=() -400:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=80a8c850ad3eec3e8fd00d2ac09695a0f87a10e4b80b9022f49ddcd9805eb2d1_Device=CPU_Config=() -399:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9bae5a53011ecba6327961e6496f3312134c81e148523434968c3c56b5e0c491_Device=CPU_Config=() -399:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=30466048a7da9db59d20a210af1979341f7b9552362e64a89357d650102a213e_Device=CPU_Config=() -399:conformance/OpImplCheckTest.checkPluginImplementation/Function=GenerateProposals_opset9_Device=CPU_Config=() -398:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d6d8f4f28ac34b734cc984f83e8f5f6598c063a6955d00ef4c08252d5d05c276_Device=CPU_Config=() -398:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a3e1aaa7054d4d046bab4614737c931b25a574051a2f8b79799aaf6fbbd2c2e3_Device=CPU_Config=() -398:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=37337436d0d481c689caabec3bbc8f21ecec65560c70de4dd1f5b0ed9e444bf9_Device=CPU_Config=() -398:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=780fe1f9a82f728f88511b2d8194c4f425144ffb5ae4aaeb1ce90c6fdea3362a_Device=CPU_Config=() -398:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=9fa81cf001e6c48dfcf4e75aa77f95b3dce4e8d48b6ec3cfc896dcc08006c62e_Device=CPU_Config=() -398:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=() -398:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=dynamic_IR=43ceadf05184954dd8697d4f737de323ec2ee75f93e0d33d60dab2acc995f3b6_Device=CPU_Config=() -398:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=662ca1fd253f0a0c29b89eb1310ea5c7c87895533130ca1a8b76f791ef1ad99b_Device=CPU_Config=() -398:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=27a43bf8c20a81f1e244ace4c53f7cd9343a2603ba2c8b50bb041a4046ae6ecd_Device=CPU_Config=() -398:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2058548f687014df36b4da1b2644f07fa117d5a1d303a13c4d913a3f979d3ed6_Device=CPU_Config=() -397:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5c33d593e408ad72bf438729a423318330c69c69f1504402420635942050ac06_Device=CPU_Config=() -397:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=e9539332df9388555564db1da36679acc7b505b8c1fa687731f2052999bfe1fd_Device=CPU_Config=() -397:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=c7ce41820be10f17c8d48c005703d536d18e4f49b1d2022ac58f77b7b9afadec_Device=CPU_Config=() -397:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=efbe921ab3c27a093f20ff704fd02e5c610e7507d94a2d2092379c5a99743380_Device=CPU_Config=() -397:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=ba1b92833f2c8734c5178762b6cd8c847c23027ecf79ebeba295c39b667162a1_Device=CPU_Config=() -397:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=755b95b2e9c5cb5da4d4cd2c46ced327e10dbfc67a0d934667177b5fab73d431_Device=CPU_Config=() -397:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=319c7b312e9074a43819b034ce82eddf1c8f9e51d4eba3fbc7a112cb6393debf_Device=CPU_Config=() -397:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=d38ac6654882078aafe169f6d1280279fa81e646529f6f2bd621338a756046a0_Device=CPU_Config=() -397:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=f2995592ad35fbaf52873e0180081397916db8165b9596166e8d449e44b57169_Device=CPU_Config=() -397:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalNot_opset1_Device=CPU_Config=() -396:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=3801fd5b86bf772977c131734d8356c8dfa41b9056091937473be600e332fbee_Device=CPU_Config=() -396:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=474e4bfe52232239280bbe4e2d2aed15cf69c7ec8db86b010084c6e68a8d0e1d_Device=CPU_Config=() -396:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43a00b4dc097228af52c00054951dd5b57d8e0086207f11a8996e5ac880c8980_Device=CPU_Config=() -396:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=() -396:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=a0336bba08291ea34d6271c83816fb349d163fc5989171b07fe1bce50a2f3ea9_Device=CPU_Config=() -396:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=1a0639f04a426db13dd7cfac918ec6e2254e1cb8f18e0853e3bd597cdf090421_Device=CPU_Config=() -396:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=1da672197f2c962a6cdfb059e9d09c10a03c3b082838f53d2faf6a761fee0637_Device=CPU_Config=() -396:conformance/OpImplCheckTest.checkPluginImplementation/Function=ShapeOf_opset1_Device=CPU_Config=() -395:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=() -395:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=efbe921ab3c27a093f20ff704fd02e5c610e7507d94a2d2092379c5a99743380_Device=CPU_Config=() -395:conformance_HSigmoid/ReadIRTest.ImportExport/Op=HSigmoid.5_Type=f32_Shape=static_IR=85df90c3ae7b84d89ec4eae30556ebf4af996c318afa45d90dbb219f73033f31_Device=CPU_Config=() -395:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d73edb68da4aee1c052b79ffce030b368f204c04bffd9a9dc01a9b54de932e7_Device=CPU_Config=() -395:conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=66f4344fac8e5e5484f5762b1bfea68ed08bcbc378a8b10f53d0a8e053524749_Device=CPU_Config=() -395:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=fe80b80ced0033aef6f7f97abd22de1271430f700d7dc9aad9a2a819f91e11a5_Device=CPU_Config=() -395:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=b93daedfdba7331025c12a5eb4b881bd7df445d80bd4fac34833087fe6d65bf5_Device=CPU_Config=() -395:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=335e78458fe959fc5a9669069890bcc67c1f1eabf21dbfb6011cc80b8322e9c0_Device=CPU_Config=() -394:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=dynamic_IR=8c78da5f8bf9c1a4cd7f89cde9d61eb6500fa10ea0454e36a585466ed97fb12d_Device=CPU_Config=() -394:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=469a63c5aee73bdefc9abdf8abd8413713c0b68cc098d16c193399a11c7093c5_Device=CPU_Config=() -394:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=01b095b8763565527be0de9edff565070949485db907493e99e95c2cddf6abaf_Device=CPU_Config=() -394:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=dynamic_IR=791be312b2af6da6abd2eadadc6185c7052271efbcf314bb678828313fc58414_Device=CPU_Config=() -394:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=99fbf009fb26eae6bfc372a5b3d9bef89d6f82e5fa45c62cc5ece995bcc71079_Device=CPU_Config=() -394:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=486675b6412030beffb4209c326672af07d343d5e1bbca31b9bfeed3cc339e3d_Device=CPU_Config=() -394:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=4520f02da2bc674bf781c84ea3cca92375a1eeaa77f4f4f7e4cfc3ef75fb2964_Device=CPU_Config=() -393:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=610a8f8c44b0e133d4b5684c37017859d06bb2251482eca0cdece0a1c216b936_Device=CPU_Config=() -393:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=dynamic_IR=2af646407076eafcc1ed2d628158fc32eac4ef2fb34fb967962c06f81376d61c_Device=CPU_Config=() -393:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=fe80951a0a44625457a6106d8613c9813c9c0b8fe3606fa5ac1c064217c8a0e6_Device=CPU_Config=() -393:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=745c0804609863998b4bcc6956b1e78fc221e0e4f1535ab09b89a9c966a16995_Device=CPU_Config=() -393:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=fda1f84f5e911136f8daaf4fcebfb989f3216c066ddc1cae578882a41ca0f5bf_Device=CPU_Config=() -393:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e365913541918ae265939740fd9930d4f5d919773ce47a4e896a264bd8f86460_Device=CPU_Config=() -392:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=51bb427ac8abf618a72159cde1ee840e08518016a09e995f503cd888941f5039_Device=CPU_Config=() -392:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=d5f5f2d39bfe4ccc6f12f76e5eca8e2e40ac7ac6c5f38a7cac21970df213d4cc_Device=CPU_Config=() -392:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=e7b766e89f08e80fd96ba40dac738561546ca7210c4566b727ca8cb49528c823_Device=CPU_Config=() -392:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=29a633b64671e28103c44b79ec5c329118c0d7c4f70466ad44482116aa2a3b6c_Device=CPU_Config=() -392:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=860decd2bf091a335f6f820b2c6b6acc58618fbb6027e30484470ce899bb1591_Device=CPU_Config=() -392:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=b35fe21330bf6e76f55ad27b71fb0422a737d0c400255fd6cf2cdb3252d3617f_Device=CPU_Config=() -392:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=() -392:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e61665bc5590265246ab882bb55b9487e81412012ed98ac9cb16154bc8eddd17_Device=CPU_Config=() -392:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=7e1801bf4ef7ad1b27663dfb399f318ccb2526e925d48e3d30e2ab837824b217_Device=CPU_Config=() -392:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=f7bc08f4bc2edb455c7afc9cecba3666df1150bf4e3a67a20061714f867ddb0f_Device=CPU_Config=() -391:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=29bb3b751638e157d0ba7114cc0e156a4b792a9dbb2bafa3ca124516595f01a2_Device=CPU_Config=() -391:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c777366b6b37df3f4a3b19b637f66b707fbbb113972a9eff7eb4d793731f8c9b_Device=CPU_Config=() -391:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4a9237e5cd29f0d2d5e738891752c6f6b29c9dc4c29d130b9c9921ad5787f819_Device=CPU_Config=() -391:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=bc90fb9a95a74efb937b6cf808584dd1e91aa6c4d774640b51f4325f0aca6b42_Device=CPU_Config=() -391:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=static_IR=ca5d2626f2066e0c806addc4b6ffb4b3a71f1183b93783b92f44de62d82faaf8_Device=CPU_Config=() -391:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=f802331401875cb16be10c9f752520406437b2e63a50e022b7d95b732e5296f2_Device=CPU_Config=() -391:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=91b6cdd8a7664759217ce0b84a8baed2105bca0ae9876e9efd01c074aa27039c_Device=CPU_Config=() -391:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=d81ef130a76622c79592b0b42acf5cd6dd357ccec28958dec6eb02a654beb9ab_Device=CPU_Config=() -390:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=90cf12798b53937dd1a31daebe5444e1c10c27c5a67fcde6dc61b5feb1df89ec_Device=CPU_Config=() -390:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=5995707c0c9656ffe179147e29d03df5a35286481a4140b7ef019434d83aaa61_Device=CPU_Config=() -390:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=4420cfb7f4a734731dacfe5b0c27db41ccaac2ab8bbff56cac0f99ed96e976f2_Device=CPU_Config=() -390:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=27e8804992c0d74c18c958f0876c06be6c7eda2b36fe7de3ab616b577dce13c6_Device=CPU_Config=() -390:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=0d62db1843ef7e470a613f9f4d4999ce0e6c94365bd667b78c283cb9406e915d_Device=CPU_Config=() -390:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=c1c38223834d99f4481cb74db2bc302710629de5807b4f08381fd01655b9d44a_Device=CPU_Config=() -390:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=() -390:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=e03d85019ea733c10b7ece4721036f3aeae2e60179d9b044d34e862608fd36a1_Device=CPU_Config=() -390:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=29a544bbefe85bdabe1d5d36d83d8ee1d80c71f8b98ff6e898e1062671daa8ad_Device=CPU_Config=() -390:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a50644dc2d133df429ff4aa6a19ca9bafbf41d2948522e584fc5f417ad16d76c_Device=CPU_Config=() -390:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=9c66c6a6d93c10149920c3e034d9a0765afbef45dab66083fd5e3d796a57e406_Device=CPU_Config=() -390:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=40876e66f31053b621aea004baaba7607b9131d4fff8e8b00ed7e1e58204988c_Device=CPU_Config=() -390:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=be4d557c62a3a43e7f309d2276cd7549bf1976ca8593bf2be752e60c42237a19_Device=CPU_Config=() -390:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=07b257862a62290d7e8ae939147bb7422992528bf54209b8d1bff500b99b6f4b_Device=CPU_Config=() -390:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=c808434d1d2cbd9ea66373f22c7e635c5bb2e3a6294f93421d1d9d34ac62515d_Device=CPU_Config=() -390:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=f7bc08f4bc2edb455c7afc9cecba3666df1150bf4e3a67a20061714f867ddb0f_Device=CPU_Config=() -389:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=1696523c5dd3a701251583b9c9f29e43f852383cec3dde5a93e6f7f7cabf3398_Device=CPU_Config=() -389:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=766d904d646b6f43847158972a615db69af2bf66517db0992a19418856bef52f_Device=CPU_Config=() -389:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=21a343909133e844b3d88a967b2f6c948e4c9c9eb96030b936f9517dd9bec865_Device=CPU_Config=() -389:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=54a5630072fb0e0127611a4ae63db14b7c0fa0979f4d2be7bfec548b5291a0af_Device=CPU_Config=() -389:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=a3d8e1343e43c666358304b530278c73bc7c52a0d7fff38977154b6f7c456731_Device=CPU_Config=() -389:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=525408cae199f0936f7552165ba12d61ced6b675d75d56f1d69be8281feec5d5_Device=CPU_Config=() -388:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d77f317dd01a80955f901d0da2930aa1f82531848f4bf22d839c60a84941e6c4_Device=CPU_Config=() -388:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=77316b4db1518258304408714d1b57a023070cefb5c1b141b6721028258f5744_Device=CPU_Config=() -388:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=9031b1919c35a9df591ff64fbe4748c02cc837649899099542716f35b5c68cc5_Device=CPU_Config=() -388:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=e08e84b17997c1b1279429161d287720e4c7deb0e6d055539149bc577ed3b104_Device=CPU_Config=() -388:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6167830634e0b253aa78e883453d45bb737cd5df33c849e4b16b99164fd49d5e_Device=CPU_Config=() -388:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=fbdf008803736374dd213f1d7e0a041fc0e9b3f025c212a588fa05842ee5ee56_Device=CPU_Config=() -388:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a848753a720bf9791ee4c239cf08712d714b877bfb6df23805590ad690ceaff7_Device=CPU_Config=() -388:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0bb9a29f02d37ba32dc29b4284f58e10ce59571799f58381d449c77655c795d6_Device=CPU_Config=() -388:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=() -388:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=d38ac6654882078aafe169f6d1280279fa81e646529f6f2bd621338a756046a0_Device=CPU_Config=() -388:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e365913541918ae265939740fd9930d4f5d919773ce47a4e896a264bd8f86460_Device=CPU_Config=() -388:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i32_Shape=static_IR=cd4d566c041357cdd7f8539933888956fff5cfd15e3c42872df59d9890c169b3_Device=CPU_Config=() -387:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cbd851b8c4e89bce3a20b8795b3bc5a0105d26e252a4674541ff630496144aaa_Device=CPU_Config=() -387:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=a449aa561efb222cad1a414ee87443f9fec0e5c2f6220f6a57b6705c9ef26cd6_Device=CPU_Config=() -387:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=e1130d42d591780dd2a746ce7ff874a2bf4725ca9fd09803932ba4a7b0b389aa_Device=CPU_Config=() -387:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=5038017e90f931327d5159938d422b2afc229aa4d776a4ac80a946724fee357d_Device=CPU_Config=() -387:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=9ca1360242688f494c59b8eb1073a4bf7291ee7b2ff460380bd47248fc591dc1_Device=CPU_Config=() -387:conformance_HSwish/ReadIRTest.Inference/Op=HSwish.4_Type=f32_Shape=static_IR=98546b7eda390c30f82053a093b5e3855c6dc8c631451b3637eadf95858af2bb_Device=CPU_Config=() -387:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1385af2553c7c9b0f9ce2aa4345d8b767d36136a9cd8e2acae79d4970d6b5c8b_Device=CPU_Config=() -387:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=8337ad383956ad96ca95f4aeb967e05c694fe586b4ed6e46547e3ffa0217c59b_Device=CPU_Config=() -386:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d8a48dc7581c2ece0179d0ad668e8caebdddddfe492e365ea2e0e5f3a7302eea_Device=CPU_Config=() -386:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=6b69e46c11a2a82ac7ad6697cd768d88da6e870e75f489779bbd1714bad23450_Device=CPU_Config=() -385:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=59bac5d30704b81def0385b29fb8d79e459a71b9251b4f6e94116524bd9aa7be_Device=CPU_Config=() -385:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=0138363d3baa37869a3e55e1b059a42a87612507ba318e753361a58549ed5ec1_Device=CPU_Config=() -385:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=26d09bb7dc7ce95aac39023ac90bd083da9101b9e7383af49e7467e4f0571f2e_Device=CPU_Config=() -385:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=d661093ec9006177e5d47e7f666d7c98353f9c3d5290ba6284145f60822f2573_Device=CPU_Config=() -385:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=b99ba096eea2f3725fa98eabc2a941fa895c0a58bcd7a8ea68d2a245ce913113_Device=CPU_Config=() -384:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=77316b4db1518258304408714d1b57a023070cefb5c1b141b6721028258f5744_Device=CPU_Config=() -384:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=120cc30794fe9c9d59dc9df6fadbb9791f3a6b99e4b9fdc06c5e01f494b05780_Device=CPU_Config=() -384:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=f76da5edfb7a9e3fa7cec034fa43307bce74eeb0629176ae5dd40d154baf858f_Device=CPU_Config=() -384:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4bb7bd2471752f1a62dc15dbcacad87dd329443459a90dc6768b1a34fd00c064_Device=CPU_Config=() -384:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=6faa91bd8e7037c9233825cde9313cfd2afafa21ff423a00544eaa36d734332e_Device=CPU_Config=() -384:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=586094b4ff6617c08c87a53c7be1ca26aae40657c8d964d81eda731dbb27e848_Device=CPU_Config=() -383:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=eb966d8fd7e1301280e6ef709dd785d210a35a1346eb88c3f38379bd96036ce4_Device=CPU_Config=() -383:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=8fc296db9f7dd10289217cb81cdf5991c6b5f3c89369936a94c8ac484702bfa3_Device=CPU_Config=() -383:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=1cb2f17dcf4f8b738a23313501e9a98101169cd9e368f3fb98c552f994232073_Device=CPU_Config=() -383:conformance_Abs/ReadIRTest.ImportExport/Op=Abs.1_Type=f32_Shape=static_IR=083771171646a2eadcbb3384bd457e04d74ce8ea771813cdf67c56f7bbf20c69_Device=CPU_Config=() -382:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4baf5444c85028a4cfdedc5888a7cd403e2491ab694ab65c820dd3c410f8eafb_Device=CPU_Config=() -382:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3c03ae2ab13dfccc85d9909840eafb6a291b978e9bf859f27886b4a0d3e87ffa_Device=CPU_Config=() -382:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d16722dfa770998d9923d09fa1e2a973bac5ae7afc6452a0b5ac21d839720bb4_Device=CPU_Config=() -382:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=92dc9b12889f441d7a93e95851a15849139787b0ecc080e70d266fe4cb6dd9c1_Device=CPU_Config=() -382:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=2f842d4b64513c6df5748c54a1166a3f14436dc1ca59b7a28530bcafcdcde2f6_Device=CPU_Config=() -382:conformance_LogicalNot/ReadIRTest.ImportExport/Op=LogicalNot.1_Type=boolean_Shape=static_IR=66b8769b499fa31cfd7545411d16a17b04e1a336bb63a7e907707cd170a30fc9_Device=CPU_Config=() -382:conformance_HSigmoid/ReadIRTest.ImportExport/Op=HSigmoid.5_Type=f32_Shape=static_IR=4a55e1cc1410675b7789f083f2cd3f6ff851f49c8a0818f5bf0dd27280b197f9_Device=CPU_Config=() -382:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=517a5eeb2f1f21304b8a1d5971f89bfc93aa678252180bdb05144657b1a8619f_Device=CPU_Config=() -382:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=cbfc33348aff4daf15fb7926884243c7ffe38aa29e60eceda90fa9b8aadad5b1_Device=CPU_Config=() -382:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=() -381:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.3_Type=f32_Shape=static_IR=a56b3f758c88a5723e4a2cf04ce46c92681ed7fb0d6dd7f4d5b937dbf00b0eff_Device=CPU_Config=() -381:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=0138363d3baa37869a3e55e1b059a42a87612507ba318e753361a58549ed5ec1_Device=CPU_Config=() -381:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=8368b4f6e208aa4cfbf0aeaa648e9408c281a71d98d15ee09407d26274fb349f_Device=CPU_Config=() -381:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d42cb628111ca80a33a558dcd1c2c310aa7b95d6c48549075291f49ec59c302d_Device=CPU_Config=() -381:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=99183013393075553f5cd30818ccd603ff5d3e9e71dd8f42ced0df2377280729_Device=CPU_Config=() -381:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=cd2470c72fa7d2238d2eca4d067e49a02340ad187681be2fa7e0bac6eab3500b_Device=CPU_Config=() -381:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=u64_Shape=dynamic_IR=5f87db7fc306440f807b413acb7eb175932f29f59d1b5eb4a9df8945b9aef9d4_Device=CPU_Config=() -381:conformance_BatchToSpace/ReadIRTest.QueryModel/Op=BatchToSpace.2_Type=f32_Shape=static_IR=f118f5911730937f9dab91ad5eb6f78cb1af6de7bae1dc745dab2d4f02257fff_Device=CPU_Config=() -381:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=b92112b2ea2f233a6fb6ee512363082a49db0f85ab23f89dc29ad907e6ab408f_Device=CPU_Config=() -380:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a05c6778a396b4eb89a5e112fe505a41f47ff6bef50fa025eee1dfb7ec6a95e7_Device=CPU_Config=() -380:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=634db7c7a580a605f3375f671b3bcb2a1baf5856b32032d2786a5f8061df63c3_Device=CPU_Config=() -380:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=5b1fc9693e4e947bc88a88bf1ad22ee2f59c13bf291626eec3e8ed49b0cef7ed_Device=CPU_Config=() -380:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=93ce70e605eb712479090e3a266e86eb7422bf0fdd3acb1c38a0b92a9c381e2c_Device=CPU_Config=() -380:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=d442b2d9df68f25f567a3e8da8d87866c200d391624cf1c339554a57a9a527a4_Device=CPU_Config=() -379:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f1ffa9874732c1aa88e04fd55fbc864c9c6986877d3d52045fa6ae7f18dba62b_Device=CPU_Config=() -379:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=429b91023f3ae9a323e40ed372fc29926fcd6aa7a8e77e4ddaaf68fa648c43b7_Device=CPU_Config=() -379:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=f7e1aae2dbc817ca8f64a6bb0742e476055c239cc6e31a4233b7580205feeb41_Device=CPU_Config=() -379:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=f32_Shape=static_IR=7ad6fe3ff1472399c9c0e12aba1db89105e1e4a243cd092dc43ee763a2571fa9_Device=CPU_Config=() -379:conformance_HSwish/ReadIRTest.QueryModel/Op=HSwish.4_Type=f32_Shape=static_IR=ce108d9befa5ee87b0161e969c5ac986c176e468ecae9f66895cdc4fc6bad940_Device=CPU_Config=() -379:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d141b35e277394511f5635b2e395039c986ac392e6f49c2415da6a5071bee96a_Device=CPU_Config=() -379:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43aed1509066aa7c839a82c9865228ce3ebdfbe519061649807875ec6e86d715_Device=CPU_Config=() -379:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=285bcc240dec2c32e171f3866ea33107a109566fb8ef39f0dd84e99664aaf8df_Device=CPU_Config=() -379:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=27b03da9a0155039856b1bebe424d10d1b8ad768747cbeb851bfc0463edd5cb6_Device=CPU_Config=() -379:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=15d323a190bbeb1834cfa08a3afc633a2c203e44e2660bff4e98453c02ea4cfc_Device=CPU_Config=() -379:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=dynamic_IR=79cffe28ff617b42488d33b204b0f50bcf4e304c74d2a11820c830e091c6383e_Device=CPU_Config=() -378:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=557b6184296452c25e420a307a2021cfb0eedcb73e42bb4bc247c34c15b18447_Device=CPU_Config=() -378:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=41c1e13447cce632ccd478ec2bf36f09e510942449b0bffd3271f3b1f0b48d54_Device=CPU_Config=() -378:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d962e7157ea216206d6c5b11fe5ef6ee162a1f7dc20f84a3b058e405c324a592_Device=CPU_Config=() -378:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=94b08f3c309048124724d9de0d120698fed90ff0237b07c4a4a2b7ccf843d76a_Device=CPU_Config=() -378:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aaafa4ff22a5fcab1e6e0f48065210ff790275fba7a5c16602aa4a00951a8cb8_Device=CPU_Config=() -378:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=8ef4d7ceb7d904a084d93d6ede1c15a64d2511b3bf1312d630792eb21c591408_Device=CPU_Config=() -378:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4b00183255fde45d5c3b815b552e5a4279284bfe1ceb31389560260ad5546c14_Device=CPU_Config=() -378:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=99b432aa5821136994e06b4e3c690a4e298bc5a496740ea2c5fe6aa300edacf8_Device=CPU_Config=() -378:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=() -377:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=254937408e91c70536c4f3b3f81f1a7aede93b29f142631a46fa7d962c531131_Device=CPU_Config=() -377:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=4c3b0cda20bf6b3c574eaefbce21b9b2b0ed92fa1b37c32af252b111b6466d0e_Device=CPU_Config=() -377:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=68853f0b8867d4ddb5eeb239690f1b41600c05f64ee4d3efa8cc828e72b9bc1f_Device=CPU_Config=() -377:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=766d904d646b6f43847158972a615db69af2bf66517db0992a19418856bef52f_Device=CPU_Config=() -377:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=131fa1ed3ff9df038bbed73979ab906c3d84fea9dd2cf5dedc82b3222d511b1d_Device=CPU_Config=() -377:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=060423427a9100b6a38aad12a83043441f8af436c1d2502350ae867f45bd721f_Device=CPU_Config=() -377:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=cccecd6fd3e8f3d84fb98f219b212cd2b55ae0e4e34c099a25a1028e9e2f83e7_Device=CPU_Config=() -376:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=75aed7fbb8f7d7e8a1281d4a16c4fe2e55160dfb9e6a1bc446913a223c5aa0de_Device=CPU_Config=() -376:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1245c8dbd9027cc56d2eeb58e1bd23774ce945522f66a17ecc3c03ca1ca163b0_Device=CPU_Config=() -376:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=e77dc4aecdbd4ab3d67fc3c1d9e350a9d259af1d4c0188d680121a31c6ed8ccf_Device=CPU_Config=() -376:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f18fa21106120cecd81f50d635b1c42cbd641877ffbf78e746ef7375ff546d7d_Device=CPU_Config=() -376:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a76c4cc0a1f2294a3ceb18dd5d214d842cf37c08d2e34770c66c29b44ee92e48_Device=CPU_Config=() -376:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=() -376:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=d294c71f3796d2e2b88f819f6512ed03942eab440681a5bc5b092e5a34192107_Device=CPU_Config=() -376:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0256d48640841a9233553afa85e34dca797e6b5eedbd772f606c1a0e6f8e91a1_Device=CPU_Config=() -376:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=5e7e2adae49fae3a376e9a5a971513a9b23b5fe4008ce51814e0fa1fd91f1f22_Device=CPU_Config=() -376:conformance/OpImplCheckTest.checkPluginImplementation/Function=If_opset8_Device=CPU_Config=() -375:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7c8594e723d769f8817c58fc16146033afb91d821bc941dff944223796029f8b_Device=CPU_Config=() -375:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=574e53e574b1a6e0bc16a7296aadd78785cac535293e956b008b0a2274b7cb36_Device=CPU_Config=() -375:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=() -375:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=cbd1111f323b8e6d78b59b531708defef64b90463f973f64f52251795ac5a7dc_Device=CPU_Config=() -375:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=923032e47821636c4c8098a7a9afa97b331a47d47357c780b7bced2e46ea9921_Device=CPU_Config=() -375:conformance_HSigmoid/ReadIRTest.ImportExport/Op=HSigmoid.5_Type=f32_Shape=static_IR=cc18959ba7c26661ba0f986207bd00aca503bf924b31c4a2070ac40ac3ec5468_Device=CPU_Config=() -374:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b2931a4972ae4f946778af45cd5824e6958dcc1fc79cea4da1032590b2663d16_Device=CPU_Config=() -374:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1269afc1a9f9a4f71ca2167cc59274b7a3bead8cca474162919619b810eb9c1a_Device=CPU_Config=() -374:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=edb5dc5a42b36879d5ced77fc2db7d8b331c888534602893ffb277f742da1005_Device=CPU_Config=() -374:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=66bf131d73ad3116d698e15ac3c9e48bde66e096228138eb865c0807295c0d4d_Device=CPU_Config=() -374:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=() -374:conformance_HSigmoid/ReadIRTest.Inference/Op=HSigmoid.5_Type=f32_Shape=static_IR=4a55e1cc1410675b7789f083f2cd3f6ff851f49c8a0818f5bf0dd27280b197f9_Device=CPU_Config=() -374:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fa2eea1b545d6b876282ed0165fb935f0af249c713e3f20fd97cc06118e615eb_Device=CPU_Config=() -374:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=c56cf3dc39ed0072f3e5a8cadd1502fef904b32de3b7760ee4c6964c0e505ac9_Device=CPU_Config=() -374:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=922e194a5ae53e76be5ae624754d3c1fe5ea0d8c564410062bd9c30afc48ffe0_Device=CPU_Config=() -373:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f0145ffb8d2846d866b1a89c8217d54209830e6d3d0d10913e75af42f2510c74_Device=CPU_Config=() -373:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a956d2fb1fd17e2d864b3eaa8915cc0c4f9a768e35fdf5bf20cf6bc7f41aa130_Device=CPU_Config=() -373:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=13f3d097d5e17c2add48d6f9b6f86454a1b521408d7fb8252e3638d9f17ea6fb_Device=CPU_Config=() -373:conformance_Swish/ReadIRTest.Inference/Op=Swish.4_Type=f32_Shape=static_IR=d79b47022a50437c9df095b34e515c53eb042c9813fcf6dc7bcdb96962818ddf_Device=CPU_Config=() -372:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f84dc200af2852df01662dfbe891b8ed4abb27db6763f3a2b645ab75324834f3_Device=CPU_Config=() -372:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=8c43b49d99c64bec883205ca15c7b2d9dbb47b9fe5140fedaeb8eb7220a36f6c_Device=CPU_Config=() -372:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=bb6a76dcb7d086a6f8dc96d3e0b17573b6dc2775ff9d0f19060947deda586bde_Device=CPU_Config=() -372:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=dbee34cd3b708559af1ceb5fcf89aac35add00fc1b9e3eda2beebb2d5b629fc1_Device=CPU_Config=() -372:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i32_Shape=static_IR=e256f7acbc71e64cab857fb6378a035096c7ceebdd4f867b5140d35865cf6532_Device=CPU_Config=() -372:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=bd927dd60e7b65e84d03c2c01d29c6932961f801bed1312124c2212b5e22a921_Device=CPU_Config=() -372:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=a3370e3b46f385ea6e46137d49d5f1b4158fe08d0a3e9feb47a162f6b3640951_Device=CPU_Config=() -372:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=6daca83f4b162285c00c695825e255cbafce9cf9c9cea68b969a301105475303_Device=CPU_Config=() -372:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=922e194a5ae53e76be5ae624754d3c1fe5ea0d8c564410062bd9c30afc48ffe0_Device=CPU_Config=() -372:conformance/OpImplCheckTest.checkPluginImplementation/Function=Proposal_opset1_Device=CPU_Config=() -371:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=77dbcc61a98e0bf3c1bdcbec543818a8a959751f10b8ec1489b66570ff4e634e_Device=CPU_Config=() -371:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=155b8d9ccf06f4d8f9ada6024fbe66f39e4e6e96917c12d7ac02eac98c5473de_Device=CPU_Config=() -371:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=54009010668252832a2a755d277e9f574fd2486892184caa0eb4774e753ed094_Device=CPU_Config=() -371:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=5150e1785d97b052a42873f9e9d23a511027248ff4b13ba7c269c8c3d4639e45_Device=CPU_Config=() -371:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=df085870336c57084e22afa8b52ece7149abc21b5d1784965a7d36d5ada91e8b_Device=CPU_Config=() -371:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c54189129febdb864ceaa5447a7a0011c8ccdf3711fcfd87424feca61b44c0b6_Device=CPU_Config=() -371:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=681b1f284fb69c16681d3efd2081d7f812496e3a027baef35a75bb0aeb9c003b_Device=CPU_Config=() -370:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e23a8faab46e1096894a906794325ff1a8c6001d3b980aa809088385675c77ed_Device=CPU_Config=() -370:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=1366ff72dd5b68a3faf25de8f98e4ac5500663b1aac4941af11532ea2ee769d3_Device=CPU_Config=() -370:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.1_Type=i64_Shape=static_IR=1c06ff77487507dddcddf290d75d4812bfc8a7b2c9bc78176da5212eab029966_Device=CPU_Config=() -370:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=() -370:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=651e5fbc222577151cf14e9c8e9bdf9e155f1e0d277206887160d65b532caf53_Device=CPU_Config=() -370:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=2fda32f5fe8957d151306845ffd0f877b2efad70f7bd4921fab2fd770d78c2a8_Device=CPU_Config=() -370:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=1988b645a87be14c17740085aa8c4a38e88cd2111f0ba294f77ed0bf856b0561_Device=CPU_Config=() -369:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=35d15ad61ee34c17abe50c4a67e568c2e253712c2d63cb828b0bccdb2175a6bf_Device=CPU_Config=() -369:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=92ed2f40e1ecbb9a90904cfe8e8ceda94f73154a44ac28a50c0d7acb221e8835_Device=CPU_Config=() -369:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=53da49d7aaa81cbb7c3a3dbc8ea938bbffabda14bd106fa6c2b6abe244ba5cda_Device=CPU_Config=() -369:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=a6722b8718b7c028e1bbde4462945c096dfc551775af27bcc7d00967d7d73919_Device=CPU_Config=() -369:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=0a2311ddc09b949cceb73fd0e09bbdcc2932c2635fee3a2c411bec27a30e9439_Device=CPU_Config=() -369:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d932ccb58823509e768be954dc85ef1162d9456db17138d650a2a883e31b99ed_Device=CPU_Config=() -369:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=86a9c310cdd99d5c2fc0b7239080c9cff89efd37662cb38da28bc9e2a1471d7a_Device=CPU_Config=() -369:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=73623637f6155bde0a4735dcd904e5b491d7d459bef5f8d3f66f02f9558937a1_Device=CPU_Config=() -369:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=f64585bfa3951a93f76c18fbc795f3ef82176e270c9f37161bdfe48e094c1d39_Device=CPU_Config=() -368:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=96117baf3ff208c696a9796404eec467b613c37977067ff0cc62e39355856d30_Device=CPU_Config=() -368:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=() -368:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=154d7358887845b8f2a661e79ef57318fa9499ee5c19b7cae461b6f798c57b36_Device=CPU_Config=() -367:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=8919e05ab2b0d545cabc2e2732828fa693c8f364e9d4d03faf7097f787d4f628_Device=CPU_Config=() -367:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=14598e053d7dee616de43f2b160e780b4bb53decaea53b31db58341464b82e48_Device=CPU_Config=() -367:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0d782801290370c7c390ad549171ec3500ab344b8b34ce4b8fd8b05339fe5557_Device=CPU_Config=() -366:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f977fc239a0230860702f8c1971bd424f10b978bb03937668c37edee6777f12b_Device=CPU_Config=() -366:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=920aa0d732c7ace2bcfe73df0e7217e66b6388dce554ef827efa96f4e7d31a2f_Device=CPU_Config=() -366:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=10c19142631a9ac6d8026ec82820aa75ba1e14605fe5ea1e017fa4bde4a90c44_Device=CPU_Config=() -366:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=29a633b64671e28103c44b79ec5c329118c0d7c4f70466ad44482116aa2a3b6c_Device=CPU_Config=() -366:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e8c2981885674129fedb6fc6a376f3fd3db7bf6f9867ee8a3f4e5aede63ee168_Device=CPU_Config=() -366:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1c73b4d05053065f5c37954586376ae4e1cf9e220959363b7c2cb381f489bee0_Device=CPU_Config=() -366:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMSequence_opset5_Device=CPU_Config=() -365:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=63ba45deb14e56e09574bd3694e3d94caf6ab09f67f5278e6c299c6c924a3cf2_Device=CPU_Config=() -365:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e4523b73661dc593224b91713f8f20f1c87513a62e3b8ee8265e1136eb74f9ed_Device=CPU_Config=() -365:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=d25e26d9a54a5dc9799e9881e3035bfd5f125d12ea6cb69fb1eb0166e29ec88d_Device=CPU_Config=() -365:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=b4f42a7d1252f2dd02b31ac7b0cf4ffcbd452dbf0e508833e7dc709ee04889c3_Device=CPU_Config=() -365:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=120cc30794fe9c9d59dc9df6fadbb9791f3a6b99e4b9fdc06c5e01f494b05780_Device=CPU_Config=() -365:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=dynamic_IR=502fbd3f8c0e9c0a9523269a9df9b0fbd83d59ca94f373fd543048429a957f5c_Device=CPU_Config=() -365:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=dynamic_IR=502fbd3f8c0e9c0a9523269a9df9b0fbd83d59ca94f373fd543048429a957f5c_Device=CPU_Config=() -365:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=f32_Shape=static_IR=35c61b2251b78ad9f9804bd3f9e301e1f974c6dc138ce0466b8b940d106ddd72_Device=CPU_Config=() -365:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3a17c045930ed967b45d1606b78fdc92e736731b198465e95ed7268d99eed246_Device=CPU_Config=() -365:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0ce1ec496e5d71728fc5daaba87809c5922406a65e85823913381de0d2112e01_Device=CPU_Config=() -365:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=3209c1cce78c7b856203c0a5676f6fad4d098a3146c7305ee3c0471b3be2e3d5_Device=CPU_Config=() -365:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e05af92d21ebd869cf6e9554a4aa0bfc60c8b0c64baebee798f0be5a0a01019e_Device=CPU_Config=() -365:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=1a0639f04a426db13dd7cfac918ec6e2254e1cb8f18e0853e3bd597cdf090421_Device=CPU_Config=() -364:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=dynamic_IR=9feb072b58552898ff80a05dffe8f39c880b4f2a2382d56cb24a78e278ea1756_Device=CPU_Config=() -364:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=b91a183b8c36d6e8358dad7056638b8091005393dd1ee6813728f25cd3e6a9f5_Device=CPU_Config=() -364:conformance_LRN/ReadIRTest.ImportExport/Op=LRN.1_Type=f32_Shape=static_IR=c1a0f6661ad306b82e66063988835c1a17072608792f3423bb058fe38c4b14d1_Device=CPU_Config=() -364:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fdb744ee1deeced50395d992d949989a5e8bac5d4f73a6d4b51a56f22359f4f1_Device=CPU_Config=() -364:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=58cd9ea3d8db317b6ff7fca55bebcbc6846aebdbe309b1b621f5535b18a70320_Device=CPU_Config=() -364:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=() -364:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=f8662769a2f3a5fb20582ccbb1931b7e3fa73ec7713eca30362b0e7c0baf829a_Device=CPU_Config=() -364:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=2e70eb484f4bac4cd11e9f643d2531cd0e78994af07c015183edf9d62a709d47_Device=CPU_Config=() -364:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=00b85178c2e7f891c89e99a6692b94a56ab0882f4a30167997e104db1429a9c9_Device=CPU_Config=() -364:conformance/OpImplCheckTest.checkPluginImplementation/Function=GridSample_opset9_Device=CPU_Config=() -363:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a3e1aaa7054d4d046bab4614737c931b25a574051a2f8b79799aaf6fbbd2c2e3_Device=CPU_Config=() -363:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=822cfb44c999b67217c8fff1da18293fcbd3a8a71d901d95991ad6df22398af2_Device=CPU_Config=() -363:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=db5c391cca1031cb4ec32def18ce3a4776c53f71e861c39b350fe5856da4fa43_Device=CPU_Config=() -363:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=dbabd4c2992053ca70e9d6a489b437cf8d1f13807220adb5054204e9bede00e1_Device=CPU_Config=() -363:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=165dc8f683138c4d731ee850aa6212a70851b91630cc42e2b4e9d46e0ab15b57_Device=CPU_Config=() -363:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=851aa3cf931a01e0188758055b866fd14280bc344f548da6166e4a57ca7c9254_Device=CPU_Config=() -363:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4fb0809c5cf2945a097d18f445de6f4f5cd2c124cdb495e6f0a12e9d937e2b80_Device=CPU_Config=() -363:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=d442b2d9df68f25f567a3e8da8d87866c200d391624cf1c339554a57a9a527a4_Device=CPU_Config=() -362:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e2734d3e803c031e2fd56d0c9f7a72818227bc7981d9f7d9d1148f1cf07135fa_Device=CPU_Config=() -362:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=22707f4dd48a39013f543e7eea951a8feb16952bb25f9dd34a0f05dcc28883f6_Device=CPU_Config=() -362:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=1696523c5dd3a701251583b9c9f29e43f852383cec3dde5a93e6f7f7cabf3398_Device=CPU_Config=() -362:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=abd733caa05592feccf41344f138de6625efce4afe605efeea57e0748d7b2e07_Device=CPU_Config=() -362:conformance_HSigmoid/ReadIRTest.Inference/Op=HSigmoid.5_Type=f32_Shape=static_IR=85df90c3ae7b84d89ec4eae30556ebf4af996c318afa45d90dbb219f73033f31_Device=CPU_Config=() -362:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ce2bcc21fba106cc8be4846179a73cb30f650e7ec48d443fed591f6b479fa9d1_Device=CPU_Config=() -362:conformance_Abs/ReadIRTest.ImportExport/Op=Abs.1_Type=f32_Shape=static_IR=5713be8dd761def00c701c74d0aa913d259206eff1103b9fa6de0f6f1a25e566_Device=CPU_Config=() -361:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=949611ba6617b054b828175c04452b8fcbd109c99cb25d5d8827a872b4044fd3_Device=CPU_Config=() -361:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=68c3856ae6a30752004a5ebfabb93bd0d98446a91ba7fd84e686226f45d326b9_Device=CPU_Config=() -361:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=576ef0e9eaf8fefade547928d4592bc2b341ff1100c3de5104f0a63b2fbeeca0_Device=CPU_Config=() -361:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=49245e23b8c1c485428d0e490a687e48c541bfb833eb7838efd8c112736a076d_Device=CPU_Config=() -361:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2ce1f8773e871f8aed0d3541cfafba0bb079e1765f04c1336af8a47f354cd766_Device=CPU_Config=() -361:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=9281a7e3ea8124fdbe416d1f15434752a7e799fc77a63be64babddf60b6f2d8b_Device=CPU_Config=() -361:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=7685da6dcf91a208b72d5961c2c248d816de501366163d61b1ee3c148787fe77_Device=CPU_Config=() -361:conformance_ReduceProd/ReadIRTest.QueryModel/Op=ReduceProd.1_Type=i64_Shape=static_IR=44e0e688ecb44d7a9e83f7c9e1639fae49b2883dfc1b1ed588c98c5bd1f614fe_Device=CPU_Config=() -361:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d7ce9fd9d99a7ce9ebb5fdadb4db39f4ea66f74788704b2b9f96660c7403c031_Device=CPU_Config=() -361:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=() -361:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=b92112b2ea2f233a6fb6ee512363082a49db0f85ab23f89dc29ad907e6ab408f_Device=CPU_Config=() -360:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=93dee798d72e36c04cf60499e95f84cd6b63d84226d7dd1dc0edcf0875cf301f_Device=CPU_Config=() -360:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=dcfe0aa2fab0afc3b370be59184a5e59c7bc0e8b2930bb671d1d6b38f55234ea_Device=CPU_Config=() -360:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=bec81407211db6e10d7c8811bc58b53c23c8aafa0e2083f262204f345b9bcfc6_Device=CPU_Config=() -360:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=49ed5fbacb5510d9cb3970dee136271e98ad5322b95217c6dc41026e583f3bcc_Device=CPU_Config=() -360:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=c30414e8e845d75527c26f62880518cc4d24c1a528b20cefc3b2c32be7436c81_Device=CPU_Config=() -360:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=dynamic_IR=c838ac42d5464130a9049a63f7020166b34e2ef974c257a4060fa02c3b70ff76_Device=CPU_Config=() -360:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=54009010668252832a2a755d277e9f574fd2486892184caa0eb4774e753ed094_Device=CPU_Config=() -360:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=e1a894c49294c6930cb8f8c857ec745fa2c6d18cc3607389c89af4d13df4e411_Device=CPU_Config=() -360:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=94de295ab12bd6b03bc5de22f9e9c46d5875d111eb942d3ba35f8e2456ece1cd_Device=CPU_Config=() -360:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a9b0552d84d057a656080c8e302afa30962dc02105abe7136cfd77f0433eec18_Device=CPU_Config=() -360:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7b8d235013affb9589d57a8f99b36858d739258b787cffc7cec85d1dca567261_Device=CPU_Config=() -360:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=dynamic_IR=70c260fea7c5ff6d2d1e9580ecf6c6a8a26c0e688b4f8dc4540888526bc13e76_Device=CPU_Config=() -360:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=3e016da7faeea7044ea204d1c3a2f1729d3d7ef0be27f5b769484bc7aebea5ab_Device=CPU_Config=() -360:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i32_Shape=static_IR=cd4d566c041357cdd7f8539933888956fff5cfd15e3c42872df59d9890c169b3_Device=CPU_Config=() -359:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=12e571ef61251520c35bd8c0429b1ee71277033ae88101f08dd769a300d86c5c_Device=CPU_Config=() -359:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8fa841d409e36b6665e289f4963330eaff4124d5452c93b75d779937cabe14d8_Device=CPU_Config=() -359:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=() -359:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=319f74dd5b7a959d0e5443c76051fa5958463cd18ec11c275ef92b77321bb93c_Device=CPU_Config=() -359:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6a8fb5f2948de2436a33999ee2a01e239193c268f61634f1e80692b0c45aa3da_Device=CPU_Config=() -359:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=0b603f9cb63e722122080ea36f76fe45b25da83b0b1e213871140e82dea5f405_Device=CPU_Config=() -359:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=939b665ae35f9a384e3119dc3bdc1904b105de495d262648282c859b0cb4c9e3_Device=CPU_Config=() -359:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=33199e062b7b59c8244477fd2682a08876e72126701842265efc0c9fb4a90c94_Device=CPU_Config=() -359:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=34404b0d0f956acd1827f417b44bc1cf1a085d6517d5d81a6c6d38ee27c745e7_Device=CPU_Config=() -358:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=539610c21b2839b71cfecbb15b7b7145f9fee8bfef8ed9e1d73aaad2de661496_Device=CPU_Config=() -358:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=7f37f31081476643f5c279fddc3d25eae22d909730b4aca0211aa70fdd572843_Device=CPU_Config=() -358:conformance_Range/ReadIRTest.ImportExport/Op=Range.4_Type=i64_Shape=dynamic_IR=0d660483dfd9c9975f102d300ec98da49785fcb6484b379c45df8a61e1292797_Device=CPU_Config=() -358:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=704412b992d55bf9ff00d823458e5d3b3a369e47b3eca3429fed94b87c8da554_Device=CPU_Config=() -358:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8ec74565f16a2ee1e322b4549ea19aa0b30719787abd90bd957e121705edb268_Device=CPU_Config=() -358:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=9c6d5cdaf19c92d1f994e4ae6cfdecf5a9ff04e47a2e0e68f3a08ec8f6e74479_Device=CPU_Config=() -358:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=f826a40d2d5d59d35300a911a15dfd8022c0fc486ecdc7f00c06a26f5dc44338_Device=CPU_Config=() -357:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fffd24bb56af50d2e56fb2abdc6c0c96fceb21f00a9a1556b3890bdc50840352_Device=CPU_Config=() -357:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3dcf824c36c868d06d715e3fe24587c31eb7cad18ae9f9e044c7f6abfd261651_Device=CPU_Config=() -357:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=356e2a728749d3970a85939d23344315d0ff533567c35a559caa3bef173b76f7_Device=CPU_Config=() -357:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=2ef8d38ce64fd0460d641e6f3bfcb1654bbe3d2c25f9dd244ae259eaa4b6941b_Device=CPU_Config=() -357:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=b6669eb568f36e5d649ae67afdecaa481064561d7a71f1aab592968aca7d8bb0_Device=CPU_Config=() -357:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=c843b49e26b9be555df454d4c63f0bff72e6ce29d3ae80e9193741500b08f424_Device=CPU_Config=() -357:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5beb9762188e985c9554ffb0a05fdc1608fb7d970baacebbbd7118186a324617_Device=CPU_Config=() -357:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f28013382ca254b4538a5527896cdfcd9d404aa854af83ef1d417abcdd781ef5_Device=CPU_Config=() -357:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=674e2446a2f5929d12d36f14451d68e7b55ad61d2d8df755e85c27c4a52943e3_Device=CPU_Config=() -357:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=9b915f1788d3d4768839d2cefe4fbba2f8b2d8aa4c22f9ad574335c22d0db1a2_Device=CPU_Config=() -357:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=dynamic_IR=edf223c654667e60869d97d2fb6a2bdf356db8d7e997b4b9a66e56445bc24f30_Device=CPU_Config=() -356:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ca3d0cbccca665493e85a757798ab5e12399ad295466cea744c7a2d278c86c97_Device=CPU_Config=() -356:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f208ab78a0ef0497856952f499578a17818269d066f4281183ef92ac2f9ce449_Device=CPU_Config=() -356:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5d738cba54fcfd696b0cb7e808dd466b4510900ccba26c728b5eb272a55d6bab_Device=CPU_Config=() -356:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=5995707c0c9656ffe179147e29d03df5a35286481a4140b7ef019434d83aaa61_Device=CPU_Config=() -356:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=451a3b635d3882a87cc0d7b3f6f74197c08b708669751bb11fef93da9604e276_Device=CPU_Config=() -356:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=f286960ead5b83e3e4015ee5751b114a9d70e90aa788e0fb004ac50b95a8fa2d_Device=CPU_Config=() -356:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=2c114b0035075d866c028f9a1168725375feac9a666a881ae6b7db6e9066bb3f_Device=CPU_Config=() -356:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sin_opset1_Device=CPU_Config=() -355:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=24920893b72e3bdf88b7e4142d1dd9ae0a679f686a3b187bf740f014d04b9ade_Device=CPU_Config=() -355:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8ad9f9e5cb26eb922d7d7d80f93be2e9d3a5ef344a013c9dd546df2ef195ec24_Device=CPU_Config=() -355:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=879bb4767167c3e9c45eacd08a14fb7e01b072864013784f924d62aad7b37c56_Device=CPU_Config=() -355:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=df97761393479b4c56cc923a2b89888b7c3fb949f5c3a93f4bba0ac8a44178aa_Device=CPU_Config=() -355:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=static_IR=7065a836f4fd77a07431ecff6bcc591ef9b0160cb5366a8f3c8b8fe5f83f7be1_Device=CPU_Config=() -355:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=1d7cabddc96cb4ca2ed111c9f7a9c31b76ed9a052fd0b79db6bdc8fc55f24a4b_Device=CPU_Config=() -355:conformance_ReverseSequence/ReadIRTest.QueryModel/Op=ReverseSequence.1_Type=f32_Shape=static_IR=1ff07d9b87513cab5bbcf5059507b8c998fdb25d2802b267bb6c0b90eb3e231d_Device=CPU_Config=() -355:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=9bb8728e6e9f68cf68a9e39d1aa4c618c4aca4187d4262f735c0647d680c0506_Device=CPU_Config=() -355:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=dynamic_IR=e306da3fedc4369302fb21159f2bbbe65849661eabe5bb83efdad3e83f64fd68_Device=CPU_Config=() -354:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8f622d39d560109549e99d37f3c9cb476f4d69e8525e7a0ad8fce6fe79a6f982_Device=CPU_Config=() -354:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=ade98724a678a73bf789fc539dfa277031242ea3a694227dae29c11b45cdfb9e_Device=CPU_Config=() -354:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=7b702f91c21af6c336654c924011d0f4d149111c503c697fcb85a83cd60b7ab7_Device=CPU_Config=() -354:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=05c2f891e743416ad510bf0ebf713738bd41258123cc4bbdc5cf067f251e35d8_Device=CPU_Config=() -354:conformance_ScatterUpdate/ReadIRTest.Inference/Op=ScatterUpdate.3_Type=f32_Shape=static_IR=537f04d52049add01923acd0c57cee03462926f9ce213a4fc9774496f5f66398_Device=CPU_Config=() -354:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=817b3db8f96297276bc70f1b4854867cb92c164925c9dce59a1d054e3c315bee_Device=CPU_Config=() -354:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=08393711dca608a5beec54493fa162068673eb746a6223b6dab2640d411570c0_Device=CPU_Config=() -354:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=bd927dd60e7b65e84d03c2c01d29c6932961f801bed1312124c2212b5e22a921_Device=CPU_Config=() -354:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=() -354:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=3ca9994321c7492af9bff158852a484636638e711ae39a6acb66d273f696906e_Device=CPU_Config=() -354:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=boolean_Shape=static_IR=0702c04c1d16f65b7d552044e66732886a0b389702aa43f4c845e2460ddff1c4_Device=CPU_Config=() -354:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=a7f6c704686f1b0e6fd4ab522930aa3fb5b4cd4683b204aa31e5c73b427e7058_Device=CPU_Config=() -354:conformance/OpImplCheckTest.checkPluginImplementation/Function=Ceiling_opset1_Device=CPU_Config=() -353:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8b55c14423b60f30029c68c603417fb98119c5922e2827c60c99edc05ea813e1_Device=CPU_Config=() -353:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=822cfb44c999b67217c8fff1da18293fcbd3a8a71d901d95991ad6df22398af2_Device=CPU_Config=() -353:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ca72f78cc4db6d46ce969f61c5bf707507ed8204785159e1ac5130e7aa251858_Device=CPU_Config=() -353:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=7b9883414482f3b1108e549a9c47bb8a8aa162d962813c7e99411d000e02690e_Device=CPU_Config=() -353:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=b288dfcaf8fd8fefe24212a70255bb280e7e695badf6fad6538042701d77073e_Device=CPU_Config=() -353:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=static_IR=da15c9ddbf446de00565c83e95b8a554d400b8b925481e56eb3df41f7efe26d9_Device=CPU_Config=() -353:conformance_ScatterUpdate/ReadIRTest.ImportExport/Op=ScatterUpdate.3_Type=f32_Shape=static_IR=537f04d52049add01923acd0c57cee03462926f9ce213a4fc9774496f5f66398_Device=CPU_Config=() -353:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=static_IR=2e3f53e7b949e1dd0ab38890b0c9fc9e770dfb68569e37fa5cdd4e3ef03d6eb0_Device=CPU_Config=() -353:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=ee49657e646466b0c22aff01740a48c1cc271a828a8c3e10a21d75b04f511cb1_Device=CPU_Config=() -353:conformance_LogSoftmax/ReadIRTest.Inference/Op=LogSoftmax.5_Type=f32_Shape=dynamic_IR=a3f02c85607891ecc34c484b433c6a78333e13f3d8cd231e651f8bec26e7d0ce_Device=CPU_Config=() -353:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=db85fabcfcf049a7225468036e29c949eb779253ba145485205596e72cb8cc7e_Device=CPU_Config=() -353:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3e2e16f3ba7681bebb6b4c06788f38a40fe24e26fa3ec3accd756c87bee7d62f_Device=CPU_Config=() -353:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=4fe6c9c924477957512c3d32086ca167fe5a4ddd5cd1b90d5d32452f6de8317e_Device=CPU_Config=() -353:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=99fbf009fb26eae6bfc372a5b3d9bef89d6f82e5fa45c62cc5ece995bcc71079_Device=CPU_Config=() -353:conformance/OpImplCheckTest.checkPluginImplementation/Function=GroupConvolutionBackpropData_opset1_Device=CPU_Config=() -352:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=94693638ec4742dea16dc168eb9323995f1b2a35a53f577cf58ac3a08096892d_Device=CPU_Config=() -352:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=478861c92198ee8679e3e43476abfe79906c4ead6ee80af975af365829822025_Device=CPU_Config=() -352:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=d6be1de020bbe6277d8cacd77eece21f766e5e39badb520ef29e880d52e3604b_Device=CPU_Config=() -352:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=055b7eb16539ce5cee62e165db9a6d51a11e0bdf90bc9f82eeca1f2faac2bf89_Device=CPU_Config=() -352:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=776018866cd0a06171706794dcd0d7bb13b5960fd98a66b306ecfac7595feec9_Device=CPU_Config=() -352:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=40876e66f31053b621aea004baaba7607b9131d4fff8e8b00ed7e1e58204988c_Device=CPU_Config=() -352:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=02f589480d24784ece323ba30be856c7cc718151d3588f683ef4825a407749ac_Device=CPU_Config=() -352:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=18d294f76a0d8f4562d85033a45aaa3f2d50fdfd9d9f30e295a772fd10540d25_Device=CPU_Config=() -352:conformance/OpImplCheckTest.checkPluginImplementation/Function=Loop_opset5_Device=CPU_Config=() -351:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c80a104f5912c91154ff9731be5aaf1ce189988eb9689ebc32cf4bb8f1307615_Device=CPU_Config=() -351:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=e7b766e89f08e80fd96ba40dac738561546ca7210c4566b727ca8cb49528c823_Device=CPU_Config=() -351:conformance_Mish/ReadIRTest.ImportExport/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=() -351:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=185e849a9d8fec26bd81b2098d63bd842d34dc7a8ee7e47086a208e4b8bd9298_Device=CPU_Config=() -351:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=335e78458fe959fc5a9669069890bcc67c1f1eabf21dbfb6011cc80b8322e9c0_Device=CPU_Config=() -351:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0da39d97a2f46fcbdf524727d0283243d3bf0c3fab75f76f529b6480c84f67c1_Device=CPU_Config=() -351:conformance_Ceiling/ReadIRTest.Inference/Op=Ceiling.1_Type=f32_Shape=static_IR=1484c3d0a5a8b6d1daa002e27b07bb8ba0b5d83aae50b0a3b3bea08483815d55_Device=CPU_Config=() -351:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=29624e785b9377dbf03b9aae46e7d0049e93a94655059ec37a0fe308ff7cb9a3_Device=CPU_Config=() -350:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9ea20be5797b5ab937555c69751a5be584c73a191b3fe3d6fb96a5665e26fcbb_Device=CPU_Config=() -350:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=d2759b52de5dc9f1fa494c243d08ac40cf4e877c51323d53dbfa02abc1564e45_Device=CPU_Config=() -350:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=41c94561e79611e27aaf339205962d4967188b385d68c169b2bf4557173005d7_Device=CPU_Config=() -350:conformance_ROIPooling/ReadIRTest.QueryModel/Op=ROIPooling.2_Type=f32_Shape=static_IR=baa256d53878b528f6bdba95bf1837cc570dd83b577220f95d9c24cb26d37c35_Device=CPU_Config=() -350:conformance_Proposal/ReadIRTest.Inference/Op=Proposal.4_Type=f32_Shape=static_IR=b169d6330e4006909e4deaaf78b03e789ccd9538c5b59d9d41e05f878bb60704_Device=CPU_Config=() -350:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=0db5765bcfeb7716699abd0cee850918cf5ef18e2cfdf1614b463734ca35a20f_Device=CPU_Config=() -350:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=e020cc29b6ec76cfac0e0b52ed3024458fbeb567c4fe9932eb5257e3ade79b95_Device=CPU_Config=() -350:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=962d8a421369e4dac96b6d89d05053f63c9e5fc8b7b82a60c922432125da80c0_Device=CPU_Config=() -350:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=6faa91bd8e7037c9233825cde9313cfd2afafa21ff423a00544eaa36d734332e_Device=CPU_Config=() -350:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=d5cd3fb647dd4a57feb28366d922a151a3ffb1707864f2ac85595fcc30f222be_Device=CPU_Config=() -349:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=883597c2c4e004b0ec1e1ca8d1b75395c714fc6a99cd31e35ca0597d0ccd8f8f_Device=CPU_Config=() -349:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=bbe05f014b2e4602f4e44d9c07795321404d2459bf782d2dd406de14bd2bd523_Device=CPU_Config=() -349:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=i32_Shape=static_IR=f777fb31e1669cd58cc77e2a04c3f9a804b654b6d710432641a3dc34504460b4_Device=CPU_Config=() -349:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=564cd54b2564c7e39fda0c5e580c274b7bf99603760f6c66f03b4450f23cc4bf_Device=CPU_Config=() -349:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=22707f4dd48a39013f543e7eea951a8feb16952bb25f9dd34a0f05dcc28883f6_Device=CPU_Config=() -349:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=6837cea94eff6256c3c29807532662e123ccbffde1fcb6f75875d65aa7124a4b_Device=CPU_Config=() -349:conformance_LSTMSequence/ReadIRTest.QueryModel/Op=LSTMSequence.5_Type=f32_Shape=static_IR=1f24aeeef6f9f91272546fca89299c1ce448b0008fe43905db434ae3f28a75d0_Device=CPU_Config=() -349:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aaafa4ff22a5fcab1e6e0f48065210ff790275fba7a5c16602aa4a00951a8cb8_Device=CPU_Config=() -349:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=6e508ca44667fb311f5b6d634584d2751c3fb15fc034626765c90695b7de9619_Device=CPU_Config=() -348:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c90ac17f02f16c647a0a206326f24ac348a0f8a7787037486e52ecc8c091818e_Device=CPU_Config=() -348:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=259cf71b937e6d184948130afa5684d7539769988cee7a74b06138ad4d09c689_Device=CPU_Config=() -348:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=b7aebb27d8d2b43e770ade887778c291072210b947b77b1b92e05d3327843977_Device=CPU_Config=() -348:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=b4f42a7d1252f2dd02b31ac7b0cf4ffcbd452dbf0e508833e7dc709ee04889c3_Device=CPU_Config=() -348:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=01d609bdfca9f2a499a564f66ab9dd71b394310593d27b8739283b19980e2dc2_Device=CPU_Config=() -348:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=e7ab5b597681da2db03c13a2424b4e0a62135eecfb2f97f4c59b53331afb7f85_Device=CPU_Config=() -348:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=01b095b8763565527be0de9edff565070949485db907493e99e95c2cddf6abaf_Device=CPU_Config=() -348:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=ff96b044b0064dcc13dc7c1d80f2b2cddde0ead8c4501d5d741034833079d47b_Device=CPU_Config=() -348:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=d507892556310f7fe85cbf9245ddf040b219ec8cfe9c779809180a011caab9d6_Device=CPU_Config=() -348:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=de01a0d560bebb0018927f02409922427ef35b59a96f0aef8f18991ee0d9542a_Device=CPU_Config=() -348:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1c9d69e1a85d03b8599961a8a1b90af7b3b2d43bc5c4f4a6b8d5da3c22166abd_Device=CPU_Config=() -348:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=77d771a04d8618bf32943e460b714076f7bbc34cd1d40f9a90864af976bea30e_Device=CPU_Config=() -348:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=6e614b9877c6dd3bf1ebd731443e5a1e0b7492edbc3a4683adcff53c965ca1bb_Device=CPU_Config=() -348:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=486675b6412030beffb4209c326672af07d343d5e1bbca31b9bfeed3cc339e3d_Device=CPU_Config=() -348:conformance/OpImplCheckTest.checkPluginImplementation/Function=DFT_opset7_Device=CPU_Config=() -347:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f83f2d7d9c08aaf30635b39b51c0d7f1f622b4624da59c6cbcdf28d42470f11d_Device=CPU_Config=() -347:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=static_IR=2b026a0d21a35251b07099e31ec58c459b848602575d2afa67e55830e8f3f411_Device=CPU_Config=() -347:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=a5dc3f8dd6385eb7f6d4052af82e27b7af7e8a58bdcb6092ec79ea3087f141c6_Device=CPU_Config=() -347:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=08b46b9b2881764fde87811d2462a361d75c30fcec74f631f116f010953daced_Device=CPU_Config=() -347:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=e939c4d2a27e1d7dba93827ab807881c32e47d48b726fec701712bc85c3404a8_Device=CPU_Config=() -347:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=725aaeceedd7eba9be6ba4203e31cead733ed80dbafc33e902465d4338dc8f4c_Device=CPU_Config=() -347:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=f0edc45979b98d4401eea2c345bbcb794721dd3cdbfb3963be5a2842b27ccc5b_Device=CPU_Config=() -347:conformance_HSwish/ReadIRTest.ImportExport/Op=HSwish.4_Type=f32_Shape=static_IR=98546b7eda390c30f82053a093b5e3855c6dc8c631451b3637eadf95858af2bb_Device=CPU_Config=() -347:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e7e10785757d3131ebc375ebfd83c556e2c34a72be20965d9dd3e4f24a5ee2f9_Device=CPU_Config=() -347:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a1e0bbe02c433cb144b4825a9f1b2c30c03743f210830db5462736850b6db383_Device=CPU_Config=() -347:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=14108fac0139d5bb39f6b2106857e1ac91c8d44ef9156e4e0873facf9d932316_Device=CPU_Config=() -347:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=547fea7da34d5e65ad7ea069be003753e9ef281110c80dde11520bc350c4ca14_Device=CPU_Config=() -347:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=3c1c8bc7ce009c03509ca9d6a86f3d5cff89be49439e7513edcde4e62fbfb8ce_Device=CPU_Config=() -347:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=b005a58abf8192face35451602a847d378849223e4d433924581d28ef8141303_Device=CPU_Config=() -346:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=64358a022d0c072ff89427a2f3acd3a3afb49b8f76e57353eb95962fd2572ca9_Device=CPU_Config=() -346:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=42afa027ada245d36900a89c54a870ba5fc7fe3cc3bc0fc7dbda23af3e5111d8_Device=CPU_Config=() -346:conformance_HSigmoid/ReadIRTest.Inference/Op=HSigmoid.5_Type=f32_Shape=static_IR=cc18959ba7c26661ba0f986207bd00aca503bf924b31c4a2070ac40ac3ec5468_Device=CPU_Config=() -346:conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=48256cdbf5a3d19f0b7bb6b0540cbd664a36885a88fa8f5f56da7057de97a608_Device=CPU_Config=() -346:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=8b8121ebbd51ee995f98531f595145a01ba70ce026ad0bee588733c33e70272d_Device=CPU_Config=() -346:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=7e1801bf4ef7ad1b27663dfb399f318ccb2526e925d48e3d30e2ab837824b217_Device=CPU_Config=() -345:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=2c5e9a1cd59ec2d5786132697bfcb1519a7857cdfe06038bb39abed39c09e9a2_Device=CPU_Config=() -345:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=48a273073ced3efa39d01e5ce40c30b2901e8a3dff0b414911282b8fdfc0b09f_Device=CPU_Config=() -345:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=f45b24f3bf21a2c94bc89cdc3d20c283d47f4e6ea386444897330e232bd7d90f_Device=CPU_Config=() -345:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=6f2159bf315f062962fe87512c15ed5cacf09f898397a92b690c32caf147e50e_Device=CPU_Config=() -345:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d7e3ea8c5ea46f1b0430b6a2763c85395235c0ac58652e1d269e1257f6dbf7c8_Device=CPU_Config=() -345:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=cc989fde083332a75d3066112105028a711bdac4fc44463d098022774da752b7_Device=CPU_Config=() -344:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1457b3d8c7f130113d74f540dfbd2d4062f869018f7b1afb11c743acc0a007b9_Device=CPU_Config=() -344:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=eb966d8fd7e1301280e6ef709dd785d210a35a1346eb88c3f38379bd96036ce4_Device=CPU_Config=() -344:conformance_ShuffleChannels/ReadIRTest.ImportExport/Op=ShuffleChannels.1_Type=f32_Shape=static_IR=46e851dee1f7bead1a6e2459157df33266c45559375a1caff90a2732cacaf881_Device=CPU_Config=() -344:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a78437a93ab424a706d064188d1bc0971b2e1afc98a74fea979a6f8b99036597_Device=CPU_Config=() -344:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bb610d59221e7c5d8e96f971519b7ef27bda7bbb9be329b873a901a1e749b9cc_Device=CPU_Config=() -344:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=79e0a530c5a64063a9af26b438f208476e3bbf5a267c28ddded0459019a1d8e1_Device=CPU_Config=() -344:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=e15d2825807b2c7fda150b7b7b4e2c6914fab2d4af4313e959abaff56dffe6d2_Device=CPU_Config=() -344:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1eb25d18fbd1070f2a8ff803d76077d092d493f9e9df80e93e2f58f3621a121f_Device=CPU_Config=() -344:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=09c1f9f81a463477da73d33f00d1321fa5c1f64a9c3c51c6e3c1344e362d4ced_Device=CPU_Config=() -344:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=93ce70e605eb712479090e3a266e86eb7422bf0fdd3acb1c38a0b92a9c381e2c_Device=CPU_Config=() -344:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=5d68272f8318c073e481b5353e6e4350e6b3b5e120f389a98859dbd5af43db9d_Device=CPU_Config=() -343:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8042d30c9796e8eca03cb2e3651f84b5167204aaf186ad08ad5f74a9b0a26b9d_Device=CPU_Config=() -343:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f977fc239a0230860702f8c1971bd424f10b978bb03937668c37edee6777f12b_Device=CPU_Config=() -343:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=89dcb383b48e2a4423a7c81461f282b74b1d9ab0f48f0a0427cd4c599672f3fb_Device=CPU_Config=() -343:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=() -343:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i32_Shape=static_IR=c78feba7097eb1c59197840a7e5510c26faeaa51ff724d643dc1f1ec077a6344_Device=CPU_Config=() -343:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=u8_Shape=dynamic_IR=b12ccd794c23494b994608015d049eec0f2ca30dc319bd35c1adddb3e4b8e631_Device=CPU_Config=() -343:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=d8546655166c322e3049ed3a71725c8e89901212007c44c8029ef8379de96db6_Device=CPU_Config=() -343:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=8d472bf25f969c5ab5eb85fb198c2176766a2de7cd444819e8b60d416969e3c4_Device=CPU_Config=() -343:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=ea71ab322d6f3d74b0a7bdc3ff5dfd322f2d8c518a1fb5bc9960c5e04808f28e_Device=CPU_Config=() -343:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6eb80b60b2162fc469f652535ee11822ae34c903ca44191dc95ad7f9678b9337_Device=CPU_Config=() -343:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=54a5630072fb0e0127611a4ae63db14b7c0fa0979f4d2be7bfec548b5291a0af_Device=CPU_Config=() -343:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=681b1f284fb69c16681d3efd2081d7f812496e3a027baef35a75bb0aeb9c003b_Device=CPU_Config=() -343:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=4a64918e1c0c648268ad4a1c2147889b2578b4513693737ec2ea1c7ff81dbc52_Device=CPU_Config=() -343:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=3fec5c6f9e39d8a15d58c5800a889e1660adb375cb7660af1526cd31e69f7cdc_Device=CPU_Config=() -343:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=f826a40d2d5d59d35300a911a15dfd8022c0fc486ecdc7f00c06a26f5dc44338_Device=CPU_Config=() -342:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e250a19bfbe236f81b6715a92beb0c259080e4a5d379ea1187892e8c8d9add8a_Device=CPU_Config=() -342:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7b42d3a61f732f3639d1ae7011b86158d070acc922308a18f00a01b9c6a60ead_Device=CPU_Config=() -342:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=936ac30f388261cb12776b5e94062a9b5f7b81aa16c9aa5d8f994b8d69231c40_Device=CPU_Config=() -342:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=e1d727df48a0a74d8b9865c00e5c39c9d53a5023d83da3c58f281b6b1411b696_Device=CPU_Config=() -342:conformance_Range/ReadIRTest.ImportExport/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=() -342:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=659cd025e440fdc633859089f52f7f38cab5701c63c79d1e8d1837c217b8cf75_Device=CPU_Config=() -342:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=9c63b760d92c46d2ba731cb9edc4cf19a96848e4f3c354797f10a7a1bb9edf8c_Device=CPU_Config=() -342:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f06ff28476f886d4298a83d39f88aff34399d5cd589e0a6d6395e00b0ad96876_Device=CPU_Config=() -342:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=58b9cf97229bd8293e747a47979c3d98261275f9da473dc942b746a06a1fa214_Device=CPU_Config=() -342:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=f0d5131a073c03932316e3f20f40c527ddabafc926f0d10824a96158c03524b8_Device=CPU_Config=() -342:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gather_opset8_Device=CPU_Config=() -341:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d74cf8dde02b582dc1efa697474a50738532e0ce5b40831d81d0852a74a94c79_Device=CPU_Config=() -341:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=95d9789ef78c733e0c7972738bafd4da289a90f0d9ea00bc9452192173390b6f_Device=CPU_Config=() -341:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=() -341:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=c61a8f259a8b37e49f9267dbc921d88dd60e5766aa30dd05319f423a01c14aee_Device=CPU_Config=() -341:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f8a096633b64512b865ea5e4a57529cbf621afedcb873285bd5e24cdb199a46_Device=CPU_Config=() -341:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=50a0e83d438a3220ed14dd8ae783e92c96381f645b10719669054ea944297244_Device=CPU_Config=() -341:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=152333527a542f3e2228bac5d0fd4ed288dde9205632a318b9b22b64e43be329_Device=CPU_Config=() -341:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=9d4ebc5a7d195ea0e566695253c38ac5d02fea1f4fbe97396828ef9f7754808a_Device=CPU_Config=() -341:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=349d64660bcbb9269f88067431a4b8fc31fcfd09ffb1afa9f3ecf4bc37e8c4ca_Device=CPU_Config=() -341:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=f61b45eec10f28e255a0f82842384e1c947830dc5d5618bf00c6385cecbab8d5_Device=CPU_Config=() -341:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=1e95665a92aa6efcc7e06d24fbe4cb2afa07d75374cea3ea928658a270ef489b_Device=CPU_Config=() -341:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=dynamic_IR=79cffe28ff617b42488d33b204b0f50bcf4e304c74d2a11820c830e091c6383e_Device=CPU_Config=() -340:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=a16b5a0ea2fc8d89980db21cab743fbf776918ed2ed1f91f2e4d3ad3c304d4a4_Device=CPU_Config=() -340:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=797bfeedb05fe1883757101c44e78eb807ff9c3570aa58b0891172e729d4b384_Device=CPU_Config=() -340:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b0376bbdfc6560184c2eb15a9cff7fc6d6b39c47dd22936fb64629d345e227d0_Device=CPU_Config=() -340:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=u8_Shape=dynamic_IR=5de1e1eb337f4eff857dccbc075ec7079425a50de3096d4f81d25f0118acc6fd_Device=CPU_Config=() -340:conformance_Round/ReadIRTest.QueryModel/Op=Round.5_Type=f32_Shape=static_IR=f4cc9554ddbd189f18575e3a80afe6e8f8bce613dc8852a48d4171ab6916e087_Device=CPU_Config=() -340:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=boolean_Shape=static_IR=6d34694c9c8e71415be894a80a8ededc6a83657c6e7ce3aaf66dcd6f9ab99226_Device=CPU_Config=() -340:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8596cca11141e34e75c884b1be9a75be19663caf4c0b1b4275f6035a73d62e_Device=CPU_Config=() -340:conformance_Proposal/ReadIRTest.ImportExport/Op=Proposal.4_Type=f32_Shape=static_IR=c0884ce897724cace24b30df395a33443364f8494f1f8495d212f2db20fc49e2_Device=CPU_Config=() -340:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=927c151867c504f57aea681772afe32ec9c67cdaa4a0dcbc9055a8725c0296dd_Device=CPU_Config=() -340:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=77b3b21d35d3742f7abc1097b99d510453f42ebe921681685fbc457d2fa9912a_Device=CPU_Config=() -340:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=a5a2ba7fff85401feb05248462e85d334440769790e7e6ba1a75ffb413f7fc64_Device=CPU_Config=() -340:conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=() -340:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=6e614b9877c6dd3bf1ebd731443e5a1e0b7492edbc3a4683adcff53c965ca1bb_Device=CPU_Config=() -340:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=4d14510ef37733d7ca3d69697626c173feb05638f5036c49b060f6a80aea9ada_Device=CPU_Config=() -340:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=18d294f76a0d8f4562d85033a45aaa3f2d50fdfd9d9f30e295a772fd10540d25_Device=CPU_Config=() -340:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gather_opset7_Device=CPU_Config=() -339:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=6e53e1fedd57631f3ec70d6825d8d1029ac95905b82b6bef7fd44ba87373e9c6_Device=CPU_Config=() -339:conformance_Swish/ReadIRTest.ImportExport/Op=Swish.4_Type=f32_Shape=static_IR=d79b47022a50437c9df095b34e515c53eb042c9813fcf6dc7bcdb96962818ddf_Device=CPU_Config=() -339:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=f32_Shape=static_IR=c14da825d470c9141af0ea87eb82edd0866a415cb5ac59f1014c2ded35340201_Device=CPU_Config=() -339:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=dynamic_IR=dac2c804cd13d69a51906319a3648ac0edd87764c686c99fb47179f379cecf7d_Device=CPU_Config=() -339:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=b39441c49977534ef3b2d1c4a9d7a5a0aedd66c7ba0a6e1be3446151a8e18317_Device=CPU_Config=() -339:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=3141ed71fe3efbd7fb026a006824ec24e4673d8b97d23dce275548e92eedad91_Device=CPU_Config=() -339:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=4c3b0cda20bf6b3c574eaefbce21b9b2b0ed92fa1b37c32af252b111b6466d0e_Device=CPU_Config=() -339:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=dac1d1bb4f11cef03519894a2853742d914abb0e3225b7caa3bc5f23d167cdaf_Device=CPU_Config=() -339:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=79e0a530c5a64063a9af26b438f208476e3bbf5a267c28ddded0459019a1d8e1_Device=CPU_Config=() -339:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43ba20ec70e156f4782e1f11a30f02daaaafb2039912a373620d845e995c97cc_Device=CPU_Config=() -339:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=cbfc33348aff4daf15fb7926884243c7ffe38aa29e60eceda90fa9b8aadad5b1_Device=CPU_Config=() -339:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=23ad83652d315aa08ee781b0fc81c0eb737265280c85a86a4f08cad71b33e74a_Device=CPU_Config=() -339:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=8b9cabc6a44ece744453092791ef63b8d6ca4d83af7e8635f2f4ad78186e5184_Device=CPU_Config=() -338:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=81954ff76e3fd04ec3b3e3c26e28a79ac259c9b255f90ebe3cc0772fb673874e_Device=CPU_Config=() -338:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i64_Shape=static_IR=38f6cef69f6a7d9886b5d38902fb76e4ae41385fb3c95e229be4b44456ab2e87_Device=CPU_Config=() -338:conformance_ReverseSequence/ReadIRTest.QueryModel/Op=ReverseSequence.1_Type=f32_Shape=static_IR=a5cc0793d73f7f76fc02b5ae04ef2a29bf212ce5c59f9bbef91e0aa5ee17785c_Device=CPU_Config=() -338:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=e7ab5b597681da2db03c13a2424b4e0a62135eecfb2f97f4c59b53331afb7f85_Device=CPU_Config=() -338:conformance_ReduceProd/ReadIRTest.QueryModel/Op=ReduceProd.1_Type=i32_Shape=static_IR=e34207bf06e51dbf322bc0db76f3a9828ae018b02dba2b1826ed97004bee8125_Device=CPU_Config=() -338:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3b3a5cbc6a255792eeeec698aa5a90947164eab96ec744ada9d02b6c7f453f8f_Device=CPU_Config=() -338:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f82842bfa510be994f17d9c00d43b6f67b232b3a41c64ae276e243610d927d9_Device=CPU_Config=() -338:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=() -337:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=525ed9b2af76610bf0ee3d11cb1dcfd46059335968359c143d0da7465736ac2e_Device=CPU_Config=() -337:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=12965dd8a422975f08bb0fc707c666ad7ae2671d09c68757d534e3a1d67efd41_Device=CPU_Config=() -337:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=() -337:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=6ac457e9181610da9eb4bf0bec6cd53bf3078e0b84df1211f49921207d81c6e9_Device=CPU_Config=() -337:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a8ca0b23e0a0f66247fc693c6a8982e4f7daa11e14da296db0dbc9277fcad4df_Device=CPU_Config=() -337:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=bf4d5291899ea4eccf6584f62d4ecdfb39de79edd102e509f840664838f59d19_Device=CPU_Config=() -337:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a24dd1485e484f31d0c72f3a0c31f373f883f6ca4a751b1d2ce18132913506dc_Device=CPU_Config=() -337:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=30dd450fadb8a1081c1315cd0e5234728862b4de39b097a5a3248d551369b60a_Device=CPU_Config=() -336:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ac40c4284a523b39af21eda7394a11b9ca2f2deb5263c03c92c0e217d34bedad_Device=CPU_Config=() -336:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fe5cbe273830f6a09e3f18eaf8e9410f9f7f1083af508a9dcaf5f0f22aa3ac1f_Device=CPU_Config=() -336:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=df19449b7a95887e834ba16ebf2e1f08416d6293686a6cb6b6cf39fc82559595_Device=CPU_Config=() -336:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c39e4c1d9cbf5b8730644e1686cc09f36f7e4a4b89cadaf8d8902fdb27993a7a_Device=CPU_Config=() -336:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=boolean_Shape=static_IR=6d34694c9c8e71415be894a80a8ededc6a83657c6e7ce3aaf66dcd6f9ab99226_Device=CPU_Config=() -336:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=f32_Shape=static_IR=7ad6fe3ff1472399c9c0e12aba1db89105e1e4a243cd092dc43ee763a2571fa9_Device=CPU_Config=() -336:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a7d9ffa60c8d1f330ec303edf6a6c0f8d8e0fe8657c561431bfb91a94c2639e8_Device=CPU_Config=() -336:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c3c821b46d994404c55856237eb70534cff33687df2bde0a86d0bcc9f20878eb_Device=CPU_Config=() -336:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=93788242c06d787e33afa50ecbef5372898e50024d0c88624056a752535572bf_Device=CPU_Config=() -336:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=c3f8bb35f2f4473c563c3e5171a8fdc6f7a0ae20e4acde31a578bd20630952fa_Device=CPU_Config=() -336:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=6d7cce19ff10d7690177fe1e3200d872ef5d8827b7ff49e6c9994e597a15dab2_Device=CPU_Config=() -336:conformance_Ceiling/ReadIRTest.QueryModel/Op=Ceiling.1_Type=f32_Shape=static_IR=1484c3d0a5a8b6d1daa002e27b07bb8ba0b5d83aae50b0a3b3bea08483815d55_Device=CPU_Config=() -336:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=34404b0d0f956acd1827f417b44bc1cf1a085d6517d5d81a6c6d38ee27c745e7_Device=CPU_Config=() -335:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=dc350b3fec164adcb096b8fc922e342cf7b0c6f7a4aa25074bec5566225cff01_Device=CPU_Config=() -335:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6b86bf4f834b297dcb461acb5854aeb9783a381521ea1a8e1cf4fbeb60d6d09b_Device=CPU_Config=() -335:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=64d7467cf7785e52814a8c25f96c1a5d82c071ced27dea8302b5cd69b464ac65_Device=CPU_Config=() -335:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3fb25dbf33700d0b8ebc3c53fe328f2ee9f45c5a090240eec120b954998d17ce_Device=CPU_Config=() -335:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=d6be1de020bbe6277d8cacd77eece21f766e5e39badb520ef29e880d52e3604b_Device=CPU_Config=() -335:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=dynamic_IR=dac2c804cd13d69a51906319a3648ac0edd87764c686c99fb47179f379cecf7d_Device=CPU_Config=() -335:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=b39441c49977534ef3b2d1c4a9d7a5a0aedd66c7ba0a6e1be3446151a8e18317_Device=CPU_Config=() -335:conformance_ReverseSequence/ReadIRTest.ImportExport/Op=ReverseSequence.1_Type=f32_Shape=static_IR=1ff07d9b87513cab5bbcf5059507b8c998fdb25d2802b267bb6c0b90eb3e231d_Device=CPU_Config=() -335:conformance_Proposal/ReadIRTest.ImportExport/Op=Proposal.4_Type=f32_Shape=static_IR=b169d6330e4006909e4deaaf78b03e789ccd9538c5b59d9d41e05f878bb60704_Device=CPU_Config=() -335:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=f110ef35c9642ecd941cd85a67a12b616353d4a8cd33f9770d532759e2846255_Device=CPU_Config=() -335:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=03ebf297344daffba82d04292a767fcd7c959f56788ede32ff0d7c5af06ea504_Device=CPU_Config=() -335:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=941fa6fdaa34b8082171350da966423497232e44077f333cf3a46488bf237aeb_Device=CPU_Config=() -335:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=6b69e46c11a2a82ac7ad6697cd768d88da6e870e75f489779bbd1714bad23450_Device=CPU_Config=() -335:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=0c6a844f626f6628628034d332ccb6d520e0447e4b616048c7efb516d0fd87bb_Device=CPU_Config=() -335:conformance/OpImplCheckTest.checkPluginImplementation/Function=Roll_opset7_Device=CPU_Config=() -334:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9465b2ea76ea3be1365dfe1255524d4ecce0dff6123e929a2157bfc767396b0c_Device=CPU_Config=() -334:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=16b3235d5271e534a1bc725f80e2bfcb837a1c6f144bcfe8211a3e5359644441_Device=CPU_Config=() -334:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=7e386c35d9d397e043876a23a2b9e5885964cee59bf46f1ae0660e6a84641ea4_Device=CPU_Config=() -334:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=u8_Shape=dynamic_IR=5de1e1eb337f4eff857dccbc075ec7079425a50de3096d4f81d25f0118acc6fd_Device=CPU_Config=() -334:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=8b8efa859c54f9cf2200c18953de243d469d2f04bf38ba5f3efe441de23ffe45_Device=CPU_Config=() -334:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=109afa0426a29179db58e16917b829096af105f0def2375a589ea1391138ee2f_Device=CPU_Config=() -334:conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=static_IR=944072d96554abf3ceac6b928cc00ea1705d5e0dfae8e9a0662de4e56fb3e62f_Device=CPU_Config=() -334:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=33d84638f606d759354e190991899e47d2f4c63b0e378aac985e5fb9132dcd01_Device=CPU_Config=() -334:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=b434cd386e4c5e688aac8da3425d2ed0d72961223eaaa1cf2ff951a88a5fa001_Device=CPU_Config=() -334:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=dynamic_IR=08776190d0fddfcb15ad75cdbf6892de03f79e89d57e02b7c3e80b4a7a125d35_Device=CPU_Config=() -334:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=f6f85e9282e58756d40411508d6edaacc75c0f4e64d4e25021ade07ba17bd8ce_Device=CPU_Config=() -334:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=12e7ea655764a32069a93a3f7ab147983bceeacc8a2bc88fbb2def005a1596b3_Device=CPU_Config=() -334:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=u64_Shape=dynamic_IR=5f87db7fc306440f807b413acb7eb175932f29f59d1b5eb4a9df8945b9aef9d4_Device=CPU_Config=() -334:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=0cc60631ab50733ce6b7a2256c0db1f9d9338505ae85b30fee02026c28511383_Device=CPU_Config=() -334:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=9d26a7c321db2d87b29b93baeca20dd25357e7777261ea6a4cbf968a203969ea_Device=CPU_Config=() -334:conformance/OpImplCheckTest.checkPluginImplementation/Function=ConvertLike_opset1_Device=CPU_Config=() -333:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5288d099588f5876e907c5cd750c9f0b2191d1ea060881e80af1006cfad259ac_Device=CPU_Config=() -333:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=d6250086b712a16042ee74438bb61b89fbfaa5bae433049207402d1da4cffaef_Device=CPU_Config=() -333:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=() -333:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=d9231cf5e3e491e318f16514e771cfdee4b781b42fc9d45088da850ab48079cc_Device=CPU_Config=() -333:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=6ddb35aeda2a6cb63282d2fcf6503aa02135ad60e23c752280ef82aaf6a31191_Device=CPU_Config=() -333:conformance/OpImplCheckTest.checkPluginImplementation/Function=Unsqueeze_opset1_Device=CPU_Config=() -332:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b3fdb9be3484a0c498bf40f1a102c452eea04caa5b1dd627e8267087df0acc87_Device=CPU_Config=() -332:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f89e84d6fb931cf0cd074acd01a50e50daa47ad88b1b74e4b3671d63bd7889f2_Device=CPU_Config=() -332:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=ee49657e646466b0c22aff01740a48c1cc271a828a8c3e10a21d75b04f511cb1_Device=CPU_Config=() -332:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=8d472bf25f969c5ab5eb85fb198c2176766a2de7cd444819e8b60d416969e3c4_Device=CPU_Config=() -332:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=21a3318957d920b39d8b3d84c76cfd2a5ad98515824f88145326deead0961486_Device=CPU_Config=() -332:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=ea71ab322d6f3d74b0a7bdc3ff5dfd322f2d8c518a1fb5bc9960c5e04808f28e_Device=CPU_Config=() -332:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=dynamic_IR=5c05bbc013fc857a8f2b340df778f3ad5bdbc1b7273cf41b23d6da410205c612_Device=CPU_Config=() -332:conformance_GroupNormalization/ReadIRTest.QueryModel/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=() -332:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d242e8ecc8ae0239fc2e7773fe0f8a1d50792a71ae4aaac4fd439174e87e95b1_Device=CPU_Config=() -332:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c1852c534b8b95bf1a9aa2771decf2368fa095c5f5688d38ab9ce0bd86152a19_Device=CPU_Config=() -332:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=64bd2f48b3326db083653b5993c9a75d21be515cbc5af67c62c981e9744e2f0b_Device=CPU_Config=() -332:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=550d5d475e0f53be8506153a78626cd5a5c0a949b9bbd9e2fea96a4ba2f7b908_Device=CPU_Config=() -332:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset5_Device=CPU_Config=() -331:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a48d232b00b4d4a735d6b9999c29b413a32cd7f05c104610a11cab01465a3887_Device=CPU_Config=() -331:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=87baad85c649084e386ca502375581e9dc47c68c076bacae5e5ac1ddbaaa7830_Device=CPU_Config=() -331:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=e8df0b3ab9e127c1d37881f4c250ca0fd0dd2ec822cd24bf95e7860484fe9b8a_Device=CPU_Config=() -331:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=u8_Shape=dynamic_IR=b12ccd794c23494b994608015d049eec0f2ca30dc319bd35c1adddb3e4b8e631_Device=CPU_Config=() -331:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=990cce0ce92df99ae74ad8840f7b89d1c48c0044deb9cb71619b44a565eed911_Device=CPU_Config=() -331:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=dynamic_IR=502fbd3f8c0e9c0a9523269a9df9b0fbd83d59ca94f373fd543048429a957f5c_Device=CPU_Config=() -331:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=f8b14e90b051624d56678dbe68f15e6db94e22878b22914d0be241047d1a3783_Device=CPU_Config=() -331:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=61091e18fb5e9eddcab243ec79234ef3b93a5d01d9b2611a3a0e027eed4e4b31_Device=CPU_Config=() -331:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=66df22ce11e7009aea35ba6a11b4294eda44815bf041eed0721499a3d2c484b1_Device=CPU_Config=() -331:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dc9060efbe22735c22c69f0323c7e6a77a30cfbaae7b79670b9b26fb2be70_Device=CPU_Config=() -331:conformance_FloorMod/ReadIRTest.ImportExport/Op=FloorMod.1_Type=i32_Shape=static_IR=2d09fd84ef3e176a2eae04f1066929ceb3973045b87989e5f0f11b97cab6cc7c_Device=CPU_Config=() -331:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=117fd22d36b97216edb2112c043ba97872b9b7915d7909dfc395406e8ad91e4d_Device=CPU_Config=() -331:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=6d7cce19ff10d7690177fe1e3200d872ef5d8827b7ff49e6c9994e597a15dab2_Device=CPU_Config=() -331:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=9ec0516350dc25e0dff22b12b65f761cd4e2744881c1f356f9ab50680eee1a69_Device=CPU_Config=() -331:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i32_Shape=static_IR=a3f2389f6a8a495885efa87742d53e1e154f58f8fd6e83df89bddf5922247095_Device=CPU_Config=() -331:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=a3032224f3e9c096102921fd8571966d23c21cba931b9d5e31ba41e9698d07b6_Device=CPU_Config=() -331:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=eed21ac7c17920ba437332691e231037113367ee3d256b4db1380c8d2e0db84f_Device=CPU_Config=() -331:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=a3032224f3e9c096102921fd8571966d23c21cba931b9d5e31ba41e9698d07b6_Device=CPU_Config=() -331:conformance/OpImplCheckTest.checkPluginImplementation/Function=Einsum_opset7_Device=CPU_Config=() -330:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0b7d6fb137555d6fde92f0c9b3e6278715adaeb38cf760236070b17bafb5babc_Device=CPU_Config=() -330:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=adee3d4d6728b17fb5ab17a9915c5b7c8808f949ad358e8a16a0bb12dad7c958_Device=CPU_Config=() -330:conformance_ScatterNDUpdate/ReadIRTest.ImportExport/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=b39441c49977534ef3b2d1c4a9d7a5a0aedd66c7ba0a6e1be3446151a8e18317_Device=CPU_Config=() -330:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=() -330:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=cd5756749d3d73dc7b666f7f41dc292c73230e5d31ddbbd43aae77210b86220a_Device=CPU_Config=() -330:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=596d0b6cfe8b39e0ceaa665f1fa82aeeeff78d09315fca7cef031b6dc210a1f3_Device=CPU_Config=() -330:conformance/OpImplCheckTest.checkPluginImplementation/Function=Clamp_opset1_Device=CPU_Config=() -329:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5f45e938f9e6d58ccc6bf771049731f2d9c4a8b0ed83e2a1942ac69ab76984b3_Device=CPU_Config=() -329:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=920aa0d732c7ace2bcfe73df0e7217e66b6388dce554ef827efa96f4e7d31a2f_Device=CPU_Config=() -329:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=3d37166487c5c52af657343f8fa10903efc7d580d5b370a519a0ccfbf6fc56bf_Device=CPU_Config=() -329:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=a94e0bbcae35d7cb33efba2c6df3275f7bca8520ddb37eeeab81829906fc8964_Device=CPU_Config=() -329:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=98274ec3fc894754adaacedf83b4b7da373e639a51cfa7dc348412898e45e8dc_Device=CPU_Config=() -329:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.1_Type=f32_Shape=static_IR=f735a44db0a337a22f5ebed052a5718168765287ff4e0eca961c3f9fd68586c0_Device=CPU_Config=() -329:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=i32_Shape=static_IR=6650e462a4f0086329d8576eb6352979e89825517f48e264fe719c7c5ca276fc_Device=CPU_Config=() -329:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=68853f0b8867d4ddb5eeb239690f1b41600c05f64ee4d3efa8cc828e72b9bc1f_Device=CPU_Config=() -329:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c1ffd0690c9370725a30028d2915ec798aff173f86a1864f3dc92a4defefef85_Device=CPU_Config=() -329:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=256f748d7b98b0eb70cc659403910bac929d62a2b153e63438f8746f602a83fa_Device=CPU_Config=() -328:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9f8fca1ab855d5a71d7acabdefda202e270bf16b559fd581f9e663caa301ffd7_Device=CPU_Config=() -328:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=2ebbd25d315f10aa32cd8251ced4e269c1688202ee64b4fb5245e4ab53cba16b_Device=CPU_Config=() -328:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=28675c37d06426cf6895e7ffc15d6c212ef8be1b278fd199d1bfbd0678f825fa_Device=CPU_Config=() -328:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=e7b766e89f08e80fd96ba40dac738561546ca7210c4566b727ca8cb49528c823_Device=CPU_Config=() -328:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=81c2956d325aab4a7bfd931d94151e1285083a15326e0890f861b97017a24bb9_Device=CPU_Config=() -328:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f82842bfa510be994f17d9c00d43b6f67b232b3a41c64ae276e243610d927d9_Device=CPU_Config=() -328:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=30466048a7da9db59d20a210af1979341f7b9552362e64a89357d650102a213e_Device=CPU_Config=() -328:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=3e016da7faeea7044ea204d1c3a2f1729d3d7ef0be27f5b769484bc7aebea5ab_Device=CPU_Config=() -327:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a9d3d025df92369ee1f1a81fe676bb00d7d6cc488868e04d0e713fb9e42451a9_Device=CPU_Config=() -327:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=9efd5749a1591709057d6e97334c9b5b89f5864d705c91774e0196d42966d1b9_Device=CPU_Config=() -327:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=e7e985d4d02762d236131e74fd867acff1828bcd4c4eb32e190de20eadb831fb_Device=CPU_Config=() -327:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=f2df871f255156043f03f34333d59d9213fd52ea24f69dda1b04888ed269acad_Device=CPU_Config=() -327:conformance_SpaceToBatch/ReadIRTest.QueryModel/Op=SpaceToBatch.2_Type=f32_Shape=static_IR=8acd95619121cb22760fd92815b1ba85f541f282d3860e910f73036ed335a9ee_Device=CPU_Config=() -327:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d8a48dc7581c2ece0179d0ad668e8caebdddddfe492e365ea2e0e5f3a7302eea_Device=CPU_Config=() -327:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=() -327:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=933c6450f6856b32e879034662cf60eca53970c10106f8a11eb925e5621042e9_Device=CPU_Config=() -327:conformance_LogSoftmax/ReadIRTest.QueryModel/Op=LogSoftmax.5_Type=f32_Shape=static_IR=38bcc7d745ee21a7c6858a161e269f0281d3f41d62d65d10fde9b0a9b80992c4_Device=CPU_Config=() -327:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4819c2459dd2bf875545cc912152c6751ed5db8ef07aba31d3eae6c3dedc7aca_Device=CPU_Config=() -327:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=2538d525d8f11b9f4961c2a4a8cc36fd27d8b3d97271ef7db4f7eac9732b71f4_Device=CPU_Config=() -326:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=59eaeea8102953f8ffe85ed1ced2a44ddeed77ec237608b45be0573bb32b1104_Device=CPU_Config=() -326:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f7cf7cbc88dec99af8d35e65e926745ad318706c454b90740a19589285733fe9_Device=CPU_Config=() -326:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=12965dd8a422975f08bb0fc707c666ad7ae2671d09c68757d534e3a1d67efd41_Device=CPU_Config=() -326:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=944072d96554abf3ceac6b928cc00ea1705d5e0dfae8e9a0662de4e56fb3e62f_Device=CPU_Config=() -326:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a46f51b7498c921515a53b67480ec4d413ed43ff809e1fa6a4deb7365f4a0460_Device=CPU_Config=() -326:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=046798a0cf8d4c3fd8f1dc12bd0363a669628e748a6c964385eb50bb783924fd_Device=CPU_Config=() -326:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=4ccf5cecf790d27400fb95526a993f8a1a28cd4f3120b897cf45bbe78f087ab2_Device=CPU_Config=() -326:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=2aa586a55098e1960c204572ca9704bb3b8b9a3baab5fcf08200594261f7bef7_Device=CPU_Config=() -326:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=66cff13148d62809cced5a381c251525486476f7178eddd3c8e45eeed40afd06_Device=CPU_Config=() -326:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=dabed23c3f30d92c6fcca7a6845160022837de8cbfa1077c222e6f1224b745e1_Device=CPU_Config=() -326:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReorgYolo_opset2_Device=CPU_Config=() -326:conformance/OpImplCheckTest.checkPluginImplementation/Function=MatrixNms_opset8_Device=CPU_Config=() -326:conformance/OpImplCheckTest.checkPluginImplementation/Function=BatchNormInference_opset5_Device=CPU_Config=() -325:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=90f882a97d637e527900edfb1b7c277b65544832793d08efdf8454be21a2f496_Device=CPU_Config=() -325:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ec19939673cc58f2511ffd6695a3652f1d724872b0db958a6d667e1e87002b21_Device=CPU_Config=() -325:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=8832b317ba58dd0efd1e8fa5238d35644d8468a03c9b35809a20ae64098dc986_Device=CPU_Config=() -325:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8fce2d85c65eb0e8b40c2923338675276902296daf8744322876552dcd68f7_Device=CPU_Config=() -325:conformance_NonZero/ReadIRTest.QueryModel/Op=NonZero.3_Type=i64_Shape=dynamic_IR=7d0265450b8fc92464273ac05d685952ea3877be45b4d745959f2f373fef1431_Device=CPU_Config=() -325:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=a29bdaa31edbcf7b3dc392625c0aa0a27e827e1363d52519858c93defbf9ebac_Device=CPU_Config=() -325:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=b459cd78b41e36a6c3823301811fd3322a77f802ffc3399eefdfd8ffa4ce6e6c_Device=CPU_Config=() -325:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=a5a2ba7fff85401feb05248462e85d334440769790e7e6ba1a75ffb413f7fc64_Device=CPU_Config=() -325:conformance_HSwish/ReadIRTest.QueryModel/Op=HSwish.4_Type=f32_Shape=static_IR=1c38a17a13c5c03cfc1eeb147ca2474debea05ae1d6f2357ce40ce23552286fa_Device=CPU_Config=() -325:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3c7d4160bf883d550620e8d1ceb54b3d78bf1512388b5ee57e1a380949d441e1_Device=CPU_Config=() -325:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=51d309244d7c90039cf86929d62320f5e5c5df8b1390c6b1241d8389eb6914e2_Device=CPU_Config=() -325:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=15d323a190bbeb1834cfa08a3afc633a2c203e44e2660bff4e98453c02ea4cfc_Device=CPU_Config=() -325:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=34404b0d0f956acd1827f417b44bc1cf1a085d6517d5d81a6c6d38ee27c745e7_Device=CPU_Config=() -325:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=eed21ac7c17920ba437332691e231037113367ee3d256b4db1380c8d2e0db84f_Device=CPU_Config=() -324:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e00cea4f2ea99f32c11ea265ecc0483554192192bb99f36438dd38de09820888_Device=CPU_Config=() -324:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=83e2d01e24eebe910418ed24fb506852c37576ce70c18d27de197f675f49c9d2_Device=CPU_Config=() -324:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=fad6766f10f7a0ffee665be437521766f5dd56b673293920d8b469bdcef8e7f8_Device=CPU_Config=() -324:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=b9581fac6848b0c6c9fc9af5fd17eca3f2f64832fb7205f97684f1cc4c1985f0_Device=CPU_Config=() -324:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=f1e43476084575ad240db6631f433a61ba2076d1ca95e44a0e4471ea9d6f66df_Device=CPU_Config=() -324:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=659cd025e440fdc633859089f52f7f38cab5701c63c79d1e8d1837c217b8cf75_Device=CPU_Config=() -324:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=176c218db11ea18f367fdf98a3de14e9a9c65152bbcc39783c38772b37f6e9c2_Device=CPU_Config=() -324:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=fabbe8bc510b0d1afb64f2fbe68d755be05fdccfadec5fe845dc6b3c4e6a2767_Device=CPU_Config=() -324:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=80a8c850ad3eec3e8fd00d2ac09695a0f87a10e4b80b9022f49ddcd9805eb2d1_Device=CPU_Config=() -324:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=a937747c04b70351d3632aab91189200e2c0a69b6467ed856b7075885c54d83a_Device=CPU_Config=() -324:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=cc13aaec2a2bbe9b760651d358622114b4b0a20cb106472bd8519f0fade61dcd_Device=CPU_Config=() -324:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=2c2cec03b3ec1da29ad4d5fbb3530ee7343a436e27be923ee1f9dd97d29731a3_Device=CPU_Config=() -323:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b2fc03d707298e863f83bd3912617e76e63d0fd922c87edf912c17bf51cc1fcb_Device=CPU_Config=() -323:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5ba879b46e93286e4c880a726e28d6956a1c8415508733b5349079f899462679_Device=CPU_Config=() -323:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=5295b6c6090a820891e5754c34d03dc3347d3436fa16fa4a701422ce8ac78b92_Device=CPU_Config=() -323:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=d1d0510ce6d862a5512bf4c5c588f84548f1aed0226eca6850b5e2d470a5ee84_Device=CPU_Config=() -323:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=a30154a78e0e565a598629670b87338d03582cbe4ed5547256634ddad7bc9d5c_Device=CPU_Config=() -323:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=5c5e10f28ed3a8d4ee0d3c8af982df5f383a4a1a713baba556dd17ee52e9ef32_Device=CPU_Config=() -323:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=() -323:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=3effc90c24c0eb76bbc89809d34c6541654366a02e21378a668dd932a6cc7756_Device=CPU_Config=() -323:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=214e4e8f7de64e9cc8c77c67d214172905cfb4b9fde65e2ef3d32bb7b4ed93f1_Device=CPU_Config=() -323:conformance_HSigmoid/ReadIRTest.QueryModel/Op=HSigmoid.5_Type=f32_Shape=static_IR=cc18959ba7c26661ba0f986207bd00aca503bf924b31c4a2070ac40ac3ec5468_Device=CPU_Config=() -323:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=74f34c8b7abfe0f7afe021ba5d4861e29f9f3915beba5cdb2af936f1f2409fb6_Device=CPU_Config=() -323:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eba756a8d0ce89c9a8df50baeaeb82d5b719461bbaa06386db7e1be10ec535f3_Device=CPU_Config=() -323:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dd181ad2875cd08679b8554d2a85ea0fd15d7f09f733a8290f677fed6c757_Device=CPU_Config=() -323:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=b31dbb99720fd5083e5a7e5b1b626bda91455999e2918eb8e658992cfa6588dc_Device=CPU_Config=() -323:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=cc989fde083332a75d3066112105028a711bdac4fc44463d098022774da752b7_Device=CPU_Config=() -322:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=afd856f31f3a815b84c34b66e1ba0a70a313301ce82fdccc2f1b779ad3157d4f_Device=CPU_Config=() -322:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=34784838e98e93a6b024109ef3a8a5d4e1fc7f89b98ca23c81cf085f19acc663_Device=CPU_Config=() -322:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=7c1b4dfda36336bb1a943fec9786d89e220f2a811159fe9cbed7d51186f8fdfe_Device=CPU_Config=() -322:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=6b0b123bc93e799aed7bee84e55ed9def25af4f11d27958d8368983eee9c527b_Device=CPU_Config=() -322:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=6aff57130da7904e5d2300c4962f104d31c704872d5c33bbda4bb38efc34d563_Device=CPU_Config=() -322:conformance_ReduceMin/ReadIRTest.QueryModel/Op=ReduceMin.1_Type=f32_Shape=static_IR=61bca82940fd4a54bcb587a88272b81c191b8feeab37bfafa044ef768240977c_Device=CPU_Config=() -322:conformance_ReduceMin/ReadIRTest.Inference/Op=ReduceMin.1_Type=f32_Shape=static_IR=61bca82940fd4a54bcb587a88272b81c191b8feeab37bfafa044ef768240977c_Device=CPU_Config=() -322:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=c61a8f259a8b37e49f9267dbc921d88dd60e5766aa30dd05319f423a01c14aee_Device=CPU_Config=() -322:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=d05c1b7fcf976117a23e0284998d9ce21689411ff24530175787f1512ca25879_Device=CPU_Config=() -322:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=641b1e74512a5cdc87bcd63515a28a409f155a3475fa923e440868e563daaffd_Device=CPU_Config=() -322:conformance/OpImplCheckTest.checkPluginImplementation/Function=PriorBox_opset8_Device=CPU_Config=() -321:conformance_ScatterUpdate/ReadIRTest.Inference/Op=ScatterUpdate.3_Type=i64_Shape=static_IR=f5ad439e65ed1e090d3d5744e9e5bcd9b8fed6ac6a191735cbb1cdd9af8bccf4_Device=CPU_Config=() -321:conformance_ScatterUpdate/ReadIRTest.Inference/Op=ScatterUpdate.3_Type=i64_Shape=static_IR=b5f5ffd783aa251498c2011f19a63c1d68991e426384ef9728bc0b46587faa2f_Device=CPU_Config=() -321:conformance_Proposal/ReadIRTest.QueryModel/Op=Proposal.4_Type=f32_Shape=static_IR=c0884ce897724cace24b30df395a33443364f8494f1f8495d212f2db20fc49e2_Device=CPU_Config=() -321:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=() -321:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=cdf79cced0ed380052910c95b09b4022841474c87d06061f29791ea2ad9813a4_Device=CPU_Config=() -321:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=431db89311a543581d104e2a2c498fe021da2e4026323817834670bf5bee67a2_Device=CPU_Config=() -321:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=155b8d9ccf06f4d8f9ada6024fbe66f39e4e6e96917c12d7ac02eac98c5473de_Device=CPU_Config=() -321:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=5bfbbb826bcb2c9e7b5364fcc5da23e737953150029c2ea7455ad4b09caaf01d_Device=CPU_Config=() -321:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=97181a6433949eaef7277fdfec4f8f94b27463ee3ed4a6aefc678fdaf7eab4db_Device=CPU_Config=() -321:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8108f6881c436dfa59a0c27d173054c885f082306ae5af1694cdede13718bde2_Device=CPU_Config=() -321:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=f0853773e26eae3d051504ed8db7f182c0e90ef7b45625a1a72ac51a73e2208a_Device=CPU_Config=() -321:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=c3c821b46d994404c55856237eb70534cff33687df2bde0a86d0bcc9f20878eb_Device=CPU_Config=() -321:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a24dd1485e484f31d0c72f3a0c31f373f883f6ca4a751b1d2ce18132913506dc_Device=CPU_Config=() -321:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a3d6337c1ea3e8b67256696ea4231da4fc0e9d9f8bea169607a1287233086b3f_Device=CPU_Config=() -321:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=() -321:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=ef6e4b3910cac801199b1f6be74902b42105d23de549d426b1c4bcdd7361f79a_Device=CPU_Config=() -321:conformance_BatchNormInference/ReadIRTest.Inference/Op=BatchNormInference.5_Type=f32_Shape=static_IR=c602b01c85ee95a1d7deb1498c5f0494a5ee727ce8874d5beded8bf33631d0b4_Device=CPU_Config=() -321:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=f286960ead5b83e3e4015ee5751b114a9d70e90aa788e0fb004ac50b95a8fa2d_Device=CPU_Config=() -321:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceLogicalOr_opset1_Device=CPU_Config=() -320:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9575e384c23faea27b9011de8c0093099fbe0ee6462baaebaceb075529664665_Device=CPU_Config=() -320:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=() -320:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=7625f5af6c70a9d4bccb783dc369a11b53ef1f6492df030ae5404452ea0cdc79_Device=CPU_Config=() -320:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f8ee6adb1573c51bcffdd8c24455ecd6b6fbf04f171e9aa5de36c5d6f18babe_Device=CPU_Config=() -320:conformance_Equal/ReadIRTest.Inference/Op=Equal.1_Type=boolean_Shape=dynamic_IR=0723b6d683bc65225624112929bd8f7a0adde9e9c2265a2ec1a54b10c4433735_Device=CPU_Config=() -320:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b4c737aec2f47947d1afbe26d9d8cd124c6fdd24e30cab1f563d91310d1b62c7_Device=CPU_Config=() -320:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=3d5c8f5c1545419050f982e8555a6ef9e5dcc06545b1a8573d710e8bc2375a6b_Device=CPU_Config=() -320:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=fabbe8bc510b0d1afb64f2fbe68d755be05fdccfadec5fe845dc6b3c4e6a2767_Device=CPU_Config=() -320:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=09dd33f661a07095dc47e3e5205c9fc6dceda72526e79be0751c34823c7e7cf1_Device=CPU_Config=() -320:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=f826a40d2d5d59d35300a911a15dfd8022c0fc486ecdc7f00c06a26f5dc44338_Device=CPU_Config=() -319:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c0cbd07b1517991754ef075284aedef586dd4b250e2b867379dacebdf99ce1e1_Device=CPU_Config=() -319:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=fa88ad79fad41544d799f0333f83b91322f2bb408689e27e53bd175786ed0979_Device=CPU_Config=() -319:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f84bcf4f549ca0d6e75c7905f1463fbace4f3b955032fcae627e46e353b2aee9_Device=CPU_Config=() -319:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=299e5f0fc159bf294093a5e1f258f7083fc54a08cbaa3a55b2a2197d29ae780c_Device=CPU_Config=() -319:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d8a48dc7581c2ece0179d0ad668e8caebdddddfe492e365ea2e0e5f3a7302eea_Device=CPU_Config=() -319:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=b91a183b8c36d6e8358dad7056638b8091005393dd1ee6813728f25cd3e6a9f5_Device=CPU_Config=() -319:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=313740a93070bb3cb89143685b7521ea0ace30c3f6d510a4d83ed809808caeac_Device=CPU_Config=() -319:conformance_MVN/ReadIRTest.Inference/Op=MVN.6_Type=f32_Shape=static_IR=a7b7ec75e1b343acfa06ea53d7d5b631c06d44c68b1fc92555d7168c77aeadb3_Device=CPU_Config=() -319:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=d98330d8f9f03556036d103fb4ca3f8436be42fa4f0b21b185aaad3abb2fb53c_Device=CPU_Config=() -319:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=d98330d8f9f03556036d103fb4ca3f8436be42fa4f0b21b185aaad3abb2fb53c_Device=CPU_Config=() -319:conformance_GroupNormalization/ReadIRTest.ImportExport/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=() -319:conformance_BatchNormInference/ReadIRTest.QueryModel/Op=BatchNormInference.5_Type=f32_Shape=dynamic_IR=694ab408745deafb90f8515e002a393e790a8b1f83e58519081b983067d76967_Device=CPU_Config=() -319:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=cee58d2e3f2d6ef0061c5b245a15c60f0a26a58474c015f71dbdbc0c171b2a8b_Device=CPU_Config=() -319:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=525408cae199f0936f7552165ba12d61ced6b675d75d56f1d69be8281feec5d5_Device=CPU_Config=() -318:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=35d15ad61ee34c17abe50c4a67e568c2e253712c2d63cb828b0bccdb2175a6bf_Device=CPU_Config=() -318:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=i64_Shape=static_IR=6590ae34a784f81de25c016454fcc919ae1f9eab672c78c9da0daf83dcdaf1bc_Device=CPU_Config=() -318:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=c1c38223834d99f4481cb74db2bc302710629de5807b4f08381fd01655b9d44a_Device=CPU_Config=() -318:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=dynamic_IR=85a35059512fed9e0c70cdcbd5e73c1e247ef97821d5193cbc4f7f7c3ebbaef8_Device=CPU_Config=() -318:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=72c58b462f61521af4eab9c890e568b5676c7a3194c4e35f8e04f98596013c47_Device=CPU_Config=() -318:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=674e2446a2f5929d12d36f14451d68e7b55ad61d2d8df755e85c27c4a52943e3_Device=CPU_Config=() -318:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=0cc60631ab50733ce6b7a2256c0db1f9d9338505ae85b30fee02026c28511383_Device=CPU_Config=() -318:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=bc52d884c8eb9ffc1a5c6af9467b8f285933b715def03c4e5cadf426ba186c3a_Device=CPU_Config=() -318:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=9b9521ed73100b54a3c5920107db944380157eea1b72f4e4d94f8e2ced1f2e4f_Device=CPU_Config=() -318:conformance/OpImplCheckTest.checkPluginImplementation/Function=TensorIterator_opset1_Device=CPU_Config=() -317:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=6e1207753b08d53b18c551ad07a245243197370051be78218db028f3d3b835a5_Device=CPU_Config=() -317:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=d7fbbe9f8f446b009ea2de8594e4cfaad46432734cba27596e3fa721f04c04ee_Device=CPU_Config=() -317:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=6e8dbb054c99609e5aedd642130e867c22091118e0bb7ddd870a66dcfd11452f_Device=CPU_Config=() -317:conformance_NonZero/ReadIRTest.ImportExport/Op=NonZero.3_Type=i64_Shape=dynamic_IR=7d0265450b8fc92464273ac05d685952ea3877be45b4d745959f2f373fef1431_Device=CPU_Config=() -317:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=84f6f3544adcc7c68df5ca411844cf36c2232c1b6c820094e5693a444faa143d_Device=CPU_Config=() -317:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=fe615eeceb735b046b190d844931c56223d45439021da3b6b23227a1f9cb73c7_Device=CPU_Config=() -317:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=488c8e933df63c1368e021869a92fd48929ac252863ed4c2acfab7174b449581_Device=CPU_Config=() -316:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=20450a7796284bbdcb011ce027d5c7260ed7dcdf07e4d39e48d99a2162eaae51_Device=CPU_Config=() -316:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=178677f6c6e3857b2c3aa8765c8e3186bd25b73154ba6463ff33a9e1c911e6bf_Device=CPU_Config=() -316:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=9aba412b059ee77c603bebe3e49240d6f2183168002d25bb7bfe62f1224be2fd_Device=CPU_Config=() -316:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=2d6f6b955cd431e0f4786aae35f5a1f7f69a6b627e88c42643ded0477f1cfef7_Device=CPU_Config=() -316:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=dynamic_IR=0f5965e2daa2a1f6b050813850956d9a4bbd771cb234ec814617099e1541ea0c_Device=CPU_Config=() -316:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.1_Type=i64_Shape=static_IR=1c06ff77487507dddcddf290d75d4812bfc8a7b2c9bc78176da5212eab029966_Device=CPU_Config=() -316:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=21a3318957d920b39d8b3d84c76cfd2a5ad98515824f88145326deead0961486_Device=CPU_Config=() -316:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=2e70eb484f4bac4cd11e9f643d2531cd0e78994af07c015183edf9d62a709d47_Device=CPU_Config=() -316:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalXor_opset2_Device=CPU_Config=() -316:conformance/OpImplCheckTest.checkPluginImplementation/Function=LessEqual_opset1_Device=CPU_Config=() -316:conformance/OpImplCheckTest.checkPluginImplementation/Function=GRN_opset1_Device=CPU_Config=() -315:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=97f6fd9998be395222e6878ccaab47f5d50561d1ab8f988987f7f292e784fe2d_Device=CPU_Config=() -315:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=53828d433bfa231cac709949db0e4ff72010e5cf9df167ecda7ac72bd5a69e10_Device=CPU_Config=() -315:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=2027d5da17dab73d23b4984fe88696fb770ba2fa479a194b3531d30ac75dc840_Device=CPU_Config=() -315:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6a8fb5f2948de2436a33999ee2a01e239193c268f61634f1e80692b0c45aa3da_Device=CPU_Config=() -315:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=99820651f05bae979a287a8644f1b739637d684efad288b48044c2a664e43a3f_Device=CPU_Config=() -315:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a8ca0b23e0a0f66247fc693c6a8982e4f7daa11e14da296db0dbc9277fcad4df_Device=CPU_Config=() -315:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=f32_Shape=static_IR=35c61b2251b78ad9f9804bd3f9e301e1f974c6dc138ce0466b8b940d106ddd72_Device=CPU_Config=() -315:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f55c473236715e5c4e6ec21a9e07d1c73b14d529b57fae0cb38ef9d6cd383b53_Device=CPU_Config=() -315:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=750599c4cdfcbe7468328647a8760c7249a9f5dba8bc33ebd00c151d9f3b13f6_Device=CPU_Config=() -315:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=dynamic_IR=6b70264ed3eb3831e0e034230813ce1a1e71c157a302822b56335e587bd200b3_Device=CPU_Config=() -315:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=7b2199d0ea56102a7c6737be2334b9717ee292c13cdb692d07fddfd173ea5b82_Device=CPU_Config=() -315:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=5d68272f8318c073e481b5353e6e4350e6b3b5e120f389a98859dbd5af43db9d_Device=CPU_Config=() -315:conformance/OpImplCheckTest.checkPluginImplementation/Function=ShuffleChannels_opset1_Device=CPU_Config=() -314:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=07849f3111a0f12a712cb0deb7ec9c4778e70120385bdff7f17c1af30e31062c_Device=CPU_Config=() -314:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=dynamic_IR=9feb072b58552898ff80a05dffe8f39c880b4f2a2382d56cb24a78e278ea1756_Device=CPU_Config=() -314:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=e9539332df9388555564db1da36679acc7b505b8c1fa687731f2052999bfe1fd_Device=CPU_Config=() -314:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c87c002bc627f4adfa58547da4c2b1f270e07e9961a1b4ae99dda72d88980550_Device=CPU_Config=() -314:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=2d6f6b955cd431e0f4786aae35f5a1f7f69a6b627e88c42643ded0477f1cfef7_Device=CPU_Config=() -314:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=5aa10dbbcee8d7434796180d5fbe8f0a954b772c441c8d6046439c615d3b9011_Device=CPU_Config=() -314:conformance_Proposal/ReadIRTest.QueryModel/Op=Proposal.4_Type=f32_Shape=static_IR=ea8cc682a9a36cc61498573e967ec64d289af84a9e3da1911085b1de4fea4c82_Device=CPU_Config=() -314:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=() -314:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1245c8dbd9027cc56d2eeb58e1bd23774ce945522f66a17ecc3c03ca1ca163b0_Device=CPU_Config=() -314:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=447c546ed54e81edcfea77cafa8d18261923bf25c050666029828ea72e3a875c_Device=CPU_Config=() -314:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=dda009a1f3191e35286b7515f5741905e303f27287041248e2ce15f6954af810_Device=CPU_Config=() -314:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=b93daedfdba7331025c12a5eb4b881bd7df445d80bd4fac34833087fe6d65bf5_Device=CPU_Config=() -314:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=00d8728cd472d05b1eebf4b4d0ffa4a5d7c7dd34b3a99055b0f8ff5b0173af53_Device=CPU_Config=() -314:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=2ce56cfc77884dfc61f7e9fab9a0ce04a4b016f9b3d13465cde1576b9374a2a6_Device=CPU_Config=() -314:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=c808434d1d2cbd9ea66373f22c7e635c5bb2e3a6294f93421d1d9d34ac62515d_Device=CPU_Config=() -314:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=9b9521ed73100b54a3c5920107db944380157eea1b72f4e4d94f8e2ced1f2e4f_Device=CPU_Config=() -313:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a4b3740eda9e6bbd3968dd39e6abb33b22a90a811298df6a761958216acb389f_Device=CPU_Config=() -313:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.1_Type=i64_Shape=static_IR=36b9b7be1407243aad0792e7a49ef25f7c3e3791dc1ff93cad40480837ba87cf_Device=CPU_Config=() -313:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=static_IR=ca5d2626f2066e0c806addc4b6ffb4b3a71f1183b93783b92f44de62d82faaf8_Device=CPU_Config=() -313:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=7685da6dcf91a208b72d5961c2c248d816de501366163d61b1ee3c148787fe77_Device=CPU_Config=() -313:conformance_NormalizeL2/ReadIRTest.ImportExport/Op=NormalizeL2.1_Type=f32_Shape=static_IR=acdcf37615b571d8a1275b71cfe0c43a6410e56f5f18db8e9d795e46aac73d0c_Device=CPU_Config=() -313:conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=() -313:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=c39d76c89bb03fe251dfffdd9b8eb85c0585904ed9c5bb4660c3dedfdc451efb_Device=CPU_Config=() -313:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=a7b7ec75e1b343acfa06ea53d7d5b631c06d44c68b1fc92555d7168c77aeadb3_Device=CPU_Config=() -313:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ee1f9348ff09a058dc09cd63581663590521d463d14b785a23ccd3cd28110b5b_Device=CPU_Config=() -313:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=315fa20f952b6c7678cc93dbfd340097847826fea7928eabcec46d7ccacdb224_Device=CPU_Config=() -313:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=5df86bdcc255998a0b5b18e64e3059afb2c80e37b5695208d04a6fc0f1410b50_Device=CPU_Config=() -313:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=a815b68b6a8d36546d3ac0112c60283bd69ae1059e8deeb98b21f538c8089beb_Device=CPU_Config=() -313:conformance/OpImplCheckTest.checkPluginImplementation/Function=Select_opset1_Device=CPU_Config=() -313:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gelu_opset7_Device=CPU_Config=() -312:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ede6f5f8a1d9bcfd1979965f575c8f267870e0d6a5d3a62d229ea029893525b6_Device=CPU_Config=() -312:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2758266e894d04cd7283921f678a468cc1fced81d1a09a3c95add3ed9e5d6719_Device=CPU_Config=() -312:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=125ec4e4ba4158d3a6d1a7725cda9a18a220926d5ad6ed623a1433688c79b579_Device=CPU_Config=() -312:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=edb5dc5a42b36879d5ced77fc2db7d8b331c888534602893ffb277f742da1005_Device=CPU_Config=() -312:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i64_Shape=dynamic_IR=2c47f1ee19359a486a72bdafc2614159d48fffc80ddabe0f897212a454a75b18_Device=CPU_Config=() -312:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=697bdfc59094203ea1616203d64759a40193f1a23a4a51f11340a7912e355cd1_Device=CPU_Config=() -312:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fbd54c37e1db9cd3cd3fc7c571117f65c26d9f5ff0674711a326e02ebd3f9d57_Device=CPU_Config=() -312:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=e22e40a4f300567612f963b17707be4de09093cb9a248aed62af594e7986f7dc_Device=CPU_Config=() -312:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=753b524e2aad8fde7e7206fa8c3e7ca15c52c49f22f41d48cfb6b4d814cb40af_Device=CPU_Config=() -312:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=718d6ff3b19f498cf4edeb9f7f4a7528fef578dd6fc7edb0796d476505472e46_Device=CPU_Config=() -312:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=b4fecfa9b5d565a02a9f0d0ed19a11127ea9c8c4e70a0e5f7b920701e0665d51_Device=CPU_Config=() -312:conformance/OpImplCheckTest.checkPluginImplementation/Function=Xor_opset1_Device=CPU_Config=() -311:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9ce6a2f4787ef120c486a68cc02bacb95d6cb1c4cdb5e2054275cde409a39803_Device=CPU_Config=() -311:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=5f8b64ad8dd9ccd202ae8d5080ce166fe9f47b909e803da49546dbffdfb4ab3d_Device=CPU_Config=() -311:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=a65e17fc28c74df4f3b1bad89635ccfc376a857f2d92ba646ca830b03eafab7c_Device=CPU_Config=() -311:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=() -311:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=ad5c5df7cea37955709ef71d9967828ce3f0011e68aa1c6085984f1422944058_Device=CPU_Config=() -311:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=f03721e9c346ede7ba78d0a2466e38cec6d1e08b3395b38c8f47ebcbfba35d3e_Device=CPU_Config=() -311:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=c985b086d155654f9db8470da3af5245c4fbb0139015d049b8b3b20f393c2545_Device=CPU_Config=() -311:conformance/OpImplCheckTest.checkPluginImplementation/Function=Eye_opset9_Device=CPU_Config=() -311:conformance/OpImplCheckTest.checkPluginImplementation/Function=DetectionOutput_opset8_Device=CPU_Config=() -310:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=04e25f2a56de557c8da87110ba02c02ae45277d029964d932fe6837acc0f1b10_Device=CPU_Config=() -310:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=bc90fb9a95a74efb937b6cf808584dd1e91aa6c4d774640b51f4325f0aca6b42_Device=CPU_Config=() -310:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=5995707c0c9656ffe179147e29d03df5a35286481a4140b7ef019434d83aaa61_Device=CPU_Config=() -310:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8fce2d85c65eb0e8b40c2923338675276902296daf8744322876552dcd68f7_Device=CPU_Config=() -310:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=61091e18fb5e9eddcab243ec79234ef3b93a5d01d9b2611a3a0e027eed4e4b31_Device=CPU_Config=() -310:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=31ce051edcf02344a693eb2d200fa02b53412a5707faaffc2907cadcf81192f4_Device=CPU_Config=() -310:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d2d4814c8ab7cbe5107a556fb3e73998aafae0278b0d304fa07fc4ac9fad4559_Device=CPU_Config=() -310:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=c8ec200fa8fd8ec9c185d9d45ee1380be5e0e4a6f3157e5900401e9fce999553_Device=CPU_Config=() -310:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ec60ac68ad3b748ccd56a7c91b3a2461510f05d66e4b64e12a2069483d8243ae_Device=CPU_Config=() -310:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4a3c7edd1efc847f3d1255738c19cdaa682c9348c0b0bfc466ea9d5749d5eca4_Device=CPU_Config=() -310:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=9d26a7c321db2d87b29b93baeca20dd25357e7777261ea6a4cbf968a203969ea_Device=CPU_Config=() -310:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=00b85178c2e7f891c89e99a6692b94a56ab0882f4a30167997e104db1429a9c9_Device=CPU_Config=() -310:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=dynamic_IR=79cffe28ff617b42488d33b204b0f50bcf4e304c74d2a11820c830e091c6383e_Device=CPU_Config=() -309:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9e21c0af425c90066d92577a0b8aadb6e9fdee50c197b15eea040b89eb715a6a_Device=CPU_Config=() -309:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=2b02493e0e09536d01441e885df61f27f2202a3e16742695bcc4d1d0d892c56d_Device=CPU_Config=() -309:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.1_Type=f32_Shape=dynamic_IR=7cb8f8f3f3b4335221f85190d4bc29dd28a6b99133ab630a5ee04640af0843a0_Device=CPU_Config=() -309:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=() -309:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=727e029d6373e823f7500e6bdfd1c07ba87fdb3ba428fd0a089885d7a1e91552_Device=CPU_Config=() -309:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=a1862e486a20c8de71dd94c12a157098ac5f222ba8ba3e1d3edaf9362331e185_Device=CPU_Config=() -309:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=() -309:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=61091e18fb5e9eddcab243ec79234ef3b93a5d01d9b2611a3a0e027eed4e4b31_Device=CPU_Config=() -309:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=29a633b64671e28103c44b79ec5c329118c0d7c4f70466ad44482116aa2a3b6c_Device=CPU_Config=() -309:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=78a5e7f340d63660dc0710d0e390dea2d3f68ac98f16e8dbc11b4c28ac0440e0_Device=CPU_Config=() -309:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=bbb0129fbafd6d1874ccef37a1bb60379733012c502d58326dae70f413e387f2_Device=CPU_Config=() -309:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=755b95b2e9c5cb5da4d4cd2c46ced327e10dbfc67a0d934667177b5fab73d431_Device=CPU_Config=() -309:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e05af92d21ebd869cf6e9554a4aa0bfc60c8b0c64baebee798f0be5a0a01019e_Device=CPU_Config=() -309:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=b8e37f2c8e2574b3f3554578b72e9df771c290c1bb47238fc4de9754c6e6f126_Device=CPU_Config=() -309:conformance_Ceiling/ReadIRTest.Inference/Op=Ceiling.1_Type=f32_Shape=static_IR=fb5c74aa3b17b4a8d5e1603b9179b60bf3f0b8301c74a8fb632b6869896439d6_Device=CPU_Config=() -308:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=dynamic_IR=c838ac42d5464130a9049a63f7020166b34e2ef974c257a4060fa02c3b70ff76_Device=CPU_Config=() -308:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=() -308:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=b7a53df966d640f075cea7421ca5989ca91ca638e7af16aff33bc275eb7dfe9c_Device=CPU_Config=() -308:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=99a80c495a8fb4626995167a3ad2efa0efed7696459f6219125414a2bd20dfc5_Device=CPU_Config=() -308:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=() -308:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=cdf79cced0ed380052910c95b09b4022841474c87d06061f29791ea2ad9813a4_Device=CPU_Config=() -308:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=b6e3f37ddee609d492f47b36b8fe937ee401d01e6d43d7e0b7c06d1a1781b501_Device=CPU_Config=() -308:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=2c5e9a1cd59ec2d5786132697bfcb1519a7857cdfe06038bb39abed39c09e9a2_Device=CPU_Config=() -308:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=12b6ad1cd462f676c9add533f2fb2a5d98698e72fc5d0e6dc984abb27f54475d_Device=CPU_Config=() -308:conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=() -308:conformance_HSigmoid/ReadIRTest.QueryModel/Op=HSigmoid.5_Type=f32_Shape=static_IR=85df90c3ae7b84d89ec4eae30556ebf4af996c318afa45d90dbb219f73033f31_Device=CPU_Config=() -308:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=9f7a30c4f90df2edf8e70468ac22f325bc97e99613fa6ee2aced93e71ea5896a_Device=CPU_Config=() -308:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=bc52d884c8eb9ffc1a5c6af9467b8f285933b715def03c4e5cadf426ba186c3a_Device=CPU_Config=() -307:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=fcab2b4b3bf1a04070e3fd3490e6317f2d6870335d302d96c768f40da8565c8d_Device=CPU_Config=() -307:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=797bfeedb05fe1883757101c44e78eb807ff9c3570aa58b0891172e729d4b384_Device=CPU_Config=() -307:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5f18fb02adfd683f379dd5a15d38f01cf744e6940754f6a40e2646a1d9c97be8_Device=CPU_Config=() -307:conformance_ScatterElementsUpdate/ReadIRTest.ImportExport/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=() -307:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=b6984001a616b3dd3ef4b835b2dc6a48bcaf8882bfde7761b4e141733364f66a_Device=CPU_Config=() -307:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=3ca9994321c7492af9bff158852a484636638e711ae39a6acb66d273f696906e_Device=CPU_Config=() -307:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=41ea59b807081adea7869609c65776a42f88079ec22180807905d5c2e8ca0777_Device=CPU_Config=() -307:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=997a090766babacae10464bab19af5db238eb28704c6d463cfcba48767a90c8b_Device=CPU_Config=() -307:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=810f13adb3f7342c7d514bec2aa3f20d7a59527b54c7f6954b038efb194c5ceb_Device=CPU_Config=() -307:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=d661093ec9006177e5d47e7f666d7c98353f9c3d5290ba6284145f60822f2573_Device=CPU_Config=() -307:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=c56cf3dc39ed0072f3e5a8cadd1502fef904b32de3b7760ee4c6964c0e505ac9_Device=CPU_Config=() -307:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=8337ad383956ad96ca95f4aeb967e05c694fe586b4ed6e46547e3ffa0217c59b_Device=CPU_Config=() -307:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=f3d84b4cb7f301c6b64c64927dd1e8c20e144671419843ed3d20692f0773445c_Device=CPU_Config=() -307:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=a3e2f08143425d4c6ed46ee301de31c5942694f79af0d297e4d1801e9a6a0ff8_Device=CPU_Config=() -307:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=d673fdf688abaeaf4cc6239ff762f8df557ab445bf9f031ab3bd87782717f2ef_Device=CPU_Config=() -307:conformance/OpImplCheckTest.checkPluginImplementation/Function=Reshape_opset1_Device=CPU_Config=() -306:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d99c03088bad009d9be7f29ec5bad7e3b6c7534fe2649f9670b6f713bf017e7e_Device=CPU_Config=() -306:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=6095afd484c177267854bcab902c3057a2a1bbf37b2188d3a31fd2cec48de2fe_Device=CPU_Config=() -306:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=13dad9a80315de728323f8d84534389c4840a92e74073be42c312c46107fd964_Device=CPU_Config=() -306:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c219261f655fdb1bcfbcc367ca8f6c4bdf0dc1fbeb7413343a3f0bdd74a70857_Device=CPU_Config=() -306:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=bc90fb9a95a74efb937b6cf808584dd1e91aa6c4d774640b51f4325f0aca6b42_Device=CPU_Config=() -306:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=ba1a7c4cca6d39b8bc7be7d52a0680d055e33a776f4048ecf38335a2ccdd8d51_Device=CPU_Config=() -306:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d56533ce961113b2ca0baf02f3ff9f8ff210264343f6bebf26418a35ecf36b02_Device=CPU_Config=() -306:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=e3a5a7f1a73793457fae9520ae122c6bbbfa92f1daac0ef214e47a2ec7ea18e2_Device=CPU_Config=() -306:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=49b05f6b6a636d84beca451fdc1fc81e3411a100ea105fbcd49ef72ef1fa0934_Device=CPU_Config=() -306:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=7293f99e38d76387b64632d06503c539c369e1ab78d9388e1af42d7071d8230e_Device=CPU_Config=() -306:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=33297e2649e2f0c53b0bfb5e349d83ede580471764202480855e3f1efc8017a5_Device=CPU_Config=() -305:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6513dbb80f00e325d6dfc953d1208c5834199f75a60430fc85925ed6eb0d9bb5_Device=CPU_Config=() -305:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7c43bd989494b4ef0f2ca40c3b0c57b471d58b21491456e9588938f702721be0_Device=CPU_Config=() -305:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f84bcf4f549ca0d6e75c7905f1463fbace4f3b955032fcae627e46e353b2aee9_Device=CPU_Config=() -305:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=99820651f05bae979a287a8644f1b739637d684efad288b48044c2a664e43a3f_Device=CPU_Config=() -305:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=0d62db1843ef7e470a613f9f4d4999ce0e6c94365bd667b78c283cb9406e915d_Device=CPU_Config=() -305:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=dynamic_IR=33e67497d576ce6af4a214d55862646d034effd328ef5beed8d7b0f380b6b689_Device=CPU_Config=() -305:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=0a7b1efc8d314c5e37062e482a9398f718082ba0528c6ca2d2f6c88e7a4a2bb0_Device=CPU_Config=() -305:conformance_Loop/ReadIRTest.ImportExport/Op=Loop.5_Type=i32_Shape=static_IR=5b9cbac8797158a77d5616e8b7e5d8132360e23e26d31d845f0d129df7bfd7b5_Device=CPU_Config=() -305:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=fdb744ee1deeced50395d992d949989a5e8bac5d4f73a6d4b51a56f22359f4f1_Device=CPU_Config=() -305:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=static_IR=57d49137431cc7fe4364cc2fef13111fb9f7a5a908b2d7b6f5663100ba5d636c_Device=CPU_Config=() -305:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=c70693ee2f825a40f3e1fc8dd2ce9355690bc33ff27030f674d082a0cb343cc9_Device=CPU_Config=() -305:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=efeea353bf41d0aac1f5400e451346d6cb407610566018f368726328cafca221_Device=CPU_Config=() -304:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a0b3d7813e380f287a758c35e56e8e8edbb72b8c64fab6194a8890dacd5e2f16_Device=CPU_Config=() -304:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=92f5c3aa4427a89ad6ef275c0beb2139cbd0c6ce2eb71205117448adf592ad20_Device=CPU_Config=() -304:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=776ce5493890837f137a7abc7851ff04164468d7c13ef1022f73f1f68e058c1c_Device=CPU_Config=() -304:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a7242174afe3f7c2e95d31cd14d56ceb0a566e2e8d65ba97e07d004200f4f517_Device=CPU_Config=() -304:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=876a77d1e2efb758a87bce1dd2fe35cd8e455c6f3dd7cd2bed8e10504c426de4_Device=CPU_Config=() -304:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5beb9762188e985c9554ffb0a05fdc1608fb7d970baacebbbd7118186a324617_Device=CPU_Config=() -304:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d2d4814c8ab7cbe5107a556fb3e73998aafae0278b0d304fa07fc4ac9fad4559_Device=CPU_Config=() -304:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i64_Shape=dynamic_IR=50ebc9636f3321fe9bc87cbfe301c8ca3ea27f56cf429c983ceed6ae63bb3885_Device=CPU_Config=() -303:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=610a8f8c44b0e133d4b5684c37017859d06bb2251482eca0cdece0a1c216b936_Device=CPU_Config=() -303:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=20450a7796284bbdcb011ce027d5c7260ed7dcdf07e4d39e48d99a2162eaae51_Device=CPU_Config=() -303:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=506b15e531d5a643d3276fd84af8e10eb2a62ce20fe3aeda90c50cd7442e0a88_Device=CPU_Config=() -303:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=8fc296db9f7dd10289217cb81cdf5991c6b5f3c89369936a94c8ac484702bfa3_Device=CPU_Config=() -303:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=22707f4dd48a39013f543e7eea951a8feb16952bb25f9dd34a0f05dcc28883f6_Device=CPU_Config=() -303:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=00d924b3557896a41b0be32897f7b7293fcc44d79a285e91695a5fd2f29f3b8c_Device=CPU_Config=() -303:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=6d5907929d59d1f99e85183238e29d6602c84721d099284dcb8900ae5fc3c45f_Device=CPU_Config=() -303:conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i32_Shape=static_IR=8d3863956a8a6a5067c45d40ae0207b14b9f1736bdf2a5b8c01979fbc012a5e9_Device=CPU_Config=() -303:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=94b08f3c309048124724d9de0d120698fed90ff0237b07c4a4a2b7ccf843d76a_Device=CPU_Config=() -303:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=b81d993247e604272e6df01b8c4ba016be7f60263c892e8469deef67a8a6afba_Device=CPU_Config=() -303:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=16ccecc11352f2c476db041adea21d67a96e03cf33902b37f4f6855b5113c202_Device=CPU_Config=() -303:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=5d5dd8756ccd01ee77e0c17d26f248c9e35d07aa812dc64bc39ac1ffe17ae585_Device=CPU_Config=() -303:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=0cc60631ab50733ce6b7a2256c0db1f9d9338505ae85b30fee02026c28511383_Device=CPU_Config=() -303:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=281f1852405ad37d0606184e81d8534d769f50b3fe99f5f17ebfda6954f4a584_Device=CPU_Config=() -303:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScaledDotProductAttention_opset13_Device=CPU_Config=() -303:conformance/OpImplCheckTest.checkPluginImplementation/Function=BinaryConvolution_opset1_Device=CPU_Config=() -302:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b2ca18b9d9f9e7c05f66a1f197b65ef9ca1d59319ed5f30d4eadf6f8befcd9bf_Device=CPU_Config=() -302:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=562ad06104aa1fed1781e5e3438d71855e1ee7e0126457f2d8d8d415f9c30c03_Device=CPU_Config=() -302:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i32_Shape=static_IR=61760c9c95110bf88cbfb8aa09378cc214d4cbbbd6c39c98feec1dcfbb7d47fb_Device=CPU_Config=() -302:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=8368b4f6e208aa4cfbf0aeaa648e9408c281a71d98d15ee09407d26274fb349f_Device=CPU_Config=() -302:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=1366ff72dd5b68a3faf25de8f98e4ac5500663b1aac4941af11532ea2ee769d3_Device=CPU_Config=() -302:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=670a0d513277b4508e8edcddae6361e98fd03c2fff31293637c36f97e59a6b9c_Device=CPU_Config=() -302:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=ba1a7c4cca6d39b8bc7be7d52a0680d055e33a776f4048ecf38335a2ccdd8d51_Device=CPU_Config=() -302:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=92dc9b12889f441d7a93e95851a15849139787b0ecc080e70d266fe4cb6dd9c1_Device=CPU_Config=() -302:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=() -302:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=b459cd78b41e36a6c3823301811fd3322a77f802ffc3399eefdfd8ffa4ce6e6c_Device=CPU_Config=() -302:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=98a6da6e0972a1b70caa5df788a6921d4e470565dc3880faa59e913fdc15f460_Device=CPU_Config=() -302:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=7b8eedb1c6be0db4a0c041ec3b04498d6dc68b326c35533ae16258e750f21e3f_Device=CPU_Config=() -302:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=f0d5131a073c03932316e3f20f40c527ddabafc926f0d10824a96158c03524b8_Device=CPU_Config=() -302:conformance/OpImplCheckTest.checkPluginImplementation/Function=Tanh_opset1_Device=CPU_Config=() -301:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=445a2c47e85b116d03e5f6fe43863a39778b78ca5175fba1bb0eec669f7610cf_Device=CPU_Config=() -301:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=f32_Shape=static_IR=7f806d6c4a0ff3515dd9a092fee2ab14a5f363fd5fbc7503d64a8cec4bb1cca3_Device=CPU_Config=() -301:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=() -301:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=() -301:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=fb8064c0836e50254162e2a9cab01514f76b19f78084410b6d1b69bd54f93168_Device=CPU_Config=() -301:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=30f4b90114764377dcd8e010019eefe0ec9c21dc6f0503b52323dfe867a51df5_Device=CPU_Config=() -301:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f069cbce6f4c3276869b6d9c4a6c843d7a1e1c9d299e8680218636b04339a9dc_Device=CPU_Config=() -301:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d0aad85620a1b97486758b17c69043a6a9cf75a459bf6e283b28ca132e917dcb_Device=CPU_Config=() -301:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=a7d9ffa60c8d1f330ec303edf6a6c0f8d8e0fe8657c561431bfb91a94c2639e8_Device=CPU_Config=() -301:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=d673fdf688abaeaf4cc6239ff762f8df557ab445bf9f031ab3bd87782717f2ef_Device=CPU_Config=() -301:conformance/OpImplCheckTest.checkPluginImplementation/Function=Pad_opset12_Device=CPU_Config=() -300:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=() -300:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6d705ecceb3a026a9be0b5963705b0c3c6be0123fb7d25885d3ae21213f1716b_Device=CPU_Config=() -300:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5e31c7022ed7bf2adff14876be4bbf6562afdc2239a08ddcdb507e3d1a20071b_Device=CPU_Config=() -300:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=6e53e1fedd57631f3ec70d6825d8d1029ac95905b82b6bef7fd44ba87373e9c6_Device=CPU_Config=() -300:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=i64_Shape=static_IR=d4acbcb1930b26610eaa33c0bb8aa7fd866d8142afda9fd007226f0ee6fa5c36_Device=CPU_Config=() -300:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.3_Type=f32_Shape=static_IR=a56b3f758c88a5723e4a2cf04ce46c92681ed7fb0d6dd7f4d5b937dbf00b0eff_Device=CPU_Config=() -300:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=7b9883414482f3b1108e549a9c47bb8a8aa162d962813c7e99411d000e02690e_Device=CPU_Config=() -300:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=i64_Shape=static_IR=68115f3a18f8ea201078166547e9c2a8587a5bb37646adf6f90da976f7298386_Device=CPU_Config=() -300:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=7fb9c2cdb4c82a4b65d110fc84c03948917cc1921c372cc645cab00a3377fad8_Device=CPU_Config=() -300:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=7988ae4f263061e530c61f5987afd5e7f1945ecef9fcded2bc9799afdcec0df6_Device=CPU_Config=() -300:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=33d84638f606d759354e190991899e47d2f4c63b0e378aac985e5fb9132dcd01_Device=CPU_Config=() -300:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=ae7b6a45a538bb7f65d5895f2f7941fd9048645482faa40adb1f773e282a946c_Device=CPU_Config=() -300:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=7b8eedb1c6be0db4a0c041ec3b04498d6dc68b326c35533ae16258e750f21e3f_Device=CPU_Config=() -300:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gelu_opset2_Device=CPU_Config=() -300:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingBagPackedSum_opset3_Device=CPU_Config=() -300:conformance/OpImplCheckTest.checkPluginImplementation/Function=DeformablePSROIPooling_opset1_Device=CPU_Config=() -299:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=08fa156c3f25fc8836356fd1a8edb73222f9fe2b3476c0ae32a26636b5870247_Device=CPU_Config=() -299:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=cc5e06594accd8694073f3ebe702319fe0711c3b7d4db5e06072d83eeb7cb096_Device=CPU_Config=() -299:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=fdfd59e3d316eea2f9fc3c56664cf1a07603bb6e26d1b367987d5046526ac60e_Device=CPU_Config=() -299:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=136768c6c28210cc47eacf6667103eac8106e3f255618e067d351cb700e62cbf_Device=CPU_Config=() -299:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=644274eaea5cff1fa9976380a2c024a8510f88826d0c1a6036aea3b18e3ecd8e_Device=CPU_Config=() -299:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=dda9a81656cbcb4ab5484fea52e7172baf67d46babce886726c96eaa1980766d_Device=CPU_Config=() -299:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d42cb628111ca80a33a558dcd1c2c310aa7b95d6c48549075291f49ec59c302d_Device=CPU_Config=() -299:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=() -299:conformance_NormalizeL2/ReadIRTest.ImportExport/Op=NormalizeL2.1_Type=f32_Shape=static_IR=e177da00e93cb595c18d142e92898135415f0de01a3b1ea763f3ffef3d7ce96b_Device=CPU_Config=() -299:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=f31f6d969e04a7a1c964c02f107a7291c85067ac31d935921bc418363c2a7a46_Device=CPU_Config=() -299:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=c4d1a1fdd0a336620be37a8ce7578ca0dd0c74f89fdb32ee86e7004792aa8445_Device=CPU_Config=() -299:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=491b849a7ce8fdb2190df5415fe037ff02fc23814efc520c343e872f539d6e55_Device=CPU_Config=() -299:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=58b9cf97229bd8293e747a47979c3d98261275f9da473dc942b746a06a1fa214_Device=CPU_Config=() -299:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=922699707423c4110bf8a551eaf7dc3689fd3673fff79cca21442cda90c22dda_Device=CPU_Config=() -299:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=55d83e2240e88295a78084f92162888c9b0beef46ae468cd7ab93a1c0a432835_Device=CPU_Config=() -299:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=3fbff9f870428a19ed434cdf72834eec251edc3dddd149491c94319d63a8438e_Device=CPU_Config=() -298:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=18763287c1afb7684d3f74e91fbb8a8c17a13aa52908a5d97b6ad220c5c4f633_Device=CPU_Config=() -298:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=d51bc4204bb6079e79da8d0cf95ab8a3454c90a040aee0fc6fedb00f0795c577_Device=CPU_Config=() -298:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=() -298:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=dynamic_IR=3e669c3f90fc7b2209d3d588932f8eff3827309a5928f4b27722139964e2c46f_Device=CPU_Config=() -298:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=debf36fea706c02dc67354edf761f0dc931ebcccbed285f186164fc4b9532766_Device=CPU_Config=() -298:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=05e9fdd5183bd179e5ef996ebcdc53f239900ca46a8122ee8bb1e885c2c091ce_Device=CPU_Config=() -298:conformance_ReduceMin/ReadIRTest.ImportExport/Op=ReduceMin.1_Type=f32_Shape=static_IR=61bca82940fd4a54bcb587a88272b81c191b8feeab37bfafa044ef768240977c_Device=CPU_Config=() -298:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cf02be750ce25545f7bfd694603192667eb3fdb07a186eaa7f3ecf5767547651_Device=CPU_Config=() -298:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aeabe9639d6dcd5ab6e09f9905ffa8bdfe7cafcc7f5c8598e20e4ff39bdb50a6_Device=CPU_Config=() -298:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=246f55d43a6e986a8ba35f711c43dd32cfb1ca097598b0a01690d4765e0d5019_Device=CPU_Config=() -298:conformance/OpImplCheckTest.checkPluginImplementation/Function=Round_opset5_Device=CPU_Config=() -297:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=90deb33b54746ec16cf8594f8aa0792c6aab2e27ff12ed97523da583402aad95_Device=CPU_Config=() -297:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=37f1a0a9bb9b948ed78217a65a5a2de7f0234b1e000fe5ee11ede68767240f1b_Device=CPU_Config=() -297:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=fe8bea06bc602fce2362c5c7671e3c8cfc63fee6bace0be9baa41e9874e86b26_Device=CPU_Config=() -297:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=adee3d4d6728b17fb5ab17a9915c5b7c8808f949ad358e8a16a0bb12dad7c958_Device=CPU_Config=() -297:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=f7e1aae2dbc817ca8f64a6bb0742e476055c239cc6e31a4233b7580205feeb41_Device=CPU_Config=() -297:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=6c1aeced5aaaecd99f3917a0f38e01902dbe81614ae4dc9a99fc09a379990abc_Device=CPU_Config=() -297:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=0a5f9fad12bf5e2592c6f720232bb38d94a5fb9ac1fdc5a8f7d474ed9e9d2504_Device=CPU_Config=() -297:conformance_LRN/ReadIRTest.QueryModel/Op=LRN.1_Type=f32_Shape=static_IR=c1a0f6661ad306b82e66063988835c1a17072608792f3423bb058fe38c4b14d1_Device=CPU_Config=() -297:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f4b78bee713f23abfda124ca92d58828eeab6118710d93572a491cfd85cd05b4_Device=CPU_Config=() -297:conformance/OpImplCheckTest.checkPluginImplementation/Function=ConvolutionBackpropData_opset1_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8f622d39d560109549e99d37f3c9cb476f4d69e8525e7a0ad8fce6fe79a6f982_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=526afcc4dff58aaa019466b0440b94dbd2d5f14c060d47b8ec40183deafecd83_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4c794e0e6b27bbef5d21922537d8b23d0d2b5955622c1f5ee724a4d8faf2c86b_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=461dc8aa282946831fdc86d1c024a273ac0f29f5ad615cd55b879feea6d23007_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2c20f6aace24bf601953b848c173ad475502b91b667c903638acf41fb9a67d3a_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=04e25f2a56de557c8da87110ba02c02ae45277d029964d932fe6837acc0f1b10_Device=CPU_Config=() -296:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e5092af5c0f683044b1df5a45f211f4a692436d1112181a5d613bbf335941684_Device=CPU_Config=() -296:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=b288dfcaf8fd8fefe24212a70255bb280e7e695badf6fad6538042701d77073e_Device=CPU_Config=() -296:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=i64_Shape=static_IR=6590ae34a784f81de25c016454fcc919ae1f9eab672c78c9da0daf83dcdaf1bc_Device=CPU_Config=() -296:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=2b927ee73187f1c1cbdb071ad3c0a72c9eb8a8631f2e7c6c3a8f8482c301fcf3_Device=CPU_Config=() -296:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=53108cff3836c47360380f3898c5de245a566a5d98040820d78befd46e56955b_Device=CPU_Config=() -296:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=46b077d7466eecbadbb7ceba5ed90724db3d9e216d22171f5dee02e44b9a5377_Device=CPU_Config=() -296:conformance_LogSoftmax/ReadIRTest.ImportExport/Op=LogSoftmax.5_Type=f32_Shape=dynamic_IR=a3f02c85607891ecc34c484b433c6a78333e13f3d8cd231e651f8bec26e7d0ce_Device=CPU_Config=() -296:conformance_Less/ReadIRTest.Inference/Op=Less.1_Type=boolean_Shape=static_IR=8cac1c4c51c2eb61b9ec75320814acf81b9ac240a88e1cc68f29541f6eb546e7_Device=CPU_Config=() -296:conformance_LSTMSequence/ReadIRTest.QueryModel/Op=LSTMSequence.5_Type=f32_Shape=static_IR=f36a3f626860d7088b33d97a5a6ce009c89609c142158b256aeb6b5e6dac02d0_Device=CPU_Config=() -296:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=246f55d43a6e986a8ba35f711c43dd32cfb1ca097598b0a01690d4765e0d5019_Device=CPU_Config=() -296:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=dynamic_IR=e46ec3487f18188d1da4c029a2981033018c1f8f273f60d3f7d1bcbdae18c2c5_Device=CPU_Config=() -296:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=() -296:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=5b466c4e4b53a5ea739df517da47f0764f9e31197b7d30fd9dabf17d1b33a489_Device=CPU_Config=() -296:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=d435aa8d2d045d69b2d187147f90c879205f27346ac991765ba97bd47d4fe0f6_Device=CPU_Config=() -295:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=df97761393479b4c56cc923a2b89888b7c3fb949f5c3a93f4bba0ac8a44178aa_Device=CPU_Config=() -295:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f66bbeb796e4da5d462ef573e38fe52db5bdaf2367b2a07aeedae6ce33c6704f_Device=CPU_Config=() -295:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=9ec266d6550d7e0c9f4d6114272d7afc80ad822b0bf5078654598b3d623f356b_Device=CPU_Config=() -295:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=i64_Shape=static_IR=d106f0cba8d8311b75f6074c099f45e10400c0829fdd1826292b1310471076cb_Device=CPU_Config=() -295:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=109afa0426a29179db58e16917b829096af105f0def2375a589ea1391138ee2f_Device=CPU_Config=() -295:conformance_NotEqual/ReadIRTest.ImportExport/Op=NotEqual.1_Type=boolean_Shape=static_IR=8fe4bce2e674753d81a1516280769a06cdde538e658ae548087e4888ffa2905f_Device=CPU_Config=() -295:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=10cf1b7a4de1231ad721c9660697d6ee17bcaa2151f08eef596b41e6e3aa1b2f_Device=CPU_Config=() -295:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=() -295:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=6e6c053ee1974a5d036c6d549508f6d43586d501c72db05df9930639ad745bc4_Device=CPU_Config=() -294:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=45b3506bf3dbe053fcb290dd1040a9d125c56086b37223e8480647bdd9b9372d_Device=CPU_Config=() -294:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c9352ef8b6aae01025051f9c73f023e7b5a13f8987f81bfff4ce0ff9725c21b5_Device=CPU_Config=() -294:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f9e738e5e947a25c9a0d18fe47597f10526e8a74e9d72b35fd848b73f4c80b0f_Device=CPU_Config=() -294:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=a16b5a0ea2fc8d89980db21cab743fbf776918ed2ed1f91f2e4d3ad3c304d4a4_Device=CPU_Config=() -294:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=bec81407211db6e10d7c8811bc58b53c23c8aafa0e2083f262204f345b9bcfc6_Device=CPU_Config=() -294:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i64_Shape=static_IR=def60f5f3fb7a0d22cb3d23253e7c8e502aa9dd2d3756c54dd4343b66c2682ca_Device=CPU_Config=() -294:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=6dae5ccb2325826167ff4ec57e51280b4e125801e6405a33f4d95fd9ab9f3fc5_Device=CPU_Config=() -294:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=5150e1785d97b052a42873f9e9d23a511027248ff4b13ba7c269c8c3d4639e45_Device=CPU_Config=() -294:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.4_Type=f32_Shape=static_IR=f03721e9c346ede7ba78d0a2466e38cec6d1e08b3395b38c8f47ebcbfba35d3e_Device=CPU_Config=() -294:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9033954b258cdfa9fa858317ee4588b8c92cc946d7eb305bf130d3ca8ee0f1fe_Device=CPU_Config=() -294:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=f3d704d4f0da6c58c39e279d727dd82fe0e59a41dbaf09a3cbaa8f591daf95f7_Device=CPU_Config=() -294:conformance/OpImplCheckTest.checkPluginImplementation/Function=Cos_opset1_Device=CPU_Config=() -293:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ba28829f211d64d6d4922682b85f1bad6a3c28cc30b4f9651186b1e8fab39fec_Device=CPU_Config=() -293:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=() -293:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=43d0f2c259414c3e23105e2f5a13e8faaf322904d9b70ceb8a056bdb51677ef6_Device=CPU_Config=() -293:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=72373e9c2bc4cdf2f0aa0a5d14e30ed1a5e0545d9a96f4ab675f3b9dc69d8cf4_Device=CPU_Config=() -293:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=592176a8c97f4d759a0c6b3ef56c3610df4a0df4743f3be7ba3ed2ffb5dcfaed_Device=CPU_Config=() -293:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=377acd11b0f7dfb4f3e57baec8a6c8a84737857b7e794614542f139982feaf73_Device=CPU_Config=() -293:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=d50dd7c19583071293118e8b98f2bc749ef3e34ab8eb0149138e6b9fe49a153c_Device=CPU_Config=() -293:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=6837cea94eff6256c3c29807532662e123ccbffde1fcb6f75875d65aa7124a4b_Device=CPU_Config=() -293:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=ad5c5df7cea37955709ef71d9967828ce3f0011e68aa1c6085984f1422944058_Device=CPU_Config=() -293:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=424814fbe4a3ba7a49c506f11509c035212fbdf4ef44fb2bc708c5f201e4e1ec_Device=CPU_Config=() -293:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=b11ede8f1aee40577413d8bbe89704e02252e3f02805fcc0ded624857ddb8280_Device=CPU_Config=() -293:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=a815b68b6a8d36546d3ac0112c60283bd69ae1059e8deeb98b21f538c8089beb_Device=CPU_Config=() -293:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=d442b2d9df68f25f567a3e8da8d87866c200d391624cf1c339554a57a9a527a4_Device=CPU_Config=() -293:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=f8c3c9cefc3f7ab9b8e1fd3031be6eb34eba46f9c493b316439c24355a8a4978_Device=CPU_Config=() -293:conformance/OpImplCheckTest.checkPluginImplementation/Function=Selu_opset1_Device=CPU_Config=() -292:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=12e571ef61251520c35bd8c0429b1ee71277033ae88101f08dd769a300d86c5c_Device=CPU_Config=() -292:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1e9f662cfa263a98c546e69de318268918914f2ddd0ee87cba23c2690a81ec19_Device=CPU_Config=() -292:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=15995a372d69998eb6a001f53486201fa9bbc89fb608c7d2a447203a404713ea_Device=CPU_Config=() -292:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=db87efd37ce8dcbe14286197df3b7a345fdc46ccc03d7d8bda17e3791df332aa_Device=CPU_Config=() -292:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=9031b1919c35a9df591ff64fbe4748c02cc837649899099542716f35b5c68cc5_Device=CPU_Config=() -292:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=7f37f31081476643f5c279fddc3d25eae22d909730b4aca0211aa70fdd572843_Device=CPU_Config=() -292:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=431db89311a543581d104e2a2c498fe021da2e4026323817834670bf5bee67a2_Device=CPU_Config=() -292:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=ba4f511cc4a0870c64cc5027fa39b2bf91a6e7f39ea36cd43a693eb59de6d836_Device=CPU_Config=() -292:conformance_NonZero/ReadIRTest.Inference/Op=NonZero.3_Type=i64_Shape=dynamic_IR=7d0265450b8fc92464273ac05d685952ea3877be45b4d745959f2f373fef1431_Device=CPU_Config=() -292:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=fb8064c0836e50254162e2a9cab01514f76b19f78084410b6d1b69bd54f93168_Device=CPU_Config=() -292:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=98526403db7eb1f67a41aed2c34fea684d99d8cb8225313136e55be7d326aaaa_Device=CPU_Config=() -292:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2fc01b66086ac5d8272dd81ab731188b62bbe8920bff1efe61bf3261a3a8b3e6_Device=CPU_Config=() -292:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6af32fc288bcbd414ea63525c4345aeda74ab21c44aab5910f85b8b7fb5d1179_Device=CPU_Config=() -292:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=ff39aa885f7ecc22a06f668b79fef4ac41b3adf8dea82f428711b241c0fa6059_Device=CPU_Config=() -292:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c5c5d09465cec7f1477d5e02f3f1c4cf593c71aa090532c4e43451fedde7c2c5_Device=CPU_Config=() -292:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=1988b645a87be14c17740085aa8c4a38e88cd2111f0ba294f77ed0bf856b0561_Device=CPU_Config=() -292:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=bd3ed1b35506cb92c8e587acb102c70abbe02bdaa75f76e5792d48d8e1f2f33f_Device=CPU_Config=() -292:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=c202ffc0e1805a36e48ee4b06d06b68a9f179eef00dc353a092a13818e8ebbe9_Device=CPU_Config=() -292:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=bd99ad9e1d756435cca9c6309caf45043f34c6c3c844f60e17deb8dfef4234f4_Device=CPU_Config=() -292:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=87523dfccb2a9c8334d6810e33c2a2d3b6bc09db7623e7ae93ba4cea89b66a06_Device=CPU_Config=() -292:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=489201dc4d1a937b4387f1b7d01f75fa42ff02d7035d39ac6a7f56536b0d3a20_Device=CPU_Config=() -292:conformance/OpImplCheckTest.checkPluginImplementation/Function=IRDFT_opset9_Device=CPU_Config=() -291:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=37337436d0d481c689caabec3bbc8f21ecec65560c70de4dd1f5b0ed9e444bf9_Device=CPU_Config=() -291:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=fb8283ecd8934dfc5340a41e9889a0a760b39869e4873efed4ef85606c162ce7_Device=CPU_Config=() -291:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=() -291:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=9f4964a8b6440cdec94781121b408df16f0ef2283b0355583eb934b3cd2bcb66_Device=CPU_Config=() -291:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=b288dfcaf8fd8fefe24212a70255bb280e7e695badf6fad6538042701d77073e_Device=CPU_Config=() -291:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=dynamic_IR=f550a37ab884668f47ed232e7119c2a2baa814c98fbbcfa3129e7a00feebde0b_Device=CPU_Config=() -291:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=56fb4fb30ec6fd9ddd0ff2e394434eb87546ac7de273f47b663252efa2a380be_Device=CPU_Config=() -291:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=0db5765bcfeb7716699abd0cee850918cf5ef18e2cfdf1614b463734ca35a20f_Device=CPU_Config=() -291:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=923032e47821636c4c8098a7a9afa97b331a47d47357c780b7bced2e46ea9921_Device=CPU_Config=() -291:conformance_LogicalNot/ReadIRTest.Inference/Op=LogicalNot.1_Type=boolean_Shape=static_IR=66b8769b499fa31cfd7545411d16a17b04e1a336bb63a7e907707cd170a30fc9_Device=CPU_Config=() -291:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=474e4bfe52232239280bbe4e2d2aed15cf69c7ec8db86b010084c6e68a8d0e1d_Device=CPU_Config=() -291:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=596d0b6cfe8b39e0ceaa665f1fa82aeeeff78d09315fca7cef031b6dc210a1f3_Device=CPU_Config=() -291:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=03ebf297344daffba82d04292a767fcd7c959f56788ede32ff0d7c5af06ea504_Device=CPU_Config=() -291:conformance/OpImplCheckTest.checkPluginImplementation/Function=RegionYolo_opset1_Device=CPU_Config=() -291:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset1_Device=CPU_Config=() -291:conformance/OpImplCheckTest.checkPluginImplementation/Function=NV12toRGB_opset8_Device=CPU_Config=() -291:conformance/OpImplCheckTest.checkPluginImplementation/Function=FakeConvert_opset13_Device=CPU_Config=() -290:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f0af28fe49c157f5f62f72f0ab209c50aa07d97c65477217fde6e3a3d0dc98ef_Device=CPU_Config=() -290:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bf802641cd9b20a23b73202f401f4b32903ac7083d0ac7026098cfb4311b35c5_Device=CPU_Config=() -290:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7895fea00309326a052d47dbd2f9e562b86bb9d0501f2a2fd8843a0340359b67_Device=CPU_Config=() -290:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=71010d034cbc059af32ae6066fff1f27834db480e76042d1ef7bd1e7bc426a08_Device=CPU_Config=() -290:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=66abbc2c605a0f866880bd4730865ae6b5401a1f4beb242f346bf6f2f8138eb6_Device=CPU_Config=() -290:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c90b6f528b750f144ddd29be0059c202d46b3bac799c0d70893f2f4f9f05f64c_Device=CPU_Config=() -290:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=boolean_Shape=static_IR=6d34694c9c8e71415be894a80a8ededc6a83657c6e7ce3aaf66dcd6f9ab99226_Device=CPU_Config=() -290:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=707190f77491e910ce61476cd3a9d5dc275e7c5ad820cd3894a37c348c2995ff_Device=CPU_Config=() -290:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=() -290:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=cda3b9bda63d065b5c27e6bce5ffe20968024d77efe5e174a9f4395db56a30c0_Device=CPU_Config=() -290:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=dynamic_IR=e306da3fedc4369302fb21159f2bbbe65849661eabe5bb83efdad3e83f64fd68_Device=CPU_Config=() -290:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=cc13aaec2a2bbe9b760651d358622114b4b0a20cb106472bd8519f0fade61dcd_Device=CPU_Config=() -290:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=9b9521ed73100b54a3c5920107db944380157eea1b72f4e4d94f8e2ced1f2e4f_Device=CPU_Config=() -290:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIAlign_opset9_Device=CPU_Config=() -289:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=40c74727a381659b1343c4083d7f903ac2519d5297703fd15979a32f820adfcb_Device=CPU_Config=() -289:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=3e669c3f90fc7b2209d3d588932f8eff3827309a5928f4b27722139964e2c46f_Device=CPU_Config=() -289:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=c7ce41820be10f17c8d48c005703d536d18e4f49b1d2022ac58f77b7b9afadec_Device=CPU_Config=() -289:conformance_ROIPooling/ReadIRTest.ImportExport/Op=ROIPooling.2_Type=f32_Shape=static_IR=baa256d53878b528f6bdba95bf1837cc570dd83b577220f95d9c24cb26d37c35_Device=CPU_Config=() -289:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=4212a754718adff414309fb1da18c4361792b5478366bfdc0994490c7bc716e3_Device=CPU_Config=() -289:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=43c8e8300f01242788a8cfdc37b48779f51f7ee7aef5b28e8de542320ba86e4e_Device=CPU_Config=() -289:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=32537f045cce3d13cb28dd292a0ebe06e13002877d9ed2e5b25d3ebdf5afcb58_Device=CPU_Config=() -289:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=() -289:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=64bd2f48b3326db083653b5993c9a75d21be515cbc5af67c62c981e9744e2f0b_Device=CPU_Config=() -289:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=2001ebb8291c8bc8cd1db17c172f216cfb3994c57e344eef65565ea9f9cda1d7_Device=CPU_Config=() -289:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=f8c3c9cefc3f7ab9b8e1fd3031be6eb34eba46f9c493b316439c24355a8a4978_Device=CPU_Config=() -289:conformance/OpImplCheckTest.checkPluginImplementation/Function=Convolution_opset1_Device=CPU_Config=() -288:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4d2e12e00779d116e2192ca77f2be233d76bdd5ce366ddabcf436cc205a9f811_Device=CPU_Config=() -288:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=e2da6d928938b6445170cd69fd4a7aab40130a560cef3ffa2d268a428f56fcec_Device=CPU_Config=() -288:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c6b8f476c9b5cf1a102cb33d5e68033bb074a520d01e360ff46b3e479addf407_Device=CPU_Config=() -288:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9730f247ba4a13fb03274850f295de500156107d33db957188846fe49c2f4566_Device=CPU_Config=() -288:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=978c6fe274296020718998393e7fe94bbe0a0856fc377aa474df0454534824a6_Device=CPU_Config=() -288:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=63ba45deb14e56e09574bd3694e3d94caf6ab09f67f5278e6c299c6c924a3cf2_Device=CPU_Config=() -288:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i32_Shape=static_IR=61760c9c95110bf88cbfb8aa09378cc214d4cbbbd6c39c98feec1dcfbb7d47fb_Device=CPU_Config=() -288:conformance_Sigmoid/ReadIRTest.Inference/Op=Sigmoid.1_Type=f32_Shape=static_IR=936ac30f388261cb12776b5e94062a9b5f7b81aa16c9aa5d8f994b8d69231c40_Device=CPU_Config=() -288:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6167830634e0b253aa78e883453d45bb737cd5df33c849e4b16b99164fd49d5e_Device=CPU_Config=() -288:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=8ea778d7d98fd08efe4b2efa501ef3599df00ca9bd036980ce86e0d6dc454b96_Device=CPU_Config=() -288:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=a58fb7847e59bb119656b143af0c6f65e29f8211034fe7aab03666cdb95d7fe1_Device=CPU_Config=() -288:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=() -288:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4819c2459dd2bf875545cc912152c6751ed5db8ef07aba31d3eae6c3dedc7aca_Device=CPU_Config=() -288:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=120b0e6b0c1f7bda754d62ac7c88e7c8bd9e96ddb85e7e5f29decdaa7c1cde96_Device=CPU_Config=() -288:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=023f3573ef77fb592345c68ee5e6a79191b120f9cb68f81194381da2cf68f21a_Device=CPU_Config=() -288:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=66cff13148d62809cced5a381c251525486476f7178eddd3c8e45eeed40afd06_Device=CPU_Config=() -288:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=29624e785b9377dbf03b9aae46e7d0049e93a94655059ec37a0fe308ff7cb9a3_Device=CPU_Config=() -287:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=53828d433bfa231cac709949db0e4ff72010e5cf9df167ecda7ac72bd5a69e10_Device=CPU_Config=() -287:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=c20603ac895226554bc910680f6be82589e053503b3067b3074bcc210f4d0ef2_Device=CPU_Config=() -287:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=582f7347a93cb2c9e51ade6c405ff25b23d009bdcd3d7a3c49902e627a041252_Device=CPU_Config=() -287:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=19f9f95d2205816fc002d8eaea7cfb19f19218fbc3528e4932b99f1486b62827_Device=CPU_Config=() -287:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=1e5127a9c21ad1ccabe67dd1f1e28a3730c09ba294ef1f9fc001c6dcd723ec62_Device=CPU_Config=() -287:conformance_ScatterUpdate/ReadIRTest.QueryModel/Op=ScatterUpdate.3_Type=i64_Shape=static_IR=f5ad439e65ed1e090d3d5744e9e5bcd9b8fed6ac6a191735cbb1cdd9af8bccf4_Device=CPU_Config=() -287:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=7744b2351d112ed761ebe0f43945f7dfd58fd2bfbd94bc5a4737549923caf4ed_Device=CPU_Config=() -287:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=18697d690af0de3ff8365a5aafa6ebc7d8e14418c3ab5dd55b3b505d2445ac86_Device=CPU_Config=() -287:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=b6669eb568f36e5d649ae67afdecaa481064561d7a71f1aab592968aca7d8bb0_Device=CPU_Config=() -287:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=fbb85f74ecfa0ffc50b9e6ce637911b406f1fd6ad054a886b9c6ddc6bc898739_Device=CPU_Config=() -287:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=8919e05ab2b0d545cabc2e2732828fa693c8f364e9d4d03faf7097f787d4f628_Device=CPU_Config=() -287:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0df360e6d6391827cd65ceefd3201c263a829e50ed375522d4e8700f3879de09_Device=CPU_Config=() -287:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=30680a7972de02e47d59c768730b8a64a06b011dc8b5be4fd25f190662cf1c1d_Device=CPU_Config=() -287:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=d81ef130a76622c79592b0b42acf5cd6dd357ccec28958dec6eb02a654beb9ab_Device=CPU_Config=() -287:conformance/OpImplCheckTest.checkPluginImplementation/Function=Atan_opset1_Device=CPU_Config=() -286:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e6aa73efa73e8b557d46457037aea3d6ba037b67ac1b52437354c2823abf2be8_Device=CPU_Config=() -286:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=37a75b89894d8a024fe6d1808e0674b4fb59534cd319f4bcd07c6d9caaaf97a5_Device=CPU_Config=() -286:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=fd10c1c5d33aef77d3428fb5c9789f3c2c2463ab9f6cb51184ad37951578320a_Device=CPU_Config=() -286:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a5e5b588f6223da1508413c42c21c3945994f492b039511b7ba2e576a052a52a_Device=CPU_Config=() -286:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=6a05cd292e71af9d96e456cbc515097d5224a9e41cd9c3d48cc73f1a4e6e2164_Device=CPU_Config=() -286:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=13dad9a80315de728323f8d84534389c4840a92e74073be42c312c46107fd964_Device=CPU_Config=() -286:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=fe80951a0a44625457a6106d8613c9813c9c0b8fe3606fa5ac1c064217c8a0e6_Device=CPU_Config=() -286:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=20c2030cdd180dbbfad1e5b8a4f865d1757a9d427c3d5ff21651a429369f4341_Device=CPU_Config=() -286:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=() -286:conformance_Less/ReadIRTest.ImportExport/Op=Less.1_Type=boolean_Shape=static_IR=953b15e350d9a27c4d048cbae41a278c732f3b3a6e8debd7fd2e75e99a015966_Device=CPU_Config=() -286:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e1f0357795d5676c5e4a38b6639cc90c924880ab961eb73e407b5ad0142ac0b4_Device=CPU_Config=() -286:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=3d5c8f5c1545419050f982e8555a6ef9e5dcc06545b1a8573d710e8bc2375a6b_Device=CPU_Config=() -286:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=0add7fb1bf1500ea125aa6d245bad577d6dea18d038c020d18c2dcd56704c671_Device=CPU_Config=() -286:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=3fec5c6f9e39d8a15d58c5800a889e1660adb375cb7660af1526cd31e69f7cdc_Device=CPU_Config=() -286:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=fced0ff647e4ea9a4b1673016b017f68ed75cdc778cad156dbd6cc379bb815f9_Device=CPU_Config=() -286:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=dynamic_IR=c3d754fe46cacaaf519f39fdc6feb9df6b23d92f6271f6e731c2a8ddc24a948e_Device=CPU_Config=() -286:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=eed21ac7c17920ba437332691e231037113367ee3d256b4db1380c8d2e0db84f_Device=CPU_Config=() -285:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=14c8a8bb712c40d63edf76de9a75dd1dcd53a2df8c6098c80ee760119966f364_Device=CPU_Config=() -285:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=c20603ac895226554bc910680f6be82589e053503b3067b3074bcc210f4d0ef2_Device=CPU_Config=() -285:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=bbf75e5f7aa9f20f890a8eb204ddb5f159ca5eae0616fb99ee0b5169b165d595_Device=CPU_Config=() -285:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=f32_Shape=static_IR=dbc3b2f724614a68d750ae4adfd7d8239c77ced05d30f89deabe272f104a5e75_Device=CPU_Config=() -285:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=dynamic_IR=fc75aba0dd172d6628de0b473569c672b52f070ac3c446cc3342cb1184ef076a_Device=CPU_Config=() -285:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=dda9a81656cbcb4ab5484fea52e7172baf67d46babce886726c96eaa1980766d_Device=CPU_Config=() -285:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=18697d690af0de3ff8365a5aafa6ebc7d8e14418c3ab5dd55b3b505d2445ac86_Device=CPU_Config=() -285:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=5038017e90f931327d5159938d422b2afc229aa4d776a4ac80a946724fee357d_Device=CPU_Config=() -285:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=065b3de2617f318d1376e9610f9fa1a2f2fc04292f9a7cc949780ae41d3539b4_Device=CPU_Config=() -285:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=58b9cf97229bd8293e747a47979c3d98261275f9da473dc942b746a06a1fa214_Device=CPU_Config=() -285:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=e4388b1379e224ea4849e6052827ef17b490cab3718159195ea2b2986719bb4a_Device=CPU_Config=() -285:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=269ec3789c76e21789e01e31f13f0f1a4895905b3f131e710e663ed2a0d8f632_Device=CPU_Config=() -285:conformance/OpImplCheckTest.checkPluginImplementation/Function=Abs_opset1_Device=CPU_Config=() -284:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=92ed2f40e1ecbb9a90904cfe8e8ceda94f73154a44ac28a50c0d7acb221e8835_Device=CPU_Config=() -284:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=69c68c20edefc8789e62a7cc8a0f8fe7e649f884649ac30833fb5a2ce43c4098_Device=CPU_Config=() -284:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=35525421f74fa15c49098ff1c7faed4fe65763d72ed13add33c6fe8d4dcfb0ed_Device=CPU_Config=() -284:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=97f8a2367c5590d5fe7e405d32ec48e5318a6cb3c0862f2b0e8705a7842e8105_Device=CPU_Config=() -284:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9403397dde8b4f6a240bdc928d0f080dfb42f6442f281d6b3fe8b6e348ccacfd_Device=CPU_Config=() -284:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=2233a83397f11ea3c674c4845409c4f27f8bffbb8d0295712a2525c9e93d6041_Device=CPU_Config=() -284:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=24e44f75d91fe4e7e28db6c93870a47d536abeb87240841ff5b7e74b40189e42_Device=CPU_Config=() -284:conformance_ROIAlign/ReadIRTest.QueryModel/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=() -284:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=a72b942dc1915ccee8af871c00b16647db7c8935100b012f91ebd799bbe8d416_Device=CPU_Config=() -284:conformance_Mish/ReadIRTest.QueryModel/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=() -284:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=313740a93070bb3cb89143685b7521ea0ace30c3f6d510a4d83ed809808caeac_Device=CPU_Config=() -284:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=bc1a7618e707ddd2c4773d1a2234e6dfb39954ad872abdf38a18d653ec35b26f_Device=CPU_Config=() -284:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=25f55a7cb5f72689bff67eb95af15c64b31c2d29bcde97611e74917fa6724ff3_Device=CPU_Config=() -284:conformance_IDFT/ReadIRTest.ImportExport/Op=IDFT.7_Type=f32_Shape=static_IR=cf47311b142dabf10271ebf5c2e359455d9bcea82d95ad2a1a2d58915c77bb16_Device=CPU_Config=() -284:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=66a4d902b67742a95e2d41d79b9d2434e57a55c168a88049624a0ccb62df9ca2_Device=CPU_Config=() -284:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e1f0357795d5676c5e4a38b6639cc90c924880ab961eb73e407b5ad0142ac0b4_Device=CPU_Config=() -284:conformance_BatchToSpace/ReadIRTest.ImportExport/Op=BatchToSpace.2_Type=f32_Shape=static_IR=f118f5911730937f9dab91ad5eb6f78cb1af6de7bae1dc745dab2d4f02257fff_Device=CPU_Config=() -284:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i32_Shape=static_IR=cd4d566c041357cdd7f8539933888956fff5cfd15e3c42872df59d9890c169b3_Device=CPU_Config=() -284:conformance/OpImplCheckTest.checkPluginImplementation/Function=Reverse_opset1_Device=CPU_Config=() -284:conformance/OpImplCheckTest.checkPluginImplementation/Function=CTCGreedyDecoderSeqLen_opset6_Device=CPU_Config=() -283:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d7a96943c0264427eb83ab413f6e7b0f15f09f83525de581fba582655d0fa4af_Device=CPU_Config=() -283:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=bb6a76dcb7d086a6f8dc96d3e0b17573b6dc2775ff9d0f19060947deda586bde_Device=CPU_Config=() -283:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=41c94561e79611e27aaf339205962d4967188b385d68c169b2bf4557173005d7_Device=CPU_Config=() -283:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=44dceb7343477ff50d3de4be1567a57a97d2e3c6f92b48fc93d20eea80487862_Device=CPU_Config=() -283:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=707190f77491e910ce61476cd3a9d5dc275e7c5ad820cd3894a37c348c2995ff_Device=CPU_Config=() -283:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=25f55a7cb5f72689bff67eb95af15c64b31c2d29bcde97611e74917fa6724ff3_Device=CPU_Config=() -283:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=2737751bcc195e4aaa63ab6d86d803741817287d78fc864e18a31c328078940d_Device=CPU_Config=() -283:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=09dd33f661a07095dc47e3e5205c9fc6dceda72526e79be0751c34823c7e7cf1_Device=CPU_Config=() -283:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=1da672197f2c962a6cdfb059e9d09c10a03c3b082838f53d2faf6a761fee0637_Device=CPU_Config=() -283:conformance/OpImplCheckTest.checkPluginImplementation/Function=Erf_opset1_Device=CPU_Config=() -283:conformance/OpImplCheckTest.checkPluginImplementation/Function=CTCGreedyDecoder_opset1_Device=CPU_Config=() -282:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=7dcfe3f43645f6b9f3290b524024a1a3d48efa3ce346eacc2330be7e27a046fd_Device=CPU_Config=() -282:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=9aba412b059ee77c603bebe3e49240d6f2183168002d25bb7bfe62f1224be2fd_Device=CPU_Config=() -282:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=u8_Shape=dynamic_IR=81bbb9658ad214babb825fa4b576aa83a9ceaae7dc0b878a84e42ea194f3ec13_Device=CPU_Config=() -282:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6cf01dbf95872b3fc0c914e73415ed8e4dd52cb355031002a65e3e974559d6d6_Device=CPU_Config=() -282:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=() -282:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=075342290aa43542c81f7ed4e804c905f110edc23440452c6d0c0f0c312b65c1_Device=CPU_Config=() -282:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=7293f99e38d76387b64632d06503c539c369e1ab78d9388e1af42d7071d8230e_Device=CPU_Config=() -282:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=dynamic_IR=85a35059512fed9e0c70cdcbd5e73c1e247ef97821d5193cbc4f7f7c3ebbaef8_Device=CPU_Config=() -282:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d8574c324ded923f1ea3ab0d8e09c626f3e8a04efe08258b665539c639b7958b_Device=CPU_Config=() -282:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=c808434d1d2cbd9ea66373f22c7e635c5bb2e3a6294f93421d1d9d34ac62515d_Device=CPU_Config=() -282:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=b005a58abf8192face35451602a847d378849223e4d433924581d28ef8141303_Device=CPU_Config=() -282:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterElementsUpdate_opset12_Device=CPU_Config=() -281:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=db5c391cca1031cb4ec32def18ce3a4776c53f71e861c39b350fe5856da4fa43_Device=CPU_Config=() -281:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=f32_Shape=static_IR=c14da825d470c9141af0ea87eb82edd0866a415cb5ac59f1014c2ded35340201_Device=CPU_Config=() -281:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=8973f2f4c2be5d0ed57c94e1aed24bf809e51854c03c2abd73ea37ef7221d328_Device=CPU_Config=() -281:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=e939c4d2a27e1d7dba93827ab807881c32e47d48b726fec701712bc85c3404a8_Device=CPU_Config=() -281:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=2b927ee73187f1c1cbdb071ad3c0a72c9eb8a8631f2e7c6c3a8f8482c301fcf3_Device=CPU_Config=() -281:conformance_ReduceMin/ReadIRTest.QueryModel/Op=ReduceMin.1_Type=i32_Shape=static_IR=a2b9f0b4c044e23f536d137b6e157d1357df657d1af119cb8f71294d7dc098cd_Device=CPU_Config=() -281:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=990cce0ce92df99ae74ad8840f7b89d1c48c0044deb9cb71619b44a565eed911_Device=CPU_Config=() -281:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=() -281:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=a72b942dc1915ccee8af871c00b16647db7c8935100b012f91ebd799bbe8d416_Device=CPU_Config=() -281:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=c307ba8fc5f5d81037e40e46cb8ce1057d0bab7433138943596e5b21bb84221e_Device=CPU_Config=() -281:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=9f7a30c4f90df2edf8e70468ac22f325bc97e99613fa6ee2aced93e71ea5896a_Device=CPU_Config=() -281:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9b64733aa0a8994cb3695a7c26f905f4d2b86c2e157edbd8a9970d33970a4015_Device=CPU_Config=() -281:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=() -281:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0df360e6d6391827cd65ceefd3201c263a829e50ed375522d4e8700f3879de09_Device=CPU_Config=() -281:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e61665bc5590265246ab882bb55b9487e81412012ed98ac9cb16154bc8eddd17_Device=CPU_Config=() -281:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=769e7bb56fd0d0fa75fed14765279f68841e300b1450909cdcc802d347446b52_Device=CPU_Config=() -280:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=22dc864b06ef0c7deb8aecd74a26c7bcf75eee316288284413fb61381d79425f_Device=CPU_Config=() -280:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=42afa027ada245d36900a89c54a870ba5fc7fe3cc3bc0fc7dbda23af3e5111d8_Device=CPU_Config=() -280:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ba15b8b85609531d91c7809eb90c3a0079d19d36b83c8767306cb276c9d67ace_Device=CPU_Config=() -280:conformance_ScatterUpdate/ReadIRTest.QueryModel/Op=ScatterUpdate.3_Type=i64_Shape=static_IR=b5f5ffd783aa251498c2011f19a63c1d68991e426384ef9728bc0b46587faa2f_Device=CPU_Config=() -280:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=() -280:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=8c5831a53b504e86ce404e5a521921ef86bf4e130e79819c1abdb0e88a6543c5_Device=CPU_Config=() -280:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=7744b2351d112ed761ebe0f43945f7dfd58fd2bfbd94bc5a4737549923caf4ed_Device=CPU_Config=() -280:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=ed75de35729f20a3285506937672f78d2d5137851a3043d15f4eafc040768fc8_Device=CPU_Config=() -280:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=() -280:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=() -280:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=dynamic_IR=5c05bbc013fc857a8f2b340df778f3ad5bdbc1b7273cf41b23d6da410205c612_Device=CPU_Config=() -280:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=1c6cbe8477d09b0b193ddf9a453c1b6a8a79e3d1adcdf1c096709cee7a4866db_Device=CPU_Config=() -280:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=3d5c8f5c1545419050f982e8555a6ef9e5dcc06545b1a8573d710e8bc2375a6b_Device=CPU_Config=() -280:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=b8e37f2c8e2574b3f3554578b72e9df771c290c1bb47238fc4de9754c6e6f126_Device=CPU_Config=() -280:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e8a26a33d6dbe0bb560820295fb6b8aafc3da0d2b78e29199d2f09e952722efe_Device=CPU_Config=() -280:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=c70693ee2f825a40f3e1fc8dd2ce9355690bc33ff27030f674d082a0cb343cc9_Device=CPU_Config=() -279:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3421ca968a9f4061cea0492ac3920fe1a29fb35093314cbb56a78bbb136d8fc7_Device=CPU_Config=() -279:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5d738cba54fcfd696b0cb7e808dd466b4510900ccba26c728b5eb272a55d6bab_Device=CPU_Config=() -279:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=3e669c3f90fc7b2209d3d588932f8eff3827309a5928f4b27722139964e2c46f_Device=CPU_Config=() -279:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=i32_Shape=static_IR=a142d6fb0ae0c0decec2ebeba376ed65852e1c60b1c1abee7bc574d5ef3a6a3e_Device=CPU_Config=() -279:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=() -279:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=4212a754718adff414309fb1da18c4361792b5478366bfdc0994490c7bc716e3_Device=CPU_Config=() -279:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=08cdbd5ea904a12dde32bce43e6c512aacd0ff990d5df3a90ff625226c936edd_Device=CPU_Config=() -279:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=d46d4fc3e7b3b2cea07f7ba710f77f7d99b4799e7fb0d3127ea6862f3f731ae9_Device=CPU_Config=() -279:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=899cf50d8feefa9c5e02f6fe88b79e66b59c4a53478755d51b3e82570683613b_Device=CPU_Config=() -279:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=46a3135a1078cd8732e84754fa66872648997791d16caa379a179e1a90960608_Device=CPU_Config=() -279:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=c0c33bc628fffda062b4f013c7d41d0f9080f14f41e084ac547099384a9b3d20_Device=CPU_Config=() -278:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ab760f0d90b0fef133a0555cb2a5d40fb525aef88e6568c5387a87d7e82f67f8_Device=CPU_Config=() -278:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=45d612bd5bc0895879f727cffcc13c978977a0aa10dfc726d00d6450faeff068_Device=CPU_Config=() -278:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=017d4b1dac18731e05634414942698ecbc750e306eb86e773ffe5007bfa9feee_Device=CPU_Config=() -278:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6bbd8d7f90e7c210514c28d527eb33bf0889b1fafbd5cf7d9660532f5d6bd940_Device=CPU_Config=() -278:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f5d63cfc40e19fff35078633a3354fe5e3a8b6dbadbc89e20747398d87e02176_Device=CPU_Config=() -278:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=6c1aeced5aaaecd99f3917a0f38e01902dbe81614ae4dc9a99fc09a379990abc_Device=CPU_Config=() -278:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=c3ef1d1e09e7c0917298070d6909b455d5962c4bf3adf8d2d4c04f0741141f1f_Device=CPU_Config=() -278:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=() -278:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=f097978a7f18dafc7577a9dcf2306d82d397faf1bedb106ca3de70b3d9ada557_Device=CPU_Config=() -278:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=704412b992d55bf9ff00d823458e5d3b3a369e47b3eca3429fed94b87c8da554_Device=CPU_Config=() -278:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=dynamic_IR=08776190d0fddfcb15ad75cdbf6892de03f79e89d57e02b7c3e80b4a7a125d35_Device=CPU_Config=() -278:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=3e893f54d0ed092823ca8e256e66c367f53e466f30573a7b5911a432d88299a2_Device=CPU_Config=() -278:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4a80814933ec1c6198745b1caa4d5b7c9171395b6d8a53cd791dcdf64fa6c91b_Device=CPU_Config=() -278:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=be59de0f93d8a22736d98d0aab618839905eb9a04f79c8d88d7ef08c7267f4ec_Device=CPU_Config=() -278:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f49b212b59261888a5ea4652f9a4cdfe25657c7a0e4d3b6ecc16255e8d2e8cd5_Device=CPU_Config=() -278:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=3e4364d93433ea741efe178b0c83cfb13c46259888aec468f59f77cd3f1bb39f_Device=CPU_Config=() -278:conformance/OpImplCheckTest.checkPluginImplementation/Function=Range_opset1_Device=CPU_Config=() -277:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6d705ecceb3a026a9be0b5963705b0c3c6be0123fb7d25885d3ae21213f1716b_Device=CPU_Config=() -277:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=259cf71b937e6d184948130afa5684d7539769988cee7a74b06138ad4d09c689_Device=CPU_Config=() -277:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=aa2c77112641e46dd617356a9cae765813b93353cd8a0f0508b915e0b03eede4_Device=CPU_Config=() -277:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1837f66989053233e19b617ab462b5c608981c0be175b57a2366fd41ca1a9fdb_Device=CPU_Config=() -277:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=707190f77491e910ce61476cd3a9d5dc275e7c5ad820cd3894a37c348c2995ff_Device=CPU_Config=() -277:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=() -277:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=i64_Shape=static_IR=75c36f65570966e7f975e5c839036e0e13fe30e6d24ce4be8e6a0e8449173951_Device=CPU_Config=() -277:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=1f7f2d40b938416773b13282d8ac09d81a50e4d5d7548f42fc5fd575f84e1385_Device=CPU_Config=() -277:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=95884fb8d74cae609a67146ef94a84eadda8f3bd6369a9cb465bc413264a1d0a_Device=CPU_Config=() -277:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=03ebf297344daffba82d04292a767fcd7c959f56788ede32ff0d7c5af06ea504_Device=CPU_Config=() -277:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=0add7fb1bf1500ea125aa6d245bad577d6dea18d038c020d18c2dcd56704c671_Device=CPU_Config=() -277:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=256f748d7b98b0eb70cc659403910bac929d62a2b153e63438f8746f602a83fa_Device=CPU_Config=() -277:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=c0c1a43608279d8870258be63005b38e23fe5501876c87840cc16a0bb2cf8dfe_Device=CPU_Config=() -276:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=ccef47523d9134720116dbd4a37d5038c9d15e2c393ccf1a6d24c3790529c282_Device=CPU_Config=() -276:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=aa2c77112641e46dd617356a9cae765813b93353cd8a0f0508b915e0b03eede4_Device=CPU_Config=() -276:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=01d609bdfca9f2a499a564f66ab9dd71b394310593d27b8739283b19980e2dc2_Device=CPU_Config=() -276:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=2f23f1158754aa494abbf61ab15118173a7ccfe90523b2b9ab7cc3a6fdaa0e37_Device=CPU_Config=() -276:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=ddacee38f2bf3dd45ddd36ba236440ae28b9737487e0fb186c2b9777c0b557e9_Device=CPU_Config=() -276:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=683b86794b415f893e4d426a8c68aa38f46c250e4c31bc5f5807a86c20ffb34b_Device=CPU_Config=() -276:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=() -276:conformance_NonZero/ReadIRTest.QueryModel/Op=NonZero.3_Type=i64_Shape=dynamic_IR=31f428e60ddfdb3cb3c98c2cc858d0409fd35c5e6e97f9dcdfbb20a876c475a6_Device=CPU_Config=() -276:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e0293184207036f6016f557f8df813c6536b18332f589245c5c606a3b36df1e4_Device=CPU_Config=() -276:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=2737751bcc195e4aaa63ab6d86d803741817287d78fc864e18a31c328078940d_Device=CPU_Config=() -276:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b91f26a0b7b56224c507de772631016119cd0bc3fd49527013f571e2db477402_Device=CPU_Config=() -276:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=50a0e83d438a3220ed14dd8ae783e92c96381f645b10719669054ea944297244_Device=CPU_Config=() -276:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=00709ceadeb9692263607310765b0957f34a8af1ebd17a13cc28d9587d360465_Device=CPU_Config=() -276:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=785551399ba4bb8eb76271bf698b3ca795b8388338f110843d5c78c03009625d_Device=CPU_Config=() -276:conformance/OpImplCheckTest.checkPluginImplementation/Function=Mish_opset4_Device=CPU_Config=() -275:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=93dee798d72e36c04cf60499e95f84cd6b63d84226d7dd1dc0edcf0875cf301f_Device=CPU_Config=() -275:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3147f462ceda9b383de633ac08d6014a7779e74b169d3745990fa2b2799b1dbd_Device=CPU_Config=() -275:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f7cf7cbc88dec99af8d35e65e926745ad318706c454b90740a19589285733fe9_Device=CPU_Config=() -275:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a29be1e2e5f78c12657221f33e5309470a7a4dbb9061a8100d7c454215198f7c_Device=CPU_Config=() -275:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=5f43b4d027388fff204c9c64df9f62bd2a72034143bd655e45121ca886c5d15a_Device=CPU_Config=() -275:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=bff490cc95cf384b15409e96ee7d0995aa91640e23409cda381b85b2fef69e01_Device=CPU_Config=() -275:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=5c5e10f28ed3a8d4ee0d3c8af982df5f383a4a1a713baba556dd17ee52e9ef32_Device=CPU_Config=() -275:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=1bde2f2a7294810531e23de80f25a451b3033487b5919c949b708b273dc3973c_Device=CPU_Config=() -275:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=56fb4fb30ec6fd9ddd0ff2e394434eb87546ac7de273f47b663252efa2a380be_Device=CPU_Config=() -275:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=() -275:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=c4e2668f98d5c21fc085695c9b6037f08a1e6710e1854fa73b7465a618e99b95_Device=CPU_Config=() -275:conformance_HSigmoid/ReadIRTest.QueryModel/Op=HSigmoid.5_Type=f32_Shape=static_IR=4a55e1cc1410675b7789f083f2cd3f6ff851f49c8a0818f5bf0dd27280b197f9_Device=CPU_Config=() -275:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b12c40f6d576482396a94e28e0814488b87eb6844583bc87384ed385d45bd6e0_Device=CPU_Config=() -275:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=57ba21d45369359487dc3b6a8feb0aa2b6fb21ffa328dc8e8eed58ee2896fdad_Device=CPU_Config=() -275:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=282e24ea7ef9130becb8db8f0251c907b02a534119d08162e07091212d67f290_Device=CPU_Config=() -275:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=a9fdcbd778622e442a42d8d2a1a12a1be0cf7e9d79c4d7ad56d5802c7a84d337_Device=CPU_Config=() -275:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=362638bf065f1917d2b4dac3008a8f46f8f8d64a80d2442c1ad98f4fb943cff9_Device=CPU_Config=() -275:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=941fa6fdaa34b8082171350da966423497232e44077f333cf3a46488bf237aeb_Device=CPU_Config=() -275:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sign_opset1_Device=CPU_Config=() -274:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6289210c93bab9199850c9aef5ac3144ad0a900007dbca3e889a9f875318e9b5_Device=CPU_Config=() -274:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=dynamic_IR=bc8918b82285bb58c2cf1b4b60b023262426de4044e0c2d50ae07f4b22ae0eb0_Device=CPU_Config=() -274:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=f2df871f255156043f03f34333d59d9213fd52ea24f69dda1b04888ed269acad_Device=CPU_Config=() -274:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=727e029d6373e823f7500e6bdfd1c07ba87fdb3ba428fd0a089885d7a1e91552_Device=CPU_Config=() -274:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6fefc3626ba6ef60433d3635bd5abeb3e7025277a86e2fd9d92234ff099c303e_Device=CPU_Config=() -274:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=67a5010efb429e6dedf35481443b40a77cb01c1b4fb51ec5890fcfcb010fd6f7_Device=CPU_Config=() -274:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=fbb85f74ecfa0ffc50b9e6ce637911b406f1fd6ad054a886b9c6ddc6bc898739_Device=CPU_Config=() -274:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=86cd07b4db06e4210732553cace1797b55c19f590e2d9b7814eb30485d8599ef_Device=CPU_Config=() -274:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i32_Shape=static_IR=22a8f509c3f76bc2dd6bc9a26ec4ab92a5b9ae4678532c886c1438669d627323_Device=CPU_Config=() -274:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=a29bdaa31edbcf7b3dc392625c0aa0a27e827e1363d52519858c93defbf9ebac_Device=CPU_Config=() -274:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=5fd7b424cb32653589798a45526ac4b3f3aafd29a58e5ed1cef16a958fd4a859_Device=CPU_Config=() -274:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=bf7feb979b2eab03afc780965804a3f6b8471b574c36125654fcaf3ebc2c30f5_Device=CPU_Config=() -274:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a46f51b7498c921515a53b67480ec4d413ed43ff809e1fa6a4deb7365f4a0460_Device=CPU_Config=() -274:conformance_Elu/ReadIRTest.Inference/Op=Elu.1_Type=f32_Shape=static_IR=1cb500b61fe11278cc50fca509be3e7b654190294dd581c7862ea3f108e0c192_Device=CPU_Config=() -274:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=346617ba1990b67ca1fec8ec219645b16aafa6c94a4a0f752c2f3633b85df679_Device=CPU_Config=() -274:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0df360e6d6391827cd65ceefd3201c263a829e50ed375522d4e8700f3879de09_Device=CPU_Config=() -274:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReadValue_opset6_Device=CPU_Config=() -274:conformance/OpImplCheckTest.checkPluginImplementation/Function=LRN_opset1_Device=CPU_Config=() -273:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=104a69286d09ab8a5a88403ce6b421979659231fe5c5f973393216607a995dcf_Device=CPU_Config=() -273:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=7d73fec5a605ca6fc06cb014fb723236fd2ddfa1820648acb7fdae8530866f45_Device=CPU_Config=() -273:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=u8_Shape=dynamic_IR=b12ccd794c23494b994608015d049eec0f2ca30dc319bd35c1adddb3e4b8e631_Device=CPU_Config=() -273:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=d4e6cfc9844e29087dc5bb222a1822c26ec71f2e751575790add7c9b98a5a23f_Device=CPU_Config=() -273:conformance_ReduceMin/ReadIRTest.Inference/Op=ReduceMin.1_Type=i32_Shape=static_IR=a2b9f0b4c044e23f536d137b6e157d1357df657d1af119cb8f71294d7dc098cd_Device=CPU_Config=() -273:conformance_Equal/ReadIRTest.Inference/Op=Equal.1_Type=boolean_Shape=static_IR=857447d7e14c7516667094409cf5ef351000344fe170570671be0f71834d04f9_Device=CPU_Config=() -273:conformance_Equal/ReadIRTest.ImportExport/Op=Equal.1_Type=boolean_Shape=dynamic_IR=0723b6d683bc65225624112929bd8f7a0adde9e9c2265a2ec1a54b10c4433735_Device=CPU_Config=() -273:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=d34bccebe88a4093c9810d56088e4bf07b55bdab1801d7d830360aea1be22499_Device=CPU_Config=() -273:conformance_BatchNormInference/ReadIRTest.QueryModel/Op=BatchNormInference.5_Type=f32_Shape=static_IR=8f1629e9b003409304f12c3e315e8ae8246b3bc80208c3f612d5c5c179082a7b_Device=CPU_Config=() -273:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=a3e2f08143425d4c6ed46ee301de31c5942694f79af0d297e4d1801e9a6a0ff8_Device=CPU_Config=() -273:conformance/OpImplCheckTest.checkPluginImplementation/Function=Result_opset1_Device=CPU_Config=() -273:conformance/OpImplCheckTest.checkPluginImplementation/Function=Elu_opset1_Device=CPU_Config=() -273:conformance/OpImplCheckTest.checkPluginImplementation/Function=DeformableConvolution_opset1_Device=CPU_Config=() -272:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=bbe05f014b2e4602f4e44d9c07795321404d2459bf782d2dd406de14bd2bd523_Device=CPU_Config=() -272:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bee11d430236dcbd0fb5efbae712d8d89d84beeb89e0ee60e0ba3ba9512079f8_Device=CPU_Config=() -272:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e4b374c3afdeb45605c3ac745c03fc9eb938cf3f3828c119917ca92a6e9135f0_Device=CPU_Config=() -272:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=8952b1ce6fc7bfd900e669e12b520b624c02026b458bae41afe28e1f76058315_Device=CPU_Config=() -272:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=b94d2ed6a2b113922805a69578ec5ba2ba3d8f0ea46ca37f095b4ccc94d76b77_Device=CPU_Config=() -272:conformance_ROIPooling/ReadIRTest.QueryModel/Op=ROIPooling.2_Type=f32_Shape=static_IR=556c6863ca3b12d255c4c81d92b4573203f02c5588e064fb22dd4aa23c8283c6_Device=CPU_Config=() -272:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=fbdf008803736374dd213f1d7e0a041fc0e9b3f025c212a588fa05842ee5ee56_Device=CPU_Config=() -272:conformance_NormalizeL2/ReadIRTest.Inference/Op=NormalizeL2.1_Type=f32_Shape=static_IR=e177da00e93cb595c18d142e92898135415f0de01a3b1ea763f3ffef3d7ce96b_Device=CPU_Config=() -272:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f69e74dc680137ec5ef0b63e38d451da7bf1b61d2acabab77df46b76c9777402_Device=CPU_Config=() -272:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=f13dcb47235a9516298088a0c45ff56fdb7f95144da257a3dfa1c618c7373ce9_Device=CPU_Config=() -272:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0da39d97a2f46fcbdf524727d0283243d3bf0c3fab75f76f529b6480c84f67c1_Device=CPU_Config=() -272:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=03e7b025285b1369ca39bcf887783a843fe06ea29f7f394efc8201d1b7ad3a09_Device=CPU_Config=() -272:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=d5cd3fb647dd4a57feb28366d922a151a3ffb1707864f2ac85595fcc30f222be_Device=CPU_Config=() -272:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=e2d1f4fde3dc1889d4f86004173ea34a9d9836f645730727f5cdf90bc0738361_Device=CPU_Config=() -271:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=af1f864a9f4bc94bdb713b0fed3f4c39dbd290cf7464f3cee8f1aded11981d4d_Device=CPU_Config=() -271:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=f0ae8e6b136d1db7e5e7748c03eeaed6907460d3d3941fcb1a6651cff61be113_Device=CPU_Config=() -271:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=98932a2171e1c93b2bec3991892faaac027e1c319e91b9008ef0d0f469bcb0e7_Device=CPU_Config=() -271:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=() -271:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=e9539332df9388555564db1da36679acc7b505b8c1fa687731f2052999bfe1fd_Device=CPU_Config=() -271:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=9031b1919c35a9df591ff64fbe4748c02cc837649899099542716f35b5c68cc5_Device=CPU_Config=() -271:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=8b759b2f1999be207aeb39763bde3eba4aee028e9369a86a87493ff86f3fa014_Device=CPU_Config=() -271:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=2233a83397f11ea3c674c4845409c4f27f8bffbb8d0295712a2525c9e93d6041_Device=CPU_Config=() -271:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=b94b5361ee75b3684455c2b871b656a50c72e325564787c302a714f222845b26_Device=CPU_Config=() -271:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=d04bc06efa76ef2937aa1539893ec9c79ac61c765cb50cd4a26dbf5586bfc904_Device=CPU_Config=() -271:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=7cfae687d408da17a0405d88f47e2b6623a608861114dc76018b8a2142453139_Device=CPU_Config=() -271:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=933c6450f6856b32e879034662cf60eca53970c10106f8a11eb925e5621042e9_Device=CPU_Config=() -271:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=static_IR=8834a8881c2da907f6ae38d4c45100dde754e653f3e4994cf9add141c217c781_Device=CPU_Config=() -271:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=c307ba8fc5f5d81037e40e46cb8ce1057d0bab7433138943596e5b21bb84221e_Device=CPU_Config=() -271:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=28dbc474828462a812108c43a47aa4e70fa0d2e8e814bef5916092f3e8c7a2fd_Device=CPU_Config=() -271:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=() -271:conformance_LSTMSequence/ReadIRTest.QueryModel/Op=LSTMSequence.5_Type=f32_Shape=static_IR=b8e32896d2ab304fb4fdca3924e0110852da92be25307f30709cd7d897c2f038_Device=CPU_Config=() -271:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=29c89ebfa45163b40be304d7bfc96f3068cd96175db94e6ebda942d3c4af538f_Device=CPU_Config=() -271:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=3d24c272ca88d4ee24f437a310abc05340e110f8596beb6a1ef96dd18818ebbe_Device=CPU_Config=() -271:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=556de70b55386fc9a264a24a9000d075a07636de6461cc5f4cd41af639b0597e_Device=CPU_Config=() -271:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=4520f02da2bc674bf781c84ea3cca92375a1eeaa77f4f4f7e4cfc3ef75fb2964_Device=CPU_Config=() -271:conformance/OpImplCheckTest.checkPluginImplementation/Function=Parameter_opset1_Device=CPU_Config=() -271:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogSoftmax_opset5_Device=CPU_Config=() -271:conformance/OpImplCheckTest.checkPluginImplementation/Function=DeformableConvolution_opset8_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=80bc3dff7b0901463ccc52bd8e4a8e7522b1e9768421de45e63bdf8db601b9d6_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7b904365e0652437dcb59aef3b84da17f4205a821586224e41db1409d96e910b_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f8408a1d4e8c11ebbda01e0431217a5ff4ac6a869cc4cd3208cc9adc59d227fa_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a9c40d7a1ada834400ffbdff779b9970c83bd576891dfa7f637182cadf9e9681_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=243d5b44a22822e90c2f6b7c2817f8110bd6a060331e686c1fde1869f3392db1_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=15197edec77da431c491f42f64e86a811d89a337bf44615824226425b1c64d28_Device=CPU_Config=() -270:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ca72f78cc4db6d46ce969f61c5bf707507ed8204785159e1ac5130e7aa251858_Device=CPU_Config=() -270:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=83b83dd13b1733a50ec728ca6e7f09eb75641a573178816d1d33f30390464d87_Device=CPU_Config=() -270:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=0d413b2d40036984ce2b85933c4b5ffda416e8779a20b602095d2654db296d58_Device=CPU_Config=() -270:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=6d5907929d59d1f99e85183238e29d6602c84721d099284dcb8900ae5fc3c45f_Device=CPU_Config=() -270:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=9bb8728e6e9f68cf68a9e39d1aa4c618c4aca4187d4262f735c0647d680c0506_Device=CPU_Config=() -270:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i64_Shape=static_IR=f9377788ac0fd1ad0a7f51d16543722cb5acb69640745df17d9f41f5d1d0b544_Device=CPU_Config=() -270:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=927c151867c504f57aea681772afe32ec9c67cdaa4a0dcbc9055a8725c0296dd_Device=CPU_Config=() -270:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=i32_Shape=static_IR=201b881bba09ed67334d9489a1a8971e483120bd1cc75a1aa1c9f015f760e002_Device=CPU_Config=() -270:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=41bcf70f8013164bdfeb7e348c05e6d43d9a1afc49087c49745679bc3aaf1e10_Device=CPU_Config=() -270:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=486675b6412030beffb4209c326672af07d343d5e1bbca31b9bfeed3cc339e3d_Device=CPU_Config=() -270:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=3f0c39b97aeab67748bd4039950e926a9d9f33b6d3261c4d65d048500adb5b7f_Device=CPU_Config=() -270:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=4520f02da2bc674bf781c84ea3cca92375a1eeaa77f4f4f7e4cfc3ef75fb2964_Device=CPU_Config=() -270:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMCell_opset1_Device=CPU_Config=() -269:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=57b104f3a1796c31d59d676d9f6d65789ed72fb21beb382bf418c452b8452d27_Device=CPU_Config=() -269:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i32_Shape=static_IR=5224ffd078708e8917b14b4118bc4a42317c123dc0a5dca8234ad73d44daf845_Device=CPU_Config=() -269:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=dda9a81656cbcb4ab5484fea52e7172baf67d46babce886726c96eaa1980766d_Device=CPU_Config=() -269:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=e1ea320702cf8065ce85c325507a199b95dc9ffce3fa715b4d8195ca67a5a374_Device=CPU_Config=() -269:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=b6984001a616b3dd3ef4b835b2dc6a48bcaf8882bfde7761b4e141733364f66a_Device=CPU_Config=() -269:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=c39d76c89bb03fe251dfffdd9b8eb85c0585904ed9c5bb4660c3dedfdc451efb_Device=CPU_Config=() -269:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=282e24ea7ef9130becb8db8f0251c907b02a534119d08162e07091212d67f290_Device=CPU_Config=() -269:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=5980eb1b6c7a44c7812f89f10f0741e5925abda9ad07e1a82ae2a3310abae74a_Device=CPU_Config=() -269:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=b5a1e5c47a0597ee9c9d0c0aca9909c596cbe71ebb069254460c2e97acfc1c0c_Device=CPU_Config=() -269:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=3e016da7faeea7044ea204d1c3a2f1729d3d7ef0be27f5b769484bc7aebea5ab_Device=CPU_Config=() -269:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=a7f6c704686f1b0e6fd4ab522930aa3fb5b4cd4683b204aa31e5c73b427e7058_Device=CPU_Config=() -269:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=2c2cec03b3ec1da29ad4d5fbb3530ee7343a436e27be923ee1f9dd97d29731a3_Device=CPU_Config=() -269:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gather_opset1_Device=CPU_Config=() -268:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f208ab78a0ef0497856952f499578a17818269d066f4281183ef92ac2f9ce449_Device=CPU_Config=() -268:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=41c1e13447cce632ccd478ec2bf36f09e510942449b0bffd3271f3b1f0b48d54_Device=CPU_Config=() -268:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=0f3e035b6571da159267ff1f89b5f2b2d3bbd599760dc5d5721a1fb2ab2ea75d_Device=CPU_Config=() -268:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=static_IR=7798cef9c8734d0908103b3c42fd7fc791806ad61d35dc680dc43d9597c6f1fb_Device=CPU_Config=() -268:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=dcd71a51a6682c9bc461a6cb72d59082352ab8a020e1f79e64c3cc44a37b55ba_Device=CPU_Config=() -268:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=697bdfc59094203ea1616203d64759a40193f1a23a4a51f11340a7912e355cd1_Device=CPU_Config=() -268:conformance_ReverseSequence/ReadIRTest.Inference/Op=ReverseSequence.1_Type=f32_Shape=static_IR=1ff07d9b87513cab5bbcf5059507b8c998fdb25d2802b267bb6c0b90eb3e231d_Device=CPU_Config=() -268:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=725aaeceedd7eba9be6ba4203e31cead733ed80dbafc33e902465d4338dc8f4c_Device=CPU_Config=() -268:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=99820651f05bae979a287a8644f1b739637d684efad288b48044c2a664e43a3f_Device=CPU_Config=() -268:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0e78ae14fcef33de9637ac99e87f672b3247ea32c221a4b555b2e5bbdff88788_Device=CPU_Config=() -268:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=eabe482de99e120ef1260cc91a746df95f8db04fa1cf6832dc45b3ee1b38f9c5_Device=CPU_Config=() -268:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i64_Shape=static_IR=7147d6ead151efc24a53c196b63fc441e240c34b41ad2226a535580eb2a3f3d2_Device=CPU_Config=() -267:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e2734d3e803c031e2fd56d0c9f7a72818227bc7981d9f7d9d1148f1cf07135fa_Device=CPU_Config=() -267:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=28bb0064e4cb56c497227ec69899b08dc09cccbf7d390555416aff617a393f81_Device=CPU_Config=() -267:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=564cd54b2564c7e39fda0c5e580c274b7bf99603760f6c66f03b4450f23cc4bf_Device=CPU_Config=() -267:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=static_IR=8c82cead166c3db4616f034b66c4795cb4bed653de41d2b6dc71b48ce76a296e_Device=CPU_Config=() -267:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.3_Type=f32_Shape=dynamic_IR=fb3cc70d8993f96508516aa7a36cdcb9973edd563c78a7d6d5ac5ca9f816e3fd_Device=CPU_Config=() -267:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=36783f31e83ed0f978f00a1cdd87a25b4b881c251fe059e5d2829be3d0b45c5c_Device=CPU_Config=() -267:conformance_ShuffleChannels/ReadIRTest.QueryModel/Op=ShuffleChannels.1_Type=f32_Shape=static_IR=46e851dee1f7bead1a6e2459157df33266c45559375a1caff90a2732cacaf881_Device=CPU_Config=() -267:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=223a34e46344a0dff7f35a637c9bd08e2a76a552ca87e5bf0134c9fc6d6be41d_Device=CPU_Config=() -267:conformance_ReduceMax/ReadIRTest.ImportExport/Op=ReduceMax.1_Type=f32_Shape=static_IR=a3b350b1516cb0391e088317ea67433757a08847710c4a4bff143922873208df_Device=CPU_Config=() -267:conformance_Less/ReadIRTest.Inference/Op=Less.1_Type=boolean_Shape=static_IR=953b15e350d9a27c4d048cbae41a278c732f3b3a6e8debd7fd2e75e99a015966_Device=CPU_Config=() -267:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=57921f181e48af2b294b923633e457650e5ab2a9ac7f5d4d07930974ad5e03e1_Device=CPU_Config=() -267:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=() -267:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=2538d525d8f11b9f4961c2a4a8cc36fd27d8b3d97271ef7db4f7eac9732b71f4_Device=CPU_Config=() -267:conformance_Gelu/ReadIRTest.ImportExport/Op=Gelu.7_Type=f32_Shape=static_IR=4ee688aa25b818f6e6986c7070e544d0eef9ce888124d85c0e5e126802213a46_Device=CPU_Config=() -267:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=c98e1e2347c7b6939804dfcfcebbbd57d4c05e8d13b35b2611912290d06107ff_Device=CPU_Config=() -267:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0d782801290370c7c390ad549171ec3500ab344b8b34ce4b8fd8b05339fe5557_Device=CPU_Config=() -267:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=fe80b80ced0033aef6f7f97abd22de1271430f700d7dc9aad9a2a819f91e11a5_Device=CPU_Config=() -266:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ef702f626a20bec33a58f2596e4e6e15f105860ebfff1d6f42116a514d853c4a_Device=CPU_Config=() -266:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=22dc864b06ef0c7deb8aecd74a26c7bcf75eee316288284413fb61381d79425f_Device=CPU_Config=() -266:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=i32_Shape=static_IR=75f0349e33d0151c276e3f5ce34f7c1a71f5572331157b2e34f889773d7d8754_Device=CPU_Config=() -266:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=4d10da0860e049587221c12f55c3bca9fc587b74dd3fec194c8ba5854a736d93_Device=CPU_Config=() -266:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=64186bbc89d54f073554e029b8972fbbfba2abce8026a379b7ac3833f84ac9d4_Device=CPU_Config=() -266:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=static_IR=2055c46f29a25953e331656839e227b0472b10695ea23410b64428d14232345a_Device=CPU_Config=() -266:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=8ea778d7d98fd08efe4b2efa501ef3599df00ca9bd036980ce86e0d6dc454b96_Device=CPU_Config=() -266:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=a5a2ba7fff85401feb05248462e85d334440769790e7e6ba1a75ffb413f7fc64_Device=CPU_Config=() -266:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=78239cbf0f8d473af2209ad3d9297e02208c110efa7af981f8c09ea7d7290032_Device=CPU_Config=() -266:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=eeeaf32688af20dbc39dd3705dc09fc804c0636d4d5807b003c002eaab1e79dd_Device=CPU_Config=() -266:conformance_Gelu/ReadIRTest.Inference/Op=Gelu.7_Type=f32_Shape=static_IR=4ee688aa25b818f6e6986c7070e544d0eef9ce888124d85c0e5e126802213a46_Device=CPU_Config=() -266:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=57d49137431cc7fe4364cc2fef13111fb9f7a5a908b2d7b6f5663100ba5d636c_Device=CPU_Config=() -266:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=dynamic_IR=c3d754fe46cacaaf519f39fdc6feb9df6b23d92f6271f6e731c2a8ddc24a948e_Device=CPU_Config=() -266:conformance/OpImplCheckTest.checkPluginImplementation/Function=Acosh_opset4_Device=CPU_Config=() -265:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=05690f7225eecae70805d45641cd02c02c46bc61f9fa4cf91d3ec7ce94f6fd3f_Device=CPU_Config=() -265:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=deec30214c79ceb43a503bf521937a2bd554588775195d0e6302c521cd2b55ab_Device=CPU_Config=() -265:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b01e9e819c2e610a4fdedcb693f536f99b9dbdeccfcf9b0e70dc37c19c365421_Device=CPU_Config=() -265:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d0bade0811581a6fae53c343866f1bdb63acfe07776fd60b7e791f8edd3f88b2_Device=CPU_Config=() -265:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=41d80c815a196293f7d22af59f5f602f7e4f11e06208a693b19743fb796b98a8_Device=CPU_Config=() -265:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=9f4d316675c933ea5d6511324e3d664440a8ba287cb2ffe768517f9cbfb613e7_Device=CPU_Config=() -265:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=461bf15d226b7ee3cbdcbc8cf1806e98267c5f14f0aef49dfb9de094f56347b7_Device=CPU_Config=() -265:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=109afa0426a29179db58e16917b829096af105f0def2375a589ea1391138ee2f_Device=CPU_Config=() -265:conformance_Minimum/ReadIRTest.ImportExport/Op=Minimum.1_Type=f32_Shape=static_IR=206184d6fe0a3ab9fe71914c66d3804e145caed7cf3ac09cb1d50183144d6ac7_Device=CPU_Config=() -265:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=7244cd4799e0eab987f823edc7d6038b76afa7585e4663278be826124c5596ed_Device=CPU_Config=() -265:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=6b69e46c11a2a82ac7ad6697cd768d88da6e870e75f489779bbd1714bad23450_Device=CPU_Config=() -265:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=5e7e2adae49fae3a376e9a5a971513a9b23b5fe4008ce51814e0fa1fd91f1f22_Device=CPU_Config=() -265:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=941fa6fdaa34b8082171350da966423497232e44077f333cf3a46488bf237aeb_Device=CPU_Config=() -265:conformance/OpImplCheckTest.checkPluginImplementation/Function=SoftSign_opset9_Device=CPU_Config=() -264:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=42062545b0991e415aad8d29d47de2a278e5791996ea55974411694aa821b54c_Device=CPU_Config=() -264:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=14c8a8bb712c40d63edf76de9a75dd1dcd53a2df8c6098c80ee760119966f364_Device=CPU_Config=() -264:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f89e84d6fb931cf0cd074acd01a50e50daa47ad88b1b74e4b3671d63bd7889f2_Device=CPU_Config=() -264:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=db87efd37ce8dcbe14286197df3b7a345fdc46ccc03d7d8bda17e3791df332aa_Device=CPU_Config=() -264:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=f32_Shape=static_IR=f5807b455d9031305e8225f2b65fd5cc289f61785d762f19a275280085a2e5e8_Device=CPU_Config=() -264:conformance_Sin/ReadIRTest.ImportExport/Op=Sin.1_Type=f32_Shape=static_IR=54a909996c38d86ec830295e37f0fc0070260101390dbaae2cc6eaabea82a7b5_Device=CPU_Config=() -264:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=bff490cc95cf384b15409e96ee7d0995aa91640e23409cda381b85b2fef69e01_Device=CPU_Config=() -264:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=() -264:conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=() -264:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=139cc84777f1e0d489245d058877303e72a93eba3cffbf5f919de21b4514bb0d_Device=CPU_Config=() -264:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=74f34c8b7abfe0f7afe021ba5d4861e29f9f3915beba5cdb2af936f1f2409fb6_Device=CPU_Config=() -264:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d12581f68d14d140f4b982b47b97000f6b666cd115483247d369fed87267556e_Device=CPU_Config=() -264:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=dynamic_IR=8029d5dae7f4721807eb717310512bad44630efdd0a64962496a0fd802a12325_Device=CPU_Config=() -264:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=33297e2649e2f0c53b0bfb5e349d83ede580471764202480855e3f1efc8017a5_Device=CPU_Config=() -264:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=33199e062b7b59c8244477fd2682a08876e72126701842265efc0c9fb4a90c94_Device=CPU_Config=() -264:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=29eeefa6ea54ff2530e2e17153db324026e85d4e45432c053ca066699187bbc5_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=65493d18baa6530c757031b74c5fbd51757e2b04bb79149d3acbf6c40bac11c1_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=ade98724a678a73bf789fc539dfa277031242ea3a694227dae29c11b45cdfb9e_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b706dc1dbca4cc6c308f2cadf799fec41a8b3f08251de3a58444f0d760994cbb_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=348254d0e2b145f9e5443b4d4470b2ab29487acbb34a71285a5c0e1bd29cb942_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2f96ff03126561aa475067ad88e454b2da78fc8f0b816dc6c01ec5c81568288d_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=cb7ad9dd22a7bccd73ade4d4aa78f9a25cc2bb7f0c08a01064491200089b3718_Device=CPU_Config=() -263:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ad640e033c11cf7d81ab237630f0ba656968f620eb4ed77f38cd79c6cbac42f6_Device=CPU_Config=() -263:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=2b02493e0e09536d01441e885df61f27f2202a3e16742695bcc4d1d0d892c56d_Device=CPU_Config=() -263:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=c55846f7a08af86fb1c914c925433852fd4bc735f671c87e965a6db9b6971708_Device=CPU_Config=() -263:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=7df296e0e156bb36cb643a292802f9db374c77035c6a05ee4a865fbe2c6ef92b_Device=CPU_Config=() -263:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=a7b7ec75e1b343acfa06ea53d7d5b631c06d44c68b1fc92555d7168c77aeadb3_Device=CPU_Config=() -263:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=() -263:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=dynamic_IR=e306da3fedc4369302fb21159f2bbbe65849661eabe5bb83efdad3e83f64fd68_Device=CPU_Config=() -263:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=09dd33f661a07095dc47e3e5205c9fc6dceda72526e79be0751c34823c7e7cf1_Device=CPU_Config=() -262:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=e6aef819fecf54f7c98b15f330074d33ea0ca6c8fc3edd895b362f04449b12a7_Device=CPU_Config=() -262:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=d5f5f2d39bfe4ccc6f12f76e5eca8e2e40ac7ac6c5f38a7cac21970df213d4cc_Device=CPU_Config=() -262:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=7e386c35d9d397e043876a23a2b9e5885964cee59bf46f1ae0660e6a84641ea4_Device=CPU_Config=() -262:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=5d791fd5b82a74a42073567349728035c4ac52ea64c1a154a73bd4e61d1b42dd_Device=CPU_Config=() -262:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=debf36fea706c02dc67354edf761f0dc931ebcccbed285f186164fc4b9532766_Device=CPU_Config=() -262:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=4892263cb1ea7a434b5771aa16f07885c39710f67fa1411dd9235653a6b8622c_Device=CPU_Config=() -262:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=dbabd4c2992053ca70e9d6a489b437cf8d1f13807220adb5054204e9bede00e1_Device=CPU_Config=() -262:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=() -262:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=3801fd5b86bf772977c131734d8356c8dfa41b9056091937473be600e332fbee_Device=CPU_Config=() -262:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=62b8aaf25e8c93387362b0c657886c31c39a7330cf3455486b8943a1e375ef5c_Device=CPU_Config=() -262:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=() -262:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a4e797de860d6e4dcec00062050168ba9745d3da953b9c644de654f4d2818b77_Device=CPU_Config=() -262:conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() -262:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=b38f11a07d752c83a5e4fc709d5b78fe9a40ef3394f4b617a30df29c21640338_Device=CPU_Config=() -262:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i32_Shape=static_IR=a3f2389f6a8a495885efa87742d53e1e154f58f8fd6e83df89bddf5922247095_Device=CPU_Config=() -261:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e27f0bcb3118a7cdb488f4685707bec982ae54ff8bf7e97aff9ea6ecedd66714_Device=CPU_Config=() -261:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fd97b6aab7b86b0dd2f8c0ce622601e80f3b864d23d7d4f61d2dfa42195936b1_Device=CPU_Config=() -261:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=3c0b9fab07568e0eebb5e5d068cfccdd617ee6e98e4253a0461ea8d3f0f582e8_Device=CPU_Config=() -261:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=8fc5ce53f1f6b924371ab2cf156ddbf7aea234b17befdcb6206ba51a7ad988c9_Device=CPU_Config=() -261:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=745c0804609863998b4bcc6956b1e78fc221e0e4f1535ab09b89a9c966a16995_Device=CPU_Config=() -261:conformance_SpaceToDepth/ReadIRTest.Inference/Op=SpaceToDepth.1_Type=f32_Shape=static_IR=9296c80cc93d8ab7448140ad2f31b3b47a0759c383d1bc045704985503732195_Device=CPU_Config=() -261:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=7fb9c2cdb4c82a4b65d110fc84c03948917cc1921c372cc645cab00a3377fad8_Device=CPU_Config=() -261:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=70d4da84623a0af3bc8362a828bac5ef13285498b420a3df6bf2e88bf05311db_Device=CPU_Config=() -261:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=8de81b7de05bdd151427e1b5b03a8b4222284dafd31f9d4b1c3d0917995e9310_Device=CPU_Config=() -261:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=96117baf3ff208c696a9796404eec467b613c37977067ff0cc62e39355856d30_Device=CPU_Config=() -261:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=e1a894c49294c6930cb8f8c857ec745fa2c6d18cc3607389c89af4d13df4e411_Device=CPU_Config=() -261:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=dynamic_IR=6a0218ea2e7eb0329e4915f2f6a7c215742d2469e868a4a8e43c683c2dddc01d_Device=CPU_Config=() -261:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=c7998d9fa7e16dedd52f8cbe3d0814f2f3b30ee6d728881d64c4743e0ff6fae0_Device=CPU_Config=() -261:conformance/OpImplCheckTest.checkPluginImplementation/Function=BatchToSpace_opset2_Device=CPU_Config=() -260:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=557b6184296452c25e420a307a2021cfb0eedcb73e42bb4bc247c34c15b18447_Device=CPU_Config=() -260:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=30eb0edc699f72085fb77a6cc31ad4aa9e62cf97befb64273493d234494fc64c_Device=CPU_Config=() -260:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a110c620d27325938e9febcd9d757a5525c421bc29450fea960403fbca3507f4_Device=CPU_Config=() -260:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=i32_Shape=static_IR=75f0349e33d0151c276e3f5ce34f7c1a71f5572331157b2e34f889773d7d8754_Device=CPU_Config=() -260:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=81313f6065af987d98f37a1709f149d804bc1a36bb0a5c4a11223b29c6ccc3d2_Device=CPU_Config=() -260:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=7e88dcf638caa6058b01dd6c31ba40efb0fca8077cc295ca63c2ebe4c7298926_Device=CPU_Config=() -260:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=6b0b123bc93e799aed7bee84e55ed9def25af4f11d27958d8368983eee9c527b_Device=CPU_Config=() -260:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=69f4c39c3fb2dfc55714893e1e45761238e74bf28ecfadbee3f4965b5a379888_Device=CPU_Config=() -260:conformance_Relu/ReadIRTest.ImportExport/Op=Relu.1_Type=f32_Shape=static_IR=03c3e6567da3c139c19e0ce0d301a6076b2e2446d191216c7bf38bc030ea7855_Device=CPU_Config=() -260:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=() -260:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=5a1aa66136ca2be83f714067139e11fcbf672d73f8b28c57d29333b885a17f83_Device=CPU_Config=() -260:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=de46537615051a46fea66871c5fc6ef3417b577ce42bd1f7e239d821e1ed5c51_Device=CPU_Config=() -260:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=f26c1f41ef689dde33e9d61b0a1066788b8397ba6a170f5eb1362726ba9c0868_Device=CPU_Config=() -260:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=eeed611756b048927c290a65dd92a5833ad66d347bbc772abddaa751f2016ff1_Device=CPU_Config=() -260:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=u64_Shape=dynamic_IR=5f87db7fc306440f807b413acb7eb175932f29f59d1b5eb4a9df8945b9aef9d4_Device=CPU_Config=() -260:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=269ec3789c76e21789e01e31f13f0f1a4895905b3f131e710e663ed2a0d8f632_Device=CPU_Config=() -260:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=3f0c39b97aeab67748bd4039950e926a9d9f33b6d3261c4d65d048500adb5b7f_Device=CPU_Config=() -260:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=dabed23c3f30d92c6fcca7a6845160022837de8cbfa1077c222e6f1224b745e1_Device=CPU_Config=() -259:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=eb98c3593d72ffaa01de42caf4832854d9486b4148c57742c6dd72a251f8cb45_Device=CPU_Config=() -259:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=static_IR=bcb10a9124f9b0471012f9e22d4aed5c2a47a55e652312e8a8382dc0d809a23e_Device=CPU_Config=() -259:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=d7fbbe9f8f446b009ea2de8594e4cfaad46432734cba27596e3fa721f04c04ee_Device=CPU_Config=() -259:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=d6250086b712a16042ee74438bb61b89fbfaa5bae433049207402d1da4cffaef_Device=CPU_Config=() -259:conformance_NormalizeL2/ReadIRTest.QueryModel/Op=NormalizeL2.1_Type=f32_Shape=static_IR=e177da00e93cb595c18d142e92898135415f0de01a3b1ea763f3ffef3d7ce96b_Device=CPU_Config=() -259:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=ee49657e646466b0c22aff01740a48c1cc271a828a8c3e10a21d75b04f511cb1_Device=CPU_Config=() -259:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=i32_Shape=static_IR=201b881bba09ed67334d9489a1a8971e483120bd1cc75a1aa1c9f015f760e002_Device=CPU_Config=() -259:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=d575b00d2b6e155319fe7120133d8e0c3dcb5c79bda710b0650fa48543dc5c84_Device=CPU_Config=() -259:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=165dc8f683138c4d731ee850aa6212a70851b91630cc42e2b4e9d46e0ab15b57_Device=CPU_Config=() -259:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=e0422b2fb57587a85d9ce1532f7fc28a6bd01e72a325d42d9045419dda4bbba5_Device=CPU_Config=() -259:conformance_Erf/ReadIRTest.Inference/Op=Erf.1_Type=f32_Shape=static_IR=2e5aed1612da0f720adb051e22460983a3911c38cb09184d812ceb949870f450_Device=CPU_Config=() -259:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=1988b645a87be14c17740085aa8c4a38e88cd2111f0ba294f77ed0bf856b0561_Device=CPU_Config=() -259:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=3c1c8bc7ce009c03509ca9d6a86f3d5cff89be49439e7513edcde4e62fbfb8ce_Device=CPU_Config=() -259:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=64bd2f48b3326db083653b5993c9a75d21be515cbc5af67c62c981e9744e2f0b_Device=CPU_Config=() -258:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=59d132b45e2ac60a670eb43efafa43f065bb43d492208ac670fc8234b4f618c9_Device=CPU_Config=() -258:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=952ad9af4561d61157cc5e73bbc5608bf8cbea1473c52a566ad1ae7252bcb35f_Device=CPU_Config=() -258:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0dafd9117cb3fba3a335f7cd28aaa3fbd9276878383657b357210e135a93d916_Device=CPU_Config=() -258:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d1b4dff28b71e41d8106d3730f2705e537487aafe0dd53ae7dfba9ec21724287_Device=CPU_Config=() -258:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=u8_Shape=dynamic_IR=4d2c49ebbc46b60233510b63e280442319496782da33185f7c2d6003611f937e_Device=CPU_Config=() -258:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=static_IR=2055c46f29a25953e331656839e227b0472b10695ea23410b64428d14232345a_Device=CPU_Config=() -258:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=4e14d87b7667a7900d4427ec46c72eb3c7bfd2e3d86e5bdf92eb2485059b4951_Device=CPU_Config=() -258:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=static_IR=5fd7b424cb32653589798a45526ac4b3f3aafd29a58e5ed1cef16a958fd4a859_Device=CPU_Config=() -258:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=a6f5b58b1d85e5a99389748ae14e507302127e583c436dd9e6015d3c33ab0536_Device=CPU_Config=() -257:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c90ac17f02f16c647a0a206326f24ac348a0f8a7787037486e52ecc8c091818e_Device=CPU_Config=() -257:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=945bd465761a4d9b013b0a5e88a3a9e041d8bd8bfa8df8044f28d71ba26f224b_Device=CPU_Config=() -257:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fd97b6aab7b86b0dd2f8c0ce622601e80f3b864d23d7d4f61d2dfa42195936b1_Device=CPU_Config=() -257:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=4479acfb061c41832bd1f2ff0de0141dde3a3c496ee4471523fac0a37451311d_Device=CPU_Config=() -257:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=69c87ccfa0080f65ed28b9a088343db5ceef524ae917b8e259b1865a017df22f_Device=CPU_Config=() -257:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=525ed9b2af76610bf0ee3d11cb1dcfd46059335968359c143d0da7465736ac2e_Device=CPU_Config=() -257:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=cedd3bc0f0a8e20fe947135bd6ab9515283275867e1b837d36f2fac72363f449_Device=CPU_Config=() -257:conformance_NotEqual/ReadIRTest.Inference/Op=NotEqual.1_Type=boolean_Shape=static_IR=8fe4bce2e674753d81a1516280769a06cdde538e658ae548087e4888ffa2905f_Device=CPU_Config=() -257:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=() -257:conformance_GRUSequence/ReadIRTest.ImportExport/Op=GRUSequence.5_Type=f32_Shape=static_IR=98a6da6e0972a1b70caa5df788a6921d4e470565dc3880faa59e913fdc15f460_Device=CPU_Config=() -257:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=66cff13148d62809cced5a381c251525486476f7178eddd3c8e45eeed40afd06_Device=CPU_Config=() -257:conformance/OpImplCheckTest.checkPluginImplementation/Function=SoftPlus_opset4_Device=CPU_Config=() -256:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4479acfb061c41832bd1f2ff0de0141dde3a3c496ee4471523fac0a37451311d_Device=CPU_Config=() -256:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=557b6184296452c25e420a307a2021cfb0eedcb73e42bb4bc247c34c15b18447_Device=CPU_Config=() -256:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=37ed85c113d481da6d55c0a820d49090a8b256694e0f1b111feded60fe708279_Device=CPU_Config=() -256:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=9aba412b059ee77c603bebe3e49240d6f2183168002d25bb7bfe62f1224be2fd_Device=CPU_Config=() -256:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=dbabd4c2992053ca70e9d6a489b437cf8d1f13807220adb5054204e9bede00e1_Device=CPU_Config=() -256:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=27e8804992c0d74c18c958f0876c06be6c7eda2b36fe7de3ab616b577dce13c6_Device=CPU_Config=() -256:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=i64_Shape=static_IR=056c07f9ad8e27e01b269b5136ee29b4cb4d1229a009cda07e4fd32c45d4e97f_Device=CPU_Config=() -256:conformance_Loop/ReadIRTest.QueryModel/Op=Loop.5_Type=i32_Shape=static_IR=5b9cbac8797158a77d5616e8b7e5d8132360e23e26d31d845f0d129df7bfd7b5_Device=CPU_Config=() -256:conformance_Log/ReadIRTest.QueryModel/Op=Log.1_Type=f32_Shape=static_IR=038bd1e152575a3b8ca28bfe18fdcc9cbf19c9489e7bb831b9d5f56f7499cb7c_Device=CPU_Config=() -256:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3d73edb68da4aee1c052b79ffce030b368f204c04bffd9a9dc01a9b54de932e7_Device=CPU_Config=() -256:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=effa926dbd9beaa9b2b7b660288ceab99da8cfb440c4b01b7779d1bc25be336f_Device=CPU_Config=() -256:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=1409169e395a3eb90f9235b74f2f8c94e0e27a63fae33cda153d991ae1cbb68d_Device=CPU_Config=() -256:conformance/OpImplCheckTest.checkPluginImplementation/Function=Pad_opset1_Device=CPU_Config=() -256:conformance/OpImplCheckTest.checkPluginImplementation/Function=Convert_opset1_Device=CPU_Config=() -255:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=686b6d84e29d87a91c8177396d2aa5a1fbb88656c79e41af9a0b30b42805f477_Device=CPU_Config=() -255:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1a29918856ba0f88e99346fda6e6c21ff2bf129f5599d8a1c8611346ab41f2f7_Device=CPU_Config=() -255:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=984e628a0090ff9d04bf8f41b795f0682dd3083fb78b71397a51cc2efacee247_Device=CPU_Config=() -255:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=138e0258106faf2065b52655adfb8b45d49b677f9cd04850bc5ac9335a9d16d7_Device=CPU_Config=() -255:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=e6ee69f681f9388da19dc9c17781710c5622ecda436aa2d4b018578548acebc7_Device=CPU_Config=() -255:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=19f9f95d2205816fc002d8eaea7cfb19f19218fbc3528e4932b99f1486b62827_Device=CPU_Config=() -255:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=4d10da0860e049587221c12f55c3bca9fc587b74dd3fec194c8ba5854a736d93_Device=CPU_Config=() -255:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=99a80c495a8fb4626995167a3ad2efa0efed7696459f6219125414a2bd20dfc5_Device=CPU_Config=() -255:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=d4e6cfc9844e29087dc5bb222a1822c26ec71f2e751575790add7c9b98a5a23f_Device=CPU_Config=() -255:conformance_PRelu/ReadIRTest.Inference/Op=PRelu.1_Type=f32_Shape=static_IR=86cd07b4db06e4210732553cace1797b55c19f590e2d9b7814eb30485d8599ef_Device=CPU_Config=() -255:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=ae817dcac1ed2395cc4098f67bf6d2bcbecd8b7e91ef7592622d1ee75ed4a3cc_Device=CPU_Config=() -255:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=14f550bd7e83223ffbf501918141376e6a144484865f03c9768fe9da49a9f06f_Device=CPU_Config=() -255:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=120b0e6b0c1f7bda754d62ac7c88e7c8bd9e96ddb85e7e5f29decdaa7c1cde96_Device=CPU_Config=() -255:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=6eac2d4e0df77b93f566f0d226ce4972da143d2b3fd794f7d316faacce442035_Device=CPU_Config=() -255:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=922699707423c4110bf8a551eaf7dc3689fd3673fff79cca21442cda90c22dda_Device=CPU_Config=() -255:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=cee58d2e3f2d6ef0061c5b245a15c60f0a26a58474c015f71dbdbc0c171b2a8b_Device=CPU_Config=() -255:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=525408cae199f0936f7552165ba12d61ced6b675d75d56f1d69be8281feec5d5_Device=CPU_Config=() -255:conformance/OpImplCheckTest.checkPluginImplementation/Function=NormalizeL2_opset1_Device=CPU_Config=() -255:conformance/OpImplCheckTest.checkPluginImplementation/Function=Exp_opset1_Device=CPU_Config=() -254:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=516b04726c16c5c01fbeb1c97f8f9d9376b80e9341d2029c634f7fe4975cc4be_Device=CPU_Config=() -254:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=2606bb36cbc87d845c9f678ac84e47c0893f0b86a3b675e70018d1e535234875_Device=CPU_Config=() -254:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=21950c433f50ded0f662b9e0591e756a8dd685bc11a8296bcacc57ca1a4968b4_Device=CPU_Config=() -254:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=683b86794b415f893e4d426a8c68aa38f46c250e4c31bc5f5807a86c20ffb34b_Device=CPU_Config=() -254:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=2463ef4b8684fd6b391fca0b123328e1d695b47017fe94ffe5a419a3c22ce93e_Device=CPU_Config=() -254:conformance_NormalizeL2/ReadIRTest.Inference/Op=NormalizeL2.1_Type=f32_Shape=static_IR=3bfa35b53e4bb74a9e450b1220a5d3c061f050e498cf86c8f72118052b7fa252_Device=CPU_Config=() -254:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=bc1a7618e707ddd2c4773d1a2234e6dfb39954ad872abdf38a18d653ec35b26f_Device=CPU_Config=() -254:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=60ab42bb613fe785777ed45bc99044f41dae00316065ed5e5f07e69f5c861fc4_Device=CPU_Config=() -254:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b46a2ee4f7042328b2496382ed2bb9cf39621c3e3e27fd1d355c9682543effc2_Device=CPU_Config=() -254:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=c54189129febdb864ceaa5447a7a0011c8ccdf3711fcfd87424feca61b44c0b6_Device=CPU_Config=() -254:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i32_Shape=static_IR=a3f2389f6a8a495885efa87742d53e1e154f58f8fd6e83df89bddf5922247095_Device=CPU_Config=() -254:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=1da672197f2c962a6cdfb059e9d09c10a03c3b082838f53d2faf6a761fee0637_Device=CPU_Config=() -254:conformance/OpImplCheckTest.checkPluginImplementation/Function=Subtract_opset1_Device=CPU_Config=() -254:conformance/OpImplCheckTest.checkPluginImplementation/Function=Broadcast_opset3_Device=CPU_Config=() -253:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6d71ec3285f12c65001e4396546f6c8c02215560675397656d85777f0c9c2644_Device=CPU_Config=() -253:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7cfdc0a97fd79a5d272b29850c24dad4a0a8f147ea89b7683c98fa203a448c52_Device=CPU_Config=() -253:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=80cdfe1797800671134d77fa9c7032cdc1b19b4905fcefb11399610216f6e623_Device=CPU_Config=() -253:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dd181ad2875cd08679b8554d2a85ea0fd15d7f09f733a8290f677fed6c757_Device=CPU_Config=() -253:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=effa926dbd9beaa9b2b7b660288ceab99da8cfb440c4b01b7779d1bc25be336f_Device=CPU_Config=() -253:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=b1477d38842775944964d18c13278454256d9610e0ef880fbce0cc87e5977556_Device=CPU_Config=() -253:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f28013382ca254b4538a5527896cdfcd9d404aa854af83ef1d417abcdd781ef5_Device=CPU_Config=() -253:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=be4d557c62a3a43e7f309d2276cd7549bf1976ca8593bf2be752e60c42237a19_Device=CPU_Config=() -253:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=a0336bba08291ea34d6271c83816fb349d163fc5989171b07fe1bce50a2f3ea9_Device=CPU_Config=() -253:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReadValue_opset3_Device=CPU_Config=() -252:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c6e38c3297ab303b166e2a613203a1f09f4ba5a15659c8d2b233febd8fd09d9d_Device=CPU_Config=() -252:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7b1df1422bfecf1fdf9c25f72d938950cb1492ee1c7223d9c0d771f93b1fbdb8_Device=CPU_Config=() -252:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5bf1e9348ae0ec7106a2231d8940acc74464f5ecf0cbc6a682defc3a9bc5c2c2_Device=CPU_Config=() -252:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6ddd9bc0333c5b1ebae36dafbc24444ffcd34d29bdb58a9b20d4e584c2cc63eb_Device=CPU_Config=() -252:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=63de0838ea26e3575f49700f73fffb0d3415ab68b29b1a1da690b84f7a034822_Device=CPU_Config=() -252:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=461bf15d226b7ee3cbdcbc8cf1806e98267c5f14f0aef49dfb9de094f56347b7_Device=CPU_Config=() -252:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.1_Type=i64_Shape=static_IR=36b9b7be1407243aad0792e7a49ef25f7c3e3791dc1ff93cad40480837ba87cf_Device=CPU_Config=() -252:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=58961039245de875e98bf9501f24065bd4b7fd4bd962ffb488c93a61eaa401f7_Device=CPU_Config=() -252:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=03c3e6567da3c139c19e0ce0d301a6076b2e2446d191216c7bf38bc030ea7855_Device=CPU_Config=() -252:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=() -252:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=f31f6d969e04a7a1c964c02f107a7291c85067ac31d935921bc418363c2a7a46_Device=CPU_Config=() -252:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=98526403db7eb1f67a41aed2c34fea684d99d8cb8225313136e55be7d326aaaa_Device=CPU_Config=() -252:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=cbb80f496fd705f24fdb25f6de3734bb2a2b7f49c984bdb32c4f62ec4640797a_Device=CPU_Config=() -252:conformance/OpImplCheckTest.checkPluginImplementation/Function=Softmax_opset1_Device=CPU_Config=() -251:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=68c3856ae6a30752004a5ebfabb93bd0d98446a91ba7fd84e686226f45d326b9_Device=CPU_Config=() -251:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=7d73fec5a605ca6fc06cb014fb723236fd2ddfa1820648acb7fdae8530866f45_Device=CPU_Config=() -251:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=09d4b4ea324f91ba6006bad4c82ca08e723c83c1b862d8075475e986696220da_Device=CPU_Config=() -251:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=dynamic_IR=516ad610612780fdaf83c5dc151316e83772eda4700882f934c97b2a2bd86dac_Device=CPU_Config=() -251:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=aa757ffed4165beb3074da6ad09422d7823a1d0d6c8a654adc56343d0e43dc66_Device=CPU_Config=() -251:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=c55846f7a08af86fb1c914c925433852fd4bc735f671c87e965a6db9b6971708_Device=CPU_Config=() -251:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=b7a53df966d640f075cea7421ca5989ca91ca638e7af16aff33bc275eb7dfe9c_Device=CPU_Config=() -251:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=3bfc4cff938f4386af23d87ce10f8680a62a25ce1fa9178874f212edf45ee045_Device=CPU_Config=() -251:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=i64_Shape=static_IR=75c36f65570966e7f975e5c839036e0e13fe30e6d24ce4be8e6a0e8449173951_Device=CPU_Config=() -251:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=19a94fc5cfe3ab1b4e169b342ec8d9f0fdc4ef19484c8c34d6ab938c6e7bf5fd_Device=CPU_Config=() -251:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=95afe52c888afd5c641ad2d6d0c3f8491f039af2c6938b91fe6fca613ec0b6ab_Device=CPU_Config=() -251:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e8c2981885674129fedb6fc6a376f3fd3db7bf6f9867ee8a3f4e5aede63ee168_Device=CPU_Config=() -251:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ce2bcc21fba106cc8be4846179a73cb30f650e7ec48d443fed591f6b479fa9d1_Device=CPU_Config=() -251:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=29a544bbefe85bdabe1d5d36d83d8ee1d80c71f8b98ff6e898e1062671daa8ad_Device=CPU_Config=() -251:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=75bf24e3b7a4c4374c5c92331d9e48423d734d35b5cafb951222e39ea4c29613_Device=CPU_Config=() -251:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=a937747c04b70351d3632aab91189200e2c0a69b6467ed856b7075885c54d83a_Device=CPU_Config=() -251:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=6e614b9877c6dd3bf1ebd731443e5a1e0b7492edbc3a4683adcff53c965ca1bb_Device=CPU_Config=() -251:conformance/OpImplCheckTest.checkPluginImplementation/Function=Proposal_opset4_Device=CPU_Config=() -250:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3e1e1cd684c1bcfcf06febedcb4eb0f4f62b5c0920098fa0715c828e9a9761a7_Device=CPU_Config=() -250:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0e9ccd2a8aded784ff21758802648777721176f1d112ff60aaf3f150d6292156_Device=CPU_Config=() -250:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=07b4c5d05754987a0524385690d79f74988302f437597b7477770e8d062d72a0_Device=CPU_Config=() -250:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=i64_Shape=static_IR=7adee81cf21b942334c25378325f61e13e9ee3ac95ae004d4d9efceaab6c0949_Device=CPU_Config=() -250:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=a5dc3f8dd6385eb7f6d4052af82e27b7af7e8a58bdcb6092ec79ea3087f141c6_Device=CPU_Config=() -250:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=5840000517cf6690e3b881e338ab887afae81129e22bb0e3c71b049e42ccd68e_Device=CPU_Config=() -250:conformance_Sigmoid/ReadIRTest.ImportExport/Op=Sigmoid.1_Type=f32_Shape=static_IR=b6a75c5d2a686eae53cc25c6b107630b31a8a4d8c6514980ed1a97754f33bdcd_Device=CPU_Config=() -250:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=427900d25144ee6b8cd4b35cd53c6e9335375018f6328dd01ae4db304846d991_Device=CPU_Config=() -250:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=1bde2f2a7294810531e23de80f25a451b3033487b5919c949b708b273dc3973c_Device=CPU_Config=() -250:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=3141ed71fe3efbd7fb026a006824ec24e4673d8b97d23dce275548e92eedad91_Device=CPU_Config=() -250:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=62b8aaf25e8c93387362b0c657886c31c39a7330cf3455486b8943a1e375ef5c_Device=CPU_Config=() -250:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=d066432a0ddac020441582a98f139d063cf5f4e9f34deaa0be5ab9b9f048aa0b_Device=CPU_Config=() -250:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=d8432e7d31bcf4d95ff7ab845a6858ea67cf751c7ef0fca60a9bab1d187fe3cf_Device=CPU_Config=() -250:conformance_Less/ReadIRTest.QueryModel/Op=Less.1_Type=boolean_Shape=static_IR=8cac1c4c51c2eb61b9ec75320814acf81b9ac240a88e1cc68f29541f6eb546e7_Device=CPU_Config=() -250:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7373e7e64fbb2fabed337c09be0d6b42c5cfad39b26d92c6dd74810499863448_Device=CPU_Config=() -250:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f3b3afbedffce0d70b40d78f882a0061ba05e26e385c37cf902aec88ea43a649_Device=CPU_Config=() -250:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=33199e062b7b59c8244477fd2682a08876e72126701842265efc0c9fb4a90c94_Device=CPU_Config=() -250:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=b16650eec74ddd46ff3bffc9eedb340b6bad99a338fbe6b11f7eca3098a324d2_Device=CPU_Config=() -249:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6ea8e16cab0d6f60ef13562706c941f5ba3c90d3a65447ab3844e100cec5a0ad_Device=CPU_Config=() -249:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6ddd9bc0333c5b1ebae36dafbc24444ffcd34d29bdb58a9b20d4e584c2cc63eb_Device=CPU_Config=() -249:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=45bae87afb2c7e7f0b7315334e33b8a9baf42d81b95b844cb4987dd3540f1dff_Device=CPU_Config=() -249:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=1c6447222d58a16595cfdd8b216fac2cb3f005d2b236a6526ef5de8e272e4847_Device=CPU_Config=() -249:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=static_IR=da15c9ddbf446de00565c83e95b8a554d400b8b925481e56eb3df41f7efe26d9_Device=CPU_Config=() -249:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=dynamic_IR=a9636e6e43bc01f8b1cfcfcd8e60e4ffba20837d0d3b80429c93f23cd8da89e0_Device=CPU_Config=() -249:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=2620e86e1e6ce8f0ecb3eebce969f3e7df11f7f86c6f97309aa24993f9036033_Device=CPU_Config=() -249:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b46a2ee4f7042328b2496382ed2bb9cf39621c3e3e27fd1d355c9682543effc2_Device=CPU_Config=() -249:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6eb80b60b2162fc469f652535ee11822ae34c903ca44191dc95ad7f9678b9337_Device=CPU_Config=() -249:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=046798a0cf8d4c3fd8f1dc12bd0363a669628e748a6c964385eb50bb783924fd_Device=CPU_Config=() -249:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=1c6cbe8477d09b0b193ddf9a453c1b6a8a79e3d1adcdf1c096709cee7a4866db_Device=CPU_Config=() -249:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8f731757a7c32fa8e4d602d7197af81a1a82ea228ec05f4baeae7c59eba11f2b_Device=CPU_Config=() -249:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=7147d6ead151efc24a53c196b63fc441e240c34b41ad2226a535580eb2a3f3d2_Device=CPU_Config=() -249:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=c70693ee2f825a40f3e1fc8dd2ce9355690bc33ff27030f674d082a0cb343cc9_Device=CPU_Config=() -248:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=acc81187b83e3de7c3d0903f40daadcadff63455905c00ff2f98498f21bd68ea_Device=CPU_Config=() -248:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8710c3eaa10d25119059f4e15970d8a6381f978cd905fc8eb1b4d43a36d1d5f6_Device=CPU_Config=() -248:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=9fc3d18a9496df4681f38d330d3d1ff7b83b29b8f4e08e19c26a0107c4b69157_Device=CPU_Config=() -248:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=5840000517cf6690e3b881e338ab887afae81129e22bb0e3c71b049e42ccd68e_Device=CPU_Config=() -248:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=cbd1111f323b8e6d78b59b531708defef64b90463f973f64f52251795ac5a7dc_Device=CPU_Config=() -248:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=8e098b9c129ab30efc257d55cfbc737d990d2ff0f7931039d3335c42d5f286eb_Device=CPU_Config=() -248:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=eeeaf32688af20dbc39dd3705dc09fc804c0636d4d5807b003c002eaab1e79dd_Device=CPU_Config=() -248:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=dc4bcacb769fc4d8f1ef4ff20ca7ba6b3b369d69ea3b1c65733d4cbd2cb0762c_Device=CPU_Config=() -248:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=739517c4c613063fc5ef734443f0a599400dec31cd5a56686735f3165b2dc2d0_Device=CPU_Config=() -248:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=dynamic_IR=60bd170e816e0c2345a1658fd88459775fe8b7cce5de31a16e4e6cdea199f264_Device=CPU_Config=() -247:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e62245706f4242ff86bcb70d4d221bf49aa31db3807698d574125166bff5f8aa_Device=CPU_Config=() -247:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1bae1a851b5bf95921ad7666e48803dae416315a20a3ddbcc1c81243cb5bdede_Device=CPU_Config=() -247:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=83b83dd13b1733a50ec728ca6e7f09eb75641a573178816d1d33f30390464d87_Device=CPU_Config=() -247:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=8952b1ce6fc7bfd900e669e12b520b624c02026b458bae41afe28e1f76058315_Device=CPU_Config=() -247:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c87c002bc627f4adfa58547da4c2b1f270e07e9961a1b4ae99dda72d88980550_Device=CPU_Config=() -247:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=f76da5edfb7a9e3fa7cec034fa43307bce74eeb0629176ae5dd40d154baf858f_Device=CPU_Config=() -247:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=static_IR=e1d727df48a0a74d8b9865c00e5c39c9d53a5023d83da3c58f281b6b1411b696_Device=CPU_Config=() -247:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=7d3d30fa9e2a8a839cf42249de3eb8228681229e8b302ff7f290cc0d00c10a1a_Device=CPU_Config=() -247:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=fe615eeceb735b046b190d844931c56223d45439021da3b6b23227a1f9cb73c7_Device=CPU_Config=() -247:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6af32fc288bcbd414ea63525c4345aeda74ab21c44aab5910f85b8b7fb5d1179_Device=CPU_Config=() -247:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=453c1f5bb6c2e9c81a04475c49696c6e9e94f77853ef961e1839b541de7c7e21_Device=CPU_Config=() -247:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=028177a440f430edc5dfd7a7f0f2c0dded422876a98b6da66a647ad9aca10e57_Device=CPU_Config=() -247:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=f8c3c9cefc3f7ab9b8e1fd3031be6eb34eba46f9c493b316439c24355a8a4978_Device=CPU_Config=() -247:conformance/OpImplCheckTest.checkPluginImplementation/Function=NotEqual_opset1_Device=CPU_Config=() -246:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=e2da6d928938b6445170cd69fd4a7aab40130a560cef3ffa2d268a428f56fcec_Device=CPU_Config=() -246:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ffc3cad64b8bf82ffa4d189a247a9434e71886cacd3582956c5dd98921fd2141_Device=CPU_Config=() -246:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9b4725171957a420a98f908742f18062fbcee198871d527ab5b4d939005ac4e6_Device=CPU_Config=() -246:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d9937a6c3eb62ad6328d7367f15e45758ce5f2ebc0488931855a5b1925574d36_Device=CPU_Config=() -246:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=05c2f891e743416ad510bf0ebf713738bd41258123cc4bbdc5cf067f251e35d8_Device=CPU_Config=() -246:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=c7ce41820be10f17c8d48c005703d536d18e4f49b1d2022ac58f77b7b9afadec_Device=CPU_Config=() -246:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=08393711dca608a5beec54493fa162068673eb746a6223b6dab2640d411570c0_Device=CPU_Config=() -246:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=7df296e0e156bb36cb643a292802f9db374c77035c6a05ee4a865fbe2c6ef92b_Device=CPU_Config=() -246:conformance_ROIPooling/ReadIRTest.QueryModel/Op=ROIPooling.2_Type=f32_Shape=static_IR=1a0e3f63698678d2e6bb8968fbadc98227d9ce548e77c53021412d80d7711753_Device=CPU_Config=() -246:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=21f786ad25c17eff66f16501d160439b96636a7d5d8512c1bd3db5fb5d5e6987_Device=CPU_Config=() -246:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=c0eaf7f2465de396f92db5829a30b7d887dc26bc8d49b86f0fd0d688c7129e18_Device=CPU_Config=() -246:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=4d9f16ede014da56824607d45502439f71b57275c332fbf15c6ba2ec1496466f_Device=CPU_Config=() -246:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=64d3761db7bdfd0de19878c66fa4465d084f7462c332fd978de458e328f97875_Device=CPU_Config=() -246:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=08cdbd5ea904a12dde32bce43e6c512aacd0ff990d5df3a90ff625226c936edd_Device=CPU_Config=() -246:conformance_Erf/ReadIRTest.ImportExport/Op=Erf.1_Type=f32_Shape=static_IR=2e5aed1612da0f720adb051e22460983a3911c38cb09184d812ceb949870f450_Device=CPU_Config=() -246:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a9fdcbd778622e442a42d8d2a1a12a1be0cf7e9d79c4d7ad56d5802c7a84d337_Device=CPU_Config=() -246:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=11477a6d571446d4e895d1cc6b0155c36606963d5c4a3a0a516802063a60906f_Device=CPU_Config=() -246:conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=static_IR=fb9febc1b0984c7d6887460d058a75a9444bd1ade793c5b945c9b79ad2c63e46_Device=CPU_Config=() -246:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=053d601716750db93af5ae01d67213086ed987370f9ff59723824dcd0a6c2462_Device=CPU_Config=() -246:conformance/OpImplCheckTest.checkPluginImplementation/Function=PriorBox_opset1_Device=CPU_Config=() -246:conformance/OpImplCheckTest.checkPluginImplementation/Function=Multinomial_opset13_Device=CPU_Config=() -245:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=10c19142631a9ac6d8026ec82820aa75ba1e14605fe5ea1e017fa4bde4a90c44_Device=CPU_Config=() -245:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=ccef47523d9134720116dbd4a37d5038c9d15e2c393ccf1a6d24c3790529c282_Device=CPU_Config=() -245:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=969c6a651dc204576d68d7d893ad2dbff1f7c74803b1763857d41aabdd19a72a_Device=CPU_Config=() -245:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=2d153f841ff4b6825fe5b8399105916112addb79300aa00df85409c88fdd70ec_Device=CPU_Config=() -245:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ea8fff2db5032f5015f68d53904354d4bdfbe5288224c7f549a1573794455d80_Device=CPU_Config=() -245:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=2cc50ee05a039bf65fd7be2282284790d9d2e1fabb4cfec509f5bed121152d93_Device=CPU_Config=() -245:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6ddd9bc0333c5b1ebae36dafbc24444ffcd34d29bdb58a9b20d4e584c2cc63eb_Device=CPU_Config=() -245:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=85d1eaa250a32acf89b675cc50f513ef3c7df50ed9d68f2cff2fc89db41b63f2_Device=CPU_Config=() -245:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.1_Type=f32_Shape=static_IR=a4fe57973b0bba01e6038a8050f07b8ad1bf6871c1ad86270920f9084dc84905_Device=CPU_Config=() -245:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=28675c37d06426cf6895e7ffc15d6c212ef8be1b278fd199d1bfbd0678f825fa_Device=CPU_Config=() -245:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=92dc9b12889f441d7a93e95851a15849139787b0ecc080e70d266fe4cb6dd9c1_Device=CPU_Config=() -245:conformance_NormalizeL2/ReadIRTest.ImportExport/Op=NormalizeL2.1_Type=f32_Shape=static_IR=3bfa35b53e4bb74a9e450b1220a5d3c061f050e498cf86c8f72118052b7fa252_Device=CPU_Config=() -245:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=9bb8728e6e9f68cf68a9e39d1aa4c618c4aca4187d4262f735c0647d680c0506_Device=CPU_Config=() -245:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=15dd996f113d962d9bb21424d1006af0aa28376a2af63d791a80f0ab95a604fb_Device=CPU_Config=() -245:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=77b3b21d35d3742f7abc1097b99d510453f42ebe921681685fbc457d2fa9912a_Device=CPU_Config=() -245:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=a714d51739b3d420cf27f476e338bacbeabb40d0ced1e1527587756265253d8a_Device=CPU_Config=() -245:conformance_Less/ReadIRTest.QueryModel/Op=Less.1_Type=boolean_Shape=static_IR=953b15e350d9a27c4d048cbae41a278c732f3b3a6e8debd7fd2e75e99a015966_Device=CPU_Config=() -245:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=86fb2ad636e51f682c83919d64217835cd9ab458695e3bdab295c4107516e733_Device=CPU_Config=() -245:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=b7b0a0b3921a1e1434a3fef630e32b124c810e8bd15a3e861fe7da79158947b2_Device=CPU_Config=() -245:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=45959eb5eb391b2bc86455cb1e86aca76799c6b082437e72b15c171037a6206d_Device=CPU_Config=() -245:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=225aaa01462e6e43c0c12cff65f96e7d9c07d368a820ff3c1b2939fefe86d492_Device=CPU_Config=() -245:conformance/OpImplCheckTest.checkPluginImplementation/Function=Tan_opset1_Device=CPU_Config=() -245:conformance/OpImplCheckTest.checkPluginImplementation/Function=OneHot_opset1_Device=CPU_Config=() -245:conformance/OpImplCheckTest.checkPluginImplementation/Function=GRUCell_opset3_Device=CPU_Config=() -244:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d69304b651805edf18138147ec5a4c16e883ad5e5d9828db849a35249c28b263_Device=CPU_Config=() -244:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f2685b40efb789012e69252fa0fe30803c68be724a52dbcda9b2cb796138ea57_Device=CPU_Config=() -244:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=c7a696f3217515ef4ff5eb46fbd15af6533f0fcd268398fbd434f105c0a11328_Device=CPU_Config=() -244:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=66abbc2c605a0f866880bd4730865ae6b5401a1f4beb242f346bf6f2f8138eb6_Device=CPU_Config=() -244:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=dynamic_IR=a99a5ab2de2d408c2e40ad5734c9bd5ab4d1d221f4dd24572e05538b134ef88c_Device=CPU_Config=() -244:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i64_Shape=dynamic_IR=2c47f1ee19359a486a72bdafc2614159d48fffc80ddabe0f897212a454a75b18_Device=CPU_Config=() -244:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=223a34e46344a0dff7f35a637c9bd08e2a76a552ca87e5bf0134c9fc6d6be41d_Device=CPU_Config=() -244:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=2233a83397f11ea3c674c4845409c4f27f8bffbb8d0295712a2525c9e93d6041_Device=CPU_Config=() -244:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=b434cd386e4c5e688aac8da3425d2ed0d72961223eaaa1cf2ff951a88a5fa001_Device=CPU_Config=() -244:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=49b05f6b6a636d84beca451fdc1fc81e3411a100ea105fbcd49ef72ef1fa0934_Device=CPU_Config=() -244:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=a714d51739b3d420cf27f476e338bacbeabb40d0ced1e1527587756265253d8a_Device=CPU_Config=() -244:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=static_IR=c4d8543f8e0b375407e428ef119ba4049d44cc273a10661b57645bcd1d36f5cf_Device=CPU_Config=() -244:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=60ab42bb613fe785777ed45bc99044f41dae00316065ed5e5f07e69f5c861fc4_Device=CPU_Config=() -244:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a1e0bbe02c433cb144b4825a9f1b2c30c03743f210830db5462736850b6db383_Device=CPU_Config=() -244:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=f26c1f41ef689dde33e9d61b0a1066788b8397ba6a170f5eb1362726ba9c0868_Device=CPU_Config=() -244:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=717ea579a24839ee9c5ba7c59a07af667fea4fd44ee18bf60e8970264852bde7_Device=CPU_Config=() -244:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d141b35e277394511f5635b2e395039c986ac392e6f49c2415da6a5071bee96a_Device=CPU_Config=() -244:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=fda1f84f5e911136f8daaf4fcebfb989f3216c066ddc1cae578882a41ca0f5bf_Device=CPU_Config=() -244:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e8a26a33d6dbe0bb560820295fb6b8aafc3da0d2b78e29199d2f09e952722efe_Device=CPU_Config=() -244:conformance/OpImplCheckTest.checkPluginImplementation/Function=Split_opset1_Device=CPU_Config=() -244:conformance/OpImplCheckTest.checkPluginImplementation/Function=ShapeOf_opset3_Device=CPU_Config=() -244:conformance/OpImplCheckTest.checkPluginImplementation/Function=MulticlassNms_opset9_Device=CPU_Config=() -243:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ba28829f211d64d6d4922682b85f1bad6a3c28cc30b4f9651186b1e8fab39fec_Device=CPU_Config=() -243:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7a3cae38e357ee1e5b0400c7e1256cc8a2d78da81911fbbb3ae6d9e510d78aac_Device=CPU_Config=() -243:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2d886a31e22f61d30c33ddd300ba7d8ba1cd9796ee1a4f688db9126b1d8d9c83_Device=CPU_Config=() -243:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=64186bbc89d54f073554e029b8972fbbfba2abce8026a379b7ac3833f84ac9d4_Device=CPU_Config=() -243:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=cd389fc4a9417c7136f75474e42dfb43d1f9cb35fa0e104632ffa69fce2b7e57_Device=CPU_Config=() -243:conformance_Exp/ReadIRTest.ImportExport/Op=Exp.1_Type=f32_Shape=static_IR=67632b67a0834136cf2f3bcd6b3fbaf0d2f2bbffc1da6c33fd5fce0d0b8a763c_Device=CPU_Config=() -243:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=a3add607f5e37633f3298794f8e32e409e3403666af3c0fc57c7d4427b714eca_Device=CPU_Config=() -243:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=08ba7fbf736896f373ea81dd727940aefae22a39e217e84dfc5617ed62133d10_Device=CPU_Config=() -243:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ff39aa885f7ecc22a06f668b79fef4ac41b3adf8dea82f428711b241c0fa6059_Device=CPU_Config=() -243:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=07b257862a62290d7e8ae939147bb7422992528bf54209b8d1bff500b99b6f4b_Device=CPU_Config=() -243:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=14f4dcbc8e714fdb791d15b62646db0da2cf647d431dd6ea044ca6976ef51753_Device=CPU_Config=() -242:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=aa14d6e18f8580015dd7d32b167fba6ee137133b87fd617eab4599f407a51b69_Device=CPU_Config=() -242:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a0f8789f0f95beb6f28efc829bdf2f99d34a3e9397ad1a80d7831aaaf125b5eb_Device=CPU_Config=() -242:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8a5bf21112b4a458a3323e615dfce41a8627c89ac692e1d568786634667849ab_Device=CPU_Config=() -242:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=43d871d4b2b3346c08f8582b892ba0c0017d77688e16fd6d69f83f8101e12a69_Device=CPU_Config=() -242:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=c662eb0004f431152ddc69e12826a6c0e7aa66b24be0169acf10ca95f2a63f52_Device=CPU_Config=() -242:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=33d8f6d258ae8dfd09b8e6fd39f0e74384eabfb685e0e72a3c798101ea56a1d2_Device=CPU_Config=() -242:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=bd927dd60e7b65e84d03c2c01d29c6932961f801bed1312124c2212b5e22a921_Device=CPU_Config=() -242:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=f8b14e90b051624d56678dbe68f15e6db94e22878b22914d0be241047d1a3783_Device=CPU_Config=() -242:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=206184d6fe0a3ab9fe71914c66d3804e145caed7cf3ac09cb1d50183144d6ac7_Device=CPU_Config=() -242:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=a3370e3b46f385ea6e46137d49d5f1b4158fe08d0a3e9feb47a162f6b3640951_Device=CPU_Config=() -242:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a7b2c196b6ae12252522b2571af40b540eae94513bfbd88e15708fee816869f8_Device=CPU_Config=() -242:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3a17c045930ed967b45d1606b78fdc92e736731b198465e95ed7268d99eed246_Device=CPU_Config=() -242:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=0d6cc305ea05df2178e3b4ea61ba2f296655e77af08556491e0dc8dfd46bdc6f_Device=CPU_Config=() -242:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=00d6c2465c4fa7ddab80d30c2fd8099a684bcc47cf9bdba89a39560beed737f6_Device=CPU_Config=() -242:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=7b8eedb1c6be0db4a0c041ec3b04498d6dc68b326c35533ae16258e750f21e3f_Device=CPU_Config=() -242:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=i32_Shape=static_IR=681b1f284fb69c16681d3efd2081d7f812496e3a027baef35a75bb0aeb9c003b_Device=CPU_Config=() -242:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=b005a58abf8192face35451602a847d378849223e4d433924581d28ef8141303_Device=CPU_Config=() -242:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceProd_opset1_Device=CPU_Config=() -242:conformance/OpImplCheckTest.checkPluginImplementation/Function=Greater_opset1_Device=CPU_Config=() -242:conformance/OpImplCheckTest.checkPluginImplementation/Function=Equal_opset1_Device=CPU_Config=() -241:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0d74ee98934e32799620ac90fd3ae8335bca026b9225782458949c64139d89c3_Device=CPU_Config=() -241:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f9f701a7d26d77a2b1eb3cc822efb5da95f1edbe614469f725a381ce892d8d91_Device=CPU_Config=() -241:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4746fb4d92aab20d21eeb0885d35c88abd50aa250298473f5bd143658eef2316_Device=CPU_Config=() -241:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=9fa81cf001e6c48dfcf4e75aa77f95b3dce4e8d48b6ec3cfc896dcc08006c62e_Device=CPU_Config=() -241:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=055b7eb16539ce5cee62e165db9a6d51a11e0bdf90bc9f82eeca1f2faac2bf89_Device=CPU_Config=() -241:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=8b8efa859c54f9cf2200c18953de243d469d2f04bf38ba5f3efe441de23ffe45_Device=CPU_Config=() -241:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=5840000517cf6690e3b881e338ab887afae81129e22bb0e3c71b049e42ccd68e_Device=CPU_Config=() -241:conformance_ScatterNDUpdate/ReadIRTest.QueryModel/Op=ScatterNDUpdate.4_Type=f32_Shape=static_IR=d42cb628111ca80a33a558dcd1c2c310aa7b95d6c48549075291f49ec59c302d_Device=CPU_Config=() -241:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=58961039245de875e98bf9501f24065bd4b7fd4bd962ffb488c93a61eaa401f7_Device=CPU_Config=() -241:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=b91a183b8c36d6e8358dad7056638b8091005393dd1ee6813728f25cd3e6a9f5_Device=CPU_Config=() -241:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=5a1aa66136ca2be83f714067139e11fcbf672d73f8b28c57d29333b885a17f83_Device=CPU_Config=() -241:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=f5d3b4ec51e032e4df5dae00ecba1a3198c29cba96c72b8c89126c4638b715d3_Device=CPU_Config=() -241:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f13dcb47235a9516298088a0c45ff56fdb7f95144da257a3dfa1c618c7373ce9_Device=CPU_Config=() -241:conformance/OpImplCheckTest.checkPluginImplementation/Function=SquaredDifference_opset1_Device=CPU_Config=() -241:conformance/OpImplCheckTest.checkPluginImplementation/Function=Asinh_opset4_Device=CPU_Config=() -240:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=abefab3b34ee5f7da347f3c86a1a0b7b17617de416051dc18c3aee80862c3000_Device=CPU_Config=() -240:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c4ae9be783990e398b3e8f0af76cab50d72c40c705677a3fe1c5dea592952d1e_Device=CPU_Config=() -240:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=12c56cc6ebb22e8e31d97e0ef640fecab5f93e5c5b2810c4dde56b09a7ac7f48_Device=CPU_Config=() -240:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f84bcf4f549ca0d6e75c7905f1463fbace4f3b955032fcae627e46e353b2aee9_Device=CPU_Config=() -240:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=() -240:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=81313f6065af987d98f37a1709f149d804bc1a36bb0a5c4a11223b29c6ccc3d2_Device=CPU_Config=() -240:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=c377dc784ecf97aef916740686298f47bc82c7c007326042ffe748e91ccfde1a_Device=CPU_Config=() -240:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i64_Shape=static_IR=def60f5f3fb7a0d22cb3d23253e7c8e502aa9dd2d3756c54dd4343b66c2682ca_Device=CPU_Config=() -240:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=36f17a498b10c140f8a319d82e5c8f2cc3cdb7eb3be9f82f7ef35d9c9470231d_Device=CPU_Config=() -240:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=c721fdd5d79e702e4ac48a31d0ebacc4977f050c67d1c415b085773042c8e93b_Device=CPU_Config=() -240:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=54009010668252832a2a755d277e9f574fd2486892184caa0eb4774e753ed094_Device=CPU_Config=() -240:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=d066432a0ddac020441582a98f139d063cf5f4e9f34deaa0be5ab9b9f048aa0b_Device=CPU_Config=() -240:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=7ad5da9c461223f21afd023e08220eaed788598f50e144e45fcdf3466c0810a3_Device=CPU_Config=() -240:conformance_GroupConvolutionBackpropData/ReadIRTest.QueryModel/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=29c89ebfa45163b40be304d7bfc96f3068cd96175db94e6ebda942d3c4af538f_Device=CPU_Config=() -240:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f9b090cbcb19663630a1490fe18357b752e430ad793c0e3aaabedcb74ab64934_Device=CPU_Config=() -240:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b7983ae70a4e7868ccbf4b25a5d8e795620182c29817ad1151d89f2e932d770b_Device=CPU_Config=() -239:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=() -239:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5e31c7022ed7bf2adff14876be4bbf6562afdc2239a08ddcdb507e3d1a20071b_Device=CPU_Config=() -239:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8978b8e985b54cc12e2cefa8d9097f4a3a03d477129230b6c7e3daf8112e2c0e_Device=CPU_Config=() -239:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=138e0258106faf2065b52655adfb8b45d49b677f9cd04850bc5ac9335a9d16d7_Device=CPU_Config=() -239:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a9311932565e68fff052e15c1a0522e1c09270d06521541ca28b67c34184b1c5_Device=CPU_Config=() -239:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=41a35ec8a58f581cb2558464a66077408e961b57821db604fe525d492d4f4fbb_Device=CPU_Config=() -239:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=static_IR=bcb10a9124f9b0471012f9e22d4aed5c2a47a55e652312e8a8382dc0d809a23e_Device=CPU_Config=() -239:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=70d4da84623a0af3bc8362a828bac5ef13285498b420a3df6bf2e88bf05311db_Device=CPU_Config=() -239:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=5c5e10f28ed3a8d4ee0d3c8af982df5f383a4a1a713baba556dd17ee52e9ef32_Device=CPU_Config=() -239:conformance_NonMaxSuppression/ReadIRTest.QueryModel/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=() -239:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i32_Shape=static_IR=22a8f509c3f76bc2dd6bc9a26ec4ab92a5b9ae4678532c886c1438669d627323_Device=CPU_Config=() -239:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=a50bcc7d92264c02627cb62bd0cac349b895311cef54b60a957a6366619e82f3_Device=CPU_Config=() -239:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=046798a0cf8d4c3fd8f1dc12bd0363a669628e748a6c964385eb50bb783924fd_Device=CPU_Config=() -239:conformance_FakeQuantize/ReadIRTest.ImportExport/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() -239:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=dynamic_IR=346617ba1990b67ca1fec8ec219645b16aafa6c94a4a0f752c2f3633b85df679_Device=CPU_Config=() -239:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=5d68272f8318c073e481b5353e6e4350e6b3b5e120f389a98859dbd5af43db9d_Device=CPU_Config=() -239:conformance/OpImplCheckTest.checkPluginImplementation/Function=MaxPool_opset1_Device=CPU_Config=() -238:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7d706b614d2b5d59c5e152bbb61a8fd558686bb3b8e9fda199c499ca49f03042_Device=CPU_Config=() -238:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=dynamic_IR=214b1d4be2a141409b6b54847c952a282d9b2d7236d3d8ada3463f7dc8554097_Device=CPU_Config=() -238:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=cd2470c72fa7d2238d2eca4d067e49a02340ad187681be2fa7e0bac6eab3500b_Device=CPU_Config=() -238:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=075342290aa43542c81f7ed4e804c905f110edc23440452c6d0c0f0c312b65c1_Device=CPU_Config=() -238:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=4a80814933ec1c6198745b1caa4d5b7c9171395b6d8a53cd791dcdf64fa6c91b_Device=CPU_Config=() -238:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fe70e0ee3f24f0bfe4391da7797647a01f66fcb109b481ca859c9f8f7dc7b411_Device=CPU_Config=() -238:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=cd5756749d3d73dc7b666f7f41dc292c73230e5d31ddbbd43aae77210b86220a_Device=CPU_Config=() -238:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=87523dfccb2a9c8334d6810e33c2a2d3b6bc09db7623e7ae93ba4cea89b66a06_Device=CPU_Config=() -238:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=281f1852405ad37d0606184e81d8534d769f50b3fe99f5f17ebfda6954f4a584_Device=CPU_Config=() -238:conformance/OpImplCheckTest.checkPluginImplementation/Function=SpaceToBatch_opset2_Device=CPU_Config=() -238:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset4_Device=CPU_Config=() -238:conformance/OpImplCheckTest.checkPluginImplementation/Function=FloorMod_opset1_Device=CPU_Config=() -237:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=92f5c3aa4427a89ad6ef275c0beb2139cbd0c6ce2eb71205117448adf592ad20_Device=CPU_Config=() -237:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5295b6c6090a820891e5754c34d03dc3347d3436fa16fa4a701422ce8ac78b92_Device=CPU_Config=() -237:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7b904365e0652437dcb59aef3b84da17f4205a821586224e41db1409d96e910b_Device=CPU_Config=() -237:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=43e58b152a871421132d25894025e9f4e2b5294f4b22923ca549bb0f2b8ab50d_Device=CPU_Config=() -237:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0495648ac153ca7bb07160aed49b620b855a89b368d363a22fb45ff3428349eb_Device=CPU_Config=() -237:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=9281a7e3ea8124fdbe416d1f15434752a7e799fc77a63be64babddf60b6f2d8b_Device=CPU_Config=() -237:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=i64_Shape=dynamic_IR=84a8c7a897894ee6bb1c03759bced74ea6d773a2cb8335efdc8d193a534f3833_Device=CPU_Config=() -237:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=bec81407211db6e10d7c8811bc58b53c23c8aafa0e2083f262204f345b9bcfc6_Device=CPU_Config=() -237:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=9337e101d74f6d35bf81e9be895ffba9e972cdab9d79b2802f1c1ec0f4d34a83_Device=CPU_Config=() -237:conformance_ReduceMax/ReadIRTest.QueryModel/Op=ReduceMax.1_Type=f32_Shape=static_IR=590a910a27283b92d7a4650bba546a3bec08a6ded604bbe8523ab3c6d734c70b_Device=CPU_Config=() -237:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=b729ddf6b689006067cfce88ec7d9e89268dd6cd904e4596717016541632b13b_Device=CPU_Config=() -237:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cdd7ce044f231ae39fc0f7460a55473c0de6934124cd263444a5912b8cbbc0ce_Device=CPU_Config=() -237:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=acaf36c12445c608b306074ac4e2be9cfde2f5550905993d4b5bd1714dc96aaa_Device=CPU_Config=() -237:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=8f3e3716e8a1e8647454d124d7538ac1faacdc1b95873ccc1a760e09d48c30d3_Device=CPU_Config=() -237:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=2e70eb484f4bac4cd11e9f643d2531cd0e78994af07c015183edf9d62a709d47_Device=CPU_Config=() -237:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=b16650eec74ddd46ff3bffc9eedb340b6bad99a338fbe6b11f7eca3098a324d2_Device=CPU_Config=() -237:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=2c114b0035075d866c028f9a1168725375feac9a666a881ae6b7db6e9066bb3f_Device=CPU_Config=() -237:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=a3e2f08143425d4c6ed46ee301de31c5942694f79af0d297e4d1801e9a6a0ff8_Device=CPU_Config=() -237:conformance/OpImplCheckTest.checkPluginImplementation/Function=MaxPool_opset8_Device=CPU_Config=() -236:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=cc2f28d736d3c67fdd13fbea9b8cef7c0b075f06b37034581fc732966421802f_Device=CPU_Config=() -236:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=14c8a8bb712c40d63edf76de9a75dd1dcd53a2df8c6098c80ee760119966f364_Device=CPU_Config=() -236:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=396388d4dce8240937c39dcd24e583e775f7b4e84d6c85fa9b5930588dfb9b56_Device=CPU_Config=() -236:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4df4ab698c70278594efe8b4349a4c99c8b2ab7c4ee0182c5a4b7673da922ad6_Device=CPU_Config=() -236:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=64186bbc89d54f073554e029b8972fbbfba2abce8026a379b7ac3833f84ac9d4_Device=CPU_Config=() -236:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=87c65c520de106b146e91222609f5b25cd79e96cdd6b942c3293cddb656617ee_Device=CPU_Config=() -236:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6cf01dbf95872b3fc0c914e73415ed8e4dd52cb355031002a65e3e974559d6d6_Device=CPU_Config=() -236:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=6e8dbb054c99609e5aedd642130e867c22091118e0bb7ddd870a66dcfd11452f_Device=CPU_Config=() -236:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=b6e3f37ddee609d492f47b36b8fe937ee401d01e6d43d7e0b7c06d1a1781b501_Device=CPU_Config=() -236:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=927c151867c504f57aea681772afe32ec9c67cdaa4a0dcbc9055a8725c0296dd_Device=CPU_Config=() -236:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=43c8e8300f01242788a8cfdc37b48779f51f7ee7aef5b28e8de542320ba86e4e_Device=CPU_Config=() -236:conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=() -236:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eace26dff7f6f0403126e78a4c93920ee5e54a721cd580b4b18c2c9989baef86_Device=CPU_Config=() -236:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b3e45847dae7906b7f320b6a751727593b35ad8659ee80a11caf445f44f392df_Device=CPU_Config=() -236:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d9db827de158568b8a10347c13216e92b37ec20d8eac92c38aabd86690114805_Device=CPU_Config=() -236:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=46a3135a1078cd8732e84754fa66872648997791d16caa379a179e1a90960608_Device=CPU_Config=() -236:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=e4388b1379e224ea4849e6052827ef17b490cab3718159195ea2b2986719bb4a_Device=CPU_Config=() -236:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=b077af9b63e937fc64589d3007372d5fb2e4accc392ea09889a2519e3885413d_Device=CPU_Config=() -236:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=00b85178c2e7f891c89e99a6692b94a56ab0882f4a30167997e104db1429a9c9_Device=CPU_Config=() -236:conformance/OpImplCheckTest.checkPluginImplementation/Function=PriorBoxClustered_opset1_Device=CPU_Config=() -235:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=37ed85c113d481da6d55c0a820d49090a8b256694e0f1b111feded60fe708279_Device=CPU_Config=() -235:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a6b95dd49e84f2860b57f1f1ab6fe2baa265bb757112e53def3004a360053aa8_Device=CPU_Config=() -235:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=fad6766f10f7a0ffee665be437521766f5dd56b673293920d8b469bdcef8e7f8_Device=CPU_Config=() -235:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7895fea00309326a052d47dbd2f9e562b86bb9d0501f2a2fd8843a0340359b67_Device=CPU_Config=() -235:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=104a69286d09ab8a5a88403ce6b421979659231fe5c5f973393216607a995dcf_Device=CPU_Config=() -235:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=3866cad522b1a4da567b64df204a69863faf25dd6e09f85dc5806d3101689458_Device=CPU_Config=() -235:conformance_TopK/ReadIRTest.ImportExport/Op=TopK.11_Type=f32_Shape=static_IR=8c82cead166c3db4616f034b66c4795cb4bed653de41d2b6dc71b48ce76a296e_Device=CPU_Config=() -235:conformance_Round/ReadIRTest.ImportExport/Op=Round.5_Type=f32_Shape=static_IR=f4cc9554ddbd189f18575e3a80afe6e8f8bce613dc8852a48d4171ab6916e087_Device=CPU_Config=() -235:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=7988ae4f263061e530c61f5987afd5e7f1945ecef9fcded2bc9799afdcec0df6_Device=CPU_Config=() -235:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=3638f7714d7627d7536ec02891656e512fee1ec55d59bb4f68c7409ad82f3879_Device=CPU_Config=() -235:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=c843b49e26b9be555df454d4c63f0bff72e6ce29d3ae80e9193741500b08f424_Device=CPU_Config=() -235:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0ce1ec496e5d71728fc5daaba87809c5922406a65e85823913381de0d2112e01_Device=CPU_Config=() -235:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d9db827de158568b8a10347c13216e92b37ec20d8eac92c38aabd86690114805_Device=CPU_Config=() -235:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=ea860537d420b0d1afe0ec9a10192912ec59d8f4ba01b27add362ce50fd6b380_Device=CPU_Config=() -235:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=f0d5131a073c03932316e3f20f40c527ddabafc926f0d10824a96158c03524b8_Device=CPU_Config=() -234:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7b42d3a61f732f3639d1ae7011b86158d070acc922308a18f00a01b9c6a60ead_Device=CPU_Config=() -234:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6bbd8d7f90e7c210514c28d527eb33bf0889b1fafbd5cf7d9660532f5d6bd940_Device=CPU_Config=() -234:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=f9f031e1fb61fcf87468eb1f4b2005e7cecc5f073eca95c161fe62fbbfc983f4_Device=CPU_Config=() -234:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1269afc1a9f9a4f71ca2167cc59274b7a3bead8cca474162919619b810eb9c1a_Device=CPU_Config=() -234:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f226723f90368b020cf11817ce0a39c002b9c30e07d16ac9297b7e574a010b0e_Device=CPU_Config=() -234:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=874c0fa19029457645c4cff20769f66ba7aaa1a35ade84c948f83aaa9c1ead19_Device=CPU_Config=() -234:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.1_Type=i64_Shape=dynamic_IR=45a9a897d75b175e3d805e74ec09322789564e0c0e8d9535724f262a9f534572_Device=CPU_Config=() -234:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=() -234:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=dynamic_IR=a9636e6e43bc01f8b1cfcfcd8e60e4ffba20837d0d3b80429c93f23cd8da89e0_Device=CPU_Config=() -234:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=() -234:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=be720054cd6d960249271114344ef2f4f36e2a2208376df70d4395a82386dd01_Device=CPU_Config=() -234:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=72c58b462f61521af4eab9c890e568b5676c7a3194c4e35f8e04f98596013c47_Device=CPU_Config=() -234:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=e0422b2fb57587a85d9ce1532f7fc28a6bd01e72a325d42d9045419dda4bbba5_Device=CPU_Config=() -234:conformance_Ceiling/ReadIRTest.QueryModel/Op=Ceiling.1_Type=f32_Shape=static_IR=fb5c74aa3b17b4a8d5e1603b9179b60bf3f0b8301c74a8fb632b6869896439d6_Device=CPU_Config=() -233:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=50c46a070e458a716446dafab20580095bfe902eeb4ad96c39bc2c617964c1d8_Device=CPU_Config=() -233:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=254937408e91c70536c4f3b3f81f1a7aede93b29f142631a46fa7d962c531131_Device=CPU_Config=() -233:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=6095afd484c177267854bcab902c3057a2a1bbf37b2188d3a31fd2cec48de2fe_Device=CPU_Config=() -233:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ae538f87e4d49bbdc53184fcaa6082eee131a79b480dab9b46e12976d01ea913_Device=CPU_Config=() -233:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=2e06088cb191d8d26309843b1285b9ae4a1eb0722e1370875edde7fd2783851b_Device=CPU_Config=() -233:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=2d153f841ff4b6825fe5b8399105916112addb79300aa00df85409c88fdd70ec_Device=CPU_Config=() -233:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=i64_Shape=static_IR=7adee81cf21b942334c25378325f61e13e9ee3ac95ae004d4d9efceaab6c0949_Device=CPU_Config=() -233:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=9fc3d18a9496df4681f38d330d3d1ff7b83b29b8f4e08e19c26a0107c4b69157_Device=CPU_Config=() -233:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i32_Shape=static_IR=58961039245de875e98bf9501f24065bd4b7fd4bd962ffb488c93a61eaa401f7_Device=CPU_Config=() -233:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=20c2030cdd180dbbfad1e5b8a4f865d1757a9d427c3d5ff21651a429369f4341_Device=CPU_Config=() -233:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=0a5f9fad12bf5e2592c6f720232bb38d94a5fb9ac1fdc5a8f7d474ed9e9d2504_Device=CPU_Config=() -233:conformance_NormalizeL2/ReadIRTest.QueryModel/Op=NormalizeL2.1_Type=f32_Shape=static_IR=acdcf37615b571d8a1275b71cfe0c43a6410e56f5f18db8e9d795e46aac73d0c_Device=CPU_Config=() -233:conformance_NormalizeL2/ReadIRTest.QueryModel/Op=NormalizeL2.1_Type=f32_Shape=static_IR=3bfa35b53e4bb74a9e450b1220a5d3c061f050e498cf86c8f72118052b7fa252_Device=CPU_Config=() -233:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=static_IR=2e3f53e7b949e1dd0ab38890b0c9fc9e770dfb68569e37fa5cdd4e3ef03d6eb0_Device=CPU_Config=() -233:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=i32_Shape=static_IR=22a8f509c3f76bc2dd6bc9a26ec4ab92a5b9ae4678532c886c1438669d627323_Device=CPU_Config=() -233:conformance_Less/ReadIRTest.ImportExport/Op=Less.1_Type=boolean_Shape=static_IR=8cac1c4c51c2eb61b9ec75320814acf81b9ac240a88e1cc68f29541f6eb546e7_Device=CPU_Config=() -233:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=a3de81c04a0e7d5cab275045415ab4c294ed3270588c2ef704ab6db5514ed0dc_Device=CPU_Config=() -233:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8ec74565f16a2ee1e322b4549ea19aa0b30719787abd90bd957e121705edb268_Device=CPU_Config=() -233:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=6b2c79edda9cc9cce61c98552d6a0d3a3555c9ccac3a56c6692f536a0abdb61e_Device=CPU_Config=() -233:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=68c6351cbee22a4783b3c592f69eea3778c17594c48972d5d0d1e9d728f5b47e_Device=CPU_Config=() -233:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=c98e1e2347c7b6939804dfcfcebbbd57d4c05e8d13b35b2611912290d06107ff_Device=CPU_Config=() -233:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=9c6d5cdaf19c92d1f994e4ae6cfdecf5a9ff04e47a2e0e68f3a08ec8f6e74479_Device=CPU_Config=() -233:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=55c7f63e25ddf106ebdab6f4eab66f1be6950cf7a68abdb5b7e9a395d2fa6add_Device=CPU_Config=() -233:conformance/OpImplCheckTest.checkPluginImplementation/Function=RDFT_opset9_Device=CPU_Config=() -233:conformance/OpImplCheckTest.checkPluginImplementation/Function=Mod_opset1_Device=CPU_Config=() -233:conformance/OpImplCheckTest.checkPluginImplementation/Function=HardSigmoid_opset1_Device=CPU_Config=() -232:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=43e58b152a871421132d25894025e9f4e2b5294f4b22923ca549bb0f2b8ab50d_Device=CPU_Config=() -232:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f99a212a117855e6e2dc4a338444a8ecee441f989638f7a0700ce24e037d29e3_Device=CPU_Config=() -232:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=134ff6b704123c583b694d7023c99cbcfd10a1afc48819ef35b46dc4d0bca500_Device=CPU_Config=() -232:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=136768c6c28210cc47eacf6667103eac8106e3f255618e067d351cb700e62cbf_Device=CPU_Config=() -232:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=8b8efa859c54f9cf2200c18953de243d469d2f04bf38ba5f3efe441de23ffe45_Device=CPU_Config=() -232:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=5d791fd5b82a74a42073567349728035c4ac52ea64c1a154a73bd4e61d1b42dd_Device=CPU_Config=() -232:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i32_Shape=static_IR=683b86794b415f893e4d426a8c68aa38f46c250e4c31bc5f5807a86c20ffb34b_Device=CPU_Config=() -232:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=377acd11b0f7dfb4f3e57baec8a6c8a84737857b7e794614542f139982feaf73_Device=CPU_Config=() -232:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=ed75de35729f20a3285506937672f78d2d5137851a3043d15f4eafc040768fc8_Device=CPU_Config=() -232:conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=i32_Shape=static_IR=5b9cbac8797158a77d5616e8b7e5d8132360e23e26d31d845f0d129df7bfd7b5_Device=CPU_Config=() -232:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=8108f6881c436dfa59a0c27d173054c885f082306ae5af1694cdede13718bde2_Device=CPU_Config=() -232:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=a0cee5b220a433f1d76460a1f452bfc26aae12f7b84983a063605b4a8cd0a5d4_Device=CPU_Config=() -232:conformance_ConvolutionBackpropData/ReadIRTest.ImportExport/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=3d20de7392465c055c84dc20d0af64ae6d14809f5a6e4bb05e315a2654066f93_Device=CPU_Config=() -232:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceL1_opset4_Device=CPU_Config=() -232:conformance/OpImplCheckTest.checkPluginImplementation/Function=Maximum_opset1_Device=CPU_Config=() -231:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6d71ec3285f12c65001e4396546f6c8c02215560675397656d85777f0c9c2644_Device=CPU_Config=() -231:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f5a74749f6c90dccecbb5e4a7d0fee72cca6247f0084487b5ca7d94d098c9b9b_Device=CPU_Config=() -231:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=87baad85c649084e386ca502375581e9dc47c68c076bacae5e5ac1ddbaaa7830_Device=CPU_Config=() -231:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=i64_Shape=dynamic_IR=84a8c7a897894ee6bb1c03759bced74ea6d773a2cb8335efdc8d193a534f3833_Device=CPU_Config=() -231:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=i32_Shape=static_IR=a142d6fb0ae0c0decec2ebeba376ed65852e1c60b1c1abee7bc574d5ef3a6a3e_Device=CPU_Config=() -231:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=5aa10dbbcee8d7434796180d5fbe8f0a954b772c441c8d6046439c615d3b9011_Device=CPU_Config=() -231:conformance_LogicalNot/ReadIRTest.QueryModel/Op=LogicalNot.1_Type=boolean_Shape=static_IR=66b8769b499fa31cfd7545411d16a17b04e1a336bb63a7e907707cd170a30fc9_Device=CPU_Config=() -231:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aaafa4ff22a5fcab1e6e0f48065210ff790275fba7a5c16602aa4a00951a8cb8_Device=CPU_Config=() -231:conformance_Abs/ReadIRTest.QueryModel/Op=Abs.1_Type=f32_Shape=static_IR=083771171646a2eadcbb3384bd457e04d74ce8ea771813cdf67c56f7bbf20c69_Device=CPU_Config=() -231:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIAlign_opset3_Device=CPU_Config=() -230:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4722375e4770c972f87bc89a8ca16871aa57251a9c01ab2a14adc11f885cac91_Device=CPU_Config=() -230:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=6a9a72aca963de945d97658e484453191cf6af26cd6838c1603299aff3a49a8c_Device=CPU_Config=() -230:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5bf1e9348ae0ec7106a2231d8940acc74464f5ecf0cbc6a682defc3a9bc5c2c2_Device=CPU_Config=() -230:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=static_IR=4892263cb1ea7a434b5771aa16f07885c39710f67fa1411dd9235653a6b8622c_Device=CPU_Config=() -230:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=03c3e6567da3c139c19e0ce0d301a6076b2e2446d191216c7bf38bc030ea7855_Device=CPU_Config=() -230:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=7201a55d869ac6072af38ff89dfac3cfd2e6720d25f7607c6cc5f80040a8e82a_Device=CPU_Config=() -230:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=() -230:conformance_Log/ReadIRTest.ImportExport/Op=Log.1_Type=f32_Shape=static_IR=038bd1e152575a3b8ca28bfe18fdcc9cbf19c9489e7bb831b9d5f56f7499cb7c_Device=CPU_Config=() -230:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=57ba21d45369359487dc3b6a8feb0aa2b6fb21ffa328dc8e8eed58ee2896fdad_Device=CPU_Config=() -230:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c161ff64d4c506fdbe44d0ee76042f958f5dfce778833653628a026de01a3f9f_Device=CPU_Config=() -230:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=ea860537d420b0d1afe0ec9a10192912ec59d8f4ba01b27add362ce50fd6b380_Device=CPU_Config=() -230:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=d673fdf688abaeaf4cc6239ff762f8df557ab445bf9f031ab3bd87782717f2ef_Device=CPU_Config=() -230:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=b2dd13c363e41fef66b0dcc3e21e77b9a97e413c1c89f8c8a53179b05f01c2cd_Device=CPU_Config=() -230:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset9_Device=CPU_Config=() -229:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c777366b6b37df3f4a3b19b637f66b707fbbb113972a9eff7eb4d793731f8c9b_Device=CPU_Config=() -229:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=7dcfe3f43645f6b9f3290b524024a1a3d48efa3ce346eacc2330be7e27a046fd_Device=CPU_Config=() -229:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d7a96943c0264427eb83ab413f6e7b0f15f09f83525de581fba582655d0fa4af_Device=CPU_Config=() -229:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=08b46b9b2881764fde87811d2462a361d75c30fcec74f631f116f010953daced_Device=CPU_Config=() -229:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=a7b79789ba2466daa67ce8610753fbd89a2ca372d65e2326802c24cce03f795f_Device=CPU_Config=() -229:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=b0e3e542180f521cfd4651ae18d3a58962751d3c6de9265240be6d4fe9745bf0_Device=CPU_Config=() -229:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=be720054cd6d960249271114344ef2f4f36e2a2208376df70d4395a82386dd01_Device=CPU_Config=() -229:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=99377bd11138d36797502d82ac9adddc31dfe1e4cbb8bba8684b1479f8a16f26_Device=CPU_Config=() -229:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=c39d76c89bb03fe251dfffdd9b8eb85c0585904ed9c5bb4660c3dedfdc451efb_Device=CPU_Config=() -229:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=7ad5da9c461223f21afd023e08220eaed788598f50e144e45fcdf3466c0810a3_Device=CPU_Config=() -229:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=db85fabcfcf049a7225468036e29c949eb779253ba145485205596e72cb8cc7e_Device=CPU_Config=() -229:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=d246ad7201844e04821cf31a7d0650c362d6684da5e02f625d28b1afc3789127_Device=CPU_Config=() -229:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=769e7bb56fd0d0fa75fed14765279f68841e300b1450909cdcc802d347446b52_Device=CPU_Config=() -229:conformance/OpImplCheckTest.checkPluginImplementation/Function=Broadcast_opset1_Device=CPU_Config=() -228:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=64358a022d0c072ff89427a2f3acd3a3afb49b8f76e57353eb95962fd2572ca9_Device=CPU_Config=() -228:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5ba879b46e93286e4c880a726e28d6956a1c8415508733b5349079f899462679_Device=CPU_Config=() -228:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3ebf4d995c8af299693b32b6adabb6a261a3761137ec6c5e68b35bdf0942bd85_Device=CPU_Config=() -228:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=() -228:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1a29918856ba0f88e99346fda6e6c21ff2bf129f5599d8a1c8611346ab41f2f7_Device=CPU_Config=() -228:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.1_Type=f32_Shape=dynamic_IR=7cb8f8f3f3b4335221f85190d4bc29dd28a6b99133ab630a5ee04640af0843a0_Device=CPU_Config=() -228:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=dynamic_IR=0b30cc6cee9ce5400085a0e78b44763bc169eeea93357f22fd716564f20226db_Device=CPU_Config=() -228:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=1c6447222d58a16595cfdd8b216fac2cb3f005d2b236a6526ef5de8e272e4847_Device=CPU_Config=() -228:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=823c1bd1ce8ee0ae28410bcea9f3c33ef9f9271e8f41f0871a7d6eb6b2850757_Device=CPU_Config=() -228:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=i64_Shape=static_IR=056c07f9ad8e27e01b269b5136ee29b4cb4d1229a009cda07e4fd32c45d4e97f_Device=CPU_Config=() -228:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=966eae58d5c103f24a598a5143d7b3a3c40a12fa2606a65431f0d1aef855cd32_Device=CPU_Config=() -228:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=dynamic_IR=e894ea68d25e2a0af6fe2e330929c3305710bd07aca8e099b727df78fb26cdf6_Device=CPU_Config=() -228:conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=static_IR=d05c1b7fcf976117a23e0284998d9ce21689411ff24530175787f1512ca25879_Device=CPU_Config=() -228:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=4fe95284f224758c29c5198a8b2e6f97e8e737435d36cb94b9cdf0bca3c89dc1_Device=CPU_Config=() -228:conformance_FakeQuantize/ReadIRTest.ImportExport/Op=FakeQuantize.1_Type=f32_Shape=static_IR=48256cdbf5a3d19f0b7bb6b0540cbd664a36885a88fa8f5f56da7057de97a608_Device=CPU_Config=() -228:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=00d6c2465c4fa7ddab80d30c2fd8099a684bcc47cf9bdba89a39560beed737f6_Device=CPU_Config=() -228:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6b87ee29001d1d3b17ec72a66638e954796b7d6ec1d6f6be86890c7d5a3bcceb_Device=CPU_Config=() -228:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2058548f687014df36b4da1b2644f07fa117d5a1d303a13c4d913a3f979d3ed6_Device=CPU_Config=() -228:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=2f7925a034999529ce07a5c8bed2b2c7aeeb7936f74730d9c8ca5a5086dea4cd_Device=CPU_Config=() -227:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c5637c5151109c002830514b8b1450092dc52df14146ecee467dc54469a77718_Device=CPU_Config=() -227:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=bea169459345470ab5d89e5ae9a8b67d6e9401caf7dc35f5060805152e20d6cf_Device=CPU_Config=() -227:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=fa88ad79fad41544d799f0333f83b91322f2bb408689e27e53bd175786ed0979_Device=CPU_Config=() -227:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f0af28fe49c157f5f62f72f0ab209c50aa07d97c65477217fde6e3a3d0dc98ef_Device=CPU_Config=() -227:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=dbee34cd3b708559af1ceb5fcf89aac35add00fc1b9e3eda2beebb2d5b629fc1_Device=CPU_Config=() -227:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=f32_Shape=static_IR=136768c6c28210cc47eacf6667103eac8106e3f255618e067d351cb700e62cbf_Device=CPU_Config=() -227:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=45bae87afb2c7e7f0b7315334e33b8a9baf42d81b95b844cb4987dd3540f1dff_Device=CPU_Config=() -227:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=168e02701204a8f0e325fa1a2a4407612df10c3218c9431981fa6f1f8300eec2_Device=CPU_Config=() -227:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=i64_Shape=static_IR=68115f3a18f8ea201078166547e9c2a8587a5bb37646adf6f90da976f7298386_Device=CPU_Config=() -227:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=i32_Shape=static_IR=a142d6fb0ae0c0decec2ebeba376ed65852e1c60b1c1abee7bc574d5ef3a6a3e_Device=CPU_Config=() -227:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=f32_Shape=dynamic_IR=fc75aba0dd172d6628de0b473569c672b52f070ac3c446cc3342cb1184ef076a_Device=CPU_Config=() -227:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=e4baf41ae9a77441993eb0f95c3d7335e9a719e5eac8b1ffaf60d8f515f769a1_Device=CPU_Config=() -227:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=e14dc7fb2cf0b63fd08f616d407511ff2036109a3e105dcb87398053d1c334d0_Device=CPU_Config=() -227:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=84f6f3544adcc7c68df5ca411844cf36c2232c1b6c820094e5693a444faa143d_Device=CPU_Config=() -227:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=45e4a607b0964915174f6a14de049a61a5740f258a4a71817e5aae1b93be5ae7_Device=CPU_Config=() -227:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=ff96b044b0064dcc13dc7c1d80f2b2cddde0ead8c4501d5d741034833079d47b_Device=CPU_Config=() -227:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=08cdbd5ea904a12dde32bce43e6c512aacd0ff990d5df3a90ff625226c936edd_Device=CPU_Config=() -227:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=c8ec200fa8fd8ec9c185d9d45ee1380be5e0e4a6f3157e5900401e9fce999553_Device=CPU_Config=() -227:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fb83c1c4a2ce0a8860479916f23f3961a5c20481e62de79390573dd7859c09f0_Device=CPU_Config=() -227:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bbb0129fbafd6d1874ccef37a1bb60379733012c502d58326dae70f413e387f2_Device=CPU_Config=() -227:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=150b1e03f5e8abf76f88e68ae56a3afc3cb3ae110fcb12af35192aaf93b20f5b_Device=CPU_Config=() -227:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=7244cd4799e0eab987f823edc7d6038b76afa7585e4663278be826124c5596ed_Device=CPU_Config=() -227:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=13e9472dcdeb5e6ce2928191ed13dde08b6cdd62c82c94e77469d8a3ed94e39b_Device=CPU_Config=() -227:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=cccecd6fd3e8f3d84fb98f219b212cd2b55ae0e4e34c099a25a1028e9e2f83e7_Device=CPU_Config=() -227:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterElementsUpdate_opset3_Device=CPU_Config=() -227:conformance/OpImplCheckTest.checkPluginImplementation/Function=RNNCell_opset1_Device=CPU_Config=() -227:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronDetectionOutput_opset6_Device=CPU_Config=() -227:conformance/OpImplCheckTest.checkPluginImplementation/Function=Concat_opset1_Device=CPU_Config=() -226:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2006e1eaa808a3e78550535058de54c5cd83e9a32a52e488fef1f7883c321a3_Device=CPU_Config=() -226:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8fa841d409e36b6665e289f4963330eaff4124d5452c93b75d779937cabe14d8_Device=CPU_Config=() -226:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=f89eecd15ff45d6929f82696f96a68adfd694043ec3f859952d80080bd140627_Device=CPU_Config=() -226:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=3866cad522b1a4da567b64df204a69863faf25dd6e09f85dc5806d3101689458_Device=CPU_Config=() -226:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2acd53645519bc460dcc71923563fd462ed997366cc7ae08cb5a30245302a859_Device=CPU_Config=() -226:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=72373e9c2bc4cdf2f0aa0a5d14e30ed1a5e0545d9a96f4ab675f3b9dc69d8cf4_Device=CPU_Config=() -226:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=8368b4f6e208aa4cfbf0aeaa648e9408c281a71d98d15ee09407d26274fb349f_Device=CPU_Config=() -226:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=745c0804609863998b4bcc6956b1e78fc221e0e4f1535ab09b89a9c966a16995_Device=CPU_Config=() -226:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=e08e84b17997c1b1279429161d287720e4c7deb0e6d055539149bc577ed3b104_Device=CPU_Config=() -226:conformance_NonZero/ReadIRTest.Inference/Op=NonZero.3_Type=i64_Shape=dynamic_IR=31f428e60ddfdb3cb3c98c2cc858d0409fd35c5e6e97f9dcdfbb20a876c475a6_Device=CPU_Config=() -226:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=df085870336c57084e22afa8b52ece7149abc21b5d1784965a7d36d5ada91e8b_Device=CPU_Config=() -226:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0d782801290370c7c390ad549171ec3500ab344b8b34ce4b8fd8b05339fe5557_Device=CPU_Config=() -226:conformance/OpImplCheckTest.checkPluginImplementation/Function=IsFinite_opset10_Device=CPU_Config=() -225:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9403397dde8b4f6a240bdc928d0f080dfb42f6442f281d6b3fe8b6e348ccacfd_Device=CPU_Config=() -225:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=20af9ae4466332a072f3b04c1219146d272daabf2306b66c755980bfd31f2a76_Device=CPU_Config=() -225:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=978c6fe274296020718998393e7fe94bbe0a0856fc377aa474df0454534824a6_Device=CPU_Config=() -225:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=920aa0d732c7ace2bcfe73df0e7217e66b6388dce554ef827efa96f4e7d31a2f_Device=CPU_Config=() -225:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f2eb693da69b0ad1af3bcef6c4af46ba2b92897f76989c310a65aac5c2027725_Device=CPU_Config=() -225:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=254aa036653eace9f3faddc8f2fb69e04ba0c788a2070c054b4c9fc059d33845_Device=CPU_Config=() -225:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=dynamic_IR=2af646407076eafcc1ed2d628158fc32eac4ef2fb34fb967962c06f81376d61c_Device=CPU_Config=() -225:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=e6ee69f681f9388da19dc9c17781710c5622ecda436aa2d4b018578548acebc7_Device=CPU_Config=() -225:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=644274eaea5cff1fa9976380a2c024a8510f88826d0c1a6036aea3b18e3ecd8e_Device=CPU_Config=() -225:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=4420cfb7f4a734731dacfe5b0c27db41ccaac2ab8bbff56cac0f99ed96e976f2_Device=CPU_Config=() -225:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=00d924b3557896a41b0be32897f7b7293fcc44d79a285e91695a5fd2f29f3b8c_Device=CPU_Config=() -225:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=2f842d4b64513c6df5748c54a1166a3f14436dc1ca59b7a28530bcafcdcde2f6_Device=CPU_Config=() -225:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=() -225:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=dynamic_IR=c18d3d2fd8001cb07daaa5000258b36352807e3e81999d2d80a668e4d6add085_Device=CPU_Config=() -225:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=e14dc7fb2cf0b63fd08f616d407511ff2036109a3e105dcb87398053d1c334d0_Device=CPU_Config=() -225:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=776018866cd0a06171706794dcd0d7bb13b5960fd98a66b306ecfac7595feec9_Device=CPU_Config=() -225:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3374f930d0ffd26ccd7cb542638f2386ae5f803b5bdce4d848ba1e93b4a173a8_Device=CPU_Config=() -225:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIPooling_opset2_Device=CPU_Config=() -225:conformance/OpImplCheckTest.checkPluginImplementation/Function=MulticlassNms_opset8_Device=CPU_Config=() -225:conformance/OpImplCheckTest.checkPluginImplementation/Function=Interpolate_opset1_Device=CPU_Config=() -225:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherND_opset8_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a917525b3e5a37fc2be5f35fd5a3d50b57627cd9b985333e082b169c29f848f3_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1837f66989053233e19b617ab462b5c608981c0be175b57a2366fd41ca1a9fdb_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8042d30c9796e8eca03cb2e3651f84b5167204aaf186ad08ad5f74a9b0a26b9d_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=ac40c4284a523b39af21eda7394a11b9ca2f2deb5263c03c92c0e217d34bedad_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9257d329b4cc9eff8545270d1693734adac9ac4ee44dcbaa21c774287e84aadd_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=50c46a070e458a716446dafab20580095bfe902eeb4ad96c39bc2c617964c1d8_Device=CPU_Config=() -224:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=1f6be1a43c786bfbf35baad6ff643b762e9d63c069c884a69b4ec6e89062ad7e_Device=CPU_Config=() -224:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=i32_Shape=static_IR=f777fb31e1669cd58cc77e2a04c3f9a804b654b6d710432641a3dc34504460b4_Device=CPU_Config=() -224:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=8fc296db9f7dd10289217cb81cdf5991c6b5f3c89369936a94c8ac484702bfa3_Device=CPU_Config=() -224:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=c3ef1d1e09e7c0917298070d6909b455d5962c4bf3adf8d2d4c04f0741141f1f_Device=CPU_Config=() -224:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=15dd996f113d962d9bb21424d1006af0aa28376a2af63d791a80f0ab95a604fb_Device=CPU_Config=() -224:conformance_Minimum/ReadIRTest.Inference/Op=Minimum.1_Type=f32_Shape=static_IR=206184d6fe0a3ab9fe71914c66d3804e145caed7cf3ac09cb1d50183144d6ac7_Device=CPU_Config=() -224:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=i64_Shape=static_IR=75c36f65570966e7f975e5c839036e0e13fe30e6d24ce4be8e6a0e8449173951_Device=CPU_Config=() -224:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=8e098b9c129ab30efc257d55cfbc737d990d2ff0f7931039d3335c42d5f286eb_Device=CPU_Config=() -223:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3fb25dbf33700d0b8ebc3c53fe328f2ee9f45c5a090240eec120b954998d17ce_Device=CPU_Config=() -223:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=686b6d84e29d87a91c8177396d2aa5a1fbb88656c79e41af9a0b30b42805f477_Device=CPU_Config=() -223:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=0fcad2ddd1c7b81bf5e88ef4d4abb26a33326a37fb0cceb1205c1efd2a2d3615_Device=CPU_Config=() -223:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=dynamic_IR=8b79cf070ed44bdefd5afbe86a81199e189fa486c42190795419dbfc7cc26d6b_Device=CPU_Config=() -223:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=2ef8d38ce64fd0460d641e6f3bfcb1654bbe3d2c25f9dd244ae259eaa4b6941b_Device=CPU_Config=() -223:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=823c1bd1ce8ee0ae28410bcea9f3c33ef9f9271e8f41f0871a7d6eb6b2850757_Device=CPU_Config=() -223:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=() -223:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=f0edc45979b98d4401eea2c345bbcb794721dd3cdbfb3963be5a2842b27ccc5b_Device=CPU_Config=() -223:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=b06553539d6e27195623fcbce51610b5671dd70700bcf61703a1f7a8bbc7c5d8_Device=CPU_Config=() -223:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=776018866cd0a06171706794dcd0d7bb13b5960fd98a66b306ecfac7595feec9_Device=CPU_Config=() -223:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=static_IR=78239cbf0f8d473af2209ad3d9297e02208c110efa7af981f8c09ea7d7290032_Device=CPU_Config=() -223:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=f45b24f3bf21a2c94bc89cdc3d20c283d47f4e6ea386444897330e232bd7d90f_Device=CPU_Config=() -223:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=99377bd11138d36797502d82ac9adddc31dfe1e4cbb8bba8684b1479f8a16f26_Device=CPU_Config=() -223:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=2a3d6c0476c17897fd4cc6d3623519fc033ac4022a01fbebd40b461f414f6c15_Device=CPU_Config=() -223:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e2d2eef3e776af9379eb35540d8f4c888491082d8333aeb70f58822aa5cee878_Device=CPU_Config=() -223:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=68c6351cbee22a4783b3c592f69eea3778c17594c48972d5d0d1e9d728f5b47e_Device=CPU_Config=() -223:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fb9febc1b0984c7d6887460d058a75a9444bd1ade793c5b945c9b79ad2c63e46_Device=CPU_Config=() -223:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=8b9cabc6a44ece744453092791ef63b8d6ca4d83af7e8635f2f4ad78186e5184_Device=CPU_Config=() -223:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=0662f4c4f222a79755532ac9eed43118b2ebd0faf0fbb9b400f9047ca1071b5f_Device=CPU_Config=() -223:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=5be0b1c69be525cbddd7996b695c1a4a9f380173d03f291e8570df76c050678b_Device=CPU_Config=() -223:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i32_Shape=static_IR=a7f6c704686f1b0e6fd4ab522930aa3fb5b4cd4683b204aa31e5c73b427e7058_Device=CPU_Config=() -223:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=29eeefa6ea54ff2530e2e17153db324026e85d4e45432c053ca066699187bbc5_Device=CPU_Config=() -223:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=281f1852405ad37d0606184e81d8534d769f50b3fe99f5f17ebfda6954f4a584_Device=CPU_Config=() -223:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=1e95665a92aa6efcc7e06d24fbe4cb2afa07d75374cea3ea928658a270ef489b_Device=CPU_Config=() -223:conformance/OpImplCheckTest.checkPluginImplementation/Function=Interpolate_opset4_Device=CPU_Config=() -222:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=61f6b4fbde686888b82614a5d24cac53e835377c4cfa791ace3f3cd3f8ac2dd8_Device=CPU_Config=() -222:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3f87262a458b0dd0a330ab0cfc48c74ee687819228d3e2e1226df3b02de26afb_Device=CPU_Config=() -222:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1d52baa348f922bf85866fbfaa488c1ca33e01f0b79bd6a25fb430e8b7fc8b06_Device=CPU_Config=() -222:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=caf20ebc8d39cb23a107a03e819e8ee5b2807fbd311fe65453446251e4b6a611_Device=CPU_Config=() -222:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=cc2f28d736d3c67fdd13fbea9b8cef7c0b075f06b37034581fc732966421802f_Device=CPU_Config=() -222:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=57c57d85bad2b76d3d65d88baf2b3677dca6e5d534121e87efd618efbe5b1547_Device=CPU_Config=() -222:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=f89e84d6fb931cf0cd074acd01a50e50daa47ad88b1b74e4b3671d63bd7889f2_Device=CPU_Config=() -222:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.8_Type=f32_Shape=static_IR=b94d2ed6a2b113922805a69578ec5ba2ba3d8f0ea46ca37f095b4ccc94d76b77_Device=CPU_Config=() -222:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=u8_Shape=dynamic_IR=81bbb9658ad214babb825fa4b576aa83a9ceaae7dc0b878a84e42ea194f3ec13_Device=CPU_Config=() -222:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c87c002bc627f4adfa58547da4c2b1f270e07e9961a1b4ae99dda72d88980550_Device=CPU_Config=() -222:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=3688e2a973219245d05c5fa675cebe9036d40777809ebf583c1bae9b9f87eed6_Device=CPU_Config=() -222:conformance_ReduceMax/ReadIRTest.QueryModel/Op=ReduceMax.1_Type=f32_Shape=static_IR=a3b350b1516cb0391e088317ea67433757a08847710c4a4bff143922873208df_Device=CPU_Config=() -222:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=5fd7b424cb32653589798a45526ac4b3f3aafd29a58e5ed1cef16a958fd4a859_Device=CPU_Config=() -222:conformance_LogSoftmax/ReadIRTest.QueryModel/Op=LogSoftmax.5_Type=f32_Shape=dynamic_IR=a3f02c85607891ecc34c484b433c6a78333e13f3d8cd231e651f8bec26e7d0ce_Device=CPU_Config=() -222:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=de46537615051a46fea66871c5fc6ef3417b577ce42bd1f7e239d821e1ed5c51_Device=CPU_Config=() -222:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3c7d4160bf883d550620e8d1ceb54b3d78bf1512388b5ee57e1a380949d441e1_Device=CPU_Config=() -222:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=a2450d07c12669e586815e60d9a2b568f88a49c9b63730c898b9eae907b5ec4a_Device=CPU_Config=() -222:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=86fb2ad636e51f682c83919d64217835cd9ab458695e3bdab295c4107516e733_Device=CPU_Config=() -222:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=750599c4cdfcbe7468328647a8760c7249a9f5dba8bc33ebd00c151d9f3b13f6_Device=CPU_Config=() -222:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4b00183255fde45d5c3b815b552e5a4279284bfe1ceb31389560260ad5546c14_Device=CPU_Config=() -222:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=d46d4fc3e7b3b2cea07f7ba710f77f7d99b4799e7fb0d3127ea6862f3f731ae9_Device=CPU_Config=() -222:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=b99ba096eea2f3725fa98eabc2a941fa895c0a58bcd7a8ea68d2a245ce913113_Device=CPU_Config=() -222:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=eabe482de99e120ef1260cc91a746df95f8db04fa1cf6832dc45b3ee1b38f9c5_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e27641fd09143d736ece2166cc3156e80c190d5def706b86358f49fe980cf9b7_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d46034925bf5b01e31b5a57911fe30f5dd09a8712432312fb1efd844e69913bf_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c3e5791580edfc2b522c8a3aecd33445b3fa8d771e2b5a8387ef0f303773c848_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9efd5749a1591709057d6e97334c9b5b89f5864d705c91774e0196d42966d1b9_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7efae3e9c1a0419670b3967f8b2dda53fb0200f946a3d529b8da235ee14690ff_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=254aa036653eace9f3faddc8f2fb69e04ba0c788a2070c054b4c9fc059d33845_Device=CPU_Config=() -221:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=b08690e29e0249d5a6a30f2ad886ec714067df994bc4d8cbd82d0d02af6335bf_Device=CPU_Config=() -221:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=5f18fb02adfd683f379dd5a15d38f01cf744e6940754f6a40e2646a1d9c97be8_Device=CPU_Config=() -221:conformance_VariadicSplit/ReadIRTest.Inference/Op=VariadicSplit.1_Type=f32_Shape=static_IR=fb8283ecd8934dfc5340a41e9889a0a760b39869e4873efed4ef85606c162ce7_Device=CPU_Config=() -221:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=i64_Shape=dynamic_IR=84a8c7a897894ee6bb1c03759bced74ea6d773a2cb8335efdc8d193a534f3833_Device=CPU_Config=() -221:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=81313f6065af987d98f37a1709f149d804bc1a36bb0a5c4a11223b29c6ccc3d2_Device=CPU_Config=() -221:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i32_Shape=static_IR=e256f7acbc71e64cab857fb6378a035096c7ceebdd4f867b5140d35865cf6532_Device=CPU_Config=() -221:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=f802331401875cb16be10c9f752520406437b2e63a50e022b7d95b732e5296f2_Device=CPU_Config=() -221:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=b94b5361ee75b3684455c2b871b656a50c72e325564787c302a714f222845b26_Device=CPU_Config=() -221:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=() -221:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=f097978a7f18dafc7577a9dcf2306d82d397faf1bedb106ca3de70b3d9ada557_Device=CPU_Config=() -221:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=98274ec3fc894754adaacedf83b4b7da373e639a51cfa7dc348412898e45e8dc_Device=CPU_Config=() -221:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=e2ab1cf295df4df47d43e632065bf8a48fa58e6f3a6d1bc971b45fe97a66652e_Device=CPU_Config=() -221:conformance_MVN/ReadIRTest.QueryModel/Op=MVN.6_Type=f32_Shape=static_IR=2a9ba5f3e5a74f05be93e288553139a15242f1500e1eca8317dbd82ee8cf00d1_Device=CPU_Config=() -221:conformance_Interpolate/ReadIRTest.ImportExport/Op=Interpolate.11_Type=f32_Shape=static_IR=66bf131d73ad3116d698e15ac3c9e48bde66e096228138eb865c0807295c0d4d_Device=CPU_Config=() -221:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=c843b49e26b9be555df454d4c63f0bff72e6ce29d3ae80e9193741500b08f424_Device=CPU_Config=() -221:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f069cbce6f4c3276869b6d9c4a6c843d7a1e1c9d299e8680218636b04339a9dc_Device=CPU_Config=() -221:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=46282ba6f0eb5aac6acc1e114a2408cc301300a027c6d7a05691928b5e6dd9dd_Device=CPU_Config=() -221:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=7e1801bf4ef7ad1b27663dfb399f318ccb2526e925d48e3d30e2ab837824b217_Device=CPU_Config=() -221:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=cee58d2e3f2d6ef0061c5b245a15c60f0a26a58474c015f71dbdbc0c171b2a8b_Device=CPU_Config=() -221:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=f64585bfa3951a93f76c18fbc795f3ef82176e270c9f37161bdfe48e094c1d39_Device=CPU_Config=() -221:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=3f0c39b97aeab67748bd4039950e926a9d9f33b6d3261c4d65d048500adb5b7f_Device=CPU_Config=() -221:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset3_Device=CPU_Config=() -221:conformance/OpImplCheckTest.checkPluginImplementation/Function=I420toRGB_opset8_Device=CPU_Config=() -220:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=34784838e98e93a6b024109ef3a8a5d4e1fc7f89b98ca23c81cf085f19acc663_Device=CPU_Config=() -220:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=356e2a728749d3970a85939d23344315d0ff533567c35a559caa3bef173b76f7_Device=CPU_Config=() -220:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=1a9779319a9cc5f21b6005ebb9b4517e0bb1f868ef8e568453a58c44474c40bf_Device=CPU_Config=() -220:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7efae3e9c1a0419670b3967f8b2dda53fb0200f946a3d529b8da235ee14690ff_Device=CPU_Config=() -220:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=d2759b52de5dc9f1fa494c243d08ac40cf4e877c51323d53dbfa02abc1564e45_Device=CPU_Config=() -220:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=817b3db8f96297276bc70f1b4854867cb92c164925c9dce59a1d054e3c315bee_Device=CPU_Config=() -220:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=3638f7714d7627d7536ec02891656e512fee1ec55d59bb4f68c7409ad82f3879_Device=CPU_Config=() -220:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=1696523c5dd3a701251583b9c9f29e43f852383cec3dde5a93e6f7f7cabf3398_Device=CPU_Config=() -220:conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=() -220:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=c4d1a1fdd0a336620be37a8ce7578ca0dd0c74f89fdb32ee86e7004792aa8445_Device=CPU_Config=() -220:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e044b25aa265a98dcd0a5cf5f7132fdac5f36074068dc2210e04dd4c459aad61_Device=CPU_Config=() -220:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=f73224b14c094974e582d3d903cc332f5c1da138368692e5d0be93127f1bf753_Device=CPU_Config=() -220:conformance_Cos/ReadIRTest.Inference/Op=Cos.1_Type=f32_Shape=static_IR=e5379d72e978c773e9be98561b316a64f76c6015608d87739211e7c0e8b7bba3_Device=CPU_Config=() -220:conformance_Clamp/ReadIRTest.ImportExport/Op=Clamp.1_Type=f32_Shape=static_IR=0662f4c4f222a79755532ac9eed43118b2ebd0faf0fbb9b400f9047ca1071b5f_Device=CPU_Config=() -220:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=0c6a844f626f6628628034d332ccb6d520e0447e4b616048c7efb516d0fd87bb_Device=CPU_Config=() -220:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=b7973bf8dd344289b971d9b47575d6793643f503e13bb83c4e9c2a2863570b7a_Device=CPU_Config=() -219:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=07849f3111a0f12a712cb0deb7ec9c4778e70120385bdff7f17c1af30e31062c_Device=CPU_Config=() -219:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=41d80c815a196293f7d22af59f5f602f7e4f11e06208a693b19743fb796b98a8_Device=CPU_Config=() -219:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=f0c4dee4dcd8f03dd599ae04d7dd6ccfafc4d900d052a62f232a5507ffc006f0_Device=CPU_Config=() -219:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0bc70791680aff885fa6a5903cea30fdb2386e7720403a8e6698362c5491a877_Device=CPU_Config=() -219:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=5bed52483d61091259db863ffcd3b09c190fedde5dac72edad6f1bf37230f344_Device=CPU_Config=() -219:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=deec30214c79ceb43a503bf521937a2bd554588775195d0e6302c521cd2b55ab_Device=CPU_Config=() -219:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=9c1e1b695646ea4f56a87b7e5a815c12856f718920e01e86ed78f2dcaf896a37_Device=CPU_Config=() -219:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=() -219:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=d6250086b712a16042ee74438bb61b89fbfaa5bae433049207402d1da4cffaef_Device=CPU_Config=() -219:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=46b077d7466eecbadbb7ceba5ed90724db3d9e216d22171f5dee02e44b9a5377_Device=CPU_Config=() -219:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=efeea353bf41d0aac1f5400e451346d6cb407610566018f368726328cafca221_Device=CPU_Config=() -219:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=30dd450fadb8a1081c1315cd0e5234728862b4de39b097a5a3248d551369b60a_Device=CPU_Config=() -219:conformance/OpImplCheckTest.checkPluginImplementation/Function=Less_opset1_Device=CPU_Config=() -219:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingBagOffsetsSum_opset3_Device=CPU_Config=() -218:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f729a1e882f1894319a357f6c5474552e883ae9322cc3dc399b3a292b13e6de4_Device=CPU_Config=() -218:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9991a1b4140ee8e6ed0460fb384b7729f681bc1068315a4d970eea59dcc89950_Device=CPU_Config=() -218:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3ebf4d995c8af299693b32b6adabb6a261a3761137ec6c5e68b35bdf0942bd85_Device=CPU_Config=() -218:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b0376bbdfc6560184c2eb15a9cff7fc6d6b39c47dd22936fb64629d345e227d0_Device=CPU_Config=() -218:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=a30154a78e0e565a598629670b87338d03582cbe4ed5547256634ddad7bc9d5c_Device=CPU_Config=() -218:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=8f7dc81bfce05ce39b694fe48197a4fd2aa7933c7061508be3b9dfefef518f75_Device=CPU_Config=() -218:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=a1862e486a20c8de71dd94c12a157098ac5f222ba8ba3e1d3edaf9362331e185_Device=CPU_Config=() -218:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=424814fbe4a3ba7a49c506f11509c035212fbdf4ef44fb2bc708c5f201e4e1ec_Device=CPU_Config=() -218:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=510b36fcb991c73abd98b488eff26715dde08a322b7b9429cd897dce6976dab9_Device=CPU_Config=() -218:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=be59de0f93d8a22736d98d0aab618839905eb9a04f79c8d88d7ef08c7267f4ec_Device=CPU_Config=() -218:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=962d8a421369e4dac96b6d89d05053f63c9e5fc8b7b82a60c922432125da80c0_Device=CPU_Config=() -218:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=739517c4c613063fc5ef734443f0a599400dec31cd5a56686735f3165b2dc2d0_Device=CPU_Config=() -218:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalAnd_opset1_Device=CPU_Config=() -217:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cc5e06594accd8694073f3ebe702319fe0711c3b7d4db5e06072d83eeb7cb096_Device=CPU_Config=() -217:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=88e65a668c1bbccdf69927ed3926a7c273c97f72a7059d1d748ba6b0da8492e7_Device=CPU_Config=() -217:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f226723f90368b020cf11817ce0a39c002b9c30e07d16ac9297b7e574a010b0e_Device=CPU_Config=() -217:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2d886a31e22f61d30c33ddd300ba7d8ba1cd9796ee1a4f688db9126b1d8d9c83_Device=CPU_Config=() -217:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=847ce287888e882e988cdd5bf41277c32c207e38215e1e7d41439890037216db_Device=CPU_Config=() -217:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=f32_Shape=static_IR=c14da825d470c9141af0ea87eb82edd0866a415cb5ac59f1014c2ded35340201_Device=CPU_Config=() -217:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=0b603f9cb63e722122080ea36f76fe45b25da83b0b1e213871140e82dea5f405_Device=CPU_Config=() -217:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=727e029d6373e823f7500e6bdfd1c07ba87fdb3ba428fd0a089885d7a1e91552_Device=CPU_Config=() -217:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=6167830634e0b253aa78e883453d45bb737cd5df33c849e4b16b99164fd49d5e_Device=CPU_Config=() -217:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=2463ef4b8684fd6b391fca0b123328e1d695b47017fe94ffe5a419a3c22ce93e_Device=CPU_Config=() -217:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=96117baf3ff208c696a9796404eec467b613c37977067ff0cc62e39355856d30_Device=CPU_Config=() -217:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=dynamic_IR=33e67497d576ce6af4a214d55862646d034effd328ef5beed8d7b0f380b6b689_Device=CPU_Config=() -217:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=4d9f16ede014da56824607d45502439f71b57275c332fbf15c6ba2ec1496466f_Device=CPU_Config=() -217:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=e894ea68d25e2a0af6fe2e330929c3305710bd07aca8e099b727df78fb26cdf6_Device=CPU_Config=() -217:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=4946bdb7dec06c2bc8eae33d5903d6fa41bbf3654b13a0cb5cfa4af5a4720426_Device=CPU_Config=() -217:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=a6b0532b200874d6d1c57719b46f2b301c368ebc35042df00796dfb87eed618b_Device=CPU_Config=() -217:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=0b0005b038a938c698489da595fd89a45d2f685c831bc172d81b2afc09658dae_Device=CPU_Config=() -217:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceSum_opset1_Device=CPU_Config=() -217:conformance/OpImplCheckTest.checkPluginImplementation/Function=Interpolate_opset11_Device=CPU_Config=() -216:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=244310d1092f478729162ea9a4da5660b066ad7ca70a65d8a205cb03787eb73b_Device=CPU_Config=() -216:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=57c57d85bad2b76d3d65d88baf2b3677dca6e5d534121e87efd618efbe5b1547_Device=CPU_Config=() -216:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6903ceb67d029d79d90687340dee0204830d5df1f1ea6fbb09f14a6eca234739_Device=CPU_Config=() -216:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=478861c92198ee8679e3e43476abfe79906c4ead6ee80af975af365829822025_Device=CPU_Config=() -216:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4d569fc3e7d2fa1724c99fec62e4f31fb000a6f5c306273c404e2b449761feba_Device=CPU_Config=() -216:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=eca24a51b737307a94a918f4d03923c1e035a3379c73359515c63ff3ea98be85_Device=CPU_Config=() -216:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=469a63c5aee73bdefc9abdf8abd8413713c0b68cc098d16c193399a11c7093c5_Device=CPU_Config=() -216:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=a65e17fc28c74df4f3b1bad89635ccfc376a857f2d92ba646ca830b03eafab7c_Device=CPU_Config=() -216:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=() -216:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=5038017e90f931327d5159938d422b2afc229aa4d776a4ac80a946724fee357d_Device=CPU_Config=() -216:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=dynamic_IR=166d8442037dcf0469f0b14ab83676b30bce53edd79494c52a575e3744920c4d_Device=CPU_Config=() -216:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=155b8d9ccf06f4d8f9ada6024fbe66f39e4e6e96917c12d7ac02eac98c5473de_Device=CPU_Config=() -216:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=b9f9ac285915db9ef3e7437728695f2833d165757ffc81afb88242e7b471f434_Device=CPU_Config=() -216:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=2aa586a55098e1960c204572ca9704bb3b8b9a3baab5fcf08200594261f7bef7_Device=CPU_Config=() -215:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ed872c2ef0d35af97e7f9be84d83eee6d42f2fb279b71f4feaa1aecefb450a28_Device=CPU_Config=() -215:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=392b855febfc39fd1b2a9fa43270f58bae53e0d210525e8700edc15a10d28d33_Device=CPU_Config=() -215:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=88e65a668c1bbccdf69927ed3926a7c273c97f72a7059d1d748ba6b0da8492e7_Device=CPU_Config=() -215:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=28cabba0fd0acde452552a362925344e8cd8c5af033419d83041bf26b1d14d69_Device=CPU_Config=() -215:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i32_Shape=static_IR=61760c9c95110bf88cbfb8aa09378cc214d4cbbbd6c39c98feec1dcfbb7d47fb_Device=CPU_Config=() -215:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=dynamic_IR=0b30cc6cee9ce5400085a0e78b44763bc169eeea93357f22fd716564f20226db_Device=CPU_Config=() -215:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=966eae58d5c103f24a598a5143d7b3a3c40a12fa2606a65431f0d1aef855cd32_Device=CPU_Config=() -215:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=6b2c79edda9cc9cce61c98552d6a0d3a3555c9ccac3a56c6692f536a0abdb61e_Device=CPU_Config=() -215:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=b11ede8f1aee40577413d8bbe89704e02252e3f02805fcc0ded624857ddb8280_Device=CPU_Config=() -215:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=66375ff8539da6387946c19b0d20e6b4fd57da25150255e41282458e241963a0_Device=CPU_Config=() -215:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e22e40a4f300567612f963b17707be4de09093cb9a248aed62af594e7986f7dc_Device=CPU_Config=() -215:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=65afcce29f554c2dfbbb4449ea6e11f1f1b9b96aa5c8bf73a55796de849b58bd_Device=CPU_Config=() -215:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=2001ebb8291c8bc8cd1db17c172f216cfb3994c57e344eef65565ea9f9cda1d7_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2ca34430931dd41f08f2b3cb8163ea5c1889a23b53d0f3b7d26b7a8af1acef3_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=62409191ca760efe019eed9d1923c8df9ab545d39f90b1230a58d1747d3143b1_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3f830d5ee243ca3f56d027f95929bbadd427e4954e286e6c890ddd60f9c5c2d0_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e7b65875a7e2d88532271dfb93a4a0fbe4c41963fee3193cb3de547c19121f78_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d9937a6c3eb62ad6328d7367f15e45758ce5f2ebc0488931855a5b1925574d36_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=d8441d8bc521ac390fb58cb882a952618ebf5892d40e8768a9051f852a9dcfc6_Device=CPU_Config=() -214:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=72eb2887828b5b14b41d001b6c7277d395f39c8003b9461730a938833899aacc_Device=CPU_Config=() -214:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=63de0838ea26e3575f49700f73fffb0d3415ab68b29b1a1da690b84f7a034822_Device=CPU_Config=() -214:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=dcd71a51a6682c9bc461a6cb72d59082352ab8a020e1f79e64c3cc44a37b55ba_Device=CPU_Config=() -214:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=c30414e8e845d75527c26f62880518cc4d24c1a528b20cefc3b2c32be7436c81_Device=CPU_Config=() -214:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=1cb2f17dcf4f8b738a23313501e9a98101169cd9e368f3fb98c552f994232073_Device=CPU_Config=() -214:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=e3a5a7f1a73793457fae9520ae122c6bbbfa92f1daac0ef214e47a2ec7ea18e2_Device=CPU_Config=() -214:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=2a3d6c0476c17897fd4cc6d3623519fc033ac4022a01fbebd40b461f414f6c15_Device=CPU_Config=() -214:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=99e405218c1a96c5f8af65aa814893d8958e8e991d1ed8dbbbd586efa589df39_Device=CPU_Config=() -214:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=66375ff8539da6387946c19b0d20e6b4fd57da25150255e41282458e241963a0_Device=CPU_Config=() -214:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=2737751bcc195e4aaa63ab6d86d803741817287d78fc864e18a31c328078940d_Device=CPU_Config=() -214:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fb5525d36d14f54eebc5670c06232ca4e32cf920d309b5777e37d3377d386433_Device=CPU_Config=() -214:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f43df065734a36674b3fdc7a47fddd1cfa5c1b36bf73e7de86a100c645fbc7d3_Device=CPU_Config=() -214:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=87a966d3d3b90cb32db3454c5dfb2f67af86b68a5e45fa1c5f4a75c3b5cb452b_Device=CPU_Config=() -214:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4bb7bd2471752f1a62dc15dbcacad87dd329443459a90dc6768b1a34fd00c064_Device=CPU_Config=() -214:conformance_Ceiling/ReadIRTest.ImportExport/Op=Ceiling.1_Type=f32_Shape=static_IR=fb5c74aa3b17b4a8d5e1603b9179b60bf3f0b8301c74a8fb632b6869896439d6_Device=CPU_Config=() -214:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=c5f54dc9ad0b693c13c07d44fe5572bd91852b0edd57f8f06314df3e71f3659b_Device=CPU_Config=() -213:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=aa6c3816ce7ce49f40be5edbe957468e80910a8eb5a3956f54d89fdf7c264b44_Device=CPU_Config=() -213:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8198512c1849e0efe931509147ac4dfed4ddc7ea8d0736a7defb4fce81e2ea28_Device=CPU_Config=() -213:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7d3a099a5040e70c73014df347c478d0976123d68b6fcab6bf767f90bbdf8e6a_Device=CPU_Config=() -213:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3f87262a458b0dd0a330ab0cfc48c74ee687819228d3e2e1226df3b02de26afb_Device=CPU_Config=() -213:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=8973f2f4c2be5d0ed57c94e1aed24bf809e51854c03c2abd73ea37ef7221d328_Device=CPU_Config=() -213:conformance_Relu/ReadIRTest.Inference/Op=Relu.1_Type=f32_Shape=static_IR=377acd11b0f7dfb4f3e57baec8a6c8a84737857b7e794614542f139982feaf73_Device=CPU_Config=() -213:conformance_ROIPooling/ReadIRTest.ImportExport/Op=ROIPooling.2_Type=f32_Shape=static_IR=1a0e3f63698678d2e6bb8968fbadc98227d9ce548e77c53021412d80d7711753_Device=CPU_Config=() -213:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=c18d3d2fd8001cb07daaa5000258b36352807e3e81999d2d80a668e4d6add085_Device=CPU_Config=() -213:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=abd733caa05592feccf41344f138de6625efce4afe605efeea57e0748d7b2e07_Device=CPU_Config=() -213:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e2d2eef3e776af9379eb35540d8f4c888491082d8333aeb70f58822aa5cee878_Device=CPU_Config=() -213:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=25ae6295f4d206fa9069e20bc659dbd87c20aaa15c3f149ab25d003641c738c5_Device=CPU_Config=() -213:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f13ce39b60cc25991465a0c02e27edcb35af0523cd28004adf6fd9acd8a5fcb8_Device=CPU_Config=() -213:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9360fbacf32f2208bd7f241535752ccaf434551d16bd8fd46d0422cd1cafc3c6_Device=CPU_Config=() -213:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8fdd77d8381b78b82c04360bc3f05a358bd690bd8204e2cdaa2c0a65bff61a41_Device=CPU_Config=() -213:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=319c7b312e9074a43819b034ce82eddf1c8f9e51d4eba3fbc7a112cb6393debf_Device=CPU_Config=() -212:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=dd575df40c907e85f7561296f2b1b5bb9786bf44bc27f26e33f235ba57391e26_Device=CPU_Config=() -212:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0b7d6fb137555d6fde92f0c9b3e6278715adaeb38cf760236070b17bafb5babc_Device=CPU_Config=() -212:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5295b6c6090a820891e5754c34d03dc3347d3436fa16fa4a701422ce8ac78b92_Device=CPU_Config=() -212:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=() -212:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=7c1b4dfda36336bb1a943fec9786d89e220f2a811159fe9cbed7d51186f8fdfe_Device=CPU_Config=() -212:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=7a1d8cbdb446c3330ed845d7a81e20d9b7c7662d532f4d816d4fc1c56822fa81_Device=CPU_Config=() -212:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=87c65c520de106b146e91222609f5b25cd79e96cdd6b942c3293cddb656617ee_Device=CPU_Config=() -212:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=static_IR=592176a8c97f4d759a0c6b3ef56c3610df4a0df4743f3be7ba3ed2ffb5dcfaed_Device=CPU_Config=() -212:conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=() -212:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=e1130d42d591780dd2a746ce7ff874a2bf4725ca9fd09803932ba4a7b0b389aa_Device=CPU_Config=() -212:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=4e2e2e9dd89aad4bc14634b85c94336a7250dbb8ff61cb451c9507753f54a102_Device=CPU_Config=() -212:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=e0422b2fb57587a85d9ce1532f7fc28a6bd01e72a325d42d9045419dda4bbba5_Device=CPU_Config=() -212:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d7e3ea8c5ea46f1b0430b6a2763c85395235c0ac58652e1d269e1257f6dbf7c8_Device=CPU_Config=() -212:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=94ad9524c175a0e0d2fe22bceeac82b0dc66006caa0942d343d551268e03afec_Device=CPU_Config=() -212:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=839faaa50aafa2e3ed38fc682d0759304b694043dac1a242a085e2973aac8091_Device=CPU_Config=() -212:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=d671a241de6d46bd5562def47a92602d2c9ba076568feed303765168433ee89b_Device=CPU_Config=() -212:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=6e6c053ee1974a5d036c6d549508f6d43586d501c72db05df9930639ad745bc4_Device=CPU_Config=() -212:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=f7bc08f4bc2edb455c7afc9cecba3666df1150bf4e3a67a20061714f867ddb0f_Device=CPU_Config=() -212:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=18d294f76a0d8f4562d85033a45aaa3f2d50fdfd9d9f30e295a772fd10540d25_Device=CPU_Config=() -211:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e6aef819fecf54f7c98b15f330074d33ea0ca6c8fc3edd895b362f04449b12a7_Device=CPU_Config=() -211:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=bca72a16df5bcf81d10dfbbb0e53aceb2a8a70ec94d4247d47333679de7214c5_Device=CPU_Config=() -211:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=42fc9a4f8909a26e98a1938054417339bbc3c21668dfa2792da78fa1ed8eb49b_Device=CPU_Config=() -211:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0e58762b5cd9926391cba6f63db3c7db49285b900ad0abc93b4d05d4baec800c_Device=CPU_Config=() -211:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=d51bc4204bb6079e79da8d0cf95ab8a3454c90a040aee0fc6fedb00f0795c577_Device=CPU_Config=() -211:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0d74ee98934e32799620ac90fd3ae8335bca026b9225782458949c64139d89c3_Device=CPU_Config=() -211:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=28cabba0fd0acde452552a362925344e8cd8c5af033419d83041bf26b1d14d69_Device=CPU_Config=() -211:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=b9581fac6848b0c6c9fc9af5fd17eca3f2f64832fb7205f97684f1cc4c1985f0_Device=CPU_Config=() -211:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=21950c433f50ded0f662b9e0591e756a8dd685bc11a8296bcacc57ca1a4968b4_Device=CPU_Config=() -211:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.1_Type=f32_Shape=static_IR=a4fe57973b0bba01e6038a8050f07b8ad1bf6871c1ad86270920f9084dc84905_Device=CPU_Config=() -211:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i32_Shape=dynamic_IR=9ec266d6550d7e0c9f4d6114272d7afc80ad822b0bf5078654598b3d623f356b_Device=CPU_Config=() -211:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=dynamic_IR=848de524e27e13a1e5b33e5db3cdf2710ba4566c3219a018e878f998c07dd718_Device=CPU_Config=() -211:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=0d413b2d40036984ce2b85933c4b5ffda416e8779a20b602095d2654db296d58_Device=CPU_Config=() -211:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=18697d690af0de3ff8365a5aafa6ebc7d8e14418c3ab5dd55b3b505d2445ac86_Device=CPU_Config=() -211:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=9f19f32ddff44c1c8f7dc3b9b244a9191a15fef9874e016666fe6a817937f699_Device=CPU_Config=() -211:conformance_NonZero/ReadIRTest.ImportExport/Op=NonZero.3_Type=i64_Shape=dynamic_IR=31f428e60ddfdb3cb3c98c2cc858d0409fd35c5e6e97f9dcdfbb20a876c475a6_Device=CPU_Config=() -211:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=28dbc474828462a812108c43a47aa4e70fa0d2e8e814bef5916092f3e8c7a2fd_Device=CPU_Config=() -211:conformance_GroupConvolutionBackpropData/ReadIRTest.ImportExport/Op=GroupConvolutionBackpropData.1_Type=f32_Shape=static_IR=3e893f54d0ed092823ca8e256e66c367f53e466f30573a7b5911a432d88299a2_Device=CPU_Config=() -211:conformance_FakeQuantize/ReadIRTest.QueryModel/Op=FakeQuantize.1_Type=f32_Shape=static_IR=48256cdbf5a3d19f0b7bb6b0540cbd664a36885a88fa8f5f56da7057de97a608_Device=CPU_Config=() -211:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=349d64660bcbb9269f88067431a4b8fc31fcfd09ffb1afa9f3ecf4bc37e8c4ca_Device=CPU_Config=() -211:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=6ddb35aeda2a6cb63282d2fcf6503aa02135ad60e23c752280ef82aaf6a31191_Device=CPU_Config=() -211:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=dabed23c3f30d92c6fcca7a6845160022837de8cbfa1077c222e6f1224b745e1_Device=CPU_Config=() -211:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=b2dd13c363e41fef66b0dcc3e21e77b9a97e413c1c89f8c8a53179b05f01c2cd_Device=CPU_Config=() -210:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=8c43b49d99c64bec883205ca15c7b2d9dbb47b9fe5140fedaeb8eb7220a36f6c_Device=CPU_Config=() -210:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7cfdc0a97fd79a5d272b29850c24dad4a0a8f147ea89b7683c98fa203a448c52_Device=CPU_Config=() -210:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=7c43bd989494b4ef0f2ca40c3b0c57b471d58b21491456e9588938f702721be0_Device=CPU_Config=() -210:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=7a1d8cbdb446c3330ed845d7a81e20d9b7c7662d532f4d816d4fc1c56822fa81_Device=CPU_Config=() -210:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6fefc3626ba6ef60433d3635bd5abeb3e7025277a86e2fd9d92234ff099c303e_Device=CPU_Config=() -210:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=2ef8d38ce64fd0460d641e6f3bfcb1654bbe3d2c25f9dd244ae259eaa4b6941b_Device=CPU_Config=() -210:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=i32_Shape=static_IR=201b881bba09ed67334d9489a1a8971e483120bd1cc75a1aa1c9f015f760e002_Device=CPU_Config=() -210:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7373e7e64fbb2fabed337c09be0d6b42c5cfad39b26d92c6dd74810499863448_Device=CPU_Config=() -210:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=6af32fc288bcbd414ea63525c4345aeda74ab21c44aab5910f85b8b7fb5d1179_Device=CPU_Config=() -210:conformance_Equal/ReadIRTest.QueryModel/Op=Equal.1_Type=boolean_Shape=static_IR=857447d7e14c7516667094409cf5ef351000344fe170570671be0f71834d04f9_Device=CPU_Config=() -210:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=45c9fd0289649c455939587c623f1884a4e675e2f970192d9ac2f60a65e6da9a_Device=CPU_Config=() -210:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0bc2bfc4481de7733f5503750d21376d00de6bfa699ecff3ee0c4333d9515db8_Device=CPU_Config=() -210:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=55c7f63e25ddf106ebdab6f4eab66f1be6950cf7a68abdb5b7e9a395d2fa6add_Device=CPU_Config=() -210:conformance/OpImplCheckTest.checkPluginImplementation/Function=IDFT_opset7_Device=CPU_Config=() -210:conformance/OpImplCheckTest.checkPluginImplementation/Function=Assign_opset3_Device=CPU_Config=() -209:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9e21c0af425c90066d92577a0b8aadb6e9fdee50c197b15eea040b89eb715a6a_Device=CPU_Config=() -209:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5d738cba54fcfd696b0cb7e808dd466b4510900ccba26c728b5eb272a55d6bab_Device=CPU_Config=() -209:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=104a69286d09ab8a5a88403ce6b421979659231fe5c5f973393216607a995dcf_Device=CPU_Config=() -209:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=1942042c790c3fc6053ad91fa5e45f8ebf3c11bff7e3427a71b8fdc1bc5db053_Device=CPU_Config=() -209:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=dynamic_IR=9feb072b58552898ff80a05dffe8f39c880b4f2a2382d56cb24a78e278ea1756_Device=CPU_Config=() -209:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=fe8bea06bc602fce2362c5c7671e3c8cfc63fee6bace0be9baa41e9874e86b26_Device=CPU_Config=() -209:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=7cfae687d408da17a0405d88f47e2b6623a608861114dc76018b8a2142453139_Device=CPU_Config=() -209:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=8216637727ccef527454bfdea7ab22ccd4e5e29709494bf96dde5af3b4a7eaaf_Device=CPU_Config=() -209:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=028177a440f430edc5dfd7a7f0f2c0dded422876a98b6da66a647ad9aca10e57_Device=CPU_Config=() -209:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=1c63f30ce7cb977ac945ee25eb97f3c472a81b999eacbcdd4b3bfd253f25cb51_Device=CPU_Config=() -209:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=cc13aaec2a2bbe9b760651d358622114b4b0a20cb106472bd8519f0fade61dcd_Device=CPU_Config=() -209:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sigmoid_opset1_Device=CPU_Config=() -209:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherND_opset5_Device=CPU_Config=() -208:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a48d232b00b4d4a735d6b9999c29b413a32cd7f05c104610a11cab01465a3887_Device=CPU_Config=() -208:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=822cfb44c999b67217c8fff1da18293fcbd3a8a71d901d95991ad6df22398af2_Device=CPU_Config=() -208:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4ef9d8687805658001fa7650e660620d74bab09868b356603c268bc8cdf7a5c7_Device=CPU_Config=() -208:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=461dc8aa282946831fdc86d1c024a273ac0f29f5ad615cd55b879feea6d23007_Device=CPU_Config=() -208:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2d886a31e22f61d30c33ddd300ba7d8ba1cd9796ee1a4f688db9126b1d8d9c83_Device=CPU_Config=() -208:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=fdfd59e3d316eea2f9fc3c56664cf1a07603bb6e26d1b367987d5046526ac60e_Device=CPU_Config=() -208:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i32_Shape=static_IR=fe8bea06bc602fce2362c5c7671e3c8cfc63fee6bace0be9baa41e9874e86b26_Device=CPU_Config=() -208:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=3688e2a973219245d05c5fa675cebe9036d40777809ebf583c1bae9b9f87eed6_Device=CPU_Config=() -208:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=f32_Shape=dynamic_IR=f550a37ab884668f47ed232e7119c2a2baa814c98fbbcfa3129e7a00feebde0b_Device=CPU_Config=() -208:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=() -208:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=3c7c072c9e4ee694e049a5f256cf0e72caf85384291ee8d399ce136d22c575a3_Device=CPU_Config=() -208:conformance_RegionYolo/ReadIRTest.Inference/Op=RegionYolo.1_Type=f32_Shape=static_IR=1cb2f17dcf4f8b738a23313501e9a98101169cd9e368f3fb98c552f994232073_Device=CPU_Config=() -208:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=01b095b8763565527be0de9edff565070949485db907493e99e95c2cddf6abaf_Device=CPU_Config=() -208:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=27e8804992c0d74c18c958f0876c06be6c7eda2b36fe7de3ab616b577dce13c6_Device=CPU_Config=() -208:conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=6e67522f2df32ac8e237fd4de148d082f3c55e6c31ace80cffeaef784dfe75a0_Device=CPU_Config=() -208:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7cbd5676618d9b507238807c281801b8a817202b0ae648a44cfa32fc16c02547_Device=CPU_Config=() -208:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=i64_Shape=static_IR=32ab4bca2ccc66d25b8b9ac449dbc58666434d98aa5b789e1aa28726c530986e_Device=CPU_Config=() -208:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=3d20de7392465c055c84dc20d0af64ae6d14809f5a6e4bb05e315a2654066f93_Device=CPU_Config=() -208:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=362638bf065f1917d2b4dac3008a8f46f8f8d64a80d2442c1ad98f4fb943cff9_Device=CPU_Config=() -208:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=c5f54dc9ad0b693c13c07d44fe5572bd91852b0edd57f8f06314df3e71f3659b_Device=CPU_Config=() -207:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ea604e7edf80c14a14bf7fcb042125f4d666d0d69ce3c0209c2f9dce26d406fa_Device=CPU_Config=() -207:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d4b1dbc565a45f6c9f60cd4a73bb15c0f9e05baadfd3acdcd5e133d782c54cbb_Device=CPU_Config=() -207:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=243d5b44a22822e90c2f6b7c2817f8110bd6a060331e686c1fde1869f3392db1_Device=CPU_Config=() -207:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=2cc50ee05a039bf65fd7be2282284790d9d2e1fabb4cfec509f5bed121152d93_Device=CPU_Config=() -207:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9aac77567d944de6632688fd3de80c0b3da1ee741da639897c2104d3121d690b_Device=CPU_Config=() -207:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=71c0c7e3176ae8b233352c89d47a61394cb46695e7879118ed02070a4a23d5e1_Device=CPU_Config=() -207:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=98932a2171e1c93b2bec3991892faaac027e1c319e91b9008ef0d0f469bcb0e7_Device=CPU_Config=() -207:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=i64_Shape=static_IR=d4acbcb1930b26610eaa33c0bb8aa7fd866d8142afda9fd007226f0ee6fa5c36_Device=CPU_Config=() -207:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=44dceb7343477ff50d3de4be1567a57a97d2e3c6f92b48fc93d20eea80487862_Device=CPU_Config=() -207:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=() -207:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=b81d993247e604272e6df01b8c4ba016be7f60263c892e8469deef67a8a6afba_Device=CPU_Config=() -207:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.11_Type=f32_Shape=static_IR=d507892556310f7fe85cbf9245ddf040b219ec8cfe9c779809180a011caab9d6_Device=CPU_Config=() -207:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=() -207:conformance_Floor/ReadIRTest.ImportExport/Op=Floor.1_Type=f32_Shape=static_IR=b064511ab38a9a70b4d203e11a12b990f388a03550ba98c65468be1b85c68fda_Device=CPU_Config=() -207:conformance_FakeQuantize/ReadIRTest.QueryModel/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() -207:conformance_Exp/ReadIRTest.QueryModel/Op=Exp.1_Type=f32_Shape=static_IR=67632b67a0834136cf2f3bcd6b3fbaf0d2f2bbffc1da6c33fd5fce0d0b8a763c_Device=CPU_Config=() -207:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=5980eb1b6c7a44c7812f89f10f0741e5925abda9ad07e1a82ae2a3310abae74a_Device=CPU_Config=() -207:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=8411c0432159fb60adefa760384515552240bc6220800a736556d7461765eb60_Device=CPU_Config=() -207:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e61665bc5590265246ab882bb55b9487e81412012ed98ac9cb16154bc8eddd17_Device=CPU_Config=() -207:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=785551399ba4bb8eb76271bf698b3ca795b8388338f110843d5c78c03009625d_Device=CPU_Config=() -207:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=07b257862a62290d7e8ae939147bb7422992528bf54209b8d1bff500b99b6f4b_Device=CPU_Config=() -207:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=550d5d475e0f53be8506153a78626cd5a5c0a949b9bbd9e2fea96a4ba2f7b908_Device=CPU_Config=() -207:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=13e9472dcdeb5e6ce2928191ed13dde08b6cdd62c82c94e77469d8a3ed94e39b_Device=CPU_Config=() -207:conformance/OpImplCheckTest.checkPluginImplementation/Function=IsNaN_opset10_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d8fc538fc2b9ca150eb22763e4c7416c002b5c7fa6481314201540178e940a78_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a4b3740eda9e6bbd3968dd39e6abb33b22a90a811298df6a761958216acb389f_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2f96ff03126561aa475067ad88e454b2da78fc8f0b816dc6c01ec5c81568288d_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=588ef4d887ae9d8ad432525108c81a9762dc27490a3e01d3e86795c73275148b_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ae538f87e4d49bbdc53184fcaa6082eee131a79b480dab9b46e12976d01ea913_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=90deb33b54746ec16cf8594f8aa0792c6aab2e27ff12ed97523da583402aad95_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=2ebbd25d315f10aa32cd8251ced4e269c1688202ee64b4fb5245e4ab53cba16b_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=2606bb36cbc87d845c9f678ac84e47c0893f0b86a3b675e70018d1e535234875_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=fc8b85b03281a7e8532a130a70fcfce5b6c40b1c8863eaea3910013a0bc4e769_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c08b3d30c1b4f1b5456e4791d4d7fab1d21f743dff0dac1ae5d09abc6764fca8_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=2435ff5e2ac06afcf99563821fa2a2a5e4a9456cb3f74154b3eb364a6f0e450a_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=() -206:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=42fc9a4f8909a26e98a1938054417339bbc3c21668dfa2792da78fa1ed8eb49b_Device=CPU_Config=() -206:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=a449aa561efb222cad1a414ee87443f9fec0e5c2f6220f6a57b6705c9ef26cd6_Device=CPU_Config=() -206:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=f32_Shape=static_IR=dbc3b2f724614a68d750ae4adfd7d8239c77ced05d30f89deabe272f104a5e75_Device=CPU_Config=() -206:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=u8_Shape=dynamic_IR=81bbb9658ad214babb825fa4b576aa83a9ceaae7dc0b878a84e42ea194f3ec13_Device=CPU_Config=() -206:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=e77dc4aecdbd4ab3d67fc3c1d9e350a9d259af1d4c0188d680121a31c6ed8ccf_Device=CPU_Config=() -206:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=491b849a7ce8fdb2190df5415fe037ff02fc23814efc520c343e872f539d6e55_Device=CPU_Config=() -206:conformance_Greater/ReadIRTest.QueryModel/Op=Greater.1_Type=boolean_Shape=static_IR=aed960e9b7608b89973346cc2ab23c7ff65e72275fa55daa8b13f925a3779701_Device=CPU_Config=() -206:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=4e2e2e9dd89aad4bc14634b85c94336a7250dbb8ff61cb451c9507753f54a102_Device=CPU_Config=() -206:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4a3c7edd1efc847f3d1255738c19cdaa682c9348c0b0bfc466ea9d5749d5eca4_Device=CPU_Config=() -206:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=b7973bf8dd344289b971d9b47575d6793643f503e13bb83c4e9c2a2863570b7a_Device=CPU_Config=() -206:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=dynamic_IR=c3d754fe46cacaaf519f39fdc6feb9df6b23d92f6271f6e731c2a8ddc24a948e_Device=CPU_Config=() -206:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=b92112b2ea2f233a6fb6ee512363082a49db0f85ab23f89dc29ad907e6ab408f_Device=CPU_Config=() -206:conformance/OpImplCheckTest.checkPluginImplementation/Function=Negative_opset1_Device=CPU_Config=() -206:conformance/OpImplCheckTest.checkPluginImplementation/Function=MVN_opset6_Device=CPU_Config=() -206:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronROIFeatureExtractor_opset6_Device=CPU_Config=() -205:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=5a82d5761e70d13623af2cc6a6eab20a7a0657ac28f38223e34b63d6cbc1224b_Device=CPU_Config=() -205:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=9a26ec9d1e0c4963016ff36986c79f5faed763ca5189215923d375e43c70a17c_Device=CPU_Config=() -205:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c599f8f5de2a73e08727a5e27e2f77989b4c5ce9a5e70e6b98ce4c87e8aa26f5_Device=CPU_Config=() -205:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=952a43f4c368721e0c69418b71fe89982ef1eb2be0671653cb1200e34cb4bda3_Device=CPU_Config=() -205:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=d8441d8bc521ac390fb58cb882a952618ebf5892d40e8768a9051f852a9dcfc6_Device=CPU_Config=() -205:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=c662eb0004f431152ddc69e12826a6c0e7aa66b24be0169acf10ca95f2a63f52_Device=CPU_Config=() -205:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=f7e1aae2dbc817ca8f64a6bb0742e476055c239cc6e31a4233b7580205feeb41_Device=CPU_Config=() -205:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=static_IR=99a80c495a8fb4626995167a3ad2efa0efed7696459f6219125414a2bd20dfc5_Device=CPU_Config=() -205:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f71810b04667907bc88c4a1ecc28b9325fde04026b5e56b5eb0e2d6608f3742_Device=CPU_Config=() -205:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a78437a93ab424a706d064188d1bc0971b2e1afc98a74fea979a6f8b99036597_Device=CPU_Config=() -205:conformance_Erf/ReadIRTest.QueryModel/Op=Erf.1_Type=f32_Shape=static_IR=906676850a62f56935dbd13792be1013db602488f29eb757a546b411699ccdd5_Device=CPU_Config=() -205:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=98c0b6c23e4cf51a6069f306109ea2b4e181cfb8e552482cc0d0e63c61406933_Device=CPU_Config=() -205:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=717ea579a24839ee9c5ba7c59a07af667fea4fd44ee18bf60e8970264852bde7_Device=CPU_Config=() -205:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=fb6a053d244fc1bdea6fd5e69e0c05025272ac0da2f676e077c598239b6493c2_Device=CPU_Config=() -205:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=fdb744ee1deeced50395d992d949989a5e8bac5d4f73a6d4b51a56f22359f4f1_Device=CPU_Config=() -205:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6587874c50811a2ca7e27f84cb4381e9a06eb4465e940ea877c76dfaeba02753_Device=CPU_Config=() -205:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=622add2dcd72d2e1560e983ef4aad56fd35b48b71964ea8204137026f445d37d_Device=CPU_Config=() -205:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=6daca83f4b162285c00c695825e255cbafce9cf9c9cea68b969a301105475303_Device=CPU_Config=() -205:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=5be0b1c69be525cbddd7996b695c1a4a9f380173d03f291e8570df76c050678b_Device=CPU_Config=() -205:conformance/OpImplCheckTest.checkPluginImplementation/Function=GroupConvolution_opset1_Device=CPU_Config=() -204:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c80a104f5912c91154ff9731be5aaf1ce189988eb9689ebc32cf4bb8f1307615_Device=CPU_Config=() -204:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=089d73af2221696ce3755a9f33124c9af87fd3e860a1d4f229995eb01ff46703_Device=CPU_Config=() -204:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ae9604aa3fcfc361f87562022cf6996fb2cdd9c356eed6a6eaddb14e103b6b73_Device=CPU_Config=() -204:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=4e6262ae12e4f9470a87cc4f1cc1ef2a817a8080e25a79ca4ef67cb60a558b41_Device=CPU_Config=() -204:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=6095afd484c177267854bcab902c3057a2a1bbf37b2188d3a31fd2cec48de2fe_Device=CPU_Config=() -204:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=134ff6b704123c583b694d7023c99cbcfd10a1afc48819ef35b46dc4d0bca500_Device=CPU_Config=() -204:conformance_Softmax/ReadIRTest.ImportExport/Op=Softmax.1_Type=f32_Shape=static_IR=2b1509d227d4c32fee4bb0b7ac59d4ecf5018afce9fd19714067a20d01933455_Device=CPU_Config=() -204:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=f32_Shape=static_IR=bcb10a9124f9b0471012f9e22d4aed5c2a47a55e652312e8a8382dc0d809a23e_Device=CPU_Config=() -204:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=939b665ae35f9a384e3119dc3bdc1904b105de495d262648282c859b0cb4c9e3_Device=CPU_Config=() -204:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=a895a5053f72560fa5e36ce8b68a8de0cde25ddc1152cb1f647211f1b570d172_Device=CPU_Config=() -204:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=99b432aa5821136994e06b4e3c690a4e298bc5a496740ea2c5fe6aa300edacf8_Device=CPU_Config=() -204:conformance/OpImplCheckTest.checkPluginImplementation/Function=Atanh_opset4_Device=CPU_Config=() -203:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=afd856f31f3a815b84c34b66e1ba0a70a313301ce82fdccc2f1b779ad3157d4f_Device=CPU_Config=() -203:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=244310d1092f478729162ea9a4da5660b066ad7ca70a65d8a205cb03787eb73b_Device=CPU_Config=() -203:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c990afda81456723598f8f4085cb476376b1789d7f755e340e1d5498bcf02080_Device=CPU_Config=() -203:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=85d1eaa250a32acf89b675cc50f513ef3c7df50ed9d68f2cff2fc89db41b63f2_Device=CPU_Config=() -203:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=7b9883414482f3b1108e549a9c47bb8a8aa162d962813c7e99411d000e02690e_Device=CPU_Config=() -203:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=299e5f0fc159bf294093a5e1f258f7083fc54a08cbaa3a55b2a2197d29ae780c_Device=CPU_Config=() -203:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=2b02493e0e09536d01441e885df61f27f2202a3e16742695bcc4d1d0d892c56d_Device=CPU_Config=() -203:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=cbd1111f323b8e6d78b59b531708defef64b90463f973f64f52251795ac5a7dc_Device=CPU_Config=() -203:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eba756a8d0ce89c9a8df50baeaeb82d5b719461bbaa06386db7e1be10ec535f3_Device=CPU_Config=() -203:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=() -203:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b0dea4cb6a0cd2380e8657b0b64caab43819c0f8182ed73b2cb12eec608bfa7d_Device=CPU_Config=() -203:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a52a8e6ef7bbeacbc1435cde72a1a70bdb8a3abf78b5b971c2ecb1135cb4c136_Device=CPU_Config=() -203:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=93788242c06d787e33afa50ecbef5372898e50024d0c88624056a752535572bf_Device=CPU_Config=() -203:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sinh_opset1_Device=CPU_Config=() -202:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b01e9e819c2e610a4fdedcb693f536f99b9dbdeccfcf9b0e70dc37c19c365421_Device=CPU_Config=() -202:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=125ec4e4ba4158d3a6d1a7725cda9a18a220926d5ad6ed623a1433688c79b579_Device=CPU_Config=() -202:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=5bed52483d61091259db863ffcd3b09c190fedde5dac72edad6f1bf37230f344_Device=CPU_Config=() -202:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a45c7a05cac7f403aae101f22fac53b2697d90dcade1bb550200ce439cda7914_Device=CPU_Config=() -202:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1b46ce72aadab0dcf92991f242e971bbb36689e1bcafecc68d646aace43291ed_Device=CPU_Config=() -202:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e7b65875a7e2d88532271dfb93a4a0fbe4c41963fee3193cb3de547c19121f78_Device=CPU_Config=() -202:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=9fa81cf001e6c48dfcf4e75aa77f95b3dce4e8d48b6ec3cfc896dcc08006c62e_Device=CPU_Config=() -202:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=2ad5b63ed56c3966570062970125d1cac16629595e9ac34c6613cf00d6dec0aa_Device=CPU_Config=() -202:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=574e53e574b1a6e0bc16a7296aadd78785cac535293e956b008b0a2274b7cb36_Device=CPU_Config=() -202:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=d9eeac72636735d7541c2d0ef14ebfc7d4a1b3598c08c136a9123b2ed89e13ef_Device=CPU_Config=() -202:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=ddacee38f2bf3dd45ddd36ba236440ae28b9737487e0fb186c2b9777c0b557e9_Device=CPU_Config=() -202:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i32_Shape=static_IR=7988ae4f263061e530c61f5987afd5e7f1945ecef9fcded2bc9799afdcec0df6_Device=CPU_Config=() -202:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=() -202:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7ab51e173b82572bfb29cac5dfdc326e3689e466c68cf91590dcbdddf1f530de_Device=CPU_Config=() -202:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6017d3f7ee3d7e667e8e7e4881f9aae335d47c8617c92b18ec370aa0770314d9_Device=CPU_Config=() -202:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0182ad6b02d77803accd2ebe55d87b679950570d1dcfef2940adcbb5fb9f1a24_Device=CPU_Config=() -202:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=19d36388bdf9535fef89243d6dfce670fc91377062ed4b3095ea55b88e4f296a_Device=CPU_Config=() -202:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=674e2446a2f5929d12d36f14451d68e7b55ad61d2d8df755e85c27c4a52943e3_Device=CPU_Config=() -202:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronGenerateProposalsSingleImage_opset6_Device=CPU_Config=() -202:conformance/OpImplCheckTest.checkPluginImplementation/Function=BatchNormInference_opset1_Device=CPU_Config=() -201:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b2fc03d707298e863f83bd3912617e76e63d0fd922c87edf912c17bf51cc1fcb_Device=CPU_Config=() -201:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2758266e894d04cd7283921f678a468cc1fced81d1a09a3c95add3ed9e5d6719_Device=CPU_Config=() -201:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=15995a372d69998eb6a001f53486201fa9bbc89fb608c7d2a447203a404713ea_Device=CPU_Config=() -201:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=d6be1de020bbe6277d8cacd77eece21f766e5e39badb520ef29e880d52e3604b_Device=CPU_Config=() -201:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=19f9f95d2205816fc002d8eaea7cfb19f19218fbc3528e4932b99f1486b62827_Device=CPU_Config=() -201:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=6ab37e1d52328b5ce1204cfe13977b06dcfabeb4acff9821d65ffc91bd3cf09d_Device=CPU_Config=() -201:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=dynamic_IR=f1e43476084575ad240db6631f433a61ba2076d1ca95e44a0e4471ea9d6f66df_Device=CPU_Config=() -201:conformance_SoftPlus/ReadIRTest.ImportExport/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=() -201:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=3326cf79d426d1a669158c4db8256fdd956fa4725b0d6fb9e8ab5e5206612eef_Device=CPU_Config=() -201:conformance_ReduceMax/ReadIRTest.Inference/Op=ReduceMax.1_Type=f32_Shape=static_IR=590a910a27283b92d7a4650bba546a3bec08a6ded604bbe8523ab3c6d734c70b_Device=CPU_Config=() -201:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=static_IR=f9377788ac0fd1ad0a7f51d16543722cb5acb69640745df17d9f41f5d1d0b544_Device=CPU_Config=() -201:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=e14dc7fb2cf0b63fd08f616d407511ff2036109a3e105dcb87398053d1c334d0_Device=CPU_Config=() -201:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=2c5e9a1cd59ec2d5786132697bfcb1519a7857cdfe06038bb39abed39c09e9a2_Device=CPU_Config=() -201:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=7d3d30fa9e2a8a839cf42249de3eb8228681229e8b302ff7f290cc0d00c10a1a_Device=CPU_Config=() -201:conformance_Elu/ReadIRTest.QueryModel/Op=Elu.1_Type=f32_Shape=static_IR=1cb500b61fe11278cc50fca509be3e7b654190294dd581c7862ea3f108e0c192_Device=CPU_Config=() -201:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=68f6c55980c58f4d6de9e948d1c034b712cf74de509d8fd825fe7f7dfb11550f_Device=CPU_Config=() -201:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=c0c33bc628fffda062b4f013c7d41d0f9080f14f41e084ac547099384a9b3d20_Device=CPU_Config=() -201:conformance/OpImplCheckTest.checkPluginImplementation/Function=StridedSlice_opset1_Device=CPU_Config=() -201:conformance/OpImplCheckTest.checkPluginImplementation/Function=RNNSequence_opset5_Device=CPU_Config=() -201:conformance/OpImplCheckTest.checkPluginImplementation/Function=PRelu_opset1_Device=CPU_Config=() -200:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e4523b73661dc593224b91713f8f20f1c87513a62e3b8ee8265e1136eb74f9ed_Device=CPU_Config=() -200:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a2e1d1400763fcb89889255855a5c99dbbb17ee5e390e891c94211308fa2d725_Device=CPU_Config=() -200:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=90cf12798b53937dd1a31daebe5444e1c10c27c5a67fcde6dc61b5feb1df89ec_Device=CPU_Config=() -200:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7895fea00309326a052d47dbd2f9e562b86bb9d0501f2a2fd8843a0340359b67_Device=CPU_Config=() -200:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=18763287c1afb7684d3f74e91fbb8a8c17a13aa52908a5d97b6ad220c5c4f633_Device=CPU_Config=() -200:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i32_Shape=static_IR=c78feba7097eb1c59197840a7e5510c26faeaa51ff724d643dc1f1ec077a6344_Device=CPU_Config=() -200:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=8d472bf25f969c5ab5eb85fb198c2176766a2de7cd444819e8b60d416969e3c4_Device=CPU_Config=() -200:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0534fdfa97228a6aacf4ed196a9ace8e09d8e4decdcce058176b0312500b6c07_Device=CPU_Config=() -200:conformance_FakeQuantize/ReadIRTest.ImportExport/Op=FakeQuantize.1_Type=f32_Shape=static_IR=848caca8b0b971d54e9c9b715b8bf35e0a33f1274d50a946384e64e5c0843a96_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8c773c776396a2ff506691f857349efa9a4a580f1e046d1f17ff2ab49c73553d_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f9e738e5e947a25c9a0d18fe47597f10526e8a74e9d72b35fd848b73f4c80b0f_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6a05cd292e71af9d96e456cbc515097d5224a9e41cd9c3d48cc73f1a4e6e2164_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c14aca93b401d9d2325a5396c1489e1fa29aaa57f592cd2b4e6792ba5af90a90_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8eef79ab2081a12ed39f5c6f8f2e917d14685f54ccd0fcb0e19865740ca7d608_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=f89eecd15ff45d6929f82696f96a68adfd694043ec3f859952d80080bd140627_Device=CPU_Config=() -199:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=e2da6d928938b6445170cd69fd4a7aab40130a560cef3ffa2d268a428f56fcec_Device=CPU_Config=() -199:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=fe80951a0a44625457a6106d8613c9813c9c0b8fe3606fa5ac1c064217c8a0e6_Device=CPU_Config=() -199:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=d25e26d9a54a5dc9799e9881e3035bfd5f125d12ea6cb69fb1eb0166e29ec88d_Device=CPU_Config=() -199:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=c377dc784ecf97aef916740686298f47bc82c7c007326042ffe748e91ccfde1a_Device=CPU_Config=() -199:conformance_Split/ReadIRTest.QueryModel/Op=Split.1_Type=f32_Shape=static_IR=f5807b455d9031305e8225f2b65fd5cc289f61785d762f19a275280085a2e5e8_Device=CPU_Config=() -199:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=1c6447222d58a16595cfdd8b216fac2cb3f005d2b236a6526ef5de8e272e4847_Device=CPU_Config=() -199:conformance_ScatterElementsUpdate/ReadIRTest.QueryModel/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=5b185120e46fc0a2238ff4de19e278888ecda5fbae130c62e1ec21b4883ee61d_Device=CPU_Config=() -199:conformance_ReduceMean/ReadIRTest.ImportExport/Op=ReduceMean.1_Type=f32_Shape=static_IR=ae7b6a45a538bb7f65d5895f2f7941fd9048645482faa40adb1f773e282a946c_Device=CPU_Config=() -199:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=() -199:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=21f786ad25c17eff66f16501d160439b96636a7d5d8512c1bd3db5fb5d5e6987_Device=CPU_Config=() -199:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=() -199:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=b31dbb99720fd5083e5a7e5b1b626bda91455999e2918eb8e658992cfa6588dc_Device=CPU_Config=() -199:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=b7b0a0b3921a1e1434a3fef630e32b124c810e8bd15a3e861fe7da79158947b2_Device=CPU_Config=() -199:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=9d4ebc5a7d195ea0e566695253c38ac5d02fea1f4fbe97396828ef9f7754808a_Device=CPU_Config=() -198:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b706dc1dbca4cc6c308f2cadf799fec41a8b3f08251de3a58444f0d760994cbb_Device=CPU_Config=() -198:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=3b4dbc6facc24173723b52757e4ee60953d7a639e1fcb6e70236918d6a40b3a5_Device=CPU_Config=() -198:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=945bd465761a4d9b013b0a5e88a3a9e041d8bd8bfa8df8044f28d71ba26f224b_Device=CPU_Config=() -198:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a45c7a05cac7f403aae101f22fac53b2697d90dcade1bb550200ce439cda7914_Device=CPU_Config=() -198:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=396388d4dce8240937c39dcd24e583e775f7b4e84d6c85fa9b5930588dfb9b56_Device=CPU_Config=() -198:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=7b702f91c21af6c336654c924011d0f4d149111c503c697fcb85a83cd60b7ab7_Device=CPU_Config=() -198:conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=() -198:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=b6984001a616b3dd3ef4b835b2dc6a48bcaf8882bfde7761b4e141733364f66a_Device=CPU_Config=() -198:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=3326cf79d426d1a669158c4db8256fdd956fa4725b0d6fb9e8ab5e5206612eef_Device=CPU_Config=() -198:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=() -198:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=i64_Shape=static_IR=8834a8881c2da907f6ae38d4c45100dde754e653f3e4994cf9add141c217c781_Device=CPU_Config=() -198:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=7625f5af6c70a9d4bccb783dc369a11b53ef1f6492df030ae5404452ea0cdc79_Device=CPU_Config=() -198:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=6119edc6e1f969159ce54e6ff4451d96db51485b54fae625a972035414c704ef_Device=CPU_Config=() -198:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3b3a5cbc6a255792eeeec698aa5a90947164eab96ec744ada9d02b6c7f453f8f_Device=CPU_Config=() -198:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=cbb80f496fd705f24fdb25f6de3734bb2a2b7f49c984bdb32c4f62ec4640797a_Device=CPU_Config=() -198:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=86fb2ad636e51f682c83919d64217835cd9ab458695e3bdab295c4107516e733_Device=CPU_Config=() -198:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=b61800abac107b248c29df7ba04a73c91d490782b1da46164c1b7d2f8cec3cdf_Device=CPU_Config=() -198:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f55c473236715e5c4e6ec21a9e07d1c73b14d529b57fae0cb38ef9d6cd383b53_Device=CPU_Config=() -198:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=0add7fb1bf1500ea125aa6d245bad577d6dea18d038c020d18c2dcd56704c671_Device=CPU_Config=() -198:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=() -198:conformance/OpImplCheckTest.checkPluginImplementation/Function=HSigmoid_opset5_Device=CPU_Config=() -198:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseAnd_opset13_Device=CPU_Config=() -197:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b66a71c512cd06f5dc1d1a254ba0128b606c1c41b860f272dc1d2514502c2350_Device=CPU_Config=() -197:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f5d63cfc40e19fff35078633a3354fe5e3a8b6dbadbc89e20747398d87e02176_Device=CPU_Config=() -197:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1a29918856ba0f88e99346fda6e6c21ff2bf129f5599d8a1c8611346ab41f2f7_Device=CPU_Config=() -197:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=37b1b14a23dbc309d75fbd98158648e1a7fd246684b96e1ebb10a75c3f5b03b6_Device=CPU_Config=() -197:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=51bb427ac8abf618a72159cde1ee840e08518016a09e995f503cd888941f5039_Device=CPU_Config=() -197:conformance_Select/ReadIRTest.Inference/Op=Select.1_Type=f32_Shape=static_IR=da15c9ddbf446de00565c83e95b8a554d400b8b925481e56eb3df41f7efe26d9_Device=CPU_Config=() -197:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=f802331401875cb16be10c9f752520406437b2e63a50e022b7d95b732e5296f2_Device=CPU_Config=() -197:conformance_Negative/ReadIRTest.ImportExport/Op=Negative.1_Type=f32_Shape=static_IR=c29451ffff103b5e965a1bbea7994ef6da6394060855ee071b9e7a3a4702141f_Device=CPU_Config=() -197:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=c721fdd5d79e702e4ac48a31d0ebacc4977f050c67d1c415b085773042c8e93b_Device=CPU_Config=() -197:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=dynamic_IR=214b1d4be2a141409b6b54847c952a282d9b2d7236d3d8ada3463f7dc8554097_Device=CPU_Config=() -197:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=cd389fc4a9417c7136f75474e42dfb43d1f9cb35fa0e104632ffa69fce2b7e57_Device=CPU_Config=() -197:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=9ca1360242688f494c59b8eb1073a4bf7291ee7b2ff460380bd47248fc591dc1_Device=CPU_Config=() -197:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=14108fac0139d5bb39f6b2106857e1ac91c8d44ef9156e4e0873facf9d932316_Device=CPU_Config=() -197:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=5498e895212b57b42748644679c1dd67936f230d2c61998ca6bee31d527035cc_Device=CPU_Config=() -197:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=4fe95284f224758c29c5198a8b2e6f97e8e737435d36cb94b9cdf0bca3c89dc1_Device=CPU_Config=() -197:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=80e0900e8270dfbd0fc879ad4d065847f767cff9399688bb9e5e03b8531c554e_Device=CPU_Config=() -197:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c0413244803edff103b95dbbcab27b2c714740372ba215264371a9474355a8c4_Device=CPU_Config=() -196:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=df19449b7a95887e834ba16ebf2e1f08416d6293686a6cb6b6cf39fc82559595_Device=CPU_Config=() -196:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=776ce5493890837f137a7abc7851ff04164468d7c13ef1022f73f1f68e058c1c_Device=CPU_Config=() -196:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3c0b9fab07568e0eebb5e5d068cfccdd617ee6e98e4253a0461ea8d3f0f582e8_Device=CPU_Config=() -196:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=178677f6c6e3857b2c3aa8765c8e3186bd25b73154ba6463ff33a9e1c911e6bf_Device=CPU_Config=() -196:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d1b4dff28b71e41d8106d3730f2705e537487aafe0dd53ae7dfba9ec21724287_Device=CPU_Config=() -196:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=afc2cb913bcb4e4badd203c9cdf491ea1e6ed4f1cd835e7507889a9bba25b958_Device=CPU_Config=() -196:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=i32_Shape=static_IR=f777fb31e1669cd58cc77e2a04c3f9a804b654b6d710432641a3dc34504460b4_Device=CPU_Config=() -196:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=b574ee57274a9f27f6d0908cef2645c458983225e3cb82c455148e83337ee3ef_Device=CPU_Config=() -196:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=4420cfb7f4a734731dacfe5b0c27db41ccaac2ab8bbff56cac0f99ed96e976f2_Device=CPU_Config=() -196:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=670a0d513277b4508e8edcddae6361e98fd03c2fff31293637c36f97e59a6b9c_Device=CPU_Config=() -196:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=1c91956bf0130fd338f8f11cf76a08dcf5fe3c6c42239fa6a6aeb517eeabba36_Device=CPU_Config=() -196:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=6c1aeced5aaaecd99f3917a0f38e01902dbe81614ae4dc9a99fc09a379990abc_Device=CPU_Config=() -196:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=84f6f3544adcc7c68df5ca411844cf36c2232c1b6c820094e5693a444faa143d_Device=CPU_Config=() -196:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=b12c40f6d576482396a94e28e0814488b87eb6844583bc87384ed385d45bd6e0_Device=CPU_Config=() -195:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d27e8ca8280dc9219f4b76a2c8f47cf526b32a58710126c7549e2c04026944de_Device=CPU_Config=() -195:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a0b3d7813e380f287a758c35e56e8e8edbb72b8c64fab6194a8890dacd5e2f16_Device=CPU_Config=() -195:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9465b2ea76ea3be1365dfe1255524d4ecce0dff6123e929a2157bfc767396b0c_Device=CPU_Config=() -195:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4df4ab698c70278594efe8b4349a4c99c8b2ab7c4ee0182c5a4b7673da922ad6_Device=CPU_Config=() -195:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=51390fa8c8a5680ae4a8de4f655083caefbb8445dac8814d2b1827e2bd43f470_Device=CPU_Config=() -195:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=0fcad2ddd1c7b81bf5e88ef4d4abb26a33326a37fb0cceb1205c1efd2a2d3615_Device=CPU_Config=() -195:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=dynamic_IR=9337e101d74f6d35bf81e9be895ffba9e972cdab9d79b2802f1c1ec0f4d34a83_Device=CPU_Config=() -195:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=dcd71a51a6682c9bc461a6cb72d59082352ab8a020e1f79e64c3cc44a37b55ba_Device=CPU_Config=() -195:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=7fb9c2cdb4c82a4b65d110fc84c03948917cc1921c372cc645cab00a3377fad8_Device=CPU_Config=() -195:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=ba1a7c4cca6d39b8bc7be7d52a0680d055e33a776f4048ecf38335a2ccdd8d51_Device=CPU_Config=() -195:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=2b927ee73187f1c1cbdb071ad3c0a72c9eb8a8631f2e7c6c3a8f8482c301fcf3_Device=CPU_Config=() -195:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=d93633fac99f9472435ede6fcdb9c72475b68bf1352d58b33e8cbdf9ca74ac50_Device=CPU_Config=() -195:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=d36c5ab59d2ab873aa35b35a952e061568edd4ee8e64c1ab200bea63472a97b3_Device=CPU_Config=() -195:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=2620e86e1e6ce8f0ecb3eebce969f3e7df11f7f86c6f97309aa24993f9036033_Device=CPU_Config=() -195:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=0a7b1efc8d314c5e37062e482a9398f718082ba0528c6ca2d2f6c88e7a4a2bb0_Device=CPU_Config=() -195:conformance_FakeQuantize/ReadIRTest.QueryModel/Op=FakeQuantize.1_Type=f32_Shape=static_IR=66f4344fac8e5e5484f5762b1bfea68ed08bcbc378a8b10f53d0a8e053524749_Device=CPU_Config=() -195:conformance_FakeQuantize/ReadIRTest.ImportExport/Op=FakeQuantize.1_Type=f32_Shape=static_IR=66f4344fac8e5e5484f5762b1bfea68ed08bcbc378a8b10f53d0a8e053524749_Device=CPU_Config=() -195:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=b1477d38842775944964d18c13278454256d9610e0ef880fbce0cc87e5977556_Device=CPU_Config=() -195:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1e56a3e2379d29d81af93174e56ef91408af41dfc085d4851ff58dbec781b8fa_Device=CPU_Config=() -194:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f99a212a117855e6e2dc4a338444a8ecee441f989638f7a0700ce24e037d29e3_Device=CPU_Config=() -194:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e4b374c3afdeb45605c3ac745c03fc9eb938cf3f3828c119917ca92a6e9135f0_Device=CPU_Config=() -194:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=() -194:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=() -194:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=004b6fd9b060324a42aad296dcb21f5b7eb7586c082f98d23f25a6d882f70c14_Device=CPU_Config=() -194:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b91ccf96246dcf055dd9122c823ccc54ea572f1ad8fcbad3a98c88edb7e454c4_Device=CPU_Config=() -194:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=static_IR=591cc5abb16f22cfa720e53be695097b83c42a971536fb5b79d0b02cc4ad328b_Device=CPU_Config=() -194:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=dynamic_IR=c117722add2db4a6eee4dc2fbfb99174911d54eb3896c65097d31d656fdee639_Device=CPU_Config=() -194:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=8b759b2f1999be207aeb39763bde3eba4aee028e9369a86a87493ff86f3fa014_Device=CPU_Config=() -194:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=033c6bc337d14053ae097dcbee99ef5de7cb7728b589cc8d64783467505a8ba7_Device=CPU_Config=() -194:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=67a5010efb429e6dedf35481443b40a77cb01c1b4fb51ec5890fcfcb010fd6f7_Device=CPU_Config=() -194:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=f32_Shape=static_IR=6e67522f2df32ac8e237fd4de148d082f3c55e6c31ace80cffeaef784dfe75a0_Device=CPU_Config=() -194:conformance_Minimum/ReadIRTest.QueryModel/Op=Minimum.1_Type=f32_Shape=static_IR=5150e1785d97b052a42873f9e9d23a511027248ff4b13ba7c269c8c3d4639e45_Device=CPU_Config=() -194:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=c4d8543f8e0b375407e428ef119ba4049d44cc273a10661b57645bcd1d36f5cf_Device=CPU_Config=() -194:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9c651eeba5c3e7b07a8cd0d4ba479fe8c5aaa2c4df9b18ab022e775ea01dd867_Device=CPU_Config=() -193:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ad640e033c11cf7d81ab237630f0ba656968f620eb4ed77f38cd79c6cbac42f6_Device=CPU_Config=() -193:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=95d9789ef78c733e0c7972738bafd4da289a90f0d9ea00bc9452192173390b6f_Device=CPU_Config=() -193:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7caba2dff8ab10660f66796a39d8d2a78f3e282f0629c2ecbee9b90c34e62aa0_Device=CPU_Config=() -193:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=7caba2dff8ab10660f66796a39d8d2a78f3e282f0629c2ecbee9b90c34e62aa0_Device=CPU_Config=() -193:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=9f4d316675c933ea5d6511324e3d664440a8ba287cb2ffe768517f9cbfb613e7_Device=CPU_Config=() -193:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=f32_Shape=static_IR=0138363d3baa37869a3e55e1b059a42a87612507ba318e753361a58549ed5ec1_Device=CPU_Config=() -193:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=1c91956bf0130fd338f8f11cf76a08dcf5fe3c6c42239fa6a6aeb517eeabba36_Device=CPU_Config=() -193:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=dynamic_IR=166d8442037dcf0469f0b14ab83676b30bce53edd79494c52a575e3744920c4d_Device=CPU_Config=() -193:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=c4d8543f8e0b375407e428ef119ba4049d44cc273a10661b57645bcd1d36f5cf_Device=CPU_Config=() -193:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=eace26dff7f6f0403126e78a4c93920ee5e54a721cd580b4b18c2c9989baef86_Device=CPU_Config=() -193:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=965ded994c427ec62353194906203c202a52dfc0467196d5f1143759fed94b07_Device=CPU_Config=() -193:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5176d95c14be776a4247f25a469708ba7976378b7aa8860a115a28a8bf2c2902_Device=CPU_Config=() -193:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1b59316585dcbdfdbef9fd71e2681207498cc867a2285eff20d125c4fca0502c_Device=CPU_Config=() -193:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=dd366f3f5b63fbfce3d9378cf0d8bfa4a909a973bc3e5e97eaa9d346c5cbf1d4_Device=CPU_Config=() -192:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a4772901ff77541ae624f89db89901c7d5a502a0dc5d1e0dc21eb8e08c599525_Device=CPU_Config=() -192:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9257d329b4cc9eff8545270d1693734adac9ac4ee44dcbaa21c774287e84aadd_Device=CPU_Config=() -192:conformance_Sqrt/ReadIRTest.ImportExport/Op=Sqrt.1_Type=f32_Shape=static_IR=33aa0d800115f94b07bce9c6ca8b4447f2c4f442bff77cb9b02b23d2ddabcc01_Device=CPU_Config=() -192:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=d683b96d525bc074d4f8c15934a5082a3fba1068b591f67e4b05d605fe5e6aa7_Device=CPU_Config=() -192:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=static_IR=ca5d2626f2066e0c806addc4b6ffb4b3a71f1183b93783b92f44de62d82faaf8_Device=CPU_Config=() -192:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=ae817dcac1ed2395cc4098f67bf6d2bcbecd8b7e91ef7592622d1ee75ed4a3cc_Device=CPU_Config=() -192:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=static_IR=c721fdd5d79e702e4ac48a31d0ebacc4977f050c67d1c415b085773042c8e93b_Device=CPU_Config=() -192:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=0db5765bcfeb7716699abd0cee850918cf5ef18e2cfdf1614b463734ca35a20f_Device=CPU_Config=() -192:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=2a9ba5f3e5a74f05be93e288553139a15242f1500e1eca8317dbd82ee8cf00d1_Device=CPU_Config=() -192:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cf02be750ce25545f7bfd694603192667eb3fdb07a186eaa7f3ecf5767547651_Device=CPU_Config=() -192:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=90f981f067c23b4fd3d2df838af8e6d11ae1c5e9465b566501628c7f3d63674d_Device=CPU_Config=() -192:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=3e4364d93433ea741efe178b0c83cfb13c46259888aec468f59f77cd3f1bb39f_Device=CPU_Config=() -192:conformance/OpImplCheckTest.checkPluginImplementation/Function=GRUSequence_opset5_Device=CPU_Config=() -192:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseNot_opset13_Device=CPU_Config=() -191:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=caf20ebc8d39cb23a107a03e819e8ee5b2807fbd311fe65453446251e4b6a611_Device=CPU_Config=() -191:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=7b1df1422bfecf1fdf9c25f72d938950cb1492ee1c7223d9c0d771f93b1fbdb8_Device=CPU_Config=() -191:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=4341385bd87226eb41493c667323e8c1c39817983a48025192209270750eed06_Device=CPU_Config=() -191:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=055b7eb16539ce5cee62e165db9a6d51a11e0bdf90bc9f82eeca1f2faac2bf89_Device=CPU_Config=() -191:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=69f4c39c3fb2dfc55714893e1e45761238e74bf28ecfadbee3f4965b5a379888_Device=CPU_Config=() -191:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=944072d96554abf3ceac6b928cc00ea1705d5e0dfae8e9a0662de4e56fb3e62f_Device=CPU_Config=() -191:conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=i64_Shape=static_IR=1c06ff77487507dddcddf290d75d4812bfc8a7b2c9bc78176da5212eab029966_Device=CPU_Config=() -191:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=() -191:conformance_Interpolate/ReadIRTest.QueryModel/Op=Interpolate.4_Type=f32_Shape=static_IR=d05c1b7fcf976117a23e0284998d9ce21689411ff24530175787f1512ca25879_Device=CPU_Config=() -191:conformance_FloorMod/ReadIRTest.QueryModel/Op=FloorMod.1_Type=i32_Shape=static_IR=2d09fd84ef3e176a2eae04f1066929ceb3973045b87989e5f0f11b97cab6cc7c_Device=CPU_Config=() -191:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2e586703f4f8e9285249881d509a2a0b96d4758be5f97d75e7ee4f78951c58e9_Device=CPU_Config=() -191:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=922e194a5ae53e76be5ae624754d3c1fe5ea0d8c564410062bd9c30afc48ffe0_Device=CPU_Config=() -191:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=fced0ff647e4ea9a4b1673016b017f68ed75cdc778cad156dbd6cc379bb815f9_Device=CPU_Config=() -190:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b42c98b6313e56a7a012553eeabae92f0672c0bde6f9895d10fb459796448b75_Device=CPU_Config=() -190:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0d40552a1b6c1945765ada16284a0c03f5c1454fb12f226a34dee8a07b14f17f_Device=CPU_Config=() -190:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=47423c3e9443249e3dbbf58ee0f5b69b15e677f84de44ddb9d2851d1341dae96_Device=CPU_Config=() -190:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=21534d0488c3f7c8bd40bc81476832e866000c97ee6892359826c7877905d733_Device=CPU_Config=() -190:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=fb8283ecd8934dfc5340a41e9889a0a760b39869e4873efed4ef85606c162ce7_Device=CPU_Config=() -190:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=474c6273d1e48e8e5885966dc93629ad413683ad942e3101452c1a58fb5b5af9_Device=CPU_Config=() -190:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=f32_Shape=static_IR=7b702f91c21af6c336654c924011d0f4d149111c503c697fcb85a83cd60b7ab7_Device=CPU_Config=() -190:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=83b83dd13b1733a50ec728ca6e7f09eb75641a573178816d1d33f30390464d87_Device=CPU_Config=() -190:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=f32_Shape=static_IR=7f806d6c4a0ff3515dd9a092fee2ab14a5f363fd5fbc7503d64a8cec4bb1cca3_Device=CPU_Config=() -190:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=i64_Shape=dynamic_IR=debf36fea706c02dc67354edf761f0dc931ebcccbed285f186164fc4b9532766_Device=CPU_Config=() -190:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f0472c0e5ff8fb82651424269bd9f77e73eff6c43c70b6192f07303c0d35db8e_Device=CPU_Config=() -190:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=cdd7ce044f231ae39fc0f7460a55473c0de6934124cd263444a5912b8cbbc0ce_Device=CPU_Config=() -190:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a7b2c196b6ae12252522b2571af40b540eae94513bfbd88e15708fee816869f8_Device=CPU_Config=() -190:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b0a418fb8ec50f25147079b3aef1b13095ea626a9e52a643600c39972982ff9c_Device=CPU_Config=() -190:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceMax_opset1_Device=CPU_Config=() -189:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fe5cbe273830f6a09e3f18eaf8e9410f9f7f1083af508a9dcaf5f0f22aa3ac1f_Device=CPU_Config=() -189:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=64d7467cf7785e52814a8c25f96c1a5d82c071ced27dea8302b5cd69b464ac65_Device=CPU_Config=() -189:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c6e38c3297ab303b166e2a613203a1f09f4ba5a15659c8d2b233febd8fd09d9d_Device=CPU_Config=() -189:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=93a9a06d14c3b4d51891ff0e704c74dae5905db9b5de06d31379f33fa685c80c_Device=CPU_Config=() -189:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=3500be960a489d618c1ff6345c1d6788d17c43786c10a7e7b630586920bce356_Device=CPU_Config=() -189:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=dynamic_IR=bc8918b82285bb58c2cf1b4b60b023262426de4044e0c2d50ae07f4b22ae0eb0_Device=CPU_Config=() -189:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=a6722b8718b7c028e1bbde4462945c096dfc551775af27bcc7d00967d7d73919_Device=CPU_Config=() -189:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=91b6cdd8a7664759217ce0b84a8baed2105bca0ae9876e9efd01c074aa27039c_Device=CPU_Config=() -189:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=0a5f9fad12bf5e2592c6f720232bb38d94a5fb9ac1fdc5a8f7d474ed9e9d2504_Device=CPU_Config=() -189:conformance_NonMaxSuppression/ReadIRTest.QueryModel/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=() -189:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=bf7feb979b2eab03afc780965804a3f6b8471b574c36125654fcaf3ebc2c30f5_Device=CPU_Config=() -189:conformance_Erf/ReadIRTest.QueryModel/Op=Erf.1_Type=f32_Shape=dynamic_IR=e6f95710a782b6c7df8397480e5cffbfa773fdf4ef11c93b2b1ac4694313b080_Device=CPU_Config=() -189:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=b9f9ac285915db9ef3e7437728695f2833d165757ffc81afb88242e7b471f434_Device=CPU_Config=() -189:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=() -189:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=256f748d7b98b0eb70cc659403910bac929d62a2b153e63438f8746f602a83fa_Device=CPU_Config=() -189:conformance/OpImplCheckTest.checkPluginImplementation/Function=Slice_opset8_Device=CPU_Config=() -189:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceMean_opset1_Device=CPU_Config=() -188:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f01152d615a3092ffd4ad1059779ea183d7a62c1ab5b970d940f3f537e6f12db_Device=CPU_Config=() -188:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e23a8faab46e1096894a906794325ff1a8c6001d3b980aa809088385675c77ed_Device=CPU_Config=() -188:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=cf334277b64fe023019fb7f007aae9ebf7432b733a1876d6cd61bce6a204e0dd_Device=CPU_Config=() -188:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=780fe1f9a82f728f88511b2d8194c4f425144ffb5ae4aaeb1ce90c6fdea3362a_Device=CPU_Config=() -188:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f5a74749f6c90dccecbb5e4a7d0fee72cca6247f0084487b5ca7d94d098c9b9b_Device=CPU_Config=() -188:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=c377dc784ecf97aef916740686298f47bc82c7c007326042ffe748e91ccfde1a_Device=CPU_Config=() -188:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=31ce051edcf02344a693eb2d200fa02b53412a5707faaffc2907cadcf81192f4_Device=CPU_Config=() -188:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2ef3273b8c144dedd6cc2d2b8c2d2921d999fa286b10d90aa796fa188dc52cef_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ec19939673cc58f2511ffd6695a3652f1d724872b0db958a6d667e1e87002b21_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=97f6fd9998be395222e6878ccaab47f5d50561d1ab8f988987f7f292e784fe2d_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6453d2955ad3344d5e021f97d71691ddd7c27ffc0d9044b724c9a6b5c20cb427_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=eca24a51b737307a94a918f4d03923c1e035a3379c73359515c63ff3ea98be85_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=42afa027ada245d36900a89c54a870ba5fc7fe3cc3bc0fc7dbda23af3e5111d8_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8b55c14423b60f30029c68c603417fb98119c5922e2827c60c99edc05ea813e1_Device=CPU_Config=() -187:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=deaa5ef98e478a5850df528107031c9c7bfa6305bc7507325c91b98f9337b0b8_Device=CPU_Config=() -187:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i32_Shape=static_IR=5224ffd078708e8917b14b4118bc4a42317c123dc0a5dca8234ad73d44daf845_Device=CPU_Config=() -187:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=8f7dc81bfce05ce39b694fe48197a4fd2aa7933c7061508be3b9dfefef518f75_Device=CPU_Config=() -187:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=ace54c326bc8255cd741eec12762e4d8f645fe93d50c037effce893745f8fdb5_Device=CPU_Config=() -187:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.1_Type=f32_Shape=static_IR=a4fe57973b0bba01e6038a8050f07b8ad1bf6871c1ad86270920f9084dc84905_Device=CPU_Config=() -187:conformance_Sin/ReadIRTest.QueryModel/Op=Sin.1_Type=f32_Shape=static_IR=54a909996c38d86ec830295e37f0fc0070260101390dbaae2cc6eaabea82a7b5_Device=CPU_Config=() -187:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=() -187:conformance_Maximum/ReadIRTest.QueryModel/Op=Maximum.1_Type=f32_Shape=static_IR=62b8aaf25e8c93387362b0c657886c31c39a7330cf3455486b8943a1e375ef5c_Device=CPU_Config=() -187:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=d575b00d2b6e155319fe7120133d8e0c3dcb5c79bda710b0650fa48543dc5c84_Device=CPU_Config=() -187:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=10cf1b7a4de1231ad721c9660697d6ee17bcaa2151f08eef596b41e6e3aa1b2f_Device=CPU_Config=() -187:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=boolean_Shape=static_IR=4da22853b6e4b853fa57b9dce8f5a26920d079a74055831d651c10f48ee96e8f_Device=CPU_Config=() -187:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=i64_Shape=static_IR=e8fc48c9bceee1462572c6aa8c5afbda94a9d6e8760deea1c9a3d04d1d797fb5_Device=CPU_Config=() -187:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=dda009a1f3191e35286b7515f5741905e303f27287041248e2ce15f6954af810_Device=CPU_Config=() -187:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=95884fb8d74cae609a67146ef94a84eadda8f3bd6369a9cb465bc413264a1d0a_Device=CPU_Config=() -187:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=3c1c8bc7ce009c03509ca9d6a86f3d5cff89be49439e7513edcde4e62fbfb8ce_Device=CPU_Config=() -186:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d16722dfa770998d9923d09fa1e2a973bac5ae7afc6452a0b5ac21d839720bb4_Device=CPU_Config=() -186:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7c43bd989494b4ef0f2ca40c3b0c57b471d58b21491456e9588938f702721be0_Device=CPU_Config=() -186:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=392b855febfc39fd1b2a9fa43270f58bae53e0d210525e8700edc15a10d28d33_Device=CPU_Config=() -186:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=71010d034cbc059af32ae6066fff1f27834db480e76042d1ef7bd1e7bc426a08_Device=CPU_Config=() -186:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=474c6273d1e48e8e5885966dc93629ad413683ad942e3101452c1a58fb5b5af9_Device=CPU_Config=() -186:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=db5c391cca1031cb4ec32def18ce3a4776c53f71e861c39b350fe5856da4fa43_Device=CPU_Config=() -186:conformance_Sin/ReadIRTest.Inference/Op=Sin.1_Type=f32_Shape=static_IR=54a909996c38d86ec830295e37f0fc0070260101390dbaae2cc6eaabea82a7b5_Device=CPU_Config=() -186:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=05e9fdd5183bd179e5ef996ebcdc53f239900ca46a8122ee8bb1e885c2c091ce_Device=CPU_Config=() -186:conformance_Pad/ReadIRTest.QueryModel/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=() -186:conformance_Pad/ReadIRTest.ImportExport/Op=Pad.12_Type=i32_Shape=static_IR=6650e462a4f0086329d8576eb6352979e89825517f48e264fe719c7c5ca276fc_Device=CPU_Config=() -186:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0c5ac67592b69e8c2b7acbae7a0f877cfed184c572d2fae09eb8fa629e86eeb1_Device=CPU_Config=() -186:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9b64733aa0a8994cb3695a7c26f905f4d2b86c2e157edbd8a9970d33970a4015_Device=CPU_Config=() -186:conformance_CumSum/ReadIRTest.ImportExport/Op=CumSum.3_Type=f32_Shape=static_IR=d517f63a168293380a1f066313e6a2bacef9eddf961ce164f11ce2609a632b3a_Device=CPU_Config=() -185:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f8408a1d4e8c11ebbda01e0431217a5ff4ac6a869cc4cd3208cc9adc59d227fa_Device=CPU_Config=() -185:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a29be1e2e5f78c12657221f33e5309470a7a4dbb9061a8100d7c454215198f7c_Device=CPU_Config=() -185:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9ce6a2f4787ef120c486a68cc02bacb95d6cb1c4cdb5e2054275cde409a39803_Device=CPU_Config=() -185:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8e80bbd29743e87a0a6d4158a06249766b6a9cf424cc1c0ed3c6f60e30e6db58_Device=CPU_Config=() -185:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a2e1d1400763fcb89889255855a5c99dbbb17ee5e390e891c94211308fa2d725_Device=CPU_Config=() -185:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=adee3d4d6728b17fb5ab17a9915c5b7c8808f949ad358e8a16a0bb12dad7c958_Device=CPU_Config=() -185:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=9f19f32ddff44c1c8f7dc3b9b244a9191a15fef9874e016666fe6a817937f699_Device=CPU_Config=() -185:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=() -185:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=i64_Shape=dynamic_IR=08776190d0fddfcb15ad75cdbf6892de03f79e89d57e02b7c3e80b4a7a125d35_Device=CPU_Config=() -185:conformance_Multiply/ReadIRTest.ImportExport/Op=Multiply.1_Type=f32_Shape=dynamic_IR=6ac457e9181610da9eb4bf0bec6cd53bf3078e0b84df1211f49921207d81c6e9_Device=CPU_Config=() -185:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=i64_Shape=static_IR=056c07f9ad8e27e01b269b5136ee29b4cb4d1229a009cda07e4fd32c45d4e97f_Device=CPU_Config=() -185:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=508a961c358d40ddb6906694a24f87dc24f74cb4643aab58ee1d6fa28f099e6b_Device=CPU_Config=() -185:conformance_HSwish/ReadIRTest.QueryModel/Op=HSwish.4_Type=f32_Shape=static_IR=98546b7eda390c30f82053a093b5e3855c6dc8c631451b3637eadf95858af2bb_Device=CPU_Config=() -185:conformance_Floor/ReadIRTest.Inference/Op=Floor.1_Type=f32_Shape=static_IR=b064511ab38a9a70b4d203e11a12b990f388a03550ba98c65468be1b85c68fda_Device=CPU_Config=() -185:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=80e0900e8270dfbd0fc879ad4d065847f767cff9399688bb9e5e03b8531c554e_Device=CPU_Config=() -185:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=851aa3cf931a01e0188758055b866fd14280bc344f548da6166e4a57ca7c9254_Device=CPU_Config=() -185:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=c985b086d155654f9db8470da3af5245c4fbb0139015d049b8b3b20f393c2545_Device=CPU_Config=() -184:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e58cf21c9c62dd427747021dcf9544157638e0773329eecfb8755a71b24f65a8_Device=CPU_Config=() -184:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d9b3427efacda497c4fb86cebe89023b322722167d0c32de8a2602a80b23580b_Device=CPU_Config=() -184:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=949611ba6617b054b828175c04452b8fcbd109c99cb25d5d8827a872b4044fd3_Device=CPU_Config=() -184:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8dfd99ad2ffed2573598829ff34a62deccbd70f5337c1fec4c2962cef1992595_Device=CPU_Config=() -184:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=005e1b57ad768f4c8efb3116fe51bc85661c377e6632518b9172e8862d1c3edc_Device=CPU_Config=() -184:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=8fc5ce53f1f6b924371ab2cf156ddbf7aea234b17befdcb6206ba51a7ad988c9_Device=CPU_Config=() -184:conformance_Swish/ReadIRTest.QueryModel/Op=Swish.4_Type=f32_Shape=static_IR=d79b47022a50437c9df095b34e515c53eb042c9813fcf6dc7bcdb96962818ddf_Device=CPU_Config=() -184:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=() -184:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=282e24ea7ef9130becb8db8f0251c907b02a534119d08162e07091212d67f290_Device=CPU_Config=() -184:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b38f11a07d752c83a5e4fc709d5b78fe9a40ef3394f4b617a30df29c21640338_Device=CPU_Config=() -184:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a3d6337c1ea3e8b67256696ea4231da4fc0e9d9f8bea169607a1287233086b3f_Device=CPU_Config=() -184:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=234277ecce31161bea52cf4aa2a37aa8cd43f1bbeed281a79a6aa1d07368872c_Device=CPU_Config=() -184:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=93ce70e605eb712479090e3a266e86eb7422bf0fdd3acb1c38a0b92a9c381e2c_Device=CPU_Config=() -184:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=d5cd3fb647dd4a57feb28366d922a151a3ffb1707864f2ac85595fcc30f222be_Device=CPU_Config=() -184:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronPriorGridGenerator_opset6_Device=CPU_Config=() -183:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f0145ffb8d2846d866b1a89c8217d54209830e6d3d0d10913e75af42f2510c74_Device=CPU_Config=() -183:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ad4c3d2d3f258a4be14846d9d26203008e01b2832ff004bb8a23ff05c72747b5_Device=CPU_Config=() -183:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=86d8d42c30e423e801b5d4d832f87cd6837bf9feb3c546f5bf87e04f842a04f1_Device=CPU_Config=() -183:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d69304b651805edf18138147ec5a4c16e883ad5e5d9828db849a35249c28b263_Device=CPU_Config=() -183:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=3d37166487c5c52af657343f8fa10903efc7d580d5b370a519a0ccfbf6fc56bf_Device=CPU_Config=() -183:conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=() -183:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=static_IR=7065a836f4fd77a07431ecff6bcc591ef9b0160cb5366a8f3c8b8fe5f83f7be1_Device=CPU_Config=() -183:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i32_Shape=static_IR=db87efd37ce8dcbe14286197df3b7a345fdc46ccc03d7d8bda17e3791df332aa_Device=CPU_Config=() -183:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=bbf75e5f7aa9f20f890a8eb204ddb5f159ca5eae0616fb99ee0b5169b165d595_Device=CPU_Config=() -183:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=33aa0d800115f94b07bce9c6ca8b4447f2c4f442bff77cb9b02b23d2ddabcc01_Device=CPU_Config=() -183:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=05c2f891e743416ad510bf0ebf713738bd41258123cc4bbdc5cf067f251e35d8_Device=CPU_Config=() -183:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d56533ce961113b2ca0baf02f3ff9f8ff210264343f6bebf26418a35ecf36b02_Device=CPU_Config=() -183:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=ba1b92833f2c8734c5178762b6cd8c847c23027ecf79ebeba295c39b667162a1_Device=CPU_Config=() -183:conformance_GatherND/ReadIRTest.QueryModel/Op=GatherND.8_Type=f32_Shape=static_IR=58581d0746e5bf56df7df18df87d35371d41ff69ba09c7850c8e96354c7910b4_Device=CPU_Config=() -183:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=dynamic_IR=8029d5dae7f4721807eb717310512bad44630efdd0a64962496a0fd802a12325_Device=CPU_Config=() -183:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=5498e895212b57b42748644679c1dd67936f230d2c61998ca6bee31d527035cc_Device=CPU_Config=() -183:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=76ef553ce6e6b782a200e030fcb744ed737623fc3a8c9c8faeb0e05691c5a55c_Device=CPU_Config=() -183:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=030fa97d19aab57ae9eb898fe101353fdc76bbc034d4574971c68ef254006c85_Device=CPU_Config=() -183:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=b077af9b63e937fc64589d3007372d5fb2e4accc392ea09889a2519e3885413d_Device=CPU_Config=() -183:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=e2d1f4fde3dc1889d4f86004173ea34a9d9836f645730727f5cdf90bc0738361_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6eeea9355df867c7fc97af81dae6d02799239ec1e480dc2c975a60761fc5f7be_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=b7aebb27d8d2b43e770ade887778c291072210b947b77b1b92e05d3327843977_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=992d8967c619d96c75985952485fcd79b943ac5e71c40457eafad4b71bf56a4a_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=952a43f4c368721e0c69418b71fe89982ef1eb2be0671653cb1200e34cb4bda3_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6e73ec183893b70ec42a4393f3b1b7c55767a14f630eaab0c3e3b6d22c6b8e26_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=a16b5a0ea2fc8d89980db21cab743fbf776918ed2ed1f91f2e4d3ad3c304d4a4_Device=CPU_Config=() -182:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=63ba45deb14e56e09574bd3694e3d94caf6ab09f67f5278e6c299c6c924a3cf2_Device=CPU_Config=() -182:conformance_Transpose/ReadIRTest.Inference/Op=Transpose.1_Type=i64_Shape=static_IR=d4acbcb1930b26610eaa33c0bb8aa7fd866d8142afda9fd007226f0ee6fa5c36_Device=CPU_Config=() -182:conformance_Split/ReadIRTest.ImportExport/Op=Split.1_Type=i64_Shape=static_IR=68115f3a18f8ea201078166547e9c2a8587a5bb37646adf6f90da976f7298386_Device=CPU_Config=() -182:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.1_Type=i64_Shape=dynamic_IR=45a9a897d75b175e3d805e74ec09322789564e0c0e8d9535724f262a9f534572_Device=CPU_Config=() -182:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=efbe921ab3c27a093f20ff704fd02e5c610e7507d94a2d2092379c5a99743380_Device=CPU_Config=() -182:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=86cd07b4db06e4210732553cace1797b55c19f590e2d9b7814eb30485d8599ef_Device=CPU_Config=() -182:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=i64_Shape=static_IR=e8fc48c9bceee1462572c6aa8c5afbda94a9d6e8760deea1c9a3d04d1d797fb5_Device=CPU_Config=() -182:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=4555fb7029260c7e46403e1fbc99a3815a94373b7b08d2408277976173facc37_Device=CPU_Config=() -182:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=23654f4a28ae697d81f49d72568e7f0657d5c15b82e173fd7381760ebcb61cda_Device=CPU_Config=() -182:conformance/OpImplCheckTest.checkPluginImplementation/Function=TopK_opset1_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e4be028a5a300682b79da2f015dd1c1b13381b38b19bb76951e1f26439173212_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c599f8f5de2a73e08727a5e27e2f77989b4c5ce9a5e70e6b98ce4c87e8aa26f5_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a9c40d7a1ada834400ffbdff779b9970c83bd576891dfa7f637182cadf9e9681_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=879bb4767167c3e9c45eacd08a14fb7e01b072864013784f924d62aad7b37c56_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f2685b40efb789012e69252fa0fe30803c68be724a52dbcda9b2cb796138ea57_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f2403b7d119fabadb1609250bbd0959aeef2cd68c62a4036657518ebfbcedf71_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=125693eeea442dd24dd812dd2eaf8d2154274f5975d68b0132d2bf9bedfe0ee8_Device=CPU_Config=() -181:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c3e5791580edfc2b522c8a3aecd33445b3fa8d771e2b5a8387ef0f303773c848_Device=CPU_Config=() -181:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=2e38326f5f0527299a0385fc3bb6c85c80e12e5bce07fe530624aba7113e82a6_Device=CPU_Config=() -181:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=() -181:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=75aed7fbb8f7d7e8a1281d4a16c4fe2e55160dfb9e6a1bc446913a223c5aa0de_Device=CPU_Config=() -181:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=() -181:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=dynamic_IR=66df22ce11e7009aea35ba6a11b4294eda44815bf041eed0721499a3d2c484b1_Device=CPU_Config=() -181:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=acaf36c12445c608b306074ac4e2be9cfde2f5550905993d4b5bd1714dc96aaa_Device=CPU_Config=() -181:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=32537f045cce3d13cb28dd292a0ebe06e13002877d9ed2e5b25d3ebdf5afcb58_Device=CPU_Config=() -181:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=i64_Shape=static_IR=e8fc48c9bceee1462572c6aa8c5afbda94a9d6e8760deea1c9a3d04d1d797fb5_Device=CPU_Config=() -181:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=1e95665a92aa6efcc7e06d24fbe4cb2afa07d75374cea3ea928658a270ef489b_Device=CPU_Config=() -181:conformance/OpImplCheckTest.checkPluginImplementation/Function=Minimum_opset1_Device=CPU_Config=() -181:conformance/OpImplCheckTest.checkPluginImplementation/Function=GroupNormalization_opset12_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cdc57df56ccf890a00f886c3b83f504d24ea9d4ed5f0ef05f1189879172777f8_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9beef927f57c512d381a87a35982fe4ca7a00b9a9d50ede54f7baecc5ec7fa0c_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=be4634976e408d799217398ce693fe430fd46cdba6c78e01e9b824c208856128_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=78db1c0e2c0fd4f0d351e66ce9cd31f7a6ee804cd23bc686b8c9081125b7142e_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=506b15e531d5a643d3276fd84af8e10eb2a62ce20fe3aeda90c50cd7442e0a88_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=deaa5ef98e478a5850df528107031c9c7bfa6305bc7507325c91b98f9337b0b8_Device=CPU_Config=() -180:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=86decc829c047a5febe7e5d047c689075810441a2f4725088317ef68d6c31239_Device=CPU_Config=() -180:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=f32_Shape=static_IR=0832e6deae4ceb25b92cdfa532fb5d5fadfe7fd7a00b79f630ddb5bc011986ab_Device=CPU_Config=() -180:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i64_Shape=static_IR=7e88dcf638caa6058b01dd6c31ba40efb0fca8077cc295ca63c2ebe4c7298926_Device=CPU_Config=() -180:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=b06553539d6e27195623fcbce51610b5671dd70700bcf61703a1f7a8bbc7c5d8_Device=CPU_Config=() -180:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=e1130d42d591780dd2a746ce7ff874a2bf4725ca9fd09803932ba4a7b0b389aa_Device=CPU_Config=() -180:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=d3155499ccf835bc57e4ca19c25ca32fc63ecede0a2c43ab2a3e43ba4a6a4dcc_Device=CPU_Config=() -180:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7b8d235013affb9589d57a8f99b36858d739258b787cffc7cec85d1dca567261_Device=CPU_Config=() -180:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=593116ea16692c8f5a8994c0562c47e1c627f9088c519b752a635a7d91973085_Device=CPU_Config=() -180:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=059046ce67f6b09ef45aaad5724e28fdaaf40afb92613740fd058c974a120d3e_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4c794e0e6b27bbef5d21922537d8b23d0d2b5955622c1f5ee724a4d8faf2c86b_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=20450a7796284bbdcb011ce027d5c7260ed7dcdf07e4d39e48d99a2162eaae51_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=847ce287888e882e988cdd5bf41277c32c207e38215e1e7d41439890037216db_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=dcfe0aa2fab0afc3b370be59184a5e59c7bc0e8b2930bb671d1d6b38f55234ea_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=71c0c7e3176ae8b233352c89d47a61394cb46695e7879118ed02070a4a23d5e1_Device=CPU_Config=() -179:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=deada5d69a05cf27af659254f89b4e53e6685c517fdc2bb8a250cb5d4ba0a3dc_Device=CPU_Config=() -179:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=static_IR=5f8b64ad8dd9ccd202ae8d5080ce166fe9f47b909e803da49546dbffdfb4ab3d_Device=CPU_Config=() -179:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=static_IR=6a8fb5f2948de2436a33999ee2a01e239193c268f61634f1e80692b0c45aa3da_Device=CPU_Config=() -179:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=85d1eaa250a32acf89b675cc50f513ef3c7df50ed9d68f2cff2fc89db41b63f2_Device=CPU_Config=() -179:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=i64_Shape=static_IR=41a35ec8a58f581cb2558464a66077408e961b57821db604fe525d492d4f4fbb_Device=CPU_Config=() -179:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=936ac30f388261cb12776b5e94062a9b5f7b81aa16c9aa5d8f994b8d69231c40_Device=CPU_Config=() -179:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=static_IR=44dceb7343477ff50d3de4be1567a57a97d2e3c6f92b48fc93d20eea80487862_Device=CPU_Config=() -179:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=12965dd8a422975f08bb0fc707c666ad7ae2671d09c68757d534e3a1d67efd41_Device=CPU_Config=() -179:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=0b603f9cb63e722122080ea36f76fe45b25da83b0b1e213871140e82dea5f405_Device=CPU_Config=() -179:conformance_ReduceProd/ReadIRTest.ImportExport/Op=ReduceProd.1_Type=i32_Shape=static_IR=e34207bf06e51dbf322bc0db76f3a9828ae018b02dba2b1826ed97004bee8125_Device=CPU_Config=() -179:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=ae7b6a45a538bb7f65d5895f2f7941fd9048645482faa40adb1f773e282a946c_Device=CPU_Config=() -179:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=c0eaf7f2465de396f92db5829a30b7d887dc26bc8d49b86f0fd0d688c7129e18_Device=CPU_Config=() -179:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a08cb2499595ed0de5c51e3b0feae24d9d5462d227572e771862564e1875b6ef_Device=CPU_Config=() -179:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=510b36fcb991c73abd98b488eff26715dde08a322b7b9429cd897dce6976dab9_Device=CPU_Config=() -179:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=f3d704d4f0da6c58c39e279d727dd82fe0e59a41dbaf09a3cbaa8f591daf95f7_Device=CPU_Config=() -179:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=176c218db11ea18f367fdf98a3de14e9a9c65152bbcc39783c38772b37f6e9c2_Device=CPU_Config=() -179:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=static_IR=489201dc4d1a937b4387f1b7d01f75fa42ff02d7035d39ac6a7f56536b0d3a20_Device=CPU_Config=() -179:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterUpdate_opset3_Device=CPU_Config=() -179:conformance/OpImplCheckTest.checkPluginImplementation/Function=AdaptiveMaxPool_opset8_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e0f4f91a6470af49c5e2497ae8fa917051879c18dd1e39cae18d159b697e8fec_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8eef79ab2081a12ed39f5c6f8f2e917d14685f54ccd0fcb0e19865740ca7d608_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=22dc864b06ef0c7deb8aecd74a26c7bcf75eee316288284413fb61381d79425f_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1b46ce72aadab0dcf92991f242e971bbb36689e1bcafecc68d646aace43291ed_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=13f3d097d5e17c2add48d6f9b6f86454a1b521408d7fb8252e3638d9f17ea6fb_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ca72f78cc4db6d46ce969f61c5bf707507ed8204785159e1ac5130e7aa251858_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=59bac5d30704b81def0385b29fb8d79e459a71b9251b4f6e94116524bd9aa7be_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=35d15ad61ee34c17abe50c4a67e568c2e253712c2d63cb828b0bccdb2175a6bf_Device=CPU_Config=() -178:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=b6e76f65817017d4cbe3504634568430a419a30e418a5febf75b89b566ca3631_Device=CPU_Config=() -178:conformance_Slice/ReadIRTest.Inference/Op=Slice.8_Type=i32_Shape=static_IR=e256f7acbc71e64cab857fb6378a035096c7ceebdd4f867b5140d35865cf6532_Device=CPU_Config=() -178:conformance_Slice/ReadIRTest.ImportExport/Op=Slice.8_Type=i64_Shape=static_IR=38f6cef69f6a7d9886b5d38902fb76e4ae41385fb3c95e229be4b44456ab2e87_Device=CPU_Config=() -178:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=56fb4fb30ec6fd9ddd0ff2e394434eb87546ac7de273f47b663252efa2a380be_Device=CPU_Config=() -178:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=427900d25144ee6b8cd4b35cd53c6e9335375018f6328dd01ae4db304846d991_Device=CPU_Config=() -178:conformance_Range/ReadIRTest.QueryModel/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=() -178:conformance_Proposal/ReadIRTest.ImportExport/Op=Proposal.4_Type=f32_Shape=static_IR=ea8cc682a9a36cc61498573e967ec64d289af84a9e3da1911085b1de4fea4c82_Device=CPU_Config=() -178:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=065b3de2617f318d1376e9610f9fa1a2f2fc04292f9a7cc949780ae41d3539b4_Device=CPU_Config=() -178:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d12581f68d14d140f4b982b47b97000f6b666cd115483247d369fed87267556e_Device=CPU_Config=() -178:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=0d6cc305ea05df2178e3b4ea61ba2f296655e77af08556491e0dc8dfd46bdc6f_Device=CPU_Config=() -178:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=510b36fcb991c73abd98b488eff26715dde08a322b7b9429cd897dce6976dab9_Device=CPU_Config=() -178:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=a35667a1c5401fb3102a59ce0fa67d0ea4829f8ce282c43767517ce025469bac_Device=CPU_Config=() -178:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=2001ebb8291c8bc8cd1db17c172f216cfb3994c57e344eef65565ea9f9cda1d7_Device=CPU_Config=() -177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2ce1f8773e871f8aed0d3541cfafba0bb079e1765f04c1336af8a47f354cd766_Device=CPU_Config=() -177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0e5b8f44656b680d14f7b7aa3293d8933ebfa82524d6acc09e41d38e8efda726_Device=CPU_Config=() -177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=93a9a06d14c3b4d51891ff0e704c74dae5905db9b5de06d31379f33fa685c80c_Device=CPU_Config=() -177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=319f74dd5b7a959d0e5443c76051fa5958463cd18ec11c275ef92b77321bb93c_Device=CPU_Config=() -177:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=2d153f841ff4b6825fe5b8399105916112addb79300aa00df85409c88fdd70ec_Device=CPU_Config=() -177:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=005e1b57ad768f4c8efb3116fe51bc85661c377e6632518b9172e8862d1c3edc_Device=CPU_Config=() -177:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=e1ea320702cf8065ce85c325507a199b95dc9ffce3fa715b4d8195ca67a5a374_Device=CPU_Config=() -177:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=c3ef1d1e09e7c0917298070d6909b455d5962c4bf3adf8d2d4c04f0741141f1f_Device=CPU_Config=() -177:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=e0641a7f9e64123d0d51a75e576fbd0e405105b8ead44a618068e77d2b4bf933_Device=CPU_Config=() -177:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b78ffc69401084763d529e2aee12f9b9793bc92be3eca3df2a97730b9a252ce3_Device=CPU_Config=() -177:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b15fd62115a849e0b5226ebe9162cda9371ad2783637a518f2a8724d24710253_Device=CPU_Config=() -177:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6624c22e3b5d72c4e8d21df59af6f3759fa4d8fa68f2b5f3f92a98d6a943d0b4_Device=CPU_Config=() -177:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=489201dc4d1a937b4387f1b7d01f75fa42ff02d7035d39ac6a7f56536b0d3a20_Device=CPU_Config=() -177:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=55c7f63e25ddf106ebdab6f4eab66f1be6950cf7a68abdb5b7e9a395d2fa6add_Device=CPU_Config=() -176:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b2931a4972ae4f946778af45cd5824e6958dcc1fc79cea4da1032590b2663d16_Device=CPU_Config=() -176:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=23f7f775455e615175f3122ce422ee96de019ca40fe603b5a4605d51f28210b1_Device=CPU_Config=() -176:conformance_SpaceToBatch/ReadIRTest.ImportExport/Op=SpaceToBatch.2_Type=f32_Shape=static_IR=8acd95619121cb22760fd92815b1ba85f541f282d3860e910f73036ed335a9ee_Device=CPU_Config=() -176:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=cb67c5d0b8712ebac00fe4169f0cad2e0a8c71d7f9603d5d2ce6ff6dd6bc055e_Device=CPU_Config=() -176:conformance_Einsum/ReadIRTest.Inference/Op=Einsum.7_Type=f32_Shape=static_IR=1c6cbe8477d09b0b193ddf9a453c1b6a8a79e3d1adcdf1c096709cee7a4866db_Device=CPU_Config=() -176:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=23ad83652d315aa08ee781b0fc81c0eb737265280c85a86a4f08cad71b33e74a_Device=CPU_Config=() -176:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingSegmentsSum_opset3_Device=CPU_Config=() -175:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=49245e23b8c1c485428d0e490a687e48c541bfb833eb7838efd8c112736a076d_Device=CPU_Config=() -175:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=1f429cd9b96a0ae8b336e874e911d2cdb79820b76030c61de8a1c057a0c33168_Device=CPU_Config=() -175:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=cf334277b64fe023019fb7f007aae9ebf7432b733a1876d6cd61bce6a204e0dd_Device=CPU_Config=() -175:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=static_IR=7065a836f4fd77a07431ecff6bcc591ef9b0160cb5366a8f3c8b8fe5f83f7be1_Device=CPU_Config=() -175:conformance_Tanh/ReadIRTest.ImportExport/Op=Tanh.1_Type=f32_Shape=static_IR=2b026a0d21a35251b07099e31ec58c459b848602575d2afa67e55830e8f3f411_Device=CPU_Config=() -175:conformance_SpaceToDepth/ReadIRTest.ImportExport/Op=SpaceToDepth.1_Type=f32_Shape=static_IR=9296c80cc93d8ab7448140ad2f31b3b47a0759c383d1bc045704985503732195_Device=CPU_Config=() -175:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=978c328422e3866322f3bdd52955690a47a1fdd47ddb9db66a4707b36a535dbf_Device=CPU_Config=() -175:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=810f13adb3f7342c7d514bec2aa3f20d7a59527b54c7f6954b038efb194c5ceb_Device=CPU_Config=() -175:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=68f6c55980c58f4d6de9e948d1c034b712cf74de509d8fd825fe7f7dfb11550f_Device=CPU_Config=() -175:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6f2159bf315f062962fe87512c15ed5cacf09f898397a92b690c32caf147e50e_Device=CPU_Config=() -175:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=152333527a542f3e2228bac5d0fd4ed288dde9205632a318b9b22b64e43be329_Device=CPU_Config=() -174:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=eb33c5485ec10ae4f1268ab19db6a4ef86812d4c92680b43791274bb055e2220_Device=CPU_Config=() -174:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=94693638ec4742dea16dc168eb9323995f1b2a35a53f577cf58ac3a08096892d_Device=CPU_Config=() -174:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=f01fb29e8f5ddc7562e954e46b1d2bdbe6144d6bbe2ed2a0f16610f2812ac721_Device=CPU_Config=() -174:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=dbee34cd3b708559af1ceb5fcf89aac35add00fc1b9e3eda2beebb2d5b629fc1_Device=CPU_Config=() -174:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=b94b5361ee75b3684455c2b871b656a50c72e325564787c302a714f222845b26_Device=CPU_Config=() -174:conformance_Range/ReadIRTest.ImportExport/Op=Range.4_Type=i32_Shape=static_IR=8d3863956a8a6a5067c45d40ae0207b14b9f1736bdf2a5b8c01979fbc012a5e9_Device=CPU_Config=() -174:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=d36c5ab59d2ab873aa35b35a952e061568edd4ee8e64c1ab200bea63472a97b3_Device=CPU_Config=() -174:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=7201a55d869ac6072af38ff89dfac3cfd2e6720d25f7607c6cc5f80040a8e82a_Device=CPU_Config=() -174:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2bb16e2257294e3f7d905f66a483a8210f392ea822836e4edcf8910a7fbb4277_Device=CPU_Config=() -174:conformance_Exp/ReadIRTest.QueryModel/Op=Exp.1_Type=f32_Shape=static_IR=9416264710da7447d7e3bced32d5275e81b03a897ad99eed5291cc94ad77449b_Device=CPU_Config=() -174:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=c0c1a43608279d8870258be63005b38e23fe5501876c87840cc16a0bb2cf8dfe_Device=CPU_Config=() -174:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=beb6b43d96ce20db13ecf6abc53742fdc20d2221ea66af01e3c945348acf9bd4_Device=CPU_Config=() -173:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c9fa96695ebc82ee5e83b4cde8910e54ce09611f304f24fb6b3faa692a21c60f_Device=CPU_Config=() -173:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=1f6be1a43c786bfbf35baad6ff643b762e9d63c069c884a69b4ec6e89062ad7e_Device=CPU_Config=() -173:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=() -173:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=168e02701204a8f0e325fa1a2a4407612df10c3218c9431981fa6f1f8300eec2_Device=CPU_Config=() -173:conformance_Power/ReadIRTest.Inference/Op=Power.1_Type=f32_Shape=static_IR=6837cea94eff6256c3c29807532662e123ccbffde1fcb6f75875d65aa7124a4b_Device=CPU_Config=() -173:conformance_Power/ReadIRTest.ImportExport/Op=Power.1_Type=f32_Shape=static_IR=b434cd386e4c5e688aac8da3425d2ed0d72961223eaaa1cf2ff951a88a5fa001_Device=CPU_Config=() -173:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=d8432e7d31bcf4d95ff7ab845a6858ea67cf751c7ef0fca60a9bab1d187fe3cf_Device=CPU_Config=() -173:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=6745937b3d592b8cc1729ab2af1888ce58502379a33f0ae5d5a3eb0e70c0bc87_Device=CPU_Config=() -173:conformance_Exp/ReadIRTest.Inference/Op=Exp.1_Type=f32_Shape=static_IR=9416264710da7447d7e3bced32d5275e81b03a897ad99eed5291cc94ad77449b_Device=CPU_Config=() -172:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f83f2d7d9c08aaf30635b39b51c0d7f1f622b4624da59c6cbcdf28d42470f11d_Device=CPU_Config=() -172:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=86decc829c047a5febe7e5d047c689075810441a2f4725088317ef68d6c31239_Device=CPU_Config=() -172:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=07b4c5d05754987a0524385690d79f74988302f437597b7477770e8d062d72a0_Device=CPU_Config=() -172:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=8fc5ce53f1f6b924371ab2cf156ddbf7aea234b17befdcb6206ba51a7ad988c9_Device=CPU_Config=() -172:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=fdfd59e3d316eea2f9fc3c56664cf1a07603bb6e26d1b367987d5046526ac60e_Device=CPU_Config=() -172:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=c52cc9f84ee56b9ced415f830d9f251e52d1dc56a3cace6548b3d345d2b1e812_Device=CPU_Config=() -172:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=41a35ec8a58f581cb2558464a66077408e961b57821db604fe525d492d4f4fbb_Device=CPU_Config=() -172:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=1d7cabddc96cb4ca2ed111c9f7a9c31b76ed9a052fd0b79db6bdc8fc55f24a4b_Device=CPU_Config=() -172:conformance_Sigmoid/ReadIRTest.QueryModel/Op=Sigmoid.1_Type=f32_Shape=static_IR=b6a75c5d2a686eae53cc25c6b107630b31a8a4d8c6514980ed1a97754f33bdcd_Device=CPU_Config=() -172:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=7744b2351d112ed761ebe0f43945f7dfd58fd2bfbd94bc5a4737549923caf4ed_Device=CPU_Config=() -172:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=e48a363cfdabe0b62509e21641bb1cc88edaaa7d2eb82bf3ce747cab8355ff3b_Device=CPU_Config=() -172:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=8de81b7de05bdd151427e1b5b03a8b4222284dafd31f9d4b1c3d0917995e9310_Device=CPU_Config=() -172:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=a58fb7847e59bb119656b143af0c6f65e29f8211034fe7aab03666cdb95d7fe1_Device=CPU_Config=() -172:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=66a4d902b67742a95e2d41d79b9d2434e57a55c168a88049624a0ccb62df9ca2_Device=CPU_Config=() -172:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=de3245d77d2e004bea85af29c91e1668ae1b6905fe2cdabb92711adbde6406a9_Device=CPU_Config=() -172:conformance/OpImplCheckTest.checkPluginImplementation/Function=NV12toBGR_opset8_Device=CPU_Config=() -172:conformance/OpImplCheckTest.checkPluginImplementation/Function=Floor_opset1_Device=CPU_Config=() -171:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c6b8f476c9b5cf1a102cb33d5e68033bb074a520d01e360ff46b3e479addf407_Device=CPU_Config=() -171:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8f622d39d560109549e99d37f3c9cb476f4d69e8525e7a0ad8fce6fe79a6f982_Device=CPU_Config=() -171:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=b08690e29e0249d5a6a30f2ad886ec714067df994bc4d8cbd82d0d02af6335bf_Device=CPU_Config=() -171:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=cb7ad9dd22a7bccd73ade4d4aa78f9a25cc2bb7f0c08a01064491200089b3718_Device=CPU_Config=() -171:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c990afda81456723598f8f4085cb476376b1789d7f755e340e1d5498bcf02080_Device=CPU_Config=() -171:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=125693eeea442dd24dd812dd2eaf8d2154274f5975d68b0132d2bf9bedfe0ee8_Device=CPU_Config=() -171:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i64_Shape=static_IR=45bae87afb2c7e7f0b7315334e33b8a9baf42d81b95b844cb4987dd3540f1dff_Device=CPU_Config=() -171:conformance_Split/ReadIRTest.Inference/Op=Split.1_Type=f32_Shape=static_IR=7f806d6c4a0ff3515dd9a092fee2ab14a5f363fd5fbc7503d64a8cec4bb1cca3_Device=CPU_Config=() -171:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=6aff57130da7904e5d2300c4962f104d31c704872d5c33bbda4bb38efc34d563_Device=CPU_Config=() -171:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=a29bdaa31edbcf7b3dc392625c0aa0a27e827e1363d52519858c93defbf9ebac_Device=CPU_Config=() -171:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=b9f9ac285915db9ef3e7437728695f2833d165757ffc81afb88242e7b471f434_Device=CPU_Config=() -171:conformance/OpImplCheckTest.checkPluginImplementation/Function=Asin_opset1_Device=CPU_Config=() -170:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9730f247ba4a13fb03274850f295de500156107d33db957188846fe49c2f4566_Device=CPU_Config=() -170:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4e6262ae12e4f9470a87cc4f1cc1ef2a817a8080e25a79ca4ef67cb60a558b41_Device=CPU_Config=() -170:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=18763287c1afb7684d3f74e91fbb8a8c17a13aa52908a5d97b6ad220c5c4f633_Device=CPU_Config=() -170:conformance_VariadicSplit/ReadIRTest.ImportExport/Op=VariadicSplit.1_Type=i64_Shape=static_IR=7adee81cf21b942334c25378325f61e13e9ee3ac95ae004d4d9efceaab6c0949_Device=CPU_Config=() -170:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=51390fa8c8a5680ae4a8de4f655083caefbb8445dac8814d2b1827e2bd43f470_Device=CPU_Config=() -170:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=4541365c567e68739f0733edba54e889f231026025e6866f805446392c575960_Device=CPU_Config=() -170:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=21950c433f50ded0f662b9e0591e756a8dd685bc11a8296bcacc57ca1a4968b4_Device=CPU_Config=() -170:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=b574ee57274a9f27f6d0908cef2645c458983225e3cb82c455148e83337ee3ef_Device=CPU_Config=() -170:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=1c91956bf0130fd338f8f11cf76a08dcf5fe3c6c42239fa6a6aeb517eeabba36_Device=CPU_Config=() -170:conformance_PRelu/ReadIRTest.ImportExport/Op=PRelu.1_Type=f32_Shape=static_IR=41ea59b807081adea7869609c65776a42f88079ec22180807905d5c2e8ca0777_Device=CPU_Config=() -170:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=87f3815fd73265960ef5910a3b03580b13e96d02784e159a0bf0ebc30bc911d5_Device=CPU_Config=() -170:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=5b466c4e4b53a5ea739df517da47f0764f9e31197b7d30fd9dabf17d1b33a489_Device=CPU_Config=() -170:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=() -170:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=beb6b43d96ce20db13ecf6abc53742fdc20d2221ea66af01e3c945348acf9bd4_Device=CPU_Config=() -170:conformance/OpImplCheckTest.checkPluginImplementation/Function=DepthToSpace_opset1_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a5e5b588f6223da1508413c42c21c3945994f492b039511b7ba2e576a052a52a_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=43d871d4b2b3346c08f8582b892ba0c0017d77688e16fd6d69f83f8101e12a69_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c219261f655fdb1bcfbcc367ca8f6c4bdf0dc1fbeb7413343a3f0bdd74a70857_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=6adce7c66c1630295ec8938bcb429f20b628b0ceed938bf81ac0fca8580f8d34_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=43d0f2c259414c3e23105e2f5a13e8faaf322904d9b70ceb8a056bdb51677ef6_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=be4634976e408d799217398ce693fe430fd46cdba6c78e01e9b824c208856128_Device=CPU_Config=() -169:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=9a26ec9d1e0c4963016ff36986c79f5faed763ca5189215923d375e43c70a17c_Device=CPU_Config=() -169:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=4341385bd87226eb41493c667323e8c1c39817983a48025192209270750eed06_Device=CPU_Config=() -169:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=f32_Shape=static_IR=1e5127a9c21ad1ccabe67dd1f1e28a3730c09ba294ef1f9fc001c6dcd723ec62_Device=CPU_Config=() -169:conformance_Sqrt/ReadIRTest.Inference/Op=Sqrt.1_Type=f32_Shape=static_IR=33aa0d800115f94b07bce9c6ca8b4447f2c4f442bff77cb9b02b23d2ddabcc01_Device=CPU_Config=() -169:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=e2ab1cf295df4df47d43e632065bf8a48fa58e6f3a6d1bc971b45fe97a66652e_Device=CPU_Config=() -169:conformance_Maximum/ReadIRTest.Inference/Op=Maximum.1_Type=f32_Shape=static_IR=78239cbf0f8d473af2209ad3d9297e02208c110efa7af981f8c09ea7d7290032_Device=CPU_Config=() -169:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=6289232b1cbbafc963ac3cd787330c81a9cd02def9fefb83d6f6cced249de92f_Device=CPU_Config=() -169:conformance_GatherND/ReadIRTest.QueryModel/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=() -169:conformance_FakeQuantize/ReadIRTest.QueryModel/Op=FakeQuantize.1_Type=f32_Shape=static_IR=848caca8b0b971d54e9c9b715b8bf35e0a33f1274d50a946384e64e5c0843a96_Device=CPU_Config=() -169:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=a6ce8e7d0cf79a4e800c911d6aec8f178a39642718eae3f8e9a89f7adc05dc64_Device=CPU_Config=() -168:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=89ed1d3c7fa6e15c01df3b792a183ade5b90edbb87886e1d58db075566b60a92_Device=CPU_Config=() -168:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=588ef4d887ae9d8ad432525108c81a9762dc27490a3e01d3e86795c73275148b_Device=CPU_Config=() -168:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=7e386c35d9d397e043876a23a2b9e5885964cee59bf46f1ae0660e6a84641ea4_Device=CPU_Config=() -168:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=817b3db8f96297276bc70f1b4854867cb92c164925c9dce59a1d054e3c315bee_Device=CPU_Config=() -168:conformance_ReduceMean/ReadIRTest.Inference/Op=ReduceMean.1_Type=f32_Shape=static_IR=33d84638f606d759354e190991899e47d2f4c63b0e378aac985e5fb9132dcd01_Device=CPU_Config=() -168:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=a8ca0b23e0a0f66247fc693c6a8982e4f7daa11e14da296db0dbc9277fcad4df_Device=CPU_Config=() -168:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=1409169e395a3eb90f9235b74f2f8c94e0e27a63fae33cda153d991ae1cbb68d_Device=CPU_Config=() -168:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=154d7358887845b8f2a661e79ef57318fa9499ee5c19b7cae461b6f798c57b36_Device=CPU_Config=() -168:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b53fa2c9b93d3750c17dfb8ef75e51c43881ee79fddc863d6c1c2adfeaeaba2e_Device=CPU_Config=() -168:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4694d5512c7f6b97213ae6c93eb6f547e57922279edf34b94a8e45b7f6a9a980_Device=CPU_Config=() -168:conformance/OpImplCheckTest.checkPluginImplementation/Function=DetectionOutput_opset1_Device=CPU_Config=() -167:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=4a9237e5cd29f0d2d5e738891752c6f6b29c9dc4c29d130b9c9921ad5787f819_Device=CPU_Config=() -167:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1bae1a851b5bf95921ad7666e48803dae416315a20a3ddbcc1c81243cb5bdede_Device=CPU_Config=() -167:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=69c87ccfa0080f65ed28b9a088343db5ceef524ae917b8e259b1865a017df22f_Device=CPU_Config=() -167:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=451a3b635d3882a87cc0d7b3f6f74197c08b708669751bb11fef93da9604e276_Device=CPU_Config=() -167:conformance_Equal/ReadIRTest.Inference/Op=Equal.1_Type=boolean_Shape=static_IR=9e166ed18be64949ce2451a1dc981381040fb109ee60e13a7f47308caac73e24_Device=CPU_Config=() -167:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=4fe6c9c924477957512c3d32086ca167fe5a4ddd5cd1b90d5d32452f6de8317e_Device=CPU_Config=() -167:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9cb8bb36dacdb562fddf77e93890fba560c6cdf038921e057e21f3e5e458c88e_Device=CPU_Config=() -167:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=83cdc5670c74aa0db5a1c14e70c45552cdba1c9e1f4d55c83398ce51abf80393_Device=CPU_Config=() -167:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=58cd9ea3d8db317b6ff7fca55bebcbc6846aebdbe309b1b621f5535b18a70320_Device=CPU_Config=() -167:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=117fd22d36b97216edb2112c043ba97872b9b7915d7909dfc395406e8ad91e4d_Device=CPU_Config=() -167:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=550d5d475e0f53be8506153a78626cd5a5c0a949b9bbd9e2fea96a4ba2f7b908_Device=CPU_Config=() -166:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=2e06088cb191d8d26309843b1285b9ae4a1eb0722e1370875edde7fd2783851b_Device=CPU_Config=() -166:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=i32_Shape=static_IR=b4f42a7d1252f2dd02b31ac7b0cf4ffcbd452dbf0e508833e7dc709ee04889c3_Device=CPU_Config=() -166:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=d683b96d525bc074d4f8c15934a5082a3fba1068b591f67e4b05d605fe5e6aa7_Device=CPU_Config=() -166:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.1_Type=i64_Shape=static_IR=36b9b7be1407243aad0792e7a49ef25f7c3e3791dc1ff93cad40480837ba87cf_Device=CPU_Config=() -166:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=() -166:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=97181a6433949eaef7277fdfec4f8f94b27463ee3ed4a6aefc678fdaf7eab4db_Device=CPU_Config=() -166:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=a3add607f5e37633f3298794f8e32e409e3403666af3c0fc57c7d4427b714eca_Device=CPU_Config=() -166:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f4b78bee713f23abfda124ca92d58828eeab6118710d93572a491cfd85cd05b4_Device=CPU_Config=() -166:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=c3f8bb35f2f4473c563c3e5171a8fdc6f7a0ae20e4acde31a578bd20630952fa_Device=CPU_Config=() -166:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sqrt_opset1_Device=CPU_Config=() -166:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExtractImagePatches_opset3_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f977fc239a0230860702f8c1971bd424f10b978bb03937668c37edee6777f12b_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d962e7157ea216206d6c5b11fe5ef6ee162a1f7dc20f84a3b058e405c324a592_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c39e4c1d9cbf5b8730644e1686cc09f36f7e4a4b89cadaf8d8902fdb27993a7a_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=15197edec77da431c491f42f64e86a811d89a337bf44615824226425b1c64d28_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a9d3d025df92369ee1f1a81fe676bb00d7d6cc488868e04d0e713fb9e42451a9_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a6b95dd49e84f2860b57f1f1ab6fe2baa265bb757112e53def3004a360053aa8_Device=CPU_Config=() -165:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=77dbcc61a98e0bf3c1bdcbec543818a8a959751f10b8ec1489b66570ff4e634e_Device=CPU_Config=() -165:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=38d935b0aa7266960b3d349b60c97bb15f535faed953fbe3ff24ae2560828f04_Device=CPU_Config=() -165:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=0fcad2ddd1c7b81bf5e88ef4d4abb26a33326a37fb0cceb1205c1efd2a2d3615_Device=CPU_Config=() -165:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=a30154a78e0e565a598629670b87338d03582cbe4ed5547256634ddad7bc9d5c_Device=CPU_Config=() -165:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=dynamic_IR=c838ac42d5464130a9049a63f7020166b34e2ef974c257a4060fa02c3b70ff76_Device=CPU_Config=() -165:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=() -165:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=() -165:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=36f17a498b10c140f8a319d82e5c8f2cc3cdb7eb3be9f82f7ef35d9c9470231d_Device=CPU_Config=() -165:conformance_MatMul/ReadIRTest.ImportExport/Op=MatMul.1_Type=f32_Shape=static_IR=f5d3b4ec51e032e4df5dae00ecba1a3198c29cba96c72b8c89126c4638b715d3_Device=CPU_Config=() -165:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e7e10785757d3131ebc375ebfd83c556e2c34a72be20965d9dd3e4f24a5ee2f9_Device=CPU_Config=() -164:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c2539b8a06e5dd0e01933c6861e366f8ed565e5956b8b2546647b55e966e7755_Device=CPU_Config=() -164:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c6abba035865ece7c6c44b0284ab7c6b8f735bc1ad1f75a9ee3bae6ce26c58fa_Device=CPU_Config=() -164:conformance_Subtract/ReadIRTest.ImportExport/Op=Subtract.1_Type=i64_Shape=static_IR=c52cc9f84ee56b9ced415f830d9f251e52d1dc56a3cace6548b3d345d2b1e812_Device=CPU_Config=() -164:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=ace54c326bc8255cd741eec12762e4d8f645fe93d50c037effce893745f8fdb5_Device=CPU_Config=() -164:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=e08e84b17997c1b1279429161d287720e4c7deb0e6d055539149bc577ed3b104_Device=CPU_Config=() -164:conformance_PriorBox/ReadIRTest.QueryModel/Op=PriorBox.1_Type=f32_Shape=static_IR=cedd3bc0f0a8e20fe947135bd6ab9515283275867e1b837d36f2fac72363f449_Device=CPU_Config=() -164:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0534fdfa97228a6aacf4ed196a9ace8e09d8e4decdcce058176b0312500b6c07_Device=CPU_Config=() -164:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=5980eb1b6c7a44c7812f89f10f0741e5925abda9ad07e1a82ae2a3310abae74a_Device=CPU_Config=() -164:conformance_BatchNormInference/ReadIRTest.QueryModel/Op=BatchNormInference.5_Type=f32_Shape=static_IR=c602b01c85ee95a1d7deb1498c5f0494a5ee727ce8874d5beded8bf33631d0b4_Device=CPU_Config=() -164:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=dynamic_IR=edf223c654667e60869d97d2fb6a2bdf356db8d7e997b4b9a66e56445bc24f30_Device=CPU_Config=() -163:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fd97b6aab7b86b0dd2f8c0ce622601e80f3b864d23d7d4f61d2dfa42195936b1_Device=CPU_Config=() -163:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6b86bf4f834b297dcb461acb5854aeb9783a381521ea1a8e1cf4fbeb60d6d09b_Device=CPU_Config=() -163:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=610a8f8c44b0e133d4b5684c37017859d06bb2251482eca0cdece0a1c216b936_Device=CPU_Config=() -163:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=47423c3e9443249e3dbbf58ee0f5b69b15e677f84de44ddb9d2851d1341dae96_Device=CPU_Config=() -163:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=2ad5b63ed56c3966570062970125d1cac16629595e9ac34c6613cf00d6dec0aa_Device=CPU_Config=() -163:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=69f4c39c3fb2dfc55714893e1e45761238e74bf28ecfadbee3f4965b5a379888_Device=CPU_Config=() -163:conformance_Select/ReadIRTest.ImportExport/Op=Select.1_Type=f32_Shape=dynamic_IR=848de524e27e13a1e5b33e5db3cdf2710ba4566c3219a018e878f998c07dd718_Device=CPU_Config=() -163:conformance/OpImplCheckTest.checkPluginImplementation/Function=FakeQuantize_opset1_Device=CPU_Config=() -162:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9ea20be5797b5ab937555c69751a5be584c73a191b3fe3d6fb96a5665e26fcbb_Device=CPU_Config=() -162:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=77dbcc61a98e0bf3c1bdcbec543818a8a959751f10b8ec1489b66570ff4e634e_Device=CPU_Config=() -162:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=1f429cd9b96a0ae8b336e874e911d2cdb79820b76030c61de8a1c057a0c33168_Device=CPU_Config=() -162:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=static_IR=591cc5abb16f22cfa720e53be695097b83c42a971536fb5b79d0b02cc4ad328b_Device=CPU_Config=() -162:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=1bde2f2a7294810531e23de80f25a451b3033487b5919c949b708b273dc3973c_Device=CPU_Config=() -162:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=508a961c358d40ddb6906694a24f87dc24f74cb4643aab58ee1d6fa28f099e6b_Device=CPU_Config=() -162:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=0d6cc305ea05df2178e3b4ea61ba2f296655e77af08556491e0dc8dfd46bdc6f_Device=CPU_Config=() -162:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=98c0b6c23e4cf51a6069f306109ea2b4e181cfb8e552482cc0d0e63c61406933_Device=CPU_Config=() -162:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f49b212b59261888a5ea4652f9a4cdfe25657c7a0e4d3b6ecc16255e8d2e8cd5_Device=CPU_Config=() -162:conformance/OpImplCheckTest.checkPluginImplementation/Function=Cosh_opset1_Device=CPU_Config=() -161:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f99caac2fbfafe61a686cc29c0df0779eae1a0a1826f5bcb820048ec3c148207_Device=CPU_Config=() -161:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2b59c9f67435c46699dc1c66ee7ddbdd333bfa544d0aef7bd1389db2635868c7_Device=CPU_Config=() -161:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f66bbeb796e4da5d462ef573e38fe52db5bdaf2367b2a07aeedae6ce33c6704f_Device=CPU_Config=() -161:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=445a2c47e85b116d03e5f6fe43863a39778b78ca5175fba1bb0eec669f7610cf_Device=CPU_Config=() -161:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=0f3e035b6571da159267ff1f89b5f2b2d3bbd599760dc5d5721a1fb2ab2ea75d_Device=CPU_Config=() -161:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=c0c3d43548fe20fc4e63bcfc8ee6d0a70a6076dfc0ee79e31fdcecf6cf35921c_Device=CPU_Config=() -161:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=0832e6deae4ceb25b92cdfa532fb5d5fadfe7fd7a00b79f630ddb5bc011986ab_Device=CPU_Config=() -161:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=4541365c567e68739f0733edba54e889f231026025e6866f805446392c575960_Device=CPU_Config=() -161:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.1_Type=i64_Shape=static_IR=26d97c755f660ed8ee08a0de8d6ab88598391cc79b239bfaf0a102722ffc4bf7_Device=CPU_Config=() -161:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=6e8dbb054c99609e5aedd642130e867c22091118e0bb7ddd870a66dcfd11452f_Device=CPU_Config=() -161:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=() -161:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=d8574c324ded923f1ea3ab0d8e09c626f3e8a04efe08258b665539c639b7958b_Device=CPU_Config=() -161:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=453c1f5bb6c2e9c81a04475c49696c6e9e94f77853ef961e1839b541de7c7e21_Device=CPU_Config=() -161:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f6f3c6d199a224ee983f6905aa4f72ea4138e6076d7307c72588dda0cc9c6ed1_Device=CPU_Config=() -161:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=439308ddb64edf02f96ade09e7888cf89f422fbdb8c8242521ecc3f93e61bdd7_Device=CPU_Config=() -161:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0256d48640841a9233553afa85e34dca797e6b5eedbd772f606c1a0e6f8e91a1_Device=CPU_Config=() -161:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceL2_opset4_Device=CPU_Config=() -161:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalOr_opset1_Device=CPU_Config=() -161:conformance/OpImplCheckTest.checkPluginImplementation/Function=Bucketize_opset3_Device=CPU_Config=() -160:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e86061c75b7e9a65644e82de6b8fb2a532ebdfb302f46f378b6ff20af8d1d14b_Device=CPU_Config=() -160:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a956d2fb1fd17e2d864b3eaa8915cc0c4f9a768e35fdf5bf20cf6bc7f41aa130_Device=CPU_Config=() -160:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=526afcc4dff58aaa019466b0440b94dbd2d5f14c060d47b8ec40183deafecd83_Device=CPU_Config=() -160:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=8bc8753f4d26c5d1f2ea481937dcce0f5b78971f18f5ebb258f49d4a0d86a333_Device=CPU_Config=() -160:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=8832b317ba58dd0efd1e8fa5238d35644d8468a03c9b35809a20ae64098dc986_Device=CPU_Config=() -160:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i64_Shape=dynamic_IR=51390fa8c8a5680ae4a8de4f655083caefbb8445dac8814d2b1827e2bd43f470_Device=CPU_Config=() -160:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=1942042c790c3fc6053ad91fa5e45f8ebf3c11bff7e3427a71b8fdc1bc5db053_Device=CPU_Config=() -160:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=c52cc9f84ee56b9ced415f830d9f251e52d1dc56a3cace6548b3d345d2b1e812_Device=CPU_Config=() -160:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=f32_Shape=static_IR=2f23f1158754aa494abbf61ab15118173a7ccfe90523b2b9ab7cc3a6fdaa0e37_Device=CPU_Config=() -160:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=b94d2ed6a2b113922805a69578ec5ba2ba3d8f0ea46ca37f095b4ccc94d76b77_Device=CPU_Config=() -160:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i64_Shape=static_IR=5d791fd5b82a74a42073567349728035c4ac52ea64c1a154a73bd4e61d1b42dd_Device=CPU_Config=() -160:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=() -160:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=d9231cf5e3e491e318f16514e771cfdee4b781b42fc9d45088da850ab48079cc_Device=CPU_Config=() -160:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=a9b0552d84d057a656080c8e302afa30962dc02105abe7136cfd77f0433eec18_Device=CPU_Config=() -160:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=b61800abac107b248c29df7ba04a73c91d490782b1da46164c1b7d2f8cec3cdf_Device=CPU_Config=() -160:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=dynamic_IR=f42d85c8e1388cf2cb69f9efb2970255c6535f1c3f904a9b08cc18cbea6aa6c3_Device=CPU_Config=() -160:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0ac57f7cc81a683585f810885288fdaa174de2497d00156b85e067653aad3a56_Device=CPU_Config=() -159:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f89a1dfd0ef8b50a998962d5a4f4b54451ea4c533476a2e3d42c04e9e645afaa_Device=CPU_Config=() -159:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=eb98c3593d72ffaa01de42caf4832854d9486b4148c57742c6dd72a251f8cb45_Device=CPU_Config=() -159:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c14aca93b401d9d2325a5396c1489e1fa29aaa57f592cd2b4e6792ba5af90a90_Device=CPU_Config=() -159:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=348254d0e2b145f9e5443b4d4470b2ab29487acbb34a71285a5c0e1bd29cb942_Device=CPU_Config=() -159:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=5f43b4d027388fff204c9c64df9f62bd2a72034143bd655e45121ca886c5d15a_Device=CPU_Config=() -159:conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f99a212a117855e6e2dc4a338444a8ecee441f989638f7a0700ce24e037d29e3_Device=CPU_Config=() -159:conformance_ScatterElementsUpdate/ReadIRTest.QueryModel/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=() -159:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=3c7c072c9e4ee694e049a5f256cf0e72caf85384291ee8d399ce136d22c575a3_Device=CPU_Config=() -159:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=99183013393075553f5cd30818ccd603ff5d3e9e71dd8f42ced0df2377280729_Device=CPU_Config=() -159:conformance_MaxPool/ReadIRTest.ImportExport/Op=MaxPool.8_Type=f32_Shape=static_IR=10cf1b7a4de1231ad721c9660697d6ee17bcaa2151f08eef596b41e6e3aa1b2f_Device=CPU_Config=() -159:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=dynamic_IR=e255ef2321233444ce6e4fdeb513a9b271987457aa9bd456948b64f589de1e2b_Device=CPU_Config=() -159:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=453c1f5bb6c2e9c81a04475c49696c6e9e94f77853ef961e1839b541de7c7e21_Device=CPU_Config=() -159:conformance_Abs/ReadIRTest.QueryModel/Op=Abs.1_Type=f32_Shape=static_IR=5713be8dd761def00c701c74d0aa913d259206eff1103b9fa6de0f6f1a25e566_Device=CPU_Config=() -159:conformance/OpImplCheckTest.checkPluginImplementation/Function=RandomUniform_opset8_Device=CPU_Config=() -158:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f7cf7cbc88dec99af8d35e65e926745ad318706c454b90740a19589285733fe9_Device=CPU_Config=() -158:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f0c4dee4dcd8f03dd599ae04d7dd6ccfafc4d900d052a62f232a5507ffc006f0_Device=CPU_Config=() -158:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=eaac9340f5625cd59856645684fd84a5f1f0703dd3748eb85fdff2eedd8ee64a_Device=CPU_Config=() -158:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=6e1207753b08d53b18c551ad07a245243197370051be78218db028f3d3b835a5_Device=CPU_Config=() -158:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=static_IR=8b759b2f1999be207aeb39763bde3eba4aee028e9369a86a87493ff86f3fa014_Device=CPU_Config=() -158:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=dd6dc9060efbe22735c22c69f0323c7e6a77a30cfbaae7b79670b9b26fb2be70_Device=CPU_Config=() -158:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=978c328422e3866322f3bdd52955690a47a1fdd47ddb9db66a4707b36a535dbf_Device=CPU_Config=() -158:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=98c0b6c23e4cf51a6069f306109ea2b4e181cfb8e552482cc0d0e63c61406933_Device=CPU_Config=() -158:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=0b0005b038a938c698489da595fd89a45d2f685c831bc172d81b2afc09658dae_Device=CPU_Config=() -158:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c1852c534b8b95bf1a9aa2771decf2368fa095c5f5688d38ab9ce0bd86152a19_Device=CPU_Config=() -157:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f1f52703006b7d81ccadfa1c54db42d8b19ac7b8beb3ee88f2d7252170358d90_Device=CPU_Config=() -157:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9aac77567d944de6632688fd3de80c0b3da1ee741da639897c2104d3121d690b_Device=CPU_Config=() -157:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=57b104f3a1796c31d59d676d9f6d65789ed72fb21beb382bf418c452b8452d27_Device=CPU_Config=() -157:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=9bae5a53011ecba6327961e6496f3312134c81e148523434968c3c56b5e0c491_Device=CPU_Config=() -157:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=725aaeceedd7eba9be6ba4203e31cead733ed80dbafc33e902465d4338dc8f4c_Device=CPU_Config=() -157:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=() -157:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=f73224b14c094974e582d3d903cc332f5c1da138368692e5d0be93127f1bf753_Device=CPU_Config=() -157:conformance_Exp/ReadIRTest.ImportExport/Op=Exp.1_Type=f32_Shape=static_IR=9416264710da7447d7e3bced32d5275e81b03a897ad99eed5291cc94ad77449b_Device=CPU_Config=() -157:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=e0641a7f9e64123d0d51a75e576fbd0e405105b8ead44a618068e77d2b4bf933_Device=CPU_Config=() -157:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=a0cee5b220a433f1d76460a1f452bfc26aae12f7b84983a063605b4a8cd0a5d4_Device=CPU_Config=() -157:conformance_CumSum/ReadIRTest.Inference/Op=CumSum.3_Type=f32_Shape=static_IR=d517f63a168293380a1f066313e6a2bacef9eddf961ce164f11ce2609a632b3a_Device=CPU_Config=() -157:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=d34bccebe88a4093c9810d56088e4bf07b55bdab1801d7d830360aea1be22499_Device=CPU_Config=() -157:conformance/OpImplCheckTest.checkPluginImplementation/Function=Squeeze_opset1_Device=CPU_Config=() -157:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReverseSequence_opset1_Device=CPU_Config=() -156:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c08b3d30c1b4f1b5456e4791d4d7fab1d21f743dff0dac1ae5d09abc6764fca8_Device=CPU_Config=() -156:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=582f7347a93cb2c9e51ade6c405ff25b23d009bdcd3d7a3c49902e627a041252_Device=CPU_Config=() -156:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=09d4b4ea324f91ba6006bad4c82ca08e723c83c1b862d8075475e986696220da_Device=CPU_Config=() -156:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=dynamic_IR=24920893b72e3bdf88b7e4142d1dd9ae0a679f686a3b187bf740f014d04b9ade_Device=CPU_Config=() -156:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=d5f5f2d39bfe4ccc6f12f76e5eca8e2e40ac7ac6c5f38a7cac21970df213d4cc_Device=CPU_Config=() -156:conformance_Squeeze/ReadIRTest.Inference/Op=Squeeze.1_Type=i32_Shape=static_IR=5224ffd078708e8917b14b4118bc4a42317c123dc0a5dca8234ad73d44daf845_Device=CPU_Config=() -156:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=d9eeac72636735d7541c2d0ef14ebfc7d4a1b3598c08c136a9123b2ed89e13ef_Device=CPU_Config=() -156:conformance_MVN/ReadIRTest.ImportExport/Op=MVN.6_Type=f32_Shape=static_IR=ea71ab322d6f3d74b0a7bdc3ff5dfd322f2d8c518a1fb5bc9960c5e04808f28e_Device=CPU_Config=() -156:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=a35667a1c5401fb3102a59ce0fa67d0ea4829f8ce282c43767517ce025469bac_Device=CPU_Config=() -156:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=bb5cb4e2a8cb9be32332ed3255c99de478d8d2e31cfb1747aa322df438ebaa49_Device=CPU_Config=() -156:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f0853773e26eae3d051504ed8db7f182c0e90ef7b45625a1a72ac51a73e2208a_Device=CPU_Config=() -156:conformance/OpImplCheckTest.checkPluginImplementation/Function=TopK_opset3_Device=CPU_Config=() -156:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMCell_opset4_Device=CPU_Config=() -156:conformance/OpImplCheckTest.checkPluginImplementation/Function=CTCLoss_opset4_Device=CPU_Config=() -155:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f9f701a7d26d77a2b1eb3cc822efb5da95f1edbe614469f725a381ce892d8d91_Device=CPU_Config=() -155:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e5249d5630503351688090f1a9d0143b02e750045924aee8f9003072446583f4_Device=CPU_Config=() -155:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=429b91023f3ae9a323e40ed372fc29926fcd6aa7a8e77e4ddaaf68fa648c43b7_Device=CPU_Config=() -155:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=8de274a65748ff76511a53b614cfb33651d2b51720714851a16976fc1ee2b6ea_Device=CPU_Config=() -155:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=134ff6b704123c583b694d7023c99cbcfd10a1afc48819ef35b46dc4d0bca500_Device=CPU_Config=() -155:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=c30414e8e845d75527c26f62880518cc4d24c1a528b20cefc3b2c32be7436c81_Device=CPU_Config=() -155:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=dynamic_IR=c117722add2db4a6eee4dc2fbfb99174911d54eb3896c65097d31d656fdee639_Device=CPU_Config=() -155:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=a94e0bbcae35d7cb33efba2c6df3275f7bca8520ddb37eeeab81829906fc8964_Device=CPU_Config=() -155:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f0472c0e5ff8fb82651424269bd9f77e73eff6c43c70b6192f07303c0d35db8e_Device=CPU_Config=() -155:conformance_Greater/ReadIRTest.ImportExport/Op=Greater.1_Type=boolean_Shape=static_IR=dce38966c13ac9886c7480261e3483d822355a9bf3835d00795e7627744a60d7_Device=CPU_Config=() -155:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=5498e895212b57b42748644679c1dd67936f230d2c61998ca6bee31d527035cc_Device=CPU_Config=() -155:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=99e405218c1a96c5f8af65aa814893d8958e8e991d1ed8dbbbd586efa589df39_Device=CPU_Config=() -155:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=09683cb2a0a44acb804a2791ca93bf004bfc3882c11af94ea67a9fc1eb1e5052_Device=CPU_Config=() -155:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=2c114b0035075d866c028f9a1168725375feac9a666a881ae6b7db6e9066bb3f_Device=CPU_Config=() -154:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=e8df0b3ab9e127c1d37881f4c250ca0fd0dd2ec822cd24bf95e7860484fe9b8a_Device=CPU_Config=() -154:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=874c0fa19029457645c4cff20769f66ba7aaa1a35ade84c948f83aaa9c1ead19_Device=CPU_Config=() -154:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=f2df871f255156043f03f34333d59d9213fd52ea24f69dda1b04888ed269acad_Device=CPU_Config=() -154:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=823c1bd1ce8ee0ae28410bcea9f3c33ef9f9271e8f41f0871a7d6eb6b2850757_Device=CPU_Config=() -154:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=6745937b3d592b8cc1729ab2af1888ce58502379a33f0ae5d5a3eb0e70c0bc87_Device=CPU_Config=() -154:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=a6ce8e7d0cf79a4e800c911d6aec8f178a39642718eae3f8e9a89f7adc05dc64_Device=CPU_Config=() -154:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=474e4bfe52232239280bbe4e2d2aed15cf69c7ec8db86b010084c6e68a8d0e1d_Device=CPU_Config=() -154:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=14f4dcbc8e714fdb791d15b62646db0da2cf647d431dd6ea044ca6976ef51753_Device=CPU_Config=() -153:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=37f1a0a9bb9b948ed78217a65a5a2de7f0234b1e000fe5ee11ede68767240f1b_Device=CPU_Config=() -153:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=static_IR=2e38326f5f0527299a0385fc3bb6c85c80e12e5bce07fe530624aba7113e82a6_Device=CPU_Config=() -153:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=c7a696f3217515ef4ff5eb46fbd15af6533f0fcd268398fbd434f105c0a11328_Device=CPU_Config=() -153:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=e1ea320702cf8065ce85c325507a199b95dc9ffce3fa715b4d8195ca67a5a374_Device=CPU_Config=() -153:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=b459cd78b41e36a6c3823301811fd3322a77f802ffc3399eefdfd8ffa4ce6e6c_Device=CPU_Config=() -153:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e0293184207036f6016f557f8df813c6536b18332f589245c5c606a3b36df1e4_Device=CPU_Config=() -153:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=053d601716750db93af5ae01d67213086ed987370f9ff59723824dcd0a6c2462_Device=CPU_Config=() -153:conformance/OpImplCheckTest.checkPluginImplementation/Function=Range_opset4_Device=CPU_Config=() -153:conformance/OpImplCheckTest.checkPluginImplementation/Function=Multiply_opset1_Device=CPU_Config=() -153:conformance/OpImplCheckTest.checkPluginImplementation/Function=MatMul_opset1_Device=CPU_Config=() -153:conformance/OpImplCheckTest.checkPluginImplementation/Function=I420toBGR_opset8_Device=CPU_Config=() -152:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cbd851b8c4e89bce3a20b8795b3bc5a0105d26e252a4674541ff630496144aaa_Device=CPU_Config=() -152:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a9311932565e68fff052e15c1a0522e1c09270d06521541ca28b67c34184b1c5_Device=CPU_Config=() -152:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ba15b8b85609531d91c7809eb90c3a0079d19d36b83c8767306cb276c9d67ace_Device=CPU_Config=() -152:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=static_IR=9c1e1b695646ea4f56a87b7e5a815c12856f718920e01e86ed78f2dcaf896a37_Device=CPU_Config=() -152:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=i32_Shape=static_IR=75f0349e33d0151c276e3f5ce34f7c1a71f5572331157b2e34f889773d7d8754_Device=CPU_Config=() -152:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=aa757ffed4165beb3074da6ad09422d7823a1d0d6c8a654adc56343d0e43dc66_Device=CPU_Config=() -152:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=33d8f6d258ae8dfd09b8e6fd39f0e74384eabfb685e0e72a3c798101ea56a1d2_Device=CPU_Config=() -152:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=() -152:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=d8546655166c322e3049ed3a71725c8e89901212007c44c8029ef8379de96db6_Device=CPU_Config=() -152:conformance_PriorBox/ReadIRTest.ImportExport/Op=PriorBox.1_Type=f32_Shape=static_IR=80cdfe1797800671134d77fa9c7032cdc1b19b4905fcefb11399610216f6e623_Device=CPU_Config=() -152:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=19a94fc5cfe3ab1b4e169b342ec8d9f0fdc4ef19484c8c34d6ab938c6e7bf5fd_Device=CPU_Config=() -152:conformance_Equal/ReadIRTest.ImportExport/Op=Equal.1_Type=boolean_Shape=static_IR=9e166ed18be64949ce2451a1dc981381040fb109ee60e13a7f47308caac73e24_Device=CPU_Config=() -152:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=08ba7fbf736896f373ea81dd727940aefae22a39e217e84dfc5617ed62133d10_Device=CPU_Config=() -152:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c3c821b46d994404c55856237eb70534cff33687df2bde0a86d0bcc9f20878eb_Device=CPU_Config=() -152:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7f30f8f46d999a18110b8f8f9235b3534249be45e55f1aacb419126ed1eb5851_Device=CPU_Config=() -152:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4fb0809c5cf2945a097d18f445de6f4f5cd2c124cdb495e6f0a12e9d937e2b80_Device=CPU_Config=() -151:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=3888863c4f725445490846561b2aef4a5498ef1583903b365fb864e387eb9641_Device=CPU_Config=() -151:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0aa7024ee856fc832b1e639fbed60e1382c8e1b84f7cf2d33447f4bbd9ce75ec_Device=CPU_Config=() -151:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f2eb693da69b0ad1af3bcef6c4af46ba2b92897f76989c310a65aac5c2027725_Device=CPU_Config=() -151:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=boolean_Shape=static_IR=474c6273d1e48e8e5885966dc93629ad413683ad942e3101452c1a58fb5b5af9_Device=CPU_Config=() -151:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=139cc84777f1e0d489245d058877303e72a93eba3cffbf5f919de21b4514bb0d_Device=CPU_Config=() -151:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=6745937b3d592b8cc1729ab2af1888ce58502379a33f0ae5d5a3eb0e70c0bc87_Device=CPU_Config=() -151:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=25ae6295f4d206fa9069e20bc659dbd87c20aaa15c3f149ab25d003641c738c5_Device=CPU_Config=() -151:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=80e0900e8270dfbd0fc879ad4d065847f767cff9399688bb9e5e03b8531c554e_Device=CPU_Config=() -151:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9b64733aa0a8994cb3695a7c26f905f4d2b86c2e157edbd8a9970d33970a4015_Device=CPU_Config=() -151:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=008176749f0b2cb46830abe910865d8cf1974cd62902ce3e157a03df2b1cf9c3_Device=CPU_Config=() -150:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9f8fca1ab855d5a71d7acabdefda202e270bf16b559fd581f9e663caa301ffd7_Device=CPU_Config=() -150:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8ad9f9e5cb26eb922d7d7d80f93be2e9d3a5ef344a013c9dd546df2ef195ec24_Device=CPU_Config=() -150:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=21534d0488c3f7c8bd40bc81476832e866000c97ee6892359826c7877905d733_Device=CPU_Config=() -150:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=bea169459345470ab5d89e5ae9a8b67d6e9401caf7dc35f5060805152e20d6cf_Device=CPU_Config=() -150:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=1fe78f5a88510b70fb39ed088e1418ae09155d179afc3a614a641b4e8f86574f_Device=CPU_Config=() -150:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i32_Shape=static_IR=e6ee69f681f9388da19dc9c17781710c5622ecda436aa2d4b018578548acebc7_Device=CPU_Config=() -150:conformance_Reshape/ReadIRTest.ImportExport/Op=Reshape.1_Type=f32_Shape=static_IR=d9eeac72636735d7541c2d0ef14ebfc7d4a1b3598c08c136a9123b2ed89e13ef_Device=CPU_Config=() -150:conformance_Relu/ReadIRTest.QueryModel/Op=Relu.1_Type=f32_Shape=dynamic_IR=43ceadf05184954dd8697d4f737de323ec2ee75f93e0d33d60dab2acc995f3b6_Device=CPU_Config=() -150:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=f18fa21106120cecd81f50d635b1c42cbd641877ffbf78e746ef7375ff546d7d_Device=CPU_Config=() -150:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i64_Shape=static_IR=a2450d07c12669e586815e60d9a2b568f88a49c9b63730c898b9eae907b5ec4a_Device=CPU_Config=() -150:conformance_Erf/ReadIRTest.ImportExport/Op=Erf.1_Type=f32_Shape=static_IR=906676850a62f56935dbd13792be1013db602488f29eb757a546b411699ccdd5_Device=CPU_Config=() -150:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=a6f5b58b1d85e5a99389748ae14e507302127e583c436dd9e6015d3c33ab0536_Device=CPU_Config=() -150:conformance/OpImplCheckTest.checkPluginImplementation/Function=NMSRotated_opset13_Device=CPU_Config=() -149:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fc8b85b03281a7e8532a130a70fcfce5b6c40b1c8863eaea3910013a0bc4e769_Device=CPU_Config=() -149:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=883597c2c4e004b0ec1e1ca8d1b75395c714fc6a99cd31e35ca0597d0ccd8f8f_Device=CPU_Config=() -149:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=7e88dcf638caa6058b01dd6c31ba40efb0fca8077cc295ca63c2ebe4c7298926_Device=CPU_Config=() -149:conformance_RegionYolo/ReadIRTest.ImportExport/Op=RegionYolo.1_Type=f32_Shape=static_IR=9f19f32ddff44c1c8f7dc3b9b244a9191a15fef9874e016666fe6a817937f699_Device=CPU_Config=() -149:conformance_PriorBoxClustered/ReadIRTest.ImportExport/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=() -149:conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=static_IR=81eb5381e1d4d3dc7cf0d83a9cd787813d3267c99b31cc9a3cb0cf9b01727c0e_Device=CPU_Config=() -149:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d7ce9fd9d99a7ce9ebb5fdadb4db39f4ea66f74788704b2b9f96660c7403c031_Device=CPU_Config=() -149:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5adf6fcb72c0d6086a95fbbc5744e7d02dfb32490e0f42c62b57bc98489b801c_Device=CPU_Config=() -149:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=586094b4ff6617c08c87a53c7be1ca26aae40657c8d964d81eda731dbb27e848_Device=CPU_Config=() -148:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=6a9a72aca963de945d97658e484453191cf6af26cd6838c1603299aff3a49a8c_Device=CPU_Config=() -148:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=16b3235d5271e534a1bc725f80e2bfcb837a1c6f144bcfe8211a3e5359644441_Device=CPU_Config=() -148:conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=41d80c815a196293f7d22af59f5f602f7e4f11e06208a693b19743fb796b98a8_Device=CPU_Config=() -148:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=f32_Shape=static_IR=8f7dc81bfce05ce39b694fe48197a4fd2aa7933c7061508be3b9dfefef518f75_Device=CPU_Config=() -148:conformance_SoftPlus/ReadIRTest.QueryModel/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=() -148:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=7685da6dcf91a208b72d5961c2c248d816de501366163d61b1ee3c148787fe77_Device=CPU_Config=() -148:conformance_Range/ReadIRTest.QueryModel/Op=Range.4_Type=i32_Shape=static_IR=8d3863956a8a6a5067c45d40ae0207b14b9f1736bdf2a5b8c01979fbc012a5e9_Device=CPU_Config=() -148:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=3effc90c24c0eb76bbc89809d34c6541654366a02e21378a668dd932a6cc7756_Device=CPU_Config=() -148:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=52ee24baa14f302174ce3b13a119ccb6a54994413daa1f052a75464528b07088_Device=CPU_Config=() -148:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f69e74dc680137ec5ef0b63e38d451da7bf1b61d2acabab77df46b76c9777402_Device=CPU_Config=() -148:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=577ff3f9c8d226d1899056073c0223ae2d81dcc940c5fef8b9ce9cf63931e9e2_Device=CPU_Config=() -148:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43aed1509066aa7c839a82c9865228ce3ebdfbe519061649807875ec6e86d715_Device=CPU_Config=() -148:conformance/OpImplCheckTest.checkPluginImplementation/Function=HSwish_opset4_Device=CPU_Config=() -147:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=cc3619fbe03f9b98ff07babc5c11f9bd9f26927c8d793abc7188595145bd1371_Device=CPU_Config=() -147:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=() -147:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=8b55c14423b60f30029c68c603417fb98119c5922e2827c60c99edc05ea813e1_Device=CPU_Config=() -147:conformance_Tanh/ReadIRTest.Inference/Op=Tanh.1_Type=f32_Shape=static_IR=591cc5abb16f22cfa720e53be695097b83c42a971536fb5b79d0b02cc4ad328b_Device=CPU_Config=() -147:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=i64_Shape=static_IR=38f6cef69f6a7d9886b5d38902fb76e4ae41385fb3c95e229be4b44456ab2e87_Device=CPU_Config=() -147:conformance_ReverseSequence/ReadIRTest.ImportExport/Op=ReverseSequence.1_Type=f32_Shape=static_IR=a5cc0793d73f7f76fc02b5ae04ef2a29bf212ce5c59f9bbef91e0aa5ee17785c_Device=CPU_Config=() -147:conformance_ReduceSum/ReadIRTest.ImportExport/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=97a94ab826d2992013df32a4f93f6adbc38ad17a26503005046f68904adf53d1_Device=CPU_Config=() -147:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a08cb2499595ed0de5c51e3b0feae24d9d5462d227572e771862564e1875b6ef_Device=CPU_Config=() -147:conformance_Erf/ReadIRTest.ImportExport/Op=Erf.1_Type=f32_Shape=dynamic_IR=e6f95710a782b6c7df8397480e5cffbfa773fdf4ef11c93b2b1ac4694313b080_Device=CPU_Config=() -147:conformance_DetectionOutput/ReadIRTest.Inference/Op=DetectionOutput.8_Type=f32_Shape=static_IR=d3155499ccf835bc57e4ca19c25ca32fc63ecede0a2c43ab2a3e43ba4a6a4dcc_Device=CPU_Config=() -147:conformance_CumSum/ReadIRTest.QueryModel/Op=CumSum.3_Type=f32_Shape=static_IR=d517f63a168293380a1f066313e6a2bacef9eddf961ce164f11ce2609a632b3a_Device=CPU_Config=() -147:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=static_IR=488c8e933df63c1368e021869a92fd48929ac252863ed4c2acfab7174b449581_Device=CPU_Config=() -147:conformance/OpImplCheckTest.checkPluginImplementation/Function=CumSum_opset3_Device=CPU_Config=() -146:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4746fb4d92aab20d21eeb0885d35c88abd50aa250298473f5bd143658eef2316_Device=CPU_Config=() -146:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=24920893b72e3bdf88b7e4142d1dd9ae0a679f686a3b187bf740f014d04b9ade_Device=CPU_Config=() -146:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=8e80bbd29743e87a0a6d4158a06249766b6a9cf424cc1c0ed3c6f60e30e6db58_Device=CPU_Config=() -146:conformance_StridedSlice/ReadIRTest.Inference/Op=StridedSlice.1_Type=u8_Shape=dynamic_IR=4d2c49ebbc46b60233510b63e280442319496782da33185f7c2d6003611f937e_Device=CPU_Config=() -146:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=dynamic_IR=a99a5ab2de2d408c2e40ad5734c9bd5ab4d1d221f4dd24572e05538b134ef88c_Device=CPU_Config=() -146:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=3d24c272ca88d4ee24f437a310abc05340e110f8596beb6a1ef96dd18818ebbe_Device=CPU_Config=() -146:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2bdfd42ec67d330dec8ea2817499b4c2d32a3d91deccede902acba057b050c49_Device=CPU_Config=() -146:conformance/OpImplCheckTest.checkPluginImplementation/Function=Tile_opset1_Device=CPU_Config=() -146:conformance/OpImplCheckTest.checkPluginImplementation/Function=Power_opset1_Device=CPU_Config=() -146:conformance/OpImplCheckTest.checkPluginImplementation/Function=Log_opset1_Device=CPU_Config=() -145:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f8795aaaf3fb96028b8cdcc963cbdff4c3362d78c4801af4172a73a3cd843edc_Device=CPU_Config=() -145:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c4ae9be783990e398b3e8f0af76cab50d72c40c705677a3fe1c5dea592952d1e_Device=CPU_Config=() -145:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3500be960a489d618c1ff6345c1d6788d17c43786c10a7e7b630586920bce356_Device=CPU_Config=() -145:conformance_Power/ReadIRTest.QueryModel/Op=Power.1_Type=f32_Shape=static_IR=3ca9994321c7492af9bff158852a484636638e711ae39a6acb66d273f696906e_Device=CPU_Config=() -145:conformance_Equal/ReadIRTest.ImportExport/Op=Equal.1_Type=boolean_Shape=static_IR=857447d7e14c7516667094409cf5ef351000344fe170570671be0f71834d04f9_Device=CPU_Config=() -145:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ee1f9348ff09a058dc09cd63581663590521d463d14b785a23ccd3cd28110b5b_Device=CPU_Config=() -145:conformance/OpImplCheckTest.checkPluginImplementation/Function=IsInf_opset10_Device=CPU_Config=() -145:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronTopKROIs_opset6_Device=CPU_Config=() -145:conformance/OpImplCheckTest.checkPluginImplementation/Function=Constant_opset1_Device=CPU_Config=() -144:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f166c58732107cb0c82859af62b8fc0d3d144468ab66ff4615a1eb4bd325d3c4_Device=CPU_Config=() -144:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=eb966d8fd7e1301280e6ef709dd785d210a35a1346eb88c3f38379bd96036ce4_Device=CPU_Config=() -144:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c6abba035865ece7c6c44b0284ab7c6b8f735bc1ad1f75a9ee3bae6ce26c58fa_Device=CPU_Config=() -144:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=13dad9a80315de728323f8d84534389c4840a92e74073be42c312c46107fd964_Device=CPU_Config=() -144:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=dynamic_IR=8b79cf070ed44bdefd5afbe86a81199e189fa486c42190795419dbfc7cc26d6b_Device=CPU_Config=() -144:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=static_IR=5bfbbb826bcb2c9e7b5364fcc5da23e737953150029c2ea7455ad4b09caaf01d_Device=CPU_Config=() -144:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=3ade42cfc9d970963d8f162b001075864e6967034198986f408ec09ce4093d18_Device=CPU_Config=() -144:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=95afe52c888afd5c641ad2d6d0c3f8491f039af2c6938b91fe6fca613ec0b6ab_Device=CPU_Config=() -144:conformance/OpImplCheckTest.checkPluginImplementation/Function=TopK_opset11_Device=CPU_Config=() -144:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceLogicalAnd_opset1_Device=CPU_Config=() -143:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b339277c7465442a5163600e784319030de12cab4005f43c0b903bcd0c46e87f_Device=CPU_Config=() -143:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ac40c4284a523b39af21eda7394a11b9ca2f2deb5263c03c92c0e217d34bedad_Device=CPU_Config=() -143:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=() -143:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=28e31d83986a1435f11ba6355b98472025fcf2c3c6e090103283d9486356b5de_Device=CPU_Config=() -143:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=i32_Shape=static_IR=38d935b0aa7266960b3d349b60c97bb15f535faed953fbe3ff24ae2560828f04_Device=CPU_Config=() -143:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=1366ff72dd5b68a3faf25de8f98e4ac5500663b1aac4941af11532ea2ee769d3_Device=CPU_Config=() -143:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.1_Type=f32_Shape=static_IR=2b1509d227d4c32fee4bb0b7ac59d4ecf5018afce9fd19714067a20d01933455_Device=CPU_Config=() -143:conformance_NotEqual/ReadIRTest.QueryModel/Op=NotEqual.1_Type=boolean_Shape=static_IR=8fe4bce2e674753d81a1516280769a06cdde538e658ae548087e4888ffa2905f_Device=CPU_Config=() -143:conformance_GatherND/ReadIRTest.Inference/Op=GatherND.8_Type=f32_Shape=static_IR=58581d0746e5bf56df7df18df87d35371d41ff69ba09c7850c8e96354c7910b4_Device=CPU_Config=() -143:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=a35667a1c5401fb3102a59ce0fa67d0ea4829f8ce282c43767517ce025469bac_Device=CPU_Config=() -143:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=0b0005b038a938c698489da595fd89a45d2f685c831bc172d81b2afc09658dae_Device=CPU_Config=() -143:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=66375ff8539da6387946c19b0d20e6b4fd57da25150255e41282458e241963a0_Device=CPU_Config=() -143:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d0aad85620a1b97486758b17c69043a6a9cf75a459bf6e283b28ca132e917dcb_Device=CPU_Config=() -143:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0bb9a29f02d37ba32dc29b4284f58e10ce59571799f58381d449c77655c795d6_Device=CPU_Config=() -142:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=fffd24bb56af50d2e56fb2abdc6c0c96fceb21f00a9a1556b3890bdc50840352_Device=CPU_Config=() -142:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4104a7840dc96c214be896cac75911b70baebb902a42a26f12b281bc2cd87318_Device=CPU_Config=() -142:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e5092af5c0f683044b1df5a45f211f4a692436d1112181a5d613bbf335941684_Device=CPU_Config=() -142:conformance_FloorMod/ReadIRTest.Inference/Op=FloorMod.1_Type=i32_Shape=static_IR=2d09fd84ef3e176a2eae04f1066929ceb3973045b87989e5f0f11b97cab6cc7c_Device=CPU_Config=() -142:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=i64_Shape=static_IR=32ab4bca2ccc66d25b8b9ac449dbc58666434d98aa5b789e1aa28726c530986e_Device=CPU_Config=() -142:conformance_Cos/ReadIRTest.ImportExport/Op=Cos.1_Type=f32_Shape=static_IR=e5379d72e978c773e9be98561b316a64f76c6015608d87739211e7c0e8b7bba3_Device=CPU_Config=() -142:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5d5dd8756ccd01ee77e0c17d26f248c9e35d07aa812dc64bc39ac1ffe17ae585_Device=CPU_Config=() -141:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=e7895756d4bbd8fc1d5f9794410daea2a42c1df95f57627cbad46e6787e6aa5b_Device=CPU_Config=() -141:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=b6e76f65817017d4cbe3504634568430a419a30e418a5febf75b89b566ca3631_Device=CPU_Config=() -141:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=e7895756d4bbd8fc1d5f9794410daea2a42c1df95f57627cbad46e6787e6aa5b_Device=CPU_Config=() -141:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=i64_Shape=static_IR=bb6a76dcb7d086a6f8dc96d3e0b17573b6dc2775ff9d0f19060947deda586bde_Device=CPU_Config=() -141:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=9c1e1b695646ea4f56a87b7e5a815c12856f718920e01e86ed78f2dcaf896a37_Device=CPU_Config=() -141:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=f32_Shape=static_IR=d2759b52de5dc9f1fa494c243d08ac40cf4e877c51323d53dbfa02abc1564e45_Device=CPU_Config=() -141:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=() -141:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i32_Shape=static_IR=d246ad7201844e04821cf31a7d0650c362d6684da5e02f625d28b1afc3789127_Device=CPU_Config=() -140:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9575e384c23faea27b9011de8c0093099fbe0ee6462baaebaceb075529664665_Device=CPU_Config=() -140:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=797bfeedb05fe1883757101c44e78eb807ff9c3570aa58b0891172e729d4b384_Device=CPU_Config=() -140:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=bbf75e5f7aa9f20f890a8eb204ddb5f159ca5eae0616fb99ee0b5169b165d595_Device=CPU_Config=() -140:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=2f23f1158754aa494abbf61ab15118173a7ccfe90523b2b9ab7cc3a6fdaa0e37_Device=CPU_Config=() -140:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=97a94ab826d2992013df32a4f93f6adbc38ad17a26503005046f68904adf53d1_Device=CPU_Config=() -140:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=i64_Shape=static_IR=a2450d07c12669e586815e60d9a2b568f88a49c9b63730c898b9eae907b5ec4a_Device=CPU_Config=() -140:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=a6ce8e7d0cf79a4e800c911d6aec8f178a39642718eae3f8e9a89f7adc05dc64_Device=CPU_Config=() -139:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=7b904365e0652437dcb59aef3b84da17f4205a821586224e41db1409d96e910b_Device=CPU_Config=() -139:conformance_Unsqueeze/ReadIRTest.QueryModel/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=() -139:conformance_Unsqueeze/ReadIRTest.ImportExport/Op=Unsqueeze.1_Type=f32_Shape=static_IR=2e38326f5f0527299a0385fc3bb6c85c80e12e5bce07fe530624aba7113e82a6_Device=CPU_Config=() -139:conformance_ScatterUpdate/ReadIRTest.QueryModel/Op=ScatterUpdate.3_Type=f32_Shape=static_IR=537f04d52049add01923acd0c57cee03462926f9ce213a4fc9774496f5f66398_Device=CPU_Config=() -139:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=static_IR=e7ab5b597681da2db03c13a2424b4e0a62135eecfb2f97f4c59b53331afb7f85_Device=CPU_Config=() -139:conformance_Range/ReadIRTest.QueryModel/Op=Range.4_Type=i64_Shape=dynamic_IR=0d660483dfd9c9975f102d300ec98da49785fcb6484b379c45df8a61e1292797_Device=CPU_Config=() -139:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=5b1fc9693e4e947bc88a88bf1ad22ee2f59c13bf291626eec3e8ed49b0cef7ed_Device=CPU_Config=() -139:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2f8ee6adb1573c51bcffdd8c24455ecd6b6fbf04f171e9aa5de36c5d6f18babe_Device=CPU_Config=() -139:conformance_Greater/ReadIRTest.ImportExport/Op=Greater.1_Type=boolean_Shape=static_IR=aed960e9b7608b89973346cc2ab23c7ff65e72275fa55daa8b13f925a3779701_Device=CPU_Config=() -139:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=dynamic_IR=8029d5dae7f4721807eb717310512bad44630efdd0a64962496a0fd802a12325_Device=CPU_Config=() -139:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=static_IR=effa926dbd9beaa9b2b7b660288ceab99da8cfb440c4b01b7779d1bc25be336f_Device=CPU_Config=() -139:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=355bfa53a1f9e712db4df6642a51970e96e3612583b2ec90e7a8170e45b1625c_Device=CPU_Config=() -138:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=aecc8a062c16343ac138f351d774858b523e42d5a09ab67b1b61e64fe62e73ff_Device=CPU_Config=() -138:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=72eb2887828b5b14b41d001b6c7277d395f39c8003b9461730a938833899aacc_Device=CPU_Config=() -138:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0bc70791680aff885fa6a5903cea30fdb2386e7720403a8e6698362c5491a877_Device=CPU_Config=() -138:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=89ed1d3c7fa6e15c01df3b792a183ade5b90edbb87886e1d58db075566b60a92_Device=CPU_Config=() -138:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c9fa96695ebc82ee5e83b4cde8910e54ce09611f304f24fb6b3faa692a21c60f_Device=CPU_Config=() -138:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=4d10da0860e049587221c12f55c3bca9fc587b74dd3fec194c8ba5854a736d93_Device=CPU_Config=() -138:conformance_Tanh/ReadIRTest.QueryModel/Op=Tanh.1_Type=f32_Shape=dynamic_IR=8c78da5f8bf9c1a4cd7f89cde9d61eb6500fa10ea0454e36a585466ed97fb12d_Device=CPU_Config=() -138:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=() -138:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=68f6c55980c58f4d6de9e948d1c034b712cf74de509d8fd825fe7f7dfb11550f_Device=CPU_Config=() -138:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c1ffd0690c9370725a30028d2915ec798aff173f86a1864f3dc92a4defefef85_Device=CPU_Config=() -138:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a848753a720bf9791ee4c239cf08712d714b877bfb6df23805590ad690ceaff7_Device=CPU_Config=() -138:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=21a343909133e844b3d88a967b2f6c948e4c9c9eb96030b936f9517dd9bec865_Device=CPU_Config=() -137:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1fe78f5a88510b70fb39ed088e1418ae09155d179afc3a614a641b4e8f86574f_Device=CPU_Config=() -137:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=f32_Shape=static_IR=299e5f0fc159bf294093a5e1f258f7083fc54a08cbaa3a55b2a2197d29ae780c_Device=CPU_Config=() -137:conformance_ReduceProd/ReadIRTest.QueryModel/Op=ReduceProd.1_Type=i64_Shape=static_IR=7dba7222be56b8fcef943fc63ab00cfb3c7e0fb4467aeac96fd43aa4421cba86_Device=CPU_Config=() -137:conformance_ReduceMean/ReadIRTest.QueryModel/Op=ReduceMean.1_Type=f32_Shape=static_IR=2a8fce2d85c65eb0e8b40c2923338675276902296daf8744322876552dcd68f7_Device=CPU_Config=() -137:conformance_Multiply/ReadIRTest.QueryModel/Op=Multiply.1_Type=f32_Shape=dynamic_IR=48a273073ced3efa39d01e5ce40c30b2901e8a3dff0b414911282b8fdfc0b09f_Device=CPU_Config=() -137:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=c4e2668f98d5c21fc085695c9b6037f08a1e6710e1854fa73b7465a618e99b95_Device=CPU_Config=() -137:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=30b790c0018dfbf2d699b7518dc62d7b1d8944cfe0375174e03f00dbf33f1c19_Device=CPU_Config=() -137:conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=848caca8b0b971d54e9c9b715b8bf35e0a33f1274d50a946384e64e5c0843a96_Device=CPU_Config=() -137:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=cda3b9bda63d065b5c27e6bce5ffe20968024d77efe5e174a9f4395db56a30c0_Device=CPU_Config=() -136:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=c0cbd07b1517991754ef075284aedef586dd4b250e2b867379dacebdf99ce1e1_Device=CPU_Config=() -136:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=9fc3d18a9496df4681f38d330d3d1ff7b83b29b8f4e08e19c26a0107c4b69157_Device=CPU_Config=() -136:conformance_Subtract/ReadIRTest.Inference/Op=Subtract.1_Type=i64_Shape=static_IR=469a63c5aee73bdefc9abdf8abd8413713c0b68cc098d16c193399a11c7093c5_Device=CPU_Config=() -136:conformance_RegionYolo/ReadIRTest.QueryModel/Op=RegionYolo.1_Type=f32_Shape=static_IR=d4e6cfc9844e29087dc5bb222a1822c26ec71f2e751575790add7c9b98a5a23f_Device=CPU_Config=() -136:conformance_Maximum/ReadIRTest.ImportExport/Op=Maximum.1_Type=f32_Shape=dynamic_IR=214b1d4be2a141409b6b54847c952a282d9b2d7236d3d8ada3463f7dc8554097_Device=CPU_Config=() -136:conformance_Einsum/ReadIRTest.ImportExport/Op=Einsum.7_Type=f32_Shape=static_IR=810f13adb3f7342c7d514bec2aa3f20d7a59527b54c7f6954b038efb194c5ceb_Device=CPU_Config=() -136:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=a6f5b58b1d85e5a99389748ae14e507302127e583c436dd9e6015d3c33ab0536_Device=CPU_Config=() -136:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=i64_Shape=static_IR=32ab4bca2ccc66d25b8b9ac449dbc58666434d98aa5b789e1aa28726c530986e_Device=CPU_Config=() -136:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=99866ef63c9a2e7e2d9b7f00d11a4c177775bef9cfdf074e83f56318c143e6a3_Device=CPU_Config=() -136:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2cc5f8b67a407507c1d59a08981887766d377c7368b53cb0a18ec71df291b1f2_Device=CPU_Config=() -136:conformance/OpImplCheckTest.checkPluginImplementation/Function=Unique_opset10_Device=CPU_Config=() -136:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonZero_opset3_Device=CPU_Config=() -135:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=12c56cc6ebb22e8e31d97e0ef640fecab5f93e5c5b2810c4dde56b09a7ac7f48_Device=CPU_Config=() -135:conformance_Tile/ReadIRTest.Inference/Op=Tile.1_Type=f32_Shape=static_IR=9f4964a8b6440cdec94781121b408df16f0ef2283b0355583eb934b3cd2bcb66_Device=CPU_Config=() -135:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i32_Shape=static_IR=c78feba7097eb1c59197840a7e5510c26faeaa51ff724d643dc1f1ec077a6344_Device=CPU_Config=() -135:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=aeabe9639d6dcd5ab6e09f9905ffa8bdfe7cafcc7f5c8598e20e4ff39bdb50a6_Device=CPU_Config=() -135:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=30b790c0018dfbf2d699b7518dc62d7b1d8944cfe0375174e03f00dbf33f1c19_Device=CPU_Config=() -135:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=1f71810b04667907bc88c4a1ecc28b9325fde04026b5e56b5eb0e2d6608f3742_Device=CPU_Config=() -135:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=dc4bcacb769fc4d8f1ef4ff20ca7ba6b3b369d69ea3b1c65733d4cbd2cb0762c_Device=CPU_Config=() -135:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=753b524e2aad8fde7e7206fa8c3e7ca15c52c49f22f41d48cfb6b4d814cb40af_Device=CPU_Config=() -135:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0973b76264164ca52a9883a69ff5f7df977e28c33a0dbe9095e7e92acd7854bf_Device=CPU_Config=() -135:conformance/OpImplCheckTest.checkPluginImplementation/Function=GatherTree_opset1_Device=CPU_Config=() -134:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d6d8f4f28ac34b734cc984f83e8f5f6598c063a6955d00ef4c08252d5d05c276_Device=CPU_Config=() -134:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=24e44f75d91fe4e7e28db6c93870a47d536abeb87240841ff5b7e74b40189e42_Device=CPU_Config=() -134:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=7293f99e38d76387b64632d06503c539c369e1ab78d9388e1af42d7071d8230e_Device=CPU_Config=() -134:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=e044b25aa265a98dcd0a5cf5f7132fdac5f36074068dc2210e04dd4c459aad61_Device=CPU_Config=() -134:conformance_GatherND/ReadIRTest.ImportExport/Op=GatherND.8_Type=f32_Shape=static_IR=58581d0746e5bf56df7df18df87d35371d41ff69ba09c7850c8e96354c7910b4_Device=CPU_Config=() -134:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=d246ad7201844e04821cf31a7d0650c362d6684da5e02f625d28b1afc3789127_Device=CPU_Config=() -134:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=131fa1ed3ff9df038bbed73979ab906c3d84fea9dd2cf5dedc82b3222d511b1d_Device=CPU_Config=() -134:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0a2311ddc09b949cceb73fd0e09bbdcc2932c2635fee3a2c411bec27a30e9439_Device=CPU_Config=() -134:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=3fbff9f870428a19ed434cdf72834eec251edc3dddd149491c94319d63a8438e_Device=CPU_Config=() -133:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d13d862f7b8306948676388381950639ef433dcc4e38f5a6fa8d50575d1aa814_Device=CPU_Config=() -133:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=d25e26d9a54a5dc9799e9881e3035bfd5f125d12ea6cb69fb1eb0166e29ec88d_Device=CPU_Config=() -133:conformance_Subtract/ReadIRTest.QueryModel/Op=Subtract.1_Type=i64_Shape=static_IR=4341385bd87226eb41493c667323e8c1c39817983a48025192209270750eed06_Device=CPU_Config=() -133:conformance_ShapeOf/ReadIRTest.Inference/Op=ShapeOf.3_Type=i32_Shape=static_IR=87c65c520de106b146e91222609f5b25cd79e96cdd6b942c3293cddb656617ee_Device=CPU_Config=() -133:conformance_DetectionOutput/ReadIRTest.ImportExport/Op=DetectionOutput.8_Type=f32_Shape=static_IR=d3155499ccf835bc57e4ca19c25ca32fc63ecede0a2c43ab2a3e43ba4a6a4dcc_Device=CPU_Config=() -133:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e77468c2881ce0c38c14038151d560ccadc7dcbd5eb5f21b68b8e227c89813a7_Device=CPU_Config=() -133:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d242e8ecc8ae0239fc2e7773fe0f8a1d50792a71ae4aaac4fd439174e87e95b1_Device=CPU_Config=() -133:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c54189129febdb864ceaa5447a7a0011c8ccdf3711fcfd87424feca61b44c0b6_Device=CPU_Config=() -133:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bfd899e1dd2a03f99d8b55d9fa5ab04c6e4576358c910e9bda97cf497f0418a4_Device=CPU_Config=() -133:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a7ad8306fe632a2d0c45a492ad2d21dbe40f2f9ea55074d602beb6f8dde17982_Device=CPU_Config=() -133:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=c8bb865a43a3782b3b85e05c3e86388fac07473697ed45a7b04f60010555a3c9_Device=CPU_Config=() -132:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ea8fff2db5032f5015f68d53904354d4bdfbe5288224c7f549a1573794455d80_Device=CPU_Config=() -132:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d0bade0811581a6fae53c343866f1bdb63acfe07776fd60b7e791f8edd3f88b2_Device=CPU_Config=() -132:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=a7b79789ba2466daa67ce8610753fbd89a2ca372d65e2326802c24cce03f795f_Device=CPU_Config=() -132:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=6dae5ccb2325826167ff4ec57e51280b4e125801e6405a33f4d95fd9ab9f3fc5_Device=CPU_Config=() -132:conformance_Elu/ReadIRTest.ImportExport/Op=Elu.1_Type=f32_Shape=static_IR=1cb500b61fe11278cc50fca509be3e7b654190294dd581c7862ea3f108e0c192_Device=CPU_Config=() -132:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=1409169e395a3eb90f9235b74f2f8c94e0e27a63fae33cda153d991ae1cbb68d_Device=CPU_Config=() -132:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=970f3f48203f3bd46dcd6ca55ad20f5ff8ad2426c3f6f74377759fdddaaf93cc_Device=CPU_Config=() -132:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8c3b386463bd59945d3c15512b26409dee7da9b1940f153e3ff62d47d6f79d2d_Device=CPU_Config=() -132:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8484c5c087ca8317588ef676a0cafb63ded379be5bad862e4d0504f43bc6fb45_Device=CPU_Config=() -132:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=4bedf955c6ec574258a05f59e5397225e1360ba68ea49d4fe105d6a62ccb3e97_Device=CPU_Config=() -131:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0dafd9117cb3fba3a335f7cd28aaa3fbd9276878383657b357210e135a93d916_Device=CPU_Config=() -131:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=deada5d69a05cf27af659254f89b4e53e6685c517fdc2bb8a250cb5d4ba0a3dc_Device=CPU_Config=() -131:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=66abbc2c605a0f866880bd4730865ae6b5401a1f4beb242f346bf6f2f8138eb6_Device=CPU_Config=() -131:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=447c546ed54e81edcfea77cafa8d18261923bf25c050666029828ea72e3a875c_Device=CPU_Config=() -131:conformance_Gelu/ReadIRTest.Inference/Op=Gelu.7_Type=f32_Shape=static_IR=8876bc4ad78a178f235f48e06e705a7dbd3f7ca06e3ea5052e6136811da69d20_Device=CPU_Config=() -131:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=c8ec200fa8fd8ec9c185d9d45ee1380be5e0e4a6f3157e5900401e9fce999553_Device=CPU_Config=() -131:conformance_Erf/ReadIRTest.QueryModel/Op=Erf.1_Type=f32_Shape=static_IR=2e5aed1612da0f720adb051e22460983a3911c38cb09184d812ceb949870f450_Device=CPU_Config=() -131:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b7983ae70a4e7868ccbf4b25a5d8e795620182c29817ad1151d89f2e932d770b_Device=CPU_Config=() -131:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2a819b46a29c8bd965ec330a28b5c163dd0a06fa2717d71bd16493ad460e8dad_Device=CPU_Config=() -131:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=09c1f9f81a463477da73d33f00d1321fa5c1f64a9c3c51c6e3c1344e362d4ced_Device=CPU_Config=() -131:conformance/OpImplCheckTest.checkPluginImplementation/Function=Transpose_opset1_Device=CPU_Config=() -131:conformance/OpImplCheckTest.checkPluginImplementation/Function=AvgPool_opset1_Device=CPU_Config=() -130:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=f32_Shape=static_IR=17472505b59f6bcf4f5570eb83b2225b056a403bf2d165562edabb8501fad1e7_Device=CPU_Config=() -130:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=8ef4d7ceb7d904a084d93d6ede1c15a64d2511b3bf1312d630792eb21c591408_Device=CPU_Config=() -129:conformance_Tile/ReadIRTest.QueryModel/Op=Tile.1_Type=f32_Shape=static_IR=6ab37e1d52328b5ce1204cfe13977b06dcfabeb4acff9821d65ffc91bd3cf09d_Device=CPU_Config=() -129:conformance_ScatterElementsUpdate/ReadIRTest.QueryModel/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=() -129:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=de01a0d560bebb0018927f02409922427ef35b59a96f0aef8f18991ee0d9542a_Device=CPU_Config=() -129:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=boolean_Shape=static_IR=4da22853b6e4b853fa57b9dce8f5a26920d079a74055831d651c10f48ee96e8f_Device=CPU_Config=() -129:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=4555fb7029260c7e46403e1fbc99a3815a94373b7b08d2408277976173facc37_Device=CPU_Config=() -129:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9795aaeb71c115680b567eab0877df338c0d8971858b489a2636c4483f3512cb_Device=CPU_Config=() -129:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5d522332a7166265867b633721d8bd8ff23a233e7c8bff59a245bbb24d7be234_Device=CPU_Config=() -129:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=5976ce31ff4cf399e87efd691dce3e75dc2de962241a84c09538593c9865b257_Device=CPU_Config=() -129:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=243bd2256612673dd04651521ed8d3fa4087c90af7b85e1a4aa381c074bacd47_Device=CPU_Config=() -128:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f226723f90368b020cf11817ce0a39c002b9c30e07d16ac9297b7e574a010b0e_Device=CPU_Config=() -128:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f1ffa9874732c1aa88e04fd55fbc864c9c6986877d3d52045fa6ae7f18dba62b_Device=CPU_Config=() -128:conformance_Slice/ReadIRTest.QueryModel/Op=Slice.8_Type=f32_Shape=static_IR=2055c46f29a25953e331656839e227b0472b10695ea23410b64428d14232345a_Device=CPU_Config=() -128:conformance_Select/ReadIRTest.QueryModel/Op=Select.1_Type=i64_Shape=static_IR=6590ae34a784f81de25c016454fcc919ae1f9eab672c78c9da0daf83dcdaf1bc_Device=CPU_Config=() -128:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6a7aa747b98a21c0469c7edf7ef78a050e1279d891b0c69ddc071befafd42c76_Device=CPU_Config=() -128:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=77d771a04d8618bf32943e460b714076f7bbc34cd1d40f9a90864af976bea30e_Device=CPU_Config=() -128:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=b6417017678573faaf72824d1bec40bcccd73ae0007aef24b089dc3743276b14_Device=CPU_Config=() -127:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=686b6d84e29d87a91c8177396d2aa5a1fbb88656c79e41af9a0b30b42805f477_Device=CPU_Config=() -127:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2d38082f8971dd7614234070dc9cb8c9b6b12fee7dc918503f0e256ab32d2fef_Device=CPU_Config=() -127:conformance_Softmax/ReadIRTest.QueryModel/Op=Softmax.8_Type=f32_Shape=static_IR=c662eb0004f431152ddc69e12826a6c0e7aa66b24be0169acf10ca95f2a63f52_Device=CPU_Config=() -127:conformance_ScatterElementsUpdate/ReadIRTest.ImportExport/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=() -127:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9c66c6a6d93c10149920c3e034d9a0765afbef45dab66083fd5e3d796a57e406_Device=CPU_Config=() -127:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6e508ca44667fb311f5b6d634584d2751c3fb15fc034626765c90695b7de9619_Device=CPU_Config=() -127:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1891282a9bf460336bad3c354519aa0d87ba6ef40876d4a07592194d2d678e25_Device=CPU_Config=() -127:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0b4b74693c2ec96e714901b1acc772655accc3b29170cdb64ae934003338b296_Device=CPU_Config=() -127:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceMin_opset1_Device=CPU_Config=() -126:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9991a1b4140ee8e6ed0460fb384b7729f681bc1068315a4d970eea59dcc89950_Device=CPU_Config=() -126:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=3b4dbc6facc24173723b52757e4ee60953d7a639e1fcb6e70236918d6a40b3a5_Device=CPU_Config=() -126:conformance_VariadicSplit/ReadIRTest.QueryModel/Op=VariadicSplit.1_Type=f32_Shape=static_IR=d1d0510ce6d862a5512bf4c5c588f84548f1aed0226eca6850b5e2d470a5ee84_Device=CPU_Config=() -126:conformance_Softmax/ReadIRTest.Inference/Op=Softmax.8_Type=f32_Shape=static_IR=670a0d513277b4508e8edcddae6361e98fd03c2fff31293637c36f97e59a6b9c_Device=CPU_Config=() -126:conformance_ShapeOf/ReadIRTest.ImportExport/Op=ShapeOf.3_Type=i64_Shape=static_IR=3688e2a973219245d05c5fa675cebe9036d40777809ebf583c1bae9b9f87eed6_Device=CPU_Config=() -126:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=45e4a607b0964915174f6a14de049a61a5740f258a4a71817e5aae1b93be5ae7_Device=CPU_Config=() -126:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=() -126:conformance_Equal/ReadIRTest.QueryModel/Op=Equal.1_Type=boolean_Shape=dynamic_IR=0723b6d683bc65225624112929bd8f7a0adde9e9c2265a2ec1a54b10c4433735_Device=CPU_Config=() -126:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=fb6a053d244fc1bdea6fd5e69e0c05025272ac0da2f676e077c598239b6493c2_Device=CPU_Config=() -126:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=00d6c2465c4fa7ddab80d30c2fd8099a684bcc47cf9bdba89a39560beed737f6_Device=CPU_Config=() -125:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=ffc3cad64b8bf82ffa4d189a247a9434e71886cacd3582956c5dd98921fd2141_Device=CPU_Config=() -125:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=51bb427ac8abf618a72159cde1ee840e08518016a09e995f503cd888941f5039_Device=CPU_Config=() -125:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=883597c2c4e004b0ec1e1ca8d1b75395c714fc6a99cd31e35ca0597d0ccd8f8f_Device=CPU_Config=() -125:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=() -125:conformance_PriorBoxClustered/ReadIRTest.QueryModel/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=() -125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b04f836c4ed5b0403f4b7fdf9c5cb8d11ff9f65105ab9bde39f80191a65f7f17_Device=CPU_Config=() -125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=59c0e972ae75900cd8c802aa7be9b6c13c96cb10417ff417eb1aafbc49b891ea_Device=CPU_Config=() -125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3a3886301663fd20cf2c8c0f74c11d80dfe8b74ac39e41652f0eac1ec9bfa2df_Device=CPU_Config=() -125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2dd63d58c85301d765882b95995de97f4eff14bbb3c933c4e4b8ee5fbc2e9e71_Device=CPU_Config=() -125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=073dca39b0ed99c8af202a5e272db241f95de1f64a7a1611e83853b92e7f7f09_Device=CPU_Config=() -125:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=023f3573ef77fb592345c68ee5e6a79191b120f9cb68f81194381da2cf68f21a_Device=CPU_Config=() -124:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=16ccecc11352f2c476db041adea21d67a96e03cf33902b37f4f6855b5113c202_Device=CPU_Config=() -124:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i32_Shape=static_IR=6eac2d4e0df77b93f566f0d226ce4972da143d2b3fd794f7d316faacce442035_Device=CPU_Config=() -124:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=1f7f2d40b938416773b13282d8ac09d81a50e4d5d7548f42fc5fd575f84e1385_Device=CPU_Config=() -124:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=() -124:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=4d14510ef37733d7ca3d69697626c173feb05638f5036c49b060f6a80aea9ada_Device=CPU_Config=() -124:conformance/OpImplCheckTest.checkPluginImplementation/Function=Add_opset1_Device=CPU_Config=() -123:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=c90b6f528b750f144ddd29be0059c202d46b3bac799c0d70893f2f4f9f05f64c_Device=CPU_Config=() -123:conformance_ReduceSum/ReadIRTest.QueryModel/Op=ReduceSum.1_Type=f32_Shape=static_IR=e1d727df48a0a74d8b9865c00e5c39c9d53a5023d83da3c58f281b6b1411b696_Device=CPU_Config=() -123:conformance_Gelu/ReadIRTest.QueryModel/Op=Gelu.7_Type=f32_Shape=static_IR=4ee688aa25b818f6e6986c7070e544d0eef9ce888124d85c0e5e126802213a46_Device=CPU_Config=() -123:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=766d904d646b6f43847158972a615db69af2bf66517db0992a19418856bef52f_Device=CPU_Config=() -123:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=517a5eeb2f1f21304b8a1d5971f89bfc93aa678252180bdb05144657b1a8619f_Device=CPU_Config=() -123:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0f61e4837d11be2b01f69947cd0b424a45d2e548d9c70ae53b07c43fa1237cd0_Device=CPU_Config=() -123:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1c73b4d05053065f5c37954586376ae4e1cf9e220959363b7c2cb381f489bee0_Device=CPU_Config=() -122:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=eeed611756b048927c290a65dd92a5833ad66d347bbc772abddaa751f2016ff1_Device=CPU_Config=() -122:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bb610d59221e7c5d8e96f971519b7ef27bda7bbb9be329b873a901a1e749b9cc_Device=CPU_Config=() -122:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1e04d36f6e56abacf8388fad66368b15355eed9d216d5771b650b0b058db3a76_Device=CPU_Config=() -121:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2fc01b66086ac5d8272dd81ab731188b62bbe8920bff1efe61bf3261a3a8b3e6_Device=CPU_Config=() -121:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=860decd2bf091a335f6f820b2c6b6acc58618fbb6027e30484470ce899bb1591_Device=CPU_Config=() -121:conformance_Floor/ReadIRTest.QueryModel/Op=Floor.1_Type=f32_Shape=static_IR=b064511ab38a9a70b4d203e11a12b990f388a03550ba98c65468be1b85c68fda_Device=CPU_Config=() -121:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9c63b760d92c46d2ba731cb9edc4cf19a96848e4f3c354797f10a7a1bb9edf8c_Device=CPU_Config=() -121:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=074ab76268ab5d03283f03f4e228a7cf73ab5a18fc0e7366778cf8c45286f18a_Device=CPU_Config=() -121:conformance/OpImplCheckTest.checkPluginImplementation/Function=VariadicSplit_opset1_Device=CPU_Config=() -120:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f2293320b7533e95bf000229d2458244fb9af573cd737ca0088a00674df1ac52_Device=CPU_Config=() -120:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=65a5483c793396983edaf7f2cc2c13898507525bd84a8469e97b2d662b5df782_Device=CPU_Config=() -120:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=2027d5da17dab73d23b4984fe88696fb770ba2fa479a194b3531d30ac75dc840_Device=CPU_Config=() -120:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=6e1207753b08d53b18c551ad07a245243197370051be78218db028f3d3b835a5_Device=CPU_Config=() -120:conformance_Sqrt/ReadIRTest.QueryModel/Op=Sqrt.1_Type=f32_Shape=static_IR=8952b1ce6fc7bfd900e669e12b520b624c02026b458bae41afe28e1f76058315_Device=CPU_Config=() -120:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=7cbd5676618d9b507238807c281801b8a817202b0ae648a44cfa32fc16c02547_Device=CPU_Config=() -120:conformance_GatherND/ReadIRTest.ImportExport/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=() -120:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=cbb80f496fd705f24fdb25f6de3734bb2a2b7f49c984bdb32c4f62ec4640797a_Device=CPU_Config=() -120:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=dac1d1bb4f11cef03519894a2853742d914abb0e3225b7caa3bc5f23d167cdaf_Device=CPU_Config=() -120:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=29d8ef1a41f51b6fed0300f97d17a3795a97e4ffb3ef3abda37f790f5f53b389_Device=CPU_Config=() -120:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=13c78a6d628bed4392d2577f132f924d9e17a7e29a2171dafebc0a596d2ade04_Device=CPU_Config=() -120:conformance/OpImplCheckTest.checkPluginImplementation/Function=AdaptiveAvgPool_opset8_Device=CPU_Config=() -120:conformance/OpImplCheckTest.checkPluginImplementation/Function=Acos_opset1_Device=CPU_Config=() -119:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=f84dc200af2852df01662dfbe891b8ed4abb27db6763f3a2b645ab75324834f3_Device=CPU_Config=() -119:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=53da49d7aaa81cbb7c3a3dbc8ea938bbffabda14bd106fa6c2b6abe244ba5cda_Device=CPU_Config=() -119:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=1942042c790c3fc6053ad91fa5e45f8ebf3c11bff7e3427a71b8fdc1bc5db053_Device=CPU_Config=() -119:conformance_StridedSlice/ReadIRTest.ImportExport/Op=StridedSlice.1_Type=f32_Shape=static_IR=17472505b59f6bcf4f5570eb83b2225b056a403bf2d165562edabb8501fad1e7_Device=CPU_Config=() -119:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=78a5e7f340d63660dc0710d0e390dea2d3f68ac98f16e8dbc11b4c28ac0440e0_Device=CPU_Config=() -119:conformance_Exp/ReadIRTest.Inference/Op=Exp.1_Type=f32_Shape=static_IR=67632b67a0834136cf2f3bcd6b3fbaf0d2f2bbffc1da6c33fd5fce0d0b8a763c_Device=CPU_Config=() -119:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=dynamic_IR=791be312b2af6da6abd2eadadc6185c7052271efbcf314bb678828313fc58414_Device=CPU_Config=() -119:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b83a85737c23e279f8878f6795581dc2b003c55e4eb8baadfbfd73fb0e98758f_Device=CPU_Config=() -119:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=64efb6dd46c36bec02b92148d178bc032417c8c2d999ff7b0a24ba08af365f91_Device=CPU_Config=() -119:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterNDUpdate_opset4_Device=CPU_Config=() -118:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f2403b7d119fabadb1609250bbd0959aeef2cd68c62a4036657518ebfbcedf71_Device=CPU_Config=() -118:conformance_Transpose/ReadIRTest.QueryModel/Op=Transpose.1_Type=f32_Shape=static_IR=564cd54b2564c7e39fda0c5e580c274b7bf99603760f6c66f03b4450f23cc4bf_Device=CPU_Config=() -118:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=b1477d38842775944964d18c13278454256d9610e0ef880fbce0cc87e5977556_Device=CPU_Config=() -117:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=dynamic_IR=f01fb29e8f5ddc7562e954e46b1d2bdbe6144d6bbe2ed2a0f16610f2812ac721_Device=CPU_Config=() -117:conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=() -117:conformance_Greater/ReadIRTest.Inference/Op=Greater.1_Type=boolean_Shape=static_IR=dce38966c13ac9886c7480261e3483d822355a9bf3835d00795e7627744a60d7_Device=CPU_Config=() -117:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=3ade42cfc9d970963d8f162b001075864e6967034198986f408ec09ce4093d18_Device=CPU_Config=() -117:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=ec60ac68ad3b748ccd56a7c91b3a2461510f05d66e4b64e12a2069483d8243ae_Device=CPU_Config=() -117:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43a00b4dc097228af52c00054951dd5b57d8e0086207f11a8996e5ac880c8980_Device=CPU_Config=() -116:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=478861c92198ee8679e3e43476abfe79906c4ead6ee80af975af365829822025_Device=CPU_Config=() -116:conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=20af9ae4466332a072f3b04c1219146d272daabf2306b66c755980bfd31f2a76_Device=CPU_Config=() -116:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c0cbd07b1517991754ef075284aedef586dd4b250e2b867379dacebdf99ce1e1_Device=CPU_Config=() -116:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i32_Shape=static_IR=38d935b0aa7266960b3d349b60c97bb15f535faed953fbe3ff24ae2560828f04_Device=CPU_Config=() -116:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=263843a2c307b91ff7d59d9b21cd8b2126e985d787fc18f44df3525a6bfd71f3_Device=CPU_Config=() -116:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=641b1e74512a5cdc87bcd63515a28a409f155a3475fa923e440868e563daaffd_Device=CPU_Config=() -116:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=57ba21d45369359487dc3b6a8feb0aa2b6fb21ffa328dc8e8eed58ee2896fdad_Device=CPU_Config=() -116:conformance_Equal/ReadIRTest.QueryModel/Op=Equal.1_Type=boolean_Shape=static_IR=9e166ed18be64949ce2451a1dc981381040fb109ee60e13a7f47308caac73e24_Device=CPU_Config=() -116:conformance_Cos/ReadIRTest.QueryModel/Op=Cos.1_Type=f32_Shape=static_IR=e5379d72e978c773e9be98561b316a64f76c6015608d87739211e7c0e8b7bba3_Device=CPU_Config=() -116:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a24dd1485e484f31d0c72f3a0c31f373f883f6ca4a751b1d2ce18132913506dc_Device=CPU_Config=() -116:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0fb6a7848271e000d49d4966647edf55e65f181523883089f43147c14cfb9871_Device=CPU_Config=() -115:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=i64_Shape=static_IR=4892263cb1ea7a434b5771aa16f07885c39710f67fa1411dd9235653a6b8622c_Device=CPU_Config=() -115:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=() -115:conformance_GroupConvolution/ReadIRTest.QueryModel/Op=GroupConvolution.1_Type=f32_Shape=static_IR=2bb16e2257294e3f7d905f66a483a8210f392ea822836e4edcf8910a7fbb4277_Device=CPU_Config=() -115:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9c651eeba5c3e7b07a8cd0d4ba479fe8c5aaa2c4df9b18ab022e775ea01dd867_Device=CPU_Config=() -115:conformance_GatherND/ReadIRTest.Inference/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=() -115:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=83d90ef3fac993f7efba4a8ed369781571b1b536af03ceb0267ae979379e1dd9_Device=CPU_Config=() -114:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=b050ebcbd31acbbc43d657d87a54415e0e52d3e91fa95b57aa1dd0451a5bf50f_Device=CPU_Config=() -114:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=4e2e2e9dd89aad4bc14634b85c94336a7250dbb8ff61cb451c9507753f54a102_Device=CPU_Config=() -114:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bf4d5291899ea4eccf6584f62d4ecdfb39de79edd102e509f840664838f59d19_Device=CPU_Config=() -114:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a7d9ffa60c8d1f330ec303edf6a6c0f8d8e0fe8657c561431bfb91a94c2639e8_Device=CPU_Config=() -114:conformance/OpImplCheckTest.checkPluginImplementation/Function=Softmax_opset8_Device=CPU_Config=() -113:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=576ef0e9eaf8fefade547928d4592bc2b341ff1100c3de5104f0a63b2fbeeca0_Device=CPU_Config=() -113:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=() -113:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i64_Shape=dynamic_IR=70d4da84623a0af3bc8362a828bac5ef13285498b420a3df6bf2e88bf05311db_Device=CPU_Config=() -113:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fa2eea1b545d6b876282ed0165fb935f0af249c713e3f20fd97cc06118e615eb_Device=CPU_Config=() -113:conformance_Greater/ReadIRTest.Inference/Op=Greater.1_Type=boolean_Shape=static_IR=aed960e9b7608b89973346cc2ab23c7ff65e72275fa55daa8b13f925a3779701_Device=CPU_Config=() -112:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=e250a19bfbe236f81b6715a92beb0c259080e4a5d379ea1187892e8c8d9add8a_Device=CPU_Config=() -112:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=1a9779319a9cc5f21b6005ebb9b4517e0bb1f868ef8e568453a58c44474c40bf_Device=CPU_Config=() -112:conformance_Transpose/ReadIRTest.ImportExport/Op=Transpose.1_Type=f32_Shape=dynamic_IR=b91ccf96246dcf055dd9122c823ccc54ea572f1ad8fcbad3a98c88edb7e454c4_Device=CPU_Config=() -112:conformance_Squeeze/ReadIRTest.QueryModel/Op=Squeeze.1_Type=i64_Shape=static_IR=168e02701204a8f0e325fa1a2a4407612df10c3218c9431981fa6f1f8300eec2_Device=CPU_Config=() -112:conformance_MaxPool/ReadIRTest.QueryModel/Op=MaxPool.8_Type=f32_Shape=static_IR=30f4b90114764377dcd8e010019eefe0ec9c21dc6f0503b52323dfe867a51df5_Device=CPU_Config=() -112:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=0c5ac67592b69e8c2b7acbae7a0f877cfed184c572d2fae09eb8fa629e86eeb1_Device=CPU_Config=() -112:conformance_Gelu/ReadIRTest.QueryModel/Op=Gelu.7_Type=f32_Shape=static_IR=8876bc4ad78a178f235f48e06e705a7dbd3f7ca06e3ea5052e6136811da69d20_Device=CPU_Config=() -112:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=79e0a530c5a64063a9af26b438f208476e3bbf5a267c28ddded0459019a1d8e1_Device=CPU_Config=() -112:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1385af2553c7c9b0f9ce2aa4345d8b767d36136a9cd8e2acae79d4970d6b5c8b_Device=CPU_Config=() -111:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=d74cf8dde02b582dc1efa697474a50738532e0ce5b40831d81d0852a74a94c79_Device=CPU_Config=() -111:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=5953b8e79f64e33e67dd330999ff8e3d8391c8f3fa7eae519b117b1273c8c19f_Device=CPU_Config=() -111:conformance/OpImplCheckTest.checkPluginImplementation/Function=MVN_opset2_Device=CPU_Config=() -110:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=984e628a0090ff9d04bf8f41b795f0682dd3083fb78b71397a51cc2efacee247_Device=CPU_Config=() -110:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=52ee24baa14f302174ce3b13a119ccb6a54994413daa1f052a75464528b07088_Device=CPU_Config=() -110:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=static_IR=a6b0532b200874d6d1c57719b46f2b301c368ebc35042df00796dfb87eed618b_Device=CPU_Config=() -110:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=651e5fbc222577151cf14e9c8e9bdf9e155f1e0d277206887160d65b532caf53_Device=CPU_Config=() -109:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=1e9f662cfa263a98c546e69de318268918914f2ddd0ee87cba23c2690a81ec19_Device=CPU_Config=() -109:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=c2539b8a06e5dd0e01933c6861e366f8ed565e5956b8b2546647b55e966e7755_Device=CPU_Config=() -109:conformance_MatMul/ReadIRTest.QueryModel/Op=MatMul.1_Type=f32_Shape=static_IR=c61a8f259a8b37e49f9267dbc921d88dd60e5766aa30dd05319f423a01c14aee_Device=CPU_Config=() -109:conformance_Divide/ReadIRTest.ImportExport/Op=Divide.1_Type=f32_Shape=static_IR=68c6351cbee22a4783b3c592f69eea3778c17594c48972d5d0d1e9d728f5b47e_Device=CPU_Config=() -108:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2acd53645519bc460dcc71923563fd462ed997366cc7ae08cb5a30245302a859_Device=CPU_Config=() -108:conformance_ShapeOf/ReadIRTest.QueryModel/Op=ShapeOf.3_Type=i32_Shape=static_IR=aa757ffed4165beb3074da6ad09422d7823a1d0d6c8a654adc56343d0e43dc66_Device=CPU_Config=() -108:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=9033954b258cdfa9fa858317ee4588b8c92cc946d7eb305bf130d3ca8ee0f1fe_Device=CPU_Config=() -108:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=185e849a9d8fec26bd81b2098d63bd842d34dc7a8ee7e47086a208e4b8bd9298_Device=CPU_Config=() -108:conformance_Gelu/ReadIRTest.ImportExport/Op=Gelu.7_Type=f32_Shape=static_IR=8876bc4ad78a178f235f48e06e705a7dbd3f7ca06e3ea5052e6136811da69d20_Device=CPU_Config=() -108:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=b11ede8f1aee40577413d8bbe89704e02252e3f02805fcc0ded624857ddb8280_Device=CPU_Config=() -107:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=89dcb383b48e2a4423a7c81461f282b74b1d9ab0f48f0a0427cd4c599672f3fb_Device=CPU_Config=() -107:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=67ed6a8048424f4e44f40c542faf7a2a2d2419e81aa982fe32a054af05caf309_Device=CPU_Config=() -107:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=static_IR=a6b0532b200874d6d1c57719b46f2b301c368ebc35042df00796dfb87eed618b_Device=CPU_Config=() -106:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.11_Type=f32_Shape=static_IR=7798cef9c8734d0908103b3c42fd7fc791806ad61d35dc680dc43d9597c6f1fb_Device=CPU_Config=() -106:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=a4e797de860d6e4dcec00062050168ba9745d3da953b9c644de654f4d2818b77_Device=CPU_Config=() -106:conformance_Gather/ReadIRTest.ImportExport/Op=Gather.8_Type=f32_Shape=dynamic_IR=4fe95284f224758c29c5198a8b2e6f97e8e737435d36cb94b9cdf0bca3c89dc1_Device=CPU_Config=() -106:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=c98e1e2347c7b6939804dfcfcebbbd57d4c05e8d13b35b2611912290d06107ff_Device=CPU_Config=() -105:conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=d74cf8dde02b582dc1efa697474a50738532e0ce5b40831d81d0852a74a94c79_Device=CPU_Config=() -105:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=3e2e16f3ba7681bebb6b4c06788f38a40fe24e26fa3ec3accd756c87bee7d62f_Device=CPU_Config=() -105:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=43ba20ec70e156f4782e1f11a30f02daaaafb2039912a373620d845e995c97cc_Device=CPU_Config=() -104:conformance_Tile/ReadIRTest.ImportExport/Op=Tile.1_Type=f32_Shape=static_IR=9f4d316675c933ea5d6511324e3d664440a8ba287cb2ffe768517f9cbfb613e7_Device=CPU_Config=() -104:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=997a090766babacae10464bab19af5db238eb28704c6d463cfcba48767a90c8b_Device=CPU_Config=() -104:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=27d1a1cfdbadd9a8c2d0269f6177d6aabd55320aafe9a0047e90681dcad1cbe9_Device=CPU_Config=() -103:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=d7fbbe9f8f446b009ea2de8594e4cfaad46432734cba27596e3fa721f04c04ee_Device=CPU_Config=() -103:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=75aed7fbb8f7d7e8a1281d4a16c4fe2e55160dfb9e6a1bc446913a223c5aa0de_Device=CPU_Config=() -102:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=45ce409a7078c7e732a092633cee36d6a0aa80fa9249cc98dce44e5b4bfc1693_Device=CPU_Config=() -102:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=boolean_Shape=static_IR=4da22853b6e4b853fa57b9dce8f5a26920d079a74055831d651c10f48ee96e8f_Device=CPU_Config=() -102:conformance_Einsum/ReadIRTest.QueryModel/Op=Einsum.7_Type=f32_Shape=static_IR=f3d704d4f0da6c58c39e279d727dd82fe0e59a41dbaf09a3cbaa8f591daf95f7_Device=CPU_Config=() -102:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1c9d69e1a85d03b8599961a8a1b90af7b3b2d43bc5c4f4a6b8d5da3c22166abd_Device=CPU_Config=() -102:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=() -101:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=41c1e13447cce632ccd478ec2bf36f09e510942449b0bffd3271f3b1f0b48d54_Device=CPU_Config=() -101:conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=i32_Shape=static_IR=6eac2d4e0df77b93f566f0d226ce4972da143d2b3fd794f7d316faacce442035_Device=CPU_Config=() -101:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=bba92f0e1fe2ee647564aec64223ab2c5b32d3defae9bad5daa5a24df76aac48_Device=CPU_Config=() -101:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=6964f870fd6bf44d1d5ee5925eee8892230b8928aeee1966db73b6c4fcd5acf8_Device=CPU_Config=() -100:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=static_IR=3326cf79d426d1a669158c4db8256fdd956fa4725b0d6fb9e8ab5e5206612eef_Device=CPU_Config=() -100:conformance_PRelu/ReadIRTest.QueryModel/Op=PRelu.1_Type=f32_Shape=static_IR=659cd025e440fdc633859089f52f7f38cab5701c63c79d1e8d1837c217b8cf75_Device=CPU_Config=() -100:conformance_GRUSequence/ReadIRTest.QueryModel/Op=GRUSequence.5_Type=f32_Shape=static_IR=556de70b55386fc9a264a24a9000d075a07636de6461cc5f4cd41af639b0597e_Device=CPU_Config=() -100:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a7eb49934c05ef49a453b19adf40a9d4c2ea9477464e8d42858dc9517c30b88c_Device=CPU_Config=() -100:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a76c4cc0a1f2294a3ceb18dd5d214d842cf37c08d2e34770c66c29b44ee92e48_Device=CPU_Config=() -99:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=516b04726c16c5c01fbeb1c97f8f9d9376b80e9341d2029c634f7fe4975cc4be_Device=CPU_Config=() -99:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=37b1b14a23dbc309d75fbd98158648e1a7fd246684b96e1ebb10a75c3f5b03b6_Device=CPU_Config=() -99:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=e0641a7f9e64123d0d51a75e576fbd0e405105b8ead44a618068e77d2b4bf933_Device=CPU_Config=() -99:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9650ac479045f70fd763f5c95d0c27c3b3cc4d6fc00b43e8ad627d16f817f342_Device=CPU_Config=() -98:conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=i64_Shape=static_IR=7c1b4dfda36336bb1a943fec9786d89e220f2a811159fe9cbed7d51186f8fdfe_Device=CPU_Config=() -98:conformance_Proposal/ReadIRTest.QueryModel/Op=Proposal.4_Type=f32_Shape=static_IR=b169d6330e4006909e4deaaf78b03e789ccd9538c5b59d9d41e05f878bb60704_Device=CPU_Config=() -98:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=263843a2c307b91ff7d59d9b21cd8b2126e985d787fc18f44df3525a6bfd71f3_Device=CPU_Config=() -98:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=static_IR=a0cee5b220a433f1d76460a1f452bfc26aae12f7b84983a063605b4a8cd0a5d4_Device=CPU_Config=() -97:conformance_TopK/ReadIRTest.QueryModel/Op=TopK.3_Type=f32_Shape=dynamic_IR=fb3cc70d8993f96508516aa7a36cdcb9973edd563c78a7d6d5ac5ca9f816e3fd_Device=CPU_Config=() -97:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=static_IR=fbd54c37e1db9cd3cd3fc7c571117f65c26d9f5ff0674711a326e02ebd3f9d57_Device=CPU_Config=() -97:conformance_Divide/ReadIRTest.QueryModel/Op=Divide.1_Type=f32_Shape=dynamic_IR=f42d85c8e1388cf2cb69f9efb2970255c6535f1c3f904a9b08cc18cbea6aa6c3_Device=CPU_Config=() -97:conformance_Divide/ReadIRTest.Inference/Op=Divide.1_Type=f32_Shape=static_IR=99e405218c1a96c5f8af65aa814893d8958e8e991d1ed8dbbbd586efa589df39_Device=CPU_Config=() -97:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=9ba199e71a3ff06e6bd330e453a1e1103599902893fc267c60da9ae47575a8a0_Device=CPU_Config=() -96:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=c0c3d43548fe20fc4e63bcfc8ee6d0a70a6076dfc0ee79e31fdcecf6cf35921c_Device=CPU_Config=() -96:conformance_Reshape/ReadIRTest.QueryModel/Op=Reshape.1_Type=f32_Shape=dynamic_IR=634db7c7a580a605f3375f671b3bcb2a1baf5856b32032d2786a5f8061df63c3_Device=CPU_Config=() -96:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9cd66958dfe8db471d48d6ea35f1b4547a413fcdc6c61c804a456befcbb09d15_Device=CPU_Config=() -96:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2386bb6412e51aa72e9426e12f9f2b2646e7074413b33fff8d95dde141ee12fc_Device=CPU_Config=() -96:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=060423427a9100b6a38aad12a83043441f8af436c1d2502350ae867f45bd721f_Device=CPU_Config=() -94:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=3dcf824c36c868d06d715e3fe24587c31eb7cad18ae9f9e044c7f6abfd261651_Device=CPU_Config=() -94:conformance_Greater/ReadIRTest.QueryModel/Op=Greater.1_Type=boolean_Shape=static_IR=dce38966c13ac9886c7480261e3483d822355a9bf3835d00795e7627744a60d7_Device=CPU_Config=() -94:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=f06ff28476f886d4298a83d39f88aff34399d5cd589e0a6d6395e00b0ad96876_Device=CPU_Config=() -94:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b9bab6ef11eb6ae637924a902a40dff310a45916d50c8f0a4ec667c8d6bde6a6_Device=CPU_Config=() -94:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a50644dc2d133df429ff4aa6a19ca9bafbf41d2948522e584fc5f417ad16d76c_Device=CPU_Config=() -94:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=3209c1cce78c7b856203c0a5676f6fad4d098a3146c7305ee3c0471b3be2e3d5_Device=CPU_Config=() -94:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=31e75a7408a46928e1a3a8babe3da21bccc6d442f87291c0b2bf57b29e18face_Device=CPU_Config=() -93:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=i64_Shape=static_IR=f26c1f41ef689dde33e9d61b0a1066788b8397ba6a170f5eb1362726ba9c0868_Device=CPU_Config=() -93:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=e15d2825807b2c7fda150b7b7b4e2c6914fab2d4af4313e959abaff56dffe6d2_Device=CPU_Config=() -92:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=0495648ac153ca7bb07160aed49b620b855a89b368d363a22fb45ff3428349eb_Device=CPU_Config=() -92:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=9fbf4ccaa68a81191afe2432a2212ee1a559df380d602459ebd2d0266053d82d_Device=CPU_Config=() -92:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=7754523e2d3739481e051eb21a4347f2d157e94db3c37d47f0006ecd8d77d512_Device=CPU_Config=() -92:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=755b95b2e9c5cb5da4d4cd2c46ced327e10dbfc67a0d934667177b5fab73d431_Device=CPU_Config=() -92:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1eb25d18fbd1070f2a8ff803d76077d092d493f9e9df80e93e2f58f3621a121f_Device=CPU_Config=() -92:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=180e9c4ce23626df8010b5b79a28ecc4c6c75b65dea91938fa99025a65411239_Device=CPU_Config=() -91:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=dynamic_IR=bc8918b82285bb58c2cf1b4b60b023262426de4044e0c2d50ae07f4b22ae0eb0_Device=CPU_Config=() -91:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=08ba7fbf736896f373ea81dd727940aefae22a39e217e84dfc5617ed62133d10_Device=CPU_Config=() -91:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d671a241de6d46bd5562def47a92602d2c9ba076568feed303765168433ee89b_Device=CPU_Config=() -90:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b3cb0ba09807204990d7e1635ef35fc96aa10330de2ffefd95f6483e68dca532_Device=CPU_Config=() -90:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=718d6ff3b19f498cf4edeb9f7f4a7528fef578dd6fc7edb0796d476505472e46_Device=CPU_Config=() -90:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=2fda32f5fe8957d151306845ffd0f877b2efad70f7bd4921fab2fd770d78c2a8_Device=CPU_Config=() -90:conformance/OpImplCheckTest.checkPluginImplementation/Function=Swish_opset4_Device=CPU_Config=() -89:conformance_Squeeze/ReadIRTest.ImportExport/Op=Squeeze.1_Type=i64_Shape=static_IR=c7a696f3217515ef4ff5eb46fbd15af6533f0fcd268398fbd434f105c0a11328_Device=CPU_Config=() -89:conformance_GroupConvolution/ReadIRTest.ImportExport/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=6838901bafb44e26f73134e2c0eb2be8f1f777ab794ae340d61b62d891ff3d59_Device=CPU_Config=() -89:conformance_Gather/ReadIRTest.QueryModel/Op=Gather.8_Type=f32_Shape=dynamic_IR=f73224b14c094974e582d3d903cc332f5c1da138368692e5d0be93127f1bf753_Device=CPU_Config=() -88:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=4d569fc3e7d2fa1724c99fec62e4f31fb000a6f5c306273c404e2b449761feba_Device=CPU_Config=() -88:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2c20f6aace24bf601953b848c173ad475502b91b667c903638acf41fb9a67d3a_Device=CPU_Config=() -88:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=e03d85019ea733c10b7ece4721036f3aeae2e60179d9b044d34e862608fd36a1_Device=CPU_Config=() -88:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=285bcc240dec2c32e171f3866ea33107a109566fb8ef39f0dd84e99664aaf8df_Device=CPU_Config=() -87:conformance_StridedSlice/ReadIRTest.QueryModel/Op=StridedSlice.1_Type=i64_Shape=static_IR=edb5dc5a42b36879d5ced77fc2db7d8b331c888534602893ffb277f742da1005_Device=CPU_Config=() -87:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=eaac8b3d6a4920fa2ac101965805d140502fb409e230821d5c2a370aec15eed8_Device=CPU_Config=() -87:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b4c737aec2f47947d1afbe26d9d8cd124c6fdd24e30cab1f563d91310d1b62c7_Device=CPU_Config=() -87:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1180dfe50d43ef6b95980bafd3b84816f6d249f8341b03a6f67d20bd8f8ba6a4_Device=CPU_Config=() -86:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9b4725171957a420a98f908742f18062fbcee198871d527ab5b4d939005ac4e6_Device=CPU_Config=() -86:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=95bbf8a23b19badbde31e9ae7f016aa436d50d797f59bd736e220030f645bd9b_Device=CPU_Config=() -86:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=547fea7da34d5e65ad7ea069be003753e9ef281110c80dde11520bc350c4ca14_Device=CPU_Config=() -86:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=() -85:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=95ea118f8053f6bd18c8f34bbc475c00921bab5dc3af177492829d5cba16aa39_Device=CPU_Config=() -85:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=() -84:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=c5c5d09465cec7f1477d5e02f3f1c4cf593c71aa090532c4e43451fedde7c2c5_Device=CPU_Config=() -84:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=27b03da9a0155039856b1bebe424d10d1b8ad768747cbeb851bfc0463edd5cb6_Device=CPU_Config=() -84:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=() -83:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=1ceb1c4ba1a45cbb5cabe7cb4b416cbfeb93f24533c8123e4c2315cc7e9f40a5_Device=CPU_Config=() -83:conformance/OpImplCheckTest.checkPluginImplementation/Function=Relu_opset1_Device=CPU_Config=() -82:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=26d09bb7dc7ce95aac39023ac90bd083da9101b9e7383af49e7467e4f0571f2e_Device=CPU_Config=() -82:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0fe2c94f8e2ed43edc0deb92ffe044a089c6920f886dcf6985ee910e7a4ffaed_Device=CPU_Config=() -82:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=dynamic_IR=327d5120022c693531fe0f1f42429b1ad78f36cd5e414f1c8bab7d0c2ced62f7_Device=CPU_Config=() -81:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=2435ff5e2ac06afcf99563821fa2a2a5e4a9456cb3f74154b3eb364a6f0e450a_Device=CPU_Config=() -81:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=42f3f3a5b34aacb93147f9c77ad5709cf7436ae8cad9318434a9b6ff6852982d_Device=CPU_Config=() -81:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=0edbc14a5d5ac1265a4b880131348aa16e284012547556ddedb36b185d833284_Device=CPU_Config=() -81:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=04db488d856ff6cf4f04ad155967df95830796ad733e589f42c3862224acd874_Device=CPU_Config=() -80:conformance_SpaceToDepth/ReadIRTest.QueryModel/Op=SpaceToDepth.1_Type=f32_Shape=static_IR=9296c80cc93d8ab7448140ad2f31b3b47a0759c383d1bc045704985503732195_Device=CPU_Config=() -80:conformance_DetectionOutput/ReadIRTest.QueryModel/Op=DetectionOutput.8_Type=f32_Shape=static_IR=92c3646daf445784fceeb022afba2831938fed34660bac5445f033a1efdccc34_Device=CPU_Config=() -80:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=a093f44f22a851366eec46b6ed80fcecd2a4a96ca797c2caf288922a2fae1fd1_Device=CPU_Config=() -79:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=b63e04695c1e6145a3fa9835130a4919df52ff3a420d3c800bddff65af7dd76e_Device=CPU_Config=() -78:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=dynamic_IR=f0ae8e6b136d1db7e5e7748c03eeaed6907460d3d3941fcb1a6651cff61be113_Device=CPU_Config=() -76:conformance_ConvolutionBackpropData/ReadIRTest.QueryModel/Op=ConvolutionBackpropData.1_Type=f32_Shape=static_IR=27a43bf8c20a81f1e244ace4c53f7cd9343a2603ba2c8b50bb041a4046ae6ecd_Device=CPU_Config=() -75:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=79a6d2a402cdd74cf1277a57ff95b71d61384da394ad2a4d9ebcf422eb5c3258_Device=CPU_Config=() -75:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=12e7ea655764a32069a93a3f7ab147983bceeacc8a2bc88fbb2def005a1596b3_Device=CPU_Config=() -74:conformance_Convolution/ReadIRTest.QueryModel/Op=Convolution.1_Type=f32_Shape=static_IR=d932ccb58823509e768be954dc85ef1162d9456db17138d650a2a883e31b99ed_Device=CPU_Config=() -62:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=dynamic_IR=8bc8753f4d26c5d1f2ea481937dcce0f5b78971f18f5ebb258f49d4a0d86a333_Device=CPU_Config=() --1:conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=f097978a7f18dafc7577a9dcf2306d82d397faf1bedb106ca3de70b3d9ada557_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=() --1:conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=f110ef35c9642ecd941cd85a67a12b616353d4a8cd33f9770d532759e2846255_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=f0edc45979b98d4401eea2c345bbcb794721dd3cdbfb3963be5a2842b27ccc5b_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=e4baf41ae9a77441993eb0f95c3d7335e9a719e5eac8b1ffaf60d8f515f769a1_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=e48a363cfdabe0b62509e21641bb1cc88edaaa7d2eb82bf3ce747cab8355ff3b_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=e3a5a7f1a73793457fae9520ae122c6bbbfa92f1daac0ef214e47a2ec7ea18e2_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=d8546655166c322e3049ed3a71725c8e89901212007c44c8029ef8379de96db6_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=d36c5ab59d2ab873aa35b35a952e061568edd4ee8e64c1ab200bea63472a97b3_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=cedd3bc0f0a8e20fe947135bd6ab9515283275867e1b837d36f2fac72363f449_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=cdf79cced0ed380052910c95b09b4022841474c87d06061f29791ea2ad9813a4_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=b6669eb568f36e5d649ae67afdecaa481064561d7a71f1aab592968aca7d8bb0_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=b0e3e542180f521cfd4651ae18d3a58962751d3c6de9265240be6d4fe9745bf0_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=b06553539d6e27195623fcbce51610b5671dd70700bcf61703a1f7a8bbc7c5d8_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=98274ec3fc894754adaacedf83b4b7da373e639a51cfa7dc348412898e45e8dc_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=94b08f3c309048124724d9de0d120698fed90ff0237b07c4a4a2b7ccf843d76a_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=939b665ae35f9a384e3119dc3bdc1904b105de495d262648282c859b0cb4c9e3_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=91b6cdd8a7664759217ce0b84a8baed2105bca0ae9876e9efd01c074aa27039c_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=8de81b7de05bdd151427e1b5b03a8b4222284dafd31f9d4b1c3d0917995e9310_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=8216637727ccef527454bfdea7ab22ccd4e5e29709494bf96dde5af3b4a7eaaf_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=80cdfe1797800671134d77fa9c7032cdc1b19b4905fcefb11399610216f6e623_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=7cfae687d408da17a0405d88f47e2b6623a608861114dc76018b8a2142453139_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=67a5010efb429e6dedf35481443b40a77cb01c1b4fb51ec5890fcfcb010fd6f7_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=451a3b635d3882a87cc0d7b3f6f74197c08b708669751bb11fef93da9604e276_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=36f17a498b10c140f8a319d82e5c8f2cc3cdb7eb3be9f82f7ef35d9c9470231d_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=3141ed71fe3efbd7fb026a006824ec24e4673d8b97d23dce275548e92eedad91_Device=CPU_Config=() --1:conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=2463ef4b8684fd6b391fca0b123328e1d695b47017fe94ffe5a419a3c22ce93e_Device=CPU_Config=() --1:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=() --1:conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=() --1:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=7581193e4db43b0e50c6a1a52f8b348d88587040bf38d1b780ac660781e3d3a4_Device=CPU_Config=() +457:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=7147d6ead151efc24a53c196b63fc441e240c34b41ad2226a535580eb2a3f3d2_Device=CPU_Config=() +457:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=fda1f84f5e911136f8daaf4fcebfb989f3216c066ddc1cae578882a41ca0f5bf_Device=CPU_Config=() +457:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=static_IR=b92112b2ea2f233a6fb6ee512363082a49db0f85ab23f89dc29ad907e6ab408f_Device=CPU_Config=() +457:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=281f1852405ad37d0606184e81d8534d769f50b3fe99f5f17ebfda6954f4a584_Device=CPU_Config=() +457:conformance/OpImplCheckTest.checkPluginImplementation/Function=Pad_opset12_Device=CPU_Config=() +456:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=7754523e2d3739481e051eb21a4347f2d157e94db3c37d47f0006ecd8d77d512_Device=CPU_Config=() +456:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=596d0b6cfe8b39e0ceaa665f1fa82aeeeff78d09315fca7cef031b6dc210a1f3_Device=CPU_Config=() +456:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=54a5630072fb0e0127611a4ae63db14b7c0fa0979f4d2be7bfec548b5291a0af_Device=CPU_Config=() +456:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=346617ba1990b67ca1fec8ec219645b16aafa6c94a4a0f752c2f3633b85df679_Device=CPU_Config=() +456:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=1c63f30ce7cb977ac945ee25eb97f3c472a81b999eacbcdd4b3bfd253f25cb51_Device=CPU_Config=() +456:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i32_Shape=static_IR=cd4d566c041357cdd7f8539933888956fff5cfd15e3c42872df59d9890c169b3_Device=CPU_Config=() +456:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=5e7e2adae49fae3a376e9a5a971513a9b23b5fe4008ce51814e0fa1fd91f1f22_Device=CPU_Config=() +456:conformance/OpImplCheckTest.checkPluginImplementation/Function=IsNaN_opset10_Device=CPU_Config=() +455:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=40876e66f31053b621aea004baaba7607b9131d4fff8e8b00ed7e1e58204988c_Device=CPU_Config=() +455:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=d46d4fc3e7b3b2cea07f7ba710f77f7d99b4799e7fb0d3127ea6862f3f731ae9_Device=CPU_Config=() +455:conformance_Ceiling/ReadIRTest.Inference/Op=Ceiling.1_Type=f32_Shape=static_IR=1484c3d0a5a8b6d1daa002e27b07bb8ba0b5d83aae50b0a3b3bea08483815d55_Device=CPU_Config=() +455:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=0add7fb1bf1500ea125aa6d245bad577d6dea18d038c020d18c2dcd56704c671_Device=CPU_Config=() +455:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=c0bba39370340d37250a2107758b1374125465ee32317f5632f5bb64842c9d7a_Device=CPU_Config=() +455:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=30680a7972de02e47d59c768730b8a64a06b011dc8b5be4fd25f190662cf1c1d_Device=CPU_Config=() +455:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=dynamic_IR=edf223c654667e60869d97d2fb6a2bdf356db8d7e997b4b9a66e56445bc24f30_Device=CPU_Config=() +455:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterNDUpdate_opset15_Device=CPU_Config=() +454:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=718269cf894ffbb59c15a1c688fd7bf726a87899dd7ef6dc0c9c8731f2b33293_Device=CPU_Config=() +454:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=b99ba096eea2f3725fa98eabc2a941fa895c0a58bcd7a8ea68d2a245ce913113_Device=CPU_Config=() +454:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=00b85178c2e7f891c89e99a6692b94a56ab0882f4a30167997e104db1429a9c9_Device=CPU_Config=() +454:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=dynamic_IR=c3d754fe46cacaaf519f39fdc6feb9df6b23d92f6271f6e731c2a8ddc24a948e_Device=CPU_Config=() +454:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=281f1852405ad37d0606184e81d8534d769f50b3fe99f5f17ebfda6954f4a584_Device=CPU_Config=() +454:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=256f748d7b98b0eb70cc659403910bac929d62a2b153e63438f8746f602a83fa_Device=CPU_Config=() +454:conformance/OpImplCheckTest.checkPluginImplementation/Function=Xor_opset1_Device=CPU_Config=() +454:conformance/OpImplCheckTest.checkPluginImplementation/Function=StridedSlice_opset1_Device=CPU_Config=() +454:conformance/OpImplCheckTest.checkPluginImplementation/Function=Slice_opset8_Device=CPU_Config=() +454:conformance/OpImplCheckTest.checkPluginImplementation/Function=Negative_opset1_Device=CPU_Config=() +454:conformance/OpImplCheckTest.checkPluginImplementation/Function=I420toBGR_opset8_Device=CPU_Config=() +453:conformance_Clamp/ReadIRTest.QueryModel/Op=Clamp.1_Type=f32_Shape=static_IR=028177a440f430edc5dfd7a7f0f2c0dded422876a98b6da66a647ad9aca10e57_Device=CPU_Config=() +453:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=769e7bb56fd0d0fa75fed14765279f68841e300b1450909cdcc802d347446b52_Device=CPU_Config=() +453:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=14f4dcbc8e714fdb791d15b62646db0da2cf647d431dd6ea044ca6976ef51753_Device=CPU_Config=() +453:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=a3032224f3e9c096102921fd8571966d23c21cba931b9d5e31ba41e9698d07b6_Device=CPU_Config=() +453:conformance/OpImplCheckTest.checkPluginImplementation/Function=VariadicSplit_opset1_Device=CPU_Config=() +453:conformance/OpImplCheckTest.checkPluginImplementation/Function=TopK_opset1_Device=CPU_Config=() +453:conformance/OpImplCheckTest.checkPluginImplementation/Function=ScatterElementsUpdate_opset12_Device=CPU_Config=() +453:conformance/OpImplCheckTest.checkPluginImplementation/Function=Broadcast_opset1_Device=CPU_Config=() +452:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=45c9fd0289649c455939587c623f1884a4e675e2f970192d9ac2f60a65e6da9a_Device=CPU_Config=() +452:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=f8662769a2f3a5fb20582ccbb1931b7e3fa73ec7713eca30362b0e7c0baf829a_Device=CPU_Config=() +452:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=beb6b43d96ce20db13ecf6abc53742fdc20d2221ea66af01e3c945348acf9bd4_Device=CPU_Config=() +452:conformance/OpImplCheckTest.checkPluginImplementation/Function=Convert_opset1_Device=CPU_Config=() +452:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseXor_opset13_Device=CPU_Config=() +451:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=58b9cf97229bd8293e747a47979c3d98261275f9da473dc942b746a06a1fa214_Device=CPU_Config=() +451:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=8b9cabc6a44ece744453092791ef63b8d6ca4d83af7e8635f2f4ad78186e5184_Device=CPU_Config=() +451:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=edb39965b8843a3b48f2478c204a8dafdab8eb2ff76dbbbe82dca6ee3b4589af_Device=CPU_Config=() +451:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=14598e053d7dee616de43f2b160e780b4bb53decaea53b31db58341464b82e48_Device=CPU_Config=() +451:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=3fbff9f870428a19ed434cdf72834eec251edc3dddd149491c94319d63a8438e_Device=CPU_Config=() +451:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=5c513c27d089910165e78a92df11852007d7c5332246fdce490b3c6dbc16b44c_Device=CPU_Config=() +451:conformance/OpImplCheckTest.checkPluginImplementation/Function=SpaceToBatch_opset2_Device=CPU_Config=() +451:conformance/OpImplCheckTest.checkPluginImplementation/Function=OneHot_opset1_Device=CPU_Config=() +450:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=4df317952d546ce966e5273b7fcc7a611c641b1cddeebc74d1b66ea80567ee89_Device=CPU_Config=() +450:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0da39d97a2f46fcbdf524727d0283243d3bf0c3fab75f76f529b6480c84f67c1_Device=CPU_Config=() +450:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=a7f6c704686f1b0e6fd4ab522930aa3fb5b4cd4683b204aa31e5c73b427e7058_Device=CPU_Config=() +450:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=dabed23c3f30d92c6fcca7a6845160022837de8cbfa1077c222e6f1224b745e1_Device=CPU_Config=() +449:conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=dynamic_IR=b31dbb99720fd5083e5a7e5b1b626bda91455999e2918eb8e658992cfa6588dc_Device=CPU_Config=() +449:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=dynamic_IR=60bd170e816e0c2345a1658fd88459775fe8b7cce5de31a16e4e6cdea199f264_Device=CPU_Config=() +449:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=681b1f284fb69c16681d3efd2081d7f812496e3a027baef35a75bb0aeb9c003b_Device=CPU_Config=() +449:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=346617ba1990b67ca1fec8ec219645b16aafa6c94a4a0f752c2f3633b85df679_Device=CPU_Config=() +449:conformance/OpImplCheckTest.checkPluginImplementation/Function=Asin_opset1_Device=CPU_Config=() +448:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=() +448:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=99b432aa5821136994e06b4e3c690a4e298bc5a496740ea2c5fe6aa300edacf8_Device=CPU_Config=() +448:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=2aa586a55098e1960c204572ca9704bb3b8b9a3baab5fcf08200594261f7bef7_Device=CPU_Config=() +448:conformance/OpImplCheckTest.checkPluginImplementation/Function=Col2Im_opset15_Device=CPU_Config=() +448:conformance/OpImplCheckTest.checkPluginImplementation/Function=BatchNormInference_opset1_Device=CPU_Config=() +447:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=() +447:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=static_IR=d661093ec9006177e5d47e7f666d7c98353f9c3d5290ba6284145f60822f2573_Device=CPU_Config=() +447:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=fabbe8bc510b0d1afb64f2fbe68d755be05fdccfadec5fe845dc6b3c4e6a2767_Device=CPU_Config=() +447:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=cbfc33348aff4daf15fb7926884243c7ffe38aa29e60eceda90fa9b8aadad5b1_Device=CPU_Config=() +447:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=922699707423c4110bf8a551eaf7dc3689fd3673fff79cca21442cda90c22dda_Device=CPU_Config=() +447:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=07b257862a62290d7e8ae939147bb7422992528bf54209b8d1bff500b99b6f4b_Device=CPU_Config=() +447:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=02f589480d24784ece323ba30be856c7cc718151d3588f683ef4825a407749ac_Device=CPU_Config=() +446:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=b584676efc43f08169626742b0af9b96fda041574269fc007d97acf89eed42b3_Device=CPU_Config=() +446:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=6e614b9877c6dd3bf1ebd731443e5a1e0b7492edbc3a4683adcff53c965ca1bb_Device=CPU_Config=() +446:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=899cf50d8feefa9c5e02f6fe88b79e66b59c4a53478755d51b3e82570683613b_Device=CPU_Config=() +446:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=64bd2f48b3326db083653b5993c9a75d21be515cbc5af67c62c981e9744e2f0b_Device=CPU_Config=() +446:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=0bc2bfc4481de7733f5503750d21376d00de6bfa699ecff3ee0c4333d9515db8_Device=CPU_Config=() +446:conformance/OpImplCheckTest.checkPluginImplementation/Function=Erf_opset1_Device=CPU_Config=() +445:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=() +445:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=dd366f3f5b63fbfce3d9378cf0d8bfa4a909a973bc3e5e97eaa9d346c5cbf1d4_Device=CPU_Config=() +445:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=dynamic_IR=a937747c04b70351d3632aab91189200e2c0a69b6467ed856b7075885c54d83a_Device=CPU_Config=() +445:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=() +445:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=c0c1a43608279d8870258be63005b38e23fe5501876c87840cc16a0bb2cf8dfe_Device=CPU_Config=() +445:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=5c513c27d089910165e78a92df11852007d7c5332246fdce490b3c6dbc16b44c_Device=CPU_Config=() +445:conformance/OpImplCheckTest.checkPluginImplementation/Function=Pad_opset1_Device=CPU_Config=() +445:conformance/OpImplCheckTest.checkPluginImplementation/Function=PSROIPooling_opset1_Device=CPU_Config=() +445:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonMaxSuppression_opset3_Device=CPU_Config=() +444:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=dynamic_IR=e46ec3487f18188d1da4c029a2981033018c1f8f273f60d3f7d1bcbdae18c2c5_Device=CPU_Config=() +444:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=66cff13148d62809cced5a381c251525486476f7178eddd3c8e45eeed40afd06_Device=CPU_Config=() +444:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=() +444:conformance/OpImplCheckTest.checkPluginImplementation/Function=Multinomial_opset13_Device=CPU_Config=() +443:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=b7973bf8dd344289b971d9b47575d6793643f503e13bb83c4e9c2a2863570b7a_Device=CPU_Config=() +443:conformance/OpImplCheckTest.checkPluginImplementation/Function=NonZero_opset3_Device=CPU_Config=() +442:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=static_IR=66cff13148d62809cced5a381c251525486476f7178eddd3c8e45eeed40afd06_Device=CPU_Config=() +442:conformance/OpImplCheckTest.checkPluginImplementation/Function=MVN_opset6_Device=CPU_Config=() +441:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=dynamic_IR=70c260fea7c5ff6d2d1e9580ecf6c6a8a26c0e688b4f8dc4540888526bc13e76_Device=CPU_Config=() +441:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=adabeb9321a0770cb065345aca787cbf7d1adef68132cc5c7d8df885ea64ab2c_Device=CPU_Config=() +441:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=33297e2649e2f0c53b0bfb5e349d83ede580471764202480855e3f1efc8017a5_Device=CPU_Config=() +441:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceMean_opset1_Device=CPU_Config=() +441:conformance/OpImplCheckTest.checkPluginImplementation/Function=NormalizeL2_opset1_Device=CPU_Config=() +441:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMCell_opset1_Device=CPU_Config=() +441:conformance/OpImplCheckTest.checkPluginImplementation/Function=ConvertPromoteTypes_opset14_Device=CPU_Config=() +440:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=() +440:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i32_Shape=dynamic_IR=6a0218ea2e7eb0329e4915f2f6a7c215742d2469e868a4a8e43c683c2dddc01d_Device=CPU_Config=() +440:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=dynamic_IR=e306da3fedc4369302fb21159f2bbbe65849661eabe5bb83efdad3e83f64fd68_Device=CPU_Config=() +440:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=3c1c8bc7ce009c03509ca9d6a86f3d5cff89be49439e7513edcde4e62fbfb8ce_Device=CPU_Config=() +440:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=33297e2649e2f0c53b0bfb5e349d83ede580471764202480855e3f1efc8017a5_Device=CPU_Config=() +440:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=4520f02da2bc674bf781c84ea3cca92375a1eeaa77f4f4f7e4cfc3ef75fb2964_Device=CPU_Config=() +440:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i32_Shape=static_IR=cd4d566c041357cdd7f8539933888956fff5cfd15e3c42872df59d9890c169b3_Device=CPU_Config=() +439:conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=bcaccd02132919b356b3d4928fa5f1dc4bb2902748fe238f849e557a42e7a879_Device=CPU_Config=() +439:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=93788242c06d787e33afa50ecbef5372898e50024d0c88624056a752535572bf_Device=CPU_Config=() +439:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=6daaaff289d357ea77e7a8656dc7ce8d368771abebee6641a097def0a8170b8b_Device=CPU_Config=() +439:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0bc2bfc4481de7733f5503750d21376d00de6bfa699ecff3ee0c4333d9515db8_Device=CPU_Config=() +439:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=8337ad383956ad96ca95f4aeb967e05c694fe586b4ed6e46547e3ffa0217c59b_Device=CPU_Config=() +439:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=9c6d5cdaf19c92d1f994e4ae6cfdecf5a9ff04e47a2e0e68f3a08ec8f6e74479_Device=CPU_Config=() +439:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=boolean_Shape=static_IR=0702c04c1d16f65b7d552044e66732886a0b389702aa43f4c845e2460ddff1c4_Device=CPU_Config=() +439:conformance_Abs/ReadIRTest.ImportExport/Op=Abs.1_Type=f32_Shape=static_IR=083771171646a2eadcbb3384bd457e04d74ce8ea771813cdf67c56f7bbf20c69_Device=CPU_Config=() +438:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=i64_Shape=dynamic_IR=70c260fea7c5ff6d2d1e9580ecf6c6a8a26c0e688b4f8dc4540888526bc13e76_Device=CPU_Config=() +438:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=d46d4fc3e7b3b2cea07f7ba710f77f7d99b4799e7fb0d3127ea6862f3f731ae9_Device=CPU_Config=() +438:conformance/OpImplCheckTest.checkPluginImplementation/Function=Swish_opset4_Device=CPU_Config=() +438:conformance/OpImplCheckTest.checkPluginImplementation/Function=Squeeze_opset1_Device=CPU_Config=() +438:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalXor_opset2_Device=CPU_Config=() +437:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=0c6a844f626f6628628034d332ccb6d520e0447e4b616048c7efb516d0fd87bb_Device=CPU_Config=() +437:conformance/OpImplCheckTest.checkPluginImplementation/Function=DepthToSpace_opset1_Device=CPU_Config=() +437:conformance/OpImplCheckTest.checkPluginImplementation/Function=CumSum_opset3_Device=CPU_Config=() +436:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=060423427a9100b6a38aad12a83043441f8af436c1d2502350ae867f45bd721f_Device=CPU_Config=() +436:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=1f29402ea664e850ea05d5f2e500f087a6165f1f4c9b3e5102b5509c020f0f6d_Device=CPU_Config=() +436:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=9ec078619d1ab35cd4e6a1a176bcbb2bd0e493689929a7fb1ab9a526e9ba6bd2_Device=CPU_Config=() +436:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMSequence_opset1_Device=CPU_Config=() +435:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=5df86bdcc255998a0b5b18e64e3059afb2c80e37b5695208d04a6fc0f1410b50_Device=CPU_Config=() +435:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=5be0b1c69be525cbddd7996b695c1a4a9f380173d03f291e8570df76c050678b_Device=CPU_Config=() +435:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=dabed23c3f30d92c6fcca7a6845160022837de8cbfa1077c222e6f1224b745e1_Device=CPU_Config=() +434:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=5df86bdcc255998a0b5b18e64e3059afb2c80e37b5695208d04a6fc0f1410b50_Device=CPU_Config=() +434:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=488c8e933df63c1368e021869a92fd48929ac252863ed4c2acfab7174b449581_Device=CPU_Config=() +433:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=f32_Shape=static_IR=6d7cce19ff10d7690177fe1e3200d872ef5d8827b7ff49e6c9994e597a15dab2_Device=CPU_Config=() +433:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIAlign_opset9_Device=CPU_Config=() +433:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExtractImagePatches_opset3_Device=CPU_Config=() +433:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseLeftShift_opset15_Device=CPU_Config=() +432:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=43a00b4dc097228af52c00054951dd5b57d8e0086207f11a8996e5ac880c8980_Device=CPU_Config=() +432:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0df360e6d6391827cd65ceefd3201c263a829e50ed375522d4e8700f3879de09_Device=CPU_Config=() +432:conformance_AvgPool/ReadIRTest.Inference/Op=AvgPool.1_Type=f32_Shape=static_IR=9b915f1788d3d4768839d2cefe4fbba2f8b2d8aa4c22f9ad574335c22d0db1a2_Device=CPU_Config=() +432:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=9b9521ed73100b54a3c5920107db944380157eea1b72f4e4d94f8e2ced1f2e4f_Device=CPU_Config=() +432:conformance/OpImplCheckTest.checkPluginImplementation/Function=Subtract_opset1_Device=CPU_Config=() +432:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReadValue_opset3_Device=CPU_Config=() +432:conformance/OpImplCheckTest.checkPluginImplementation/Function=Gather_opset8_Device=CPU_Config=() +431:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4bedf955c6ec574258a05f59e5397225e1360ba68ea49d4fe105d6a62ccb3e97_Device=CPU_Config=() +431:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=8b8121ebbd51ee995f98531f595145a01ba70ce026ad0bee588733c33e70272d_Device=CPU_Config=() +431:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=cc13aaec2a2bbe9b760651d358622114b4b0a20cb106472bd8519f0fade61dcd_Device=CPU_Config=() +431:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=69ca2cf8f4d548a3d5a031c503acb5d830b490f0035255a175ef5698de7e5fa7_Device=CPU_Config=() +431:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=eed21ac7c17920ba437332691e231037113367ee3d256b4db1380c8d2e0db84f_Device=CPU_Config=() +431:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sigmoid_opset1_Device=CPU_Config=() +430:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=6d7cce19ff10d7690177fe1e3200d872ef5d8827b7ff49e6c9994e597a15dab2_Device=CPU_Config=() +430:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sinh_opset1_Device=CPU_Config=() +429:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i64_Shape=static_IR=315fa20f952b6c7678cc93dbfd340097847826fea7928eabcec46d7ccacdb224_Device=CPU_Config=() +429:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=d294c71f3796d2e2b88f819f6512ed03942eab440681a5bc5b092e5a34192107_Device=CPU_Config=() +429:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=d38ac6654882078aafe169f6d1280279fa81e646529f6f2bd621338a756046a0_Device=CPU_Config=() +429:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=cbfc33348aff4daf15fb7926884243c7ffe38aa29e60eceda90fa9b8aadad5b1_Device=CPU_Config=() +429:conformance/OpImplCheckTest.checkPluginImplementation/Function=Minimum_opset1_Device=CPU_Config=() +428:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=05f8a9ef1ef4b191dff5dedd1fa79abad9603ee87a49306ad26c5d20ad067448_Device=CPU_Config=() +428:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=b8e37f2c8e2574b3f3554578b72e9df771c290c1bb47238fc4de9754c6e6f126_Device=CPU_Config=() +428:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e05af92d21ebd869cf6e9554a4aa0bfc60c8b0c64baebee798f0be5a0a01019e_Device=CPU_Config=() +428:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=5b466c4e4b53a5ea739df517da47f0764f9e31197b7d30fd9dabf17d1b33a489_Device=CPU_Config=() +428:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogSoftmax_opset5_Device=CPU_Config=() +428:conformance/OpImplCheckTest.checkPluginImplementation/Function=GRUSequence_opset5_Device=CPU_Config=() +428:conformance/OpImplCheckTest.checkPluginImplementation/Function=EmbeddingBagPacked_opset15_Device=CPU_Config=() +427:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=adabeb9321a0770cb065345aca787cbf7d1adef68132cc5c7d8df885ea64ab2c_Device=CPU_Config=() +427:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=c985b086d155654f9db8470da3af5245c4fbb0139015d049b8b3b20f393c2545_Device=CPU_Config=() +426:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b7983ae70a4e7868ccbf4b25a5d8e795620182c29817ad1151d89f2e932d770b_Device=CPU_Config=() +426:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=d294c71f3796d2e2b88f819f6512ed03942eab440681a5bc5b092e5a34192107_Device=CPU_Config=() +426:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=0d782801290370c7c390ad549171ec3500ab344b8b34ce4b8fd8b05339fe5557_Device=CPU_Config=() +426:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=68ae288409f3972b9f52f4ea76573a81d764758059915949e76dc5f20e6952bf_Device=CPU_Config=() +426:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=9d26a7c321db2d87b29b93baeca20dd25357e7777261ea6a4cbf968a203969ea_Device=CPU_Config=() +426:conformance/OpImplCheckTest.checkPluginImplementation/Function=ShapeOf_opset1_Device=CPU_Config=() +426:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalAnd_opset1_Device=CPU_Config=() +426:conformance/OpImplCheckTest.checkPluginImplementation/Function=Asinh_opset4_Device=CPU_Config=() +425:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0973b76264164ca52a9883a69ff5f7df977e28c33a0dbe9095e7e92acd7854bf_Device=CPU_Config=() +425:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=dynamic_IR=6b70264ed3eb3831e0e034230813ce1a1e71c157a302822b56335e587bd200b3_Device=CPU_Config=() +425:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=b99ba096eea2f3725fa98eabc2a941fa895c0a58bcd7a8ea68d2a245ce913113_Device=CPU_Config=() +425:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=7147d6ead151efc24a53c196b63fc441e240c34b41ad2226a535580eb2a3f3d2_Device=CPU_Config=() +425:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=e05af92d21ebd869cf6e9554a4aa0bfc60c8b0c64baebee798f0be5a0a01019e_Device=CPU_Config=() +424:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=225aaa01462e6e43c0c12cff65f96e7d9c07d368a820ff3c1b2939fefe86d492_Device=CPU_Config=() +424:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=c0c33bc628fffda062b4f013c7d41d0f9080f14f41e084ac547099384a9b3d20_Device=CPU_Config=() +424:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sqrt_opset1_Device=CPU_Config=() +423:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=0f61e4837d11be2b01f69947cd0b424a45d2e548d9c70ae53b07c43fa1237cd0_Device=CPU_Config=() +423:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=73623637f6155bde0a4735dcd904e5b491d7d459bef5f8d3f66f02f9558937a1_Device=CPU_Config=() +423:conformance/OpImplCheckTest.checkPluginImplementation/Function=MaxPool_opset8_Device=CPU_Config=() +422:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=i64_Shape=dynamic_IR=c3d754fe46cacaaf519f39fdc6feb9df6b23d92f6271f6e731c2a8ddc24a948e_Device=CPU_Config=() +422:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=c0bba39370340d37250a2107758b1374125465ee32317f5632f5bb64842c9d7a_Device=CPU_Config=() +422:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReorgYolo_opset2_Device=CPU_Config=() +422:conformance/OpImplCheckTest.checkPluginImplementation/Function=BatchToSpace_opset2_Device=CPU_Config=() +421:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=() +421:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIPooling_opset2_Device=CPU_Config=() +420:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=dynamic_IR=60bd170e816e0c2345a1658fd88459775fe8b7cce5de31a16e4e6cdea199f264_Device=CPU_Config=() +420:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=14598e053d7dee616de43f2b160e780b4bb53decaea53b31db58341464b82e48_Device=CPU_Config=() +420:conformance/OpImplCheckTest.checkPluginImplementation/Function=Sign_opset1_Device=CPU_Config=() +420:conformance/OpImplCheckTest.checkPluginImplementation/Function=BinaryConvolution_opset1_Device=CPU_Config=() +419:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=e4388b1379e224ea4849e6052827ef17b490cab3718159195ea2b2986719bb4a_Device=CPU_Config=() +419:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=static_IR=d81ef130a76622c79592b0b42acf5cd6dd357ccec28958dec6eb02a654beb9ab_Device=CPU_Config=() +418:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=03ebf297344daffba82d04292a767fcd7c959f56788ede32ff0d7c5af06ea504_Device=CPU_Config=() +418:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e8a26a33d6dbe0bb560820295fb6b8aafc3da0d2b78e29199d2f09e952722efe_Device=CPU_Config=() +418:conformance/OpImplCheckTest.checkPluginImplementation/Function=FakeQuantize_opset1_Device=CPU_Config=() +417:conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a4772901ff77541ae624f89db89901c7d5a502a0dc5d1e0dc21eb8e08c599525_Device=CPU_Config=() +417:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=2ce56cfc77884dfc61f7e9fab9a0ce04a4b016f9b3d13465cde1576b9374a2a6_Device=CPU_Config=() +416:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=dynamic_IR=6b70264ed3eb3831e0e034230813ce1a1e71c157a302822b56335e587bd200b3_Device=CPU_Config=() +416:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=269ec3789c76e21789e01e31f13f0f1a4895905b3f131e710e663ed2a0d8f632_Device=CPU_Config=() +416:conformance/OpImplCheckTest.checkPluginImplementation/Function=DetectionOutput_opset1_Device=CPU_Config=() +415:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=d76cd25e23d34af8e58f6447a49a50d66cc28592d3432577c240e75e00d5a765_Device=CPU_Config=() +415:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=1da672197f2c962a6cdfb059e9d09c10a03c3b082838f53d2faf6a761fee0637_Device=CPU_Config=() +414:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i64_Shape=static_IR=df62dbfb022ab001a9df6b16311f57e744e8674fa8751b4e3a7ffee872fecc20_Device=CPU_Config=() +414:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=269ec3789c76e21789e01e31f13f0f1a4895905b3f131e710e663ed2a0d8f632_Device=CPU_Config=() +414:conformance/OpImplCheckTest.checkPluginImplementation/Function=LSTMCell_opset4_Device=CPU_Config=() +414:conformance/OpImplCheckTest.checkPluginImplementation/Function=Eye_opset9_Device=CPU_Config=() +413:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=b3cb0ba09807204990d7e1635ef35fc96aa10330de2ffefd95f6483e68dca532_Device=CPU_Config=() +413:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=30466048a7da9db59d20a210af1979341f7b9552362e64a89357d650102a213e_Device=CPU_Config=() +413:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=dynamic_IR=6a0218ea2e7eb0329e4915f2f6a7c215742d2469e868a4a8e43c683c2dddc01d_Device=CPU_Config=() +413:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=i64_Shape=static_IR=79738eda1d37027e5fe69a728ba8112851351b5994db7e537f38a6f7f109329e_Device=CPU_Config=() +413:conformance/OpImplCheckTest.checkPluginImplementation/Function=BitwiseAnd_opset13_Device=CPU_Config=() +412:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=0d782801290370c7c390ad549171ec3500ab344b8b34ce4b8fd8b05339fe5557_Device=CPU_Config=() +412:conformance/OpImplCheckTest.checkPluginImplementation/Function=Atan_opset1_Device=CPU_Config=() +411:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=f32_Shape=static_IR=f8662769a2f3a5fb20582ccbb1931b7e3fa73ec7713eca30362b0e7c0baf829a_Device=CPU_Config=() +411:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=6b69e46c11a2a82ac7ad6697cd768d88da6e870e75f489779bbd1714bad23450_Device=CPU_Config=() +411:conformance/OpImplCheckTest.checkPluginImplementation/Function=Einsum_opset7_Device=CPU_Config=() +410:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=i64_Shape=dynamic_IR=c3d754fe46cacaaf519f39fdc6feb9df6b23d92f6271f6e731c2a8ddc24a948e_Device=CPU_Config=() +410:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=beb6b43d96ce20db13ecf6abc53742fdc20d2221ea66af01e3c945348acf9bd4_Device=CPU_Config=() +410:conformance/OpImplCheckTest.checkPluginImplementation/Function=Concat_opset1_Device=CPU_Config=() +409:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=c56cf3dc39ed0072f3e5a8cadd1502fef904b32de3b7760ee4c6964c0e505ac9_Device=CPU_Config=() +408:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i64_Shape=static_IR=93ce70e605eb712479090e3a266e86eb7422bf0fdd3acb1c38a0b92a9c381e2c_Device=CPU_Config=() +408:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=i32_Shape=static_IR=c70693ee2f825a40f3e1fc8dd2ce9355690bc33ff27030f674d082a0cb343cc9_Device=CPU_Config=() +408:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=13e9472dcdeb5e6ce2928191ed13dde08b6cdd62c82c94e77469d8a3ed94e39b_Device=CPU_Config=() +408:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronGenerateProposalsSingleImage_opset6_Device=CPU_Config=() +407:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=a815b68b6a8d36546d3ac0112c60283bd69ae1059e8deeb98b21f538c8089beb_Device=CPU_Config=() +407:conformance/OpImplCheckTest.checkPluginImplementation/Function=SpaceToDepth_opset1_Device=CPU_Config=() +406:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=bd3ed1b35506cb92c8e587acb102c70abbe02bdaa75f76e5792d48d8e1f2f33f_Device=CPU_Config=() +406:conformance_AvgPool/ReadIRTest.QueryModel/Op=AvgPool.1_Type=f32_Shape=static_IR=f286960ead5b83e3e4015ee5751b114a9d70e90aa788e0fb004ac50b95a8fa2d_Device=CPU_Config=() +406:conformance/OpImplCheckTest.checkPluginImplementation/Function=ROIAlign_opset3_Device=CPU_Config=() +405:conformance/OpImplCheckTest.checkPluginImplementation/Function=Bucketize_opset3_Device=CPU_Config=() +404:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=486675b6412030beffb4209c326672af07d343d5e1bbca31b9bfeed3cc339e3d_Device=CPU_Config=() +404:conformance/OpImplCheckTest.checkPluginImplementation/Function=DetectionOutput_opset8_Device=CPU_Config=() +403:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=1180dfe50d43ef6b95980bafd3b84816f6d249f8341b03a6f67d20bd8f8ba6a4_Device=CPU_Config=() +403:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=69ca2cf8f4d548a3d5a031c503acb5d830b490f0035255a175ef5698de7e5fa7_Device=CPU_Config=() +402:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i32_Shape=static_IR=1c63f30ce7cb977ac945ee25eb97f3c472a81b999eacbcdd4b3bfd253f25cb51_Device=CPU_Config=() +401:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=i32_Shape=static_IR=c70693ee2f825a40f3e1fc8dd2ce9355690bc33ff27030f674d082a0cb343cc9_Device=CPU_Config=() +401:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=static_IR=3f0c39b97aeab67748bd4039950e926a9d9f33b6d3261c4d65d048500adb5b7f_Device=CPU_Config=() +401:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronDetectionOutput_opset6_Device=CPU_Config=() +400:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=922e194a5ae53e76be5ae624754d3c1fe5ea0d8c564410062bd9c30afc48ffe0_Device=CPU_Config=() +400:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=14598e053d7dee616de43f2b160e780b4bb53decaea53b31db58341464b82e48_Device=CPU_Config=() +400:conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=() +399:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4fb0809c5cf2945a097d18f445de6f4f5cd2c124cdb495e6f0a12e9d937e2b80_Device=CPU_Config=() +399:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=static_IR=596d0b6cfe8b39e0ceaa665f1fa82aeeeff78d09315fca7cef031b6dc210a1f3_Device=CPU_Config=() +399:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=55d83e2240e88295a78084f92162888c9b0beef46ae468cd7ab93a1c0a432835_Device=CPU_Config=() +399:conformance/OpImplCheckTest.checkPluginImplementation/Function=RNNCell_opset1_Device=CPU_Config=() +398:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=i64_Shape=dynamic_IR=edf223c654667e60869d97d2fb6a2bdf356db8d7e997b4b9a66e56445bc24f30_Device=CPU_Config=() +397:conformance_Convert/ReadIRTest.QueryModel/Op=Convert.1_Type=i32_Shape=static_IR=7aacf3576c3d114915bc3aa48c8ee4ac9e94bc00928709d86461877a8d2d84fa_Device=CPU_Config=() +396:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=64bd2f48b3326db083653b5993c9a75d21be515cbc5af67c62c981e9744e2f0b_Device=CPU_Config=() +396:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=() +396:conformance/OpImplCheckTest.checkPluginImplementation/Function=Constant_opset1_Device=CPU_Config=() +395:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=a3d8e1343e43c666358304b530278c73bc7c52a0d7fff38977154b6f7c456731_Device=CPU_Config=() +395:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=a0336bba08291ea34d6271c83816fb349d163fc5989171b07fe1bce50a2f3ea9_Device=CPU_Config=() +395:conformance_AvgPool/ReadIRTest.ImportExport/Op=AvgPool.1_Type=f32_Shape=static_IR=d442b2d9df68f25f567a3e8da8d87866c200d391624cf1c339554a57a9a527a4_Device=CPU_Config=() +395:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=static_IR=2c114b0035075d866c028f9a1168725375feac9a666a881ae6b7db6e9066bb3f_Device=CPU_Config=() +395:conformance/OpImplCheckTest.checkPluginImplementation/Function=AvgPool_opset1_Device=CPU_Config=() +394:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=3e4364d93433ea741efe178b0c83cfb13c46259888aec468f59f77cd3f1bb39f_Device=CPU_Config=() +394:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=d673fdf688abaeaf4cc6239ff762f8df557ab445bf9f031ab3bd87782717f2ef_Device=CPU_Config=() +394:conformance/OpImplCheckTest.checkPluginImplementation/Function=Ceiling_opset1_Device=CPU_Config=() +392:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=ea860537d420b0d1afe0ec9a10192912ec59d8f4ba01b27add362ce50fd6b380_Device=CPU_Config=() +392:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=d81ef130a76622c79592b0b42acf5cd6dd357ccec28958dec6eb02a654beb9ab_Device=CPU_Config=() +392:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=29624e785b9377dbf03b9aae46e7d0049e93a94655059ec37a0fe308ff7cb9a3_Device=CPU_Config=() +391:conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=static_IR=e365913541918ae265939740fd9930d4f5d919773ce47a4e896a264bd8f86460_Device=CPU_Config=() +390:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i64_Shape=static_IR=79738eda1d37027e5fe69a728ba8112851351b5994db7e537f38a6f7f109329e_Device=CPU_Config=() +390:conformance/OpImplCheckTest.checkPluginImplementation/Function=ReduceSum_opset1_Device=CPU_Config=() +389:conformance/OpImplCheckTest.checkPluginImplementation/Function=Selu_opset1_Device=CPU_Config=() +389:conformance/OpImplCheckTest.checkPluginImplementation/Function=BatchNormInference_opset5_Device=CPU_Config=() +388:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=4014e6cbcd000f86268253c54f7543e96897c729508d56ab831ee8a2687669db_Device=CPU_Config=() +388:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=9ec078619d1ab35cd4e6a1a176bcbb2bd0e493689929a7fb1ab9a526e9ba6bd2_Device=CPU_Config=() +386:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=dynamic_IR=c0c1a43608279d8870258be63005b38e23fe5501876c87840cc16a0bb2cf8dfe_Device=CPU_Config=() +385:conformance_Broadcast/ReadIRTest.ImportExport/Op=Broadcast.3_Type=f32_Shape=static_IR=3e4364d93433ea741efe178b0c83cfb13c46259888aec468f59f77cd3f1bb39f_Device=CPU_Config=() +385:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=29624e785b9377dbf03b9aae46e7d0049e93a94655059ec37a0fe308ff7cb9a3_Device=CPU_Config=() +384:conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=a3032224f3e9c096102921fd8571966d23c21cba931b9d5e31ba41e9698d07b6_Device=CPU_Config=() +384:conformance/OpImplCheckTest.checkPluginImplementation/Function=Add_opset1_Device=CPU_Config=() +383:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=static_IR=12e7ea655764a32069a93a3f7ab147983bceeacc8a2bc88fbb2def005a1596b3_Device=CPU_Config=() +383:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=09dd33f661a07095dc47e3e5205c9fc6dceda72526e79be0751c34823c7e7cf1_Device=CPU_Config=() +383:conformance/OpImplCheckTest.checkPluginImplementation/Function=Multiply_opset1_Device=CPU_Config=() +382:conformance/OpImplCheckTest.checkPluginImplementation/Function=Split_opset1_Device=CPU_Config=() +382:conformance/OpImplCheckTest.checkPluginImplementation/Function=LogicalNot_opset1_Device=CPU_Config=() +381:conformance/OpImplCheckTest.checkPluginImplementation/Function=Maximum_opset1_Device=CPU_Config=() +380:conformance_Add/ReadIRTest.ImportExport/Op=Add.1_Type=f32_Shape=dynamic_IR=14f4dcbc8e714fdb791d15b62646db0da2cf647d431dd6ea044ca6976ef51753_Device=CPU_Config=() +378:conformance_Concat/ReadIRTest.ImportExport/Op=Concat.1_Type=f32_Shape=static_IR=4a64918e1c0c648268ad4a1c2147889b2578b4513693737ec2ea1c7ff81dbc52_Device=CPU_Config=() +377:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=i32_Shape=static_IR=6ddb35aeda2a6cb63282d2fcf6503aa02135ad60e23c752280ef82aaf6a31191_Device=CPU_Config=() +377:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=941fa6fdaa34b8082171350da966423497232e44077f333cf3a46488bf237aeb_Device=CPU_Config=() +377:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=053d601716750db93af5ae01d67213086ed987370f9ff59723824dcd0a6c2462_Device=CPU_Config=() +376:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=u64_Shape=dynamic_IR=5f87db7fc306440f807b413acb7eb175932f29f59d1b5eb4a9df8945b9aef9d4_Device=CPU_Config=() +372:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=dynamic_IR=e46ec3487f18188d1da4c029a2981033018c1f8f273f60d3f7d1bcbdae18c2c5_Device=CPU_Config=() +372:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=1e95665a92aa6efcc7e06d24fbe4cb2afa07d75374cea3ea928658a270ef489b_Device=CPU_Config=() +371:conformance/OpImplCheckTest.checkPluginImplementation/Function=Relu_opset1_Device=CPU_Config=() +371:conformance/OpImplCheckTest.checkPluginImplementation/Function=AdaptiveAvgPool_opset8_Device=CPU_Config=() +369:conformance/OpImplCheckTest.checkPluginImplementation/Function=Interpolate_opset4_Device=CPU_Config=() +367:conformance/OpImplCheckTest.checkPluginImplementation/Function=ExperimentalDetectronROIFeatureExtractor_opset6_Device=CPU_Config=() +366:conformance_Convolution/ReadIRTest.ImportExport/Op=Convolution.1_Type=f32_Shape=dynamic_IR=6daca83f4b162285c00c695825e255cbafce9cf9c9cea68b969a301105475303_Device=CPU_Config=() +365:conformance_Broadcast/ReadIRTest.QueryModel/Op=Broadcast.3_Type=f32_Shape=static_IR=674e2446a2f5929d12d36f14451d68e7b55ad61d2d8df755e85c27c4a52943e3_Device=CPU_Config=() +365:conformance/OpImplCheckTest.checkPluginImplementation/Function=Select_opset1_Device=CPU_Config=() +364:conformance_Add/ReadIRTest.QueryModel/Op=Add.1_Type=f32_Shape=static_IR=1c0ac850b5e9b69e2e30303d623c5e0634622fc9764374217f3c892655349c12_Device=CPU_Config=() +364:conformance/OpImplCheckTest.checkPluginImplementation/Function=HardSigmoid_opset1_Device=CPU_Config=() +360:conformance/OpImplCheckTest.checkPluginImplementation/Function=Unsqueeze_opset1_Device=CPU_Config=() +356:conformance/OpImplCheckTest.checkPluginImplementation/Function=NV12toBGR_opset8_Device=CPU_Config=() +354:conformance/OpImplCheckTest.checkPluginImplementation/Function=Divide_opset1_Device=CPU_Config=() +348:conformance_Concat/ReadIRTest.QueryModel/Op=Concat.1_Type=f32_Shape=static_IR=e8a26a33d6dbe0bb560820295fb6b8aafc3da0d2b78e29199d2f09e952722efe_Device=CPU_Config=() +345:conformance_Convert/ReadIRTest.ImportExport/Op=Convert.1_Type=i32_Shape=dynamic_IR=60bd170e816e0c2345a1658fd88459775fe8b7cce5de31a16e4e6cdea199f264_Device=CPU_Config=() +342:conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=f32_Shape=dynamic_IR=e306da3fedc4369302fb21159f2bbbe65849661eabe5bb83efdad3e83f64fd68_Device=CPU_Config=() +314:conformance/OpImplCheckTest.checkPluginImplementation/Function=Abs_opset1_Device=CPU_Config=() +277:conformance/OpImplCheckTest.checkPluginImplementation/Function=Acosh_opset4_Device=CPU_Config=() +276:conformance/OpImplCheckTest.checkPluginImplementation/Function=AdaptiveMaxPool_opset8_Device=CPU_Config=() +248:conformance/OpImplCheckTest.checkPluginImplementation/Function=Acos_opset1_Device=CPU_Config=() \ No newline at end of file diff --git a/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_OP.csv b/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_OP.csv index 857d92d1ddd718..cc638e28267751 100644 --- a/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_OP.csv +++ b/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_OP.csv @@ -1,251 +1,196 @@ Test Name,Fix Priority -conformance_FakeQuantize/ReadIRTest.Inference/Op=FakeQuantize.1_Type=f32_Shape=static_IR=935369702948a57e71d169e75218162f370b48f344fe819f11112c011b6626fc_Device=CPU_Config=() -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bf235091db192c86756347e70771b4b00a6ac2c8852b93079749ba718d57d022_Device=CPU_Config=(),1.0 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=(),0.575008 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bee11d430236dcbd0fb5efbae712d8d89d84beeb89e0ee60e0ba3ba9512079f8_Device=CPU_Config=(),0.301142 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=(),0.273069 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=df8ed5b481f6b03ca63572f2059d20911d3a7757f4c032455bef9933f2c1dc35_Device=CPU_Config=(),0.204151 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=eb966d8fd7e1301280e6ef709dd785d210a35a1346eb88c3f38379bd96036ce4_Device=CPU_Config=(),0.188153 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=90f882a97d637e527900edfb1b7c277b65544832793d08efdf8454be21a2f496_Device=CPU_Config=(),0.136236 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0ffc7d7836be264b6d9f26daa71a8c7100ae6bc6fa1af23614a2736226fbdf0f_Device=CPU_Config=(),0.133748 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=351e48db45e09ca6c4bc54a271eda4cb2ddd69ba43f361b9915a6588913768b0_Device=CPU_Config=(),0.0716183 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ab760f0d90b0fef133a0555cb2a5d40fb525aef88e6568c5387a87d7e82f67f8_Device=CPU_Config=(),0.0684052 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=afc2cb913bcb4e4badd203c9cdf491ea1e6ed4f1cd835e7507889a9bba25b958_Device=CPU_Config=(),0.053864 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0a16d9d3d8d553c2c747b2c68b12eee3dcc016e29e597992cad8f83aff0aa759_Device=CPU_Config=(),0.0497053 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0f623457008d91f7fcaead549e4a3f90a5ca77dd7c52fba19906f559c34b333b_Device=CPU_Config=(),0.0350581 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c9352ef8b6aae01025051f9c73f023e7b5a13f8987f81bfff4ce0ff9725c21b5_Device=CPU_Config=(),0.0338749 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=(),0.0227255 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=e4523b73661dc593224b91713f8f20f1c87513a62e3b8ee8265e1136eb74f9ed_Device=CPU_Config=(),0.0218253 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=4d2e12e00779d116e2192ca77f2be233d76bdd5ce366ddabcf436cc205a9f811_Device=CPU_Config=(),0.0217789 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=539610c21b2839b71cfecbb15b7b7145f9fee8bfef8ed9e1d73aaad2de661496_Device=CPU_Config=(),0.0198891 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d77f317dd01a80955f901d0da2930aa1f82531848f4bf22d839c60a84941e6c4_Device=CPU_Config=(),0.0196749 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f977fc239a0230860702f8c1971bd424f10b978bb03937668c37edee6777f12b_Device=CPU_Config=(),0.0193262 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=b08690e29e0249d5a6a30f2ad886ec714067df994bc4d8cbd82d0d02af6335bf_Device=CPU_Config=(),0.0190276 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=d51bc4204bb6079e79da8d0cf95ab8a3454c90a040aee0fc6fedb00f0795c577_Device=CPU_Config=(),0.0180446 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=bca72a16df5bcf81d10dfbbb0e53aceb2a8a70ec94d4247d47333679de7214c5_Device=CPU_Config=(),0.0161398 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=776b4b6d6b102654bbc08df901869e4d16af505a5dff7f2d27686874bd20ccc1_Device=CPU_Config=(),0.0141907 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=969c6a651dc204576d68d7d893ad2dbff1f7c74803b1763857d41aabdd19a72a_Device=CPU_Config=(),0.0133005 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f208ab78a0ef0497856952f499578a17818269d066f4281183ef92ac2f9ce449_Device=CPU_Config=(),0.0119654 -conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=ae538f87e4d49bbdc53184fcaa6082eee131a79b480dab9b46e12976d01ea913_Device=CPU_Config=(),0.0113958 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ae538f87e4d49bbdc53184fcaa6082eee131a79b480dab9b46e12976d01ea913_Device=CPU_Config=(),0.0113958 -conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=ae538f87e4d49bbdc53184fcaa6082eee131a79b480dab9b46e12976d01ea913_Device=CPU_Config=(),0.0113958 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=69c68c20edefc8789e62a7cc8a0f8fe7e649f884649ac30833fb5a2ce43c4098_Device=CPU_Config=(),0.0112611 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=59eaeea8102953f8ffe85ed1ced2a44ddeed77ec237608b45be0573bb32b1104_Device=CPU_Config=(),0.0106392 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=cc2f28d736d3c67fdd13fbea9b8cef7c0b075f06b37034581fc732966421802f_Device=CPU_Config=(),0.0103985 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=017d4b1dac18731e05634414942698ecbc750e306eb86e773ffe5007bfa9feee_Device=CPU_Config=(),0.0100867 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=(),0.00993054 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=caf20ebc8d39cb23a107a03e819e8ee5b2807fbd311fe65453446251e4b6a611_Device=CPU_Config=(),0.00991679 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3c03ae2ab13dfccc85d9909840eafb6a291b978e9bf859f27886b4a0d3e87ffa_Device=CPU_Config=(),0.00984804 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=05690f7225eecae70805d45641cd02c02c46bc61f9fa4cf91d3ec7ce94f6fd3f_Device=CPU_Config=(),0.00900461 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b2ca18b9d9f9e7c05f66a1f197b65ef9ca1d59319ed5f30d4eadf6f8befcd9bf_Device=CPU_Config=(),0.00861005 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=12e571ef61251520c35bd8c0429b1ee71277033ae88101f08dd769a300d86c5c_Device=CPU_Config=(),0.00820869 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=f9f031e1fb61fcf87468eb1f4b2005e7cecc5f073eca95c161fe62fbbfc983f4_Device=CPU_Config=(),0.00807685 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=af1f864a9f4bc94bdb713b0fed3f4c39dbd290cf7464f3cee8f1aded11981d4d_Device=CPU_Config=(),0.00585062 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a917525b3e5a37fc2be5f35fd5a3d50b57627cd9b985333e082b169c29f848f3_Device=CPU_Config=(),0.0058006 -conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=dynamic_IR=2d924ba2d56e6b5c7423c6d622e7bd250ab275e0a0ab4745e232046a3223ce7d_Device=CPU_Config=(),0.00568133 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=910dee337e395f94d7673f664a3e58647ead8bcedf50ea1439250bdfe8da25dc_Device=CPU_Config=(),0.00556665 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2b59c9f67435c46699dc1c66ee7ddbdd333bfa544d0aef7bd1389db2635868c7_Device=CPU_Config=(),0.00499282 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=37337436d0d481c689caabec3bbc8f21ecec65560c70de4dd1f5b0ed9e444bf9_Device=CPU_Config=(),0.004941 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=(),0.00482108 -conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a3e1aaa7054d4d046bab4614737c931b25a574051a2f8b79799aaf6fbbd2c2e3_Device=CPU_Config=(),0.00426381 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a3e1aaa7054d4d046bab4614737c931b25a574051a2f8b79799aaf6fbbd2c2e3_Device=CPU_Config=(),0.00426381 -conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a3e1aaa7054d4d046bab4614737c931b25a574051a2f8b79799aaf6fbbd2c2e3_Device=CPU_Config=(),0.00426381 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ca3d0cbccca665493e85a757798ab5e12399ad295466cea744c7a2d278c86c97_Device=CPU_Config=(),0.00424488 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=(),0.00401399 -conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=1a29918856ba0f88e99346fda6e6c21ff2bf129f5599d8a1c8611346ab41f2f7_Device=CPU_Config=(),0.00373719 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1a29918856ba0f88e99346fda6e6c21ff2bf129f5599d8a1c8611346ab41f2f7_Device=CPU_Config=(),0.00373719 -conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=1a29918856ba0f88e99346fda6e6c21ff2bf129f5599d8a1c8611346ab41f2f7_Device=CPU_Config=(),0.00373719 -conformance_Range/ReadIRTest.Inference/Op=Range.4_Type=i64_Shape=static_IR=9402d607ff481567bf322dcea9aa597387a195b9d3756ff46de81c3ac2737a49_Device=CPU_Config=(),0.00251179 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6adce7c66c1630295ec8938bcb429f20b628b0ceed938bf81ac0fca8580f8d34_Device=CPU_Config=(),0.0023531 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c90ac17f02f16c647a0a206326f24ac348a0f8a7787037486e52ecc8c091818e_Device=CPU_Config=(),0.00203846 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8f622d39d560109549e99d37f3c9cb476f4d69e8525e7a0ad8fce6fe79a6f982_Device=CPU_Config=(),0.00199296 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=(),0.00186797 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=87baad85c649084e386ca502375581e9dc47c68c076bacae5e5ac1ddbaaa7830_Device=CPU_Config=(),0.00173828 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d27e8ca8280dc9219f4b76a2c8f47cf526b32a58710126c7549e2c04026944de_Device=CPU_Config=(),0.00170877 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=34784838e98e93a6b024109ef3a8a5d4e1fc7f89b98ca23c81cf085f19acc663_Device=CPU_Config=(),0.00150234 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=e2da6d928938b6445170cd69fd4a7aab40130a560cef3ffa2d268a428f56fcec_Device=CPU_Config=(),0.0013649 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=81954ff76e3fd04ec3b3e3c26e28a79ac259c9b255f90ebe3cc0772fb673874e_Device=CPU_Config=(),0.00133616 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f729a1e882f1894319a357f6c5474552e883ae9322cc3dc399b3a292b13e6de4_Device=CPU_Config=(),0.00121233 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=(),0.00120442 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=aecc8a062c16343ac138f351d774858b523e42d5a09ab67b1b61e64fe62e73ff_Device=CPU_Config=(),0.00111048 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=6095afd484c177267854bcab902c3057a2a1bbf37b2188d3a31fd2cec48de2fe_Device=CPU_Config=(),0.0010979 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=53828d433bfa231cac709949db0e4ff72010e5cf9df167ecda7ac72bd5a69e10_Device=CPU_Config=(),0.00100779 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=(),0.000946854 -conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=3c200607c5e2b90b5d75a439011d83643ba042c276c3033f58b3409c068faf8a_Device=CPU_Config=(),0.000944591 -conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=478861c92198ee8679e3e43476abfe79906c4ead6ee80af975af365829822025_Device=CPU_Config=(),0.000907351 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=478861c92198ee8679e3e43476abfe79906c4ead6ee80af975af365829822025_Device=CPU_Config=(),0.000907351 -conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=478861c92198ee8679e3e43476abfe79906c4ead6ee80af975af365829822025_Device=CPU_Config=(),0.000907351 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=(),0.000833132 -conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.4_Type=f32_Shape=dynamic_IR=5c05bbc013fc857a8f2b340df778f3ad5bdbc1b7273cf41b23d6da410205c612_Device=CPU_Config=(),0.000823042 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=35525421f74fa15c49098ff1c7faed4fe65763d72ed13add33c6fe8d4dcfb0ed_Device=CPU_Config=(),0.000813329 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=77dbcc61a98e0bf3c1bdcbec543818a8a959751f10b8ec1489b66570ff4e634e_Device=CPU_Config=(),0.000694344 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=f0ae8e6b136d1db7e5e7748c03eeaed6907460d3d3941fcb1a6651cff61be113_Device=CPU_Config=(),0.000689831 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b6503944921be5fa3feb0b7647c6715465af16702c645dec4e2f2556d8d679c_Device=CPU_Config=(),0.00068405 -conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=(),0.000669094 -conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=(),0.000669094 -conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=(),0.000669094 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=42afa027ada245d36900a89c54a870ba5fc7fe3cc3bc0fc7dbda23af3e5111d8_Device=CPU_Config=(),0.000662206 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0d74ee98934e32799620ac90fd3ae8335bca026b9225782458949c64139d89c3_Device=CPU_Config=(),0.00064385 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ede6f5f8a1d9bcfd1979965f575c8f267870e0d6a5d3a62d229ea029893525b6_Device=CPU_Config=(),0.000641885 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=0e58762b5cd9926391cba6f63db3c7db49285b900ad0abc93b4d05d4baec800c_Device=CPU_Config=(),0.000588452 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8978b8e985b54cc12e2cefa8d9097f4a3a03d477129230b6c7e3daf8112e2c0e_Device=CPU_Config=(),0.000557934 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=ade98724a678a73bf789fc539dfa277031242ea3a694227dae29c11b45cdfb9e_Device=CPU_Config=(),0.00054894 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a9c40d7a1ada834400ffbdff779b9970c83bd576891dfa7f637182cadf9e9681_Device=CPU_Config=(),0.000540683 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c6b8f476c9b5cf1a102cb33d5e68033bb074a520d01e360ff46b3e479addf407_Device=CPU_Config=(),0.00053922 -conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=35ab7a27cb56964d974f5e1b55c1ed76d7f9443f97da0b977370ca9fc414e093_Device=CPU_Config=(),0.000537253 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=08fa156c3f25fc8836356fd1a8edb73222f9fe2b3476c0ae32a26636b5870247_Device=CPU_Config=(),0.000492921 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=(),0.000487154 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fd97b6aab7b86b0dd2f8c0ce622601e80f3b864d23d7d4f61d2dfa42195936b1_Device=CPU_Config=(),0.00043813 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7895fea00309326a052d47dbd2f9e562b86bb9d0501f2a2fd8843a0340359b67_Device=CPU_Config=(),0.000427698 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=138e0258106faf2065b52655adfb8b45d49b677f9cd04850bc5ac9335a9d16d7_Device=CPU_Config=(),0.000426517 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=14c8a8bb712c40d63edf76de9a75dd1dcd53a2df8c6098c80ee760119966f364_Device=CPU_Config=(),0.000402047 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ba28829f211d64d6d4922682b85f1bad6a3c28cc30b4f9651186b1e8fab39fec_Device=CPU_Config=(),0.000383712 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c0cbd07b1517991754ef075284aedef586dd4b250e2b867379dacebdf99ce1e1_Device=CPU_Config=(),0.00036287 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9730f247ba4a13fb03274850f295de500156107d33db957188846fe49c2f4566_Device=CPU_Config=(),0.000357687 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=97f8a2367c5590d5fe7e405d32ec48e5318a6cb3c0862f2b0e8705a7842e8105_Device=CPU_Config=(),0.000319329 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=1a9779319a9cc5f21b6005ebb9b4517e0bb1f868ef8e568453a58c44474c40bf_Device=CPU_Config=(),0.000285942 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9e0cfe97e08c7b2974ef224799ccaa3fa777802a5fd320a089e527f00a594dbc_Device=CPU_Config=(),0.000268331 -conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=(),0.000255276 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7340b50308272b86e1b98e6962ee280e9575fc0d7042b9cc076c530268e2ca74_Device=CPU_Config=(),0.000237433 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=dc350b3fec164adcb096b8fc922e342cf7b0c6f7a4aa25074bec5566225cff01_Device=CPU_Config=(),0.000215236 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=(),0.000207265 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=(),0.000207265 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=(),0.000207265 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=(),0.000207265 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=(),0.000207265 -conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=13f3d097d5e17c2add48d6f9b6f86454a1b521408d7fb8252e3638d9f17ea6fb_Device=CPU_Config=(),0.000189037 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=13f3d097d5e17c2add48d6f9b6f86454a1b521408d7fb8252e3638d9f17ea6fb_Device=CPU_Config=(),0.000189037 -conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=13f3d097d5e17c2add48d6f9b6f86454a1b521408d7fb8252e3638d9f17ea6fb_Device=CPU_Config=(),0.000189037 -conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=1e56a3e2379d29d81af93174e56ef91408af41dfc085d4851ff58dbec781b8fa_Device=CPU_Config=(),0.000164938 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=(),0.000150034 -conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=(),0.000138293 -conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=(),0.000138293 -conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=(),0.000138293 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a4ab938f33d0b58425ed98a56789d0ee94beeca13ec7fe3358c9d3751ef136a5_Device=CPU_Config=(),0.000129335 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3e1e1cd684c1bcfcf06febedcb4eb0f4f62b5c0920098fa0715c828e9a9761a7_Device=CPU_Config=(),0.000104221 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=6289210c93bab9199850c9aef5ac3144ad0a900007dbca3e889a9f875318e9b5_Device=CPU_Config=(),9.94375e-05 -conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=(),9.36129e-05 -conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=(),8.71821e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2435ff5e2ac06afcf99563821fa2a2a5e4a9456cb3f74154b3eb364a6f0e450a_Device=CPU_Config=(),8.34273e-05 -conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=789949951bc3afd20fdff943ca2a706f79eb4f95be60086ddf632b43c3e401e6_Device=CPU_Config=(),8.2448e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=57c57d85bad2b76d3d65d88baf2b3677dca6e5d534121e87efd618efbe5b1547_Device=CPU_Config=(),8.05701e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=dynamic_IR=deec30214c79ceb43a503bf521937a2bd554588775195d0e6302c521cd2b55ab_Device=CPU_Config=(),8.00406e-05 -conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=(),7.97528e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f99a212a117855e6e2dc4a338444a8ecee441f989638f7a0700ce24e037d29e3_Device=CPU_Config=(),7.90737e-05 -conformance_Convert/ReadIRTest.Inference/Op=Convert.1_Type=boolean_Shape=static_IR=d296b02cead8f38f8a2c9fa73ab8103d3050549c92fb807b040dd6e3bbd7e2ff_Device=CPU_Config=(),7.86775e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=bbe05f014b2e4602f4e44d9c07795321404d2459bf782d2dd406de14bd2bd523_Device=CPU_Config=(),7.59607e-05 -conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=(),7.31894e-05 -conformance_ROIAlign/ReadIRTest.Inference/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=(),7.31894e-05 -conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=(),7.31894e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=dd575df40c907e85f7561296f2b1b5bb9786bf44bc27f26e33f235ba57391e26_Device=CPU_Config=(),6.61996e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=(),5.24098e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=(),5.24098e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=(),5.24098e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=(),5.24098e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=(),5.24098e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=(),5.24098e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=(),5.19909e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=(),5.19909e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=(),5.19909e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=(),5.19909e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=(),5.19909e-05 -conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=dynamic_IR=6c91ebbae26ffbeec9778f2db476ad7ecb6eca6710cba24a86d3a2a262f68e43_Device=CPU_Config=(),4.72987e-05 -conformance_Gather/ReadIRTest.Inference/Op=Gather.8_Type=f32_Shape=dynamic_IR=1c727cc96123227a9fe6c3079a497fd64a04f273bff45b5ea56a3c0d577eca8e_Device=CPU_Config=(),4.72987e-05 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=(),4.4408e-05 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=(),4.4408e-05 -conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=dd9fee8f7cd289b97050e22cb465637c6439230d0d3ebcb20452eb544b40617e_Device=CPU_Config=(),4.12031e-05 -conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=(),4.10145e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=7dcfe3f43645f6b9f3290b524024a1a3d48efa3ce346eacc2330be7e27a046fd_Device=CPU_Config=(),3.9377e-05 -conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=68dc9d01cbbb3546ce77dbc77d705f33a6a48cb6dca9a323f5bcf02b9d589993_Device=CPU_Config=(),3.63643e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=8c43b49d99c64bec883205ca15c7b2d9dbb47b9fe5140fedaeb8eb7220a36f6c_Device=CPU_Config=(),3.38007e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2d886a31e22f61d30c33ddd300ba7d8ba1cd9796ee1a4f688db9126b1d8d9c83_Device=CPU_Config=(),3.09972e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=(),3.01889e-05 -conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=(),2.94866e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=98274ec3fc894754adaacedf83b4b7da373e639a51cfa7dc348412898e45e8dc_Device=CPU_Config=(),2.93959e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=94b08f3c309048124724d9de0d120698fed90ff0237b07c4a4a2b7ccf843d76a_Device=CPU_Config=(),2.93959e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=939b665ae35f9a384e3119dc3bdc1904b105de495d262648282c859b0cb4c9e3_Device=CPU_Config=(),2.93959e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=67a5010efb429e6dedf35481443b40a77cb01c1b4fb51ec5890fcfcb010fd6f7_Device=CPU_Config=(),2.93959e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=36f17a498b10c140f8a319d82e5c8f2cc3cdb7eb3be9f82f7ef35d9c9470231d_Device=CPU_Config=(),2.93959e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=2463ef4b8684fd6b391fca0b123328e1d695b47017fe94ffe5a419a3c22ce93e_Device=CPU_Config=(),2.93959e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=28e31d83986a1435f11ba6355b98472025fcf2c3c6e090103283d9486356b5de_Device=CPU_Config=(),2.86055e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=09d4b4ea324f91ba6006bad4c82ca08e723c83c1b862d8075475e986696220da_Device=CPU_Config=(),2.83829e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=df97761393479b4c56cc923a2b89888b7c3fb949f5c3a93f4bba0ac8a44178aa_Device=CPU_Config=(),2.66896e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=dynamic_IR=47423c3e9443249e3dbbf58ee0f5b69b15e677f84de44ddb9d2851d1341dae96_Device=CPU_Config=(),2.4413e-05 -conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=dynamic_IR=cd6084826e0efefc7f1c9c3c7c9f8c1cb35b9a5f61d1a2c8131ecec5babf1af4_Device=CPU_Config=(),2.43685e-05 -conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=(),2.35027e-05 -conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=f097978a7f18dafc7577a9dcf2306d82d397faf1bedb106ca3de70b3d9ada557_Device=CPU_Config=(),1.99836e-05 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=445a2c47e85b116d03e5f6fe43863a39778b78ca5175fba1bb0eec669f7610cf_Device=CPU_Config=(),1.7481e-05 -conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=fc530f5b6bbe8f06808eeaba33889867e705fa69591d01da4dd3dee9515f323f_Device=CPU_Config=(),1.16885e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=f0edc45979b98d4401eea2c345bbcb794721dd3cdbfb3963be5a2842b27ccc5b_Device=CPU_Config=(),1.12696e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=e48a363cfdabe0b62509e21641bb1cc88edaaa7d2eb82bf3ce747cab8355ff3b_Device=CPU_Config=(),1.12696e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=cedd3bc0f0a8e20fe947135bd6ab9515283275867e1b837d36f2fac72363f449_Device=CPU_Config=(),1.12696e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=b0e3e542180f521cfd4651ae18d3a58962751d3c6de9265240be6d4fe9745bf0_Device=CPU_Config=(),1.12696e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=7cfae687d408da17a0405d88f47e2b6623a608861114dc76018b8a2142453139_Device=CPU_Config=(),1.12696e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=451a3b635d3882a87cc0d7b3f6f74197c08b708669751bb11fef93da9604e276_Device=CPU_Config=(),1.12696e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=f110ef35c9642ecd941cd85a67a12b616353d4a8cd33f9770d532759e2846255_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=e3a5a7f1a73793457fae9520ae122c6bbbfa92f1daac0ef214e47a2ec7ea18e2_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=d36c5ab59d2ab873aa35b35a952e061568edd4ee8e64c1ab200bea63472a97b3_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=cdf79cced0ed380052910c95b09b4022841474c87d06061f29791ea2ad9813a4_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=b06553539d6e27195623fcbce51610b5671dd70700bcf61703a1f7a8bbc7c5d8_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=8216637727ccef527454bfdea7ab22ccd4e5e29709494bf96dde5af3b4a7eaaf_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=80cdfe1797800671134d77fa9c7032cdc1b19b4905fcefb11399610216f6e623_Device=CPU_Config=(),1.06272e-05 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=e4baf41ae9a77441993eb0f95c3d7335e9a719e5eac8b1ffaf60d8f515f769a1_Device=CPU_Config=(),9.45415e-06 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=d8546655166c322e3049ed3a71725c8e89901212007c44c8029ef8379de96db6_Device=CPU_Config=(),9.45415e-06 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=b6669eb568f36e5d649ae67afdecaa481064561d7a71f1aab592968aca7d8bb0_Device=CPU_Config=(),9.45415e-06 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=91b6cdd8a7664759217ce0b84a8baed2105bca0ae9876e9efd01c074aa27039c_Device=CPU_Config=(),9.45415e-06 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=8de81b7de05bdd151427e1b5b03a8b4222284dafd31f9d4b1c3d0917995e9310_Device=CPU_Config=(),9.45415e-06 -conformance_PriorBox/ReadIRTest.Inference/Op=PriorBox.1_Type=f32_Shape=static_IR=3141ed71fe3efbd7fb026a006824ec24e4673d8b97d23dce275548e92eedad91_Device=CPU_Config=(),9.45415e-06 -conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=(),9.17486e-06 -conformance_GatherND/ReadIRTest.Inference/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=(),9.17486e-06 -conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=(),7.73649e-06 -conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9efd5749a1591709057d6e97334c9b5b89f5864d705c91774e0196d42966d1b9_Device=CPU_Config=(),6.64554e-06 -conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=(),6.07468e-06 -conformance_ScatterElementsUpdate/ReadIRTest.Inference/Op=ScatterElementsUpdate.12_Type=f32_Shape=static_IR=3df69301c7a4d857a546a30a0d76674c52e3abd819d644ec036636eb7cb92fc1_Device=CPU_Config=(),5.49514e-06 -conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=(),2.89071e-06 -conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=(),2.89071e-06 -conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=(),2.89071e-06 -conformance_Concat/ReadIRTest.Inference/Op=Concat.1_Type=f32_Shape=dynamic_IR=7581193e4db43b0e50c6a1a52f8b348d88587040bf38d1b780ac660781e3d3a4_Device=CPU_Config=(),7.05081e-05 -conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=(),2.76503e-05 -conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=(),2.76503e-05 -conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=b7a53df966d640f075cea7421ca5989ca91ca638e7af16aff33bc275eb7dfe9c_Device=CPU_Config=(),0.000352708 -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 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=183e5203c7008618a9cfb2680265bb3f588f80c2493bf7fac92eb258e66da2cf_Device=CPU_Config=(),1.88776e-06 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=(),1.88776e-06 -conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9b4725171957a420a98f908742f18062fbcee198871d527ab5b4d939005ac4e6_Device=CPU_Config=(),0.00116845 \ No newline at end of file +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=77e1c522d9ea4975c3071869b7b485038bb4035c9aae6f5d44291f60ae253a0e_Device=CPU_Config=(),0.0937431 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=1be99c00176df777bd8cdbd9f74ff064237f55053dc7490050d692274182182d_Device=CPU_Config=(),0.0705686 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=3f836daba711312827fc9f3ee1d7d376e22ad7af24fd156ceaccd5c75678b9bd_Device=CPU_Config=(),0.0217624 +conformance_Mish/ReadIRTest.Inference/Op=Mish.4_Type=f32_Shape=static_IR=64374638dfe8bed8e9432c51d92d23b807172fc490c0dfc76428f2c49be92400_Device=CPU_Config=(),0.012943 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c18f4f45c8ca59e5fcf1d2aa0b6115c7fb6789c4d4a583cf93901e65f4ac692c_Device=CPU_Config=(),0.00987977 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=1c4aa866633b1381ff8ee36910d91aa4750c9a8dbd05ae159b7e15a65a08bad3_Device=CPU_Config=(),0.0072303 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=5bdc625498840e88bafb7d6f58ae8f9f0081a9bd0a6cd71c72a35871ca5b1f12_Device=CPU_Config=(),0.00715895 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c533b2b13f88a1c6296bcb6831a96fdd4d354c69848e02bf3e9a1e632264524c_Device=CPU_Config=(),0.00647702 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=621c7638006b03b7c4ca5de04ae4823584c9c348cc40eca0076b898b72247e48_Device=CPU_Config=(),0.00618223 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=621c7638006b03b7c4ca5de04ae4823584c9c348cc40eca0076b898b72247e48_Device=CPU_Config=(),0.00618223 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=621c7638006b03b7c4ca5de04ae4823584c9c348cc40eca0076b898b72247e48_Device=CPU_Config=(),0.00618223 +conformance_SoftPlus/ReadIRTest.Inference/Op=SoftPlus.4_Type=f32_Shape=static_IR=443141d6914003828f76ac1de39cff68ee8ae96b2524fc41e9f5f95707b834b0_Device=CPU_Config=(),0.00485008 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c2db5dd4ed881038f0521cfb566b3773cda95681a2ef8339950d0515616c015d_Device=CPU_Config=(),0.00461692 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a93352138c144fd004303788d08066d279e5363345d3da2cf16ceb61336d58b9_Device=CPU_Config=(),0.00250517 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d8a0ff565e3467b3d0e2d6f1dd856b2ab812d675a09645b4a3b3bc8f29957453_Device=CPU_Config=(),0.00229633 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=486cda3fac543c53e385e5b26f0932be2c2c67d937dce02e9376ba2956321e5f_Device=CPU_Config=(),0.00218939 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=74310de2f35ad8a1bf7388138114655c2c74f1e85fb8cde4584f3d7905345140_Device=CPU_Config=(),0.0017982 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=94c0bd6d26bbfc0a8f22050757d17bc051a7af85dc6d6447d51413f2bf779a95_Device=CPU_Config=(),0.00113046 +conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=(),0.000986491 +conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=(),0.000986491 +conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=cf9b80bd696164fc7c8f077eb532fffc455eaf648589c54943cd1b5668e2f077_Device=CPU_Config=(),0.000986491 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5d7273e7772d3578b3c8dcefcce25913c8e843b7a1045722f80f9feed4770ba1_Device=CPU_Config=(),0.000744799 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3d6f722f81b8a23f0dcb2acaea3686f0aebde1d810953e532cad9930a034d050_Device=CPU_Config=(),0.000705396 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9c15338e53353041d5e82067a4aaf56dde40144709b2bd04d86bbc7ad22b525b_Device=CPU_Config=(),0.000686402 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=8b9ae72303fcba7808c28f788e0187827b2f548efcd6d023e6ad28047121216e_Device=CPU_Config=(),0.000661792 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=682ef97686247c6443214e731915927e131f40c22f1cae7f25a038b70eff95ba_Device=CPU_Config=(),0.000658586 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ce0514ded018b3bde00091b50a98b715da2a3e3c254406b9fb290b930d6f5680_Device=CPU_Config=(),0.000578015 +conformance_Pad/ReadIRTest.Inference/Op=Pad.12_Type=f32_Shape=static_IR=05e89f7690a9c7d235c753aa4af28229a44fab527f44ff4832ebcebf0c9debfe_Device=CPU_Config=(),0.000573521 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=a83bda80fe7800f61bcbba992511f20b4adb5da4097179f2188797871abb73ca_Device=CPU_Config=(),0.000550819 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a83bda80fe7800f61bcbba992511f20b4adb5da4097179f2188797871abb73ca_Device=CPU_Config=(),0.000550819 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=a83bda80fe7800f61bcbba992511f20b4adb5da4097179f2188797871abb73ca_Device=CPU_Config=(),0.000550819 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=60e017f098b38fe7f824eb78635cd13cfa1ff460387abfcd6420c8a7d559a915_Device=CPU_Config=(),0.000539603 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a5d03dc78d3b89cf1aaee33c609a3d52626d3b98827b980422b01eefc32cde03_Device=CPU_Config=(),0.000520597 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c531648f3b5841ad892debb2fa2eab6ef35a08d0cd5e9d33bc0a7b442a1fc707_Device=CPU_Config=(),0.000490251 +conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=3e0fb4df6ea780921a8ef21a06bd602e97f91baa201096d438de60e9114acfb1_Device=CPU_Config=(),0.000434555 +conformance_GroupNormalization/ReadIRTest.Inference/Op=GroupNormalization.12_Type=f32_Shape=static_IR=139730a541ba475f22b71d8bbe850f280751594db3560e15590939b2f017fc02_Device=CPU_Config=(),0.000324682 +conformance_Pad/ReadIRTest.Inference/Op=Pad.1_Type=f32_Shape=static_IR=fbb53c04f3cfadff9d6543e2fb4eb88d882c3189b4212e77a6ca6e50bdba6e07_Device=CPU_Config=(),0.000316864 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=47c28b32453e7972e5f4a7213522370ec927424c913b5c6d0ec08a00d7a988c9_Device=CPU_Config=(),0.000282596 +conformance_HardSigmoid/ReadIRTest.QueryModel/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=(),0.000257824 +conformance_HardSigmoid/ReadIRTest.Inference/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=(),0.000257824 +conformance_HardSigmoid/ReadIRTest.ImportExport/Op=HardSigmoid.1_Type=f32_Shape=static_IR=08a7845e89900ed725c984b42b6bc262a7f7956ec50e0a7bbdfe8e4a34d584e2_Device=CPU_Config=(),0.000257824 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ae0e669fbddc34e8aaaefff248959e3fe53196e68bc1b3a9e66be16a495d7cd2_Device=CPU_Config=(),0.000233221 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=680b155374ac22f8d01e47a3b26f133a20842702d07dbb2d0fe2d1c03333afcf_Device=CPU_Config=(),0.000194099 +conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=static_IR=0f670e49f962b0a7abc6b4f1fbf9592db592a6a78eb3e083dd4027b9f9607430_Device=CPU_Config=(),0.00018661 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=fa169b001a47d2c4cfe07d837ca82977192701fb3f1f557e0c792675f00f8158_Device=CPU_Config=(),0.000148837 +conformance_GroupConvolution/ReadIRTest.Inference/Op=GroupConvolution.1_Type=f32_Shape=static_IR=53192c27f09bf3c756e64820ae6b0a01c5e48535df5d5b91ef6dbd6d954eb6dc_Device=CPU_Config=(),0.000128037 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=105ef2497841f48e00c64d60affe13b54275083bbf0fd91837d21a4c7c85a1a5_Device=CPU_Config=(),0.000127867 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c03bca3c44df7946fcf273e9d79309b7bf33b465206eb9caf76750735e1ad19b_Device=CPU_Config=(),0.000125272 +conformance_TopK/ReadIRTest.Inference/Op=TopK.11_Type=f32_Shape=static_IR=9c57b92a55a929edae54a9705d80d730f7682ef015aa6923bd4658e244e9ca89_Device=CPU_Config=(),0.000122981 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=66ab5cfd788be1a5ebe89e70a1318d6b905d3600d0ac5a967d07a0ad6828e7df_Device=CPU_Config=(),0.000119836 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b5d0b3117c15997ddf3779525e849ba35c0096ad654c8e27fd1e87e29cbd61dd_Device=CPU_Config=(),0.000119836 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=eb014b2651dad2cccd6291bceaca16047a4a7fce1595430520ad8d8601ff29c9_Device=CPU_Config=(),0.000103198 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e7a4e6690e4897a569e29f61636fb4a99f645229fbfd2a68ecbf83b21058dcdf_Device=CPU_Config=(),7.41965e-05 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=94365490bb772d689007e25754e20090137a936cbe1a6a3739b573c644f3f318_Device=CPU_Config=(),7.25834e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=94365490bb772d689007e25754e20090137a936cbe1a6a3739b573c644f3f318_Device=CPU_Config=(),7.25834e-05 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=94365490bb772d689007e25754e20090137a936cbe1a6a3739b573c644f3f318_Device=CPU_Config=(),7.25834e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d0c2f7eea6a0d6d6d9d97881c8db3649f9e9b713633c9d5698459eb1d2e28345_Device=CPU_Config=(),6.32253e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=08a654f35ce851709d2c0634533645f6910b394b9cbb4bc6ddf20860f3a09c48_Device=CPU_Config=(),5.34865e-05 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=597a8a56fae623dd0684f6e4040ffd6ce90166e43e47adbcbcedf1dc5136ec23_Device=CPU_Config=(),5.00985e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=597a8a56fae623dd0684f6e4040ffd6ce90166e43e47adbcbcedf1dc5136ec23_Device=CPU_Config=(),5.00985e-05 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=597a8a56fae623dd0684f6e4040ffd6ce90166e43e47adbcbcedf1dc5136ec23_Device=CPU_Config=(),5.00985e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=14f15558b2c7699f7877a9e04e1e0e7d2a2d7e1307aaca519a98ea5f39afc415_Device=CPU_Config=(),3.80351e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=2076165a2a28f14ff923bf8c44250bc59536d2ffb67b4a4785f480df49c1a243_Device=CPU_Config=(),3.5607e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f5dbf9b79d3887c9207d8971e45282f563af47565ed7a941cf972014e8b5bf05_Device=CPU_Config=(),3.53456e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=c7aee90a4d266602709c28c5c6fb4e0ecb791e5399fa3077364e660f657752c0_Device=CPU_Config=(),2.95638e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=52f24d64817b922e55c19c85c0d727ec6fdb9cb104f55697330334d1517f0621_Device=CPU_Config=(),2.70435e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=eeb4d5ffc7eb6cdd80079e6b814a1c228e389e4fa01ca368f092b606666bf7c0_Device=CPU_Config=(),2.57564e-05 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5b654dfb551ec2d83e22a133055d78f13153fc1554728e34aa7f27a3f3c08541_Device=CPU_Config=(),2.34915e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b654dfb551ec2d83e22a133055d78f13153fc1554728e34aa7f27a3f3c08541_Device=CPU_Config=(),2.34915e-05 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5b654dfb551ec2d83e22a133055d78f13153fc1554728e34aa7f27a3f3c08541_Device=CPU_Config=(),2.34915e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=03c30e9e1651c6554fe73bc933149c65271a948db07a6d5062b5e8d55ef0437b_Device=CPU_Config=(),2.30945e-05 +conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=c18bd3eea12bff29ac733ae5578d28d88d5ed87aef7908aed08a09512e3b77ff_Device=CPU_Config=(),1.95245e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ffe64e2ecd6d3ed3128559b89dd2a26ed439c533f6ebeb969ebeac62f80dc12e_Device=CPU_Config=(),1.79493e-05 +conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=521ab9a51bae271537fd09832298deef71b46d465161e2db579cb503f1ac812b_Device=CPU_Config=(),1.65686e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=df5481436d81f1468146368ea1fae8d5b80f392bcda640243119a3e639f2b92b_Device=CPU_Config=(),1.4882e-05 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=9b32e763670e7a29b1ed95659051b94c323b70948e5706a00db44200cd27bad0_Device=CPU_Config=(),1.21431e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9b32e763670e7a29b1ed95659051b94c323b70948e5706a00db44200cd27bad0_Device=CPU_Config=(),1.21431e-05 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=9b32e763670e7a29b1ed95659051b94c323b70948e5706a00db44200cd27bad0_Device=CPU_Config=(),1.21431e-05 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=c9f0deaa217fa8ad54eb9662bb6d181f7b578008b5c8ff445db32b60ec61b185_Device=CPU_Config=(),8.35085e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c9f0deaa217fa8ad54eb9662bb6d181f7b578008b5c8ff445db32b60ec61b185_Device=CPU_Config=(),8.35085e-06 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=c9f0deaa217fa8ad54eb9662bb6d181f7b578008b5c8ff445db32b60ec61b185_Device=CPU_Config=(),8.35085e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d4c59fb1b2e6f27da249cc36d5d1a4c867d0fb17e9354f63b69f61f74780f8d0_Device=CPU_Config=(),7.23425e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=93a382b4c379f41c5a888ff51ba8ae2cb9e7812ce4c14f1a028fa383051a9feb_Device=CPU_Config=(),5.83717e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3b743fa55fcb61cd34046e3e97d71a05de0f8db98d3abcff4e14426d143771cb_Device=CPU_Config=(),5.58896e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=ca5847147325177b69e97415489292ae793cfe1346e23e8a7bad000f9a702d91_Device=CPU_Config=(),5.52773e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=aadbb3768045a0dfddff742fd6ac0940bf0968c7e0b1b22b064503d4081b0a54_Device=CPU_Config=(),5.4619e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d9771ac46751569172412bbd4495eccdbac435f78a97f8fdfffa9215faa74544_Device=CPU_Config=(),5.37104e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a5247d95c2671970ffbf4c367bbae5fe76245fd6e0db79c9c4fb9b7659dbd4f0_Device=CPU_Config=(),4.94309e-06 +conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=aea9eaad28967e914b80b64c929fdb29f640c9144d6c5599ed9099264cd2f54f_Device=CPU_Config=(),4.23937e-06 +conformance_Loop/ReadIRTest.Inference/Op=Loop.5_Type=f32_Shape=static_IR=dc12f3a61744181707e6cc6f1ed849088cca8ec067eeb2da8a138a69d403c826_Device=CPU_Config=(),3.42261e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=6a16663e3760c233a39f49948fbc5e2b41658e0e9fbb86e8a5d0cc16dfac33bb_Device=CPU_Config=(),2.70725e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8e41f166e0543ab380f90b0ea86819136cd0a5cf5e8ae0cfca988e81c93ce28c_Device=CPU_Config=(),1.69005e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d9b9fc6875f06b7dc454279fc5fa4432f514736cfd1a35d2a40cfc82f680c009_Device=CPU_Config=(),1.32992e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=61104a3a93d0b36db7f0499ae63420f216e5d7b0171b40c4629f640572f04f2d_Device=CPU_Config=(),4.00293e-07 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cbff70cde6194997d0bb4a7fe099d60116085fa72b8840e54f79ac61a5b4c1a7_Device=CPU_Config=(),1.0 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ccb19a7166645dd3a896b2f1f731dc87da95f98a8f824e46d434dc12f71e663e_Device=CPU_Config=(),0.151684 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a8705f91d4bf4fe876dfb6d2ac2eb9c89808c88942d4beb080e1e2c089d77040_Device=CPU_Config=(),0.0830185 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=469d09b261b88011c82288ea622dde06d63805eb41dc256c901b0d206ac5780b_Device=CPU_Config=(),0.0387788 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a82fe43f495f5ad83d1fba98c09af9c14bb09cb506339e5ed48c78c8a6c973f3_Device=CPU_Config=(),0.031788 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=b1bae9ab001e5c3b05f22881494508bed2f623801431b8402e6146e54d692016_Device=CPU_Config=(),0.0275763 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b1bae9ab001e5c3b05f22881494508bed2f623801431b8402e6146e54d692016_Device=CPU_Config=(),0.0275763 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=b1bae9ab001e5c3b05f22881494508bed2f623801431b8402e6146e54d692016_Device=CPU_Config=(),0.0275763 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=7509cd031f0085ad09a30a02057f1c0dff7ba78cd13f43ac124b33ef2cfd303b_Device=CPU_Config=(),0.0129123 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4cf0a180eb5154fca591a8d3239f3bde9024ef2b347a70c3b10341243e679177_Device=CPU_Config=(),0.0128973 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=d3add9f9496b58c3880dcf71a47c3efa156aa225d6d7faebfdf4c2f8e44d0be2_Device=CPU_Config=(),0.00976798 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=d3add9f9496b58c3880dcf71a47c3efa156aa225d6d7faebfdf4c2f8e44d0be2_Device=CPU_Config=(),0.00976798 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=d3add9f9496b58c3880dcf71a47c3efa156aa225d6d7faebfdf4c2f8e44d0be2_Device=CPU_Config=(),0.00976798 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c359e1ea71a80fc519e8a2dacfc7f52f5a94a1142058641b0434f40866875c12_Device=CPU_Config=(),0.00842842 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b299e012ad30cf620f5c9ba0c33c79a406d0e39f84cb9d1efdc4b4c8dd82f347_Device=CPU_Config=(),0.00793581 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7af359181d29634dc797b38c2defd26a52a70073a59a7d027ebdd752b4011d15_Device=CPU_Config=(),0.00726416 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=84d3a33f9325d947a72b4e26d046e3e3f9cf41091f7c8e1c654899b3088ce6e5_Device=CPU_Config=(),0.00489964 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=b6bb8473f99506737101987d5732d33073de8783b22d891c652653884bab7a87_Device=CPU_Config=(),0.00474278 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=49401e607e42aa23290f59c3d3d64d54eeff9afcdf99177506283d43b6a43928_Device=CPU_Config=(),0.00460022 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b227737b26850463ce87153061b94dcd71131aa06e3032b7f775a64e1c271f93_Device=CPU_Config=(),0.00446877 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=9c32e47cd885805256c3e3053412f7d8c448762b4b509507f6e4dd78e2aeb56c_Device=CPU_Config=(),0.00430736 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=06a1a9e9cd13f69334ecb05bddbdc5d186b85e138c5597d2e85222c4b735980b_Device=CPU_Config=(),0.00379565 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=e003079e1703f756924619f2a77b6c26741ef71bc404419560faec9c56bbfd2d_Device=CPU_Config=(),0.00373608 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ef7c3b91bb41e1db1727794a0435bfa5f38d194b9457d94abf9c19776174ef60_Device=CPU_Config=(),0.00251516 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=98c467c06ecdfe13b1f3b90237bd32041a11c553f544328ed9b181bbc3201f6c_Device=CPU_Config=(),0.00192313 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=d82f645d11f396433cad131e1e490842c14fdb9e439d93fb9425752b6a3aff09_Device=CPU_Config=(),0.00179994 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=f465651ea8ac7c2c141595f8d91a6061beffbe8d714e253a91dd12e00502ac47_Device=CPU_Config=(),0.00145491 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=f465651ea8ac7c2c141595f8d91a6061beffbe8d714e253a91dd12e00502ac47_Device=CPU_Config=(),0.00145491 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=f465651ea8ac7c2c141595f8d91a6061beffbe8d714e253a91dd12e00502ac47_Device=CPU_Config=(),0.00145491 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=9e2233439aaed8d4d48bfa36955feddb30531b843b5ed4a9c2acac5a8d815c69_Device=CPU_Config=(),0.00145019 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c1923c409aa2da9da8daf339b8b26be9ec6a106e65098182015c21881b0b5379_Device=CPU_Config=(),0.00124088 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=i64_Shape=dynamic_IR=c5ff38504273a230addadadf4fef517ef73154c5f9f10ef2ace961b1dc3cb794_Device=CPU_Config=(),0.00107711 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=5aaa81d6f07ed880b1e93a0fce7b6aab4c3c88bfb1b4b6cda4ead15eb145af63_Device=CPU_Config=(),0.000846105 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=67c29ca00af28406993de63d8e7782945a32705d95d4e6e4fd36fbf4e468a7f0_Device=CPU_Config=(),0.000838635 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=7bf0600f459cdcd8d44b0cee600efd18d2319dc459d59314af52cddef6181aa4_Device=CPU_Config=(),0.000801932 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=06fdd8a11a7ec3d8a9fc5d188f881cc6bbcc5b1bc669ceaf88751a03806257ae_Device=CPU_Config=(),0.000684183 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=4a8cdbce9473e7bc24866edf0f5ec0f5a95475da63cea7ef68a4fef7b9fac1c4_Device=CPU_Config=(),0.00067663 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=a8f0d5db2a6af7cd4d166c066f3d987d7a25edbb3047fd26551e1b68d9c179d2_Device=CPU_Config=(),0.000603071 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=554cea5d4f8f21234b429ebe1c4365bed5b6a6a309da5d607b45b301beb90828_Device=CPU_Config=(),0.000588354 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=554cea5d4f8f21234b429ebe1c4365bed5b6a6a309da5d607b45b301beb90828_Device=CPU_Config=(),0.000588354 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=554cea5d4f8f21234b429ebe1c4365bed5b6a6a309da5d607b45b301beb90828_Device=CPU_Config=(),0.000588354 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=repeat_pattern_Shape=static_IR=5c0ed2041d97a9387b2c2f31ea1f5ab3e98edcaeda47d184555677418853dffe_Device=CPU_Config=(),0.000479695 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5c0ed2041d97a9387b2c2f31ea1f5ab3e98edcaeda47d184555677418853dffe_Device=CPU_Config=(),0.000479695 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=repeat_pattern_Shape=static_IR=5c0ed2041d97a9387b2c2f31ea1f5ab3e98edcaeda47d184555677418853dffe_Device=CPU_Config=(),0.000479695 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=f3dcab6635e317bee634addec1b7f9664b2f801810997519ab06efaf1d869f81_Device=CPU_Config=(),0.000446241 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=af272d91ad67b0c830585f82cd83729fd832744707be8a2be800f76f3faadf6f_Device=CPU_Config=(),0.000421215 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=9efb5290056ad2f5ee663d4f67a89edbcc4936e512748bcbc0e9f3935b690b1a_Device=CPU_Config=(),0.000421215 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=570d13e19f312cf288f0f5d651f051c01f0fb65999579c3b06960c2936a18181_Device=CPU_Config=(),0.000421215 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=445aa399303e82b524cce3e0b3522cfdb57200720b3b72584c785fad157117b1_Device=CPU_Config=(),0.000421215 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=100761a180c245ecb5f949d8a3ea0d4e26d7bb15d679ab797362f695bff03be9_Device=CPU_Config=(),0.000421215 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0fdf62ef06a0a9225c0746379b89495e737a2e5f95077bb92600ce14f19fed40_Device=CPU_Config=(),0.000391665 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3d918677d26d54494f0b1fe41a32370a3d82612fe8e5d5c17a04b48f63d353f0_Device=CPU_Config=(),0.000239009 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=bee0968c080b9f9f930b23a2c79d957f1c160c34d994e617ea29a641b0e269c7_Device=CPU_Config=(),0.00020969 +conformance_ROIAlign/ReadIRTest.Inference/Op=ROIAlign.9_Type=f32_Shape=dynamic_IR=7260d5fcecb95f9632da5784702239161bdcab6bee60e0c1296a46e5120d5ca0_Device=CPU_Config=(),0.00018451 +conformance_subgraph/ReadIRTest.QueryModel/Extractor=fused_names_Shape=static_IR=a74540730c27b2cb9437e4ba730bfb555be123f25f1709f2863d50cdaaa21c7f_Device=CPU_Config=(),0.000173823 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=a74540730c27b2cb9437e4ba730bfb555be123f25f1709f2863d50cdaaa21c7f_Device=CPU_Config=(),0.000173823 +conformance_subgraph/ReadIRTest.ImportExport/Extractor=fused_names_Shape=static_IR=a74540730c27b2cb9437e4ba730bfb555be123f25f1709f2863d50cdaaa21c7f_Device=CPU_Config=(),0.000173823 +conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=a1b6d340122e8e3a7a665c69fb11b3c7b460eae79ec81ed3c32e878d10d5c3eb_Device=CPU_Config=(),0.000173814 +conformance_Interpolate/ReadIRTest.Inference/Op=Interpolate.11_Type=f32_Shape=dynamic_IR=360205b273a323d2cea16c9ac98847c904ed6cabb2412d3b49c27fd2eec52ab1_Device=CPU_Config=(),0.000164285 +conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=i64_Shape=dynamic_IR=2058e018d32d8a73b2bf6471186e555c47e2c1a15ceb4131bacc43110bc17d30_Device=CPU_Config=(),0.000122981 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=ea63b1a277de19e725624c4d57d7decf2a01f9764510b0849e0b9dc49ad24fbe_Device=CPU_Config=(),0.000109446 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=aed658319c31cdb1d3a47a2a93c7a4f524d9af8540e2019af10e8e1cebc3c2bc_Device=CPU_Config=(),0.000109446 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=a05339454f3f2a599ee9b041f1f01a124bad7d7e5fc1e6d133e00e43d002a086_Device=CPU_Config=(),0.000109446 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=8457db0b4ea6829aad99afe4c31b7004b57daef4cd0ae02ca00090cbe5feb72d_Device=CPU_Config=(),0.000109446 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=6b0185f2e61c010924a76c5f136ed90d0e154f507028c500ee78bdc5a7ed65ac_Device=CPU_Config=(),0.000109446 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=30897cde05f349bface3d90a8d730da4c4c3e5133c59495d59258224dcc29ae6_Device=CPU_Config=(),0.000109446 +conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=1ab723c2a389a999b3b01158b82719358d802c6d62767d6dcd91b5d7fe5531fe_Device=CPU_Config=(),9.77584e-05 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=d84c7cd2094853de1602906a47c4265442c727a532d85199772fdfaaaf7007dc_Device=CPU_Config=(),9.40441e-05 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=c5ce2b16d47cf93b073c2ba13556fa9fdd1b6f1dbe6387a50b507a40ab1d1c1e_Device=CPU_Config=(),9.40441e-05 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=93f586b65926f2fb89cf5cc3379013f6df6964cb757fb3396060277dd393bb12_Device=CPU_Config=(),9.40441e-05 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=3cef1c65fc41c5f96e90007517fb5c911435e8d8ae7db1a1398ae63c2525d6c3_Device=CPU_Config=(),9.40441e-05 +conformance_PriorBoxClustered/ReadIRTest.Inference/Op=PriorBoxClustered.1_Type=f32_Shape=static_IR=1b13b40884ddc8a2afdfc9bf351627746534303122dd4e0c2c5fdeace9e89e7c_Device=CPU_Config=(),9.40441e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=c97ae95062233f4085689c2f5dfcbd9077c16fdb1bd304e3817b76004d85b00d_Device=CPU_Config=(),8.78578e-05 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=c078bcf5a6a207fd76d9cddc1a35df577529e71ba0a120b28c7ed17bd12673bb_Device=CPU_Config=(),8.24539e-05 +conformance_Reshape/ReadIRTest.Inference/Op=Reshape.1_Type=f32_Shape=dynamic_IR=0bbbd97c4428b9565666e9a1e56acc70035b378e16abafc54559a155583d9e6b_Device=CPU_Config=(),8.24539e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=8c4eeec465e40ae0a63a47164cf3ca02e4d9a215ba5340bb1df1a5d165d8894e_Device=CPU_Config=(),7.6003e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=31dea0868f4a13f6a25819e26ae172201cf3d52de718fc200edb84cafe7c2cf9_Device=CPU_Config=(),7.51788e-05 +conformance_MatMul/ReadIRTest.Inference/Op=MatMul.1_Type=f32_Shape=dynamic_IR=17be9a027c25bbfbc08cf4dd106ee25d649680b30d16c74580fb3f8fcab54baa_Device=CPU_Config=(),6.42907e-05 +conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=802164adc9e651b0a3ec0b5f96341fc3cbd098042412236b65e0c8f77b5153f2_Device=CPU_Config=(),5.58314e-05 +conformance_Convolution/ReadIRTest.Inference/Op=Convolution.1_Type=f32_Shape=dynamic_IR=99720c46a11f3e84906fd9327f25b187f328c6910868ac89738bc67ce0d90b64_Device=CPU_Config=(),5.13392e-05 +conformance_NonMaxSuppression/ReadIRTest.ImportExport/Op=NonMaxSuppression.9_Type=i64_Shape=dynamic_IR=d12f2033cdee7e244afad462ca1d9295c314836b593b2a30730861c2a3c8e9f2_Device=CPU_Config=(),4.37745e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ef05cedf5dbaee70082962e6459d8391c8358cccf43e33695d15184215d26d8c_Device=CPU_Config=(),2.70632e-05 +conformance_MaxPool/ReadIRTest.Inference/Op=MaxPool.8_Type=f32_Shape=dynamic_IR=5ae2e8ce34957ac812bd04943714d0b0ca6e2098c46caccfd775620d7f373cbf_Device=CPU_Config=(),2.56307e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=edb315ef0796a043a072730952495a3c1a4e080553efbbef8cde28d14d79ead3_Device=CPU_Config=(),5.42239e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=ba5382529d458077147b1f822dae04bb7c6d0634adfa0d1e7a111b5b816ad3f3_Device=CPU_Config=(),2.52027e-05 +conformance_ScatterNDUpdate/ReadIRTest.Inference/Op=ScatterNDUpdate.4_Type=i32_Shape=dynamic_IR=91f59d10b16e7305a651b8ee9480a0068225d6cd56026139e35ba69b9f84b00f_Device=CPU_Config=(),2.39583e-05 +conformance_GatherND/ReadIRTest.Inference/Op=GatherND.8_Type=i64_Shape=dynamic_IR=c1cd785825e1b2794d4bc74f6dc257e92a382e95a868a864125da70acc5cdbf4_Device=CPU_Config=(),2.39583e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=9d606780b6c646a5fc037250cae9a636436e56e277c95eadad5ce23fa09d8b13_Device=CPU_Config=(),2.2294e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=3e5930f1ff4ad9d9e53216b6f8f912fc7ba051bfc85c46ce2dbcddbcd357832c_Device=CPU_Config=(),1.97065e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b11b7154cade198918ce564fd66b7009aa6ddbf42a0cf155f16aef886c476f1_Device=CPU_Config=(),1.93378e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=b0df2409ae133826dfaa59aa1b4612b6667f034acd2fbfb466b486b67c46df29_Device=CPU_Config=(),1.80777e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=5b9fd9b0043cef8aac8d0cc2e517a3e245eada8fedb7409911cd2867e7ba85ce_Device=CPU_Config=(),1.03681e-05 +conformance_subgraph/ReadIRTest.Inference/Extractor=fused_names_Shape=static_IR=df303191a733f2e33492260b5a1c6aea1db7c5d0063f1516f49de923a176a64e_Device=CPU_Config=(),9.28838e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=0a2b1efb810d1dcf7897c3671f1eef0c36bcdca679e24b8e86f078128b381833_Device=CPU_Config=(),7.81362e-06 +conformance_Broadcast/ReadIRTest.Inference/Op=Broadcast.3_Type=f32_Shape=dynamic_IR=7562536120d473cca837bb2ad1e3969484868111954ac0b168a5c2805264a689_Device=CPU_Config=(),6.92301e-06 +conformance_Unsqueeze/ReadIRTest.Inference/Op=Unsqueeze.1_Type=f32_Shape=dynamic_IR=bda73cc94d837df9fb535743febd300cf0baf7fdf48ff538c079a4a7ca291592_Device=CPU_Config=(),5.36728e-06 +conformance_ReduceSum/ReadIRTest.Inference/Op=ReduceSum.1_Type=f32_Shape=dynamic_IR=d11097e7fa04dc0b540bf3b963cde252591b39b7dcbfae66e64ed19cd2b3b06e_Device=CPU_Config=(),5.36728e-06 +conformance_Multiply/ReadIRTest.Inference/Op=Multiply.1_Type=f32_Shape=dynamic_IR=287a7562757ef0295cc38442e3d775cff0fb1ea9b27e6897bd456f01ce82d455_Device=CPU_Config=(),5.36728e-06 +conformance_Add/ReadIRTest.Inference/Op=Add.1_Type=f32_Shape=dynamic_IR=f86f86769ec214942eaf1fdcd312a29e26308676419d8fbd98fdc485c2de0815_Device=CPU_Config=(),5.36728e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=cfa4ea6d340205f9fc4db4ec912037243299168e9bfa4e248e530c98a0f8a8ab_Device=CPU_Config=(),4.71135e-06 +conformance_subgraph/ReadIRTest.Inference/Extractor=repeat_pattern_Shape=static_IR=264ac1f5ebe805838ff6e76fca75305ba3ecb27f84e44ae7b44e9c01d613df98_Device=CPU_Config=(),1.68808e-06 From f0f4c5ab52d7c7a88d3037c9a4c84def0067bccf Mon Sep 17 00:00:00 2001 From: Edward Shogulin Date: Mon, 19 Aug 2024 12:53:32 +0100 Subject: [PATCH 041/117] [LPT] Slice transformation (#26091) ### Details: - *Slice transformation (per-tensor quantization)* ### Tickets: - *CVS-149909* --- .../include/low_precision/slice.hpp | 34 +++++++++ .../src/low_precision.cpp | 2 + .../src/slice.cpp | 67 +++++++++++++++++ .../slice_transformation.cpp | 64 +++++++++++++++++ .../slice_transformation.hpp | 40 +++++++++++ .../slice_transformation.cpp | 72 +++++++++++++++++++ .../include/ov_lpt_models/slice.hpp | 30 ++++++++ .../ov_helpers/ov_lpt_models/src/slice.cpp | 49 +++++++++++++ 8 files changed, 358 insertions(+) create mode 100644 src/common/low_precision_transformations/include/low_precision/slice.hpp create mode 100644 src/common/low_precision_transformations/src/slice.cpp create mode 100644 src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/slice_transformation.cpp create mode 100644 src/tests/functional/plugin/shared/include/low_precision_transformations/slice_transformation.hpp create mode 100644 src/tests/functional/plugin/shared/src/low_precision_transformations/slice_transformation.cpp create mode 100644 src/tests/ov_helpers/ov_lpt_models/include/ov_lpt_models/slice.hpp create mode 100644 src/tests/ov_helpers/ov_lpt_models/src/slice.cpp diff --git a/src/common/low_precision_transformations/include/low_precision/slice.hpp b/src/common/low_precision_transformations/include/low_precision/slice.hpp new file mode 100644 index 00000000000000..206a07d7bca9c7 --- /dev/null +++ b/src/common/low_precision_transformations/include/low_precision/slice.hpp @@ -0,0 +1,34 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include + +#include "layer_transformation.hpp" + +namespace ov { +namespace pass { +namespace low_precision { + +/** + * @ingroup ov_transformation_common_api + * @brief SliceTransformation propagates dequantization operations through Slice operation. + * + * For more details about the transformation, refer to + * [SliceTransformation](@ref openvino_docs_OV_UG_lpt_SliceTransformation) page + * in the OpenVINO Developer Guide. + */ +class LP_TRANSFORMATIONS_API SliceTransformation : public LayerTransformation { +public: + OPENVINO_RTTI("SliceTransformation", "0"); + SliceTransformation(const Params& params = Params()); + bool transform(TransformationContext& context, ov::pass::pattern::Matcher& m) override; + bool canBeTransformed(const TransformationContext& context, std::shared_ptr op) const override; + bool isPrecisionPreserved(std::shared_ptr layer) const noexcept override; +}; + +} // namespace low_precision +} // namespace pass +} // namespace ov diff --git a/src/common/low_precision_transformations/src/low_precision.cpp b/src/common/low_precision_transformations/src/low_precision.cpp index e58374ed3e2b1a..52479a5c2dc1fa 100644 --- a/src/common/low_precision_transformations/src/low_precision.cpp +++ b/src/common/low_precision_transformations/src/low_precision.cpp @@ -68,6 +68,7 @@ #include "low_precision/relu.hpp" #include "low_precision/squeeze.hpp" #include "low_precision/subtract.hpp" +#include "low_precision/slice.hpp" #include "low_precision/space_to_batch.hpp" #include "low_precision/split.hpp" #include "low_precision/shuffle_channels.hpp" @@ -267,6 +268,7 @@ bool ov::pass::low_precision::LowPrecision::run_on_model(const std::shared_ptr + +#include "low_precision/slice.hpp" + +#include "itt.hpp" +#include "openvino/util/log.hpp" +#include "openvino/pass/pattern/op/wrap_type.hpp" +#include "openvino/opsets/opset8.hpp" + +#include "low_precision/network_helper.hpp" + +namespace ov { +namespace pass { +namespace low_precision { + +SliceTransformation::SliceTransformation(const Params& params) : LayerTransformation(params) { + MATCHER_SCOPE(SliceTransformation); + auto matcher = ov::pass::pattern::wrap_type(); + + ov::graph_rewrite_callback callback = [this](pattern::Matcher& m) { + auto op = m.get_match_root(); + if (transformation_callback(op)) { + return false; + } + return transform(*context, m); + }; + + auto m = std::make_shared(matcher, matcher_name); + this->register_matcher(m, callback); +} + +bool SliceTransformation::transform(TransformationContext& context, ov::pass::pattern::Matcher& m) { + if (!SliceTransformation::canBeTransformed(context, m.get_match_root())) { + return false; + } + + const auto strided_slice = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + auto dequantization = NetworkHelper::getDequantization(strided_slice, defaultPrecisions); + const auto newOperation = moveDequantizationAfter(context, strided_slice, NetworkHelper::getDequantization(strided_slice, defaultPrecisions)); + + OPENVINO_DEBUG("LPT: done: ", newOperation); + return true; +} + +bool SliceTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr operation) const { + if (!LayerTransformation::canBeTransformed(context, operation)) { + return false; + } + + if (!ov::is_type(operation)) { + return false; + } + + const auto dequantization = NetworkHelper::getDequantization(operation); + return dequantization.isPerTensor(); +} + +bool SliceTransformation::isPrecisionPreserved(std::shared_ptr layer) const noexcept { + return true; +} +} // namespace low_precision +} // namespace pass +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/slice_transformation.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/slice_transformation.cpp new file mode 100644 index 00000000000000..2696d6f14f8ed8 --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/slice_transformation.cpp @@ -0,0 +1,64 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include +#include "low_precision_transformations/slice_transformation.hpp" + + +using namespace LayerTestsDefinitions; + +namespace { +const std::vector netPrecisions = { + ov::element::f32 +}; + +const std::vector trasformationParamValues = { + LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams() +}; + +const std::vector params = { + { + { + 256ul, + ov::Shape{ 1, 1, 1, 1 }, + { 0.f }, + { 25.5f }, + { 0.f }, + { 12.8f } + }, + { 0 }, // start + { 2147483647 }, // end + { 2 }, // step + { 2 }, // axes + "u8" + }, + { + { + 256ul, + ov::Shape{ 1, 3, 1, 1 }, + { 0.f, 0.f, 0.f }, + { 255.f / 1.f, 255.f / 2.f, 255.f / 3.f }, + { 0.f, 0.f, 0.f }, + { 255.f / 1.f, 255.f / 2.f, 255.f / 3.f } + }, + { 0 }, // start + { 2147483647 }, // end + { 2 }, // step + { 2 }, // axes + "f32" + }, +}; + +INSTANTIATE_TEST_SUITE_P(smoke_LPT, SliceTransformation, + ::testing::Combine( + ::testing::ValuesIn(netPrecisions), + ::testing::Values(ov::PartialShape({ 1, 3, 24, 24 })), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::ValuesIn(trasformationParamValues), + ::testing::ValuesIn(params)), + SliceTransformation::getTestCaseName); + +} // namespace diff --git a/src/tests/functional/plugin/shared/include/low_precision_transformations/slice_transformation.hpp b/src/tests/functional/plugin/shared/include/low_precision_transformations/slice_transformation.hpp new file mode 100644 index 00000000000000..783f42c6b1967e --- /dev/null +++ b/src/tests/functional/plugin/shared/include/low_precision_transformations/slice_transformation.hpp @@ -0,0 +1,40 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "shared_test_classes/base/low_precision_transformations/layer_transformation.hpp" +#include "ov_lpt_models/common/fake_quantize_on_data.hpp" +#include "ov_lpt_models/common/dequantization_operations.hpp" + +namespace LayerTestsDefinitions { +class SliceTransformationParam { +public: + ov::builder::subgraph::FakeQuantizeOnData fakeQuantize; + std::vector start; + std::vector stop; + std::vector step; + std::vector axes; + std::string expectedPrecision; +}; + +typedef std::tuple< + ov::element::Type, + ov::PartialShape, + std::string, + ov::pass::low_precision::LayerTransformation::Params, + SliceTransformationParam +> SliceTransformationParams; + +class SliceTransformation : + public testing::WithParamInterface, + public LayerTestsUtils::LayerTransformation { +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj); + +protected: + void SetUp() override; +}; + +} // namespace LayerTestsDefinitions diff --git a/src/tests/functional/plugin/shared/src/low_precision_transformations/slice_transformation.cpp b/src/tests/functional/plugin/shared/src/low_precision_transformations/slice_transformation.cpp new file mode 100644 index 00000000000000..78dd8d1550f090 --- /dev/null +++ b/src/tests/functional/plugin/shared/src/low_precision_transformations/slice_transformation.cpp @@ -0,0 +1,72 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "low_precision_transformations/slice_transformation.hpp" +#include +#include +#include + +#include "ov_lpt_models/slice.hpp" + +namespace LayerTestsDefinitions { + +inline std::ostream& operator<<(std::ostream& os, const std::vector& values) { + os << "{ "; + for (size_t i = 0; i < values.size(); ++i) { + os << values[i]; + if (i != (values.size() - 1ul)) { + os << ", "; + } + } + os << " }"; + return os; +} + +std::string SliceTransformation::getTestCaseName(const testing::TestParamInfo& obj) { + ov::element::Type netPrecision; + ov::PartialShape inputShape; + std::string targetDevice; + ov::pass::low_precision::LayerTransformation::Params params; + SliceTransformationParam param;; + std::tie(netPrecision, inputShape, targetDevice, params, param) = obj.param; + + std::ostringstream result; + result << get_test_case_name_by_params(netPrecision, inputShape, targetDevice, params) << "_" << + param.fakeQuantize << "_" << + param.start << "_" << + param.stop << "_" << + param.step << "_" << + param.axes; + return result.str(); +} + +void SliceTransformation::SetUp() { + ov::element::Type netPrecision; + ov::PartialShape inputShape; + ov::pass::low_precision::LayerTransformation::Params params; + SliceTransformationParam param; + std::tie(netPrecision, inputShape, targetDevice, params, param) = this->GetParam(); + + init_input_shapes(inputShape); + + function = ov::builder::subgraph::SliceFunction::get( + netPrecision, + inputShape, + param.fakeQuantize, + param.start, + param.stop, + param.step, + param.axes); +} + +TEST_P(SliceTransformation, CompareWithRefImpl) { + SKIP_IF_CURRENT_TEST_IS_DISABLED(); + run(); + + const auto params = std::get<4>(GetParam()); + const auto& actualPrecision = get_runtime_precision_by_type("StridedSlice"); + EXPECT_EQ(actualPrecision, params.expectedPrecision); +}; + +} // namespace LayerTestsDefinitions diff --git a/src/tests/ov_helpers/ov_lpt_models/include/ov_lpt_models/slice.hpp b/src/tests/ov_helpers/ov_lpt_models/include/ov_lpt_models/slice.hpp new file mode 100644 index 00000000000000..0a8d7b0161743b --- /dev/null +++ b/src/tests/ov_helpers/ov_lpt_models/include/ov_lpt_models/slice.hpp @@ -0,0 +1,30 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include "ov_lpt_models/common/builders.hpp" +#include "ov_lpt_models/common/dequantization_operations.hpp" + +namespace ov { +namespace builder { +namespace subgraph { + +class SliceFunction { +public: + static std::shared_ptr get( + const ov::element::Type inputPrecision, + const ov::PartialShape& inputShape, + const ov::builder::subgraph::FakeQuantizeOnData& fakeQuantize, + const std::vector& start, + const std::vector& stop, + const std::vector& step, + const std::vector& axes); +}; + +} // namespace subgraph +} // namespace builder +} // namespace ov diff --git a/src/tests/ov_helpers/ov_lpt_models/src/slice.cpp b/src/tests/ov_helpers/ov_lpt_models/src/slice.cpp new file mode 100644 index 00000000000000..6701c62898fec9 --- /dev/null +++ b/src/tests/ov_helpers/ov_lpt_models/src/slice.cpp @@ -0,0 +1,49 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "ov_lpt_models/slice.hpp" +#include "openvino/opsets/opset8.hpp" + +using namespace ov::pass::low_precision; + +namespace ov { +namespace builder { +namespace subgraph { + +std::shared_ptr SliceFunction::get( + const ov::element::Type inputPrecision, + const ov::PartialShape& inputShape, + const ov::builder::subgraph::FakeQuantizeOnData& fakeQuantize, + const std::vector& start, + const std::vector& stop, + const std::vector& step, + const std::vector& axes) { + const auto input = std::make_shared(inputPrecision, inputShape); + input->set_friendly_name("input"); + const auto fqOnData = makeFakeQuantize(input, inputPrecision, fakeQuantize); + + const auto start_constant = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{ start.size() }, start); + start_constant->set_friendly_name("start"); + const auto stop_constant = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{ stop.size() }, stop); + stop_constant->set_friendly_name("stop"); + const auto step_constant = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{ step.size() }, step); + step_constant->set_friendly_name("step"); + const auto axes_constant = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{ axes.size() }, axes); + axes_constant->set_friendly_name("axes "); + + const auto stridedSlice = std::make_shared(fqOnData, start_constant, stop_constant, step_constant, axes_constant); + stridedSlice->set_friendly_name("slice"); + + const auto res = std::make_shared(stridedSlice); + const auto function = std::make_shared( + ov::ResultVector{ res }, + ov::ParameterVector{ input }, + "SliceTransformation"); + + return function; +} + +} // namespace subgraph +} // namespace builder +} // namespace ov From 4c5a13cd201b199aa1da19e7dd367a8b53548370 Mon Sep 17 00:00:00 2001 From: Jorge Ragde Date: Mon, 19 Aug 2024 05:07:20 -0700 Subject: [PATCH 042/117] [TF FE] Implemented RGBToHSV operation (#25318) ### Details: - Implemented and registered loader for RGBToHSV - Created unit test test_tf_RGBToHSV.py - Slightly modified helper to accept ov::Output instead of shared_ptr ### Tickets: - #24792 --------- Co-authored-by: Roman Kazantsev --- .../tensorflow/docs/supported_ops.md | 2 +- src/frontends/tensorflow/src/op_table.cpp | 1 + .../include/common_op_table.hpp | 1 + .../tensorflow_common/include/utils.hpp | 2 +- .../tensorflow_common/src/op/rgb_to_hsv.cpp | 38 +++++++++++++ src/frontends/tensorflow_common/src/utils.cpp | 2 +- .../tensorflow_tests/test_tf_RGBToHSV.py | 54 +++++++++++++++++++ 7 files changed, 97 insertions(+), 3 deletions(-) create mode 100644 src/frontends/tensorflow_common/src/op/rgb_to_hsv.cpp create mode 100644 tests/layer_tests/tensorflow_tests/test_tf_RGBToHSV.py diff --git a/src/frontends/tensorflow/docs/supported_ops.md b/src/frontends/tensorflow/docs/supported_ops.md index aa96ddb4fa1c3f..9f6af0f7670ae0 100644 --- a/src/frontends/tensorflow/docs/supported_ops.md +++ b/src/frontends/tensorflow/docs/supported_ops.md @@ -829,7 +829,7 @@ A "supported operation" is one that TensorFlow Frontend can convert to the OpenV | RFFT | YES | | | RFFT2D | YES | | | RFFT3D | YES | | -| RGBToHSV | NO | | +| RGBToHSV | YES | | | RaggedBincount | NO | | | RaggedCountSparseOutput | NO | | | RaggedCross | NO | | diff --git a/src/frontends/tensorflow/src/op_table.cpp b/src/frontends/tensorflow/src/op_table.cpp index 67a8ecfb68288c..8cd0c4a9b15016 100644 --- a/src/frontends/tensorflow/src/op_table.cpp +++ b/src/frontends/tensorflow/src/op_table.cpp @@ -363,6 +363,7 @@ const std::map get_supported_ops() { {"RFFT", CreatorFunction(translate_rfft_op)}, {"RFFT2D", CreatorFunction(translate_rfft_op)}, {"RFFT3D", CreatorFunction(translate_rfft_op)}, + {"RGBToHSV", CreatorFunction(translate_rgb_to_hsv_op)}, {"Rint", CreatorFunction(translate_rint_op)}, {"Roll", CreatorFunction(translate_roll_op)}, {"Round", CreatorFunction(translate_round_op)}, diff --git a/src/frontends/tensorflow_common/include/common_op_table.hpp b/src/frontends/tensorflow_common/include/common_op_table.hpp index 3332122edee0c8..b85e8b094f2d63 100644 --- a/src/frontends/tensorflow_common/include/common_op_table.hpp +++ b/src/frontends/tensorflow_common/include/common_op_table.hpp @@ -139,6 +139,7 @@ OP_CONVERTER(translate_reverse_op); OP_CONVERTER(translate_reverse_v2_op); OP_CONVERTER(translate_reverse_sequence_op); OP_CONVERTER(translate_rfft_op); +OP_CONVERTER(translate_rgb_to_hsv_op); OP_CONVERTER(translate_rint_op); OP_CONVERTER(translate_roll_op); OP_CONVERTER(translate_round_op); diff --git a/src/frontends/tensorflow_common/include/utils.hpp b/src/frontends/tensorflow_common/include/utils.hpp index 0ed5bbf9c22b8b..b47c9f97cceaaf 100644 --- a/src/frontends/tensorflow_common/include/utils.hpp +++ b/src/frontends/tensorflow_common/include/utils.hpp @@ -156,7 +156,7 @@ ov::Output get_data_slice(const ov::Output& data, ov::Output compute_broadcast_args(const ov::Output& shape1, const ov::Output& shape2); std::shared_ptr, std::shared_ptr, std::shared_ptr>> rgb_to_hsv( - const std::shared_ptr& images); + const ov::Output& images); std::shared_ptr hsv_to_rgb(const ov::Output& h, const ov::Output& s, diff --git a/src/frontends/tensorflow_common/src/op/rgb_to_hsv.cpp b/src/frontends/tensorflow_common/src/op/rgb_to_hsv.cpp new file mode 100644 index 00000000000000..45a0f3598c05bc --- /dev/null +++ b/src/frontends/tensorflow_common/src/op/rgb_to_hsv.cpp @@ -0,0 +1,38 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "common_op_table.hpp" +#include "openvino/op/concat.hpp" +#include "utils.hpp" + +using namespace std; +using namespace ov; +using namespace ov::op; + +namespace ov { +namespace frontend { +namespace tensorflow { +namespace op { + +OutputVector translate_rgb_to_hsv_op(const NodeContext& node) { + default_op_checks(node, 1, {"RGBToHSV"}); + auto images = node.get_input(0); + auto node_name = node.get_name(); + + auto hsv_components = rgb_to_hsv(images); + + auto hh = get<0>(*hsv_components); + auto ss = get<1>(*hsv_components); + auto vv = get<2>(*hsv_components); + + auto rgb = make_shared(NodeVector{hh, ss, vv}, -1); + + set_node_name(node_name, rgb); + return {rgb}; +} + +} // namespace op +} // namespace tensorflow +} // namespace frontend +} // namespace ov diff --git a/src/frontends/tensorflow_common/src/utils.cpp b/src/frontends/tensorflow_common/src/utils.cpp index ab5ecd94f4d2b0..2b79a2de8bac5a 100644 --- a/src/frontends/tensorflow_common/src/utils.cpp +++ b/src/frontends/tensorflow_common/src/utils.cpp @@ -431,7 +431,7 @@ Output compute_broadcast_args(const Output& shape1, const Outputoutput(0); } -shared_ptr, shared_ptr, shared_ptr>> rgb_to_hsv(const shared_ptr& images) { +shared_ptr, shared_ptr, shared_ptr>> rgb_to_hsv(const ov::Output& images) { // image format conversion based on // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/image/adjust_saturation_op.cc auto const_zero_f_ = create_same_type_const_scalar(images, 0.0f); diff --git a/tests/layer_tests/tensorflow_tests/test_tf_RGBToHSV.py b/tests/layer_tests/tensorflow_tests/test_tf_RGBToHSV.py new file mode 100644 index 00000000000000..e7c03893b4df05 --- /dev/null +++ b/tests/layer_tests/tensorflow_tests/test_tf_RGBToHSV.py @@ -0,0 +1,54 @@ +# Copyright (C) 2018-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import platform +import pytest +import tensorflow as tf +from common.tf_layer_test_class import CommonTFLayerTest + +rng = np.random.default_rng(3476123) + + +class TestRGBToHSV(CommonTFLayerTest): + def _prepare_input(self, inputs_info): + assert 'images:0' in inputs_info + if self.special_case == 'Black Image': + images_shape = inputs_info['images:0'] + inputs_data = {} + inputs_data['images:0'] = np.zeros(images_shape).astype(self.input_type) + elif self.special_case == 'Grayscale Image': + images_shape = inputs_info['images:0'] + inputs_data = {} + inputs_data['images:0'] = np.ones(images_shape).astype(self.input_type) * rng.random() + else: + images_shape = inputs_info['images:0'] + inputs_data = {} + inputs_data['images:0'] = rng.random(images_shape).astype(self.input_type) + + return inputs_data + + def create_rgb_to_hsv_net(self, input_shape, input_type, special_case): + self.special_case = special_case + self.input_type = input_type + tf.compat.v1.reset_default_graph() + # Create the graph and model + with tf.compat.v1.Session() as sess: + images = tf.compat.v1.placeholder(input_type, input_shape, 'images') + tf.raw_ops.RGBToHSV(images=images) + tf.compat.v1.global_variables_initializer() + tf_net = sess.graph_def + + return tf_net, None + + @pytest.mark.parametrize('input_shape', [[2, 3], [5, 6, 3], [2, 5, 10, 3]]) + @pytest.mark.parametrize('input_type', [np.float32, np.float64]) + @pytest.mark.parametrize('special_case', [None, 'Black Image', 'Grayscale Image']) + @pytest.mark.precommit + @pytest.mark.nightly + def test_adjust_hue_basic(self, input_shape, input_type, special_case, + ie_device, precision, ir_version, temp_dir, + use_legacy_frontend): + self._test(*self.create_rgb_to_hsv_net(input_shape, input_type, special_case), + ie_device, precision, ir_version, temp_dir=temp_dir, + use_legacy_frontend=use_legacy_frontend) From 8281fcc5d0cb33ec015eb927db3ea1bc45d578a9 Mon Sep 17 00:00:00 2001 From: Sergey Shlyapnikov Date: Mon, 19 Aug 2024 17:24:57 +0400 Subject: [PATCH 043/117] [GPU] Fix segmentation fault during remote tensor destruction in the Python API (#26109) ### Details: This patch updates `create_host_tensor()` and `create_tensor()` of `RemoteContext` to update _so to std::shared_ptr of the created remote tensor, preventing the dynamically loaded library from unloading before all remote tensors are destroyed --- src/inference/src/cpp/remote_context.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/inference/src/cpp/remote_context.cpp b/src/inference/src/cpp/remote_context.cpp index 3f75b4e402139e..ea3bd38b558a4b 100644 --- a/src/inference/src/cpp/remote_context.cpp +++ b/src/inference/src/cpp/remote_context.cpp @@ -67,6 +67,8 @@ std::string RemoteContext::get_device_name() const { RemoteTensor RemoteContext::create_tensor(const element::Type& type, const Shape& shape, const AnyMap& params) { OV_REMOTE_CONTEXT_STATEMENT({ auto tensor = _impl->create_tensor(type, shape, params); + if (!tensor._so) + tensor._so = _so; return make_tensor(tensor).as(); }); } @@ -74,6 +76,8 @@ RemoteTensor RemoteContext::create_tensor(const element::Type& type, const Shape Tensor RemoteContext::create_host_tensor(const element::Type element_type, const Shape& shape) { OV_REMOTE_CONTEXT_STATEMENT({ auto tensor = _impl->create_host_tensor(element_type, shape); + if (!tensor._so) + tensor._so = _so; return make_tensor(tensor); }); } From 00d9800aa2df83879ddf774bd98eb4d2a66930d9 Mon Sep 17 00:00:00 2001 From: Alexandra Sidorova Date: Mon, 19 Aug 2024 20:54:09 +0400 Subject: [PATCH 044/117] [Snippets] Added SplitLoops support for dynamic loops (#25957) ### Details: - *Introduced the class `InnerSplittedUnifiedLoopInfo` which describes inner splitted Loop after `SplitLoops`. Work amount of thus Loop is equal to increment of outer splitted loop. Removed the attribute `is_work_amount_const` from `LoopInfo`* - *Enabled `SplitLoops` optimization for dynamic loops/* - *Fixed finalization offset calculation for dynamic case* - *Fixed `increment = 1` for dynamic innermost Loops with only Eltwise ops inside - now all dynamic `Last` Loop iterations has `increment = work_amount` (`evaluate_once = true`) by default. If there is innermost Loop with only Eltiwse ops, the pass `SetLoopIncrementOne` will be registered in last iteration handler by default* - *Fixed LoopManager cloning: now all LoopInfo are cloned recursively and fully - with UnifiedLoopInfo in ExpandedLoopInfo. Before we didn't clone them.* - *Fixed `ExtractLoopInvariants` for splitted loops (which may have the same `dim_idx`) - now we separately create vector of ordered loop IDs by execution and iterate through this vector.* - *Fixed `ValidateExpandedLoopInfo` to support validation of loops iterations of which are executed not consistently (like outer splitted loop iterations)* - *Fixed buffer scratchpad size calculation in RuntimeConfigurator: no need to calculate allocation size of Buffers which are in Loops with `work_amount = 0`* - *Added workaround in `ComputeBufferAllocationSize::get_allocation_size` (the ticket 149219) to handle Buffers in cloned OuterSplittedLoops after `InsertSpecificIterations`* - *Added debug method `to_string()` for `RuntimeConfig`* ### Tickets: - *[141735](https://jira.devtools.intel.com/browse/CVS-141735)* ### Prerequisites: - [x] https://github.com/openvinotoolkit/openvino/pull/25772 --- .../include/snippets/lowered/loop_info.hpp | 141 +++++++++++++----- .../include/snippets/lowered/loop_manager.hpp | 16 +- .../snippets/lowered/pass/iter_handler.hpp | 28 +--- .../snippets/lowered/pass/split_loops.hpp | 18 ++- .../lowered/specific_loop_iter_handlers.hpp | 2 +- .../pass/analyze_broadcastable_inputs.hpp | 2 +- .../include/snippets/runtime_configurator.hpp | 7 +- src/common/snippets/src/generator.cpp | 6 +- src/common/snippets/src/lowered/loop_info.cpp | 124 +++++++++++---- .../snippets/src/lowered/loop_manager.cpp | 18 ++- .../src/lowered/pass/brgemm_blocking.cpp | 1 - .../pass/compute_buffer_allocation_size.cpp | 35 ++++- .../lowered/pass/extract_loop_invariants.cpp | 46 ++++-- .../snippets/src/lowered/pass/fuse_loops.cpp | 9 +- .../snippets/src/lowered/pass/init_loops.cpp | 9 +- .../pass/insert_specific_iterations.cpp | 8 +- .../src/lowered/pass/iter_handler.cpp | 73 +-------- .../pass/optimize_loop_single_evaluation.cpp | 3 +- .../snippets/src/lowered/pass/split_loops.cpp | 135 +++++++++++++---- .../lowered/pass/validate_expanded_loops.cpp | 62 ++++---- .../lowered/specific_loop_iter_handlers.cpp | 22 ++- .../snippets/src/runtime_configurator.cpp | 79 ++++++++-- .../pass/extracted_loop_invariants.cpp | 78 +++++++++- .../snippets/tests/src/lowered/pass/loop.cpp | 135 +++++++++-------- .../snippets/cpu_runtime_configurator.cpp | 21 +++ .../snippets/cpu_runtime_configurator.hpp | 4 + .../snippets/x64/jit_loop_emitters.cpp | 7 +- 27 files changed, 736 insertions(+), 353 deletions(-) diff --git a/src/common/snippets/include/snippets/lowered/loop_info.hpp b/src/common/snippets/include/snippets/lowered/loop_info.hpp index 5563dc240c2818..cc66f5f6ffcc95 100644 --- a/src/common/snippets/include/snippets/lowered/loop_info.hpp +++ b/src/common/snippets/include/snippets/lowered/loop_info.hpp @@ -12,28 +12,40 @@ namespace ov { namespace snippets { namespace lowered { +class LoopInfo; +using LoopInfoMap = std::unordered_map>; +using LoopInfoSet = std::unordered_set; +using LoopInfoPtr = std::shared_ptr; + /** * @interface LoopInfo * @brief The base class that contains the common information about a Loop in Linear Intermediate Representation (Linear IR): * work amount of the Loop, step of loop counter increment, input and output ports of the Loop. * @ingroup snippets */ -class LoopInfo { +class LoopInfo : public std::enable_shared_from_this { public: enum {UNDEFINED_DIM_IDX = std::numeric_limits::max()}; LoopInfo() = default; - LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, bool is_wa_const = false); - LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, - bool is_wa_const = false); + LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits); + LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits); virtual ~LoopInfo() = default; /** - * @brief Clone LoopInfo with new expressions + * @brief Clone LoopInfo with new Expressions * @param expr_map map of new and old expressions + * @param loop_map map of new and old LoopInfo. * @return the copy */ - virtual std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map) const = 0; + virtual std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const = 0; + + /** + * @brief Apply the passed function to the current LoopInfo + * @param func function for applying + * @param applied_loops set of already updated loops + */ + virtual void apply(const std::function& func, LoopInfoSet& applied_loops) = 0; /** * @brief Check if some parameters of Loop are dynamic (undefined) @@ -62,7 +74,7 @@ class LoopInfo { * @brief Returns work amount of the Loop. * @return m_work_amount */ - size_t get_work_amount() const; + virtual size_t get_work_amount() const; /** * @brief Returns step of loop counter increment. * @return m_increment @@ -83,17 +95,12 @@ class LoopInfo { * @return m_output_ports */ const std::vector& get_output_ports() const; - /** - * @brief Returns True if `work_amount` cannot be rewritten/updated by passes. - * @return m_is_work_amount_const - */ - bool is_work_amount_const() const; /** * @brief Set m_work_amount value * @param work_amount - work amount of the loop */ - void set_work_amount(size_t work_amount); + virtual void set_work_amount(size_t work_amount); /** * @brief Set m_increment value * @param increment - step of loop counter increment @@ -104,13 +111,8 @@ class LoopInfo { * @param dim_idx - index */ void set_dim_idx(size_t dim_idx); - /** - * @brief Sets `value` to `m_is_work_amount_const` - * @param value - value of the attribute - */ - void set_work_amount_const(bool value); -/** + /** * @brief Replace the current LoopPort `actual_port` with new `target_ports` * @param actual_port actual port * @param target_ports new ports. The ports order is important. Can contain `actual_port` @@ -188,12 +190,7 @@ class LoopInfo { // Note: Scalars aren't input expressions but can be before first input expr in Linear IR std::vector m_input_ports = {}; std::vector m_output_ports = {}; - - // TODO [143394] : All static values in compilation stage should be `is_const=True` (not only `work_amount`) - // If True, no one pass can rewrite the value of `m_work_amount` - bool m_is_work_amount_const = false; }; -using LoopInfoPtr = std::shared_ptr; /** * @interface UnifiedLoopInfo @@ -227,20 +224,28 @@ class UnifiedLoopInfo : public LoopInfo { UnifiedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, const std::vector& in_descs, const std::vector& out_descs, - const SpecificIterationHandlers& handlers = SpecificIterationHandlers(), bool is_wa_const = false); + const SpecificIterationHandlers& handlers = SpecificIterationHandlers()); UnifiedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, - const SpecificIterationHandlers& handlers = SpecificIterationHandlers(), bool is_wa_const = false); + const SpecificIterationHandlers& handlers = SpecificIterationHandlers()); UnifiedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, - const SpecificIterationHandlers& handlers = SpecificIterationHandlers(), bool is_wa_const = false); + const SpecificIterationHandlers& handlers = SpecificIterationHandlers()); /** - * @brief Clone LoopInfo with new expressions + * @brief Clone LoopInfo with new Expressions * @param expr_map map of new and old expressions + * @param loop_map map of new and old LoopInfo. * @return the copy */ - std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map) const override; + std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const override; + + /** + * @brief Apply the passed function on the current LoopInfo. + * @param func function for applying + * @param applied_loops set of already updated loops + */ + void apply(const std::function& func, LoopInfoSet& applied_loops) override; /** * @brief Check if some parameters of Loop are dynamic (undefined) @@ -362,7 +367,7 @@ class UnifiedLoopInfo : public LoopInfo { caller(m_output_ports[i], m_output_port_descs[i]); } -private: +protected: /** * @brief Clone LoopPortDesc[actual_port_idx] `new_count` times and insert on the place of current desc * @param actual_port_idx index of the current descriptor/port @@ -377,6 +382,65 @@ class UnifiedLoopInfo : public LoopInfo { }; using UnifiedLoopInfoPtr = std::shared_ptr; +/** + * @interface InnerSplittedUnifiedLoopInfo + * @brief The structure describes inner splitted Loop after `SplitLoops`. + * Contains pointer to outer splitted loop info. WorkAmount is equal to increment of outer splitted loop info. + * @ingroup snippets + */ +class InnerSplittedUnifiedLoopInfo : public UnifiedLoopInfo { +public: + OPENVINO_RTTI("InnerSplittedUnifiedLoopInfo", "0", UnifiedLoopInfo) + + InnerSplittedUnifiedLoopInfo() = default; + InnerSplittedUnifiedLoopInfo(size_t increment, const std::vector& entries, const std::vector& exits, + const std::vector& in_descs, const std::vector& out_descs, + const SpecificIterationHandlers& handlers, LoopInfoPtr outer_splitted_loop_info); + + /** + * @brief Clone LoopInfo with new Expressions + * @param expr_map map of new and old expressions + * @param loop_map map of new and old LoopInfo. + * If `loop_map` contains cloned outer splitted loop -info, we take it from there. + * Otherwise we manually clone it and add to this map. + * @return the copy + */ + std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const override; + + /** + * @brief Apply the passed function on OuterSplittedLoopInfo and then on the current LoopInfo. + * @param func function for applying + * @param applied_loops set of already updated loops + */ + void apply(const std::function& func, LoopInfoSet& applied_loops) override; + + /** + * @brief Returns work amount of the Loop. + * @return m_work_amount + */ + size_t get_work_amount() const override; + /** + * @brief Returns OuterSplittedLoopInfo + * @return m_outer_splitted_loop_info + */ + LoopInfoPtr get_outer_splitted_loop_info() const; + + /** + * @brief Set m_work_amount value + * @param work_amount - work amount of the loop + */ + void set_work_amount(size_t work_amount) override; + /** + * @brief Set m_outer_splitted_loop_info value + * @param outer - OuterSplittedLoopInfo + */ + void set_outer_splitted_loop_info(LoopInfoPtr outer); + +private: + LoopInfoPtr m_outer_splitted_loop_info = nullptr; +}; +using InnerSplittedUnifiedLoopInfoPtr = std::shared_ptr; + /** * @interface ExpandedLoopInfo * @brief The structure describes expanded Loop (specific iterations) after unified loop decomposition into specific loop iterations. @@ -390,14 +454,23 @@ class ExpandedLoopInfo : public LoopInfo { ExpandedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, std::vector ptr_increments, std::vector final_offsets, std::vector data_sizes, - SpecificLoopIterType type, std::shared_ptr unified_loop_info, bool is_wa_const = false, - bool evaluate_once = false); + SpecificLoopIterType type, UnifiedLoopInfoPtr unified_loop_info, bool evaluate_once = false); /** - * @brief Clone LoopInfo with new expressions + * @brief Clone LoopInfo with new Expressions * @param expr_map map of new and old expressions + * @param loop_map map of new and old LoopInfo. + * If `loop_map` contains cloned unified loop -info, we take it from there. + * Otherwise we manually clone it and add to this map. * @return the copy */ - std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map) const override; + std::shared_ptr clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const override; + + /** + * @brief Apply the passed function on UnifiedLoopInfo and then on the current LoopInfo. + * @param func function for applying + * @param applied_loops set of already updated loops + */ + void apply(const std::function& func, LoopInfoSet& applied_loops) override; /** * @brief Check if some parameters of Loop are dynamic (undefined) diff --git a/src/common/snippets/include/snippets/lowered/loop_manager.hpp b/src/common/snippets/include/snippets/lowered/loop_manager.hpp index ab4db81a8e2e6b..099d7ff634924d 100644 --- a/src/common/snippets/include/snippets/lowered/loop_manager.hpp +++ b/src/common/snippets/include/snippets/lowered/loop_manager.hpp @@ -98,13 +98,12 @@ class LoopManager { size_t increment, const std::vector& entries, const std::vector& exits, - bool set_default_handlers = true, - bool is_work_amount_const = false) { + bool set_default_handlers = true) { const auto normalized_increment = utils::is_dynamic_value(work_amount) || work_amount == 0 ? increment : std::min(increment, work_amount); - const auto& handlers = set_default_handlers - ? SpecificIterationHandlers(work_amount, normalized_increment) - : SpecificIterationHandlers(); - const auto loop_info = std::make_shared(work_amount, normalized_increment, entries, exits, handlers, is_work_amount_const); + const auto loop_info = std::make_shared(work_amount, normalized_increment, entries, exits); + if (set_default_handlers) + loop_info->set_handlers(SpecificIterationHandlers(work_amount, normalized_increment, loop_info->get_dim_idx())); + const auto loop_id = this->add_loop_info(loop_info); for (auto expr_it = loop_begin_pos; expr_it != loop_end_pos; ++expr_it) { insert_loop_id(*expr_it, loop_id); @@ -131,9 +130,8 @@ class LoopManager { size_t dim_idx, const std::vector& entries, const std::vector& exits, - bool set_default_handlers = true, - bool is_work_amount_const = false) { - const auto loop_id = mark_loop(loop_begin_pos, loop_end_pos, work_amount, increment, entries, exits, set_default_handlers, is_work_amount_const); + bool set_default_handlers = true) { + const auto loop_id = mark_loop(loop_begin_pos, loop_end_pos, work_amount, increment, entries, exits, set_default_handlers); const auto loop_info = get_loop_info(loop_id); loop_info->set_dim_idx(dim_idx); return loop_id; diff --git a/src/common/snippets/include/snippets/lowered/pass/iter_handler.hpp b/src/common/snippets/include/snippets/lowered/pass/iter_handler.hpp index b7eb4e7176f3c1..2587ffbd546dfa 100644 --- a/src/common/snippets/include/snippets/lowered/pass/iter_handler.hpp +++ b/src/common/snippets/include/snippets/lowered/pass/iter_handler.hpp @@ -48,32 +48,14 @@ class SetFillOffset : public pass::RangedPass { }; /** - * @interface TransformInnerSplitLoop - * @brief The pass updates finalization offsets, work amount and increment of inner Loop basing on tail_size of the current Loop - * @param m_tail_size - tail_size of the current Loop + * @interface SetLoopIncrementOne + * @brief The pass set `increment = 1` to ExpandedLoopInfo which is mapped on LoopEnd in the passed iterator `end` and to this LoopEnd. * @ingroup snippets */ -class TransformInnerSplitLoop : public pass::RangedPass { +class SetLoopIncrementOne : public snippets::lowered::pass::RangedPass { public: - TransformInnerSplitLoop(size_t tail_size); - OPENVINO_RTTI("TransformInnerSplitLoop", "RangedPass") - bool run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) override; - std::shared_ptr merge(const std::shared_ptr& other) override; - -private: - size_t m_tail_size; -}; - -/** - * @interface SetEvaluateOnce - * @brief The pass set `evaluate once = true` only to ExpandedLoopInfo which is mapped on LoopEnd in the passed iterator `end`. - * The pointer arithmetic should be updated in the separate optimization `OptimizeLoopSingleEvaluation` - * @ingroup snippets - */ -class SetEvaluateOnce : public snippets::lowered::pass::RangedPass { -public: - SetEvaluateOnce() = default; - OPENVINO_RTTI("SetEvaluateOnce", "RangedPass") + SetLoopIncrementOne() = default; + OPENVINO_RTTI("SetLoopIncrementOne", "RangedPass") bool run(snippets::lowered::LinearIR& linear_ir, snippets::lowered::LinearIR::constExprIt begin, snippets::lowered::LinearIR::constExprIt end) override; diff --git a/src/common/snippets/include/snippets/lowered/pass/split_loops.hpp b/src/common/snippets/include/snippets/lowered/pass/split_loops.hpp index c186e132d455e3..953f20bbe56c3d 100644 --- a/src/common/snippets/include/snippets/lowered/pass/split_loops.hpp +++ b/src/common/snippets/include/snippets/lowered/pass/split_loops.hpp @@ -32,11 +32,27 @@ namespace pass { class SplitLoops : public RangedPass { public: OPENVINO_RTTI("SplitLoops", "RangedPass") - SplitLoops(); + SplitLoops() = default; bool run(LinearIR& linear_ir, lowered::LinearIR::constExprIt begin, lowered::LinearIR::constExprIt end) override; private: static bool can_be_split(const UnifiedLoopInfoPtr& current, const UnifiedLoopInfoPtr& target); + + static void split(LinearIR& linear_ir, size_t loop_to_split_id, size_t outer_increment); + + /** + * @interface TransformInnerSplitLoop + * @brief The pass replace existing inner splitted LoopInfo with new InnerSplittedUnifiedLoopInfo and + * update the corresponding LoopInfo + * @ingroup snippets + */ + class TransformInnerSplitLoop : public pass::RangedPass { + public: + TransformInnerSplitLoop() = default; + OPENVINO_RTTI("TransformInnerSplitLoop", "RangedPass") + bool run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) override; + std::shared_ptr merge(const std::shared_ptr& other) override; + }; }; } // namespace pass diff --git a/src/common/snippets/include/snippets/lowered/specific_loop_iter_handlers.hpp b/src/common/snippets/include/snippets/lowered/specific_loop_iter_handlers.hpp index c94ac6561bce4d..f91595bf86bd26 100644 --- a/src/common/snippets/include/snippets/lowered/specific_loop_iter_handlers.hpp +++ b/src/common/snippets/include/snippets/lowered/specific_loop_iter_handlers.hpp @@ -15,7 +15,7 @@ namespace lowered { class SpecificIterationHandlers { public: SpecificIterationHandlers() = default; - SpecificIterationHandlers(size_t loop_work_amount, size_t loop_increment); + SpecificIterationHandlers(size_t loop_work_amount, size_t loop_increment, size_t processing_dim_idx); SpecificIterationHandlers(pass::PassPipeline first_iter_handlers, pass::PassPipeline main_body_handlers, pass::PassPipeline last_iter_handlers); diff --git a/src/common/snippets/include/snippets/pass/analyze_broadcastable_inputs.hpp b/src/common/snippets/include/snippets/pass/analyze_broadcastable_inputs.hpp index 1cb8122685bde6..4367567c9df1c7 100644 --- a/src/common/snippets/include/snippets/pass/analyze_broadcastable_inputs.hpp +++ b/src/common/snippets/include/snippets/pass/analyze_broadcastable_inputs.hpp @@ -12,7 +12,7 @@ namespace pass { /** * @interface AnalyzeBroadcastableInputs - * @brief Analyzes body parameters which affects inputs of broadcastable operations (If needed, `Broadcast` op should be inserted there).s + * @brief Analyzes body parameters which affects inputs of broadcastable operations (If needed, `Broadcast` op should be inserted there). * Also the pass initializes special map `BroadcastableInputsMap` * Notes: * - Must be called after Canonicalization pass diff --git a/src/common/snippets/include/snippets/runtime_configurator.hpp b/src/common/snippets/include/snippets/runtime_configurator.hpp index af01757cb0194f..169d63ee4baa92 100644 --- a/src/common/snippets/include/snippets/runtime_configurator.hpp +++ b/src/common/snippets/include/snippets/runtime_configurator.hpp @@ -37,6 +37,10 @@ class RuntimeConfig { return get_type_info().name; } +#ifdef SNIPPETS_DEBUG_CAPS + virtual std::string to_string() const; +#endif + size_t tensor_rank = 0; size_t tile_rank = 0; @@ -214,7 +218,8 @@ class RuntimeConfigurator { std::vector m_io_descs = {}; std::vector m_io_data_sizes = {}; // [cluster_id -> buffer expressions ] - std::map> m_dynamic_buffer_clusters; + std::map> m_dynamic_buffer_clusters = {}; + std::vector m_ordered_loop_ids = {}; std::vector m_latest_shapes = {}; }; diff --git a/src/common/snippets/src/generator.cpp b/src/common/snippets/src/generator.cpp index 3629245cc978bd..7ba5e830fd3362 100644 --- a/src/common/snippets/src/generator.cpp +++ b/src/common/snippets/src/generator.cpp @@ -51,9 +51,11 @@ LoweringResult Generator::generate(const lowered::LinearIRPtr& linear_ir, const } result.compiled_snippet = target->get_snippet(); result.kernel_executor_table = target->get_runtime_configurator()->get_kernel_executor_table(); - // Some kernel executors might've been registered during code emission. + // In static case some kernel executors might've been registered during code emission. // We need to update them, so appropriate kernels will be compiled. - result.kernel_executor_table->update_state(linear_ir); + // In dynamic case it should be handled by RuntimeConfigurator + if (!linear_ir->is_dynamic()) + result.kernel_executor_table->update_state(linear_ir); return result; } diff --git a/src/common/snippets/src/lowered/loop_info.cpp b/src/common/snippets/src/lowered/loop_info.cpp index 092d222bde86ec..534159020e4b4f 100644 --- a/src/common/snippets/src/lowered/loop_info.cpp +++ b/src/common/snippets/src/lowered/loop_info.cpp @@ -11,12 +11,11 @@ namespace ov { namespace snippets { namespace lowered { -LoopInfo::LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, bool is_wa_const) - : m_work_amount(work_amount), m_increment(increment), m_input_ports(entries), m_output_ports(exits), m_is_work_amount_const(is_wa_const) {} +LoopInfo::LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits) + : m_work_amount(work_amount), m_increment(increment), m_input_ports(entries), m_output_ports(exits) {} -LoopInfo::LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, - bool is_wa_const) - : m_work_amount(work_amount), m_increment(increment), m_is_work_amount_const(is_wa_const) { +LoopInfo::LoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits) + : m_work_amount(work_amount), m_increment(increment) { m_input_ports.reserve(entries.size()); m_output_ports.reserve(exits.size()); for (const auto& port : entries) @@ -73,10 +72,6 @@ const std::vector& LoopInfo::get_output_ports() const { return m_output_ports; } -bool LoopInfo::is_work_amount_const() const { - return m_is_work_amount_const; -} - void LoopInfo::set_work_amount(size_t work_amount) { m_work_amount = work_amount; } @@ -91,10 +86,6 @@ void LoopInfo::set_dim_idx(size_t dim_idx) { std::for_each(m_output_ports.begin(), m_output_ports.end(), setter); } -void LoopInfo::set_work_amount_const(bool value) { - m_is_work_amount_const = value; -} - template<> std::vector::iterator LoopInfo::find_loop_port(const LoopPort& loop_port) { auto& ports = loop_port.expr_port->get_type() == ExpressionPort::Input ? m_input_ports : m_output_ports; @@ -187,16 +178,16 @@ bool UnifiedLoopInfo::LoopPortDesc::is_dynamic() const { UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, - const SpecificIterationHandlers& handlers, bool is_wa_const) - : LoopInfo(work_amount, increment, entries, exits, is_wa_const), m_handlers(handlers), + const SpecificIterationHandlers& handlers) + : LoopInfo(work_amount, increment, entries, exits), m_handlers(handlers), m_input_port_descs(std::vector(entries.size())), m_output_port_descs(std::vector(exits.size())) { sort_ports(); } UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, - const SpecificIterationHandlers& handlers, bool is_wa_const) - : LoopInfo(work_amount, increment, entries, exits, is_wa_const), m_handlers(handlers), + const SpecificIterationHandlers& handlers) + : LoopInfo(work_amount, increment, entries, exits), m_handlers(handlers), m_input_port_descs(std::vector(entries.size())), m_output_port_descs(std::vector(exits.size())) { sort_ports(); } @@ -204,17 +195,27 @@ UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount, size_t increment, UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, const std::vector& in_shifts, const std::vector& out_shifts, - const SpecificIterationHandlers& handlers, bool is_wa_const) - : LoopInfo(work_amount, increment, entries, exits, is_wa_const), m_handlers(handlers), m_input_port_descs(in_shifts), m_output_port_descs(out_shifts) { + const SpecificIterationHandlers& handlers) + : LoopInfo(work_amount, increment, entries, exits), m_handlers(handlers), m_input_port_descs(in_shifts), m_output_port_descs(out_shifts) { sort_ports(); } -std::shared_ptr UnifiedLoopInfo::clone_with_new_expr(const ExpressionMap& expr_map) const { - const auto& new_input_ports = clone_loop_ports(expr_map, m_input_ports); - const auto& new_output_ports = clone_loop_ports(expr_map, m_output_ports); +std::shared_ptr UnifiedLoopInfo::clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const { + if (loop_map.count(this) == 0) { + const auto& new_input_ports = clone_loop_ports(expr_map, m_input_ports); + const auto& new_output_ports = clone_loop_ports(expr_map, m_output_ports); - return std::make_shared(m_work_amount, m_increment, new_input_ports, new_output_ports, - m_input_port_descs, m_output_port_descs, m_handlers, m_is_work_amount_const); + loop_map[this] = std::make_shared(m_work_amount, m_increment, new_input_ports, new_output_ports, + m_input_port_descs, m_output_port_descs, m_handlers); + } + return loop_map.at(this); +} + +void UnifiedLoopInfo::apply(const std::function& func, LoopInfoSet& applied_loops) { + if (applied_loops.count(this) == 0) { + func(shared_from_this()); + applied_loops.insert(this); + } } bool UnifiedLoopInfo::is_dynamic() const { @@ -364,24 +365,83 @@ void UnifiedLoopInfo::replace_with_new_ports(const ExpressionPort& actual_port, sort_ports(); } +InnerSplittedUnifiedLoopInfo::InnerSplittedUnifiedLoopInfo(size_t increment, const std::vector& entries, const std::vector& exits, + const std::vector& in_descs, const std::vector& out_descs, + const SpecificIterationHandlers& handlers, LoopInfoPtr outer_splitted_loop_info) + : UnifiedLoopInfo(utils::get_dynamic_value(), increment, entries, exits, in_descs, out_descs, handlers), + m_outer_splitted_loop_info(std::move(outer_splitted_loop_info)) { + OPENVINO_ASSERT(m_outer_splitted_loop_info != nullptr, "Outer Splitted Loop Info is missed!"); +} + +std::shared_ptr InnerSplittedUnifiedLoopInfo::clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const { + if (loop_map.count(this) == 0) { + auto cloned_outer_splitted_loop_info = m_outer_splitted_loop_info->clone_with_new_expr(expr_map, loop_map); + const auto& new_input_ports = clone_loop_ports(expr_map, m_input_ports); + const auto& new_output_ports = clone_loop_ports(expr_map, m_output_ports); + + loop_map[this] = std::make_shared(m_increment, new_input_ports, new_output_ports, + m_input_port_descs, m_output_port_descs, m_handlers, + std::move(cloned_outer_splitted_loop_info)); + } + return loop_map.at(this); +} + +void InnerSplittedUnifiedLoopInfo::apply(const std::function& func, LoopInfoSet& applied_loops) { + if (applied_loops.count(this) == 0) { + m_outer_splitted_loop_info->apply(func, applied_loops); + func(shared_from_this()); + applied_loops.insert(this); + } +} + +size_t InnerSplittedUnifiedLoopInfo::get_work_amount() const { + return get_outer_splitted_loop_info()->get_increment(); +} + +LoopInfoPtr InnerSplittedUnifiedLoopInfo::get_outer_splitted_loop_info() const { + OPENVINO_ASSERT(m_outer_splitted_loop_info, "Outer Splitted loop info is nullptr!"); + return m_outer_splitted_loop_info; +} + +void InnerSplittedUnifiedLoopInfo::set_work_amount(size_t work_amount) { + OPENVINO_THROW("InnerSplittedUnifiedLoopInfo doesn't support `set_work_amount`"); +} + +void InnerSplittedUnifiedLoopInfo::set_outer_splitted_loop_info(LoopInfoPtr outer) { + OPENVINO_ASSERT(outer, "Outer Splitted loop info cannot be nullptr!"); + m_outer_splitted_loop_info = std::move(outer); +} + ExpandedLoopInfo::ExpandedLoopInfo(size_t work_amount, size_t increment, const std::vector& entries, const std::vector& exits, std::vector ptr_increments, std::vector final_offsets, std::vector data_sizes, - SpecificLoopIterType type, std::shared_ptr unified_loop_info, bool is_wa_const, bool evaluate_once) - : LoopInfo(work_amount, increment, entries, exits, is_wa_const), + SpecificLoopIterType type, std::shared_ptr unified_loop_info, bool evaluate_once) + : LoopInfo(work_amount, increment, entries, exits), m_ptr_increments(std::move(ptr_increments)), m_finalization_offsets(std::move(final_offsets)), m_data_sizes(std::move(data_sizes)), m_type(type), m_unified_loop_info(std::move(unified_loop_info)), m_evaluate_once(evaluate_once) { OPENVINO_ASSERT(m_unified_loop_info, "Failed to create ExpandedLoopInfo: unified loop info is nullptr!"); sort_ports(); } -std::shared_ptr ExpandedLoopInfo::clone_with_new_expr(const ExpressionMap& expr_map) const { - const auto& new_input_ports = clone_loop_ports(expr_map, m_input_ports); - const auto& new_output_ports = clone_loop_ports(expr_map, m_output_ports); +std::shared_ptr ExpandedLoopInfo::clone_with_new_expr(const ExpressionMap& expr_map, LoopInfoMap& loop_map) const { + if (loop_map.count(this) == 0) { + auto cloned_unified_loop_info = ov::as_type_ptr(m_unified_loop_info->clone_with_new_expr(expr_map, loop_map)); + const auto& new_input_ports = clone_loop_ports(expr_map, m_input_ports); + const auto& new_output_ports = clone_loop_ports(expr_map, m_output_ports); - return std::make_shared(m_work_amount, m_increment, new_input_ports, new_output_ports, - m_ptr_increments, m_finalization_offsets, m_data_sizes, m_type, - m_unified_loop_info, m_is_work_amount_const, m_evaluate_once); + loop_map[this] = std::make_shared(m_work_amount, m_increment, new_input_ports, new_output_ports, + m_ptr_increments, m_finalization_offsets, m_data_sizes, m_type, + std::move(cloned_unified_loop_info), m_evaluate_once); + } + return loop_map.at(this); +} + +void ExpandedLoopInfo::apply(const std::function& func, LoopInfoSet& applied_loops) { + if (applied_loops.count(this) == 0) { + m_unified_loop_info->apply(func, applied_loops); + func(shared_from_this()); + applied_loops.insert(this); + } } bool ExpandedLoopInfo::is_dynamic() const { diff --git a/src/common/snippets/src/lowered/loop_manager.cpp b/src/common/snippets/src/lowered/loop_manager.cpp index 15634edb2c34c7..21f4ecc83c57b0 100644 --- a/src/common/snippets/src/lowered/loop_manager.cpp +++ b/src/common/snippets/src/lowered/loop_manager.cpp @@ -20,8 +20,12 @@ namespace lowered { std::shared_ptr LoopManager::clone_with_new_expr(const ExpressionMap& expr_map) const { auto new_loop_manager = std::make_shared(); + // To fully cloned all LoopInfo we have to create this map [old LoopInfo -> cloned LoopInfo], + // because some LoopInfo types contains pointer to another LoopInfo + // so we should recurrently make a cloning of LoopInfos' + LoopInfoMap loop_info_map; // [ old - > cloned ] for (const auto& id_info : m_map) - new_loop_manager->m_map.insert({id_info.first, id_info.second->clone_with_new_expr(expr_map)}); + new_loop_manager->m_map.insert({id_info.first, id_info.second->clone_with_new_expr(expr_map, loop_info_map)}); new_loop_manager->next_id = next_id; return new_loop_manager; } @@ -273,14 +277,22 @@ void LoopManager::fuse_loops(LinearIR::constExprIt loop_begin_target, LinearIR:: const auto work_amount = std::max(loop_info_upper->get_work_amount(), loop_info_lower->get_work_amount()); const auto increment = std::max(loop_info_upper->get_increment(), loop_info_lower->get_increment()); const auto handlers = SpecificIterationHandlers::merge_handlers(loop_info_upper->get_handlers(), loop_info_lower->get_handlers()); - const auto is_work_amount_const = loop_info_upper->is_work_amount_const() || loop_info_lower->is_work_amount_const(); auto new_entries = std::move(input_ports_upper); new_entries.insert(new_entries.end(), input_ports_lower.begin(), input_ports_lower.end()); auto new_exits = std::move(output_ports_upper); new_exits.insert(new_exits.end(), output_ports_lower.begin(), output_ports_lower.end()); - m_map[to] = std::make_shared(work_amount, increment, new_entries, new_exits, handlers, is_work_amount_const); + m_map[to] = std::make_shared(work_amount, increment, new_entries, new_exits, handlers); + + // Need to handle InnerSplittedLoopInfo - update outer splitted loop info if it was fused + for (const auto& p : m_map) { + if (const auto inner_splitted_loop_info = ov::as_type_ptr(p.second)) { + const auto outer = inner_splitted_loop_info->get_outer_splitted_loop_info(); + if (utils::one_of(outer, loop_info_upper, loop_info_lower)) + inner_splitted_loop_info->set_outer_splitted_loop_info(m_map[to]); + } + } for (auto it = loop_begin_target; it != loop_end_target; ++it) { const auto& expr = *it; diff --git a/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp b/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp index a7336c14454319..d689b183456bc1 100644 --- a/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp +++ b/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp @@ -26,7 +26,6 @@ snippets::lowered::SpecificIterationHandlers BrgemmBlockingBase::get_default_blo const auto tail_size = snippets::utils::is_dynamic_value(work_amount) ? snippets::utils::get_dynamic_value() : work_amount % block_size; if (tail_size != 0) handlers.register_pass(tail_size); - handlers.register_pass(); return handlers; } diff --git a/src/common/snippets/src/lowered/pass/compute_buffer_allocation_size.cpp b/src/common/snippets/src/lowered/pass/compute_buffer_allocation_size.cpp index 3abb254092268a..85bbed324a9865 100644 --- a/src/common/snippets/src/lowered/pass/compute_buffer_allocation_size.cpp +++ b/src/common/snippets/src/lowered/pass/compute_buffer_allocation_size.cpp @@ -27,9 +27,13 @@ std::vector get_parent_inner_loops(const std::vector& parent_loo // Ticket: 113744 // TODO: This logic covers only several specific cases so it should be generalized. size_t ComputeBufferAllocationSize::get_allocation_size(const LoopManagerPtr& loop_manager, const ExpressionPtr& buffer_expr, size_t allocation_rank) { + const auto& current_buffer = ov::as_type_ptr(buffer_expr->get_node()); + OPENVINO_ASSERT(current_buffer, "`get_allocation_size` expected Buffer"); + // Note: Buffer expressions can have more than one parent after the loops splitting transformation, but only the last parent // can be used to access valid loop ports. More info in the ticket: 146646 - const auto& parent_port = buffer_expr->get_input_port_connector(buffer_expr->get_input_count() - 1)->get_source(); + const auto buffer_in_idx = buffer_expr->get_input_count() - 1; + const auto& parent_port = buffer_expr->get_input_port_connector(buffer_in_idx)->get_source(); const auto& parent_loop_ids = get_parent_inner_loops(parent_port.get_expr()->get_loop_ids(), buffer_expr->get_loop_ids()); const auto planar_shape = utils::get_preordered_vdims(parent_port); @@ -38,13 +42,38 @@ size_t ComputeBufferAllocationSize::get_allocation_size(const LoopManagerPtr& lo const auto& subtensor = ov::snippets::utils::get_projected_subtensor(parent_port); + auto hard_equal = [&parent_port](const LoopPort& port) { + return *port.expr_port == parent_port; + }; + auto soft_equal = [&](const LoopPort& loop_port) { + const auto& port = *loop_port.expr_port; + // Check semantic of LoopPort + if (parent_port.get_index() != port.get_index() || + port.get_expr()->get_node()->get_type_info() != parent_port.get_expr()->get_node()->get_type_info()) + return false; + // Check that this LoopPort is connected to the same by semantic Buffer + const auto consumers = port.get_connected_ports(); + for (const auto& consumer : consumers) { + if (const auto buffer_consumer = ov::as_type_ptr(consumer.get_expr()->get_node())) { + if (buffer_consumer->get_cluster_id() == current_buffer->get_cluster_id() && consumer.get_index() == buffer_in_idx) + return true; + } + } + return false; + }; + size_t allocation_size = 1; std::set processed_dim_idxs; for (const auto& parent_loop : parent_loop_ids) { const auto loop_info = loop_manager->get_loop_info(parent_loop); const auto& output_ports = loop_info->get_output_ports(); - auto it = std::find_if(output_ports.begin(), output_ports.end(), [&parent_port](const LoopPort& port) { return *port.expr_port == parent_port; }); - OPENVINO_ASSERT(it != output_ports.end(), "compute_allocation_shape: output port of parent loop can not be found"); + auto it = std::find_if(output_ports.begin(), output_ports.end(), hard_equal); + // [149219] : Try to find original loop port if this LoopInfo is cloned after InsertSpecificIterations + // and ports are not mapped on the original ExpressionPorts + if (it == output_ports.end()) { + it = std::find_if(output_ports.begin(), output_ports.end(), soft_equal); + OPENVINO_ASSERT(it != output_ports.end(), "compute_allocation_shape: output port of parent loop can not be found"); + } const auto& loop_port = *it; const auto& dim_idx = loop_port.dim_idx; if (loop_port.is_incremented && dim_idx < rank) { diff --git a/src/common/snippets/src/lowered/pass/extract_loop_invariants.cpp b/src/common/snippets/src/lowered/pass/extract_loop_invariants.cpp index 6053451be9fafb..f20ace893df463 100644 --- a/src/common/snippets/src/lowered/pass/extract_loop_invariants.cpp +++ b/src/common/snippets/src/lowered/pass/extract_loop_invariants.cpp @@ -14,6 +14,34 @@ namespace snippets { namespace lowered { namespace pass { namespace { + +// Sort Loop IDs by execution order of these Loops +std::vector get_reordered_loop_ids(const LoopManagerPtr& loop_manager) { + const auto& loop_map = loop_manager->get_map(); + std::vector loop_ids_need_extract; + loop_ids_need_extract.reserve(loop_map.size()); + for (const auto& p : loop_map) + loop_ids_need_extract.push_back(p.first); + + auto sorter = [&](size_t lhs, size_t rhs) { + const auto lhs_last_expr = loop_manager->get_loop_info(lhs)->get_output_ports().back().expr_port->get_expr(); + const auto rhs_last_expr = loop_manager->get_loop_info(rhs)->get_output_ports().back().expr_port->get_expr(); + // If last output loop ports are the same expressions - first executive Loop has inner ID in expression loop IDs. + if (lhs_last_expr == rhs_last_expr) { + for (const auto& id : lhs_last_expr->get_loop_ids()) { + if (id == lhs) return false; + if (id == rhs) return true; + } + OPENVINO_THROW("Incorrect Loop IDs"); + } else { + return lhs_last_expr->get_exec_num() < rhs_last_expr->get_exec_num(); + } + }; + + std::sort(loop_ids_need_extract.begin(), loop_ids_need_extract.end(), sorter); + return loop_ids_need_extract; +} + void remove_last_loop_id(const std::shared_ptr& expr) { auto loop_ids = expr->get_loop_ids(); OPENVINO_ASSERT(!loop_ids.empty(), "Expr loop_ids should not be empty when remove last loop id."); @@ -179,22 +207,10 @@ bool ExtractLoopInvariants::run(LinearIR& linear_ir, lowered::LinearIR::constExp OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::ExtractLoopInvariants") bool modified = false; - const auto& loop_depth = linear_ir.get_config().m_loop_depth; - std::vector> loop_ids_need_extract(loop_depth); - const auto& loop_map = linear_ir.get_loop_manager()->get_map(); - for (const auto& loop : loop_map) { - const auto& loop_dim = loop.second->get_dim_idx(); - if (loop_dim != LoopInfo::UNDEFINED_DIM_IDX) { - OPENVINO_ASSERT(loop_dim < loop_depth, "dim_idx of loop should be smaller than loop_depth"); - loop_ids_need_extract[loop_dim].insert(loop.first); - } - } // move invariant expr to top(outside) of current loop - for (size_t d = 0; d < loop_depth; d++) { - const auto& loops_in_this_depth = loop_ids_need_extract[d]; - for (const auto& loop_id : loops_in_this_depth) { - modified |= extract_from_loop(loop_id, linear_ir); - } + const auto loop_ids_need_extract = get_reordered_loop_ids(linear_ir.get_loop_manager()); + for (const auto& loop_id : loop_ids_need_extract) { + modified |= extract_from_loop(loop_id, linear_ir); } return modified; diff --git a/src/common/snippets/src/lowered/pass/fuse_loops.cpp b/src/common/snippets/src/lowered/pass/fuse_loops.cpp index 1673e4ddf712c0..3708896f5abf39 100644 --- a/src/common/snippets/src/lowered/pass/fuse_loops.cpp +++ b/src/common/snippets/src/lowered/pass/fuse_loops.cpp @@ -65,13 +65,18 @@ bool FuseLoops::can_be_fused(const UnifiedLoopInfoPtr& loop_upper, const Unified (work_amount_upper == work_amount_lower) && increment_upper == increment_lower; const bool bcastable_upper = work_amount_upper == 1 && increment_upper == 1; const bool bcastable_lower = work_amount_lower == 1 && increment_lower == 1; - const auto is_const_wa_equal = loop_upper->is_work_amount_const() == loop_lower->is_work_amount_const(); // WA: we can't fuse 2 loops if one of them has first iteration handler but second hasn't, // because in this case Main/Tail body handlers of the loop wo first iter handler must be reset with new parameters // (e.g. tail size). This logic is not implemented for now, so fusion for such loops is skipped. const bool first_iter_handlers_match = loop_upper->get_handlers().get_passes().empty() == loop_lower->get_handlers().get_passes().empty(); - return first_iter_handlers_match && is_const_wa_equal && (is_dynamic_case || equal_parameters || bcastable_upper || bcastable_lower); + // InnerSplittedUnifiedLoops can be fused only if they point to the same outer loop + const auto& ispl_loop_upper = ov::as_type_ptr(loop_upper); + const auto& ispl_loop_lower = ov::as_type_ptr(loop_lower); + const auto& inner_splitted_loop_compatible = + (!ispl_loop_upper && !ispl_loop_lower) || + (ispl_loop_upper && ispl_loop_lower && ispl_loop_upper->get_outer_splitted_loop_info() == ispl_loop_lower->get_outer_splitted_loop_info()); + return first_iter_handlers_match && inner_splitted_loop_compatible && (is_dynamic_case || equal_parameters || bcastable_upper || bcastable_lower); } void FuseLoops::move(LinearIR& linear_ir, const LoopManagerPtr& loop_manager, size_t loop_id, diff --git a/src/common/snippets/src/lowered/pass/init_loops.cpp b/src/common/snippets/src/lowered/pass/init_loops.cpp index 18575131aad306..8e9b62d8fab825 100644 --- a/src/common/snippets/src/lowered/pass/init_loops.cpp +++ b/src/common/snippets/src/lowered/pass/init_loops.cpp @@ -88,8 +88,11 @@ inline int64_t get_ptr_increment(const LoopPort& loop_port, size_t work_amount, } inline int64_t get_finalization_offset(size_t work_amount, int64_t ptr_increment) { - return utils::is_dynamic_value(work_amount) || utils::is_dynamic_value(ptr_increment) ? utils::get_dynamic_value() - : -1 * ptr_increment * work_amount; + if (ptr_increment == 0 || work_amount == 0) + return 0; + if (utils::is_dynamic_value(work_amount) || utils::is_dynamic_value(ptr_increment)) + return utils::get_dynamic_value(); + return -1 * ptr_increment * work_amount; } inline int64_t get_data_size(const LoopPort& loop_port) { @@ -145,7 +148,7 @@ void InitLoops::update_data_pointer_shifts(const UnifiedLoopInfoPtr& loop_info) void InitLoops::update_runtime_parameters(const UnifiedLoopInfoPtr& loop_info) { OPENVINO_ASSERT(loop_info != nullptr, "UnifiedLoopInfo is nullptr, nothing to update"); - if (!loop_info->is_work_amount_const()) + if (!ov::is_type(loop_info)) init_work_amount(loop_info); update_data_pointer_shifts(loop_info); } diff --git a/src/common/snippets/src/lowered/pass/insert_specific_iterations.cpp b/src/common/snippets/src/lowered/pass/insert_specific_iterations.cpp index dcff90015d28f2..badf4b0477759c 100644 --- a/src/common/snippets/src/lowered/pass/insert_specific_iterations.cpp +++ b/src/common/snippets/src/lowered/pass/insert_specific_iterations.cpp @@ -91,14 +91,13 @@ size_t InsertSpecificIterations::get_decomposed_loop_increment(const UnifiedLoop size_t remaining_work_amount) { OPENVINO_ASSERT(unified_loop_info, "UnifiedLoopInfo is missed!"); const auto increment = unified_loop_info->get_increment(); - const auto is_dynamic = utils::is_dynamic_value(remaining_work_amount); switch (type) { case (SpecificLoopIterType::FIRST_ITER): case (SpecificLoopIterType::MAIN_BODY): return increment; case(SpecificLoopIterType::LAST_ITER): - return is_dynamic ? 1 : remaining_work_amount; + return remaining_work_amount; default: OPENVINO_THROW("Unknown SpecificLoopIterType!"); } @@ -167,10 +166,9 @@ bool InsertSpecificIterations::decompose(LinearIR& linear_ir, LinearIR::constExp if (is_decomposed_loop_needed(unified_loop_info, iter_type, remaining_work_amount)) { const auto work_amount = get_decomposed_loop_work_amount(unified_loop_info, iter_type, remaining_work_amount); const auto increment = get_decomposed_loop_increment(unified_loop_info, iter_type, remaining_work_amount); - const auto evaluate_once = !utils::is_dynamic_value(work_amount) && work_amount == increment; // Update remaining Loop work amount // Note: if work_amount is unknown and increment = 1, it means that a loop will iterate by whole work_amount - if (!is_wa_dynamic || increment == 1) { + if (!is_wa_dynamic || increment == 1 || iter_type == SpecificLoopIterType::LAST_ITER) { remaining_work_amount -= work_amount; } @@ -200,7 +198,7 @@ bool InsertSpecificIterations::decompose(LinearIR& linear_ir, LinearIR::constExp const auto decomposed_loop_info = std::make_shared(work_amount, increment, decomposed_loop_entry_ports, decomposed_loop_exit_ports, decomposed_ptr_increments, decomposed_finalization_offsets, - decomposed_data_sizes, iter_type, unified_loop_info, false, evaluate_once); + decomposed_data_sizes, iter_type, unified_loop_info); init_decomposed_loop(linear_ir, decomposed_loop_begin_it, decomposed_loop_end_it, decomposed_loop_info, loop_id, decomposed_loop_end); decomposed = true; diff --git a/src/common/snippets/src/lowered/pass/iter_handler.cpp b/src/common/snippets/src/lowered/pass/iter_handler.cpp index a3ee577338a691..3e035628df476f 100644 --- a/src/common/snippets/src/lowered/pass/iter_handler.cpp +++ b/src/common/snippets/src/lowered/pass/iter_handler.cpp @@ -80,78 +80,17 @@ std::shared_ptr SetFillOffset::merge(const std::shared_ptrget_node(); - const auto loop_end = ov::as_type_ptr(node); - OPENVINO_ASSERT(loop_end, "the last operation in range must be LoopEnd"); - - const auto& loop_manager = linear_ir.get_loop_manager(); - const auto& loop_info = loop_manager->get_loop_info(loop_end->get_id()); - const auto current_dim_idx = loop_info->get_dim_idx(); - OPENVINO_ASSERT(current_dim_idx != LoopInfo::UNDEFINED_DIM_IDX, - "Outer splitted loop unexpectedly iterates by several dimension indices"); - - bool modified = false; - for (auto it = begin; it != end; ++it) { - const auto& expr = *it; - const auto inner_loop_end = ov::as_type_ptr(expr->get_node()); - if (!inner_loop_end) - continue; - // There is already ExpandedLoopInfo - const auto inner_loop_info = loop_manager->get_loop_info(inner_loop_end->get_id()); - const auto inner_dim_idx = inner_loop_info->get_dim_idx(); - if (inner_dim_idx != current_dim_idx) - continue; - // TODO [141735] : At the moment Splitted loops are not supported in dynamic case - OPENVINO_ASSERT(!inner_loop_end->has_dynamic_params(), "inner loop must be static in TransformInnerSplitLoop"); - const auto inner_loop_begin = inner_loop_end->get_loop_begin(); - const auto inner_loop_work_amount = static_cast(inner_loop_end->get_work_amount()); - const auto inner_loop_increment = inner_loop_end->get_increment(); - auto inner_finalization_offsets = inner_loop_end->get_finalization_offsets(); - for (auto& offset : inner_finalization_offsets) { - offset = offset / inner_loop_work_amount * static_cast(m_tail_size); - } - inner_loop_end->set_work_amount(m_tail_size); - // Since the loop has work amount equal to increment of outer loop, not broadcasted dimension, - // we should set `work_amount_const = true` to avoid rewriting in common loop intiialization passes (for example, `InitLoops`) - inner_loop_info->set_work_amount_const(true); - // TODO: if m_tail_size more than inner loop increment, - // handlers of the inner loop must be reset with new tail size - inner_loop_end->set_increment(std::min(inner_loop_increment, m_tail_size)); - inner_loop_end->set_finalization_offsets(inner_finalization_offsets); - const auto inner_loop_begin_it = std::find(begin, it, linear_ir.get_expr_by_node(inner_loop_begin)); - const auto inner_loop_end_it = std::next(it); - OPENVINO_ASSERT(inner_loop_begin_it != it, "LoopBegin has not been found!"); - const auto& last_iter_handlers = inner_loop_info->get_unified_loop_info()->get_handlers().get_passes(); - last_iter_handlers.run(linear_ir, std::next(inner_loop_begin_it), inner_loop_end_it); - modified = true; - } - return modified; -} - -std::shared_ptr TransformInnerSplitLoop::merge(const std::shared_ptr& other) { - const auto merged_pass = std::make_shared(m_tail_size); - if (other == nullptr) - return merged_pass; - const auto casted_pass = ov::as_type_ptr(other); - if (!casted_pass || m_tail_size != casted_pass->m_tail_size) - return nullptr; - return merged_pass; -} - -bool SetEvaluateOnce::run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) { +bool SetLoopIncrementOne::run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) { const auto& loop_end = ov::as_type_ptr(end->get()->get_node()); - OPENVINO_ASSERT(loop_end, "SetEvaluateOnce expected LoopEnd node in iterator `end`."); + OPENVINO_ASSERT(loop_end, "SetLoopIncrementOne expected LoopEnd node in iterator `end`."); const auto& loop_info = linear_ir.get_loop_manager()->get_loop_info(loop_end->get_id()); - loop_info->set_evaluate_once(true); + loop_info->set_increment(1); + loop_end->set_increment(1); return true; } -std::shared_ptr SetEvaluateOnce::merge(const std::shared_ptr& other) { - return !other || ov::is_type(other) ? std::make_shared() : nullptr; +std::shared_ptr SetLoopIncrementOne::merge(const std::shared_ptr& other) { + return !other || ov::is_type(other) ? std::make_shared() : nullptr; } } // namespace pass diff --git a/src/common/snippets/src/lowered/pass/optimize_loop_single_evaluation.cpp b/src/common/snippets/src/lowered/pass/optimize_loop_single_evaluation.cpp index c6255d90106e77..24ba946c92382b 100644 --- a/src/common/snippets/src/lowered/pass/optimize_loop_single_evaluation.cpp +++ b/src/common/snippets/src/lowered/pass/optimize_loop_single_evaluation.cpp @@ -24,7 +24,7 @@ bool OptimizeLoopSingleEvaluation::run(lowered::LinearIR& linear_ir, lowered::Li const auto& expr = *expr_it; if (auto loop_end = ov::as_type_ptr(expr->get_node())) { const auto& loop_info = loop_manager->get_loop_info(loop_end->get_id()); - if (loop_info->is_evaluate_once()) { + if (loop_info->get_work_amount() == loop_info->get_increment()) { auto new_finalization_offsets = loop_end->get_finalization_offsets(); const auto& ptr_increments = loop_end->get_ptr_increments(); const auto work_amount_incr = static_cast(loop_end->get_increment()); @@ -39,6 +39,7 @@ bool OptimizeLoopSingleEvaluation::run(lowered::LinearIR& linear_ir, lowered::Li // Update the corresponding ExpandedLoopInfo loop_info->update_ptr_increments(loop_end->get_ptr_increments()); loop_info->update_finalization_offsets(loop_end->get_finalization_offsets()); + loop_info->set_evaluate_once(true); is_modified = true; } diff --git a/src/common/snippets/src/lowered/pass/split_loops.cpp b/src/common/snippets/src/lowered/pass/split_loops.cpp index 348347c35dd975..e6c59d502d4804 100644 --- a/src/common/snippets/src/lowered/pass/split_loops.cpp +++ b/src/common/snippets/src/lowered/pass/split_loops.cpp @@ -5,6 +5,7 @@ #include "snippets/lowered/pass/split_loops.hpp" #include "snippets/lowered/pass/fuse_loops.hpp" +#include "snippets/lowered/pass/init_loops.hpp" #include "snippets/lowered/linear_ir.hpp" #include "snippets/lowered/loop_manager.hpp" #include "snippets/lowered/pass/iter_handler.hpp" @@ -16,8 +17,6 @@ namespace snippets { namespace lowered { namespace pass { -SplitLoops::SplitLoops() : RangedPass() {} - bool SplitLoops::can_be_split(const UnifiedLoopInfoPtr& loop_to_split, const UnifiedLoopInfoPtr& loop_to_fuse) { OPENVINO_ASSERT(loop_to_split != nullptr && loop_to_fuse != nullptr, "LoopInfo is nullptr!"); const auto current_dim_idx = loop_to_split->get_dim_idx(); @@ -26,9 +25,7 @@ bool SplitLoops::can_be_split(const UnifiedLoopInfoPtr& loop_to_split, const Uni const bool equal_dim_idxes = current_dim_idx != LoopInfo::UNDEFINED_DIM_IDX && current_dim_idx == parent_dim_idx; const bool only_main_body = handlers.get_passes().empty() && handlers.get_passes().empty(); - // TODO [141735] : At the moment Splitted loops are not supported in dynamic case - const auto are_static = !loop_to_split->is_dynamic() && !loop_to_fuse->is_dynamic(); - return are_static && loop_to_split->get_work_amount() == loop_to_fuse->get_work_amount() && + return loop_to_split->get_work_amount() == loop_to_fuse->get_work_amount() && loop_to_split->get_increment() != loop_to_fuse->get_increment() && equal_dim_idxes && only_main_body; } @@ -70,32 +67,8 @@ bool SplitLoops::run(LinearIR& linear_ir, lowered::LinearIR::constExprIt begin, const auto& loop_to_fuse = !split_parent ? parent_loop : loop; // We don't split loop which are not compatible with parent loop because such loops will not be fused if (FuseLoops::can_be_fused(upper_loop, lower_loop) && can_be_split(loop_to_split, loop_to_fuse)) { + split(linear_ir, split_parent ? parent_loop_id : loop_id, loop_to_fuse->get_increment()); loop_was_split = true; - loop_to_split->set_work_amount(loop_to_fuse->get_increment()); - // Since the loop has work amount equal to increment of outer loop, not broadcasted dimension, - // we should set `work_amount_const = true` to avoid rewriting in common loop intiialization passes (for example, `InitLoops`) - loop_to_split->set_work_amount_const(true); - - const auto& loop_to_split_id = split_parent ? parent_loop_id : loop_id; - const auto loop_bounds = LoopManager::get_loop_bounds(linear_ir, loop_to_split_id, - loop_to_split->get_input_ports(), - loop_to_split->get_output_ports()); - const auto split_loop_id = loop_manager->mark_loop(loop_bounds.first, - loop_bounds.second, - loop_to_fuse->get_work_amount(), - loop_to_fuse->get_increment(), - loop_to_split->get_dim_idx(), - loop_to_split->get_input_ports(), - loop_to_split->get_output_ports()); - const auto& new_loop_info = loop_manager->get_loop_info(split_loop_id); - const auto work_amount = loop_to_fuse->get_work_amount(); - const auto increment = loop_to_fuse->get_increment(); - const auto tail_size = work_amount % increment; - auto new_handlers = loop_to_split->get_handlers(); - if (tail_size != 0) { - new_handlers.register_pass(tail_size); - } - new_loop_info->set_handlers(new_handlers); break; } } @@ -107,6 +80,108 @@ bool SplitLoops::run(LinearIR& linear_ir, lowered::LinearIR::constExprIt begin, FuseLoops().run(linear_ir, begin, end); return loop_was_split; } + +void SplitLoops::split(LinearIR& linear_ir, size_t loop_to_split_id, size_t outer_increment) { + const auto& loop_manager = linear_ir.get_loop_manager(); + + const auto& inner_loop_info = loop_manager->get_loop_info(loop_to_split_id); + const auto loop_bounds = LoopManager::get_loop_bounds(linear_ir, loop_to_split_id, + inner_loop_info->get_input_ports(), + inner_loop_info->get_output_ports()); + const auto outer_loop_id = loop_manager->mark_loop(loop_bounds.first, loop_bounds.second, inner_loop_info->get_work_amount(), + outer_increment, inner_loop_info->get_dim_idx(), + inner_loop_info->get_input_ports(), inner_loop_info->get_output_ports(), false); + const auto& outer_loop_info = loop_manager->get_loop_info(outer_loop_id); + + const auto& inner_splitted_loop_info = + std::make_shared(inner_loop_info->get_increment(), inner_loop_info->get_input_ports(), + inner_loop_info->get_output_ports(), inner_loop_info->get_input_port_descs(), + inner_loop_info->get_output_port_descs(), inner_loop_info->get_handlers(), + outer_loop_info); + loop_manager->replace_with_new_loop(linear_ir, loop_bounds.first, loop_bounds.second, inner_splitted_loop_info, loop_to_split_id); + + if (!outer_loop_info->get_handlers().get_passes().empty()) { + outer_loop_info->register_pass_to_handler(); + } + outer_loop_info->register_pass_to_handler(); + outer_loop_info->register_pass_to_handler(); +} + +namespace { +InnerSplittedUnifiedLoopInfoPtr make_own_inner_splitted_unified_loop_info(const ExpandedLoopInfoPtr& inner_expanded, + const ExpandedLoopInfoPtr& outer_expanded, + const InnerSplittedUnifiedLoopInfoPtr& existing_inner_unified) { + const auto loop_info = + std::make_shared(inner_expanded->get_increment(), inner_expanded->get_input_ports(), + inner_expanded->get_output_ports(), existing_inner_unified->get_input_port_descs(), + existing_inner_unified->get_output_port_descs(), existing_inner_unified->get_handlers(), + outer_expanded); + InitLoops::update_runtime_parameters(loop_info); + return loop_info; +} +ExpandedLoopInfoPtr make_own_inner_splitted_expanded_loop_info(const ExpandedLoopInfoPtr& inner_expanded, + const InnerSplittedUnifiedLoopInfoPtr& inner_unified) { + return std::make_shared(inner_unified->get_work_amount(), inner_unified->get_increment(), + inner_unified->get_input_ports(), inner_unified->get_output_ports(), + inner_unified->get_ptr_increments(), + inner_unified->get_finalization_offsets(), + inner_unified->get_data_sizes(), inner_expanded->get_type(), + inner_unified, inner_expanded->is_evaluate_once()); +} +} // namespace + +bool SplitLoops::TransformInnerSplitLoop::run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) { + OPENVINO_ASSERT(end != linear_ir.cend(), "Incorrect LinearIR range for processing"); + const auto& expr = *end; + const auto node = expr->get_node(); + const auto loop_end = ov::as_type_ptr(node); + OPENVINO_ASSERT(loop_end, "the last operation in range must be LoopEnd"); + + const auto& loop_manager = linear_ir.get_loop_manager(); + const auto& outer_loop_info = loop_manager->get_loop_info(loop_end->get_id()); + const auto current_dim_idx = outer_loop_info->get_dim_idx(); + OPENVINO_ASSERT(current_dim_idx != LoopInfo::UNDEFINED_DIM_IDX, + "Outer splitted loop unexpectedly iterates by several dimension indices"); + + bool modified = false; + for (auto it = begin; it != end; ++it) { + const auto& expr = *it; + const auto inner_loop_end = ov::as_type_ptr(expr->get_node()); + if (!inner_loop_end) + continue; + + // There is already ExpandedLoopInfo + const auto& inner_expanded_loop_info = loop_manager->get_loop_info(inner_loop_end->get_id()); + const auto inner_unified_loop_info = ov::as_type_ptr(inner_expanded_loop_info->get_unified_loop_info()); + if (!inner_unified_loop_info || inner_unified_loop_info->get_outer_splitted_loop_info() != outer_loop_info->get_unified_loop_info()) + continue; + + OPENVINO_ASSERT(current_dim_idx == inner_unified_loop_info->get_dim_idx(), "Incorrect processing dim index of splitted loops"); + OPENVINO_ASSERT(inner_expanded_loop_info->get_type() == SpecificLoopIterType::MAIN_BODY, "InnerSplittedLoop must be Main Body of loop"); + + // We have to make a new UnifiedLoopInfo to distinguish it from other unified loops in other specific iterations of outer loop. + const auto inner_splitted_unified_loop_info = make_own_inner_splitted_unified_loop_info(inner_expanded_loop_info, outer_loop_info, + inner_unified_loop_info); + + // We have to replace existing ExpandedLoopInfo with new one to have the own InnerSplittedUnifiedLoopInfo and + // distinguish it from other expanded loops in other specific iterations of outer loop. + const auto new_expanded_inner_loop_info = make_own_inner_splitted_expanded_loop_info(inner_expanded_loop_info, inner_splitted_unified_loop_info); + const auto inner_begin = linear_ir.find_before(it, linear_ir.get_expr_by_node(inner_loop_end->get_loop_begin())); + const auto new_id = loop_manager->replace_with_new_loop(linear_ir, inner_begin, std::next(it), new_expanded_inner_loop_info, inner_loop_end->get_id()); + + // [147894] : Update inner LoopEnd expression + inner_loop_end->set_id(new_id); + inner_loop_end->set_work_amount(new_expanded_inner_loop_info->get_work_amount()); + inner_loop_end->set_increment(new_expanded_inner_loop_info->get_increment()); + inner_loop_end->set_finalization_offsets(new_expanded_inner_loop_info->get_finalization_offsets()); + } + return modified; +} + +std::shared_ptr SplitLoops::TransformInnerSplitLoop::merge(const std::shared_ptr& other) { + return !other || ov::is_type(other) ? std::make_shared() : nullptr; +} + } // namespace pass } // namespace lowered } // namespace snippets diff --git a/src/common/snippets/src/lowered/pass/validate_expanded_loops.cpp b/src/common/snippets/src/lowered/pass/validate_expanded_loops.cpp index cc598b4e768cd4..ec77d75fe3ff43 100644 --- a/src/common/snippets/src/lowered/pass/validate_expanded_loops.cpp +++ b/src/common/snippets/src/lowered/pass/validate_expanded_loops.cpp @@ -43,49 +43,51 @@ void ValidateExpandedLoops::validate_loop_information(const LinearIR& linear_ir) const auto& loop_manager = linear_ir.get_loop_manager(); const auto& loop_map = loop_manager->get_map(); - UnifiedLoopInfoPtr current_unified_loop_info = nullptr; - std::vector total_finalization_offsets; - size_t current_work_amount = 0; - size_t num_ports = 0; + // Initialized UnifiedLoopInfo + struct CurrentUnifiedLoopInfo { + size_t work_amount = 0; + size_t num_ports = 0; + size_t id = 0; + std::vector finalization_offsets; + }; + std::unordered_map initializated_info_map; for (const auto& p : loop_map) { const auto& expanded_loop_info = ov::as_type_ptr(p.second); INFORMATIVE_ASSERT(expanded_loop_info, "expects only ExpandedLoopInfo in LoopManager"); - const auto& unified_loop_info = expanded_loop_info->get_unified_loop_info(); - INFORMATIVE_ASSERT(unified_loop_info, "expects non nullptr UnifiedLoopInfo in ExpandedLoopInfo"); + const auto& current_unified_loop_info = expanded_loop_info->get_unified_loop_info(); + INFORMATIVE_ASSERT(current_unified_loop_info, "expects non nullptr UnifiedLoopInfo in ExpandedLoopInfo"); - if (unified_loop_info != current_unified_loop_info) { - // If there is `current_unified_loop_info` - the previos loop is finished and need to validate total information - if (current_unified_loop_info) { - INFORMATIVE_ASSERT(current_work_amount == current_unified_loop_info->get_work_amount(), - "total work amount of expanded loops is not equal to work amount of undefined loop"); - INFORMATIVE_ASSERT(total_finalization_offsets == current_unified_loop_info->get_finalization_offsets(), - "total finalization offsets are not equal to finalization offsets of undefined loop"); - } - - current_unified_loop_info = unified_loop_info; - - INFORMATIVE_ASSERT(current_unified_loop_info->get_input_count() == expanded_loop_info->get_input_count() && - current_unified_loop_info->get_output_count() == expanded_loop_info->get_output_count(), - "incompatible loop ports with UnifiedLoopInfo"); - - current_work_amount = 0; - num_ports = expanded_loop_info->get_input_count() + expanded_loop_info->get_output_count(); - total_finalization_offsets.clear(); - total_finalization_offsets.resize(num_ports, 0); + auto& current_info = initializated_info_map[current_unified_loop_info]; + if (current_info.num_ports == 0) { // the info was just default constructed + current_info.num_ports = current_unified_loop_info->get_input_count() + current_unified_loop_info->get_output_count(); + current_info.finalization_offsets.resize(current_info.num_ports, 0); } - current_work_amount = utils::dynamic_safe_add(current_work_amount, expanded_loop_info->get_work_amount()); - INFORMATIVE_ASSERT(current_unified_loop_info, "expects non nullptr current UnifiedLoopInfo"); + INFORMATIVE_ASSERT(current_unified_loop_info->get_input_count() == expanded_loop_info->get_input_count() && + current_unified_loop_info->get_output_count() == expanded_loop_info->get_output_count(), + "incompatible loop ports with UnifiedLoopInfo"); + + current_info.work_amount = utils::dynamic_safe_add(current_info.work_amount, expanded_loop_info->get_work_amount()); INFORMATIVE_ASSERT(current_unified_loop_info->get_ptr_increments() == expanded_loop_info->get_ptr_increments(), "incompatible pointer increments with UnifiedLoopInfo"); const auto& finalization_offsets = expanded_loop_info->get_finalization_offsets(); - INFORMATIVE_ASSERT(finalization_offsets.size() == total_finalization_offsets.size(), + INFORMATIVE_ASSERT(finalization_offsets.size() == current_info.finalization_offsets.size(), "incompatible finalization offset count"); - for (size_t i = 0; i < num_ports; ++i) - total_finalization_offsets[i] = utils::dynamic_safe_add(total_finalization_offsets[i], finalization_offsets[i]); + for (size_t i = 0; i < current_info.num_ports; ++i) + current_info.finalization_offsets[i] = utils::dynamic_safe_add(current_info.finalization_offsets[i], finalization_offsets[i]); + } + + // Validation of total information + for (const auto& p : initializated_info_map) { + const auto loop_info = p.first; + const auto total_info = p.second; + INFORMATIVE_ASSERT(total_info.work_amount == loop_info->get_work_amount(), + "total work amount of expanded loops is not equal to work amount of undefined loop with ID: " + std::to_string(total_info.id)); + INFORMATIVE_ASSERT(total_info.finalization_offsets == loop_info->get_finalization_offsets(), + "total finalization offsets are not equal to finalization offsets of undefined loop with ID: " + std::to_string(total_info.id)); } } diff --git a/src/common/snippets/src/lowered/specific_loop_iter_handlers.cpp b/src/common/snippets/src/lowered/specific_loop_iter_handlers.cpp index ffc00cdd08e50a..c1302084aa68f7 100644 --- a/src/common/snippets/src/lowered/specific_loop_iter_handlers.cpp +++ b/src/common/snippets/src/lowered/specific_loop_iter_handlers.cpp @@ -13,11 +13,23 @@ namespace ov { namespace snippets { namespace lowered { -SpecificIterationHandlers::SpecificIterationHandlers(size_t loop_work_amount, size_t loop_increment) { - const auto tail_size = utils::is_dynamic_value(loop_work_amount) ? 1lu : loop_work_amount % loop_increment; - if (tail_size != 0) { - m_last_iter_handlers.register_pass(tail_size); - m_last_iter_handlers.register_pass(tail_size); +SpecificIterationHandlers::SpecificIterationHandlers(size_t loop_work_amount, size_t loop_increment, size_t processing_dim_idx) { + // The following handlers are set only for Last Iter processing + if (loop_increment > 1) { + size_t last_iter_increment = utils::get_dynamic_value(); + if (!utils::is_dynamic_value(loop_work_amount)) { + last_iter_increment = loop_work_amount % loop_increment; + } else if (utils::is_dynamic_value(loop_work_amount) && processing_dim_idx == 0) { + // [149935] : Last Iterations of Loop processed last dimensions with Eltwise nodes inside should have increment = 1 + last_iter_increment = 1; + } + if (last_iter_increment != 0) { + m_last_iter_handlers.register_pass(last_iter_increment); + m_last_iter_handlers.register_pass(last_iter_increment); + // Last Iterations of Loop processed last dimensions with Eltwise nodes inside should have increment = 1 + if (last_iter_increment == 1) + m_last_iter_handlers.register_pass(); + } } } diff --git a/src/common/snippets/src/runtime_configurator.cpp b/src/common/snippets/src/runtime_configurator.cpp index e22e4b3bee57fb..552455b89f5529 100644 --- a/src/common/snippets/src/runtime_configurator.cpp +++ b/src/common/snippets/src/runtime_configurator.cpp @@ -17,6 +17,24 @@ namespace snippets { using namespace ov::snippets::pass; using namespace ov::snippets::lowered; +#ifdef SNIPPETS_DEBUG_CAPS +std::string RuntimeConfig::to_string() const { + std::stringstream out; + out << " ========== RuntimeConfig state ==========\n" << + "tensor_rank: " << tensor_rank << "\n" << + "tile_rank: " << tile_rank << "\n" << + "master_shape: " << ov::Shape(master_shape) << "\n"; + out << "io_data_offsets: " << "\n"; + for (size_t i = 0; i < io_data_offsets.size(); ++i) + out << "\t[" << i << "]" << ov::Shape(io_data_offsets[i]) << "\n"; + out << "buffer_scratchpad_size: " << buffer_scratchpad_size << "\n"; + out << "buffer_cluster_offsets: " << "\n"; + for (size_t i = 0; i < buffer_cluster_offsets.size(); ++i) + out << "\t[" << i << "]" << buffer_cluster_offsets[i] << "\n"; + return out.str(); +} +#endif + RuntimeConfigurator::RuntimeConfigurator(std::shared_ptr c) : m_config(std::move(c)) { OPENVINO_ASSERT(m_config, "Runtime config is nullptr!"); @@ -45,6 +63,21 @@ void RuntimeConfigurator::initialization(const lowered::LinearIRCPtr& linear_ir) m_config->io_data_offsets.resize(m_io_num); m_config->tile_rank = linear_ir->get_config().m_loop_depth; m_optimizer.init(linear_ir, m_io_descs, m_in_num); + + // InnerSplittedLoops should be inited after OuterSplittedLoops + const auto& loop_map = linear_ir->get_loop_manager()->get_map(); + m_ordered_loop_ids.clear(); + m_ordered_loop_ids.reserve(loop_map.size()); + std::vector loops_must_be_last; + for (const auto& p : loop_map) { + const auto loop_id = p.first; + const auto& expanded_loop_info = ov::as_type_ptr(p.second); + OPENVINO_ASSERT(expanded_loop_info, "UpdateLoopInfo expects ExpandedLoopInfo in LoopManager"); + const auto& unified_loop_info = expanded_loop_info->get_unified_loop_info(); + auto& collection = ov::is_type(unified_loop_info) ? loops_must_be_last : m_ordered_loop_ids; + collection.push_back(loop_id); + } + m_ordered_loop_ids.insert(m_ordered_loop_ids.end(), loops_must_be_last.cbegin(), loops_must_be_last.cend()); } void RuntimeConfigurator::update(const lowered::LinearIRCPtr& linear_ir) { @@ -152,18 +185,17 @@ void RuntimeConfigurator::init_buffer_info(const lowered::LinearIRCPtr& linear_i void RuntimeConfigurator::update_loop_info(const lowered::LinearIRCPtr& linear_ir, LoopInfoRuntimeParamsMap& initializated_info_map) const { - const auto& loop_map = linear_ir->get_loop_manager()->get_map(); - for (const auto& p : loop_map) { - const auto& expanded_loop_info = ov::as_type_ptr(p.second); - OPENVINO_ASSERT(expanded_loop_info, "UpdateLoopInfo expects ExpandedLoopInfo in LoopManager"); + auto update_unified_loop_info = [&](const lowered::UnifiedLoopInfoPtr& unified_loop_info) { + if (initializated_info_map.count(unified_loop_info) == 0) { + lowered::pass::InitLoops::update_runtime_parameters(unified_loop_info); + initializated_info_map[unified_loop_info] = compute_runtime_params(unified_loop_info); + } + }; - // First visiting of unified (whole) loop + auto update_expanded_loop_info = [&](const lowered::ExpandedLoopInfoPtr& expanded_loop_info) { const auto& current_unified_loop_info = expanded_loop_info->get_unified_loop_info(); - if (initializated_info_map.count(current_unified_loop_info) == 0) { - lowered::pass::InitLoops::update_runtime_parameters(current_unified_loop_info); - initializated_info_map[current_unified_loop_info] = compute_runtime_params(current_unified_loop_info); - } + OPENVINO_ASSERT(initializated_info_map.count(current_unified_loop_info) > 0, "UnifiedLoopInfo must be updated before ExpandedLoopInfo"); auto& initializated_info = initializated_info_map.at(current_unified_loop_info); auto& current_work_amount = initializated_info.work_amount; const auto& ptr_increments = initializated_info.ptr_increments; @@ -176,7 +208,7 @@ void RuntimeConfigurator::update_loop_info(const lowered::LinearIRCPtr& linear_i expanded_loop_info->set_work_amount(0); if (expanded_loop_info->is_evaluate_once()) expanded_loop_info->set_increment(0); - continue; + return; } const auto work_amount = @@ -196,6 +228,22 @@ void RuntimeConfigurator::update_loop_info(const lowered::LinearIRCPtr& linear_i expanded_loop_info->update_ptr_increments(ptr_increments); } expanded_loop_info->update_finalization_offsets(updated_finalization_offsets); + }; + + auto update_loop_info = [&](const lowered::LoopInfoPtr& loop_info) { + if (const auto unified_loop_info = ov::as_type_ptr(loop_info)) { + update_unified_loop_info(unified_loop_info); + } else if (const auto expanded_loop_info = ov::as_type_ptr(loop_info)) { + update_expanded_loop_info(expanded_loop_info); + } else { + OPENVINO_THROW("Failed to update loop info: unknown type!"); + } + }; + + lowered::LoopInfoSet updated_loops; + const auto& loop_map = linear_ir->get_loop_manager()->get_map(); + for (const auto& p : loop_map) { + p.second->apply(update_loop_info, updated_loops); } } @@ -203,6 +251,12 @@ void RuntimeConfigurator::update_buffer_scratchpad_size(const lowered::LinearIRC const auto& loop_manager = linear_ir->get_loop_manager(); m_config->buffer_scratchpad_size = linear_ir->get_static_buffer_scratchpad_size(); + auto is_not_executed = [&loop_manager](const lowered::ExpressionPtr& buffer_expr) { + const auto& loop_ids = buffer_expr->get_loop_ids(); + return std::any_of(loop_ids.cbegin(), loop_ids.cend(), + [&loop_manager](size_t loop_id) { return loop_manager->get_loop_info(loop_id)->get_work_amount() == 0; }); + }; + for (const auto& p : m_dynamic_buffer_clusters) { const auto& cluster_id = p.first; const auto& cluster = p.second; @@ -212,13 +266,16 @@ void RuntimeConfigurator::update_buffer_scratchpad_size(const lowered::LinearIRC size_t additional_size = 0; for (const auto& buffer_expr : cluster) { + // No need to calculate allocation size of Buffers which are in Loops with `work_amount = 0` - they won't be executed + if (is_not_executed(buffer_expr)) + continue; const auto& allocation_size = lowered::pass::ComputeBufferAllocationSize::get_allocation_size(loop_manager, buffer_expr, m_config->tile_rank); + OPENVINO_ASSERT(!utils::is_dynamic_value(allocation_size), "Buffer scratchpad size must be defined!"); additional_size = std::max(allocation_size * buffer_expr->get_node()->get_element_type().size(), additional_size); } cluster_offset = m_config->buffer_scratchpad_size; OPENVINO_ASSERT(!utils::is_dynamic_value(cluster_offset), "Offset of the cluster must be defined!"); - OPENVINO_ASSERT(!utils::is_dynamic_value(additional_size), "Buffer scratchpad size must be defined!"); m_config->buffer_scratchpad_size += additional_size; } diff --git a/src/common/snippets/tests/src/lowered/pass/extracted_loop_invariants.cpp b/src/common/snippets/tests/src/lowered/pass/extracted_loop_invariants.cpp index db58805a8f023b..3e148d3c1cf329 100644 --- a/src/common/snippets/tests/src/lowered/pass/extracted_loop_invariants.cpp +++ b/src/common/snippets/tests/src/lowered/pass/extracted_loop_invariants.cpp @@ -7,12 +7,8 @@ #include "openvino/opsets/opset10.hpp" #include "snippets/lowered/pass/extract_loop_invariants.hpp" #include "snippets/lowered/pass/normalize_loop_ids.hpp" -#include "snippets/op/broadcastmove.hpp" -#include "snippets/op/scalar.hpp" -#include "snippets/op/vector_buffer.hpp" -#include "snippets/op/horizon_max.hpp" -#include "snippets/op/horizon_sum.hpp" -#include "snippets/op/powerstatic.hpp" +#include "snippets/lowered/pass/split_loops.hpp" +#include "snippets/snippets_isa.hpp" namespace ov { namespace test { @@ -292,6 +288,76 @@ TEST_F(ExtractLoopInvariantsTest, ExtractedLoopInvariantsFromInnermostToLoopOuts } } +TEST_F(ExtractLoopInvariantsTest, ExtractedLoopInvariantsSplitLoops) { + size_t vector_size = 16; + size_t block_size = 32; + const auto input_precision = ov::element::f32; + const ov::Shape input_shape_0{128, 512}; + const ov::Shape input_shape_1{512, 64}; + const ov::Shape input_shape_2{1, 1}; + const ov::snippets::VectorDims layout{0, 1}; + const ov::snippets::VectorDims subtensor{1, vector_size}; + /* + * Params Param2(1,1) + * \ / + * MatMul Broadcast + * \ / + * Add + * | + * Result + */ + { + const auto param0 = linear_ir->push_node(input_precision, input_shape_0); + const auto param1 = linear_ir->push_node(input_precision, input_shape_1); + const auto param2 = linear_ir->push_node(input_precision, input_shape_2); + const auto matmul = linear_ir->push_node(param0.second, param1.second); + const auto broadcastmove = linear_ir->push_node(param2.second, input_shape_1.back()); + init_expr_descriptors(*broadcastmove.first, {{1, 1}, subtensor}, {layout, layout}); + const auto add = linear_ir->push_node(matmul.second, broadcastmove.second); + init_expr_descriptors(*add.first, {subtensor, subtensor, subtensor}, {layout, layout, layout}); + const auto result = linear_ir->push_node(add.second); + const auto& loop_manager = linear_ir->get_loop_manager(); + loop_manager->mark_loop(matmul.first, broadcastmove.first, 128, block_size, 1, + std::vector{LoopPort((*matmul.first)->get_input_port(0)), + LoopPort((*matmul.first)->get_input_port(1), false)}, + std::vector{LoopPort((*matmul.first)->get_output_port(0))}); + loop_manager->mark_loop(broadcastmove.first, result.first, 64, vector_size, 0, + std::vector{LoopPort((*broadcastmove.first)->get_input_port(0)), + LoopPort((*add.first)->get_input_port(0))}, + std::vector{LoopPort((*add.first)->get_output_port(0))}); + loop_manager->mark_loop(broadcastmove.first, result.first, 128, 1, 1, + std::vector{LoopPort((*broadcastmove.first)->get_input_port(0)), + LoopPort((*add.first)->get_input_port(0))}, + std::vector{LoopPort((*add.first)->get_output_port(0))}); + ov::snippets::lowered::pass::SplitLoops().run(*linear_ir, linear_ir->begin(), linear_ir->end()); + } + { + const auto param0 = linear_ir_ref->push_node(input_precision, input_shape_0); + const auto param1 = linear_ir_ref->push_node(input_precision, input_shape_1); + const auto param2 = linear_ir_ref->push_node(input_precision, input_shape_2); + auto broadcastmove = linear_ir_ref->push_node(param2.second, input_shape_1.back()); + init_expr_descriptors(*broadcastmove.first, {{1, 1}, subtensor}, {layout, layout}); + const auto matmul = linear_ir_ref->push_node(param0.second, param1.second); + const auto add = linear_ir_ref->push_node(matmul.second, broadcastmove.second); + init_expr_descriptors(*add.first, {subtensor, subtensor, subtensor}, {layout, layout, layout}); + auto result = linear_ir_ref->push_node(add.second); + const auto& loop_manager = linear_ir_ref->get_loop_manager(); + loop_manager->mark_loop(matmul.first, add.first, 128, block_size, 1, + std::vector{LoopPort((*matmul.first)->get_input_port(0)), + LoopPort((*matmul.first)->get_input_port(1), false)}, + std::vector{LoopPort((*matmul.first)->get_output_port(0))}); + loop_manager->mark_loop(add.first, result.first, 64, vector_size, 0, + std::vector{LoopPort((*add.first)->get_input_port(0)), + LoopPort((*add.first)->get_input_port(1))}, + std::vector{LoopPort((*add.first)->get_output_port(0))}); + loop_manager->mark_loop(add.first, result.first, 128, 1, 1, + std::vector{LoopPort((*add.first)->get_input_port(0)), + LoopPort((*add.first)->get_input_port(1))}, + std::vector{LoopPort((*add.first)->get_output_port(0))}); + ov::snippets::lowered::pass::SplitLoops().run(*linear_ir_ref, linear_ir_ref->begin(), linear_ir_ref->end()); + } +} + class ExtractLoopInvariantsRemoveLoopsTest : public LoweredPassTestsF { public: ExtractLoopInvariantsRemoveLoopsTest() : LoweredPassTestsF() { diff --git a/src/common/snippets/tests/src/lowered/pass/loop.cpp b/src/common/snippets/tests/src/lowered/pass/loop.cpp index a7214c755f5ed6..610b98e558760f 100644 --- a/src/common/snippets/tests/src/lowered/pass/loop.cpp +++ b/src/common/snippets/tests/src/lowered/pass/loop.cpp @@ -2,23 +2,23 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "snippets/op/loop.hpp" - #include +#include "openvino/opsets/opset10.hpp" +#include "snippets/snippets_isa.hpp" #include "snippets/lowered/linear_ir.hpp" #include "snippets/lowered/pass/cleanup_loop_offsets.hpp" #include "snippets/lowered/pass/init_loops.hpp" #include "snippets/lowered/pass/insert_load_store.hpp" #include "snippets/lowered/pass/insert_loops.hpp" #include "snippets/lowered/pass/insert_specific_iterations.hpp" -#include "snippets/lowered/pass/iter_handler.hpp" +#include "snippets/lowered/pass/split_loops.hpp" +#include "snippets/lowered/pass/insert_buffers.hpp" #include "snippets/lowered/pass/optimize_loop_single_evaluation.hpp" #include "snippets/lowered/pass/validate_unified_loops.hpp" #include "snippets/lowered/pass/validate_expanded_loops.hpp" #include "snippets/lowered/pass/normalize_loop_ids.hpp" #include "snippets/shape_inference/shape_inference.hpp" -#include "subgraph_simple.hpp" using Snippets_TailProcessingTransformation = ::testing::Test; // [Inserted Loop number, [ptr_increments, final_offsets] @@ -27,34 +27,32 @@ using namespace ov::snippets::lowered; constexpr static size_t vector_size = 16; -static void init_linear_ir(const std::vector& in_shapes, LinearIR& linear_ir, size_t block_size) { - auto body = ov::test::snippets::AddFunction(in_shapes).getOriginal(); - auto shape_infer_factory = std::make_shared(); - linear_ir = LinearIR(body, shape_infer_factory); - auto expr_it = std::find_if(linear_ir.cbegin(), linear_ir.cend(), - [](const ExpressionPtr& expr) { return ov::is_type(expr->get_node()); }); - ASSERT_TRUE(expr_it != linear_ir.cend()); - const auto add = *expr_it; - const auto loop_input_ports = std::vector{add->get_input_port(0), add->get_input_port(1)}; - const auto loop_output_ports = std::vector{add->get_output_port(0)}; +static void init_linear_ir(const std::vector& in_shapes, LinearIR& linear_ir, size_t block_size) { + Config lir_config; + lir_config.m_manual_build_support = true; + linear_ir = LinearIR(lir_config, std::make_shared()); + + const ov::element::Type input_precision = ov::element::f32; + const auto param0 = linear_ir.push_node(input_precision, in_shapes[0]); + const auto param1 = linear_ir.push_node(input_precision, in_shapes[1]); + const auto param2 = linear_ir.push_node(input_precision, in_shapes[2]); + const auto matmul = linear_ir.push_node(param0.second, param1.second); + const auto add = linear_ir.push_node(matmul.second, param2.second); + const auto result = linear_ir.push_node(add.second); + const auto loop_manager = linear_ir.get_loop_manager(); - const auto in_shape0 = in_shapes[0].get_shape(); - const auto in_shape1 = in_shapes[1].get_shape(); - const auto inner_wa = std::max(*in_shape0.rbegin(), *in_shape1.rbegin()); - const auto inner_inc = std::min(vector_size, inner_wa); - const auto blocked_wa = block_size; - const auto blocked_inc = 1; - const auto outer_wa = std::max(*(in_shape0.rbegin() + 1), *(in_shape1.rbegin() + 1)); - const auto outer_inc = blocked_wa; - loop_manager->mark_loop(expr_it, std::next(expr_it), inner_wa, inner_inc, 0, loop_input_ports, loop_output_ports); - loop_manager->mark_loop(expr_it, std::next(expr_it), blocked_wa, blocked_inc, 1, loop_input_ports, loop_output_ports, true, true); - const auto loop_id = loop_manager->mark_loop(expr_it, std::next(expr_it), outer_wa, outer_inc, 1, loop_input_ports, loop_output_ports); - const auto& outer_loop_info = loop_manager->get_loop_info(loop_id); - const auto outer_tail_size = outer_wa % outer_inc; - if (outer_tail_size != 0) { - outer_loop_info->register_pass_to_handler( - outer_tail_size); - } + linear_ir.get_loop_manager()->mark_loop(matmul.first, add.first, in_shapes[0].front(), block_size, 1, + std::vector{LoopPort((*matmul.first)->get_input_port(0)), + LoopPort((*matmul.first)->get_input_port(1), false)}, + std::vector{LoopPort((*matmul.first)->get_output_port(0))}); + linear_ir.get_loop_manager()->mark_loop(add.first, result.first, in_shapes[2].back(), vector_size, 0, + std::vector{LoopPort((*add.first)->get_input_port(0)), + LoopPort((*add.first)->get_input_port(1))}, + std::vector{LoopPort((*add.first)->get_output_port(0))}); + linear_ir.get_loop_manager()->mark_loop(add.first, result.first, in_shapes[2].front(), 1, 1, + std::vector{LoopPort((*add.first)->get_input_port(0)), + LoopPort((*add.first)->get_input_port(1))}, + std::vector{LoopPort((*add.first)->get_output_port(0))}); } static void apply_transformations(LinearIR& linear_ir, const std::shared_ptr& config) { @@ -64,6 +62,8 @@ static void apply_transformations(LinearIR& linear_ir, const std::shared_ptr(); + pipeline.register_pass(); pipeline.register_pass(vector_size); pipeline.register_pass(); pipeline.register_pass(); @@ -77,25 +77,27 @@ static void apply_transformations(LinearIR& linear_ir, const std::shared_ptr loops; for (const auto& expr : linear_ir) { const auto& node = expr->get_node(); const auto loop_end = ov::as_type_ptr(node); if (!loop_end) continue; + const auto loop_num = loop_end->get_id(); ASSERT_GT(reference.count(loop_num), 0); + loops.insert(loop_num); ASSERT_TRUE(loop_end->get_ptr_increments() == reference.at(loop_num).first); ASSERT_TRUE(loop_end->get_finalization_offsets() == reference.at(loop_num).second); - loop_num++; } - ASSERT_EQ(loop_num, reference.size()); + ASSERT_EQ(loops.size(), reference.size()); } TEST(Snippets_TailProcessingTransformation, BlockedWOTail_OriginalPtrShifts) { LinearIR linear_ir; - ov::Shape inputShape0 = {1, 2, 16, 20}; - ov::Shape inputShape1 = {1, 2, 16, 20}; - init_linear_ir({inputShape0, inputShape1}, linear_ir, 4); + ov::Shape inputShape0 = {12, 16}; + ov::Shape inputShape1 = {16, 20}; + ov::Shape inputShape2 = {12, 20}; + init_linear_ir({inputShape0, inputShape1, inputShape2}, linear_ir, 4); auto config = std::make_shared(); config->disable(); @@ -107,16 +109,17 @@ TEST(Snippets_TailProcessingTransformation, BlockedWOTail_OriginalPtrShifts) { std::map, std::vector>> reference; reference[0] = { std::vector(3, 1), std::vector(3, -20)}; reference[1] = { std::vector(3, 20), std::vector(3, -80)}; - reference[2] = { std::vector(3, 20), std::vector(3, -320)}; + reference[2] = { {16, 0, 20, 20}, {-192, 0, -240, -240}}; validate(linear_ir, reference); } TEST(Snippets_TailProcessingTransformation, BlockedWOTail_CleanUpPtrShifts) { LinearIR linear_ir; - ov::Shape inputShape0 = {1, 2, 16, 20}; - ov::Shape inputShape1 = {1, 2, 16, 20}; - init_linear_ir({inputShape0, inputShape1}, linear_ir, 4); + ov::Shape inputShape0 = {12, 16}; + ov::Shape inputShape1 = {16, 20}; + ov::Shape inputShape2 = {12, 20}; + init_linear_ir({inputShape0, inputShape1, inputShape2}, linear_ir, 4); auto config = std::make_shared(); config->disable(); @@ -126,17 +129,18 @@ TEST(Snippets_TailProcessingTransformation, BlockedWOTail_CleanUpPtrShifts) { // [Inserted Loop number, [ptr_increments, final_offsets] std::map, std::vector>> reference; reference[0] = { std::vector(3, 1), std::vector(3, 0)}; - reference[1] = { std::vector(3, 0), std::vector(3, 0)}; - reference[2] = { std::vector(3, 0), std::vector(3, 0)}; + reference[1] = { std::vector(3, 0), {0, -80, 0}}; // -80 - finalization offset for Buffer ptr + reference[2] = { {16, 0, 0, 0}, std::vector(4, 0)}; validate(linear_ir, reference); } TEST(Snippets_TailProcessingTransformation, BlockedTail_OriginalPtrShifts) { LinearIR linear_ir; - ov::Shape inputShape0 = {1, 2, 18, 20}; - ov::Shape inputShape1 = {1, 2, 18, 20}; - init_linear_ir({inputShape0, inputShape1}, linear_ir, 4); + ov::Shape inputShape0 = {14, 16}; + ov::Shape inputShape1 = {16, 20}; + ov::Shape inputShape2 = {14, 20}; + init_linear_ir({inputShape0, inputShape1, inputShape2}, linear_ir, 4); auto config = std::make_shared(); config->disable(); @@ -144,38 +148,37 @@ TEST(Snippets_TailProcessingTransformation, BlockedTail_OriginalPtrShifts) { // [Inserted Loop number, [ptr_increments, final_offsets] std::map, std::vector>> reference; - reference[0] = { std::vector(3, 0), std::vector(3, 16)}; // Vector Inner - reference[1] = { std::vector(3, 0), std::vector(3, -16)}; // Blocked Inner - reference[2] = { std::vector(3, 20), std::vector(3, -80)}; // Vector Blocked - reference[3] = { std::vector(3, 20), std::vector(3, 0)}; // Vector Outer + reference[0] = { std::vector(3, 0), std::vector(3, 16)}; // Vector Inner + reference[1] = { std::vector(3, 0), std::vector(3, -16)}; // Tail Inner - reference[4] = { std::vector(3, 0), std::vector(3, 16)}; // Vector Inner - reference[5] = { std::vector(3, 0), std::vector(3, -16)}; // Blocked Inner - reference[6] = { std::vector(3, 20), std::vector(3, -40)}; // Tail Blocked - reference[7] = { std::vector(3, 0), std::vector(3, -320)}; // Tail Blocked + reference[2] = { std::vector(3, 20), std::vector(3, -80)}; // Inner Vector Blocked + reference[3] = { {16, 0, 20, 20}, std::vector(4, 0)}; // Outer Vector Blocked + + reference[4] = { std::vector(3, 20), std::vector(3, -40)}; // Inner Tail Blocked + reference[5] = { std::vector(4, 0), {-192, 0, -240, -240}}; // Outer Tail Blocked validate(linear_ir, reference); } TEST(Snippets_TailProcessingTransformation, BlockedTail_CleanUpPtrShifts) { LinearIR linear_ir; - ov::Shape inputShape0 = {1, 2, 18, 20}; - ov::Shape inputShape1 = {1, 2, 18, 20}; - init_linear_ir({inputShape0, inputShape1}, linear_ir, 4); + ov::Shape inputShape0 = {14, 16}; + ov::Shape inputShape1 = {16, 20}; + ov::Shape inputShape2 = {14, 20}; + init_linear_ir({inputShape0, inputShape1, inputShape2}, linear_ir, 4); apply_transformations(linear_ir, std::make_shared()); // [Inserted Loop number, [ptr_increments, final_offsets] std::map, std::vector>> reference; - reference[0] = { std::vector(3, 0), std::vector(3, 16)}; // Vector Inner - reference[1] = { std::vector(3, 0), std::vector(3, 4)}; // Blocked Inner - reference[2] = {std::vector(3, 0), std::vector(3, 0)}; // Vector Blocked - reference[3] = { std::vector(3, 0), std::vector(3, 0)}; // Vector Outer - - reference[4] = { std::vector(3, 0), std::vector(3, 16)}; // Vector Inner - reference[5] = { std::vector(3, 0), std::vector(3, 4)}; // Blocked Inner - reference[6] = { std::vector(3, 0), std::vector(3, 0)}; // Tail Blocked - reference[7] = { std::vector(3, 0), std::vector(3, 0)}; // Tail Blocked + reference[0] = { std::vector(3, 0), std::vector(3, 16)}; // Vector Inner + reference[1] = { std::vector(3, 0), std::vector(3, 4)}; // Tail Inner + + reference[2] = { std::vector(3, 0), {0, -80, 0}}; // Inner Vector Blocked (-80 - finalization offset for Buffer ptr) + reference[3] = { {16, 0, 0, 0}, std::vector(4, 0)}; // Outer Vector Blocked + + reference[4] = { std::vector(3, 0), {0, -40, 0}}; // Inner Tail Blocked (-40 - finalization offset for Buffer ptr) + reference[5] = { std::vector(4, 0), {32, 0, 0, 0}}; // Outer Tail Blocked validate(linear_ir, reference); } diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp index 40da4130b212c9..56c2c75dae9bc2 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp @@ -12,6 +12,27 @@ namespace intel_cpu { const size_t CPURuntimeConfigurator::rank6D = 6; +#ifdef SNIPPETS_DEBUG_CAPS +std::string CPURuntimeConfig::to_string() const { + std::stringstream out; + out << RuntimeConfig::to_string(); + out << "Loop Parameters:" << "\n"; + for (size_t i = 0; i < loop_args.size(); ++i) { + const auto& loop = loop_args[i]; + out << "\t[" << i << "] WA: " << loop.m_work_amount << "\n"; + out << "\tPointer Increments: "; + for (int64_t j = 0; j < loop.m_num_data_ptrs; ++j) + out << loop.m_ptr_increments[j] << " "; + out << "\n"; + out << "\tFinalization offsets: "; + for (int64_t j = 0; j < loop.m_num_data_ptrs; ++j) + out << loop.m_finalization_offsets[j] << " "; + out << "\n"; + } + return out.str(); +} +#endif + CPURuntimeConfigurator::CPURuntimeConfigurator() : ov::snippets::RuntimeConfigurator(std::make_shared()) { } diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp index 2104dfbdd42ddb..00bc676678d189 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp @@ -17,6 +17,10 @@ class CPURuntimeConfig : public ov::snippets::RuntimeConfig { OPENVINO_RTTI("CPURuntimeConfig", "0", ov::snippets::RuntimeConfig) CPURuntimeConfig() = default; +#ifdef SNIPPETS_DEBUG_CAPS + std::string to_string() const override; +#endif + std::vector loop_args = {}; }; diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp index cb6dfeb741109a..b968786eea8d67 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp @@ -69,7 +69,12 @@ void jit_loop_begin_emitter::emit_impl(const std::vector& in, const std: } // if wa < increment, skip the loop - h->cmp(reg_work_amount, wa_increment); + // Note : If the loop should be evaluated once and increment is dynamic, + // we should manually set `increment = 1` to compare the dynamic work amount + // with `1` at least before loop execution + // (work amount can be zero and we should skip this loop even `evaluate_once = 1`) + auto increment = evaluate_once && snippets::utils::is_dynamic_value(wa_increment) ? 1 : wa_increment; + h->cmp(reg_work_amount, increment); h->jl(*loop_end_label, Xbyak::CodeGenerator::T_NEAR); h->L(*loop_begin_label); From c328ded614fad2b03d598754c3735f44ae2ecb82 Mon Sep 17 00:00:00 2001 From: Peyara Nando Date: Tue, 20 Aug 2024 01:46:18 +0400 Subject: [PATCH 045/117] [TF FE] Implementation of BatchMatrixInverse Support (#26033) Implemented BatchMatrixInverse Registered into OP_loader Implemented associated pytests For Issue #24807 --------- Co-authored-by: Roman Kazantsev --- src/frontends/tensorflow/docs/supported_ops.md | 2 +- src/frontends/tensorflow/src/op_table.cpp | 1 + src/frontends/tensorflow_common/src/op/matrix_inverse.cpp | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/frontends/tensorflow/docs/supported_ops.md b/src/frontends/tensorflow/docs/supported_ops.md index 9f6af0f7670ae0..a851e0f64db932 100644 --- a/src/frontends/tensorflow/docs/supported_ops.md +++ b/src/frontends/tensorflow/docs/supported_ops.md @@ -111,7 +111,7 @@ A "supported operation" is one that TensorFlow Frontend can convert to the OpenV | BatchMatrixDeterminant | NO | | | BatchMatrixDiag | NO | | | BatchMatrixDiagPart | NO | | -| BatchMatrixInverse | NO | | +| BatchMatrixInverse | YES | | | BatchMatrixSetDiag | NO | | | BatchMatrixSolve | NO | | | BatchMatrixSolveLs | NO | | diff --git a/src/frontends/tensorflow/src/op_table.cpp b/src/frontends/tensorflow/src/op_table.cpp index 8cd0c4a9b15016..ad69ff8467994e 100644 --- a/src/frontends/tensorflow/src/op_table.cpp +++ b/src/frontends/tensorflow/src/op_table.cpp @@ -221,6 +221,7 @@ const std::map get_supported_ops() { {"BatchMatMul", CreatorFunction(translate_batch_mat_mul_op)}, {"BatchMatMulV2", CreatorFunction(translate_batch_mat_mul_op)}, {"BatchMatMulV3", CreatorFunction(translate_batch_mat_mul_with_type_op)}, + {"BatchMatrixInverse", CreatorFunction(translate_matrix_inverse_op)}, {"BatchToSpaceND", CreatorFunction(translate_batch_to_space_nd_op)}, {"BroadcastArgs", CreatorFunction(translate_broadcast_args_op)}, {"BroadcastTo", CreatorFunction(translate_broadcast_to_op)}, diff --git a/src/frontends/tensorflow_common/src/op/matrix_inverse.cpp b/src/frontends/tensorflow_common/src/op/matrix_inverse.cpp index f0c051d996ff4f..84a7320a191692 100644 --- a/src/frontends/tensorflow_common/src/op/matrix_inverse.cpp +++ b/src/frontends/tensorflow_common/src/op/matrix_inverse.cpp @@ -13,7 +13,7 @@ namespace frontend { namespace tensorflow { namespace op { OutputVector translate_matrix_inverse_op(const NodeContext& node) { - default_op_checks(node, 1, {"MatrixInverse"}); + default_op_checks(node, 1, {"MatrixInverse", "BatchMatrixInverse"}); // retrieve the input tensor auto input = node.get_input(0); From e0392dcc4691eedcfd9f79fb2702f0575f7c0fd8 Mon Sep 17 00:00:00 2001 From: Maciej Smyk Date: Tue, 20 Aug 2024 00:41:12 +0200 Subject: [PATCH 046/117] [DOCS] Fixing code snippet in OV Tokenizers article for master (#26114) Jira: 149945 Fixed mentioned issues in code snippets in OV Tokenizers article. --- .../learn-openvino/llm_inference_guide/ov-tokenizers.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/articles_en/learn-openvino/llm_inference_guide/ov-tokenizers.rst b/docs/articles_en/learn-openvino/llm_inference_guide/ov-tokenizers.rst index 1f5d6813cf0ba7..d6e23b3791d001 100644 --- a/docs/articles_en/learn-openvino/llm_inference_guide/ov-tokenizers.rst +++ b/docs/articles_en/learn-openvino/llm_inference_guide/ov-tokenizers.rst @@ -236,8 +236,8 @@ Convert Tokenizers: tokenizer_dir = Path("tokenizer/") core = Core() - ov_tokenizer = core.read_model(tokenizer_dir / "openvino_tokenizer") - ov_detokenizer = core.read_model(tokenizer_dir / "openvino_detokenizer") + ov_tokenizer = core.read_model(tokenizer_dir / "openvino_tokenizer.xml") + ov_detokenizer = core.read_model(tokenizer_dir / "openvino_detokenizer.xml") tokenizer, detokenizer = core.compile_model(ov_tokenizer), core.compile_model(ov_detokenizer) @@ -278,7 +278,7 @@ You can find more information and code snippets in the `OpenVINO Tokenizers Note .. code-block:: python - input numpy as np + import numpy as np text_input = ["Quick brown fox jumped"] From 72516c375a6e04217c04e5df8409d5875b90b6e9 Mon Sep 17 00:00:00 2001 From: Xiuchuan Zhai <110877886+xczhai@users.noreply.github.com> Date: Tue, 20 Aug 2024 13:06:00 +0800 Subject: [PATCH 047/117] [CPU] FC node tensor parallel (#25088) ### Details: - *Enable sub stream to compile model on each socket* - *Limit CPU cores to 32 when TP is enabled* - *Split fc into two sub-fcs at node level instead of graph level* - *Concat fc output in the horizon direction. Drop allgatherv and allreduce for performance reason* - *Supported llm fc int8 and 4bit mode* - *Remove previous version fc TP logic* ### Tickets: - *ticket-id* --------- Co-authored-by: sunxiaoxia2022 Co-authored-by: Shen, Wanglei --- .../runtime/threading/cpu_message.hpp | 58 +++++ .../threading/cpu_streams_executor.hpp | 2 +- .../runtime/threading/istreams_executor.hpp | 50 ++-- .../src/dev/threading/cpu_message.cpp | 96 +++++++ .../dev/threading/cpu_streams_executor.cpp | 100 +------ .../cpu_streams_executor_internal.cpp | 17 +- .../src/dev/threading/istreams_executor.cpp | 27 -- src/inference/tests/unit/cpu_reserve_test.cpp | 5 +- .../intel_cpu/src/async_infer_request.cpp | 10 + .../intel_cpu/src/async_infer_request.h | 13 + src/plugins/intel_cpu/src/compiled_model.cpp | 74 ++++-- src/plugins/intel_cpu/src/compiled_model.h | 19 +- src/plugins/intel_cpu/src/config.h | 4 + src/plugins/intel_cpu/src/cpu_memory.cpp | 121 +++++++++ src/plugins/intel_cpu/src/cpu_memory.h | 3 + .../intel_cpu/src/cpu_streams_calculation.cpp | 70 ++++- .../intel_cpu/src/cpu_streams_calculation.hpp | 12 + src/plugins/intel_cpu/src/graph.cpp | 145 ++--------- src/plugins/intel_cpu/src/graph.h | 5 +- src/plugins/intel_cpu/src/graph_context.cpp | 4 +- src/plugins/intel_cpu/src/graph_context.h | 10 +- src/plugins/intel_cpu/src/infer_request.cpp | 49 ++++ src/plugins/intel_cpu/src/infer_request.h | 2 + src/plugins/intel_cpu/src/node.h | 1 - .../intel_cpu/src/nodes/fullyconnected.cpp | 244 ++++++++++++++++++ .../intel_cpu/src/nodes/fullyconnected.h | 29 +++ src/plugins/intel_cpu/src/plugin.cpp | 9 +- src/plugins/intel_cpu/src/plugin.h | 3 + .../intel_cpu/src/sub_memory_manager.hpp | 57 ++++ .../convert_to_cpu_specific_opset.hpp | 6 +- .../transformation_pipeline.cpp | 6 +- .../transformations/transformation_pipeline.h | 2 - .../unit/streams_info/streams_e2e_test.cpp | 4 +- .../streams_info/streams_info_table_test.cpp | 72 +++--- .../streams_info/streams_rank_table_test.cpp | 125 +++++++++ 35 files changed, 1090 insertions(+), 364 deletions(-) create mode 100644 src/inference/dev_api/openvino/runtime/threading/cpu_message.hpp create mode 100644 src/inference/src/dev/threading/cpu_message.cpp create mode 100644 src/plugins/intel_cpu/src/sub_memory_manager.hpp create mode 100644 src/plugins/intel_cpu/tests/unit/streams_info/streams_rank_table_test.cpp diff --git a/src/inference/dev_api/openvino/runtime/threading/cpu_message.hpp b/src/inference/dev_api/openvino/runtime/threading/cpu_message.hpp new file mode 100644 index 00000000000000..357ea1fc2851e4 --- /dev/null +++ b/src/inference/dev_api/openvino/runtime/threading/cpu_message.hpp @@ -0,0 +1,58 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * @brief OpenVINO Runtime Executor Manager + * @file openvino/runtime/threading/executor_manager.hpp + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "openvino/runtime/common.hpp" +#include "openvino/runtime/threading/istreams_executor.hpp" +#include "openvino/runtime/threading/itask_executor.hpp" + + +namespace ov { + +namespace threading { +enum MsgType {CALL_BACK}; + +struct MessageInfo { + MsgType msg_type; +}; + +class OPENVINO_RUNTIME_API MessageManager { +public: + MessageManager(); + + void send_message(const MessageInfo& msg_info); + + void server_wait(); + + ~MessageManager(); + + void set_num_sub_streams(int num_sub_streams); + + int get_num_sub_streams(); +private: + int _num_sub_streams = 0; + std::vector _messageQueue; + std::mutex _msgMutex; + std::condition_variable _msgCondVar; +}; + +OPENVINO_RUNTIME_API std::shared_ptr message_manager(); +} // namespace threading +} // namespace ov \ No newline at end of file diff --git a/src/inference/dev_api/openvino/runtime/threading/cpu_streams_executor.hpp b/src/inference/dev_api/openvino/runtime/threading/cpu_streams_executor.hpp index eaa54701e2b20d..ff21eef7089353 100644 --- a/src/inference/dev_api/openvino/runtime/threading/cpu_streams_executor.hpp +++ b/src/inference/dev_api/openvino/runtime/threading/cpu_streams_executor.hpp @@ -55,7 +55,7 @@ class OPENVINO_RUNTIME_API CPUStreamsExecutor : public IStreamsExecutor { int get_socket_id() override; - void run_sub_stream(Task task, int id) override; + std::vector get_rank() override; private: struct Impl; diff --git a/src/inference/dev_api/openvino/runtime/threading/istreams_executor.hpp b/src/inference/dev_api/openvino/runtime/threading/istreams_executor.hpp index 7a34ea258c43dd..3630c2bb5a6ed7 100644 --- a/src/inference/dev_api/openvino/runtime/threading/istreams_executor.hpp +++ b/src/inference/dev_api/openvino/runtime/threading/istreams_executor.hpp @@ -38,6 +38,19 @@ class OPENVINO_RUNTIME_API IStreamsExecutor : virtual public ITaskExecutor { */ using Ptr = std::shared_ptr; + enum MsgType{ + TP, + START_INFER, + CALL_BACK + }; + + struct MessageInfo{ + MsgType msg_type; + std::vector rank; + void* buf; + Task task; + }; + /** * @brief Defines inference thread binding type */ @@ -95,6 +108,7 @@ class OPENVINO_RUNTIME_API IStreamsExecutor : virtual public ITaskExecutor { std::vector> _streams_info_table = {}; std::vector> _stream_processor_ids; int _sub_streams = 0; + std::vector _rank = {}; /** * @brief Get and reserve cpu ids based on configuration and hardware information, @@ -124,6 +138,7 @@ class OPENVINO_RUNTIME_API IStreamsExecutor : virtual public ITaskExecutor { * @param[in] cpu_reservation @copybrief Config::_cpu_reservation * @param[in] cpu_pinning @copybrief Config::_cpu_pinning * @param[in] streams_info_table @copybrief Config::_streams_info_table + * @param[in] rank @copybrief Config::_rank */ Config(std::string name = "StreamsExecutor", int streams = 1, @@ -131,14 +146,16 @@ class OPENVINO_RUNTIME_API IStreamsExecutor : virtual public ITaskExecutor { ov::hint::SchedulingCoreType thread_preferred_core_type = ov::hint::SchedulingCoreType::ANY_CORE, bool cpu_reservation = false, bool cpu_pinning = false, - std::vector> streams_info_table = {}) + std::vector> streams_info_table = {}, + std::vector rank = {}) : _name{std::move(name)}, _streams{streams}, _threads_per_stream{threads_per_stream}, _thread_preferred_core_type(thread_preferred_core_type), _cpu_reservation{cpu_reservation}, _cpu_pinning{cpu_pinning}, - _streams_info_table{std::move(streams_info_table)} { + _streams_info_table{std::move(streams_info_table)}, + _rank{rank} { update_executor_config(); } @@ -197,6 +214,9 @@ class OPENVINO_RUNTIME_API IStreamsExecutor : virtual public ITaskExecutor { int get_sub_streams() const { return _sub_streams; } + std::vector get_rank() const { + return _rank; + } StreamsMode get_sub_stream_mode() const { const auto proc_type_table = get_proc_type_table(); int sockets = proc_type_table.size() > 1 ? static_cast(proc_type_table.size()) - 1 : 1; @@ -250,31 +270,17 @@ class OPENVINO_RUNTIME_API IStreamsExecutor : virtual public ITaskExecutor { virtual int get_socket_id() = 0; /** - * @brief Execute the task in the current thread using streams executor configuration and constraints - * @param task A task to start + * @brief Return the rank of current stream + * Return {} when current stream has no rank + * @return Rank array, or throws exceptions if called not from stream thread */ - virtual void execute(Task task) = 0; + virtual std::vector get_rank() = 0; /** - * @brief Execute ov::Task inside sub stream of task executor context + * @brief Execute the task in the current thread using streams executor configuration and constraints * @param task A task to start - * @param id Sub stream id - */ - virtual void run_sub_stream(Task task, int id) = 0; - - /** - * @brief Execute all of the tasks and waits for its completion. - * Default run_sub_stream_and_wait() method implementation uses run_sub_stream() pure virtual method - * and higher level synchronization primitives from STL. - * The task is wrapped into std::packaged_task which returns std::future. - * std::packaged_task will call the task and signal to std::future that the task is finished - * or the exception is thrown from task - * Than std::future is used to wait for task execution completion and - * task exception extraction - * @note run_sub_stream_and_wait() does not copy or capture tasks! - * @param tasks A vector of tasks to execute */ - void run_sub_stream_and_wait(const std::vector& tasks); + virtual void execute(Task task) = 0; }; } // namespace threading diff --git a/src/inference/src/dev/threading/cpu_message.cpp b/src/inference/src/dev/threading/cpu_message.cpp new file mode 100644 index 00000000000000..75df25d70d53bf --- /dev/null +++ b/src/inference/src/dev/threading/cpu_message.cpp @@ -0,0 +1,96 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// +#include "openvino/runtime/threading/cpu_message.hpp" + +#include +#include +#include +#include +#include +#include + +namespace ov { +namespace threading { + +MessageManager::MessageManager() { + _num_sub_streams = 0; +} + +MessageManager::~MessageManager() {} + +void MessageManager::send_message(const MessageInfo& msg_info) { + { + std::lock_guard lock(_msgMutex); + _messageQueue.push_back(msg_info); + } + _msgCondVar.notify_all(); +} + +void MessageManager::server_wait() { + assert(_num_sub_streams); + MsgType msg_type; + int count = 0; + bool isStopped = false; + while (!isStopped) { + std::vector msgQueue; + { + std::unique_lock lock(_msgMutex); + _msgCondVar.wait(lock, [&] { + return !_messageQueue.empty(); + }); + std::swap(_messageQueue, msgQueue); + } + + for (auto rec_info : msgQueue) { + msg_type = rec_info.msg_type; + if (msg_type == CALL_BACK) { // CALL_BACK + count++; + if (count == _num_sub_streams) { + count = 0; + isStopped = true; + } + } + } + }; +} + +void MessageManager::set_num_sub_streams(int num_sub_streams) { + _num_sub_streams = num_sub_streams; +} + +int MessageManager::get_num_sub_streams() { + return _num_sub_streams; +} + +namespace { + +class MessageManageHolder { + std::mutex _mutex; + std::weak_ptr _manager; + +public: + MessageManageHolder(const MessageManageHolder&) = delete; + MessageManageHolder& operator=(const MessageManageHolder&) = delete; + + MessageManageHolder() = default; + + std::shared_ptr get() { + std::lock_guard lock(_mutex); + auto manager = _manager.lock(); + if (!manager) { + _manager = manager = std::make_shared(); + } + return manager; + } +}; + +} // namespace + +std::shared_ptr message_manager() { + static MessageManageHolder message_manage; + return message_manage.get(); +} + +} // namespace threading +} // namespace ov diff --git a/src/inference/src/dev/threading/cpu_streams_executor.cpp b/src/inference/src/dev/threading/cpu_streams_executor.cpp index 2df59d27cfe0b2..9e55cd2be18592 100644 --- a/src/inference/src/dev/threading/cpu_streams_executor.cpp +++ b/src/inference/src/dev/threading/cpu_streams_executor.cpp @@ -59,11 +59,6 @@ struct CPUStreamsExecutor::Impl { _streamId = _impl->_streamIdQueue.front(); _impl->_streamIdQueue.pop(); } - if (!_impl->_subStreamIdQueue.empty() && _impl->_subStreamsNum < _impl->_config.get_sub_streams()) { - _sub_stream_id = _impl->_subStreamIdQueue.front(); - _impl->_subStreamIdQueue.pop(); - _impl->_subStreamsNum++; - } } _numaNodeId = _impl->_config.get_streams() @@ -176,8 +171,8 @@ struct CPUStreamsExecutor::Impl { StreamCreateType stream_type; const auto org_proc_type_table = get_org_proc_type_table(); int streams_num = _impl->_config.get_streams(); - const auto stream_id = - streams_num == 0 ? 0 : (_sub_stream_id >= 0 ? streams_num + _sub_stream_id : _streamId % streams_num); + const auto stream_id = streams_num == 0 ? 0 : _streamId % streams_num; + _rank = _impl->_config.get_rank(); get_cur_stream_info(stream_id, _impl->_config.get_cpu_pinning(), org_proc_type_table, @@ -204,7 +199,7 @@ struct CPUStreamsExecutor::Impl { int _numaNodeId = 0; int _socketId = 0; bool _execute = false; - int _sub_stream_id = -1; + std::vector _rank; std::queue _taskQueue; #if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO std::unique_ptr _taskArena; @@ -335,7 +330,6 @@ struct CPUStreamsExecutor::Impl { _exectorMgr = executor_manager(); auto numaNodes = get_available_numa_nodes(); int streams_num = _config.get_streams(); - int sub_streams_num = _config.get_sub_streams(); if (streams_num != 0) { std::copy_n(std::begin(numaNodes), std::min(streams_num, numaNodes.size()), @@ -343,9 +337,6 @@ struct CPUStreamsExecutor::Impl { } else { _usedNumaNodes = std::move(numaNodes); } - if (sub_streams_num > 0) { - _subTaskThread.assign(sub_streams_num, std::make_shared()); - } for (auto streamId = 0; streamId < streams_num; ++streamId) { _threads.emplace_back([this, streamId] { openvino::itt::threadName(_config.get_name() + "_" + std::to_string(streamId)); @@ -368,31 +359,6 @@ struct CPUStreamsExecutor::Impl { }); } _streams.set_thread_ids_map(_threads); - - for (auto subId = 0; subId < sub_streams_num; ++subId) { - _subThreads.emplace_back([this, subId, sub_streams_num] { - openvino::itt::threadName(_config.get_name() + "_subthreads" + "_" + std::to_string(subId)); - for (bool stopped = false; !stopped;) { - Task task; - { _subTaskThread[subId]->que_pop(task, stopped); } - if (task) { - { - std::lock_guard lock{_streamIdMutex}; - if (_subStreamsNum < sub_streams_num) { - _subStreamIdQueue.push(subId); - } else { - std::queue empty; - std::swap(_subStreamIdQueue, empty); - } - } - Execute(task, *(_streams.local())); - } - } - }); - } - if (_subThreads.size() > 0) { - _streams.set_thread_ids_map(_subThreads); - } } void Enqueue(Task task) { @@ -403,10 +369,6 @@ struct CPUStreamsExecutor::Impl { _queueCondVar.notify_one(); } - void Enqueue_sub(Task task, int id) { - _subTaskThread[id]->que_push(std::move(task)); - } - void Execute(const Task& task, Stream& stream) { #if OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO auto& arena = stream._taskArena; @@ -467,52 +429,19 @@ struct CPUStreamsExecutor::Impl { } } - struct SubQueue { - std::mutex _subMutex; - std::condition_variable _subQueueCondVar; - bool _isSubStopped = false; - std::queue _subTaskQueue; - - SubQueue() {} - - void que_push(Task task) { - { - std::lock_guard lock(_subMutex); - _subTaskQueue.emplace(std::move(task)); - } - _subQueueCondVar.notify_one(); - } - - void que_pop(Task& task, bool& stopped) { - std::unique_lock lock(_subMutex); - _subQueueCondVar.wait(lock, [&] { - return !_subTaskQueue.empty() || (stopped = _isSubStopped); - }); - if (!_subTaskQueue.empty()) { - task = std::move(_subTaskQueue.front()); - _subTaskQueue.pop(); - } - } - - ~SubQueue() {} - }; - Config _config; std::mutex _streamIdMutex; int _streamId = 0; std::queue _streamIdQueue; - std::queue _subStreamIdQueue; - int _subStreamsNum = 0; std::vector _threads; - std::vector _subThreads; std::mutex _mutex; std::condition_variable _queueCondVar; std::queue _taskQueue; bool _isStopped = false; - std::vector> _subTaskThread; std::vector _usedNumaNodes; CustomThreadLocal _streams; std::shared_ptr _exectorMgr; + bool _isExit = false; }; int CPUStreamsExecutor::get_stream_id() { @@ -534,6 +463,11 @@ int CPUStreamsExecutor::get_socket_id() { return stream->_socketId; } +std::vector CPUStreamsExecutor::get_rank() { + auto stream = _impl->_streams.local(); + return stream->_rank; +} + CPUStreamsExecutor::CPUStreamsExecutor(const IStreamsExecutor::Config& config) : _impl{new Impl{config}} {} CPUStreamsExecutor::~CPUStreamsExecutor() { @@ -547,18 +481,6 @@ CPUStreamsExecutor::~CPUStreamsExecutor() { thread.join(); } } - for (size_t i = 0; i < _impl->_subTaskThread.size(); i++) { - { - std::lock_guard lock(_impl->_subTaskThread[i]->_subMutex); - _impl->_subTaskThread[i]->_isSubStopped = true; - } - _impl->_subTaskThread[i]->_subQueueCondVar.notify_all(); - } - for (auto& thread : _impl->_subThreads) { - if (thread.joinable()) { - thread.join(); - } - } } void CPUStreamsExecutor::execute(Task task) { @@ -573,9 +495,5 @@ void CPUStreamsExecutor::run(Task task) { } } -void CPUStreamsExecutor::run_sub_stream(Task task, int id) { - _impl->Enqueue_sub(std::move(task), id); -} - } // namespace threading } // namespace ov diff --git a/src/inference/src/dev/threading/cpu_streams_executor_internal.cpp b/src/inference/src/dev/threading/cpu_streams_executor_internal.cpp index d994b5d40f5111..547c149c3fc269 100644 --- a/src/inference/src/dev/threading/cpu_streams_executor_internal.cpp +++ b/src/inference/src/dev/threading/cpu_streams_executor_internal.cpp @@ -92,8 +92,15 @@ void reserve_cpu_by_streams_info(const std::vector> _streams_in int num_conditions = 0; int condition_idx = 0; bool last_all_proc = false; + bool sub_stream_enable = false; for (size_t i = 0; i < _streams_info_table.size(); i++) { + if (i > 0 && _streams_info_table[i][NUMBER_OF_STREAMS] < 0 && + _streams_info_table[i - 1][NUMBER_OF_STREAMS] > 0) { + stream_pos.clear(); + num_streams = 0; + sub_stream_enable = true; + } if (_streams_info_table[i][NUMBER_OF_STREAMS] != 0) { stream_pos.push_back(num_streams); } @@ -109,11 +116,15 @@ void reserve_cpu_by_streams_info(const std::vector> _streams_in std::string proc_type = ""; std::string numa_node = ""; std::string socket = ""; - if (_streams_info_table[i][NUMBER_OF_STREAMS] != 0) { + if ((_streams_info_table[i][NUMBER_OF_STREAMS] > 0 && !sub_stream_enable) || + (_streams_info_table[i][NUMBER_OF_STREAMS] < 0 && sub_stream_enable)) { streams_table.push_back(_streams_info_table[i]); if (_streams_info_table[i][NUMBER_OF_STREAMS] < 0) { - streams_table[streams_table.size() - 1][NUMBER_OF_STREAMS] = 1; + streams_table[streams_table.size() - 1][NUMBER_OF_STREAMS] = + std::abs(_streams_info_table[i][NUMBER_OF_STREAMS]); } + } else if (_streams_info_table[i][NUMBER_OF_STREAMS] != 0) { + continue; } if (last_all_proc && _streams_info_table[i][NUMBER_OF_STREAMS] != 0) { last_all_proc = false; @@ -135,7 +146,7 @@ void reserve_cpu_by_streams_info(const std::vector> _streams_in std::make_pair(proc_type + numa_node + socket, _streams_info_table[i][THREADS_PER_STREAM])); threads_status[condition_idx].push_back(0); } - if (_streams_info_table[i][PROC_TYPE] > ALL_PROC && _streams_info_table[i][NUMBER_OF_STREAMS] > 0) { + if (_streams_info_table[i][PROC_TYPE] > ALL_PROC && _streams_info_table[i][NUMBER_OF_STREAMS] != 0) { condition_idx++; } } diff --git a/src/inference/src/dev/threading/istreams_executor.cpp b/src/inference/src/dev/threading/istreams_executor.cpp index 822948e3ef1ab1..53a0c32806c6aa 100644 --- a/src/inference/src/dev/threading/istreams_executor.cpp +++ b/src/inference/src/dev/threading/istreams_executor.cpp @@ -332,32 +332,5 @@ void IStreamsExecutor::Config::set_config_zero_stream() { _cpu_pinning = false; } -void IStreamsExecutor::run_sub_stream_and_wait(const std::vector& tasks) { - std::vector> packagedTasks; - std::vector> futures; - for (std::size_t i = 0; i < tasks.size(); ++i) { - packagedTasks.emplace_back([&tasks, i] { - tasks[i](); - }); - futures.emplace_back(packagedTasks.back().get_future()); - } - for (std::size_t i = 0; i < tasks.size(); ++i) { - run_sub_stream( - [&packagedTasks, i] { - packagedTasks[i](); - }, - static_cast(i)); - } - // std::future::get will rethrow exception from task. - // We should wait all tasks before any exception is thrown. - // So wait() and get() for each future moved to separate loops - for (auto&& future : futures) { - future.wait(); - } - for (auto&& future : futures) { - future.get(); - } -} - } // namespace threading } // namespace ov diff --git a/src/inference/tests/unit/cpu_reserve_test.cpp b/src/inference/tests/unit/cpu_reserve_test.cpp index 327bcff7499688..21c7d374c94cc3 100644 --- a/src/inference/tests/unit/cpu_reserve_test.cpp +++ b/src/inference/tests/unit/cpu_reserve_test.cpp @@ -427,7 +427,7 @@ LinuxCpuReserveTestCase _2sockets_72cores_hyper_1streams = { {68, 1, 1, 68, MAIN_CORE_PROC, 32, -1}, {69, 1, 1, 69, MAIN_CORE_PROC, 33, -1}, {70, 1, 1, 70, MAIN_CORE_PROC, 34, -1}, {71, 1, 1, 71, MAIN_CORE_PROC, 35, -1}, }, - {{1, MAIN_CORE_PROC, 18, 0, 0}, {-1, MAIN_CORE_PROC, 18, 1, 1}}, + {{1, MAIN_CORE_PROC, 36, -1, -1}, {-1, MAIN_CORE_PROC, 18, 0, 0}, {-1, MAIN_CORE_PROC, 18, 1, 1}}, { {36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53}, {54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71}, @@ -789,7 +789,8 @@ LinuxCpuReserveTestCase _2sockets_104cores_1streams = { {204, 3, 1, 102, HYPER_THREADING_PROC, 102, -1}, {205, 3, 1, 102, MAIN_CORE_PROC, 102, -1}, {206, 3, 1, 103, HYPER_THREADING_PROC, 103, -1}, {207, 3, 1, 103, MAIN_CORE_PROC, 103, -1}, }, - {{1, ALL_PROC, 104, -1, 0}, + {{1, ALL_PROC, 208, -1, -1}, + {-1, ALL_PROC, 104, -1, 0}, {0, MAIN_CORE_PROC, 26, 0, 0}, {0, MAIN_CORE_PROC, 26, 1, 0}, {0, HYPER_THREADING_PROC, 26, 0, 0}, diff --git a/src/plugins/intel_cpu/src/async_infer_request.cpp b/src/plugins/intel_cpu/src/async_infer_request.cpp index b77d0059db75ef..8c5d0c8bc5c554 100644 --- a/src/plugins/intel_cpu/src/async_infer_request.cpp +++ b/src/plugins/intel_cpu/src/async_infer_request.cpp @@ -4,6 +4,8 @@ #include "async_infer_request.h" +#include "openvino/runtime/threading/cpu_message.hpp" + ov::intel_cpu::AsyncInferRequest::AsyncInferRequest( const std::shared_ptr& request, const std::shared_ptr& task_executor, @@ -13,9 +15,17 @@ ov::intel_cpu::AsyncInferRequest::AsyncInferRequest( } ov::intel_cpu::AsyncInferRequest::~AsyncInferRequest() { + if (m_has_sub_infers) { + m_sub_infer_requests.clear(); + } stop_and_wait(); } void ov::intel_cpu::AsyncInferRequest::throw_if_canceled() const { check_cancelled_state(); } + +void ov::intel_cpu::AsyncInferRequest::setSubInferRequest( + const std::vector>& requests) { + m_sub_infer_requests = requests; +} diff --git a/src/plugins/intel_cpu/src/async_infer_request.h b/src/plugins/intel_cpu/src/async_infer_request.h index ebf1a210f30a77..0491bb26a80c13 100644 --- a/src/plugins/intel_cpu/src/async_infer_request.h +++ b/src/plugins/intel_cpu/src/async_infer_request.h @@ -17,7 +17,20 @@ class AsyncInferRequest : public ov::IAsyncInferRequest { const std::shared_ptr& callback_executor); ~AsyncInferRequest(); + void setSubInferRequest(const std::vector>& requests); + + std::vector> getSubInferRequest() const { + return m_sub_infer_requests; + } + + void setSubInfer(bool has_sub_infer) { + m_has_sub_infers = has_sub_infer; + } + void throw_if_canceled() const; + + std::vector> m_sub_infer_requests; + bool m_has_sub_infers = false; }; } // namespace intel_cpu diff --git a/src/plugins/intel_cpu/src/compiled_model.cpp b/src/plugins/intel_cpu/src/compiled_model.cpp index 1a9f7f74099188..af8df9657ad34b 100644 --- a/src/plugins/intel_cpu/src/compiled_model.cpp +++ b/src/plugins/intel_cpu/src/compiled_model.cpp @@ -17,6 +17,8 @@ #include "openvino/util/common_util.hpp" #include "openvino/runtime/threading/cpu_streams_executor.hpp" #include "transformations/utils/utils.hpp" +#include "openvino/runtime/threading/cpu_streams_info.hpp" +#include "openvino/runtime/threading/cpu_message.hpp" #include "cpu/x64/cpu_isa_traits.hpp" #include @@ -42,25 +44,33 @@ struct ImmediateSerialExecutor : public ov::threading::ITaskExecutor { CompiledModel::CompiledModel(const std::shared_ptr& model, const std::shared_ptr& plugin, const Config& cfg, - const bool loaded_from_cache) + const bool loaded_from_cache, + const std::shared_ptr sub_memory_manager) : ov::ICompiledModel::ICompiledModel(model, plugin), m_model(model), m_plugin(plugin), m_cfg{cfg}, m_name{model->get_name()}, - m_loaded_from_cache(loaded_from_cache) { + m_loaded_from_cache(loaded_from_cache), + m_sub_memory_manager(sub_memory_manager) { m_mutex = std::make_shared(); const auto& core = m_plugin->get_core(); if (!core) OPENVINO_THROW("Unable to get API version. Core is unavailable"); - ov::threading::IStreamsExecutor::Ptr stream_executor = nullptr; + IStreamsExecutor::Config executor_confg; if (cfg.exclusiveAsyncRequests) { // special case when all InferRequests are muxed into a single queue m_task_executor = m_plugin->get_executor_manager()->get_executor("CPU"); } else { - stream_executor = m_plugin->get_executor_manager()->get_idle_cpu_streams_executor(m_cfg.streamExecutorConfig); - m_task_executor = stream_executor; + executor_confg = m_cfg.numSubStreams > 0 ? IStreamsExecutor::Config{"CPUMainStreamExecutor", + 1, + 1, + ov::hint::SchedulingCoreType::ANY_CORE, + false, + true} + : m_cfg.streamExecutorConfig; + m_task_executor = m_plugin->get_executor_manager()->get_idle_cpu_streams_executor(executor_confg); } if (0 != m_cfg.streamExecutorConfig.get_streams()) { m_callback_executor = m_plugin->get_executor_manager()->get_idle_cpu_streams_executor( @@ -74,11 +84,11 @@ CompiledModel::CompiledModel(const std::shared_ptr& model, if (m_callback_executor) set_callback_executor(m_callback_executor); - int streams = std::max(1, m_cfg.streamExecutorConfig.get_streams()); + int streams = std::max(1, executor_confg.get_streams()); std::vector tasks; tasks.resize(streams); m_graphs.resize(streams); - if (m_cfg.streamExecutorConfig.get_streams() != 0) { + if (executor_confg.get_streams() != 0) { auto all_graphs_ready = [&] { return std::all_of(m_graphs.begin(), m_graphs.end(), [&](Graph& graph) { return graph.IsReady(); @@ -102,15 +112,30 @@ CompiledModel::CompiledModel(const std::shared_ptr& model, } else { CompiledModel::get_graph(); } - // init sub stream threads of executor - int sub_streams = m_cfg.streamExecutorConfig.get_sub_streams(); - if (sub_streams > 0 && stream_executor != nullptr) { - std::vector tasks; - tasks.resize(sub_streams); - for (auto&& task : tasks) { - task = [] {}; + if (m_cfg.numSubStreams > 0) { + m_has_sub_compiled_models = true; + auto sub_cfg = m_cfg; + sub_cfg.numSubStreams = 0; + sub_cfg.enableNodeSplit = true; + auto streams_info_table = m_cfg.streamExecutorConfig.get_streams_info_table(); + auto message = message_manager(); + m_sub_memory_manager = std::make_shared(m_cfg.numSubStreams); + message->set_num_sub_streams(m_cfg.numSubStreams); + for (int i = 0; i < m_cfg.numSubStreams; i++) { + std::vector> sub_streams_table; + sub_streams_table.push_back(streams_info_table[i + 1]); + sub_streams_table[0][NUMBER_OF_STREAMS] = 1; + sub_cfg.streamExecutorConfig = IStreamsExecutor::Config{"CPUStreamsExecutor", + 1, + 1, + ov::hint::SchedulingCoreType::ANY_CORE, + false, + true, + sub_streams_table, + sub_cfg.streamsRankTable[i]}; + m_sub_compiled_models.push_back( + std::make_shared(model, plugin, sub_cfg, loaded_from_cache, m_sub_memory_manager)); } - stream_executor->run_sub_stream_and_wait(tasks); } } @@ -130,11 +155,14 @@ CompiledModel::GraphGuard::Lock CompiledModel::get_graph() const { GraphContext::Ptr ctx; { std::lock_guard lock{*m_mutex.get()}; - auto isQuantizedFlag = - (m_cfg.lpTransformsMode == Config::On) && - ov::pass::low_precision::LowPrecision::isFunctionQuantized(m_model); + auto isQuantizedFlag = (m_cfg.lpTransformsMode == Config::On) && + ov::pass::low_precision::LowPrecision::isFunctionQuantized(m_model); - ctx = std::make_shared(m_cfg, m_socketWeights[socketId], isQuantizedFlag, streamsExecutor); + ctx = std::make_shared(m_cfg, + m_socketWeights[socketId], + isQuantizedFlag, + streamsExecutor, + m_sub_memory_manager); } const std::shared_ptr model = m_model; graphLock._graph.CreateGraph(model, ctx); @@ -165,6 +193,14 @@ std::shared_ptr CompiledModel::create_infer_request() co std::make_shared(std::static_pointer_cast(internal_request), get_task_executor(), get_callback_executor()); + if (m_has_sub_compiled_models) { + std::vector> requests; + for (auto model : m_sub_compiled_models) { + requests.push_back(model->create_infer_request()); + } + async_infer_request->setSubInferRequest(requests); + async_infer_request->setSubInfer(true); + } return async_infer_request; } diff --git a/src/plugins/intel_cpu/src/compiled_model.h b/src/plugins/intel_cpu/src/compiled_model.h index 64caee60aeb0ae..facd9ef3698ca7 100644 --- a/src/plugins/intel_cpu/src/compiled_model.h +++ b/src/plugins/intel_cpu/src/compiled_model.h @@ -14,6 +14,7 @@ #include "openvino/runtime/iplugin.hpp" #include "openvino/runtime/isync_infer_request.hpp" #include "openvino/runtime/threading/thread_local.hpp" +#include "sub_memory_manager.hpp" namespace ov { namespace intel_cpu { @@ -25,7 +26,15 @@ class CompiledModel : public ov::ICompiledModel { CompiledModel(const std::shared_ptr& model, const std::shared_ptr& plugin, const Config& cfg, - const bool loaded_from_cache); + const bool loaded_from_cache, + const std::shared_ptr sub_memory_manager = nullptr); + + ~CompiledModel() { + if (m_has_sub_compiled_models) { + m_sub_compiled_models.clear(); + m_sub_memory_manager->_memorys_table.clear(); + } + } std::shared_ptr create_infer_request() const override; @@ -73,6 +82,14 @@ class CompiledModel : public ov::ICompiledModel { * even from main thread */ GraphGuard::Lock get_graph() const; + + std::vector> get_sub_compiled_models() const { + return m_sub_compiled_models; + } + + std::vector> m_sub_compiled_models; + std::shared_ptr m_sub_memory_manager = nullptr; + bool m_has_sub_compiled_models = false; }; } // namespace intel_cpu diff --git a/src/plugins/intel_cpu/src/config.h b/src/plugins/intel_cpu/src/config.h index 4ca6332c25c3cc..e0bcc6786a85b9 100644 --- a/src/plugins/intel_cpu/src/config.h +++ b/src/plugins/intel_cpu/src/config.h @@ -66,6 +66,7 @@ struct Config { int threadsPerStream = 0; ov::threading::IStreamsExecutor::ThreadBindingType threadBindingType = ov::threading::IStreamsExecutor::ThreadBindingType::NONE; ov::hint::PerformanceMode hintPerfMode = ov::hint::PerformanceMode::LATENCY; + std::vector> streamsRankTable; bool changedHintPerfMode = false; ov::log::Level logLevel = ov::log::Level::NO; uint32_t hintNumRequests = 0; @@ -73,6 +74,9 @@ struct Config { bool changedCpuPinning = false; ov::hint::SchedulingCoreType schedulingCoreType = ov::hint::SchedulingCoreType::ANY_CORE; std::set modelDistributionPolicy = {}; + int streamsRankLevel = 1; + int numSubStreams = 0; + bool enableNodeSplit = false; bool enableHyperThreading = true; bool changedHyperThreading = false; #if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) diff --git a/src/plugins/intel_cpu/src/cpu_memory.cpp b/src/plugins/intel_cpu/src/cpu_memory.cpp index ab454382f57d73..fac71e9e5bcc53 100644 --- a/src/plugins/intel_cpu/src/cpu_memory.cpp +++ b/src/plugins/intel_cpu/src/cpu_memory.cpp @@ -6,6 +6,7 @@ #include "memory_desc/cpu_memory_desc_utils.h" #include #include "nodes/reorder.h" +#include "nodes/common/cpu_memcpy.h" #include "utils/debug_capabilities.h" #if defined(__linux__) # include /* Definition of SYS_* constants */ @@ -657,5 +658,125 @@ bool mbind_move(const dnnl::memory mem, int numaNodeID) { return mbind_move(data, size, numaNodeID); } +MemoryPtr split_horizontal(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill) { + auto desc = src->getDescPtr(); + auto shape = src->getShape(); + auto dims = shape.getDims(); + auto prec = src->getPrecision(); + if (dim < 0) { + dim += dims.size(); + } + auto split_parts = [](int len, int n) { + int average = len / n; + std::vector parts(n, average); + parts.back() = len - average * (n - 1); + return parts; + }; + if (shape.isDynamic()) { + // if the dim is dynamic, should return a dynamic dim without any change. + // if the dim is static, should split it indeed. + const auto& pshape = shape.toPartialShape(); + if (pshape[dim].is_dynamic()) { + return src; + } + auto new_pshape = pshape; + auto splited_dim_vec = split_parts(new_pshape[dim].get_length(), w_size); + new_pshape[dim] = splited_dim_vec[w_rank]; + + auto new_desc = std::make_shared(prec, Shape{new_pshape}); + MemoryPtr ptr = std::make_shared(eng, new_desc); + return ptr; + } + assert(dims[dim] >= w_size); + auto splited_dim_vec = split_parts(dims[dim], w_size); + + // reference stride + VectorDims stride_dims = dims; + stride_dims[dim] = splited_dim_vec[0]; + size_t stride = std::accumulate(stride_dims.begin(), stride_dims.end(), static_cast(1), std::multiplies()) * prec.size(); + + // create new shape for target memory + VectorDims new_dims = dims; + new_dims[dim] = splited_dim_vec[w_rank]; + + auto new_desc = desc->cloneWithNewDims(new_dims, true); + if (!need_fill) { + MemoryPtr ptr = std::make_shared(eng, new_desc, nullptr); + return ptr; + } + + auto srcPtr = static_cast(src->getData()); + if (prec == ov::element::u4 || prec == ov::element::i4) { + stride /= 2; + } + + MemoryPtr ptr = std::make_shared(eng, new_desc, srcPtr + w_rank * stride); + return ptr; +} + +MemoryPtr split_vertical(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill) { + auto desc = src->getDescPtr(); + auto shape = src->getShape(); + auto dims = shape.getDims(); + auto prec = src->getPrecision(); + if (dim < 0) { + dim += dims.size(); + } + auto split_parts = [](int len, int n) { + int average = len / n; + std::vector parts(n, average); + parts.back() = len - average * (n - 1); + return parts; + }; + if (shape.isDynamic()) { + const auto& pshape = shape.toPartialShape(); + if (pshape[dim].is_dynamic()) { + OPENVINO_THROW("Can't split data with dynamic shapes"); + } + auto new_pshape = pshape; + auto splited_dim_vec = split_parts(new_pshape[dim].get_length(), w_size); + new_pshape[dim] = splited_dim_vec[w_rank]; + + auto new_desc = std::make_shared(prec, Shape{new_pshape}); + MemoryPtr ptr = std::make_shared(eng, new_desc); + return ptr; + } + assert(dims[dim] >= w_size); + const auto splited_size = dims[dim] * prec.size(); + auto splited_dim_vec = split_parts(dims[dim], w_size); + auto element_size = prec.size(); + + VectorDims new_dims = dims; + new_dims[dim] = splited_dim_vec[w_rank]; + + auto new_desc = desc->cloneWithNewDims(new_dims, true); + MemoryPtr ptr = std::make_shared(eng, new_desc); + if (!need_fill) { + return ptr; + } + // copy + auto srcPtr = static_cast(src->getData()); + auto dstPtr = static_cast(ptr->getData()); + // selected dim bytes + auto channel_size = dims[dim] * element_size; + // total bytes + auto mem_size = src->getSize(); + // the steps need to copy. + const int step = (mem_size / channel_size); + // bytes of selected dim. + auto strideSize = splited_dim_vec[0] * element_size; + auto copySize = splited_dim_vec[w_rank] * element_size; + if (prec == ov::element::u4 || prec == ov::element::i4) { + strideSize /= 2; + copySize /= 2; + } + parallel_for(step, [&](int i){ + int dst_offset = i * copySize; + int src_offset = i * splited_size + w_rank * strideSize; + cpu_parallel_memcpy(dstPtr + dst_offset, srcPtr + src_offset, copySize); + }); + return ptr; +} + } // namespace intel_cpu } // namespace ov diff --git a/src/plugins/intel_cpu/src/cpu_memory.h b/src/plugins/intel_cpu/src/cpu_memory.h index 69b70cb6e583a3..f62c2f052575f6 100644 --- a/src/plugins/intel_cpu/src/cpu_memory.h +++ b/src/plugins/intel_cpu/src/cpu_memory.h @@ -463,5 +463,8 @@ bool mbind_move(void* data, size_t size, int numaNodeID); bool mbind_move(const MemoryCPtr mem, int numaNodeID); bool mbind_move(const dnnl::memory mem, int numaNodeID); +MemoryPtr split_horizontal(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill = true); +MemoryPtr split_vertical(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill = true); + } // namespace intel_cpu } // namespace ov diff --git a/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp b/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp index 08ba43f9eff106..fb8294e5ce29fd 100644 --- a/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp +++ b/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp @@ -22,6 +22,7 @@ using namespace ov; using namespace ov::threading; #define INIT_VAL -100 +#define TP_CPU_LIMIT 32 namespace ov { namespace intel_cpu { @@ -101,17 +102,24 @@ std::vector> get_streams_info_table(const int input_streams, const std::vector>& one_proc_table, const int num_threads, const IStreamsExecutor::Config::StreamsMode sub_streams_model) { + stream_info[THREADS_PER_STREAM] = sub_streams_model == IStreamsExecutor::Config::StreamsMode::SUB_STREAMS_NULL + ? num_threads + : std::min(TP_CPU_LIMIT, num_threads); if ((one_proc_info[PROC_NUMA_NODE_ID] < 0) || (one_proc_info[PROC_SOCKET_ID] < 0) || - (((one_proc_info[MAIN_CORE_PROC] > 0) && (one_proc_info[MAIN_CORE_PROC] < num_threads)) || + (((one_proc_info[MAIN_CORE_PROC] > 0) && + (one_proc_info[MAIN_CORE_PROC] < stream_info[THREADS_PER_STREAM])) || ((one_proc_info[MAIN_CORE_PROC] == 0) && (one_proc_info[EFFICIENT_CORE_PROC] > 0) && - (one_proc_info[EFFICIENT_CORE_PROC] < num_threads)))) { - update_mix_stream_info(one_proc_info, one_proc_table, num_threads, sub_streams_model, ALL_PROC); + (one_proc_info[EFFICIENT_CORE_PROC] < stream_info[THREADS_PER_STREAM])))) { + update_mix_stream_info(one_proc_info, + one_proc_table, + stream_info[THREADS_PER_STREAM], + sub_streams_model, + ALL_PROC); } else { stream_info[PROC_TYPE] = - one_proc_info[MAIN_CORE_PROC] >= num_threads ? MAIN_CORE_PROC : EFFICIENT_CORE_PROC; + one_proc_info[MAIN_CORE_PROC] >= stream_info[THREADS_PER_STREAM] ? MAIN_CORE_PROC : EFFICIENT_CORE_PROC; stream_info[NUMBER_OF_STREAMS] = sub_streams_model == IStreamsExecutor::Config::StreamsMode::SUB_STREAMS_NULL ? 1 : -1; - stream_info[THREADS_PER_STREAM] = num_threads; update_ids_method(one_proc_info); streams_info_table.push_back(stream_info); } @@ -371,7 +379,7 @@ std::vector> get_streams_info_table(const int input_streams, create_one_stream(proc_socket_table[current_socket_id], proc_type_table, proc_socket_table[current_socket_id][ALL_PROC], - IStreamsExecutor::Config::StreamsMode::SUB_STREAMS_NULL); + IStreamsExecutor::Config::StreamsMode::SUB_STREAMS_FOR_SOCKET); for (size_t n_node = 0; n_node < proc_socket_table.size(); n_node++) { if (n_node != size_t(current_socket_id)) { create_one_stream(proc_socket_table[n_node], @@ -380,6 +388,23 @@ std::vector> get_streams_info_table(const int input_streams, IStreamsExecutor::Config::StreamsMode::SUB_STREAMS_FOR_SOCKET); } } + stream_info = streams_info_table[0]; + stream_info[NUMBER_OF_STREAMS] = 1; + for (size_t n = 1; n < streams_info_table.size(); n++) { + if (streams_info_table[n][NUMBER_OF_STREAMS] == -1) { + if (stream_info[PROC_TYPE] != streams_info_table[n][PROC_TYPE]) { + stream_info[PROC_TYPE] = ALL_PROC; + } + stream_info[THREADS_PER_STREAM] += streams_info_table[n][THREADS_PER_STREAM]; + if (stream_info[STREAM_NUMA_NODE_ID] != streams_info_table[n][STREAM_NUMA_NODE_ID]) { + stream_info[STREAM_NUMA_NODE_ID] = -1; + } + if (stream_info[STREAM_SOCKET_ID] != streams_info_table[n][STREAM_SOCKET_ID]) { + stream_info[STREAM_SOCKET_ID] = -1; + } + } + } + streams_info_table.insert(streams_info_table.begin(), stream_info); n_streams--; } @@ -462,6 +487,33 @@ std::vector> get_streams_info_table(const int input_streams, return streams_info_table; } +std::vector> get_streams_rank_table(const std::vector>& streams_info_table, + const int input_rank_level, + int& num_sub_streams) { + std::vector> rank_table = {}; + num_sub_streams = 0; + std::vector init_rank = {}; + int rank_level = input_rank_level == 0 ? 1 : input_rank_level; + init_rank.resize(rank_level, 0); + + for (auto& row : streams_info_table) { + if (row[NUMBER_OF_STREAMS] < 0) { + for (int i = 0; i < abs(row[NUMBER_OF_STREAMS]); i++) { + init_rank[rank_level - 1] = num_sub_streams + i; + rank_table.push_back(init_rank); + } + num_sub_streams -= row[NUMBER_OF_STREAMS]; + } + } + if (rank_level == 2) { + for (int i = num_sub_streams / 2; i < num_sub_streams; i++) { + rank_table[i][0] = 1; + rank_table[i][1] -= num_sub_streams / 2; + } + } + return rank_table; +} + int get_model_prefer_threads(const int num_streams, const std::vector> proc_type_table, const std::shared_ptr& model, @@ -608,6 +660,12 @@ std::vector> generate_stream_info(const int streams, ov::util::to_string(config.hintPerfMode), config.modelDistributionPolicy, proc_type_table); + // streams_info_table = {{1, 1, 56, 1, 1}, {-1, 1, 28, 1, 1}, {-1, 1, 28, 0, 0}}; + if (config.modelDistributionPolicy.find(ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL) != + config.modelDistributionPolicy.end()) { + config.streamsRankTable = + get_streams_rank_table(streams_info_table, config.streamsRankLevel, config.numSubStreams); + } auto cpu_pinning = get_cpu_pinning(config.enableCpuPinning, config.changedCpuPinning, proc_type_table, streams_info_table); diff --git a/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp b/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp index 584f9a2d9a0460..e362c0373d8d1d 100644 --- a/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp +++ b/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp @@ -53,6 +53,18 @@ std::vector> get_streams_info_table(const int input_streams, const std::string input_perf_hint, const std::set hint_llm_distribution_policy, const std::vector>& proc_type_table); + +/** + * @brief Generate streams rank table for tensor parallel according to streams info table. + * @param[in] streams_info_table is streams information table for tensor parallel. + * @param[in] input_rank_level is depth of rank nesting. + * @param[out] num_sub_streams is number of sub streams for tensor parallel. + * @return streams rank table which will be used by StreamsExecutor. + */ +std::vector> get_streams_rank_table(const std::vector>& streams_info_table, + const int input_rank_level, + int& num_sub_streams); + /** * @brief Get model_prefer_threads * @param[in] num_streams is target streams set by user via NUM_STREAMS or hints. diff --git a/src/plugins/intel_cpu/src/graph.cpp b/src/plugins/intel_cpu/src/graph.cpp index bfb28f769b95e7..898f69fef766c4 100644 --- a/src/plugins/intel_cpu/src/graph.cpp +++ b/src/plugins/intel_cpu/src/graph.cpp @@ -233,30 +233,6 @@ void Graph::Replicate(const std::shared_ptr &model) { } } -void Graph::GroupParallelNodes() { - std::map> pdomain_nodes; - for (size_t k = 0; k < graphNodes.size(); k++) { - auto& node = graphNodes[k]; - auto& domain = node->getParallelDomain(); - if (domain.empty()) - continue; - if (pdomain_nodes.count(domain) == 0) - pdomain_nodes[domain] = {}; - pdomain_nodes[domain].push_back(node); - } - - // record valid paralell_nodes - for (auto& pn : pdomain_nodes) { - auto& node_ptrs = pn.second; - if (node_ptrs.size() > 1) { - // parallelWith includes pointer to itself - for (auto& pnode : node_ptrs) { - pnode->parallelWith = node_ptrs; - } - } - } -} - static std::vector IdentifySyncPoints(const std::vector& graphNodes) { OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::IdentifySyncPoints"); std::vector syncNodesInds; @@ -352,8 +328,6 @@ void Graph::InitGraph(bool optimize) { optimizer.ApplyImplSpecificGraphOptimizations(*this); - GroupParallelNodes(); - SortTopologically(); const bool hasDynNodes = ProcessDynNodes(); @@ -1382,87 +1356,27 @@ void Graph::InferDynamic(SyncInferRequest* request, UpdateStrategy&& update) { } inline void Graph::ExecuteNode(const NodePtr& node, const dnnl::stream& stream) const { - if (!node->parallelWith.empty()) { - // run nodes in parallel - auto& parallelNodes = node->parallelWith; - if (node == parallelNodes[0]) { - if (const auto& cpuExecutor = context->getCPUStreamExecutor()) { - auto num_parallel_nodes = parallelNodes.size(); - ParalleMtNuma(num_parallel_nodes, cpuExecutor, [&](int subStreamID, size_t i) { - auto& n = parallelNodes[i]; - - if (n->isDynamicNode()) { - n->executeDynamic(stream, subStreamID); - } else { - n->executeStatic(stream, subStreamID); - } - }); - } else { - // fallback to serialize executor - for (auto& node : parallelNodes) { - if (node->isDynamicNode()) { - node->executeDynamic(stream); - } else { - node->executeStatic(stream); - } - } - } - } + DUMP(node, getConfig().debugCaps, infer_count); + OV_ITT_SCOPED_TASK(itt::domains::intel_cpu, node->profiling.execute); + DEBUG_LOG(*node); + // TODO: 132954 workaround for latency + int numaID = GetNumaNodeId(); + if (node->isDynamicNode()) { + node->executeDynamic(stream, numaID); } else { - DUMP(node, getConfig().debugCaps, infer_count); - OV_ITT_SCOPED_TASK(itt::domains::intel_cpu, node->profiling.execute); - DEBUG_LOG(*node); - // TODO: 132954 workaround for latency - int subStreamID = -1; -#if defined(__x86_64__) && defined(__linux__) - if ((getGraphContext()->getCPUStreamExecutor()) && (getConfig().hintPerfMode == ov::hint::PerformanceMode::LATENCY)) { - subStreamID = getGraphContext()->getCPUStreamExecutor()->get_numa_node_id(); - } -#endif - if (node->isDynamicNode()) { - node->executeDynamic(stream, subStreamID); - } else { - node->executeStatic(stream, subStreamID); - } + node->executeStatic(stream, numaID); } } -void Graph::ParalleMtNuma(size_t num_nodes, - ov::threading::CPUStreamsExecutor::Ptr executor, - const std::function& func) const { - OPENVINO_ASSERT(num_nodes > 1, "Parallel Nodes must be more than 1. But now got ", - num_nodes, - " Nodes, which shouldn't invoke multi nodes parallel."); - std::atomic nodes_remain(num_nodes); - int cur_numa_id = executor->get_numa_node_id(); - // enqueue (nsockets-1) sub stream tasks - int sub_stream_id = 0; - for (size_t socket_id = 0; socket_id < num_nodes; socket_id++) { - if (socket_id != static_cast(cur_numa_id)) { - size_t i0{0}, i1{0}; - splitter(num_nodes, num_nodes, socket_id, i0, i1); - executor->run_sub_stream( - [socket_id, i0, i1, &func, &nodes_remain]() { - for (size_t i = i0; i < i1; i++) { - func(socket_id, i); - nodes_remain--; - } - }, - sub_stream_id); - sub_stream_id++; - } - } - // run in main stream (current socket) - { - size_t i0{0}, i1{0}; - splitter(num_nodes, num_nodes, static_cast(cur_numa_id), i0, i1); - for (size_t i = i0; i < i1; i++) { - func(cur_numa_id, i); - nodes_remain--; - } +int Graph::GetNumaNodeId() const { + int numaNodeId = -1; +#if defined(__x86_64__) && defined(__linux__) + if ((getGraphContext()->getCPUStreamExecutor()) && + (getConfig().hintPerfMode == ov::hint::PerformanceMode::LATENCY)) { + numaNodeId = getGraphContext()->getCPUStreamExecutor()->get_numa_node_id(); } - // wait and sync - while (nodes_remain.load() > 0) {} +#endif + return numaNodeId; } void Graph::Infer(SyncInferRequest* request) { @@ -1504,29 +1418,12 @@ void Graph::SortTopologically() { if (node->execIndex >= 0) return; // already visited - if (!node->parallelWith.empty()) { - for (auto& n : node->parallelWith) { - for (size_t i = 0; i < n->getParentEdges().size(); i++) { - visit(n->getParentEdgeAt(i)->getParent()); - } - } - - // parallel nodes has same execIndex - // so they can provide correct start/end time point for - // their input and output memory object - ++execIndexCnt; - for (auto& n : node->parallelWith) { - sorted.push_back(n); - n->execIndex = execIndexCnt; - } - } else { - for (size_t i = 0; i < node->getParentEdges().size(); i++) { - visit(node->getParentEdgeAt(i)->getParent()); - } - - sorted.push_back(node); - node->execIndex = ++execIndexCnt; + for (size_t i = 0; i < node->getParentEdges().size(); i++) { + visit(node->getParentEdgeAt(i)->getParent()); } + + sorted.push_back(node); + node->execIndex = ++execIndexCnt; }; // First execute MemoryInput because it will change the memory pointer of diff --git a/src/plugins/intel_cpu/src/graph.h b/src/plugins/intel_cpu/src/graph.h index 6816dcc75c1a67..f91275f399ca95 100644 --- a/src/plugins/intel_cpu/src/graph.h +++ b/src/plugins/intel_cpu/src/graph.h @@ -223,7 +223,6 @@ class Graph { void ResolveEdgeConflicts(); void ResolveComplexInplaceConflicts(); bool ProcessDynNodes(); - void GroupParallelNodes(); void Allocate(const std::vector& syncNodesInds); void AllocateWithReuse(const std::vector& syncNodesInds); void ExecuteNode(const NodePtr& node, const dnnl::stream& stream) const; @@ -232,9 +231,6 @@ class Graph { template void InferDynamic(SyncInferRequest* request, UpdateStrategy&& update); - void ParalleMtNuma(size_t num_nodes, - ov::threading::CPUStreamsExecutor::Ptr executor, - const std::function& func) const; friend class intel_cpu::SyncInferRequest; friend std::shared_ptr dump_graph_as_ie_ngraph_net(const Graph &graph); @@ -259,6 +255,7 @@ class Graph { void EnforceBF16(); void insertReorder(EdgePtr& edge, bool isOptimized, std::unordered_set& uniqueLayerNames); void insertConvert(EdgePtr& edge); + int GetNumaNodeId() const; }; using GraphPtr = std::shared_ptr; diff --git a/src/plugins/intel_cpu/src/graph_context.cpp b/src/plugins/intel_cpu/src/graph_context.cpp index c06cb614d03a8c..2699a8854afb80 100644 --- a/src/plugins/intel_cpu/src/graph_context.cpp +++ b/src/plugins/intel_cpu/src/graph_context.cpp @@ -11,11 +11,13 @@ namespace intel_cpu { GraphContext::GraphContext(const Config& config, WeightsSharing::Ptr w_cache, bool isGraphQuantized, - ov::threading::IStreamsExecutor::Ptr streamExecutor) + ov::threading::IStreamsExecutor::Ptr streamExecutor, + std::shared_ptr sub_memory_manager) : config(config), weightsCache(std::move(w_cache)), isGraphQuantizedFlag(isGraphQuantized), streamExecutor(streamExecutor), + subMemoryManager(sub_memory_manager), memoryStatesRegister(std::make_shared()) { rtParamsCache = std::make_shared(config.rtCacheCapacity); // primitive/executors can be shared across sub-stream diff --git a/src/plugins/intel_cpu/src/graph_context.h b/src/plugins/intel_cpu/src/graph_context.h index 0bca410fca3c54..138ccebe0f9a40 100644 --- a/src/plugins/intel_cpu/src/graph_context.h +++ b/src/plugins/intel_cpu/src/graph_context.h @@ -5,6 +5,7 @@ #pragma once #include "openvino/runtime/threading/cpu_streams_executor.hpp" +#include "sub_memory_manager.hpp" #include "cache/multi_cache.h" #include "config.h" #include "dnnl_scratch_pad.h" @@ -25,7 +26,8 @@ class GraphContext { GraphContext(const Config& config, WeightsSharing::Ptr w_cache, bool isGraphQuantized, - ov::threading::IStreamsExecutor::Ptr streamExecutor = nullptr); + ov::threading::IStreamsExecutor::Ptr streamExecutor = nullptr, + std::shared_ptr sub_memory_manager = nullptr); const Config& getConfig() const { return config; @@ -62,6 +64,10 @@ class GraphContext { return cpuStreamExecutor; } + std::shared_ptr getSubMemory() const { + return subMemoryManager; + } + int getNumNumaNodes() const { return numNumaNodes; } @@ -86,6 +92,8 @@ class GraphContext { ov::threading::CPUStreamsExecutor::Ptr cpuStreamExecutor; // cpu stream executor for current graph + std::shared_ptr subMemoryManager; + int numNumaNodes = 1; std::shared_ptr memoryStatesRegister; diff --git a/src/plugins/intel_cpu/src/infer_request.cpp b/src/plugins/intel_cpu/src/infer_request.cpp index 82b72137b6b561..2d382c00508287 100644 --- a/src/plugins/intel_cpu/src/infer_request.cpp +++ b/src/plugins/intel_cpu/src/infer_request.cpp @@ -18,6 +18,7 @@ #include "proxy_mem_mgr.h" #include "utils/general_utils.h" #include "utils/ngraph_utils.hpp" +#include "openvino/runtime/threading/cpu_message.hpp" using OvString = ov::element_type_traits::value_type; @@ -104,8 +105,15 @@ void SyncInferRequest::infer() { OV_ITT_SCOPED_TASK(itt::domains::intel_cpu, m_profiling_task); auto graphLock = m_compiled_model->get_graph(); m_graph = &(graphLock._graph); + auto message = ov::threading::message_manager(); throw_if_canceled(); + if (m_asyncRequest->m_has_sub_infers) { + sub_streams_infer(); + message->server_wait(); + return; + } + convert_batched_tensors(); if (m_batched_tensors.size() > 0) { // batched_tensors will be updated for each infer, external_ptr should be update together @@ -303,6 +311,15 @@ void SyncInferRequest::change_default_ptr() { } std::vector> SyncInferRequest::query_state() const { + if (m_asyncRequest->m_has_sub_infers) { + auto requests = m_asyncRequest->getSubInferRequest(); + std::vector> states; + for (auto request : requests) { + auto cur = request->query_state(); + states.insert(states.end(), cur.begin(), cur.end()); + } + return states; + } return {m_memory_states.begin(), m_memory_states.end()}; } @@ -600,6 +617,38 @@ SyncInferRequest::OutputControlBlock::OutputControlBlock(const ov::element::Type m_tensor = std::make_shared(memory); } +void SyncInferRequest::sub_streams_infer() { + std::map, ov::SoPtr> input_tensors; + auto message = ov::threading::message_manager(); + auto requests = m_asyncRequest->getSubInferRequest(); + auto inputs = get_inputs(); + auto outputs = get_outputs(); + + size_t requests_num = requests.size(); + + if (requests.size() > 0) { + for (const auto& output : outputs) { + auto tensor = requests[0]->get_tensor(output); + set_tensor(output, tensor); + } + for (size_t i = 0; i < requests_num; i++) { + for (auto& input : inputs) { + auto tensor = get_tensor(input); + requests[i]->set_tensor(input, tensor); + } + + requests[i]->set_callback([message](const std::exception_ptr& ptr) { + ov::threading::MessageInfo msg_info; + msg_info.msg_type = ov::threading::MsgType::CALL_BACK; + message->send_message(msg_info); + }); + } + for (size_t i = 0; i < requests_num; i++) { + requests[i]->start_async(); + } + } +} + } // namespace intel_cpu } // namespace ov diff --git a/src/plugins/intel_cpu/src/infer_request.h b/src/plugins/intel_cpu/src/infer_request.h index e3839466f0ce0e..2e097c87673a37 100644 --- a/src/plugins/intel_cpu/src/infer_request.h +++ b/src/plugins/intel_cpu/src/infer_request.h @@ -104,6 +104,8 @@ class SyncInferRequest : public ov::ISyncInferRequest { const ov::Output& get_internal_port(const ov::Output& port) const; + void sub_streams_infer(); + private: std::unordered_map m_outputControlBlocks; diff --git a/src/plugins/intel_cpu/src/node.h b/src/plugins/intel_cpu/src/node.h index eb1f84dc8b9e34..2095907b860508 100644 --- a/src/plugins/intel_cpu/src/node.h +++ b/src/plugins/intel_cpu/src/node.h @@ -658,7 +658,6 @@ class Node { std::vector fusedWith; std::vector mergedWith; - std::vector parallelWith; int curNumaNode = -1; void toNumaNode(int numaID); diff --git a/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp index da3dcafa4750ef..d7fbd942e124c9 100644 --- a/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp +++ b/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp @@ -9,6 +9,7 @@ #include #include "common/cpu_convert.h" +#include "common/cpu_memcpy.h" #include "dnnl_extension_utils.h" #include "executors/memory_arguments.hpp" #include "graph_context.h" @@ -19,6 +20,7 @@ #include "nodes/executors/executor.hpp" #include "nodes/executors/fullyconnected_config.hpp" #include "openvino/core/type/element_type.hpp" +#include "openvino/runtime/threading/cpu_message.hpp" #include "post_ops.hpp" #include "shape_inference/custom/fullyconnected.hpp" #include "transformations/cpu_opset/common/op/fully_connected.hpp" @@ -58,10 +60,23 @@ bool FullyConnected::isSupportedOperation(const std::shared_ptr& return true; } +void FullyConnected::initTensorParallelConfig(const GraphContext::CPtr context) { + if (context->getCPUStreamExecutor()) { + if (!context->getCPUStreamExecutor()->get_rank().empty()) { + // init tp_cfg.w_rank and tp_cfg.w_size + tp_cfg.w_rank = context->getCPUStreamExecutor()->get_rank()[0]; + tp_cfg.w_size = ov::threading::message_manager()->get_num_sub_streams(); + tp_cfg.enable_tensor_parallel = tp_cfg.w_size > 1 ? true : false; + tp_cfg.sub_memory = context->getSubMemory(); + } + } +} + FullyConnected::FullyConnected(const std::shared_ptr& op, const GraphContext::CPtr context) : Node(op, context, FCShapeInferFactory(op)), errorPrefix("FullyConnected node with name '" + getName() + "'") { std::string errorMessage; + initTensorParallelConfig(context); if (!isSupportedOperation(op, errorMessage)) OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage); } @@ -73,6 +88,36 @@ bool FullyConnected::canBeExecutedInInt8() const { return one_of(srcType, ov::element::u8, ov::element::i8) && weiType == ov::element::i8; } +void FullyConnected::needPrepareParamsForTensorParallel() { + if (tp_cfg.enable_tensor_parallel) { + // must call in dynamic + const auto dstMemoryBuffer = getDstMemoryAtPort(0); + + auto split_parts = [](int len, int n) { + int average = len / n; + std::vector parts(n, average); + parts.back() = len - average * (n - 1); + return parts; + }; + + int dim = -1; + auto dst_shape = dstMemoryBuffer->getShape(); + auto dst_desc = dstMemoryBuffer->getDescPtr(); + auto dims = dst_shape.getDims(); + if (dim < 0) { + dim += dims.size(); + } + assert(dims[dim] >= tp_cfg.w_size); + auto splited_dim_vec = split_parts(dims[dim], tp_cfg.w_size); + + VectorDims new_dims = dims; + new_dims[dim] = splited_dim_vec[tp_cfg.w_rank]; + auto memory_desc = dst_desc->cloneWithNewDims(new_dims, true); + tp_cfg.cached_dst->redefineDesc(memory_desc); + memory[ARG_DST] = tp_cfg.cached_dst; + } +} + ExecutorPtr FullyConnected::createExecutor() { const auto& executor = factory->make(memory); getSelectedPrimitiveDescriptor()->setImplementationType(executor->implType()); @@ -81,11 +126,108 @@ ExecutorPtr FullyConnected::createExecutor() { } void FullyConnected::prepareParams() { + needPrepareParamsForTensorParallel(); executor = createExecutor(); } +void FullyConnected::initTensorParallelSync() { + if (tp_cfg.enable_tensor_parallel) { + tp_cfg.id = tp_cfg.sub_memory->get_memory_id(tp_cfg.w_rank); + tp_cfg.sub_memory->set_memory_used(tp_cfg.id, tp_cfg.w_rank); + while (true) { + std::lock_guard lock(tp_cfg.sub_memory->_flagMutex); + if (tp_cfg.sub_memory->_use_count[tp_cfg.id] == tp_cfg.w_size) { + tp_cfg.sub_memory->_use_count[tp_cfg.id] = 0; + for (int i = 0; i < tp_cfg.w_size; i++) { + tp_cfg.sub_memory->_memorys_table[tp_cfg.id][i].flag = false; + } + } + if (tp_cfg.sub_memory->_use_count[tp_cfg.id] == 0) { + break; + } + } + } +} + +void FullyConnected::execTensorParallelSync() { + if (tp_cfg.enable_tensor_parallel) { + // dst + auto dst = getDstMemoryAtPort(0); + auto dst_ptr = static_cast(dst->getData()); + + auto shape = dst->getShape(); + auto dims = shape.getDims(); + auto prec = dst->getPrecision(); + + // cur dst + auto cur_dst = memory[ARG_DST]; + + auto split_parts = [](int len, int n) { + int average = len / n; + std::vector parts(n, average); + parts.back() = len - average * (n - 1); + return parts; + }; + + const int dim = dims.size() - 1; + // selected dim bytes + auto channel_size = dims[dim] * prec.size(); + // total bytes + auto mem_size = dst->getSize(); + // the steps need to copy. + const size_t count = (mem_size / channel_size); + + auto splited_dim_vec = split_parts(dims[dim], tp_cfg.w_size); + const auto strideSize = splited_dim_vec[0] * prec.size(); + + tp_cfg.sub_memory->_memorys_table[tp_cfg.id][tp_cfg.w_rank].send_buf = cur_dst->getData(); + tp_cfg.sub_memory->_memorys_table[tp_cfg.id][tp_cfg.w_rank].flag = true; + + std::vector wait_list(tp_cfg.w_size, 1); + while (true) { + int wait_size = 0; + for (int idx = 0; idx < tp_cfg.w_size; idx++) { + if (wait_list[idx] > 0 && tp_cfg.sub_memory->_memorys_table[tp_cfg.id][idx].flag) { + auto new_ptr = static_cast(tp_cfg.sub_memory->_memorys_table[tp_cfg.id][idx].send_buf); + const auto copySize = splited_dim_vec[idx] * prec.size(); // bytes of half selected dim. + const size_t unloop = 8; + size_t step = count / unloop; + parallel_for(step, [&](size_t i){ + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop) * channel_size, new_ptr + (i * unloop) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 1) * channel_size, new_ptr + (i * unloop + 1) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 2) * channel_size, new_ptr + (i * unloop + 2) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 3) * channel_size, new_ptr + (i * unloop + 3) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 4) * channel_size, new_ptr + (i * unloop + 4) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 5) * channel_size, new_ptr + (i * unloop + 5) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 6) * channel_size, new_ptr + (i * unloop + 6) * copySize, copySize); + cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 7) * channel_size, new_ptr + (i * unloop + 7) * copySize, copySize); + }); + size_t tail = count & ~(unloop - 1); + for (size_t i = tail; i < count; ++i) { + size_t dst_offset = i * channel_size + idx * strideSize; + size_t src_offset = i * copySize; + cpu_parallel_memcpy(dst_ptr + dst_offset, new_ptr + src_offset, copySize); + } + wait_list[idx] = 0; + } + wait_size += wait_list[idx]; + } + if (wait_size == 0) { + break; + } + } + { + std::lock_guard lock(tp_cfg.sub_memory->_flagMutex); + tp_cfg.sub_memory->_use_count[tp_cfg.id]++; + } + } +} void FullyConnected::execute(dnnl::stream strm) { + initTensorParallelSync(); + executor->execute(memory); + + execTensorParallelSync(); } void FullyConnected::executeDynamicImpl(dnnl::stream strm) { @@ -222,9 +364,29 @@ static bool useSparseWeightsDecompression(const NodePtr& weightsInput, return sparseRate >= minSparseRate; } +void FullyConnected::needUpdateDQScaleForTensorParallel(std::vector& dequantizationScales) { + if (tp_cfg.enable_tensor_parallel) { + auto split_parts = [](int len, int n) { + int average = len / n; + std::vector parts(n, average); + parts.back() = len - average * (n - 1); + return parts; + }; + auto DQScales = getDQScales(); + auto split_lens = split_parts(DQScales.size(), tp_cfg.w_size); + auto split_offset = tp_cfg.w_rank * split_lens[0]; + std::vector newDQScales(split_lens[tp_cfg.w_rank]); + std::copy(DQScales.begin() + split_offset, DQScales.begin() + split_offset + split_lens[tp_cfg.w_rank], newDQScales.begin()); + dequantizationScales = newDQScales; + } +} + void FullyConnected::initSupportedPrimitiveDescriptors() { attrs.withBias = getOriginalInputsNumber() == 3; + attrs.dequantizationScales = getDQScales(); + needUpdateDQScaleForTensorParallel(attrs.dequantizationScales); + attrs.sparseWeights = useSparseWeightsDecompression(getParentEdgeAt(WEIGHTS_ID)->getParent(), getOriginalInputPrecisionAtPort(DATA_ID), context->getConfig().fcSparseWeiDecompressionRate); @@ -259,6 +421,9 @@ void FullyConnected::initSupportedPrimitiveDescriptors() { {ARG_DST, dstDescs[0]}, }; + needUpdateScaleForTensorParallel(); + needUpdateZeroPointForTensorParallel(); + auto executionContext = std::make_shared(context, getImplPriority(), privateWeightCache); factory = std::make_shared>(attrs, postOps, executionContext, descs); const auto nodeDescriptors = factory->getProperMemoryDescriptors(descs); @@ -274,11 +439,55 @@ void FullyConnected::initSupportedPrimitiveDescriptors() { supportedPrimitiveDescriptors.emplace_back(nodeConfig, impl_desc_type::undef); } +void FullyConnected::needSplitMemoryForTensorParallel() { + if (tp_cfg.enable_tensor_parallel) { + auto src = getSrcMemoryAtPort(DATA_ID); + auto wgt = getSrcMemoryAtPort(WEIGHTS_ID); + auto dst = getDstMemoryAtPort(0); + // src + memory[ARG_SRC] = getSrcMemoryAtPort(DATA_ID); + // wgt + // split N direction + tp_cfg.cached_splited_weight = attrs.weightsNonTransposed ? split_vertical(context->getEngine(), wgt, 0, tp_cfg.w_rank, tp_cfg.w_size) + : split_horizontal(context->getEngine(), wgt, 0, tp_cfg.w_rank, tp_cfg.w_size); + memory[ARG_WEI] = tp_cfg.cached_splited_weight; + // bias + if (attrs.withBias) { + auto bias = getSrcMemoryAtPort(BIAS_ID); + auto select_bias = split_horizontal(context->getEngine(), bias, 0, tp_cfg.w_rank, tp_cfg.w_size); + tp_cfg.cached_splited_bias = select_bias; + } else { + tp_cfg.cached_splited_bias = MemoryDescUtils::makeEmptyMemory(context); + } + memory[ARG_BIAS] = tp_cfg.cached_splited_bias; + // dst + memory[ARG_DST] = getDstMemoryAtPort(0); + tp_cfg.cached_dst = split_horizontal(context->getEngine(), dst, -1, tp_cfg.w_rank, tp_cfg.w_size, false); + } +} + +void FullyConnected::needUpdateTensorParalelConfig() { + // tensor parallel should be disabled in two conditions. + // 1. weight shape is dynamic + // 2. last dim can be splited. + if (tp_cfg.enable_tensor_parallel) { + auto shape = getSrcMemoryAtPort(WEIGHTS_ID)->getShape(); + if (shape.isDynamic()) { + tp_cfg.enable_tensor_parallel = false; + } else if (shape.getDims()[0] < static_cast(tp_cfg.w_size)) { + tp_cfg.enable_tensor_parallel = false; + } + } +} void FullyConnected::createPrimitive() { + needUpdateTensorParalelConfig(); + memory[ARG_SRC] = getSrcMemoryAtPort(DATA_ID); memory[ARG_WEI] = getSrcMemoryAtPort(WEIGHTS_ID); memory[ARG_BIAS] = attrs.withBias ? getSrcMemoryAtPort(BIAS_ID) : MemoryDescUtils::makeEmptyMemory(context); memory[ARG_DST] = getDstMemoryAtPort(0); + + needSplitMemoryForTensorParallel(); // @todo should we preconfigure only for dynamic shapes? // Since for static shapes primitive is created in scope of compile_model() anyway factory->preconfigure(memory); @@ -302,12 +511,47 @@ ov::element::Type FullyConnected::getRuntimePrecision() const { return getMaxPrecision(srcTypes); } +void FullyConnected::needUpdateScaleForTensorParallel() { + if (tp_cfg.enable_tensor_parallel && tp_cfg.cached_scale) { + attrs.decompressionMultiplyPtr = tp_cfg.cached_scale; + } +} + +void FullyConnected::needSplitScaleForTensorParallel(const MemoryCPtr& memory) { + if (tp_cfg.enable_tensor_parallel && !tp_cfg.cached_scale) { + auto scale_mem = std::const_pointer_cast(memory); + tp_cfg.cached_scale = attrs.weightsNonTransposed ? split_vertical(context->getEngine(), scale_mem, 0, tp_cfg.w_rank, tp_cfg.w_size) + : split_horizontal(context->getEngine(), scale_mem, 0, tp_cfg.w_rank, tp_cfg.w_size); + } +} + +void FullyConnected::needUpdateZeroPointForTensorParallel() { + if (tp_cfg.enable_tensor_parallel && tp_cfg.cached_zeropoint) { + attrs.decompressionSubtractPtr = tp_cfg.cached_zeropoint; + } +} + +void FullyConnected::needSplitZeroPointForTensorParallel(const MemoryCPtr& memory) { + if (tp_cfg.enable_tensor_parallel && !tp_cfg.cached_zeropoint) { + auto zeropoint_mem = std::const_pointer_cast(memory); + auto element_num = memory->getSize() / memory->getPrecision().size(); + if (element_num == 1) { + tp_cfg.cached_zeropoint = zeropoint_mem; + } else { + tp_cfg.cached_zeropoint = attrs.weightsNonTransposed ? split_vertical(context->getEngine(), zeropoint_mem, 0, tp_cfg.w_rank, tp_cfg.w_size) + : split_horizontal(context->getEngine(), zeropoint_mem, 0, tp_cfg.w_rank, tp_cfg.w_size); + } + } +} + void FullyConnected::fuseDecompressionMultiply(const MemoryCPtr& memory) { attrs.decompressionMultiplyPtr = memory; + needSplitScaleForTensorParallel(memory); } void FullyConnected::fuseDecompressionSubtract(const MemoryCPtr& memory) { attrs.decompressionSubtractPtr = memory; + needSplitZeroPointForTensorParallel(memory); } } // namespace node diff --git a/src/plugins/intel_cpu/src/nodes/fullyconnected.h b/src/plugins/intel_cpu/src/nodes/fullyconnected.h index 06b83d6a784dd9..be29342b851988 100644 --- a/src/plugins/intel_cpu/src/nodes/fullyconnected.h +++ b/src/plugins/intel_cpu/src/nodes/fullyconnected.h @@ -16,11 +16,26 @@ #include "nodes/executors/memory_arguments.hpp" #include "nodes/executors/fullyconnected_config.hpp" #include "post_ops.hpp" +#include "openvino/runtime/threading/cpu_message.hpp" namespace ov { namespace intel_cpu { namespace node { +// tensor parallel config +struct FCTensorParallelConfig { + int w_rank = -1; + int w_size = -1; + int id = 0; + bool enable_tensor_parallel = false; + std::shared_ptr sub_memory = nullptr; + MemoryPtr cached_splited_weight = nullptr; + MemoryPtr cached_splited_bias = nullptr; + MemoryPtr cached_scale = nullptr; + MemoryPtr cached_zeropoint = nullptr; + MemoryPtr cached_dst = nullptr; +}; + class FullyConnected : public Node { public: FullyConnected(const std::shared_ptr& op, const GraphContext::CPtr context); @@ -73,12 +88,26 @@ class FullyConnected : public Node { ExecutorPtr createExecutor(); void fuseDecompressionConstant(const MemoryCPtr& memory, MemoryCPtr& decompressionValuesPtr); + void initTensorParallelConfig(const GraphContext::CPtr context); + void needUpdateTensorParalelConfig(); + void needPrepareParamsForTensorParallel(); + void initTensorParallelSync(); + void execTensorParallelSync(); + void needSplitMemoryForTensorParallel(); + void needSplitScaleForTensorParallel(const MemoryCPtr& memory); + void needUpdateScaleForTensorParallel(); + void needSplitZeroPointForTensorParallel(const MemoryCPtr& memory); + void needUpdateZeroPointForTensorParallel(); + void needUpdateDQScaleForTensorParallel(std::vector& dequantizationScales); + FCAttrs attrs; PostOps postOps; MemoryArgs memory; ExecutorFactoryPtr factory; ExecutorPtr executor = nullptr; std::string errorPrefix; + + FCTensorParallelConfig tp_cfg; }; } // namespace node diff --git a/src/plugins/intel_cpu/src/plugin.cpp b/src/plugins/intel_cpu/src/plugin.cpp index c251f8c619e625..276502a0f62ebd 100644 --- a/src/plugins/intel_cpu/src/plugin.cpp +++ b/src/plugins/intel_cpu/src/plugin.cpp @@ -131,11 +131,13 @@ Plugin::Plugin() : deviceFullName(getDeviceFullName()), specialSetup(new CPUSpec }); auto& ov_version = ov::get_openvino_version(); m_compiled_model_runtime_properties["OV_VERSION"] = std::string(ov_version.buildNumber); + m_msg_manager = ov::threading::message_manager(); } Plugin::~Plugin() { executor_manager()->clear("CPU"); executor_manager()->clear("CPUStreamsExecutor"); + executor_manager()->clear("CPUMainStreamExecutor"); executor_manager()->clear("CPUCallbackExecutor"); } @@ -290,16 +292,11 @@ std::shared_ptr Plugin::compile_model(const std::shared_ptr< conf.readProperties(config, modelType); calculate_streams(conf, cloned_model); - if (conf.streamExecutorConfig.get_sub_stream_mode() == - IStreamsExecutor::Config::StreamsMode::SUB_STREAMS_FOR_SOCKET) { - int num_sub_streams = conf.streamExecutorConfig.get_sub_streams(); - transformations.SetSubStreamNum(num_sub_streams); - } - transformations.PostLpt(); transformations.Snippets(); transformations.CpuSpecificOpSet(); + DEBUG_LOG(PrintableModel(*cloned_model, "cpu_")); if ((cloned_model->inputs().size() != model->inputs().size()) || diff --git a/src/plugins/intel_cpu/src/plugin.h b/src/plugins/intel_cpu/src/plugin.h index 3332d873fdcf71..c2d24e98ee6f98 100644 --- a/src/plugins/intel_cpu/src/plugin.h +++ b/src/plugins/intel_cpu/src/plugin.h @@ -6,6 +6,7 @@ #include "compiled_model.h" #include "cpu_streams_calculation.hpp" +#include "openvino/runtime/threading/cpu_message.hpp" namespace ov { namespace intel_cpu { @@ -43,6 +44,8 @@ class Plugin : public ov::IPlugin { OPENVINO_THROW_NOT_IMPLEMENTED("Not Implemented get_default_context is not supported by CPU plugin!"); }; + std::shared_ptr m_msg_manager; + private: ov::Any get_ro_property(const std::string& name, const ov::AnyMap& options) const; diff --git a/src/plugins/intel_cpu/src/sub_memory_manager.hpp b/src/plugins/intel_cpu/src/sub_memory_manager.hpp new file mode 100644 index 00000000000000..4a0fd7ea0a21b3 --- /dev/null +++ b/src/plugins/intel_cpu/src/sub_memory_manager.hpp @@ -0,0 +1,57 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include +#include +#include +#include "cpu_memory.h" + +namespace ov { +namespace intel_cpu { +class SubMemoryManager { +public: + struct MemoryInfo { + void* send_buf; + bool flag; + bool last_used; + }; + + SubMemoryManager(int num_sub_streams) { + assert(num_sub_streams); + _num_sub_streams = num_sub_streams; + MemoryInfo memory_info; + memory_info.flag = false; + memory_info.last_used = false; + std::vector memorys; + memorys.assign(_num_sub_streams, memory_info); + _memorys_table.assign(2, memorys); + _use_count.assign(2, 0); + } + + int get_memory_id(int sub_stream_id) { + for (int i = 0; i < 2; i++) { + if (!_memorys_table[i][sub_stream_id].last_used) { + return i; + } + } + return -1; + } + + void set_memory_used(int memory_id, int sub_stream_id) { + _memorys_table[memory_id][sub_stream_id].last_used = true; + _memorys_table[(memory_id + 1) % 2][sub_stream_id].last_used = false; + } + + int _num_sub_streams; + std::vector> _memorys_table; + std::vector _use_count; + std::mutex _flagMutex; +}; +} // namespace intel_cpu + +} // namespace ov \ No newline at end of file diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp index 703df1d26cb686..20502f67d3645e 100644 --- a/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp +++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp @@ -26,7 +26,7 @@ namespace ov { namespace intel_cpu { -inline void ConvertToCPUSpecificOpset(std::shared_ptr &model, int subStreamNum) { +inline void ConvertToCPUSpecificOpset(std::shared_ptr &model) { RUN_ON_FUNCTION_SCOPE(ConvertToCPUSpecificOpset); ov::pass::Manager manager("CPU:ConvertToCPUSpecificOpset"); @@ -34,10 +34,6 @@ inline void ConvertToCPUSpecificOpset(std::shared_ptr &model, int sub CPU_REGISTER_PASS_COMMON(manager, ConvertMatMulToFC); CPU_REGISTER_PASS_X64(manager, MoveFCReshapeToWeights); CPU_REGISTER_PASS_X64(manager, ov::pass::Validate); - if (subStreamNum >= 1) { - CPU_REGISTER_PASS_COMMON(manager, SplitFC, subStreamNum); - CPU_REGISTER_PASS_COMMON(manager, ov::pass::Validate); - } CPU_REGISTER_PASS_COMMON(manager, AlignMatMulInputRanks); CPU_REGISTER_PASS_COMMON(manager, ConvertTileToSeqTiles); CPU_REGISTER_PASS_COMMON(manager, ConvertToPowerStatic); diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp index 726a416fe1c6c5..98da1be4c74876 100644 --- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp +++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp @@ -296,14 +296,10 @@ void Transformations::UpToLpt() { Lpt(defaultPrecisions); } -void Transformations::SetSubStreamNum(int SubStreams) { - subStreamNum = SubStreams; -} - void Transformations::CpuSpecificOpSet(void) { CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(this, Specific); - ConvertToCPUSpecificOpset(model, subStreamNum); + ConvertToCPUSpecificOpset(model); } void Transformations::PreLpt(const std::vector& defaultPrecisions) { diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h index 2c66d3abf1d2c8..420cf102f38fc6 100644 --- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h +++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h @@ -37,7 +37,6 @@ class Transformations { void CpuSpecificOpSet(); void PostLpt(); void Snippets(void); - void SetSubStreamNum(int); private: std::shared_ptr model; @@ -45,7 +44,6 @@ class Transformations { const ov::element::Type inferencePrecision; const Config::SnippetsMode snippetsMode; const Config& config; - int subStreamNum = -1; void PreLpt(const std::vector& defaultPrecisions); diff --git a/src/plugins/intel_cpu/tests/unit/streams_info/streams_e2e_test.cpp b/src/plugins/intel_cpu/tests/unit/streams_info/streams_e2e_test.cpp index 15d9098e9faf2a..7fd491e934f336 100644 --- a/src/plugins/intel_cpu/tests/unit/streams_info/streams_e2e_test.cpp +++ b/src/plugins/intel_cpu/tests/unit/streams_info/streams_e2e_test.cpp @@ -411,7 +411,7 @@ StreamGenerateionTestCase generation_latency_2sockets_48cores_10 = { false, ov::hint::PerformanceMode::LATENCY, {{48, 48, 0, 0, -1, -1}, {24, 24, 0, 0, 0, 0}, {24, 24, 0, 0, 1, 1}}, - {{1, MAIN_CORE_PROC, 24, 0, 0}, {-1, MAIN_CORE_PROC, 24, 1, 1}}, + {{1, MAIN_CORE_PROC, 48, -1, -1}, {-1, MAIN_CORE_PROC, 24, 0, 0}, {-1, MAIN_CORE_PROC, 24, 1, 1}}, }; StreamGenerateionTestCase generation_latency_2sockets_48cores_11 = { @@ -434,7 +434,7 @@ StreamGenerateionTestCase generation_latency_2sockets_48cores_11 = { false, ov::hint::PerformanceMode::LATENCY, {{48, 48, 0, 0, -1, -1}, {24, 24, 0, 0, 0, 0}, {24, 24, 0, 0, 1, 1}}, - {{1, MAIN_CORE_PROC, 24, 0, 0}, {-1, MAIN_CORE_PROC, 24, 1, 1}}, + {{1, MAIN_CORE_PROC, 48, -1, -1}, {-1, MAIN_CORE_PROC, 24, 0, 0}, {-1, MAIN_CORE_PROC, 24, 1, 1}}, }; StreamGenerateionTestCase generation_tput_1sockets_14cores_2 = { diff --git a/src/plugins/intel_cpu/tests/unit/streams_info/streams_info_table_test.cpp b/src/plugins/intel_cpu/tests/unit/streams_info/streams_info_table_test.cpp index 73869074bf9779..4cc795eeaf2910 100644 --- a/src/plugins/intel_cpu/tests/unit/streams_info/streams_info_table_test.cpp +++ b/src/plugins/intel_cpu/tests/unit/streams_info/streams_info_table_test.cpp @@ -58,17 +58,14 @@ StreamsCalculationTestCase _2sockets_104cores_latency_auto_1 = { 0, // param[in]: the current socket id of the running thread in this simulation "LATENCY", // param[in]: the performance hint in this simulation {ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL}, // param[in]: the hint of max threads per stream in this - // simulation + // simulation {{208, 104, 0, 104, -1, -1}, {104, 52, 0, 52, 0, 0}, {104, 52, 0, 52, 1, 1}}, // param[in]: the proc_type_table in this simulation - {{1, ALL_PROC, 104, 0, 0}, - {0, MAIN_CORE_PROC, 52, 0, 0}, - {0, HYPER_THREADING_PROC, 52, 0, 0}, - {-1, ALL_PROC, 104, 1, 1}, - {0, MAIN_CORE_PROC, 52, 1, 1}, - {0, HYPER_THREADING_PROC, 52, 1, 1}}, // param[expected out]: the expected result of streams_info_table in this - // simulation + {{1, MAIN_CORE_PROC, 64, -1, -1}, + {-1, MAIN_CORE_PROC, 32, 0, 0}, + {-1, MAIN_CORE_PROC, 32, 1, 1}}, // param[expected out]: the expected result of streams_info_table in this + // simulation }; StreamsCalculationTestCase _2sockets_104cores_latency_auto_2 = { @@ -81,7 +78,7 @@ StreamsCalculationTestCase _2sockets_104cores_latency_auto_2 = { "LATENCY", {ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL}, {{104, 104, 0, 0, -1, -1}, {52, 52, 0, 0, 0, 0}, {52, 52, 0, 0, 1, 1}}, - {{1, MAIN_CORE_PROC, 52, 0, 0}, {-1, MAIN_CORE_PROC, 52, 1, 1}}, + {{1, MAIN_CORE_PROC, 64, -1, -1}, {-1, MAIN_CORE_PROC, 32, 0, 0}, {-1, MAIN_CORE_PROC, 32, 1, 1}}, }; StreamsCalculationTestCase _2sockets_104cores_latency_auto_3 = { 1, @@ -97,16 +94,13 @@ StreamsCalculationTestCase _2sockets_104cores_latency_auto_3 = { {52, 26, 0, 26, 1, 0}, {52, 26, 0, 26, 2, 1}, {52, 26, 0, 26, 3, 1}}, - {{1, ALL_PROC, 104, -1, 0}, + {{1, ALL_PROC, 64, -1, -1}, + {-1, ALL_PROC, 32, -1, 0}, {0, MAIN_CORE_PROC, 26, 0, 0}, - {0, MAIN_CORE_PROC, 26, 1, 0}, - {0, HYPER_THREADING_PROC, 26, 0, 0}, - {0, HYPER_THREADING_PROC, 26, 1, 0}, - {-1, ALL_PROC, 104, -1, 1}, + {0, MAIN_CORE_PROC, 6, 1, 0}, + {-1, ALL_PROC, 32, -1, 1}, {0, MAIN_CORE_PROC, 26, 2, 1}, - {0, MAIN_CORE_PROC, 26, 3, 1}, - {0, HYPER_THREADING_PROC, 26, 2, 1}, - {0, HYPER_THREADING_PROC, 26, 3, 1}}, + {0, MAIN_CORE_PROC, 6, 3, 1}}, }; StreamsCalculationTestCase _2sockets_104cores_latency_auto_4 = { 1, @@ -118,12 +112,13 @@ StreamsCalculationTestCase _2sockets_104cores_latency_auto_4 = { "LATENCY", {ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL}, {{104, 104, 0, 0, -1, -1}, {26, 26, 0, 0, 0, 0}, {26, 26, 0, 0, 1, 0}, {26, 26, 0, 0, 2, 1}, {26, 26, 0, 0, 3, 1}}, - {{1, ALL_PROC, 52, -1, 0}, + {{1, ALL_PROC, 64, -1, -1}, + {-1, ALL_PROC, 32, -1, 0}, {0, MAIN_CORE_PROC, 26, 0, 0}, - {0, MAIN_CORE_PROC, 26, 1, 0}, - {-1, ALL_PROC, 52, -1, 1}, + {0, MAIN_CORE_PROC, 6, 1, 0}, + {-1, ALL_PROC, 32, -1, 1}, {0, MAIN_CORE_PROC, 26, 2, 1}, - {0, MAIN_CORE_PROC, 26, 3, 1}}, + {0, MAIN_CORE_PROC, 6, 3, 1}}, }; StreamsCalculationTestCase _2sockets_104cores_latency_platform_1 = { 1, @@ -2295,9 +2290,10 @@ StreamsCalculationTestCase _2sockets_mock_latency_22 = { "LATENCY", {ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL}, {{60, 30, 0, 30, -1, -1}, {40, 20, 0, 20, 0, 0}, {20, 10, 0, 10, 1, 1}}, - {{1, ALL_PROC, 40, 0, 0}, + {{1, ALL_PROC, 52, -1, -1}, + {-1, ALL_PROC, 32, 0, 0}, {0, MAIN_CORE_PROC, 20, 0, 0}, - {0, HYPER_THREADING_PROC, 20, 0, 0}, + {0, HYPER_THREADING_PROC, 12, 0, 0}, {-1, ALL_PROC, 20, 1, 1}, {0, MAIN_CORE_PROC, 10, 1, 1}, {0, HYPER_THREADING_PROC, 10, 1, 1}}, @@ -2340,16 +2336,13 @@ StreamsCalculationTestCase _2sockets_mock_latency_25 = { {60, 30, 0, 30, 1, 0}, {40, 20, 0, 20, 2, 1}, {20, 10, 0, 10, 3, 1}}, - {{1, ALL_PROC, 140, -1, 0}, - {0, MAIN_CORE_PROC, 40, 0, 0}, - {0, MAIN_CORE_PROC, 30, 1, 0}, - {0, HYPER_THREADING_PROC, 40, 0, 0}, - {0, HYPER_THREADING_PROC, 30, 1, 0}, - {-1, ALL_PROC, 60, -1, 1}, + {{1, ALL_PROC, 64, -1, -1}, + {-1, ALL_PROC, 32, -1, 0}, + {0, MAIN_CORE_PROC, 32, 0, 0}, + {-1, ALL_PROC, 32, -1, 1}, {0, MAIN_CORE_PROC, 20, 2, 1}, {0, MAIN_CORE_PROC, 10, 3, 1}, - {0, HYPER_THREADING_PROC, 20, 2, 1}, - {0, HYPER_THREADING_PROC, 10, 3, 1}}, + {0, HYPER_THREADING_PROC, 2, 2, 1}}, }; StreamsCalculationTestCase _2sockets_mock_latency_26 = { 1, @@ -2405,16 +2398,13 @@ StreamsCalculationTestCase _2sockets_mock_latency_28 = { {60, 30, 0, 30, 1, 0}, {40, 20, 0, 20, 2, 1}, {20, 10, 0, 10, 3, 1}}, - {{1, ALL_PROC, 140, -1, 0}, - {0, MAIN_CORE_PROC, 40, 0, 0}, - {0, MAIN_CORE_PROC, 30, 1, 0}, - {0, HYPER_THREADING_PROC, 40, 0, 0}, - {0, HYPER_THREADING_PROC, 30, 1, 0}, - {-1, ALL_PROC, 60, -1, 1}, + {{1, ALL_PROC, 64, -1, -1}, + {-1, ALL_PROC, 32, -1, 0}, + {0, MAIN_CORE_PROC, 32, 0, 0}, + {-1, ALL_PROC, 32, -1, 1}, {0, MAIN_CORE_PROC, 20, 2, 1}, {0, MAIN_CORE_PROC, 10, 3, 1}, - {0, HYPER_THREADING_PROC, 20, 2, 1}, - {0, HYPER_THREADING_PROC, 10, 3, 1}}, + {0, HYPER_THREADING_PROC, 2, 2, 1}}, }; StreamsCalculationTestCase _2sockets_mock_latency_29 = { 1, @@ -2518,7 +2508,7 @@ StreamsCalculationTestCase _2sockets_mock_latency_34 = { "LATENCY", {ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL}, {{48, 48, 0, 0, -1, -1}, {24, 24, 0, 0, 0, 0}, {24, 24, 0, 0, 1, 1}}, - {{1, MAIN_CORE_PROC, 24, 0, 0}, {-1, MAIN_CORE_PROC, 24, 1, 1}}, + {{1, MAIN_CORE_PROC, 48, -1, -1}, {-1, MAIN_CORE_PROC, 24, 0, 0}, {-1, MAIN_CORE_PROC, 24, 1, 1}}, }; StreamsCalculationTestCase _1sockets_mock_latency_1 = { 1, @@ -2642,7 +2632,7 @@ StreamsCalculationTestCase _2sockets_mock_latency_37 = { "LATENCY", {ov::hint::ModelDistributionPolicy::TENSOR_PARALLEL}, {{48, 48, 0, 0, -1, -1}, {24, 24, 0, 0, 0, 0}, {24, 24, 0, 0, 1, 1}}, - {{1, MAIN_CORE_PROC, 24, 1, 1}, {-1, MAIN_CORE_PROC, 24, 0, 0}}, + {{1, MAIN_CORE_PROC, 48, -1, -1}, {-1, MAIN_CORE_PROC, 24, 1, 1}, {-1, MAIN_CORE_PROC, 24, 0, 0}}, }; TEST_P(StreamsCalculationTests, StreamsCalculation) {} diff --git a/src/plugins/intel_cpu/tests/unit/streams_info/streams_rank_table_test.cpp b/src/plugins/intel_cpu/tests/unit/streams_info/streams_rank_table_test.cpp new file mode 100644 index 00000000000000..ce2dcb324d6837 --- /dev/null +++ b/src/plugins/intel_cpu/tests/unit/streams_info/streams_rank_table_test.cpp @@ -0,0 +1,125 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "common_test_utils/test_common.hpp" +#include "cpu_streams_calculation.hpp" + +using namespace testing; +using namespace ov; + +namespace { + +struct StreamsRankTestCase { + std::vector> stream_info_table; + int rank_level; + int num_sub_streams; + std::vector> stream_rank_table; +}; + +class StreamsRankTests : public ov::test::TestsCommon, + public testing::WithParamInterface> { +public: + void SetUp() override { + const auto& test_data = std::get<0>(GetParam()); + + int test_num_sub_streams; + std::vector> test_stream_rank_table = + ov::intel_cpu::get_streams_rank_table(test_data.stream_info_table, + test_data.rank_level, + test_num_sub_streams); + + ASSERT_EQ(test_data.stream_rank_table, test_stream_rank_table); + ASSERT_EQ(test_data.num_sub_streams, test_num_sub_streams); + } +}; + +StreamsRankTestCase _2sockets_mock_1 = { + {{1, ALL_PROC, 208, -1, -1}, + {-1, ALL_PROC, 104, 0, 0}, + {0, MAIN_CORE_PROC, 52, 0, 0}, + {0, HYPER_THREADING_PROC, 52, 0, 0}, + {-1, ALL_PROC, 104, 1, 1}, + {0, MAIN_CORE_PROC, 52, 1, 1}, + {0, HYPER_THREADING_PROC, 52, 1, 1}}, // param[in]: the expected result of streams_info_table in this simulation + 1, // param[in]: the number of rank level in this simulation + 2, // param[expected out]: the number of sub stream in this simulation + {{0}, {1}}, // param[expected out]: the expected result of streams_rank_table in thissimulation +}; +StreamsRankTestCase _2sockets_mock_2 = { + {{1, MAIN_CORE_PROC, 104, -1, -1}, {-1, MAIN_CORE_PROC, 52, 0, 0}, {-1, MAIN_CORE_PROC, 52, 1, 1}}, + 1, + 2, + {{0}, {1}}, +}; +StreamsRankTestCase _2sockets_mock_3 = { + {{1, ALL_PROC, 208, -1, -1}, + {-1, ALL_PROC, 104, -1, 0}, + {0, MAIN_CORE_PROC, 26, 0, 0}, + {0, MAIN_CORE_PROC, 26, 1, 0}, + {0, HYPER_THREADING_PROC, 26, 0, 0}, + {0, HYPER_THREADING_PROC, 26, 1, 0}, + {-1, ALL_PROC, 104, -1, 1}, + {0, MAIN_CORE_PROC, 26, 2, 1}, + {0, MAIN_CORE_PROC, 26, 3, 1}, + {0, HYPER_THREADING_PROC, 26, 2, 1}, + {0, HYPER_THREADING_PROC, 26, 3, 1}}, + 1, + 2, + {{0}, {1}}, +}; +StreamsRankTestCase _2sockets_mock_4 = { + {{1, MAIN_CORE_PROC, 104, -1, -1}, + {-1, MAIN_CORE_PROC, 26, 0, 0}, + {-1, MAIN_CORE_PROC, 26, 1, 0}, + {-1, MAIN_CORE_PROC, 26, 2, 1}, + {-1, MAIN_CORE_PROC, 26, 3, 1}}, + 1, + 4, + {{0}, {1}, {2}, {3}}, +}; +StreamsRankTestCase _2sockets_mock_5 = { + {{1, MAIN_CORE_PROC, 104, -1, -1}, + {-1, MAIN_CORE_PROC, 26, 0, 0}, + {-1, MAIN_CORE_PROC, 26, 1, 0}, + {-1, MAIN_CORE_PROC, 26, 2, 1}, + {-1, MAIN_CORE_PROC, 26, 3, 1}}, + 2, + 4, + {{0, 0}, {0, 1}, {1, 0}, {1, 1}}, +}; +StreamsRankTestCase _1sockets_mock_1 = { + {{1, MAIN_CORE_PROC, 16, 0, 0}, {-4, MAIN_CORE_PROC, 4, 0, 0}}, + 1, + 4, + {{0}, {1}, {2}, {3}}, +}; +StreamsRankTestCase _1sockets_mock_2 = { + {{1, MAIN_CORE_PROC, 16, 0, 0}, {-4, MAIN_CORE_PROC, 4, 0, 0}}, + 2, + 4, + {{0, 0}, {0, 1}, {1, 0}, {1, 1}}, +}; +StreamsRankTestCase _1sockets_mock_3 = { + {{1, MAIN_CORE_PROC, 32, 0, 0}, {-8, MAIN_CORE_PROC, 4, 0, 0}}, + 2, + 8, + {{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}}, +}; + +TEST_P(StreamsRankTests, StreamsRankTest) {} + +INSTANTIATE_TEST_SUITE_P(StreamsRankTable, + StreamsRankTests, + testing::Values(_2sockets_mock_1, + _2sockets_mock_2, + _2sockets_mock_3, + _2sockets_mock_4, + _2sockets_mock_5, + _1sockets_mock_1, + _1sockets_mock_2, + _1sockets_mock_3)); + +} // namespace From 2bfb63046103bb07a5d51fd59b5871ce806f8410 Mon Sep 17 00:00:00 2001 From: Xuejun Zhai Date: Tue, 20 Aug 2024 14:31:43 +0800 Subject: [PATCH 048/117] Don't allow to load library linking to another folder (#25958) ### Details: - *For the security purpose, don't allow to load plugin library linking to another folder* - *Both symbol link and hard link are checked* ### Tickets: - *CVS-142055* --------- Signed-off-by: Zhai, Xuejun --- src/common/util/CMakeLists.txt | 4 ++++ .../util/include/openvino/util/file_util.hpp | 21 +++++++++++++++++++ src/common/util/src/file_util.cpp | 11 ++++++++++ .../dev_api/openvino/core/so_extension.hpp | 3 +++ src/frontends/common/src/manager.cpp | 2 ++ src/inference/src/dev/core_impl.cpp | 3 ++- .../tests/functional/ov_core_test.cpp | 18 ++++++++++++++++ 7 files changed, 61 insertions(+), 1 deletion(-) diff --git a/src/common/util/CMakeLists.txt b/src/common/util/CMakeLists.txt index 6b5cf4b7a64192..efdae4b26837d8 100644 --- a/src/common/util/CMakeLists.txt +++ b/src/common/util/CMakeLists.txt @@ -41,6 +41,10 @@ target_link_libraries(${TARGET_NAME} PRIVATE ${CMAKE_DL_LIBS} PUBLIC openvino::p if (WIN32) target_link_libraries(${TARGET_NAME} PRIVATE Shlwapi) endif() + +if(LINUX) + target_link_libraries(${TARGET_NAME} PRIVATE stdc++fs) +endif() target_include_directories(${TARGET_NAME} PUBLIC $) ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME}) diff --git a/src/common/util/include/openvino/util/file_util.hpp b/src/common/util/include/openvino/util/file_util.hpp index 88b9110abeced8..7b28bda704a98b 100644 --- a/src/common/util/include/openvino/util/file_util.hpp +++ b/src/common/util/include/openvino/util/file_util.hpp @@ -12,6 +12,20 @@ #include "openvino/util/util.hpp" +#if !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) +# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L) && (_MSC_VER >= 1913)) +# if __has_include() +# include +namespace fs = std::filesystem; +# endif +# else +# define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING +# define _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM +# include +namespace fs = std::experimental::filesystem; +# endif +#endif + namespace ov { namespace util { @@ -397,5 +411,12 @@ inline std::basic_string make_path(const std::basic_string& folder, const return folder + ov::util::FileTraits::file_separator + file; } +/** + * @brief If the library path is symlink & the symlink file location is not in the real file folder, return true. Others + * return false. + * @param path - Library file path to check + * @return Bool value + */ +bool is_symlink_in_different_path(std::string library_path); } // namespace util } // namespace ov diff --git a/src/common/util/src/file_util.cpp b/src/common/util/src/file_util.cpp index 2846355e9aeb5f..8fa9e5e06b1b97 100644 --- a/src/common/util/src/file_util.cpp +++ b/src/common/util/src/file_util.cpp @@ -704,3 +704,14 @@ const char* ov::util::trim_file_name(const char* const fname) { #endif return fname_trim_ptr; } + +bool ov::util::is_symlink_in_different_path(std::string library_path) { +#if !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) + if (fs::is_symlink(library_path) && ov::util::get_absolute_file_path(ov::util::get_directory(library_path)) != + ov::util::get_directory(ov::util::get_absolute_file_path(library_path))) + return true; + return false; +#else + return false; +#endif +} diff --git a/src/core/dev_api/openvino/core/so_extension.hpp b/src/core/dev_api/openvino/core/so_extension.hpp index 931344b5fc4958..5db9879dc1cb88 100644 --- a/src/core/dev_api/openvino/core/so_extension.hpp +++ b/src/core/dev_api/openvino/core/so_extension.hpp @@ -3,6 +3,7 @@ // #pragma once +#include "openvino/core/except.hpp" #include "openvino/core/extension.hpp" #include "openvino/core/visibility.hpp" #include "openvino/util/file_util.hpp" @@ -40,6 +41,8 @@ inline std::string resolve_extension_path(const std::string& path) { } inline std::vector load_extensions(const std::string& path) { + OPENVINO_ASSERT(!ov::util::is_symlink_in_different_path(path), + "Cannot load extension with symlink path: \"" + path + "\"."); const std::string resolved_path = resolve_extension_path(path); auto so = ov::util::load_shared_object(resolved_path.c_str()); using CreateFunction = void(std::vector&); diff --git a/src/frontends/common/src/manager.cpp b/src/frontends/common/src/manager.cpp index 0a31f9a2c426e9..30bfc0a46c2e86 100644 --- a/src/frontends/common/src/manager.cpp +++ b/src/frontends/common/src/manager.cpp @@ -106,6 +106,8 @@ class FrontEndManager::Impl { } void register_front_end(const std::string& name, const std::string& library_path) { + OPENVINO_ASSERT(!ov::util::is_symlink_in_different_path(library_path), + "Cannot register plugin with symlink path: \"" + library_path + "\"."); auto lib_path = ov::util::from_file_path(ov::util::get_plugin_path(library_path)); PluginInfo plugin; plugin.m_file_path = lib_path; diff --git a/src/inference/src/dev/core_impl.cpp b/src/inference/src/dev/core_impl.cpp index 237c246ab38bdc..f8fcf26b006014 100644 --- a/src/inference/src/dev/core_impl.cpp +++ b/src/inference/src/dev/core_impl.cpp @@ -1189,7 +1189,8 @@ void ov::CoreImpl::register_plugin(const std::string& plugin, if (device_name.find('.') != std::string::npos) { OPENVINO_THROW("Device name must not contain dot '.' symbol"); } - + OPENVINO_ASSERT(!ov::util::is_symlink_in_different_path(plugin), + "Cannot registe plugin with symlink path: \"" + plugin + "\"."); PluginDescriptor desc{ov::util::get_plugin_path(plugin), properties}; register_plugin_in_registry_unsafe(device_name, desc); } diff --git a/src/inference/tests/functional/ov_core_test.cpp b/src/inference/tests/functional/ov_core_test.cpp index 26eb38e3fd13e5..acba5cc49123d3 100644 --- a/src/inference/tests/functional/ov_core_test.cpp +++ b/src/inference/tests/functional/ov_core_test.cpp @@ -95,4 +95,22 @@ TEST(CoreBaseTest, LoadOVFolderOverCWPathPluginXML) { remove_plugin_xml(ov_file_path); } +# if !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) +TEST(CoreBaseTest, AddExtensionwithSymlinkInDiffPlace) { + std::string openvino_template_extension = + ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), + std::string("openvino_template_extension") + OV_BUILD_POSTFIX); + + // Symlink file & the real file doesn't locale in the diff place. Will throw + fs::create_directory("test_link"); + std::string symlink_for_extension_copy_file = "test_link/symlink_for_extension_copy_file"; + + fs::create_symlink(openvino_template_extension, symlink_for_extension_copy_file); + ov::Core core; + EXPECT_NO_THROW(core.add_extension(openvino_template_extension)); + EXPECT_THROW(core.add_extension(symlink_for_extension_copy_file), std::runtime_error); + + ASSERT_TRUE(fs::remove_all("test_link")); +} +# endif #endif From 82bf2e5c814f91e0da9c372b16c8da467b48a0be Mon Sep 17 00:00:00 2001 From: "Min, Byungil" Date: Tue, 20 Aug 2024 17:21:23 +0900 Subject: [PATCH 049/117] [GPU][Debug] Support dynamic quantized for specified FC layer (#25914) + Added a new debug config OV_GPU_DynamicQuantizeLayers ### Details: - *item1* - *...* ### Tickets: - CVS-149215 --------- Signed-off-by: Min, Byung-il --- .../intel_gpu/runtime/debug_configuration.hpp | 4 +- .../fully_connected_kernel_bf_tiled.cpp | 15 +++++ .../src/runtime/debug_configuration.cpp | 56 +++++++++++++------ 3 files changed, 56 insertions(+), 19 deletions(-) diff --git a/src/plugins/intel_gpu/include/intel_gpu/runtime/debug_configuration.hpp b/src/plugins/intel_gpu/include/intel_gpu/runtime/debug_configuration.hpp index 589b5dd96cb055..348bfea1970a67 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/runtime/debug_configuration.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/runtime/debug_configuration.hpp @@ -140,7 +140,8 @@ class debug_configuration { int disable_runtime_skip_reorder; // Disable runtime skip reorder int disable_primitive_fusing; // Disable primitive fusing int disable_fake_alignment; // Disable fake alignment - int enable_dynamic_quantize; // Enable Dynamic quantization for fully connected primitive + int enable_dynamic_quantize; // Enable Dynamic quantization for Fully-connected primitive + std::vector dynamic_quantize_layers_without_onednn; // Specify Fully-connected layers which enable Dynamic quantization int disable_horizontal_fc_fusion; // Disable fc horizontal fusion std::set dump_iteration; // Dump n-th execution of network. std::vector load_layers_raw_dump; // List of layers to load dumped raw binary and filenames @@ -151,6 +152,7 @@ class debug_configuration { bool is_layer_for_dumping(const std::string& layerName, bool is_output = false, bool is_input = false) const; bool is_target_iteration(int64_t iteration) const; std::string get_matched_from_filelist(const std::vector& file_names, std::string pattern) const; + bool is_layer_name_matched(const std::string& layer_name, const std::string& pattern) const; struct memory_preallocation_params { bool is_initialized = false; diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp index 1613afec063eb1..61919c10b816ff 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp +++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp @@ -52,9 +52,24 @@ static std::pair get_output_aligned_bf_size(const fully_connecte // DYNAMIC_QUANTIZE static bool should_dynamic_quantize(const fully_connected_params& params) { auto dynamic_quantization_group_size = params.dynamic_quantization_group_size; + GPU_DEBUG_GET_INSTANCE(debug_config); GPU_DEBUG_IF(debug_config->enable_dynamic_quantize) { dynamic_quantization_group_size = quantize_grp_size; + + GPU_DEBUG_IF(!debug_config->dynamic_quantize_layers_without_onednn.empty()) { + auto layers = debug_config->dynamic_quantize_layers_without_onednn; + auto iter = std::find_if(layers.begin(), layers.end(), [&](const std::string& pattern){ + return debug_config->is_layer_name_matched(params.layerID, pattern); + }); + + if (iter != layers.end()) { + dynamic_quantization_group_size = quantize_grp_size; + GPU_DEBUG_COUT << "Found specified Fully-connected layer [" << params.layerID << "]. Enable Dynamic-quantize." << std::endl; + } else { + dynamic_quantization_group_size = 0; + } + } } if (params.inputs[0].GetFirstElementOffset() != 0) diff --git a/src/plugins/intel_gpu/src/runtime/debug_configuration.cpp b/src/plugins/intel_gpu/src/runtime/debug_configuration.cpp index 9a34d77ae47f3e..f0a31f81c2e2bd 100644 --- a/src/plugins/intel_gpu/src/runtime/debug_configuration.cpp +++ b/src/plugins/intel_gpu/src/runtime/debug_configuration.cpp @@ -181,7 +181,9 @@ static void print_help_messages() { message_list.emplace_back("OV_GPU_DisableRuntimeSkipReorder", "Disable runtime skip reorder."); message_list.emplace_back("OV_GPU_DisablePrimitiveFusing", "Disable primitive fusing"); message_list.emplace_back("OV_GPU_DisableFakeAlignment", "Disable fake alignment"); - message_list.emplace_back("OV_GPU_EnableDynamicQuantize", "Enable Dynamic quantization for fully connected primitive"); + message_list.emplace_back("OV_GPU_EnableDynamicQuantize", "Enable Dynamic quantization for Fully connected primitive"); + message_list.emplace_back("OV_GPU_DynamicQuantizeLayersWithoutOnednn", "Enable Dynamic quantization for specified Fully connected layers only, " + "separated by space. Support case-insensitive and regular expression. For example .*fully_connected.*"); message_list.emplace_back("OV_GPU_DisableHorizontalFCFusion", "Disable horizontal fc fusion"); message_list.emplace_back("OV_GPU_DumpIteration", "Dump n-th execution of network, separated by space."); message_list.emplace_back("OV_GPU_MemPreallocationOptions", "Controls buffer pre-allocation feature. Expects 4 values separated by space in " @@ -308,6 +310,8 @@ debug_configuration::debug_configuration() get_gpu_debug_env_var("MemPreallocationOptions", mem_preallocation_params_str); std::string load_dump_raw_bin_str; get_gpu_debug_env_var("LoadDumpRawBinary", load_dump_raw_bin_str); + std::string dynamic_quantize_layers_without_onednn_str; + get_gpu_debug_env_var("DynamicQuantizeLayersWithoutOnednn", dynamic_quantize_layers_without_onednn_str); if (help > 0) { print_help_messages(); @@ -346,6 +350,16 @@ debug_configuration::debug_configuration() } } + if (dynamic_quantize_layers_without_onednn_str.length() > 0) { + // Insert delimiter for easier parsing when used + dynamic_quantize_layers_without_onednn_str = " " + dynamic_quantize_layers_without_onednn_str + " "; + std::stringstream ss(dynamic_quantize_layers_without_onednn_str); + std::string layer; + while (ss >> layer) { + dynamic_quantize_layers_without_onednn.push_back(layer); + } + } + if (forced_impl_types_str.length() > 0) { forced_impl_types_str = " " + forced_impl_types_str + " "; std::stringstream ss(forced_impl_types_str); @@ -502,6 +516,28 @@ std::string debug_configuration::get_name_for_dump(const std::string& file_name) return filename; } +bool debug_configuration::is_layer_name_matched(const std::string& layer_name, const std::string& pattern) const { +#ifdef GPU_DEBUG_CONFIG + auto upper_layer_name = std::string(layer_name.length(), '\0'); + std::transform(layer_name.begin(), layer_name.end(), upper_layer_name.begin(), ::toupper); + auto upper_pattern = std::string(pattern.length(), '\0'); + std::transform(pattern.begin(), pattern.end(), upper_pattern.begin(), ::toupper); + + // Check pattern from exec_graph + size_t pos = upper_layer_name.find(':'); + auto upper_exec_graph_name = upper_layer_name.substr(pos + 1, upper_layer_name.size()); + if (upper_exec_graph_name.compare(upper_pattern) == 0) { + return true; + } + + // Check pattern with regular expression + std::regex re(upper_pattern); + return std::regex_match(upper_layer_name, re); +#else + return false; +#endif +} + bool debug_configuration::is_layer_for_dumping(const std::string& layer_name, bool is_output, bool is_input) const { #ifdef GPU_DEBUG_CONFIG // Dump result layer @@ -518,24 +554,8 @@ bool debug_configuration::is_layer_for_dumping(const std::string& layer_name, bo if (is_input == true && type == "parameter" && dump_layers_input == 1) return true; - auto is_match = [](const std::string& layer_name, const std::string& pattern) -> bool { - auto upper_layer_name = std::string(layer_name.length(), '\0'); - std::transform(layer_name.begin(), layer_name.end(), upper_layer_name.begin(), ::toupper); - auto upper_pattern = std::string(pattern.length(), '\0'); - std::transform(pattern.begin(), pattern.end(), upper_pattern.begin(), ::toupper); - // Check pattern from exec_graph - size_t pos = upper_layer_name.find(':'); - auto upper_exec_graph_name = upper_layer_name.substr(pos + 1, upper_layer_name.size()); - if (upper_exec_graph_name.compare(upper_pattern) == 0) { - return true; - } - // Check pattern with regular expression - std::regex re(upper_pattern); - return std::regex_match(upper_layer_name, re); - }; - auto iter = std::find_if(dump_layers.begin(), dump_layers.end(), [&](const std::string& dl){ - return is_match(layer_name, dl); + return is_layer_name_matched(layer_name, dl); }); return (iter != dump_layers.end()); #else From 23b633d3d2d675a09ecc844aa507b3ed2484c706 Mon Sep 17 00:00:00 2001 From: Maxim Vafin Date: Tue, 20 Aug 2024 10:44:24 +0200 Subject: [PATCH 050/117] Retry torchvision tests on OSError (#26066) ### Details: - *Retry torchvision tests on OSError* ### Tickets: - *CVS-149743* --- tests/model_hub_tests/pytorch/test_torchvision_models.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/model_hub_tests/pytorch/test_torchvision_models.py b/tests/model_hub_tests/pytorch/test_torchvision_models.py index 31aeaedb2366d4..6204d57741eaf5 100644 --- a/tests/model_hub_tests/pytorch/test_torchvision_models.py +++ b/tests/model_hub_tests/pytorch/test_torchvision_models.py @@ -7,7 +7,7 @@ import pytest import torch import torchvision.transforms.functional as F -from models_hub_common.utils import get_models_list +from models_hub_common.utils import get_models_list, retry from torch_utils import TestTorchConvertModel @@ -54,6 +54,7 @@ def prepare_frames_for_raft(name, frames1, frames2): class TestTorchHubConvertModel(TestTorchConvertModel): + @retry(3, exceptions=(OSError,), delay=1) def load_model(self, model_name, model_link): m = torch.hub.load("pytorch/vision", model_name, weights='DEFAULT', skip_validation=True) From 595ce79dab15c3a645927197777b3e8bcb5f0fd3 Mon Sep 17 00:00:00 2001 From: Maxim Vafin Date: Tue, 20 Aug 2024 10:55:07 +0200 Subject: [PATCH 051/117] [PT FE] Code cleanup and coverity fixes (#25888) ### Details: - *Fix several coverity issues* - *Support inplace ops if regular op is present* - *Additional code improvements* ### Tickets: - *ticket-id* --- .../openvino/frontend/pytorch/ts_decoder.py | 152 ++++++++++-------- .../src/openvino/frontend/pytorch/utils.py | 22 +-- ...decompression_convert_constant_folding.cpp | 2 +- .../openvino/frontend/pytorch/frontend.hpp | 3 +- .../frontend/pytorch/node_context.hpp | 15 +- src/frontends/pytorch/src/frontend.cpp | 49 +++--- src/frontends/pytorch/src/input_model.cpp | 18 ++- src/frontends/pytorch/src/input_model.hpp | 1 + src/frontends/pytorch/src/node_context.cpp | 45 +++--- .../pytorch/src/op/adaptive_poolnd.cpp | 2 +- src/frontends/pytorch/src/op/add.cpp | 2 + src/frontends/pytorch/src/op/addmm.cpp | 4 +- src/frontends/pytorch/src/op/any.cpp | 4 +- .../pytorch/src/op/argmax_argmin.cpp | 5 +- src/frontends/pytorch/src/op/as_strided.cpp | 2 +- src/frontends/pytorch/src/op/batch_norm.cpp | 1 - src/frontends/pytorch/src/op/clamp.cpp | 2 +- src/frontends/pytorch/src/op/dim.cpp | 3 +- src/frontends/pytorch/src/op/div.cpp | 2 + src/frontends/pytorch/src/op/pad.cpp | 2 +- src/frontends/pytorch/src/op_table.cpp | 38 +---- src/frontends/pytorch/src/op_table.hpp | 4 +- .../append_list_unpack_replacer.cpp | 11 +- .../src/transforms/aten_getitem_replacer.cpp | 2 +- .../aten_stack_list_construct_replacer.cpp | 12 +- .../src/transforms/einsum_list_construct.cpp | 4 +- .../src/transforms/listconstruct_replacer.cpp | 62 +++---- .../min_max_prim_list_construct_replacer.cpp | 6 +- .../transforms/prim_list_construct_pad.cpp | 4 +- .../prim_list_tuple_construct_replacer.cpp | 2 +- .../transforms/prim_list_unpack_replacer.cpp | 3 +- .../transforms/string_equality_replacer.cpp | 10 +- .../torchfx_gptq_pattern_replacer.cpp | 76 ++++----- .../src/transforms/tuple_unpack_replacer.cpp | 4 +- .../src/transforms/u4_block_repack.cpp | 12 +- .../pytorch/src/translate_session.cpp | 78 +++++---- .../pytorch/src/translate_session.hpp | 6 +- src/frontends/pytorch/src/utils.cpp | 19 +-- src/frontends/pytorch/src/utils_quantize.cpp | 6 +- 39 files changed, 360 insertions(+), 335 deletions(-) diff --git a/src/bindings/python/src/openvino/frontend/pytorch/ts_decoder.py b/src/bindings/python/src/openvino/frontend/pytorch/ts_decoder.py index 1853842a8eea26..8e840d111a3b8d 100644 --- a/src/bindings/python/src/openvino/frontend/pytorch/ts_decoder.py +++ b/src/bindings/python/src/openvino/frontend/pytorch/ts_decoder.py @@ -7,7 +7,14 @@ from openvino.frontend.pytorch.py_pytorch_frontend import _FrontEndPytorchDecoder as Decoder from openvino.frontend.pytorch.py_pytorch_frontend import _Type as DecoderType from openvino.runtime import op, PartialShape, Type as OVType, OVAny -from openvino.frontend.pytorch.utils import ivalue_to_constant, get_value_from_getattr, pt_to_ov_type_map, prepare_example_inputs_and_model, convert_quantized_tensor, graph_has_ops +from openvino.frontend.pytorch.utils import ( + ivalue_to_constant, + get_value_from_getattr, + pt_to_ov_type_map, + prepare_example_inputs_and_model, + convert_quantized_tensor, + graph_has_ops, +) from openvino.runtime import opset11 as ops from openvino.frontend.pytorch import gptq from openvino.frontend.pytorch import patch_model @@ -15,20 +22,22 @@ import typing import torch +import inspect -class TorchScriptPythonDecoder (Decoder): +class TorchScriptPythonDecoder(Decoder): def __init__( - self, - pt_module, - graph_element=None, - example_input=None, - alias_db=None, - shared_memory=True, - skip_freeze=False, - constant_cache=None, - module_extensions=None): - Decoder.__init__(self) + self, + pt_module, + graph_element=None, + example_input=None, + alias_db=None, + shared_memory=True, + skip_freeze=False, + constant_cache=None, + module_extensions=None, + ): + super().__init__() # We store every decoder created by this decoder so that all them are not deleted until the first decoder is deleted self.m_decoders = [] self._input_signature = None @@ -37,9 +46,11 @@ def __init__( self.constant_cache = constant_cache if constant_cache is not None else dict() self.module_extensions = module_extensions self.config = None - if hasattr(pt_module, "config"): - self.config = pt_module.config.to_dict() if not isinstance(pt_module.config, dict) else pt_module.config + self.out_debug_name_overwrites = {} if graph_element is None: + if hasattr(pt_module, "config"): + self.config = pt_module.config.to_dict() if not isinstance( + pt_module.config, dict) else pt_module.config try: pt_module = self._get_scripted_model( pt_module, example_input, skip_freeze) @@ -56,7 +67,8 @@ def __init__( f"Couldn't get TorchScript module by {msg}. With exception:\n{e}\n{help_msg} " "You can also provide TorchScript module that you obtained" " yourself, please refer to PyTorch documentation: " - "https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html.") + "https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html." + ) self.graph_element = pt_module.inlined_graph self.alias_db = self.graph_element.alias_db() else: @@ -80,27 +92,27 @@ def __init__( self._transform_tensor_list_constants_to_listconstruct( self.graph_element) self._transform_optional_constants(self.graph_element) - self.out_debug_name_overwrites = {} @staticmethod def _get_preserved_attributes(model) -> list: preserved_attributes = [] for name, module in model.named_modules(): - if hasattr(module, "weight"): - if module.weight is not None and getattr(module.weight, "dtype", None) in [torch.int8, torch.uint8, torch.float16, torch.bfloat16]: - preserved_attributes.append(name) + compressed_types = [torch.int8, torch.uint8, + torch.float16, torch.bfloat16] + if hasattr(module, "weight") and getattr(module.weight, "dtype", None) in compressed_types: + preserved_attributes.append(name) return preserved_attributes def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False): - import torch - import inspect - freeze_by_default = False if isinstance(pt_module, torch.nn.Module): pt_module.eval() input_signature = None input_parameters = None - if isinstance(pt_module, torch.nn.Module) and not isinstance(pt_module, (torch.jit._trace.TopLevelTracedModule, torch.jit._script.RecursiveScriptModule)): + if isinstance(pt_module, torch.nn.Module) and not isinstance( + pt_module, (torch.jit._trace.TopLevelTracedModule, + torch.jit._script.RecursiveScriptModule) + ): # input params is dictionary contains input names and their signature values (type hints and default values if any) input_params = inspect.signature(pt_module.forward if hasattr( pt_module, "forward") else pt_module.__call__).parameters @@ -108,7 +120,8 @@ def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False) if example_inputs is None: if self.module_extensions: - raise RuntimeError("ModuleExtension is not supported for scripting. Please provide valid example_input argument to run tracing.") + raise RuntimeError( + "ModuleExtension is not supported for scripting. Please provide valid example_input argument to run tracing.") scripted = torch.jit.script(pt_module) freeze_by_default = True else: @@ -116,9 +129,10 @@ def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False) example_inputs, input_params, pt_module) # name of attribute in a patched module where the original forward method is kept - orig_forward_name = '_openvino_module_extension_patch_orig_forward' + orig_forward_name = "_openvino_module_extension_patch_orig_forward" if self.module_extensions: - patch_model.patch_model(pt_module, self.module_extensions, orig_forward_name) + patch_model.patch_model( + pt_module, self.module_extensions, orig_forward_name) gptq_patched = False if gptq.detect_gptq_model(pt_module): @@ -127,9 +141,9 @@ def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False) gptq_patched = True except Exception as error: print( - '[ WARNING ] Failed patching of AutoGPTQ model. Error message:\n', error) + "[ WARNING ] Failed patching of AutoGPTQ model. Error message:\n", error) print( - '[ WARNING ] Tracing of the model will likely be unsuccessful or incorrect') + "[ WARNING ] Tracing of the model will likely be unsuccessful or incorrect") gptq.unpatch_model(pt_module) gptq_patched = False @@ -142,10 +156,13 @@ def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False) if self.module_extensions: patch_model.unpatch_model(pt_module, orig_forward_name) - if not freeze_by_default and graph_has_ops(scripted.inlined_graph, ["prim::Uninitialized", "prim::unchecked_cast", "aten::append"]): + have_to_freeze_ops = ["prim::Uninitialized", + "prim::unchecked_cast", "aten::append"] + if not freeze_by_default and graph_has_ops(scripted.inlined_graph, have_to_freeze_ops): # freeze models with unsupported ops freeze_by_default = True - if freeze_by_default and graph_has_ops(scripted.inlined_graph, ["quantized", "aten::as_strided"]): + quantized_hint_ops = ["quantized", "aten::as_strided"] + if freeze_by_default and graph_has_ops(scripted.inlined_graph, quantized_hint_ops): # do not freeze quantized models and can't freeze for aten::as_strided it will result in incorrect inference freeze_by_default = False if freeze_by_default and not skip_freeze: @@ -256,12 +273,14 @@ def get_subgraph_size(self) -> int: def visit_subgraph(self, node_visitor) -> None: # make sure topological order is satisfied for node in self.graph_element.nodes(): - decoder = TorchScriptPythonDecoder(self.pt_module, - node, - alias_db=self.alias_db, - shared_memory=self._shared_memory, - constant_cache=self.constant_cache, - module_extensions=self.module_extensions) + decoder = TorchScriptPythonDecoder( + self.pt_module, + node, + alias_db=self.alias_db, + shared_memory=self._shared_memory, + constant_cache=self.constant_cache, + module_extensions=self.module_extensions, + ) self.m_decoders.append(decoder) node_visitor(decoder) @@ -281,31 +300,32 @@ def get_subgraphs(self) -> list: return list(self.graph_element.blocks()) def get_subgraph_decoder(self, index: int): - decoder = TorchScriptPythonDecoder(self.pt_module, - self.get_subgraphs()[index], - alias_db=self.alias_db, - shared_memory=self._shared_memory, - module_extensions=self.module_extensions) + decoder = TorchScriptPythonDecoder( + self.pt_module, self.get_subgraphs( + )[index], alias_db=self.alias_db, shared_memory=self._shared_memory, module_extensions=self.module_extensions + ) self.m_decoders.append(decoder) return decoder def get_op_type(self) -> str: assert isinstance( self.graph_element, torch.Node), "Function can be called only when self.graph_element is of type torch.Node" - if self.graph_element.kind() == "prim::PythonOp": - if hasattr(self.graph_element, 'pyobj') and callable(self.graph_element.pyobj) and hasattr(self.graph_element.pyobj(), '__self__'): - trampoline = self.graph_element.pyobj().__self__ - if hasattr(trampoline, 'target_extension') and isinstance(trampoline.target_extension, ModuleExtension): - target_op = trampoline.target_extension.target_op - if callable(target_op): - target = target_op(trampoline.original_module) - elif isinstance(target_op, str): - target = target_op - # TODO: Support target as a callable that will play a role of ConversionExtension for an entire module instead of a single op. - # Without supporting target as a callable here, ConversionExtension functionality is still possible to implement - # by combining two extensions: ModuleExtension that use temporary name as a target op and another extension of type ConversionExtension - # that translates that particular temporary name to custom graph. But providing conversion code as a callable `target` is more convenient. - return target + if self.graph_element.kind() == "prim::PythonOp" and callable(getattr(self.graph_element, "pyobj", None)): + pyobj = self.graph_element.pyobj() + trampoline = getattr(pyobj, "__self__", None) + target_extension = getattr(trampoline, "target_extension", None) + + if isinstance(target_extension, ModuleExtension): + target_op = target_extension.target_op + if callable(target_op): + target = target_op(trampoline.original_module) + elif isinstance(target_op, str): + target = target_op + # TODO: Support target as a callable that will play a role of ConversionExtension for an entire module instead of a single op. + # Without supporting target as a callable here, ConversionExtension functionality is still possible to implement + # by combining two extensions: ModuleExtension that use temporary name as a target op and another extension of type ConversionExtension + # that translates that particular temporary name to custom graph. But providing conversion code as a callable `target` is more convenient. + return target return self.graph_element.kind() def get_schema(self) -> str: @@ -345,8 +365,8 @@ def _add_name_to_const_and_cache(self, outputs, name): self.constant_cache[name] = outputs def try_decode_get_attr(self): - pt_value, name = get_value_from_getattr(self.graph_element, - self.pt_module) + pt_value, name = get_value_from_getattr( + self.graph_element, self.pt_module) assert pt_value is not None, "Couldn't retrieve value from prim::GetAttr" if isinstance(pt_value, torch.ScriptObject): # We assume this is __torch__.torch.classes.quantized.Conv2dPackedParamsBase or __torch__.torch.classes.quantized.LinearPackedParamsBase @@ -392,8 +412,8 @@ def try_decode_get_attr(self): if name in self.constant_cache: const = self.constant_cache[name] else: - const = ivalue_to_constant(pt_value, - shared_memory=self._shared_memory) + const = ivalue_to_constant( + pt_value, shared_memory=self._shared_memory) self._add_name_to_const_and_cache(const, name) return const else: @@ -407,12 +427,11 @@ def as_constant(self): pt_value = self._raw_output(0) pt_type = pt_value.type() if isinstance(pt_type, torch.TensorType): - return ivalue_to_constant(pt_value.toIValue(), - shared_memory=self._shared_memory) + return ivalue_to_constant(pt_value.toIValue(), shared_memory=self._shared_memory) if isinstance(pt_type, torch.ListType): return self._as_constant_list(pt_value) - const = ivalue_to_constant(pt_value.toIValue(), - shared_memory=self._shared_memory) + const = ivalue_to_constant( + pt_value.toIValue(), shared_memory=self._shared_memory) if len(const) > 0: # set name corresponding to state_dict name const[0].get_node().set_friendly_name( @@ -466,8 +485,8 @@ def input_is_none(self, index: int) -> bool: else: in_node = r_input.node() if in_node.kind() == "prim::GetAttr": - pt_value, _ = get_value_from_getattr(in_node, - self.pt_module) + pt_value, _ = get_value_from_getattr( + in_node, self.pt_module) return pt_value is None return False @@ -496,7 +515,8 @@ def get_named_input(self, name): def get_rt_info(self): rt_info = {} if self.config is not None and "quantization_config" in self.config and "sym" in self.config["quantization_config"]: - rt_info["symmetric_quantization"] = OVAny(self.config["quantization_config"]["sym"]) + rt_info["symmetric_quantization"] = OVAny( + self.config["quantization_config"]["sym"]) return rt_info @staticmethod diff --git a/src/bindings/python/src/openvino/frontend/pytorch/utils.py b/src/bindings/python/src/openvino/frontend/pytorch/utils.py index 4b94503adb5595..06a58eb80ffed1 100644 --- a/src/bindings/python/src/openvino/frontend/pytorch/utils.py +++ b/src/bindings/python/src/openvino/frontend/pytorch/utils.py @@ -25,7 +25,7 @@ def fetch_attr(self_module, target: str): Return: Any: The value of the attribute. """ - target_atoms = target.split('.') + target_atoms = target.split(".") attr_itr = self_module for i, atom in enumerate(target_atoms): if not hasattr(attr_itr, atom): @@ -91,12 +91,13 @@ def get_value_from_getattr(getattr_node, self_module): node = stack.pop() attr_name = node.s("name") assert hasattr( - module, attr_name), f"No attribute with name \"{attr_name}\" found in module." + module, attr_name), f'No attribute with name "{attr_name}" found in module.' path_name = ".".join([path_name, attr_name]) module = getattr(module, attr_name) return module, path_name -def graph_has_ops(graph, op_types:list) -> bool: + +def graph_has_ops(graph, op_types: list) -> bool: res = False for n in graph.nodes(): if any(kind in n.kind() for kind in op_types): @@ -106,7 +107,7 @@ def graph_has_ops(graph, op_types:list) -> bool: if res: return res return res - + pt_to_ov_type_map = { "float": OVType.f32, @@ -134,7 +135,7 @@ def graph_has_ops(graph, op_types:list) -> bool: "torch.BoolTensor": OVType.boolean, "torch.quint8": OVType.u8, "torch.qint8": OVType.i8, - "torch.qint32": OVType.i32 + "torch.qint32": OVType.i32, } @@ -159,7 +160,7 @@ def process_dict_inputs(inputs, input_params, model): ordered_inputs.append(input_name) input_signature = list(input_params) - if ordered_inputs == input_signature[:len(ordered_inputs)]: + if ordered_inputs == input_signature[: len(ordered_inputs)]: example_inputs = [inputs[input_name] for input_name in ordered_inputs] if all([isinstance(inp, torch.Tensor) for inp in example_inputs]): return {"example_inputs": [inputs[name] for name in ordered_inputs]}, ordered_inputs, model @@ -191,8 +192,8 @@ def process_dict_inputs(inputs, input_params, model): str(input_params[input_name]).replace("NoneType", "None")) input_params_str.append(f"{input_name}={input_name}") - wrapper_class = wrapper_template.format(input_sign=', '.join( - input_sign_str), example_input=', '.join(input_params_str)) + wrapper_class = wrapper_template.format(input_sign=", ".join( + input_sign_str), example_input=", ".join(input_params_str)) result = {} try: exec(wrapper_class, result) @@ -210,7 +211,8 @@ def prepare_example_inputs_and_model(inputs, input_params, model): input_is_list = False input_signature = list(input_params) if isinstance(inputs, dict): - examples, ordered, wrapped = process_dict_inputs(inputs, input_params, model) + examples, ordered, wrapped = process_dict_inputs( + inputs, input_params, model) return examples, ordered, wrapped, input_is_list if isinstance(inputs, list) and len(inputs) == 1 and isinstance(inputs[0], torch.Tensor): if "typing.List" in str(input_params[input_signature[0]].annotation): @@ -219,7 +221,7 @@ def prepare_example_inputs_and_model(inputs, input_params, model): if isinstance(inputs, torch.Tensor): inputs = [inputs] - input_signature = input_signature[:len(inputs)] + input_signature = input_signature[: len(inputs)] return {"example_inputs": inputs}, input_signature, model, input_is_list diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp index 136ee34877c2dd..7724692be61662 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp @@ -141,7 +141,7 @@ pass::MarkCompressedFloatConstants::MarkCompressedFloatConstants() { mark_as_decompression(convert_node); disable_constant_folding(const_node); disable_constant_folding(convert_node); - return true; + return false; }; auto m = std::make_shared(convert, matcher_name); diff --git a/src/frontends/pytorch/include/openvino/frontend/pytorch/frontend.hpp b/src/frontends/pytorch/include/openvino/frontend/pytorch/frontend.hpp index 2f9ac5432ff975..3b0da6f0a18ebf 100644 --- a/src/frontends/pytorch/include/openvino/frontend/pytorch/frontend.hpp +++ b/src/frontends/pytorch/include/openvino/frontend/pytorch/frontend.hpp @@ -61,7 +61,8 @@ class PYTORCH_API FrontEnd : public ov::frontend::FrontEnd { protected: bool supported_impl(const std::vector& variants) const override; ov::frontend::InputModel::Ptr load_impl(const std::vector& variants) const override; - std::map get_supported_ops(const ov::frontend::InputModel::Ptr& model) const; + std::unordered_map get_supported_ops( + const ov::frontend::InputModel::Ptr& model) const; std::map m_op_extension_translators; std::vector m_conversion_extensions; diff --git a/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp b/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp index b1f9153835e2ff..110beedb8b2020 100644 --- a/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp +++ b/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp @@ -18,11 +18,11 @@ typedef std::unordered_map> TensorMap; class NodeContext : public frontend::NodeContext { public: - NodeContext(std::shared_ptr decoder, + NodeContext(const std::shared_ptr& decoder, const TensorMap& ext_tensor_map, - std::shared_ptr tensor_map, - std::shared_ptr external_parameters, - std::shared_ptr> mutated_tensors, + const std::shared_ptr& tensor_map, + const std::shared_ptr& external_parameters, + const std::shared_ptr>& mutated_tensors, TranslateSession* translate_session) : frontend::NodeContext(decoder->get_op_type()), m_decoder(decoder), @@ -32,11 +32,12 @@ class NodeContext : public frontend::NodeContext { m_mutated_tensors(mutated_tensors), m_translate_session(translate_session), m_decoder_inputs(decoder->inputs()), - m_decoder_outputs(decoder->outputs()) { + m_decoder_outputs(decoder->outputs()), + m_inputs_is_none(m_decoder_inputs.size(), false) { FRONT_END_GENERAL_CHECK(m_tensor_map != nullptr && m_external_parameters != nullptr && m_mutated_tensors != nullptr && m_translate_session != nullptr); for (size_t i = 0; i < m_decoder_inputs.size(); i++) { - m_inputs_is_none.push_back(decoder->input_is_none(i)); + m_inputs_is_none[i] = decoder->input_is_none(i); } } @@ -140,7 +141,7 @@ class NodeContext : public frontend::NodeContext { return m_translate_session; } - void add_tensor_to_context(size_t index, Output ov_output) const; + void add_tensor_to_context(size_t index, const Output& ov_output) const; Output get_tensor_from_model(size_t index) const { if (m_tensor_map->find(index) != m_tensor_map->end()) { diff --git a/src/frontends/pytorch/src/frontend.cpp b/src/frontends/pytorch/src/frontend.cpp index 2940e385cd4e44..e0b068c4329ee2 100644 --- a/src/frontends/pytorch/src/frontend.cpp +++ b/src/frontends/pytorch/src/frontend.cpp @@ -57,26 +57,28 @@ namespace pytorch { namespace { std::map get_unconverted_types_from_model(const std::shared_ptr& model) { std::map unconverted_ops_types; - for (const auto& node : model->get_ordered_ops()) { + ov::traverse_nodes(model, [&](const std::shared_ptr& node) { if (const auto& fw_node = ov::as_type_ptr(node)) { const auto& attrs = fw_node->get_attrs(); - FRONT_END_GENERAL_CHECK(attrs.find(PtFrameworkNode::op_type_key) != attrs.end(), + auto op_type_it = attrs.find(PtFrameworkNode::op_type_key); + FRONT_END_GENERAL_CHECK(op_type_it != attrs.end(), "FrameworkNode attributes do not contain operation type."); std::string exception_msg; - if (attrs.find(PtFrameworkNode::failed_conversion_key) != attrs.end()) { - exception_msg = attrs.at(PtFrameworkNode::failed_conversion_key); + auto exception_it = attrs.find(PtFrameworkNode::failed_conversion_key); + if (exception_it != attrs.end()) { + exception_msg = exception_it->second; } - if (!unconverted_ops_types.count(attrs.at(PtFrameworkNode::op_type_key))) { - unconverted_ops_types[attrs.at(PtFrameworkNode::op_type_key)] = exception_msg; + if (!unconverted_ops_types.count(op_type_it->second)) { + unconverted_ops_types.emplace(op_type_it->second, std::move(exception_msg)); } } if (const auto& fw_node = ov::as_type_ptr(node)) { - for (size_t i = 0; i < fw_node->get_internal_subgraphs_size(); i++) { + for (size_t i = 0; i < fw_node->get_internal_subgraphs_size(); ++i) { const auto& internal_types = get_unconverted_types_from_model(fw_node->get_function(i)); unconverted_ops_types.insert(internal_types.begin(), internal_types.end()); } } - } + }); return unconverted_ops_types; } @@ -142,7 +144,7 @@ FrontEnd::FrontEnd() {} std::shared_ptr FrontEnd::convert(const ov::frontend::InputModel::Ptr& model) const { auto pt_model = std::dynamic_pointer_cast(model); FRONT_END_GENERAL_CHECK(pt_model, "Invalid input model"); - std::map supported_ops = get_supported_ops(model); + const auto& supported_ops = get_supported_ops(model); std::shared_ptr converted_model; { pt_model->flush_places(); @@ -223,7 +225,7 @@ void FrontEnd::convert(const std::shared_ptr& partiallyConverted) const { std::shared_ptr FrontEnd::convert_partially(const ov::frontend::InputModel::Ptr& model) const { auto pt_model = std::dynamic_pointer_cast(model); FRONT_END_GENERAL_CHECK(pt_model, "Invalid input model"); - std::map supported_ops = get_supported_ops(model); + const auto& supported_ops = get_supported_ops(model); std::shared_ptr partial_model; { pt_model->flush_places(); @@ -247,11 +249,18 @@ std::shared_ptr FrontEnd::decode(const InputModel::Ptr& model) const { void FrontEnd::normalize(const std::shared_ptr& model) const { ov::pass::Manager manager("Frontend:Pytorch:normalize"); - // GPTQ transformations need to be executed before other passes - // Once the GPTQ patterns are modified by other transformations, - // they cannot be captured anymore - manager.register_pass(); - manager.register_pass(); + bool is_fx = false; + if (model->has_rt_info("decoder_type_name")) { + is_fx = model->get_rt_info()["decoder_type_name"].as() == "fx"; + } + // These transformations are only applicable to fx + if (is_fx) { + // GPTQ transformations need to be executed before other passes + // Once the GPTQ patterns are modified by other transformations, + // they cannot be captured anymore + manager.register_pass(); + manager.register_pass(); + } // the following 2 transformations are needed for keypoint detectron2 models to work. // AtenIndexToSelect will be called twice @@ -374,14 +383,16 @@ ov::frontend::InputModel::Ptr FrontEnd::load_impl(const std::vector& va return std::make_shared(tdecoder); } -std::map FrontEnd::get_supported_ops(const ov::frontend::InputModel::Ptr& model) const { - std::map supported_ops; +std::unordered_map FrontEnd::get_supported_ops( + const ov::frontend::InputModel::Ptr& model) const { + std::unordered_map supported_ops; if (std::dynamic_pointer_cast(model)->decoder_type_name() == "fx") supported_ops = get_supported_ops_fx(); else supported_ops = get_supported_ops_ts(); - for (auto i = m_op_extension_translators.begin(); i != m_op_extension_translators.end(); i++) - supported_ops[i->first] = i->second; + for (const auto& ext : m_op_extension_translators) { + supported_ops[ext.first] = ext.second; + } return supported_ops; } diff --git a/src/frontends/pytorch/src/input_model.cpp b/src/frontends/pytorch/src/input_model.cpp index 72140881c89698..52a90d6d1cc7d5 100644 --- a/src/frontends/pytorch/src/input_model.cpp +++ b/src/frontends/pytorch/src/input_model.cpp @@ -11,7 +11,9 @@ namespace ov { namespace frontend { namespace pytorch { -InputModel::InputModel(const std::shared_ptr& model_decoder) : m_model_decoder(model_decoder) { +InputModel::InputModel(const std::shared_ptr& model_decoder) + : m_model_decoder(model_decoder), + m_decoder_type_name(model_decoder->decoder_type_name()) { const auto& inputs = m_model_decoder->inputs(); for (size_t i = 0; i < inputs.size(); ++i) { auto in_place = std::make_shared(*this, inputs[i]); @@ -166,7 +168,7 @@ void InputModel::override_all_inputs(const std::vector& inputs) { }); FRONT_END_GENERAL_CHECK(all_inputs, "Only initial inputs are supported by override_all_inputs."); // We need to add back "self" input if it was in initial inputs - if (m_inputs.size() > 0 && m_inputs[0]) { + if (!m_inputs.empty() && m_inputs[0]) { // We need to remove "self" input to not confuse external users const auto& names = m_inputs[0]->get_names(); if (std::any_of(names.cbegin(), names.cend(), [](const std::string& n) { @@ -180,12 +182,14 @@ void InputModel::override_all_inputs(const std::vector& inputs) { inputs.size()); auto self_place = m_inputs[0]; // Verify that no same place already in vector - auto no_self = std::all_of(inputs.cbegin(), inputs.cend(), [&](const Place::Ptr& p) { - return !p->is_equal(self_place); + auto no_self = std::none_of(inputs.cbegin(), inputs.cend(), [&](const Place::Ptr& p) { + return p->is_equal(self_place); }); FRONT_END_GENERAL_CHECK(no_self, "Unexpected input of 'self' was provided to override_all_inputs."); - m_inputs = std::vector{self_place}; - m_inputs.insert(m_inputs.cend(), inputs.cbegin(), inputs.cend()); + m_inputs.clear(); + m_inputs.reserve(inputs.size() + 1); + m_inputs.push_back(std::move(self_place)); + m_inputs.insert(m_inputs.end(), inputs.cbegin(), inputs.cend()); return; } } @@ -199,7 +203,7 @@ void InputModel::override_all_inputs(const std::vector& inputs) { } const std::string& InputModel::decoder_type_name() const { - return m_model_decoder->decoder_type_name(); + return m_decoder_type_name; } std::shared_ptr InputModel::get_decoder() const { diff --git a/src/frontends/pytorch/src/input_model.hpp b/src/frontends/pytorch/src/input_model.hpp index b647da29465660..bfadc970e6a531 100644 --- a/src/frontends/pytorch/src/input_model.hpp +++ b/src/frontends/pytorch/src/input_model.hpp @@ -52,6 +52,7 @@ class InputModel : public ov::frontend::InputModel { std::vector> m_outputs; std::vector> m_requested_places; std::unordered_map m_descriptors; + const std::string m_decoder_type_name; }; } // namespace pytorch diff --git a/src/frontends/pytorch/src/node_context.cpp b/src/frontends/pytorch/src/node_context.cpp index 5684212f1097f5..efc3bb107eb7f0 100644 --- a/src/frontends/pytorch/src/node_context.cpp +++ b/src/frontends/pytorch/src/node_context.cpp @@ -55,31 +55,23 @@ std::shared_ptr NodeContext::mark_node(std::shared_ptr ov_node) cons void NodeContext::mutate_input(size_t index, Output ov_output) const { FRONT_END_GENERAL_CHECK(!input_is_none(index), "Input is none with index: ", index); auto input_id = m_decoder_inputs.at(index); - FRONT_END_GENERAL_CHECK(m_tensor_map->count(input_id), "No tensor corresponding input: ", input_id, " exist."); + auto tensor_it = m_tensor_map->find(input_id); + FRONT_END_GENERAL_CHECK(tensor_it != m_tensor_map->end(), "No tensor corresponding input: ", input_id, " exist."); m_translate_session->encode_tensor_name(ov_output, input_id, {m_decoder->get_input_debug_name(index)}); - (*m_tensor_map)[input_id] = ov_output; + tensor_it->second = ov_output; m_mutated_tensors->insert(input_id); // Resolve aliases - auto back_input_id = input_id; - auto back_node_input = ov_output; + auto& back_input_id = input_id; + auto& back_node_input = ov_output; while (m_translate_session->m_may_be_alias.count(back_input_id)) { - // Create node to reverseprop data. While loop is needed for the cases when alias to tensor point to another + // Create node to aliased data. While loop is needed for the cases when alias to tensor point to another // alias to tensor. In that case we need to create a chain of reverseprop ops - size_t in_tensor; - std::shared_ptr node; - Output node_converted_output; - std::tie(in_tensor, node, node_converted_output) = m_translate_session->m_may_be_alias.at(back_input_id); + auto& alias_info = m_translate_session->m_may_be_alias.at(back_input_id); + size_t in_tensor = std::get<0>(alias_info); + auto& node = std::get<1>(alias_info); + auto& node_converted_output = std::get<2>(alias_info); auto reverseprop_node = m_translate_session->get_reverseprop_op(node, node_converted_output, back_node_input); - if (m_tensor_map->count(in_tensor)) { - // Tensor is not found in the scope of this body, need to get it from internal context and mark mutated - OPENVINO_DEBUG("Couldn't find in the current body the initial aliased tensor: ", - in_tensor, - " for operation: ", - node->get_op_type(), - " creating new body input."); - get_tensor_from_model_or_create_input(in_tensor); - } m_translate_session->encode_tensor_name(reverseprop_node, in_tensor); (*m_tensor_map)[in_tensor] = reverseprop_node; m_mutated_tensors->insert(in_tensor); @@ -89,17 +81,20 @@ void NodeContext::mutate_input(size_t index, Output ov_output) const { } } -void NodeContext::add_tensor_to_context(size_t index, Output ov_output) const { +void NodeContext::add_tensor_to_context(size_t index, const Output& ov_output) const { +#ifdef ENABLE_OPENVINO_DEBUG if (m_tensor_map->count(index)) { OPENVINO_DEBUG("[ WARNING ] Current context has tensor ", index, ". Assuming mutated output.\n"); } +#endif m_translate_session->encode_tensor_name(ov_output, index); (*m_tensor_map)[index] = ov_output; } Output NodeContext::get_tensor_from_model_or_create_input(size_t index) const { - if (m_tensor_map->find(index) != m_tensor_map->end()) { - return m_tensor_map->at(index); + auto tensor_it = m_tensor_map->find(index); + if (tensor_it != m_tensor_map->end()) { + return tensor_it->second; } else { // nested subgraphs case auto parameter = std::make_shared(element::dynamic, PartialShape::dynamic()); @@ -131,7 +126,7 @@ std::shared_ptr NodeContext::convert_subgraph(size_t index) const { // Extend external context with internal tensors except Parameter nodes, because internal Parameters are created to // link internal context with external TensorMap ext_map(m_ext_tensor_map); - // map::insert does not update elements if their key is already in map; so if we have real tensors in outter scope + // map::insert does not update elements if their key is already in map; so if we have real tensors in outer scope // we will not add Parameters we created in inner scope. ext_map.insert(m_tensor_map->begin(), m_tensor_map->end()); @@ -159,10 +154,12 @@ OutputVector NodeContext::inputs() const { auto inlined_input = m_decoder->inlined_input(i); FRONT_END_GENERAL_CHECK(inlined_input.size() == 1, "Incorrect inlined input with index:", i); res.push_back(inlined_input[0]); + continue; } } - FRONT_END_GENERAL_CHECK(m_tensor_map->count(input), "No tensor corresponding input: ", input, " exist."); - res.push_back(m_tensor_map->at(input)); + auto tensor_it = m_tensor_map->find(input); + FRONT_END_GENERAL_CHECK(tensor_it != m_tensor_map->end(), "No tensor corresponding input: ", input, " exist."); + res.push_back(tensor_it->second); } return res; } diff --git a/src/frontends/pytorch/src/op/adaptive_poolnd.cpp b/src/frontends/pytorch/src/op/adaptive_poolnd.cpp index 1288f1402e778f..7d52386d0edbab 100644 --- a/src/frontends/pytorch/src/op/adaptive_poolnd.cpp +++ b/src/frontends/pytorch/src/op/adaptive_poolnd.cpp @@ -102,7 +102,7 @@ OutputVector translate_adaptive_max_pool_base(const NodeContext& context, pooled_indices = context.mark_node(std::make_shared(pooled_indices, output_shape, false)); // aten::adaptive_max_pool{n}d always returns tuple with 2 tensors: pooled tensor and indicies // output selecting only first or preserve both made outside of operation by return_indices flag - return {pooled_tensor, pooled_indices}; + return {std::move(pooled_tensor), std::move(pooled_indices)}; }; } // namespace diff --git a/src/frontends/pytorch/src/op/add.cpp b/src/frontends/pytorch/src/op/add.cpp index eada7871b8739a..dd72222a9ec943 100644 --- a/src/frontends/pytorch/src/op/add.cpp +++ b/src/frontends/pytorch/src/op/add.cpp @@ -18,6 +18,7 @@ namespace op { using namespace ov::op; +namespace { OutputVector translate_add_common(const NodeContext& context, bool inplace) { num_inputs_check(context, 2, 3); Output lhs; @@ -67,6 +68,7 @@ OutputVector translate_add_common(const NodeContext& context, bool inplace) { context.mutate_input(0, add); return {add}; }; +} // namespace OutputVector translate_add(const NodeContext& context) { return translate_add_common(context, false); diff --git a/src/frontends/pytorch/src/op/addmm.cpp b/src/frontends/pytorch/src/op/addmm.cpp index 522c5237ecd11b..4ecfd403afc6dd 100644 --- a/src/frontends/pytorch/src/op/addmm.cpp +++ b/src/frontends/pytorch/src/op/addmm.cpp @@ -46,7 +46,7 @@ OutputVector translate_addmm(const NodeContext& context) { if (!context.input_is_none(4)) { alpha = context.get_input(4); } - return {translate_addmm_common(context, beta, alpha)}; + return {translate_addmm_common(context, std::move(beta), std::move(alpha))}; }; OutputVector translate_addmm_fx(const NodeContext& context) { @@ -60,7 +60,7 @@ OutputVector translate_addmm_fx(const NodeContext& context) { if (context.has_attribute("alpha")) { alpha = context.get_input("alpha"); } - return {translate_addmm_common(context, beta, alpha)}; + return {translate_addmm_common(context, std::move(beta), std::move(alpha))}; }; OutputVector translate_conv1d_ext(const NodeContext& context) { diff --git a/src/frontends/pytorch/src/op/any.cpp b/src/frontends/pytorch/src/op/any.cpp index fb36c4268cf939..a17b8777e5f916 100644 --- a/src/frontends/pytorch/src/op/any.cpp +++ b/src/frontends/pytorch/src/op/any.cpp @@ -55,7 +55,7 @@ OutputVector translate_any(const NodeContext& context) { out_id = 3; } - auto result = translate_any_common(context, input_tensor, axes, keep_dims); + const auto& result = translate_any_common(context, input_tensor, axes, keep_dims); if (!context.input_is_none(out_id)) { context.mutate_input(out_id, result); } @@ -75,7 +75,7 @@ OutputVector translate_any_fx(const NodeContext& context) { bool keep_dims = false; if (!context.input_is_none(2)) keep_dims = context.const_input(2); - auto any = translate_any_common(context, x, dims, keep_dims); + const auto& any = translate_any_common(context, x, dims, keep_dims); return {any}; }; diff --git a/src/frontends/pytorch/src/op/argmax_argmin.cpp b/src/frontends/pytorch/src/op/argmax_argmin.cpp index e3b0b9d20680c2..9d6360609f0a57 100644 --- a/src/frontends/pytorch/src/op/argmax_argmin.cpp +++ b/src/frontends/pytorch/src/op/argmax_argmin.cpp @@ -46,8 +46,7 @@ OutputVector create_argmax_argmin_op(const NodeContext& context, TopKMode mode) std::make_shared(flatten_input, k, axis, mode, TopKSortType::SORT_VALUES, element::i64, true)); indices = topk->output(1); if (keep_dims) { - auto input_shape = context.mark_node(std::make_shared(input, element::i32)); - auto input_rank = context.mark_node(std::make_shared(input_shape, element::i32)); + auto input_rank = std::get<1>(get_shape_rank(context, input)); auto new_shape = context.mark_node(std::make_shared(k, input_rank)); indices = context.mark_node(std::make_shared(indices, new_shape, BroadcastType::BIDIRECTIONAL)); @@ -56,7 +55,7 @@ OutputVector create_argmax_argmin_op(const NodeContext& context, TopKMode mode) indices = context.mark_node(std::make_shared(indices, zero)); } } - return {indices}; + return {std::move(indices)}; } }; // namespace diff --git a/src/frontends/pytorch/src/op/as_strided.cpp b/src/frontends/pytorch/src/op/as_strided.cpp index 01bad08af60b44..20efb3ba5cb684 100644 --- a/src/frontends/pytorch/src/op/as_strided.cpp +++ b/src/frontends/pytorch/src/op/as_strided.cpp @@ -33,7 +33,7 @@ OutputVector translate_as_strided(const NodeContext& context) { auto const_neg_1 = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {-1})); auto input_strides = decoder->get_input_strides(0); PYTORCH_OP_CONVERSION_CHECK(input_strides.size() != 0, - "aten::as_strided: Couldn't retrive input stride information from torchscript."); + "aten::as_strided: Couldn't retrieve input stride information from torchscript."); std::vector idxs(input_strides.size()); iota(idxs.begin(), idxs.end(), 0); diff --git a/src/frontends/pytorch/src/op/batch_norm.cpp b/src/frontends/pytorch/src/op/batch_norm.cpp index 7f31d0894e4af6..03c6f8a75d2ae5 100644 --- a/src/frontends/pytorch/src/op/batch_norm.cpp +++ b/src/frontends/pytorch/src/op/batch_norm.cpp @@ -63,7 +63,6 @@ OutputVector make_batch_norm(const NodeContext& context, } else { b = context.mark_node(std::make_shared(b, input)); } - auto zero = context.mark_node(v0::Constant::create(element::i32, Shape{}, {0})); auto zero_1d = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {0})); auto one = context.mark_node(v0::Constant::create(element::i32, Shape{}, {1})); auto two = context.mark_node(v0::Constant::create(element::i32, Shape{}, {2})); diff --git a/src/frontends/pytorch/src/op/clamp.cpp b/src/frontends/pytorch/src/op/clamp.cpp index 67002dd61049c3..691a2d95008fa2 100644 --- a/src/frontends/pytorch/src/op/clamp.cpp +++ b/src/frontends/pytorch/src/op/clamp.cpp @@ -28,7 +28,7 @@ OutputVector translate_clamp(const NodeContext& context) { max_clip = context.mark_node(std::make_shared(max_clip, x)); x = context.mark_node(std::make_shared(x, max_clip)); } - return {x}; + return {std::move(x)}; }; } // namespace op diff --git a/src/frontends/pytorch/src/op/dim.cpp b/src/frontends/pytorch/src/op/dim.cpp index 443a171733ea5c..1d15e0b9e4d7a2 100644 --- a/src/frontends/pytorch/src/op/dim.cpp +++ b/src/frontends/pytorch/src/op/dim.cpp @@ -14,8 +14,7 @@ using namespace ov::op; OutputVector translate_dim(const NodeContext& context) { num_inputs_check(context, 1, 1); - Output rank; - std::tie(std::ignore, rank) = get_shape_rank(context, context.get_input(0), true); + Output rank = std::get<1>(get_shape_rank(context, context.get_input(0), true)); return {rank}; }; diff --git a/src/frontends/pytorch/src/op/div.cpp b/src/frontends/pytorch/src/op/div.cpp index 7c091f2c2cb8da..55ef9508dec5fc 100644 --- a/src/frontends/pytorch/src/op/div.cpp +++ b/src/frontends/pytorch/src/op/div.cpp @@ -17,6 +17,7 @@ namespace frontend { namespace pytorch { namespace op { +namespace { OutputVector translate_div_common(const NodeContext& context, const Output& lhs, const Output& rhs, @@ -56,6 +57,7 @@ OutputVector translate_div_common(const NodeContext& context, context.mutate_input(0, res); return {res}; }; +} // namespace OutputVector translate_div(const NodeContext& context) { num_inputs_check(context, 2, 3); diff --git a/src/frontends/pytorch/src/op/pad.cpp b/src/frontends/pytorch/src/op/pad.cpp index 2a8365de8a6d0d..c8f35a0afab71a 100644 --- a/src/frontends/pytorch/src/op/pad.cpp +++ b/src/frontends/pytorch/src/op/pad.cpp @@ -85,7 +85,7 @@ OutputVector translate_pad_common(const NodeContext& context, return {cur}; } auto pad_value_ = context.mark_node(std::make_shared(pad_value, data)); - const std::map pt_to_ov_pad{ + static const std::map pt_to_ov_pad{ {"constant", PadMode::CONSTANT}, {"reflect", PadMode::REFLECT}, {"replicate", PadMode::EDGE}, diff --git a/src/frontends/pytorch/src/op_table.cpp b/src/frontends/pytorch/src/op_table.cpp index 83ff923efcd89e..b3c606f3f05c98 100644 --- a/src/frontends/pytorch/src/op_table.cpp +++ b/src/frontends/pytorch/src/op_table.cpp @@ -318,7 +318,7 @@ OP_CONVERTER(translate_zeros_like_fx); } // namespace op // Supported ops for TorchScript -const std::map get_supported_ops_ts() { +const std::unordered_map get_supported_ops_ts() { return { {"aten::__and__", op::translate_bitwise_and}, {"aten::__derive_index", op::translate_derive_index}, @@ -398,17 +398,12 @@ const std::map get_supported_ops_ts() { {"aten::ceil", op::optional_out, 1>}, {"aten::ceil_", op::inplace_op>}, {"aten::celu", op::translate_celu}, - {"aten::celu_", op::inplace_op}, {"aten::channel_shuffle", op::translate_channel_shuffle}, // aten::chunk - Supported in limited set of patterns {"aten::clamp", op::translate_clamp}, - {"aten::clamp_", op::inplace_op}, {"aten::clamp_max", op::translate_1to1_match_2_inputs_align_types}, - {"aten::clamp_max_", op::inplace_op>}, {"aten::clamp_min", op::translate_1to1_match_2_inputs_align_types}, - {"aten::clamp_min_", op::inplace_op>}, {"aten::clip", op::translate_clamp}, - {"aten::clip_", op::inplace_op}, {"aten::clone", op::skip_node}, // ignore clone operators that are inserted by PyTorch autograd {"aten::col2im", op::translate_col2im}, // aten::complex - Supported in limited set of patterns @@ -440,22 +435,18 @@ const std::map get_supported_ops_ts() { {"aten::dropout_", op::skip_node}, // aten::einsum - Supported in limited set of patterns {"aten::elu", op::translate_elu}, - {"aten::elu_", op::inplace_op}, {"aten::embedding", op::translate_embedding}, {"aten::embedding_bag", op::translate_embedding_bag}, {"aten::empty", op::translate_empty}, {"aten::empty_like", op::translate_empty_like}, {"aten::eq", op::translate_1to1_match_2_inputs_align_types}, {"aten::erf", op::translate_erf}, - {"aten::erf_", op::inplace_op}, {"aten::erfc", op::translate_erfc}, - {"aten::erfc_", op::inplace_op}, {"aten::exp", op::optional_out, 1>}, {"aten::exp_", op::inplace_op>}, {"aten::expand", op::translate_expand}, {"aten::expand_as", op::translate_expand_as}, {"aten::expm1", op::translate_expm1}, - {"aten::expm1_", op::inplace_op}, {"aten::eye", op::translate_eye}, {"aten::fake_quantize_per_channel_affine", op::translate_fake_quantize_per_channel_affine}, {"aten::fake_quantize_per_tensor_affine", op::translate_fake_quantize_per_tensor_affine}, @@ -463,14 +454,12 @@ const std::map get_supported_ops_ts() { // aten::fft_irfftn - Supported in limited set of patterns // aten::fft_rfftn - Supported in limited set of patterns {"aten::fill", op::translate_fill}, - {"aten::fill_", op::inplace_op}, - {"aten::fill_diagonal_", op::inplace_op}, + {"aten::fill_diagonal", op::translate_fill_diagonal}, {"aten::flatten", op::quantizable_op}, {"aten::flip", op::translate_flip}, {"aten::floor", op::optional_out, 1>}, {"aten::floor_", op::inplace_op>}, {"aten::floor_divide", op::translate_floor_divide}, - {"aten::floor_divide_", op::inplace_op}, {"aten::floordiv", op::translate_floor_divide}, {"aten::fmod", op::translate_fmod}, {"aten::frobenius_norm", op::translate_frobenius_norm}, @@ -487,19 +476,14 @@ const std::map get_supported_ops_ts() { {"aten::gt", op::translate_1to1_match_2_inputs_align_types}, {"aten::hann_window", op::translate_hann_window}, {"aten::hardsigmoid", op::quantizable_op>}, - {"aten::hardsigmoid_", - op::quantizable_op>>}, {"aten::hardswish", op::quantizable_op>}, - {"aten::hardswish_", op::quantizable_op>>}, {"aten::hardtanh", op::quantizable_op}, - {"aten::hardtanh_", op::inplace_op>}, {"aten::im2col", op::translate_im2col}, // aten::imag - Supported in limited set of patterns // aten::index - Supported in limited set of patterns {"aten::index_copy_", op::inplace_op}, {"aten::index_put_", op::inplace_op}, {"aten::index_add", op::translate_index_add}, - {"aten::index_add_", op::inplace_op}, {"aten::index_select", op::translate_index_select}, {"aten::instance_norm", op::translate_instance_norm}, {"aten::inverse", op::translate_inverse}, @@ -514,7 +498,6 @@ const std::map get_supported_ops_ts() { {"aten::layer_norm", op::translate_layer_norm}, {"aten::le", op::translate_1to1_match_2_inputs_align_types}, {"aten::leaky_relu", op::translate_1to1_match_2_inputs}, - {"aten::leaky_relu_", op::inplace_op>}, {"aten::len", op::translate_len}, // lift op is torchscript specific op responsible for tensors coping with guarantee of new memory allocation {"aten::lift", op::skip_node}, @@ -544,9 +527,7 @@ const std::map get_supported_ops_ts() { {"aten::lstm", op::translate_lstm}, {"aten::lt", op::translate_1to1_match_2_inputs_align_types}, {"aten::masked_fill", op::translate_masked_fill}, - {"aten::masked_fill_", op::inplace_op}, {"aten::masked_scatter", op::translate_masked_scatter}, - {"aten::masked_scatter_", op::inplace_op}, {"aten::matmul", op::translate_1to1_match_2_inputs}, {"aten::max", op::translate_max}, {"aten::mv", op::translate_1to1_match_2_inputs}, @@ -562,7 +543,6 @@ const std::map get_supported_ops_ts() { {"aten::min", op::translate_min}, {"aten::minimum", op::translate_minimum}, {"aten::mish", op::translate_1to1_match_1_inputs_with_fp32_type_alignment}, - {"aten::mish_", op::inplace_op>}, {"aten::mm", op::translate_1to1_match_2_inputs}, {"aten::movedim", op::translate_movedim}, {"aten::mul", op::translate_mul}, @@ -611,7 +591,6 @@ const std::map get_supported_ops_ts() { {"aten::relu", op::optional_out, 1>}, {"aten::relu_", op::inplace_op>}, {"aten::relu6", op::translate_relu6}, - {"aten::relu6_", op::inplace_op}, {"aten::remainder", op::translate_remainder}, {"aten::repeat", op::translate_1to1_match_2_inputs}, {"aten::repeat_interleave", op::translate_repeat_interleave}, @@ -632,20 +611,15 @@ const std::map get_supported_ops_ts() { {"aten::ScalarImplicit", op::skip_node}, {"aten::scaled_dot_product_attention", op::translate_scaled_dot_product_attention}, {"aten::scatter", op::translate_scatter}, - {"aten::scatter_", op::inplace_op}, {"aten::scatter_add", op::translate_scatter_add}, - {"aten::scatter_add_", op::inplace_op}, {"aten::scatter_reduce", op::translate_scatter_reduce}, - {"aten::scatter_reduce_", op::inplace_op}, {"aten::select", op::quantizable_op}, {"aten::selu", op::translate_selu}, - {"aten::selu_", op::inplace_op}, {"aten::sigmoid", op::optional_out, 1>}, {"aten::sigmoid_", op::inplace_op>}, {"aten::sign", op::translate_sign}, {"aten::silu", op::translate_1to1_match_1_inputs}, - {"aten::silu_", op::inplace_op>}, {"aten::sin", op::optional_out, 1>}, {"aten::sin_", op::inplace_op>}, {"aten::sinh", op::optional_out, 1>}, @@ -669,7 +643,6 @@ const std::map get_supported_ops_ts() { {"aten::sum", op::translate_sum}, {"aten::swapaxes", op::quantizable_op}, {"aten::t", op::translate_t}, - {"aten::t_", op::inplace_op}, {"aten::take_along_dim", op::translate_take_along_dim}, {"aten::tan", op::optional_out, 1>}, {"aten::tan_", op::inplace_op>}, @@ -682,16 +655,13 @@ const std::map get_supported_ops_ts() { {"aten::topk", op::translate_topk}, {"aten::transpose", op::quantizable_op}, {"aten::tril", op::translate_tril}, - {"aten::tril_", op::inplace_op}, {"aten::triu", op::translate_triu}, - {"aten::triu_", op::inplace_op}, {"aten::type_as", op::translate_1to1_match_2_inputs}, // TODO: overflow semantics is different // aten::unbind - Supported in limited set of patterns {"aten::unflatten", op::translate_unflatten}, {"aten::unfold", op::translate_unfold}, {"aten::unsqueeze", op::quantizable_op>}, - {"aten::unsqueeze_", op::quantizable_op>>}, {"aten::upsample_bicubic2d", op::translate_upsample_bicubic2d}, {"aten::upsample_bilinear2d", op::translate_upsample_bilinear2d}, {"aten::upsample_linear1d", op::translate_upsample_linear1d}, @@ -704,7 +674,7 @@ const std::map get_supported_ops_ts() { {"aten::view", op::quantizable_op}, {"aten::view_as", op::translate_reshape_as}, {"aten::where", op::translate_where}, - {"aten::zero_", op::inplace_op}, + {"aten::zero", op::translate_zeros_like}, {"aten::zeros", op::translate_zeros}, {"aten::zeros_like", op::translate_zeros_like}, {"ov_ext::embedding", op::translate_embedding_ext}, @@ -742,7 +712,7 @@ const std::map get_supported_ops_ts() { }; }; -const std::map get_supported_ops_fx() { +const std::unordered_map get_supported_ops_fx() { return { {"", op::translate_add}, {"", op::translate_floor_divide}, diff --git a/src/frontends/pytorch/src/op_table.hpp b/src/frontends/pytorch/src/op_table.hpp index f7f1a51b571cb7..721146a426a12d 100644 --- a/src/frontends/pytorch/src/op_table.hpp +++ b/src/frontends/pytorch/src/op_table.hpp @@ -10,8 +10,8 @@ namespace ov { namespace frontend { namespace pytorch { -const std::map get_supported_ops_ts(); -const std::map get_supported_ops_fx(); +const std::unordered_map get_supported_ops_ts(); +const std::unordered_map get_supported_ops_fx(); } // namespace pytorch } // namespace frontend diff --git a/src/frontends/pytorch/src/transforms/append_list_unpack_replacer.cpp b/src/frontends/pytorch/src/transforms/append_list_unpack_replacer.cpp index fc5689639ec353..6263e769639e6b 100644 --- a/src/frontends/pytorch/src/transforms/append_list_unpack_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/append_list_unpack_replacer.cpp @@ -44,20 +44,23 @@ AppendListUnpackReplacer::AppendListUnpackReplacer() { while (auto append_node = cast_fw_node(input_node, "aten::append")) { rt_copy_from.push_back(append_node); - tmp_inputs.push_back(append_node->input(1).get_source_output()); + tmp_inputs.emplace_back(append_node->input(1).get_source_output()); input_node = append_node->input(0).get_source_output().get_node_shared_ptr(); } OutputVector inputs; - auto list_construct_node = cast_fw_node(input_node, "prim::ListConstruct"); + auto list_construct_node = cast_fw_node(std::move(input_node), "prim::ListConstruct"); if (!list_construct_node) { return false; } + inputs.reserve(list_construct_node->inputs().size() + tmp_inputs.size()); rt_copy_from.push_back(list_construct_node); for (auto& input : list_construct_node->inputs()) { inputs.push_back(input.get_source_output()); } - inputs.insert(inputs.end(), tmp_inputs.rbegin(), tmp_inputs.rend()); + inputs.insert(inputs.end(), + std::make_move_iterator(tmp_inputs.rbegin()), + std::make_move_iterator(tmp_inputs.rend())); if (getitem_node) { // If aten::__getitem__, expect inputs to be equivalent of pytorch Tensor[][]. // Tensor selected by aten::__getitem__ index needs to be splitted in axis 0. @@ -81,7 +84,7 @@ AppendListUnpackReplacer::AppendListUnpackReplacer() { to_copy_rt.push_back(squeeze); res.push_back(squeeze); } - copy_runtime_info_and_name(list_unpack, to_copy_rt, rt_copy_from); + copy_runtime_info_and_name(list_unpack, std::move(to_copy_rt), rt_copy_from); replace_node(list_unpack, res); return true; } else { diff --git a/src/frontends/pytorch/src/transforms/aten_getitem_replacer.cpp b/src/frontends/pytorch/src/transforms/aten_getitem_replacer.cpp index 4249363a8ef801..5d371e0d65f725 100644 --- a/src/frontends/pytorch/src/transforms/aten_getitem_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/aten_getitem_replacer.cpp @@ -47,7 +47,7 @@ AtenGetItemReplacer::AtenGetItemReplacer() { return false; ov::pass::NodeRegistry rg; - auto input_node = getitem->input_value(0).get_node_shared_ptr(); + const auto& input_node = getitem->input_value(0).get_node_shared_ptr(); if (auto torch_split = cast_fw_node(input_node, "aten::split")) { auto rank = torch_split->input(1).get_partial_shape().rank(); if (rank.is_dynamic()) { diff --git a/src/frontends/pytorch/src/transforms/aten_stack_list_construct_replacer.cpp b/src/frontends/pytorch/src/transforms/aten_stack_list_construct_replacer.cpp index b58c42b17912c1..aad973c3769246 100644 --- a/src/frontends/pytorch/src/transforms/aten_stack_list_construct_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/aten_stack_list_construct_replacer.cpp @@ -23,19 +23,19 @@ using namespace ov::op; using namespace ov::pass::pattern; AtenStackListConstructReplacer::AtenStackListConstructReplacer() { - auto list_construct = wrap_type(); - auto axis = wrap_type(); + const auto& list_construct = wrap_type(); + const auto& axis = wrap_type(); // We search for a pattern: ListConstruct -> aten::stack <- Constant - auto stack = wrap_type({list_construct, axis}); + const auto& stack = wrap_type({list_construct, axis}); - ov::matcher_pass_callback callback = [=](Matcher& m) { + ov::matcher_pass_callback callback = [list_construct, axis](Matcher& m) { auto stack = cast_fw_node(m.get_match_root(), "aten::stack"); if (!stack) { return false; } const auto& pattern_map = m.get_pattern_value_map(); - auto input_node = pattern_map.at(list_construct).get_node_shared_ptr(); + const auto& input_node = pattern_map.at(list_construct).get_node_shared_ptr(); auto axis_node = pattern_map.at(axis).get_node_shared_ptr(); auto axis_const = std::dynamic_pointer_cast(axis_node); auto axis = axis_const->cast_vector(); @@ -47,7 +47,7 @@ AtenStackListConstructReplacer::AtenStackListConstructReplacer() { if (auto list_construct_node = cast_fw_node(input_node, "prim::ListConstruct")) { const auto& list_inputs = list_construct_node->input_values(); std::shared_ptr node; - if (auto compression = u4_compression_stack(list_inputs, axis[0])) { + if (const auto& compression = u4_compression_stack(list_inputs, axis[0])) { node = compression; } else { OutputVector node_vector; diff --git a/src/frontends/pytorch/src/transforms/einsum_list_construct.cpp b/src/frontends/pytorch/src/transforms/einsum_list_construct.cpp index d0873e8479e671..a8f43d8f52cd50 100644 --- a/src/frontends/pytorch/src/transforms/einsum_list_construct.cpp +++ b/src/frontends/pytorch/src/transforms/einsum_list_construct.cpp @@ -28,8 +28,8 @@ AtenEinsumListConstructReplacer::AtenEinsumListConstructReplacer() { if (!einsum_op) { return false; } - auto equation_input = einsum_op->input_value(0).get_node_shared_ptr(); - auto tensor_list = einsum_op->input_value(1).get_node_shared_ptr(); + const auto& equation_input = einsum_op->input_value(0).get_node_shared_ptr(); + const auto& tensor_list = einsum_op->input_value(1).get_node_shared_ptr(); std::string equation; if (const auto& fw_node_mode = cast_fw_node(equation_input, "prim::Constant")) { const auto& attrs = fw_node_mode->get_attrs(); diff --git a/src/frontends/pytorch/src/transforms/listconstruct_replacer.cpp b/src/frontends/pytorch/src/transforms/listconstruct_replacer.cpp index c7db874634ba58..caa8d3cc18a3e6 100644 --- a/src/frontends/pytorch/src/transforms/listconstruct_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/listconstruct_replacer.cpp @@ -38,48 +38,48 @@ using namespace ov::op; ListConstructReplacer::ListConstructReplacer() { // Transformation for torch operators for cases where prim::ListConstruct can be replaced with Concat. - auto list = pattern::wrap_type(); + const auto& list = pattern::wrap_type(); // Both aten::view and aten::reshape are using same translation returning Reshape operator. - auto reshape_op = pattern::wrap_type({pattern::any_input(), list}); - auto roll_op = pattern::wrap_type({pattern::any_input(), list, pattern::any_input()}); - auto broadcast_op = pattern::wrap_type({pattern::any_input(), list}); - auto adapool_op = pattern::wrap_type({pattern::any_input(), list}); + const auto& reshape_op = pattern::wrap_type({pattern::any_input(), list}); + const auto& roll_op = pattern::wrap_type({pattern::any_input(), list, pattern::any_input()}); + const auto& broadcast_op = pattern::wrap_type({pattern::any_input(), list}); + const auto& adapool_op = pattern::wrap_type({pattern::any_input(), list}); // replace list construct for aten::expand(tensor, prim::ListConstruct(shapes)) old decomposition - // shape_of + broadcast + equal + select - auto shape_of_op = pattern::wrap_type({list}); - auto equal_op = pattern::wrap_type({list, pattern::any_input()}); - auto select_op = pattern::wrap_type({pattern::any_input(), pattern::any_input(), list}); + // shape_of + broadcast + equal + select + const auto& shape_of_op = pattern::wrap_type({list}); + const auto& equal_op = pattern::wrap_type({list, pattern::any_input()}); + const auto& select_op = pattern::wrap_type({pattern::any_input(), pattern::any_input(), list}); // replace list construct for aten::expand(tensor, prim::ListConstruct(shapes)) new decomposition - auto abs_op = pattern::wrap_type({list}); - auto expand_op = pattern::wrap_type({pattern::any_input(), abs_op}); + const auto& abs_op = pattern::wrap_type({list}); + const auto& expand_op = pattern::wrap_type({pattern::any_input(), abs_op}); // replace list construct for aten::repeat(tensor, prim::ListConstruct(shapes))) // shape_of + broadcast + tile - auto tile_op = pattern::wrap_type({pattern::any_input(), list}); + const auto& tile_op = pattern::wrap_type({pattern::any_input(), list}); // replace aten::permute(tensor, prim::ListConstruct) - auto transpose_op = pattern::wrap_type({pattern::any_input(), list}); + const auto& transpose_op = pattern::wrap_type({pattern::any_input(), list}); // aten::split_with_sizes case - auto vsplit_op = pattern::wrap_type({pattern::any_input(), pattern::any_input(), list}); + const auto& vsplit_op = pattern::wrap_type({pattern::any_input(), pattern::any_input(), list}); // aten::upsample... case inside the body when body was removed - auto interpolate_convert_op = pattern::wrap_type({list}); - auto interpolate_mul_op = pattern::wrap_type({interpolate_convert_op, pattern::any_input()}); - auto interpolate_op = + const auto& interpolate_convert_op = pattern::wrap_type({list}); + const auto& interpolate_mul_op = pattern::wrap_type({interpolate_convert_op, pattern::any_input()}); + const auto& interpolate_op = pattern::wrap_type({pattern::any_input(), interpolate_mul_op, pattern::any_input()}); // aten::randint case - auto rand_op = pattern::wrap_type({list, pattern::any_input(), pattern::any_input()}); - auto lc_pattern = std::make_shared(OutputVector{reshape_op, - roll_op, - broadcast_op, - adapool_op, - shape_of_op, - equal_op, - select_op, - expand_op, - tile_op, - transpose_op, - vsplit_op, - interpolate_op, - rand_op}); + const auto& rand_op = pattern::wrap_type({list, pattern::any_input(), pattern::any_input()}); + const auto& lc_pattern = std::make_shared(OutputVector{reshape_op, + roll_op, + broadcast_op, + adapool_op, + shape_of_op, + equal_op, + select_op, + expand_op, + tile_op, + transpose_op, + vsplit_op, + interpolate_op, + rand_op}); ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/frontends/pytorch/src/transforms/min_max_prim_list_construct_replacer.cpp b/src/frontends/pytorch/src/transforms/min_max_prim_list_construct_replacer.cpp index f2e092d316c875..8c056067b6b038 100644 --- a/src/frontends/pytorch/src/transforms/min_max_prim_list_construct_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/min_max_prim_list_construct_replacer.cpp @@ -26,12 +26,12 @@ namespace pass { using namespace ov::op; MinMaxPrimListConstructReplacer::MinMaxPrimListConstructReplacer() { - auto op = ov::pass::pattern::wrap_type(); + const auto& op = ov::pass::pattern::wrap_type(); ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { bool is_min = false; - auto max_op = cast_fw_node(m.get_match_root(), "prim::max"); - auto min_op = cast_fw_node(m.get_match_root(), "prim::min"); + const auto& max_op = cast_fw_node(m.get_match_root(), "prim::max"); + const auto& min_op = cast_fw_node(m.get_match_root(), "prim::min"); std::shared_ptr op; if (!max_op && !min_op) { return false; diff --git a/src/frontends/pytorch/src/transforms/prim_list_construct_pad.cpp b/src/frontends/pytorch/src/transforms/prim_list_construct_pad.cpp index a8483cd882903f..480d37d01681c8 100644 --- a/src/frontends/pytorch/src/transforms/prim_list_construct_pad.cpp +++ b/src/frontends/pytorch/src/transforms/prim_list_construct_pad.cpp @@ -59,7 +59,7 @@ const std::unordered_map PAD_MODES = {{"constant", PadMode PrimListConstructPadReplacer::PrimListConstructPadReplacer() { // transformation for case aten::pad + prim::ListConstruct as paddings - auto pad_op = ov::pass::pattern::wrap_type(); + const auto& pad_op = ov::pass::pattern::wrap_type(); ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { Output input_node; Output padding; @@ -70,7 +70,7 @@ PrimListConstructPadReplacer::PrimListConstructPadReplacer() { mode = "constant"; input_node = pad_op->input_value(0); padding = pad_op->input_value(1); - auto mode_node = pad_op->input_value(2).get_node_shared_ptr(); + const auto& mode_node = pad_op->input_value(2).get_node_shared_ptr(); if (const auto& fw_node_mode = cast_fw_node(mode_node, "prim::Constant")) { const auto& attrs = fw_node_mode->get_attrs(); if (attrs.find("string_value") != attrs.end()) { diff --git a/src/frontends/pytorch/src/transforms/prim_list_tuple_construct_replacer.cpp b/src/frontends/pytorch/src/transforms/prim_list_tuple_construct_replacer.cpp index 44f771887285e0..0c3f75360cb7f6 100644 --- a/src/frontends/pytorch/src/transforms/prim_list_tuple_construct_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/prim_list_tuple_construct_replacer.cpp @@ -52,7 +52,7 @@ bool DecomposeListTupleResults::run_on_model(const std::shared_ptr& model } auto names = out.get_names(); out.set_names({}); - for (auto name : names) { + for (auto& name : names) { if (!is_index(name)) { // Set first found non-index name as output name. If such name exist it will be debug name out.set_names({name}); diff --git a/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp b/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp index cec60b6a1a2e49..27d1245d475c56 100644 --- a/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp @@ -156,7 +156,8 @@ PrimListUnpackReplacer::PrimListUnpackReplacer() { auto range = rg.make(const_0_scalar, list_num_outs_scalar, const_1_scalar, element::i32); auto range_plus_1 = rg.make(range, const_1); - auto sections = rg.make(OutputVector{const_0, indices_or_sections, const_max}, 0); + auto sections = + rg.make(OutputVector{const_0, std::move(indices_or_sections), const_max}, 0); auto starts_tensor = rg.make(sections, const_0, const_neg_1, const_1, const_0); auto starts = diff --git a/src/frontends/pytorch/src/transforms/string_equality_replacer.cpp b/src/frontends/pytorch/src/transforms/string_equality_replacer.cpp index 028de354665fec..60a12b802f2a5f 100644 --- a/src/frontends/pytorch/src/transforms/string_equality_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/string_equality_replacer.cpp @@ -24,12 +24,12 @@ using namespace ov::pass; using namespace ov::op; StringEqualityReplacer::StringEqualityReplacer() { - auto framework_node_lhs = pattern::wrap_type(); - auto framework_node_rhs = pattern::wrap_type(); - auto equal_op = pattern::wrap_type({framework_node_lhs, framework_node_rhs}); - auto not_equal_op = pattern::wrap_type({framework_node_lhs, framework_node_rhs}); + const auto& framework_node_lhs = pattern::wrap_type(); + const auto& framework_node_rhs = pattern::wrap_type(); + const auto& equal_op = pattern::wrap_type({framework_node_lhs, framework_node_rhs}); + const auto& not_equal_op = pattern::wrap_type({framework_node_lhs, framework_node_rhs}); - auto string_equality_pattern = std::make_shared(OutputVector{equal_op, not_equal_op}); + const auto& string_equality_pattern = std::make_shared(OutputVector{equal_op, not_equal_op}); ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/frontends/pytorch/src/transforms/torchfx_gptq_pattern_replacer.cpp b/src/frontends/pytorch/src/transforms/torchfx_gptq_pattern_replacer.cpp index 95682cd784f67c..3108765b21e651 100644 --- a/src/frontends/pytorch/src/transforms/torchfx_gptq_pattern_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/torchfx_gptq_pattern_replacer.cpp @@ -52,28 +52,28 @@ void write_u4_data(void* array, size_t index, uint32_t data) { }; GPTQDecompressionReplacer::GPTQDecompressionReplacer() { - auto const_1 = wrap_type(); - auto const_2 = wrap_type(); - auto unsqueeze_1 = wrap_type({const_1, const_2}); - auto const_abs = wrap_type(); - auto abs = wrap_type({const_abs}); - auto broadcast_3 = wrap_type({unsqueeze_1, abs}); - auto const_6 = wrap_type(); - auto const_7 = wrap_type(); - auto unsqueeze_2 = wrap_type({const_6, const_7}); - auto bitwise_right_shift = wrap_type({broadcast_3, unsqueeze_2}); - auto convert_1 = wrap_type({bitwise_right_shift}); - auto const_8 = wrap_type(); - auto convert_2 = wrap_type({const_8}); - auto bitwise_and = wrap_type({convert_1, convert_2}); - - ov::matcher_pass_callback callback = [=](Matcher& m) { + const auto& const_1 = wrap_type(); + const auto& const_2 = wrap_type(); + const auto& unsqueeze_1 = wrap_type({const_1, const_2}); + const auto& const_abs = wrap_type(); + const auto& abs = wrap_type({const_abs}); + const auto& broadcast_3 = wrap_type({unsqueeze_1, abs}); + const auto& const_6 = wrap_type(); + const auto& const_7 = wrap_type(); + const auto& unsqueeze_2 = wrap_type({const_6, const_7}); + const auto& bitwise_right_shift = wrap_type({broadcast_3, unsqueeze_2}); + const auto& convert_1 = wrap_type({bitwise_right_shift}); + const auto& const_8 = wrap_type(); + const auto& convert_2 = wrap_type({const_8}); + const auto& bitwise_and = wrap_type({convert_1, convert_2}); + + ov::matcher_pass_callback callback = [unsqueeze_1](Matcher& m) { auto bitwise_and = m.get_match_root(); if (!bitwise_and) { return false; } const auto& pattern_map = m.get_pattern_value_map(); - auto input_node = pattern_map.at(unsqueeze_1).get_node_shared_ptr(); + const auto& input_node = pattern_map.at(unsqueeze_1).get_node_shared_ptr(); auto weights_u32 = std::dynamic_pointer_cast(input_node->get_input_node_shared_ptr(0)); auto axis = std::dynamic_pointer_cast(input_node->get_input_node_shared_ptr(1)); auto axis_data = axis->get_data_ptr(); @@ -118,7 +118,7 @@ GPTQDecompressionReplacer::GPTQDecompressionReplacer() { } } - copy_runtime_info_and_name(weights_u32, {new_const}, {weights_u32, bitwise_and, bitwise_right_shift}); + copy_runtime_info_and_name(weights_u32, {new_const}, {weights_u32, bitwise_and}); auto new_convert = std::make_shared(new_const, bitwise_and->get_output_element_type(0)); copy_runtime_info_and_name(bitwise_and, {new_convert}, {input_node}); @@ -131,22 +131,22 @@ GPTQDecompressionReplacer::GPTQDecompressionReplacer() { }; GPTQMultPatternReplacer::GPTQMultPatternReplacer() { - auto const_1_1 = wrap_type(); - auto convert_1 = wrap_type({const_1_1}); - auto const_1_2 = wrap_type(); - auto convert_2 = wrap_type({const_1_2}); - auto add = wrap_type({convert_1, convert_2}); - auto const_2 = wrap_type(); - auto reshape_1 = wrap_type({add, const_2}); - auto const_3_1 = wrap_type(); - auto convert_4 = wrap_type({const_3_1}); - auto const_3_2 = wrap_type(); - auto reshape_2 = wrap_type({convert_4, const_3_2}); - auto subtract = wrap_type({reshape_2, reshape_1}); - auto convert_3 = wrap_type({subtract}); - auto const_4_1 = wrap_type(); - auto const_4_2 = wrap_type(); - auto reshape_3 = wrap_type({const_4_1, const_4_2}); + const auto& const_1_1 = wrap_type(); + const auto& convert_1 = wrap_type({const_1_1}); + const auto& const_1_2 = wrap_type(); + const auto& convert_2 = wrap_type({const_1_2}); + const auto& add = wrap_type({convert_1, convert_2}); + const auto& const_2 = wrap_type(); + const auto& reshape_1 = wrap_type({add, const_2}); + const auto& const_3_1 = wrap_type(); + const auto& convert_4 = wrap_type({const_3_1}); + const auto& const_3_2 = wrap_type(); + const auto& reshape_2 = wrap_type({convert_4, const_3_2}); + const auto& subtract = wrap_type({reshape_2, reshape_1}); + const auto& convert_3 = wrap_type({subtract}); + const auto& const_4_1 = wrap_type(); + const auto& const_4_2 = wrap_type(); + const auto& reshape_3 = wrap_type({const_4_1, const_4_2}); auto mult = wrap_type({reshape_3, convert_3}); @@ -174,8 +174,8 @@ GPTQMultPatternReplacer::GPTQMultPatternReplacer() { auto add_in1_ptr = convert_2_input_const->get_data_ptr(); if (!add_in1_ptr) return false; - auto add_in0_shape = add_input0_const->get_shape(); - auto static_shape_1 = reshape_node->get_shape(); + const auto& add_in0_shape = add_input0_const->get_shape(); + const auto& static_shape_1 = reshape_node->get_shape(); size_t add_in0_size = shape_size(add_in0_shape); auto add_replace_const = std::make_shared(element::f32, static_shape_1); auto add_replace_ptr = const_cast(reinterpret_cast(add_replace_const->get_data_ptr())); @@ -191,7 +191,7 @@ GPTQMultPatternReplacer::GPTQMultPatternReplacer() { add_replace_ptr[i] = (float)val; } - auto static_shape_2 = reshape2_node->get_shape(); + const auto& static_shape_2 = reshape2_node->get_shape(); auto reshape2_in0_const = std::dynamic_pointer_cast(convert_4_node->get_input_node_shared_ptr(0)); auto sub_replace_const = std::make_shared(reshape2_in0_const->get_element_type(), static_shape_2, @@ -199,7 +199,7 @@ GPTQMultPatternReplacer::GPTQMultPatternReplacer() { auto new_convert_node = std::make_shared(sub_replace_const, element::f32); auto new_sub_node = std::make_shared(new_convert_node, add_replace_const); - auto static_shape_3 = reshape3_node->get_shape(); + const auto& static_shape_3 = reshape3_node->get_shape(); auto reshape3_in0_const = std::dynamic_pointer_cast(reshape3_node->get_input_node_shared_ptr(0)); auto mult_scale_const = std::make_shared(reshape3_in0_const->get_element_type(), static_shape_3, diff --git a/src/frontends/pytorch/src/transforms/tuple_unpack_replacer.cpp b/src/frontends/pytorch/src/transforms/tuple_unpack_replacer.cpp index a9690c8a37c436..7ea557fa81682d 100644 --- a/src/frontends/pytorch/src/transforms/tuple_unpack_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/tuple_unpack_replacer.cpp @@ -145,8 +145,8 @@ bool TupleUnpackInBodyReplacer::run_on_model(const std::shared_ptr& model int else_p_idx = inputs_mapping[j].second; if (else_p_idx > else_body_idx && else_body_idx != -1) else_p_idx--; - auto then_p = then_p_idx == -1 ? nullptr : then_body->get_parameters()[then_p_idx]; - auto else_p = else_p_idx == -1 ? nullptr : else_body->get_parameters()[else_p_idx]; + const auto& then_p = then_p_idx == -1 ? nullptr : then_body->get_parameters()[then_p_idx]; + const auto& else_p = else_p_idx == -1 ? nullptr : else_body->get_parameters()[else_p_idx]; if (then_p || else_p) new_if->set_invariant_inputs(if_op->input_value(j), {then_p, else_p}); } diff --git a/src/frontends/pytorch/src/transforms/u4_block_repack.cpp b/src/frontends/pytorch/src/transforms/u4_block_repack.cpp index 8d268d111d3653..9fc4d2c8b104bb 100644 --- a/src/frontends/pytorch/src/transforms/u4_block_repack.cpp +++ b/src/frontends/pytorch/src/transforms/u4_block_repack.cpp @@ -22,22 +22,22 @@ using namespace ov::op; using namespace ov::pass::pattern; U4BlockRepack::U4BlockRepack(bool is_symmetrical) { - const auto m_constant = ov::pass::pattern::wrap_type(); - const auto m_reshape1 = ov::pass::pattern::wrap_type({m_constant, any_input()}); - const auto m_transpose = ov::pass::pattern::wrap_type({m_reshape1, any_input()}); - const auto m_reshape2 = ov::pass::pattern::wrap_type({m_transpose, any_input()}); + const auto& m_constant = ov::pass::pattern::wrap_type(); + const auto& m_reshape1 = ov::pass::pattern::wrap_type({m_constant, any_input()}); + const auto& m_transpose = ov::pass::pattern::wrap_type({m_reshape1, any_input()}); + const auto& m_reshape2 = ov::pass::pattern::wrap_type({m_transpose, any_input()}); auto pack_byte = [](uint8_t lo, uint8_t hi) -> uint8_t { return (hi << 4) | (lo & 0x0F); }; // swap halfs because Convert op assumes this layout - std::function get_u4 = [](const uint8_t* src, size_t idx) { + const std::function& get_u4 = [](const uint8_t* src, size_t idx) { const size_t byte_idx = idx / 2; const uint8_t bit_shift = 4 * (idx % 2); return (src[byte_idx] >> bit_shift) & 0xF; }; - std::function get_i4 = [get_u4](const uint8_t* src, size_t idx) { + const std::function& get_i4 = [get_u4](const uint8_t* src, size_t idx) { // by flipping first bit we get same effect as subtracting 8 return get_u4(src, idx) ^ 0b1000; }; diff --git a/src/frontends/pytorch/src/translate_session.cpp b/src/frontends/pytorch/src/translate_session.cpp index eb7c6c08137ad7..a17e1b7d03b27d 100644 --- a/src/frontends/pytorch/src/translate_session.cpp +++ b/src/frontends/pytorch/src/translate_session.cpp @@ -21,7 +21,7 @@ namespace pytorch { using namespace ov::op; TranslateSession::TranslateSession(const ov::frontend::InputModel::Ptr& input_model, - const std::map& translator_map, + const std::unordered_map& translator_map, const std::shared_ptr& telemetry) : m_input_model(input_model), m_translator_map(translator_map), @@ -70,9 +70,10 @@ std::shared_ptr TranslateSession::translate_graph(const ov::frontend: // process model rt_info auto rt_info = pytorch_model->get_decoder()->get_rt_info(); - for (auto item : rt_info) { + for (const auto& item : rt_info) { model->set_rt_info(item.second, item.first); } + model->set_rt_info("decoder_type_name", pytorch_model->decoder_type_name()); return model; } @@ -99,10 +100,10 @@ std::shared_ptr TranslateSession::convert_pytorch_model( element::Type type = pytorch_place->get_element_type(); PartialShape pshape = pytorch_place->get_partial_shape(); auto parameter = std::make_shared(type, pshape); - if (pytorch_place->get_names().size() > 0) - parameter->set_friendly_name(pytorch_place->get_names().at(0)); + if (!pytorch_place->get_names().empty()) + parameter->set_friendly_name(pytorch_place->get_names().front()); encode_tensor_name(parameter->output(0), tensor_id); - parameters->push_back(parameter); + parameters->emplace_back(parameter); (*tensor_map)[tensor_id] = parameter; } } else { @@ -119,7 +120,7 @@ std::shared_ptr TranslateSession::convert_pytorch_model( auto parameter = std::make_shared(type, pshape); parameter->set_friendly_name(pytorch_model->get_input_signature_name(i)); encode_tensor_name(parameter->output(0), inputs.at(i), {pytorch_model->get_input_debug_name(i)}); - parameters->push_back(parameter); + parameters->emplace_back(parameter); (*tensor_map)[inputs.at(i)] = parameter; } } @@ -176,15 +177,17 @@ std::shared_ptr TranslateSession::convert_pytorch_model( converted_outputs.size(), " respectively."); + const bool has_inputs = !node->inputs().empty(); + const size_t in_tensor_id = has_inputs ? node->inputs().at(0) : 0; for (size_t i = 0; i < fw_outputs.size(); ++i) { size_t fw_tensor_id = node->output(i); - if (node->inputs().size() > 0 && node->may_produce_alias(0, i)) { + if (has_inputs && node->may_produce_alias(0, i)) { + auto alias_iter = m_may_be_alias.find(fw_tensor_id); // TODO: do we need to check other inputs, not only 0? - auto in_tensor_id = node->inputs().at(0); - if (m_may_be_alias.count(fw_tensor_id)) { + if (alias_iter != m_may_be_alias.end()) { size_t recorded_in_tensor_id; std::shared_ptr recorded_node; - std::tie(recorded_in_tensor_id, recorded_node, std::ignore) = m_may_be_alias.at(fw_tensor_id); + std::tie(recorded_in_tensor_id, recorded_node, std::ignore) = alias_iter->second; FRONT_END_GENERAL_CHECK(recorded_in_tensor_id == in_tensor_id, "Operation ", context.get_op_type(), @@ -199,14 +202,16 @@ std::shared_ptr TranslateSession::convert_pytorch_model( OPENVINO_DEBUG("Registered alias: ", fw_tensor_id, " of tensor: ", - node->inputs().at(0), + in_tensor_id, " of operation: ", context.get_op_type()); } FRONT_END_GENERAL_CHECK(tensor_map->find(fw_tensor_id) == tensor_map->end(), "Duplicated producer for PT value with unique ID: ", fw_tensor_id); - auto out_type = context.get_output_type(i); + +#ifdef ENABLE_OPENVINO_DEBUG + const auto out_type = context.get_output_type(i); if (out_type.is()) { if (!converted_outputs[i].get_element_type().compatible(out_type.as())) { OPENVINO_DEBUG("[WARNING] Produced output type for operation ", @@ -219,6 +224,7 @@ std::shared_ptr TranslateSession::convert_pytorch_model( out_type.as()); } } +#endif (*tensor_map)[fw_tensor_id] = converted_outputs[i]; encode_tensor_name(converted_outputs[i], fw_tensor_id, {node->get_output_debug_name(i)}); } @@ -236,7 +242,7 @@ std::shared_ptr TranslateSession::convert_pytorch_model( FRONT_END_GENERAL_CHECK(pytorch_place, "Only place produced by PyTorch Frontend is supported."); auto tensor_id = pytorch_place->get_tensor_index(); auto ov_output = tensor_map->at(tensor_id); - FRONT_END_GENERAL_CHECK(ov_output.get_names().size() > 0, + FRONT_END_GENERAL_CHECK(!ov_output.get_names().empty(), "Tensor doesn't have name, while it should have name: ", tensor_id); auto result = std::make_shared(ov_output); @@ -245,18 +251,18 @@ std::shared_ptr TranslateSession::convert_pytorch_model( } else { for (size_t i = 0; i < pytorch_model->num_of_outputs(); ++i) { size_t id = pytorch_model->output(i); - if (tensor_map->find(id) == tensor_map->end()) { + auto it = tensor_map->find(id); + if (it == tensor_map->end()) { // Not found in this scope, adding Parameter to connect to external scope auto parameter = std::make_shared(element::dynamic, PartialShape::dynamic()); encode_tensor_name(parameter->output(0), id); parameters->push_back(parameter); - (*tensor_map)[id] = parameter; + it = tensor_map->emplace(id, parameter).first; } - auto ov_output = tensor_map->at(id); - FRONT_END_GENERAL_CHECK(ov_output.get_names().size() > 0, + FRONT_END_GENERAL_CHECK(!it->second.get_names().empty(), "Tensor doesn't have name, while it should have name: ", id); - auto result = std::make_shared(ov_output); + auto result = std::make_shared(it->second); results.push_back(result); } } @@ -307,11 +313,22 @@ std::shared_ptr TranslateSession::convert_pytorch_model( OutputVector TranslateSession::convert_node(const NodeContext& context) { std::string exception; try { - auto it = m_translator_map.find(context.get_op_type()); + const auto& op_type = context.get_op_type(); + auto it = m_translator_map.find(op_type); if (it != m_translator_map.end()) { return it->second(context); + } else if (op_type.back() == '_') { + // inplace op case + std::string op_type_cut = op_type.substr(0, op_type.size() - 1); + auto it = m_translator_map.find(op_type_cut); + if (it != m_translator_map.end()) { + const auto& res = it->second(context); + FRONT_END_OP_CONVERSION_CHECK(res.size() == 1, "inplace op must have single output."); + context.mutate_input(0, res[0]); + return res; + } } - OPENVINO_DEBUG("No translator found for: ", context.get_op_type(), "\n"); + OPENVINO_DEBUG("No translator found for: ", op_type, "\n"); } catch (std::exception& e) { exception = e.what(); } catch (...) { @@ -332,7 +349,7 @@ OutputVector TranslateSession::convert_node(const NodeContext& context) { void TranslateSession::encode_tensor_name(Output output, size_t tensor_idx, - std::vector additional_names) { + const std::vector& additional_names) { if (!output.get_names().empty()) { OPENVINO_DEBUG("Tensor names already exist: ", output.get_any_name(), @@ -342,22 +359,21 @@ void TranslateSession::encode_tensor_name(Output output, return; } auto name = std::to_string(tensor_idx); - std::unordered_set names; - names.insert(name); - if (additional_names.size() > 0) { + std::unordered_set names = {name}; + if (!additional_names.empty()) { names.insert(additional_names.begin(), additional_names.end()); } - if (m_counter_map.count(tensor_idx)) { - auto&& pair = m_counter_map[tensor_idx]; + auto it = m_counter_map.find(tensor_idx); + if (it != m_counter_map.end()) { + auto& pair = it->second; auto new_name = name + '_' + std::to_string(++pair.first); - pair.second.set_names({new_name}); + pair.second.set_names({std::move(new_name)}); pair.second = output; - output.set_names(names); } else { - m_counter_map[tensor_idx] = {0, output}; - output.set_names(names); + m_counter_map.emplace(tensor_idx, std::make_pair(0, output)); } + output.set_names(std::move(names)); } namespace { @@ -424,7 +440,7 @@ using ReversepropCreatorFunction = std::function(const Outp Output TranslateSession::get_reverseprop_op(const std::shared_ptr& node, const Output& direct_op_output, const Output& value) { - std::map backprop_map = { + static const std::map backprop_map = { {"aten::slice", slice_reverseprop}, {"aten::select", select_reverseprop}, }; diff --git a/src/frontends/pytorch/src/translate_session.hpp b/src/frontends/pytorch/src/translate_session.hpp index 723e94e25116a8..df669dbabe1fae 100644 --- a/src/frontends/pytorch/src/translate_session.hpp +++ b/src/frontends/pytorch/src/translate_session.hpp @@ -18,7 +18,7 @@ namespace pytorch { class TranslateSession { public: TranslateSession(const frontend::InputModel::Ptr& input_model, - const std::map& translator_map, + const std::unordered_map& translator_map, const std::shared_ptr& telemetry); ~TranslateSession(); std::shared_ptr get_converted_model(); @@ -42,7 +42,7 @@ class TranslateSession { /// \brief Writes pytorch tensor index into openvino tensor void encode_tensor_name(Output tensor_desc, size_t tensor_idx, - std::vector additional_names = {}); + const std::vector& additional_names = {}); /// \brief Gets pytorch tensor index from openvino tensor size_t decode_tensor_name(const Output& tensor_desc); @@ -55,7 +55,7 @@ class TranslateSession { OutputVector convert_node(const NodeContext& context); const frontend::InputModel::Ptr m_input_model; - const std::map& m_translator_map; + const std::unordered_map& m_translator_map; std::shared_ptr m_telemetry; std::shared_ptr m_ov_model; diff --git a/src/frontends/pytorch/src/utils.cpp b/src/frontends/pytorch/src/utils.cpp index a2c4b35529de1f..b096da45f25437 100644 --- a/src/frontends/pytorch/src/utils.cpp +++ b/src/frontends/pytorch/src/utils.cpp @@ -130,9 +130,7 @@ std::shared_ptr get_node_axes_range(const NodeContext& context, const Outp Output normalize_axis(const NodeContext& context, const Output& axis, const Output& rank) { auto axis_rank = context.mark_node(std::make_shared(axis, rank)); - auto is_less = context.mark_node(std::make_shared(axis_rank, rank)); - auto new_axis = context.mark_node(std::make_shared(is_less, axis_rank, axis)); - return new_axis; + return context.mark_node(std::make_shared(axis_rank, rank)); } std::shared_ptr numel(const NodeContext& context, const Output& x, element::Type output_type) { @@ -217,14 +215,13 @@ std::shared_ptr create_fw_node_with_exception(const NodeContext bool skip_subgraphs = false) { auto fw_node = std::make_shared(context.get_decoder(), inputs, num_outputs, false, skip_subgraphs); context.mark_node(fw_node); - auto attrs = fw_node->get_attrs(); - std::string message(exception_message); - if (!message.empty()) { - message = "Exception happened during conversion of operation " + fw_node->get_friendly_name() + - " with schema " + context.get_schema() + '\n' + message; + if (!exception_message.empty()) { + auto attrs = fw_node->get_attrs(); + std::string message = "Exception happened during conversion of operation " + fw_node->get_friendly_name() + + " with schema " + context.get_schema() + '\n' + exception_message; + attrs[PtFrameworkNode::failed_conversion_key] = std::move(message); + fw_node->set_attrs(attrs); } - attrs[PtFrameworkNode::failed_conversion_key] = message; - fw_node->set_attrs(attrs); return fw_node; } } // namespace @@ -537,7 +534,7 @@ void copy_runtime_info_and_name(const std::shared_ptr& from, } else { unique_names.insert(new_name); } - op->set_friendly_name(new_name); + op->set_friendly_name(std::move(new_name)); } } copy_runtime_info(from, to); diff --git a/src/frontends/pytorch/src/utils_quantize.cpp b/src/frontends/pytorch/src/utils_quantize.cpp index ad61dc38a9580f..ccf7f20785b09b 100644 --- a/src/frontends/pytorch/src/utils_quantize.cpp +++ b/src/frontends/pytorch/src/utils_quantize.cpp @@ -256,9 +256,9 @@ std::shared_ptr u4_compression_stack(const OutputVector& list_elems, int64 // Pattern detected, weights_u8 is target u8 packed constant with weights // Part 2: Form u4 constant by repacking of the original weights_u8 - // Repacking transformes half of lanes to interleaved representation. + // Repacking transforms half of lanes to interleaved representation. - auto u8_shape = weights_u8->get_shape(); + const auto& u8_shape = weights_u8->get_shape(); size_t full_size = shape_size(u8_shape); auto src = weights_u8->get_data_ptr(); @@ -268,7 +268,7 @@ std::shared_ptr u4_compression_stack(const OutputVector& list_elems, int64 auto dst = const_cast(reinterpret_cast(new_const->get_data_ptr())); std::copy(src, src + full_size, dst); // TODO: Avoid copying, reuse the same constant - copy_runtime_info_and_name(weights_u8, {new_const}, {weights_u8, bitwise_and, bitwise_shift}); + copy_runtime_info_and_name(weights_u8, {new_const}, {weights_u8, std::move(bitwise_and), bitwise_shift}); return new_const; } From db22d0a0080701bdef58d09c98b1f9582231b6ff Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Tue, 20 Aug 2024 15:31:44 +0400 Subject: [PATCH 052/117] [TF FE][Tokenizers] Avoid dependency from TF FE in tokenizers (#26131) **Details:** All required routines (Variable, HashTable) are moved to common FE API **Ticket:** 148101 --------- Signed-off-by: Kazantsev, Roman --- .../include/openvino/frontend/hash_table.hpp | 135 ++++++++++++++++++ .../openvino/frontend/node_context.hpp | 5 + .../include/openvino/frontend/variable.hpp | 117 +++++++++++++++ src/frontends/common/src/hash_table.cpp | 9 ++ src/frontends/common/src/variable.cpp | 9 ++ .../frontend/tensorflow/hash_table.hpp | 117 +-------------- .../frontend/tensorflow/node_context.hpp | 2 +- .../openvino/frontend/tensorflow/variable.hpp | 100 +------------ 8 files changed, 280 insertions(+), 214 deletions(-) create mode 100644 src/frontends/common/include/openvino/frontend/hash_table.hpp create mode 100644 src/frontends/common/include/openvino/frontend/variable.hpp create mode 100644 src/frontends/common/src/hash_table.cpp create mode 100644 src/frontends/common/src/variable.cpp diff --git a/src/frontends/common/include/openvino/frontend/hash_table.hpp b/src/frontends/common/include/openvino/frontend/hash_table.hpp new file mode 100644 index 00000000000000..b60159fd381eda --- /dev/null +++ b/src/frontends/common/include/openvino/frontend/hash_table.hpp @@ -0,0 +1,135 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "openvino/core/node_output.hpp" +#include "openvino/core/type/element_type.hpp" +#include "openvino/frontend/variable.hpp" +#include "openvino/frontend/visibility.hpp" + +namespace ov { +namespace frontend { + +/// \brief HashTable is a special type of Variable that has a complex value including keys and values. +/// Keys and values are represented with two separate graph at each time step +class FRONTEND_API HashTable : public Variable { +public: + using Ptr = std::shared_ptr; + OPENVINO_OP("HashTable", "ov::frontend", Variable); + + HashTable(const std::string& name, + const ov::element::Type& key_type, + const ov::element::Type& value_type, + const std::shared_ptr& decoder = nullptr) + : Variable(name, decoder), + m_key_type(key_type), + m_value_type(value_type) { + validate_and_infer_types(); + } + + HashTable(const HashTable& other, const ov::Output& keys, const ov::Output& values) + : HashTable(other) { + m_keys = keys; + m_values = values; + m_is_initialized = true; + ++m_init_counter; + } + + // it must be used only for cloning + // other ways are illegal + HashTable(const std::string& name, + const ov::element::Type& key_type, + const ov::element::Type& value_type, + const ov::Output& keys, + const ov::Output& values, + bool is_initialized, + uint64_t init_counter, + const std::shared_ptr& decoder = nullptr) + : Variable(name, decoder), + m_key_type(key_type), + m_value_type(value_type), + m_keys(keys), + m_values(values) { + m_init_counter = init_counter; + m_is_initialized = is_initialized; + validate_and_infer_types(); + } + + void validate_and_infer_types() override { + // this is a type of resource so its shape and type is not applicable + // its output serves to store a reference to a resource + set_output_type(0, ov::element::dynamic, ov::PartialShape::dynamic()); + // these two outputs serves to store keys and values of a resource + // keys and values are 1D tensors + set_output_type(1, m_key_type, ov::PartialShape::dynamic(1)); + set_output_type(2, m_value_type, ov::PartialShape::dynamic(1)); + } + + std::shared_ptr clone_with_new_inputs(const OutputVector& inputs) const override { + auto hash_table_node = std::make_shared(m_name, + m_key_type, + m_value_type, + m_keys, + m_values, + m_is_initialized, + m_init_counter, + m_decoder); + hash_table_node->set_attrs(get_attrs()); + return hash_table_node; + } + + ov::Output get_value() override { + return output(0); + } + + /// \brief Returns a value corresponding keys of hash table + ov::Output get_keys() { + if (m_is_initialized) { + return m_keys; + } else if (m_other_keys.size() > 0) { + return *(m_other_keys.begin()); + } + + return output(1); + } + + /// \brief Returns a value corresponding values of hash table + ov::Output get_values() { + if (m_is_initialized) { + return m_values; + } else if (m_other_values.size() > 0) { + return *(m_other_values.begin()); + } + + return output(2); + } + + ov::element::Type get_key_type() const { + return m_key_type; + } + + ov::element::Type get_value_type() const { + return m_value_type; + } + + void add_other_keys_values(const ov::Output& other_key, const ov::Output& other_value) { + m_other_keys.insert(other_key); + m_other_values.insert(other_value); + } + + virtual ~HashTable(); + +private: + ov::element::Type m_key_type; + ov::element::Type m_value_type; + ov::Output m_keys; + ov::Output m_values; + + std::set> m_other_keys; + std::set> m_other_values; +}; + +} // namespace frontend +} // namespace ov diff --git a/src/frontends/common/include/openvino/frontend/node_context.hpp b/src/frontends/common/include/openvino/frontend/node_context.hpp index c18e6b77baa5ea..98243fab0e9c63 100644 --- a/src/frontends/common/include/openvino/frontend/node_context.hpp +++ b/src/frontends/common/include/openvino/frontend/node_context.hpp @@ -48,6 +48,11 @@ class FRONTEND_API NodeContext { FRONT_END_NOT_IMPLEMENTED(get_input); } + /// \brief Returns the input by reference. The reference value can be changed by consuming operation + virtual Output get_input_by_reference(int idx) const { + FRONT_END_NOT_IMPLEMENTED(get_input_by_reference); + } + /// \brief Returns values from Constant input with the given index as ov::Any. /// Throws an exception if the input cannot be represented as Constant. virtual Any get_values_from_const_input(int idx) const { diff --git a/src/frontends/common/include/openvino/frontend/variable.hpp b/src/frontends/common/include/openvino/frontend/variable.hpp new file mode 100644 index 00000000000000..79415bcddd2390 --- /dev/null +++ b/src/frontends/common/include/openvino/frontend/variable.hpp @@ -0,0 +1,117 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "openvino/frontend/decoder.hpp" +#include "openvino/frontend/visibility.hpp" +#include "openvino/op/util/framework_node.hpp" + +namespace ov { +namespace frontend { + +/// \brief Variable is a special node used in a conversion step +/// It can have several values (or states) during the conversion. +/// Variable value at some time step is represented with a graph. +class FRONTEND_API Variable : public ov::op::util::FrameworkNode { +public: + using Ptr = std::shared_ptr; + OPENVINO_OP("Variable", "ov::frontend", ov::op::util::FrameworkNode); + + Variable(const std::string& name, const std::shared_ptr& decoder) + : ov::op::util::FrameworkNode(ov::OutputVector{}, 1), + m_name(name), + m_shape(ov::Shape{}), + m_type(ov::element::dynamic), + m_decoder(decoder), + m_is_initialized(false), + m_init_counter(0) { + validate_and_infer_types(); + } + + Variable(const std::string& name, + const ov::Shape& shape, + const ov::element::Type& type, + const std::shared_ptr& decoder) + : ov::op::util::FrameworkNode(ov::OutputVector{}, 1), + m_name(name), + m_shape(shape), + m_type(type), + m_decoder(decoder), + m_is_initialized(false), + m_init_counter(0) { + validate_and_infer_types(); + } + + Variable(const std::string& name, + const ov::Shape& shape, + const ov::element::Type& type, + const ov::Output& value, + const std::shared_ptr& decoder) + : Variable(name, shape, type, decoder) { + m_value = value; + // reset names of tensor corresponding to variable value + // that is because variable can have multiple values during inference + m_value.set_names({}); + m_is_initialized = true; + ++m_init_counter; + } + + Variable(const Variable& other, const ov::Output& value) : Variable(other) { + m_value = value; + // reset names of tensor corresponding to variable value + // that is because variable can have multiple values during inference + m_value.set_names({}); + m_is_initialized = true; + ++m_init_counter; + } + + void validate_and_infer_types() override { + set_output_type(0, m_type, m_shape); + } + + /// \brief Checks if variable is initialized with some value + bool is_initialized() const { + return m_is_initialized; + } + + /// \brief Returns a value at the current step of conversion + virtual ov::Output get_value() { + FRONT_END_GENERAL_CHECK(m_is_initialized, "internal error: get_value() is called for uninitialized variable"); + return m_value; + } + + std::string get_name() const { + return m_name; + } + + /// \brief Returns a counter value (a number of values that have assigned to this variable) + uint64_t get_init_counter() const { + return m_init_counter; + } + + std::shared_ptr get_decoder() const { + return m_decoder; + } + + std::shared_ptr clone_with_new_inputs(const OutputVector& inputs) const override { + auto new_variable = std::make_shared(*this); + new_variable->set_attrs(get_attrs()); + return new_variable; + } + + virtual ~Variable(); + +protected: + std::string m_name; + ov::Shape m_shape; + ov::element::Type m_type; + std::shared_ptr m_decoder; + bool m_is_initialized; + ov::Output m_value; + uint64_t m_init_counter; +}; + +} // namespace frontend +} // namespace ov diff --git a/src/frontends/common/src/hash_table.cpp b/src/frontends/common/src/hash_table.cpp new file mode 100644 index 00000000000000..87991938fbfc3b --- /dev/null +++ b/src/frontends/common/src/hash_table.cpp @@ -0,0 +1,9 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/frontend/hash_table.hpp" + +using namespace ov::frontend; + +HashTable::~HashTable(){}; diff --git a/src/frontends/common/src/variable.cpp b/src/frontends/common/src/variable.cpp new file mode 100644 index 00000000000000..dc3b2a692f328c --- /dev/null +++ b/src/frontends/common/src/variable.cpp @@ -0,0 +1,9 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/frontend/variable.hpp" + +using namespace ov::frontend; + +Variable::~Variable(){}; diff --git a/src/frontends/tensorflow/include/openvino/frontend/tensorflow/hash_table.hpp b/src/frontends/tensorflow/include/openvino/frontend/tensorflow/hash_table.hpp index beecb75e733f56..f2e39df79443fb 100644 --- a/src/frontends/tensorflow/include/openvino/frontend/tensorflow/hash_table.hpp +++ b/src/frontends/tensorflow/include/openvino/frontend/tensorflow/hash_table.hpp @@ -4,9 +4,7 @@ #pragma once -#include "openvino/core/node_output.hpp" -#include "openvino/core/type/element_type.hpp" -#include "openvino/frontend/tensorflow/variable.hpp" +#include "openvino/frontend/hash_table.hpp" namespace ov { namespace frontend { @@ -16,118 +14,7 @@ namespace tensorflow { // tf.raw_ops.MutableHashTable and stores a dictionary of keys mapped to values // Objects of this class is fed to Lookup* operations for initialization and searching values by keys // Types of keys and values can be different -class HashTable : public Variable { -public: - using Ptr = std::shared_ptr; - OPENVINO_OP("TFHashTable", "ov::frontend::tensorflow", Variable); - - HashTable(const std::string& name, - const ov::element::Type& key_type, - const ov::element::Type& value_type, - const std::shared_ptr& decoder = nullptr) - : Variable(name, decoder), - m_key_type(key_type), - m_value_type(value_type) { - validate_and_infer_types(); - } - - HashTable(const HashTable& other, const ov::Output& keys, const ov::Output& values) - : HashTable(other) { - m_keys = keys; - m_values = values; - m_is_initialized = true; - ++m_init_counter; - } - - // it must be used only for cloning - // other ways are illegal - HashTable(const std::string& name, - const ov::element::Type& key_type, - const ov::element::Type& value_type, - const ov::Output& keys, - const ov::Output& values, - bool is_initialized, - uint64_t init_counter, - const std::shared_ptr& decoder = nullptr) - : Variable(name, decoder), - m_key_type(key_type), - m_value_type(value_type), - m_keys(keys), - m_values(values) { - m_init_counter = init_counter; - m_is_initialized = is_initialized; - validate_and_infer_types(); - } - - void validate_and_infer_types() override { - // this is a type of resource so its shape and type is not applicable - // its output serves to store a reference to a resource - set_output_type(0, ov::element::dynamic, ov::PartialShape::dynamic()); - // these two outputs serves to store keys and values of a resource - // keys and values are 1D tensors - set_output_type(1, m_key_type, ov::PartialShape::dynamic(1)); - set_output_type(2, m_value_type, ov::PartialShape::dynamic(1)); - } - - std::shared_ptr clone_with_new_inputs(const OutputVector& inputs) const override { - auto hash_table_node = std::make_shared(m_name, - m_key_type, - m_value_type, - m_keys, - m_values, - m_is_initialized, - m_init_counter, - m_decoder); - hash_table_node->set_attrs(get_attrs()); - return hash_table_node; - } - - ov::Output get_value() override { - return output(0); - } - - ov::Output get_keys() { - if (m_is_initialized) { - return m_keys; - } else if (m_other_keys.size() > 0) { - return *(m_other_keys.begin()); - } - - return output(1); - } - - ov::Output get_values() { - if (m_is_initialized) { - return m_values; - } else if (m_other_values.size() > 0) { - return *(m_other_values.begin()); - } - - return output(2); - } - - ov::element::Type get_key_type() const { - return m_key_type; - } - - ov::element::Type get_value_type() const { - return m_value_type; - } - - void add_other_keys_values(const ov::Output& other_key, const ov::Output& other_value) { - m_other_keys.insert(other_key); - m_other_values.insert(other_value); - } - -private: - ov::element::Type m_key_type; - ov::element::Type m_value_type; - ov::Output m_keys; - ov::Output m_values; - - std::set> m_other_keys; - std::set> m_other_values; -}; +using ov::frontend::HashTable; } // namespace tensorflow } // namespace frontend diff --git a/src/frontends/tensorflow/include/openvino/frontend/tensorflow/node_context.hpp b/src/frontends/tensorflow/include/openvino/frontend/tensorflow/node_context.hpp index 65f2c7a7bf9f0a..f2dba04b49dca7 100644 --- a/src/frontends/tensorflow/include/openvino/frontend/tensorflow/node_context.hpp +++ b/src/frontends/tensorflow/include/openvino/frontend/tensorflow/node_context.hpp @@ -37,7 +37,7 @@ class NodeContext : public ov::frontend::NodeContext { } /// Retrieve the input by reference. It is needed for operations working with reference inputs - Output get_input_by_reference(int port_index) const { + Output get_input_by_reference(int port_index) const override { auto input = m_inputs.at(port_index); auto ref_node = ov::as_type_ptr(input.get_node_shared_ptr()); if (ref_node) { diff --git a/src/frontends/tensorflow/include/openvino/frontend/tensorflow/variable.hpp b/src/frontends/tensorflow/include/openvino/frontend/tensorflow/variable.hpp index 5f54249d6e926f..14b2692bc3c00c 100644 --- a/src/frontends/tensorflow/include/openvino/frontend/tensorflow/variable.hpp +++ b/src/frontends/tensorflow/include/openvino/frontend/tensorflow/variable.hpp @@ -4,109 +4,13 @@ #pragma once -#include "openvino/frontend/tensorflow/decoder.hpp" -#include "openvino/op/util/framework_node.hpp" +#include "openvino/frontend/variable.hpp" namespace ov { namespace frontend { namespace tensorflow { -class Variable : public ov::op::util::FrameworkNode { -public: - using Ptr = std::shared_ptr; - OPENVINO_OP("TFVariable", "ov::frontend::tensorflow", ::ov::op::util::FrameworkNode); - - Variable(const std::string& name, const std::shared_ptr& decoder) - : ov::op::util::FrameworkNode(ov::OutputVector{}, 1), - m_name(name), - m_shape(ov::Shape{}), - m_type(ov::element::dynamic), - m_decoder(decoder), - m_is_initialized(false), - m_init_counter(0) { - validate_and_infer_types(); - } - - Variable(const std::string& name, - const ov::Shape& shape, - const ov::element::Type& type, - const std::shared_ptr& decoder) - : ov::op::util::FrameworkNode(ov::OutputVector{}, 1), - m_name(name), - m_shape(shape), - m_type(type), - m_decoder(decoder), - m_is_initialized(false), - m_init_counter(0) { - validate_and_infer_types(); - } - - Variable(const std::string& name, - const ov::Shape& shape, - const ov::element::Type& type, - const ov::Output& value, - const std::shared_ptr& decoder) - : Variable(name, shape, type, decoder) { - m_value = value; - // reset names of tensor corresponding to variable value - // that is because variable can have multiple values during inference - m_value.set_names({}); - m_is_initialized = true; - ++m_init_counter; - } - - Variable(const Variable& other, const ov::Output& value) : Variable(other) { - m_value = value; - // reset names of tensor corresponding to variable value - // that is because variable can have multiple values during inference - m_value.set_names({}); - m_is_initialized = true; - ++m_init_counter; - } - - void validate_and_infer_types() override { - set_output_type(0, m_type, m_shape); - } - - bool is_initialized() const { - return m_is_initialized; - } - - virtual ov::Output get_value() { - FRONT_END_GENERAL_CHECK( - m_is_initialized, - "[TensorFlow Frontend] internal error: get_value() is called for uninitialized variable"); - return m_value; - } - - std::string get_name() const { - return m_name; - } - - uint64_t get_init_counter() const { - return m_init_counter; - } - - std::shared_ptr get_decoder() const { - return m_decoder; - } - - std::shared_ptr clone_with_new_inputs(const OutputVector& inputs) const override { - auto new_variable = std::make_shared(*this); - new_variable->set_attrs(get_attrs()); - return new_variable; - } - -protected: - std::string m_name; - ov::Shape m_shape; - ov::element::Type m_type; - std::shared_ptr m_decoder; - bool m_is_initialized; - ov::Output m_value; - // this member is used to select the latest state of Variable - uint64_t m_init_counter; -}; +using ov::frontend::Variable; } // namespace tensorflow } // namespace frontend From 4d3e5bf86f9b98986bde0ace8b863f3650920262 Mon Sep 17 00:00:00 2001 From: Karol Blaszczak Date: Tue, 20 Aug 2024 15:48:50 +0200 Subject: [PATCH 053/117] [DOCS] add link to top menu (#26122) --- .../templates/navbar-nav.html | 16 +++++++++------- docs/sphinx_setup/conf.py | 2 +- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/docs/openvino_sphinx_theme/openvino_sphinx_theme/templates/navbar-nav.html b/docs/openvino_sphinx_theme/openvino_sphinx_theme/templates/navbar-nav.html index 8d428571f18b12..47c024f91fc2c0 100644 --- a/docs/openvino_sphinx_theme/openvino_sphinx_theme/templates/navbar-nav.html +++ b/docs/openvino_sphinx_theme/openvino_sphinx_theme/templates/navbar-nav.html @@ -8,9 +8,16 @@ diff --git a/docs/sphinx_setup/conf.py b/docs/sphinx_setup/conf.py index 669e15760ae27b..5b679d10213774 100644 --- a/docs/sphinx_setup/conf.py +++ b/docs/sphinx_setup/conf.py @@ -121,7 +121,7 @@ html_context = { 'current_language': 'English', - 'languages': (('English', '/latest'), ('Chinese', '/cn/latest')), + #'languages': (('English', '/latest'), ('Chinese', '/cn/latest')), 'doxygen_mapping_file': '@DOXYGEN_MAPPING_FILE@', 'doxygen_snippet_root': snippet_root, 'default_mode': 'light' From 7e19d9b6bb59ef528a8fe18f50839da0e6eed404 Mon Sep 17 00:00:00 2001 From: Eddy Kim Date: Tue, 20 Aug 2024 23:22:09 +0900 Subject: [PATCH 054/117] Update clone_with_new_inputs (#26071) ### Details: - In current `clone_with_new_inputs`, `fake_new_inputs` gets shapes from `BaseOp` instead of `new_args`. - If shapes of `BaseOp` and `new_args` are different, we meet error while executing new_node->validate_and_infer_types(). - This situation could occur in `MoveEltwiseUpThroughDataMovPerChannel`. - This PR updates `fake_new_inputs` to get shapes from `new_args` instead of `BaseOp`. ### Tickets: - 147082 --- .../include/ov_ops/type_relaxed.hpp | 3 +- .../move_eltwise_up_data_movement_test.cpp | 30 +++++++++++++++++++ 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/src/common/transformations/include/ov_ops/type_relaxed.hpp b/src/common/transformations/include/ov_ops/type_relaxed.hpp index 77b0ca774c3ba4..ddc0118882e6f9 100644 --- a/src/common/transformations/include/ov_ops/type_relaxed.hpp +++ b/src/common/transformations/include/ov_ops/type_relaxed.hpp @@ -300,8 +300,7 @@ std::shared_ptr TypeRelaxed::clone_with_new_inputs(const OutputVec auto origin_input_type = get_origin_input_type(i); if (origin_input_type == element::undefined) origin_input_type = BaseOp::get_input_element_type(i); - fake_new_inputs.push_back( - std::make_shared(origin_input_type, BaseOp::get_input_partial_shape(i))); + fake_new_inputs.push_back(std::make_shared(origin_input_type, new_args[i].get_partial_shape())); } auto base_op = BaseOp::clone_with_new_inputs(fake_new_inputs); // since originally TypeRelaxed was copying everything from the original node, we continue doing the same diff --git a/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp b/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp index cba3ae82d90fe3..374cd208fefb7d 100644 --- a/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp +++ b/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp @@ -445,3 +445,33 @@ TEST_F(MoveEltwiseUpThroughDataMovTest, PerChannelEltwiseSqueezeIllegal_1) { model = std::make_shared(ov::NodeVector{add}, ov::ParameterVector{input}); manager.register_pass(); } + +TEST_F(MoveEltwiseUpThroughDataMovTest, PerChannelReshapeMultiply) { + const ov::Shape shape{1, 3, 20}; + const std::vector target_shape = {1, 3, 4, 5}; + { + auto input = std::make_shared(ov::element::f32, shape); + + auto reshape_constant = + std::make_shared(ov::element::i64, ov::Shape{target_shape.size()}, target_shape); + auto reshape = std::make_shared(input, reshape_constant, false); + + auto per_channel_const = ov::opset8::Constant::create(ov::element::f32, {1, 3, 1, 1}, {0.5}); + auto multiply = std::make_shared(reshape, per_channel_const); + + model = std::make_shared(ov::NodeVector{multiply}, ov::ParameterVector{input}); + manager.register_pass(); + } + { + auto input = std::make_shared(ov::element::f32, shape); + + auto per_channel_const = ov::opset8::Constant::create(ov::element::f32, {1, 3, 1}, {0.5}); + auto multiply = std::make_shared(input, per_channel_const); + + auto reshape_constant = + std::make_shared(ov::element::i64, ov::Shape{target_shape.size()}, target_shape); + auto reshape = std::make_shared(multiply, reshape_constant, false); + + model_ref = std::make_shared(ov::NodeVector{reshape}, ov::ParameterVector{input}); + } +} From 8ebae42ae14702b448b856b18ea3eb0d5d195fe8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hubert=20B=C5=82aszczyk?= <56601011+hub-bla@users.noreply.github.com> Date: Tue, 20 Aug 2024 17:37:12 +0200 Subject: [PATCH 055/117] [TF FE] Support SparseTensorDenseAdd operation (#26132) ### Details: - Support `SparseTensorDenseAdd` operation ### Tickets: - None --- .../tensorflow/docs/supported_ops.md | 2 +- src/frontends/tensorflow/src/op_table.cpp | 1 + .../include/common_op_table.hpp | 1 + .../tensorflow_common/include/utils.hpp | 4 + .../src/op/sparse_tensor_dense_add.cpp | 32 +++++++ .../src/op/sparse_tensor_dense_mat_mul.cpp | 7 +- src/frontends/tensorflow_common/src/utils.cpp | 10 +++ .../test_tf_SparseTensorDenseAdd.py | 86 +++++++++++++++++++ 8 files changed, 136 insertions(+), 7 deletions(-) create mode 100644 src/frontends/tensorflow_common/src/op/sparse_tensor_dense_add.cpp create mode 100644 tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py diff --git a/src/frontends/tensorflow/docs/supported_ops.md b/src/frontends/tensorflow/docs/supported_ops.md index a851e0f64db932..0eed3eab516c70 100644 --- a/src/frontends/tensorflow/docs/supported_ops.md +++ b/src/frontends/tensorflow/docs/supported_ops.md @@ -1149,7 +1149,7 @@ A "supported operation" is one that TensorFlow Frontend can convert to the OpenV | SparseSparseMaximum | NO | | | SparseSparseMinimum | NO | | | SparseSplit | NO | | -| SparseTensorDenseAdd | NO | | +| SparseTensorDenseAdd | YES | | | SparseTensorDenseMatMul | YES | | | SparseTensorSliceDataset | NO | | | SparseTensorToCSRSparseMatrix | NO | | diff --git a/src/frontends/tensorflow/src/op_table.cpp b/src/frontends/tensorflow/src/op_table.cpp index ad69ff8467994e..76fc33c123915f 100644 --- a/src/frontends/tensorflow/src/op_table.cpp +++ b/src/frontends/tensorflow/src/op_table.cpp @@ -382,6 +382,7 @@ const std::map get_supported_ops() { {"Softmax", CreatorFunction(translate_softmax_op)}, {"SpaceToDepth", CreatorFunction(translate_space_to_depth_op)}, {"SparseReshape", CreatorFunction(translate_sparse_reshape_op)}, + {"SparseTensorDenseAdd", CreatorFunction(translate_sparse_tensor_dense_add_op)}, {"SparseTensorDenseMatMul", CreatorFunction(translate_sparse_tensor_dense_mat_mul_op)}, {"SparseToDense", CreatorFunction(translate_sparse_to_dense_op)}, {"Split", CreatorFunction(translate_split_op)}, diff --git a/src/frontends/tensorflow_common/include/common_op_table.hpp b/src/frontends/tensorflow_common/include/common_op_table.hpp index b85e8b094f2d63..dfc27f1c6ecc68 100644 --- a/src/frontends/tensorflow_common/include/common_op_table.hpp +++ b/src/frontends/tensorflow_common/include/common_op_table.hpp @@ -147,6 +147,7 @@ OP_CONVERTER(translate_rsqrt_op); OP_CONVERTER(translate_scatter_nd_op); OP_CONVERTER(translate_segment_sum_op); OP_CONVERTER(translate_space_to_batch_nd_op); +OP_CONVERTER(translate_sparse_tensor_dense_add_op); OP_CONVERTER(translate_sparse_tensor_dense_mat_mul_op); OP_CONVERTER(translate_sparse_to_dense_op); OP_CONVERTER(translate_select_op); diff --git a/src/frontends/tensorflow_common/include/utils.hpp b/src/frontends/tensorflow_common/include/utils.hpp index b47c9f97cceaaf..e961ea11710a4d 100644 --- a/src/frontends/tensorflow_common/include/utils.hpp +++ b/src/frontends/tensorflow_common/include/utils.hpp @@ -162,6 +162,10 @@ std::shared_ptr hsv_to_rgb(const ov::Output& h, const ov::Output& s, const ov::Output& v); +ov::Output create_dense_tensor(const ov::Output& indices, + const ov::Output& shape, + const ov::Output& values); + } // namespace tensorflow } // namespace frontend } // namespace ov diff --git a/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_add.cpp b/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_add.cpp new file mode 100644 index 00000000000000..4b6137c18b4a60 --- /dev/null +++ b/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_add.cpp @@ -0,0 +1,32 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "common_op_table.hpp" +#include "openvino/op/add.hpp" +#include "utils.hpp" + +using namespace std; +using namespace ov::op; + +namespace ov { +namespace frontend { +namespace tensorflow { +namespace op { +OutputVector translate_sparse_tensor_dense_add_op(const NodeContext& node) { + default_op_checks(node, 4, {"SparseTensorDenseAdd"}); + auto a_indices = node.get_input(0); + auto a_values = node.get_input(1); + auto a_shape = node.get_input(2); + auto b = node.get_input(3); + + auto a = create_dense_tensor(a_indices, a_shape, a_values); + auto res = make_shared(a, b); + set_node_name(node.get_name(), res); + return {res}; +} + +} // namespace op +} // namespace tensorflow +} // namespace frontend +} // namespace ov diff --git a/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp b/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp index e9cb1bf17c11fb..6c057a52c5b563 100644 --- a/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp +++ b/src/frontends/tensorflow_common/src/op/sparse_tensor_dense_mat_mul.cpp @@ -3,9 +3,7 @@ // #include "common_op_table.hpp" -#include "openvino/op/broadcast.hpp" #include "openvino/op/matmul.hpp" -#include "openvino/op/scatter_nd_update.hpp" #include "utils.hpp" using namespace std; @@ -24,10 +22,7 @@ OutputVector translate_sparse_tensor_dense_mat_mul_op(const NodeContext& node) { auto adjoint_a = node.get_attribute("adjoint_a", false); auto adjoint_b = node.get_attribute("adjoint_b", false); - // create dense tensor - auto zero_const = create_same_type_const_scalar(a_values, 0); - ov::Output a = make_shared(zero_const, a_shape); - a = make_shared(a, a_indices, a_values); + auto a = create_dense_tensor(a_indices, a_shape, a_values); auto res = make_shared(a, b, adjoint_a, adjoint_b); set_node_name(node.get_name(), res); return {res}; diff --git a/src/frontends/tensorflow_common/src/utils.cpp b/src/frontends/tensorflow_common/src/utils.cpp index 2b79a2de8bac5a..d2bd6356c9de66 100644 --- a/src/frontends/tensorflow_common/src/utils.cpp +++ b/src/frontends/tensorflow_common/src/utils.cpp @@ -30,6 +30,7 @@ #include "openvino/op/reduce_max.hpp" #include "openvino/op/reduce_min.hpp" #include "openvino/op/reshape.hpp" +#include "openvino/op/scatter_nd_update.hpp" #include "openvino/op/select.hpp" #include "openvino/op/shape_of.hpp" #include "openvino/op/slice.hpp" @@ -562,6 +563,15 @@ shared_ptr hsv_to_rgb(const ov::Output& h, return rgb_adjust; } +ov::Output create_dense_tensor(const ov::Output& indices, + const ov::Output& shape, + const ov::Output& values) { + auto zero_const = create_same_type_const_scalar(values, 0); + ov::Output dense_tensor = std::make_shared(zero_const, shape); + dense_tensor = std::make_shared(dense_tensor, indices, values); + return dense_tensor; +} + } // namespace tensorflow } // namespace frontend } // namespace ov diff --git a/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py new file mode 100644 index 00000000000000..704f7bd81729d8 --- /dev/null +++ b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py @@ -0,0 +1,86 @@ +# Copyright (C) 2018-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import platform +import pytest +import tensorflow as tf +from common.tf_layer_test_class import CommonTFLayerTest + +rng = np.random.default_rng(475912) + + +class TestSparseTensorDenseAdd(CommonTFLayerTest): + def _prepare_input(self, inputs_info): + assert 'a_indices:0' in inputs_info + assert 'a_values:0' in inputs_info + assert 'b:0' in inputs_info + + a_values_shape = inputs_info['a_values:0'] + b_shape = inputs_info['b:0'] + + inputs_data = {} + if np.issubdtype(self.data_type, np.floating): + inputs_data['a_values:0'] = rng.uniform(-5.0, 5.0, a_values_shape).astype(self.data_type) + inputs_data['b:0'] = rng.uniform(-5.0, 5.0, b_shape).astype(self.data_type) + elif np.issubdtype(self.data_type, np.signedinteger): + inputs_data['a_values:0'] = rng.integers(-8, 8, a_values_shape).astype(self.data_type) + inputs_data['b:0'] = rng.integers(-8, 8, b_shape).astype(self.data_type) + else: + inputs_data['a_values:0'] = rng.integers(0, 8, a_values_shape).astype(self.data_type) + inputs_data['b:0'] = rng.integers(0, 8, b_shape).astype(self.data_type) + + a_rows_num = self.a_shape[0] + a_cols_num = self.a_shape[1] + + # generate all possible indices + all_indices = [] + for row_ind in range(0, a_rows_num): + for col_ind in range(0, a_cols_num): + all_indices.append([row_ind, col_ind]) + inputs_data['a_indices:0'] = rng.choice(all_indices, self.nnz, replace=False).astype(self.indices_type) + + return inputs_data + + def create_sparse_tensor_dense_add_net(self, data_type, indices_type, + a_shape, b_shape, nnz): + self.data_type = data_type + self.indices_type = indices_type + self.a_shape = a_shape + self.nnz = nnz + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + a_indices = tf.compat.v1.placeholder(indices_type, [nnz, 2], 'a_indices') + a_values = tf.compat.v1.placeholder(data_type, [nnz], 'a_values') + a_shape = tf.constant(a_shape, dtype=indices_type) + b = tf.compat.v1.placeholder(data_type, b_shape, 'b') + tf.raw_ops.SparseTensorDenseAdd( + a_indices=a_indices, + a_values=a_values, + a_shape=a_shape, + b=b) + tf.compat.v1.global_variables_initializer() + tf_net = sess.graph_def + + ref_net = None + + return tf_net, ref_net + + @pytest.mark.parametrize('data_type', [np.float32, np.float64, np.int32]) + @pytest.mark.parametrize('indices_type', [np.int32, np.int64]) + @pytest.mark.parametrize('a_shape, b_shape, nnz', [ + [[4, 10], [4, 10], 8], + [[5, 5], [5, 5], 3], + ]) + @pytest.mark.precommit + @pytest.mark.nightly + def test_sparse_tensor_dense_add(self, data_type, indices_type, + a_shape, b_shape, nnz, + ie_device, precision, ir_version, temp_dir, + use_legacy_frontend): + if ie_device == 'GPU': + pytest.skip("149830: ScatterNDUpdate-15 is not supported on GPU") + self._test(*self.create_sparse_tensor_dense_add_net(data_type, indices_type, + a_shape, b_shape, nnz), + ie_device, precision, ir_version, temp_dir=temp_dir, + use_legacy_frontend=use_legacy_frontend) From fe624f1134f62f0c3e409b228402db2871072a4c Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Wed, 21 Aug 2024 01:10:23 +0400 Subject: [PATCH 056/117] Revert "Don't allow to load library linking to another folder" (#26141) Reverts openvinotoolkit/openvino#25958 --- src/common/util/CMakeLists.txt | 4 ---- .../util/include/openvino/util/file_util.hpp | 21 ------------------- src/common/util/src/file_util.cpp | 11 ---------- .../dev_api/openvino/core/so_extension.hpp | 3 --- src/frontends/common/src/manager.cpp | 2 -- src/inference/src/dev/core_impl.cpp | 3 +-- .../tests/functional/ov_core_test.cpp | 18 ---------------- 7 files changed, 1 insertion(+), 61 deletions(-) diff --git a/src/common/util/CMakeLists.txt b/src/common/util/CMakeLists.txt index efdae4b26837d8..6b5cf4b7a64192 100644 --- a/src/common/util/CMakeLists.txt +++ b/src/common/util/CMakeLists.txt @@ -41,10 +41,6 @@ target_link_libraries(${TARGET_NAME} PRIVATE ${CMAKE_DL_LIBS} PUBLIC openvino::p if (WIN32) target_link_libraries(${TARGET_NAME} PRIVATE Shlwapi) endif() - -if(LINUX) - target_link_libraries(${TARGET_NAME} PRIVATE stdc++fs) -endif() target_include_directories(${TARGET_NAME} PUBLIC $) ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME}) diff --git a/src/common/util/include/openvino/util/file_util.hpp b/src/common/util/include/openvino/util/file_util.hpp index 7b28bda704a98b..88b9110abeced8 100644 --- a/src/common/util/include/openvino/util/file_util.hpp +++ b/src/common/util/include/openvino/util/file_util.hpp @@ -12,20 +12,6 @@ #include "openvino/util/util.hpp" -#if !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) -# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L) && (_MSC_VER >= 1913)) -# if __has_include() -# include -namespace fs = std::filesystem; -# endif -# else -# define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING -# define _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM -# include -namespace fs = std::experimental::filesystem; -# endif -#endif - namespace ov { namespace util { @@ -411,12 +397,5 @@ inline std::basic_string make_path(const std::basic_string& folder, const return folder + ov::util::FileTraits::file_separator + file; } -/** - * @brief If the library path is symlink & the symlink file location is not in the real file folder, return true. Others - * return false. - * @param path - Library file path to check - * @return Bool value - */ -bool is_symlink_in_different_path(std::string library_path); } // namespace util } // namespace ov diff --git a/src/common/util/src/file_util.cpp b/src/common/util/src/file_util.cpp index 8fa9e5e06b1b97..2846355e9aeb5f 100644 --- a/src/common/util/src/file_util.cpp +++ b/src/common/util/src/file_util.cpp @@ -704,14 +704,3 @@ const char* ov::util::trim_file_name(const char* const fname) { #endif return fname_trim_ptr; } - -bool ov::util::is_symlink_in_different_path(std::string library_path) { -#if !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) - if (fs::is_symlink(library_path) && ov::util::get_absolute_file_path(ov::util::get_directory(library_path)) != - ov::util::get_directory(ov::util::get_absolute_file_path(library_path))) - return true; - return false; -#else - return false; -#endif -} diff --git a/src/core/dev_api/openvino/core/so_extension.hpp b/src/core/dev_api/openvino/core/so_extension.hpp index 5db9879dc1cb88..931344b5fc4958 100644 --- a/src/core/dev_api/openvino/core/so_extension.hpp +++ b/src/core/dev_api/openvino/core/so_extension.hpp @@ -3,7 +3,6 @@ // #pragma once -#include "openvino/core/except.hpp" #include "openvino/core/extension.hpp" #include "openvino/core/visibility.hpp" #include "openvino/util/file_util.hpp" @@ -41,8 +40,6 @@ inline std::string resolve_extension_path(const std::string& path) { } inline std::vector load_extensions(const std::string& path) { - OPENVINO_ASSERT(!ov::util::is_symlink_in_different_path(path), - "Cannot load extension with symlink path: \"" + path + "\"."); const std::string resolved_path = resolve_extension_path(path); auto so = ov::util::load_shared_object(resolved_path.c_str()); using CreateFunction = void(std::vector&); diff --git a/src/frontends/common/src/manager.cpp b/src/frontends/common/src/manager.cpp index 30bfc0a46c2e86..0a31f9a2c426e9 100644 --- a/src/frontends/common/src/manager.cpp +++ b/src/frontends/common/src/manager.cpp @@ -106,8 +106,6 @@ class FrontEndManager::Impl { } void register_front_end(const std::string& name, const std::string& library_path) { - OPENVINO_ASSERT(!ov::util::is_symlink_in_different_path(library_path), - "Cannot register plugin with symlink path: \"" + library_path + "\"."); auto lib_path = ov::util::from_file_path(ov::util::get_plugin_path(library_path)); PluginInfo plugin; plugin.m_file_path = lib_path; diff --git a/src/inference/src/dev/core_impl.cpp b/src/inference/src/dev/core_impl.cpp index f8fcf26b006014..237c246ab38bdc 100644 --- a/src/inference/src/dev/core_impl.cpp +++ b/src/inference/src/dev/core_impl.cpp @@ -1189,8 +1189,7 @@ void ov::CoreImpl::register_plugin(const std::string& plugin, if (device_name.find('.') != std::string::npos) { OPENVINO_THROW("Device name must not contain dot '.' symbol"); } - OPENVINO_ASSERT(!ov::util::is_symlink_in_different_path(plugin), - "Cannot registe plugin with symlink path: \"" + plugin + "\"."); + PluginDescriptor desc{ov::util::get_plugin_path(plugin), properties}; register_plugin_in_registry_unsafe(device_name, desc); } diff --git a/src/inference/tests/functional/ov_core_test.cpp b/src/inference/tests/functional/ov_core_test.cpp index acba5cc49123d3..26eb38e3fd13e5 100644 --- a/src/inference/tests/functional/ov_core_test.cpp +++ b/src/inference/tests/functional/ov_core_test.cpp @@ -95,22 +95,4 @@ TEST(CoreBaseTest, LoadOVFolderOverCWPathPluginXML) { remove_plugin_xml(ov_file_path); } -# if !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) -TEST(CoreBaseTest, AddExtensionwithSymlinkInDiffPlace) { - std::string openvino_template_extension = - ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), - std::string("openvino_template_extension") + OV_BUILD_POSTFIX); - - // Symlink file & the real file doesn't locale in the diff place. Will throw - fs::create_directory("test_link"); - std::string symlink_for_extension_copy_file = "test_link/symlink_for_extension_copy_file"; - - fs::create_symlink(openvino_template_extension, symlink_for_extension_copy_file); - ov::Core core; - EXPECT_NO_THROW(core.add_extension(openvino_template_extension)); - EXPECT_THROW(core.add_extension(symlink_for_extension_copy_file), std::runtime_error); - - ASSERT_TRUE(fs::remove_all("test_link")); -} -# endif #endif From 295917037bf9852d65f903a1e6b0b2a92e253f52 Mon Sep 17 00:00:00 2001 From: Eddy Kim Date: Wed, 21 Aug 2024 10:28:55 +0900 Subject: [PATCH 057/117] [GPU] updated OneDNN convolution impl to handle a_zp properly for dynamic models (#26106) ### Details: - OneDNN convolution requires activations zero points (a.k.a a_zp) of i32 data type. - Because its original data type is i8 or u8, onednn impl converts it to i32 data type when creating onednn conv impl, and updates program_node\ for a_zp. Then primitive_inst\ for a_zp is created from the program_node\ for a_zp. - But, in the case of dynamic model, onednn conv impl is created in runtime, and primitive_inst\ for a_zp does not have the converted a_zp data. - So, this PR updated convolution onednn impl to check if the activatations zero points were properly converted before setting arguments. ### Tickets: - 147082 --- .../graph/graph_optimizer/compile_graph.cpp | 7 ++ .../graph/impls/onednn/convolution_onednn.cpp | 9 ++ .../unit/test_cases/convolution_gpu_test.cpp | 105 ++++++++++++++++++ 3 files changed, 121 insertions(+) diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/compile_graph.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/compile_graph.cpp index fb9fbb4ab961a4..ed9f6b05817438 100644 --- a/src/plugins/intel_gpu/src/graph/graph_optimizer/compile_graph.cpp +++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/compile_graph.cpp @@ -77,6 +77,13 @@ void compile_graph::run(program& p) { if (w_layout.spatial(0) != 1 || w_layout.spatial(1) != 1) { change_initial_impl = false; } + + // OneDNN convolution requires activations zero points (a_zp) of int32 type, and the data is converted while executing choose_impl. + // If this task is done in the async compilation queue, it could result in wrong calculation of cldnn shape-agnostic kernels. + // [TODO] Is it possible to update memory of primitive_inst for a_zp in the choose_impl of onednn conv? + if (node->as().activations_zero_points_term()) { + change_initial_impl = false; + } } } diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp index a52314b3fd7ca3..4892968cda98a3 100644 --- a/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp +++ b/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp @@ -51,6 +51,15 @@ struct convolution_onednn : typed_primitive_onednn_impl { if (instance.activations_zero_points_term()) { auto a_zp = instance.activations_zero_points_memory(); + + // In the case of dynamic model, if choose_impl was executed in runtime, + // a_zp could be remained as u8 or i8. + if (a_zp->get_layout().data_type != data_types::i32) { + auto& conv_node = instance.get_node().as(); + auto& a_zp_node = conv_node.activations_zero_points().as(); + a_zp = a_zp_node.get_attached_memory_ptr(); + } + dnnl::memory::desc desc = onednn::layout_to_memory_desc(a_zp->get_layout(), dnnl::memory::format_tag::a, true); args.insert({DNNL_ARG_ATTR_ZERO_POINTS | DNNL_ARG_SRC, a_zp->get_onednn_memory(desc)}); diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp index 132b2378420a03..5e7aa5735abed7 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp @@ -4600,6 +4600,111 @@ TEST(convolution_int8_fw_gpu, quantized_convolution_u8s8f32_asymmetric_activatio } } +TEST(convolution_int8_fw_gpu, quantized_convolution_u8s8f32_asymmetric_activations_per_channel_dynamic) { + auto& engine = get_test_engine(); + + auto input = engine.allocate_memory({ data_types::u8, format::bfyx, {1, 2, 5, 4} }); + auto weights = engine.allocate_memory({ data_types::i8, format::bfyx, { 3, 2, 3, 3 } }); + auto biases = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 3, 1, 1 } }); + auto a_zp = engine.allocate_memory({ data_types::u8, format::bfyx, { 1, 3, 1, 1 } }); + + set_values(input, { 1, 2, 3, 4, 5, + 2, 2, 3, 4, 6, + 3, 3, 3, 5, 1, + 1, 1, 1, 1, 1, + + 1, 2, 3, 4, 5, + 2, 2, 3, 4, 6, + 3, 3, 3, 5, 1, + 1, 1, 1, 1, 1 }); + + set_values(weights, { 1, 2, -1, + -2, 1, 2, + 9, 7, -1, + + 9, 0, -4, + -1, 3, 2, + 0, 2, 5, + + 1, 2, -1, + -2, 1, 2, + 9, 7, -1, + + 9, 0, -4, + -1, 3, 2, + 0, 2, 5, + + 1, 2, -1, + -2, 1, 2, + 9, 7, -1, + + 9, 0, -4, + -1, 3, 2, + 0, 2, 5 }); + set_values(a_zp, { 2, 5, 5 }); + set_values(biases, { 1.0f, -8.0f, -8.0f }); + + VVVF output_vec = { + { + { -36.0f, 5.0f, -14.0f }, + { -24.0f, -10.0f, -30.0f } + }, + { + { -45.0f, -4.0f, -23.0f }, + { -33.0f, -19.0f, -39.0f } + }, + { + { -45.0f, -4.0f, -23.0f }, + { -33.0f, -19.0f, -39.0f } + } }; + + auto in_dyn_layout = layout{ov::PartialShape::dynamic(input->get_layout().get_shape().size()), data_types::u8, format::bfyx}; + + topology topology( + input_layout("input", in_dyn_layout), + data("weights", weights), + data("biases", biases), + data("a_zp", a_zp), + reorder("input_fsv", input_info("input"), { data_types::u8, format::b_fs_yx_fsv16, input->get_layout().get_tensor() }), + convolution("conv", input_info("input_fsv"), "weights", "biases", "", { "a_zp" }, "", 1, + { 2, 2 }, { 1, 1 }, { 0, 0 }, { 1, 2 }, false, data_types::f32), + reorder("out", input_info("conv"), format::bfyx, data_types::f32)); + + ExecutionConfig config = get_test_default_config(engine); + config.set_property(ov::intel_gpu::allow_new_shape_infer(true)); + ov::intel_gpu::ImplementationDesc conv_impl; + if (engine.get_device_info().supports_immad) { + conv_impl = { format::b_fs_yx_fsv16, "", impl_types::onednn }; + config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ { "conv", conv_impl } })); + } + network network(engine, topology, config); + network.set_input_data("input", input); + + auto outputs = network.execute(); + ASSERT_EQ(outputs.begin()->first, "out"); + + auto output_memory = outputs.at("out").get_memory(); + cldnn::mem_lock output_ptr(output_memory, get_test_stream()); + + auto output_layout = output_memory->get_layout(); + int y_size = output_layout.spatial(1); + int x_size = output_layout.spatial(0); + int f_size = output_layout.feature(); + int b_size = output_layout.batch(); + ASSERT_EQ(output_layout.format, format::bfyx); + ASSERT_EQ(y_size, 2); + ASSERT_EQ(x_size, 3); + ASSERT_EQ(f_size, 3); + ASSERT_EQ(b_size, 1); + for (int f = 0; f < f_size; f++) + for (int y = 0; y < y_size; ++y) { + for (int x = 0; x < x_size; ++x) { + ASSERT_NEAR(output_vec[f][y][x], ((float)output_ptr[f * y_size * x_size + y * x_size + x]), 1e-5f) << + " x="<< x << " y=" << y << " f=" << f; + } + } +} + TEST(convolution_int8_fw_gpu, quantized_convolution_u8s8f32_asymmetric_activations_per_channel_3ic_with_sub) { auto& engine = get_test_engine(); From b37ed4417d911cb53b062a7908c0136f04e335bc Mon Sep 17 00:00:00 2001 From: Mingyu Kim Date: Wed, 21 Aug 2024 12:10:15 +0900 Subject: [PATCH 058/117] [GPU] dump failure when input/output is nullptr (#26081) --- src/plugins/intel_gpu/src/graph/network.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/plugins/intel_gpu/src/graph/network.cpp b/src/plugins/intel_gpu/src/graph/network.cpp index 7817e929d0d065..597ee61841ded8 100644 --- a/src/plugins/intel_gpu/src/graph/network.cpp +++ b/src/plugins/intel_gpu/src/graph/network.cpp @@ -1097,6 +1097,11 @@ void network::execute_impl(const std::vector& events) { "_" + get_iteration_prefix(curr_iter) + layer_name + "_src" + std::to_string(i); auto input_mem = get_primitive(inst->id())->dep_memory_ptr(i); + if (input_mem == nullptr) { + GPU_DEBUG_COUT << " input_mem_" << i << " is nullptr. Nothing to dump." << std::endl; + continue; + } + auto dep = inst->dependencies().at(i); auto input_layout = dep.first->get_output_layout(dep.second); GPU_DEBUG_IF(debug_config->dump_layers_binary) { @@ -1144,6 +1149,11 @@ void network::execute_impl(const std::vector& events) { "_" + get_iteration_prefix(curr_iter) + layer_name + "_dst" + std::to_string(i); auto output_mem = get_primitive(layer_name)->output_memory_ptr(i); + if (output_mem == nullptr) { + GPU_DEBUG_COUT << " output_mem is nullptr. Nothing to dump." << std::endl; + continue; + } + GPU_DEBUG_IF(debug_config->dump_layers_binary) { // Binary dump : raw auto output_layout = inst->get_output_layout(i); From 52f6fe7d2b31b25f462d0b11dd50639a0a3403a5 Mon Sep 17 00:00:00 2001 From: Sun Xiaoxia Date: Wed, 21 Aug 2024 12:04:09 +0800 Subject: [PATCH 059/117] Fix creating too many useless threads in cpu executor (#25704) ### Details: - *When compilide_mode() is based on async mode, main thread do not create additional stream for get_graph() and reuse information from streams(0)* ### Tickets: - *CVS-137803* Co-authored-by: Wanglei Shen --- .../dev/threading/cpu_streams_executor.cpp | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/inference/src/dev/threading/cpu_streams_executor.cpp b/src/inference/src/dev/threading/cpu_streams_executor.cpp index 9e55cd2be18592..4fca252e13ea9a 100644 --- a/src/inference/src/dev/threading/cpu_streams_executor.cpp +++ b/src/inference/src/dev/threading/cpu_streams_executor.cpp @@ -313,6 +313,21 @@ struct CPUStreamsExecutor::Impl { } } + bool find_thread_id() { + auto id = std::this_thread::get_id(); + auto search = _thread_ids.find(id); + if (search != _thread_ids.end()) { + return true; + } + std::lock_guard guard(_stream_map_mutex); + for (auto& item : _stream_map) { + if (item.first->get_id() == id) { + return true; + } + } + return false; + } + private: std::set _thread_ids; Impl* _impl; @@ -445,6 +460,9 @@ struct CPUStreamsExecutor::Impl { }; int CPUStreamsExecutor::get_stream_id() { + if (!_impl->_streams.find_thread_id()) { + return 0; + } auto stream = _impl->_streams.local(); return stream->_streamId; } @@ -454,11 +472,17 @@ int CPUStreamsExecutor::get_streams_num() { } int CPUStreamsExecutor::get_numa_node_id() { + if (!_impl->_streams.find_thread_id()) { + return 0; + } auto stream = _impl->_streams.local(); return stream->_numaNodeId; } int CPUStreamsExecutor::get_socket_id() { + if (!_impl->_streams.find_thread_id()) { + return 0; + } auto stream = _impl->_streams.local(); return stream->_socketId; } From 0b8eb87e0efa9030be47d661fe94b3c8beb655fd Mon Sep 17 00:00:00 2001 From: Mingyu Kim Date: Wed, 21 Aug 2024 14:49:37 +0900 Subject: [PATCH 060/117] [GPU] update onednn to latest 3.6-pc (#26143) --- src/plugins/intel_gpu/thirdparty/onednn_gpu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/intel_gpu/thirdparty/onednn_gpu b/src/plugins/intel_gpu/thirdparty/onednn_gpu index 915b0d4c3954fe..5a17f33b0c1251 160000 --- a/src/plugins/intel_gpu/thirdparty/onednn_gpu +++ b/src/plugins/intel_gpu/thirdparty/onednn_gpu @@ -1 +1 @@ -Subproject commit 915b0d4c3954fe78f5e9b4dc28221b858f8450bd +Subproject commit 5a17f33b0c1251b8794c7724dee0828f9ac989a0 From e3ed7dfdf2caf8377f79ef31c11f78538e9f77be Mon Sep 17 00:00:00 2001 From: "Min, Byungil" Date: Wed, 21 Aug 2024 16:54:50 +0900 Subject: [PATCH 061/117] [GPU] Bugfix dynamic quantized fully_connected_bf_tiled kernel (#26102) ### Details: - bugfix fully_connected_bf_tiled kernel to resolve a customer issue ### Tickets: - CVS-149215 --------- Signed-off-by: Min, Byung-il --- .../fully_connected_gpu_bf_tiled.cl | 15 +-- .../include/batch_headers/int4_utils.cl | 41 +++--- .../test_cases/dynamic_quantize_gpu_test.cpp | 2 +- .../test_cases/fully_connected_gpu_test.cpp | 117 +++++++++++++++++- 4 files changed, 145 insertions(+), 30 deletions(-) diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl index 3dae1669ccc23f..0366f602d69982 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl @@ -80,13 +80,14 @@ KERNEL(quantize_input)( # endif #endif #if TILE_K == 4 && COMPRESSED_WEIGHTS_INT4 && FILTER_LAYOUT_OS_IS_YX_OSV32_ISV2 -// Data stored in memory : f0k0k1|f16k0k1|f0k2k3|f16k2k3 -// => unpack as f0k0k1|f0k2k3|f16k0k1|f16k2k3 so that the weight access order is preserved -#define UNPACK_INT4 UNPACK_INT4x2_OSV32_ISV2 -#define UNPACK_TRANSPOSED_INT4 UNPACK_INT4x2_OSV32_ISV2 + // Data stored in memory : f0k0k1|f16k0k1|f0k2k3|f16k2k3 + // => unpack as f0k0k1|f0k2k3|f16k0k1|f16k2k3 so that the weight access order is preserved + #define UNPACK_INT4 UNPACK_INT4x2_OSV32_ISV2 + // No need to apply transpose for dynamic quantizing. Weight values are located in order of tile_k : f0(k0,k1),f1(k2,k3) + #define UNPACK_TRANSPOSED_INT4 UNPACK_INT4x2_OSV32_ISV2 #else -#define UNPACK_INT4 UNPACK_INT4x2 -#define UNPACK_TRANSPOSED_INT4 UNPACK_TRANSPOSED_INT4x2 + #define UNPACK_INT4 UNPACK_INT4x2 + #define UNPACK_TRANSPOSED_INT4 UNPACK_TRANSPOSED_INT4x2 #endif // Macros for vectorized types. #define INPUT_VEC_TYPE MAKE_VECTOR_TYPE(INPUT0_TYPE, TILE_IFM) @@ -853,7 +854,7 @@ inline void FUNC(fc_bf_tiled_kernel_dyn_quan)( // DECOMPRESSION_SCALE_POST_OP SHOULD be enabled for dynamic quantize FC : scale is ACCUMULATOR_VAL_ONE unroll_for(uint load_iter = 0; load_iter < FILTER_LOAD_ITERS; ++load_iter) { SLM_FILTER_PACKED_VEC wei_packed = BLOCK_READN(FILTER_TYPE, FILTER_LOAD_BLOCK_SIZE, weights, weights_idx); - DQ_SLM_FILTER_UNPACKED_VEC dq_wei_unpacked = UNPACK_TRANSPOSED_INT4(DQ_TYPE, *((uint4x8_t *)&wei_packed)); + DQ_SLM_FILTER_UNPACKED_VEC dq_wei_unpacked = UNPACK_TRANSPOSED_INT4(DQ_TYPE, *((INT4_PACKED_TYPE_PRELOAD *)&wei_packed)); // Calculate zero-point and scale only for DECOMPRESSION_SCALE_POST_OP enabled #if DECOMPRESSION_ZP_TERM diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl index 0bdb3b3498ab71..fb257169a8b78c 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl @@ -46,17 +46,21 @@ inline uchar8 unpack_to_uchar(uint4x8_t v) __attribute__((overloadable)) { return (uchar8)(v0.s0, v0.s1, v1.s0, v1.s1, v2.s0, v2.s1, v3.s0, v3.s1); } +inline char2 unpack_to_char(int4x2_t v) __attribute__((overloadable)) { + return cvt_int4x2_to_int8x2(v); +} + inline char2 unpack_to_char(uint4x2_t v) __attribute__((overloadable)) { - return cvt_uint4x2_to_int8x2(v); + return convert_char2(cvt_uint4x2_to_uint8x2(v)); } -inline char4 unpack_to_char(uint4x4_t v) __attribute__((overloadable)) { +inline char4 unpack_to_char(int4x4_t v) __attribute__((overloadable)) { char2 v0 = unpack_to_char(v.s0); char2 v1 = unpack_to_char(v.s1); return (char4)(v0.s0, v0.s1, v1.s0, v1.s1); } -inline char8 unpack_to_char(uint4x8_t v) __attribute__((overloadable)) { +inline char8 unpack_to_char(int4x8_t v) __attribute__((overloadable)) { char2 v0 = unpack_to_char(v.s0); char2 v1 = unpack_to_char(v.s1); char2 v2 = unpack_to_char(v.s2); @@ -64,7 +68,7 @@ inline char8 unpack_to_char(uint4x8_t v) __attribute__((overloadable)) { return (char8)(v0.s0, v0.s1, v1.s0, v1.s1, v2.s0, v2.s1, v3.s0, v3.s1); } -inline char8 unpack_transposed_to_char(uint4x8_t v) __attribute__((overloadable)) { +inline char8 unpack_transposed_to_char(int4x8_t v) __attribute__((overloadable)) { char2 v0 = unpack_to_char(v.s0); char2 v1 = unpack_to_char(v.s1); char2 v2 = unpack_to_char(v.s2); @@ -72,26 +76,18 @@ inline char8 unpack_transposed_to_char(uint4x8_t v) __attribute__((overloadable) return (char8)(v0.s0, v1.s0, v2.s0, v3.s0, v0.s1, v1.s1, v2.s1, v3.s1); } -inline uchar8 unpack_transposed_to_uchar(uint4x8_t v) __attribute__((overloadable)) { - uchar2 v0 = unpack_to_uchar(v.s0); - uchar2 v1 = unpack_to_uchar(v.s1); - uchar2 v2 = unpack_to_uchar(v.s2); - uchar2 v3 = unpack_to_uchar(v.s3); - return (uchar8)(v0.s0, v1.s0, v2.s0, v3.s0, v0.s1, v1.s1, v2.s1, v3.s1); -} - -inline char8 unpack_transposed_to_char_osv32_isv2(uint4x8_t v) __attribute__((overloadable)) { +inline char8 unpack_transposed_to_char(uint4x8_t v) __attribute__((overloadable)) { char2 v0 = unpack_to_char(v.s0); - char2 v1 = unpack_to_char(v.s2); - char2 v2 = unpack_to_char(v.s1); + char2 v1 = unpack_to_char(v.s1); + char2 v2 = unpack_to_char(v.s2); char2 v3 = unpack_to_char(v.s3); return (char8)(v0.s0, v1.s0, v2.s0, v3.s0, v0.s1, v1.s1, v2.s1, v3.s1); } -inline uchar8 unpack_transposed_to_uchar_osv32_isv2(uint4x8_t v) __attribute__((overloadable)) { +inline uchar8 unpack_transposed_to_uchar(uint4x8_t v) __attribute__((overloadable)) { uchar2 v0 = unpack_to_uchar(v.s0); - uchar2 v1 = unpack_to_uchar(v.s2); - uchar2 v2 = unpack_to_uchar(v.s1); + uchar2 v1 = unpack_to_uchar(v.s1); + uchar2 v2 = unpack_to_uchar(v.s2); uchar2 v3 = unpack_to_uchar(v.s3); return (uchar8)(v0.s0, v1.s0, v2.s0, v3.s0, v0.s1, v1.s1, v2.s1, v3.s1); } @@ -185,6 +181,14 @@ inline half8 unpack_to_half_osv32_isv2(int4x8_t v) __attribute__((overloadable)) return (half8)(f0.s0, f0.s1, f1.s0, f1.s1, f2.s0, f2.s1, f3.s0, f3.s1); } +inline char8 unpack_to_char_osv32_isv2(int4x8_t v) __attribute__((overloadable)) { + char2 v0 = unpack_to_char(v.s0); + char2 v1 = unpack_to_char(v.s2); + char2 v2 = unpack_to_char(v.s1); + char2 v3 = unpack_to_char(v.s3); + return (char8)(v0.s0, v0.s1, v1.s0, v1.s1, v2.s0, v2.s1, v3.s0, v3.s1); +} + inline char8 unpack_to_char_osv32_isv2(uint4x8_t v) __attribute__((overloadable)) { char2 v0 = unpack_to_char(v.s0); char2 v1 = unpack_to_char(v.s2); @@ -208,4 +212,3 @@ inline uchar8 unpack_to_uchar_osv32_isv2(uint4x8_t v) __attribute__((overloadabl #define UNPACK_INT4x2(target_type, value) CAT(unpack_to_, target_type)(value) #define UNPACK_INT4x2_OSV32_ISV2(target_type, value) CAT(CAT(unpack_to_, target_type), _osv32_isv2)(value) #define UNPACK_TRANSPOSED_INT4x2(target_type, value) CAT(unpack_transposed_to_, target_type)(value) -#define UNPACK_TRANSPOSED_INT4x2_OSV32_ISV2(target_type, value) CAT(CAT(unpack_transposed_to_, target_type), _osv32_isv2)(value) diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/dynamic_quantize_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/dynamic_quantize_gpu_test.cpp index 3e6163bb10db14..c1686e359e91a0 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/dynamic_quantize_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/dynamic_quantize_gpu_test.cpp @@ -109,7 +109,7 @@ class dynamic_quantization_gpu_tests: public ::testing::Test { auto abs_diff = std::abs(output_ptr_ref[i] - output_ptr[i]); if (max_diff < abs_diff) max_diff = abs_diff; - avg = abs_diff; + avg += abs_diff; count++; OPENVINO_ASSERT(abs_diff < 1); } diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp index 3e4c1635229c86..fa3e375cbecfc5 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp @@ -1360,17 +1360,16 @@ class fully_connected_gpu_tests: public ::testing::Test { float max_diff = 0.f; float avg = 0.f; for (size_t i = 0; i < output_ptr_ref.size(); ++i) { - auto abs_diff = std::abs(output_ptr_ref[i] - output_ptr[i]); + auto abs_diff = std::abs((float)output_ptr_ref[i] - (float)output_ptr[i]); if (max_diff < abs_diff) max_diff = abs_diff; - avg = abs_diff; + avg += abs_diff; count++; OPENVINO_ASSERT(abs_diff < 256); } GPU_DEBUG_LOG << "---> count: " << count << ", max_diff:" << max_diff << ", avg_diff: " << (avg/count) << std::endl; } - void test_compressed_int4_scale(bool is_caching_test, bool is_dynamic, long int batch_num, long int scales_group_size = 128, bool is_wei_dyn = false) { tests::random_generator rg(GET_SUITE_NAME); auto& engine = get_test_engine(); @@ -2500,6 +2499,115 @@ class fully_connected_gpu_tests: public ::testing::Test { ASSERT_EQ(-2.25f, output_ptr[2]); ASSERT_EQ(3.0f, output_ptr[3]); } + + void test_compressed_int4_scale_dyn_quan_weight_i4(bool is_dynamic, int batch = 1, int ifm = 512, int ofm = 2048) { + tests::random_generator rg(GET_SUITE_NAME); + auto& engine = get_test_engine(); + + if (engine.get_device_info().dev_type == device_type::discrete_gpu) + GTEST_SKIP(); + + long int batch_num = batch; + long int ifm_num = ifm; + long int ofm_num = ofm; + int scales_group_size = 128; + + auto input_ps = ov::PartialShape{ batch_num, 1, ifm_num }; + auto input_mem = engine.allocate_memory({ input_ps, data_types::f16, format::bfyx }); + + auto weights_mem = engine.allocate_memory({ {ofm_num, ifm_num}, data_types::i4, format::bfyx }); + auto scale_mem = engine.allocate_memory({ {ofm_num, ifm_num / scales_group_size}, data_types::f16, format::fbyx }); + + auto input_data = rg.generate_random_1d(batch_num * ifm_num, -2.f, 2.f); + set_values(input_mem, input_data); + + auto weigths_data = rg.generate_random_1d(ofm_num * ifm_num / 2, 0, 4); + set_values(weights_mem, weigths_data); + + auto scale_data = rg.generate_random_1d(ofm_num * ifm_num / scales_group_size, -4.f, 4.f); + set_values(scale_mem, scale_data); + + auto in_layout = is_dynamic ? layout{ ov::PartialShape{ -1, -1, -1 }, data_types::f16, format::bfyx } + : layout{ input_ps, data_types::f16, format::bfyx }; + + auto fc_prim = fully_connected("fc_prim", input_info("input"), "weights", "", "scale", "", data_types::f16, 3, 2); + fc_prim.decompression_zero_point_scalar = 0; + + // Implemented dynamic quantize kernel + auto get_ref_results = [&]() { + topology topology( + input_layout("input", in_layout), + data("weights", weights_mem), + data("scale", scale_mem), + fc_prim + ); + + auto config = get_test_default_config(engine); + config.set_property(ov::intel_gpu::allow_new_shape_infer(true)); + ov::intel_gpu::ImplementationDesc fc_impl_desc = { format::bfyx, "fully_connected_gpu_bf_tiled", impl_types::ocl }; + config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ {"fc_prim", fc_impl_desc} })); + config.set_property(ov::hint::dynamic_quantization_group_size(0)); + + network network(engine, topology, config); + network.set_input_data("input", input_mem); + + auto outputs = network.execute(); + OPENVINO_ASSERT(outputs.size() == 1); + OPENVINO_ASSERT(outputs.begin()->first == "fc_prim"); + + auto output_layout = outputs.begin()->second.get_layout(); + auto output_mem = outputs.begin()->second.get_memory(); + + return engine.reinterpret_buffer(*output_mem, output_layout); + }; + + topology topology( + input_layout("input", in_layout), + data("weights", weights_mem), + data("scale", scale_mem), + fc_prim + ); + + auto config = get_test_default_config(engine); + config.set_property(ov::intel_gpu::allow_new_shape_infer(true)); + config.set_property(ov::intel_gpu::optimize_data(true)); + config.set_property(ov::hint::dynamic_quantization_group_size(32)); + + network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), false); + + if (is_dynamic && !engine.get_device_info().supports_immad) { + auto inst = network->get_primitive("fc_prim"); + auto impl = inst->get_impl(); + ASSERT_TRUE(impl != NULL); + ASSERT_EQ(impl->get_kernels().size(), size_t((is_dynamic ? 3 : 2))); + } + + network->set_input_data("input", input_mem); + + auto outputs = network->execute(); + ASSERT_EQ(outputs.size(), size_t(1)); + ASSERT_EQ(outputs.begin()->first, "fc_prim"); + + auto output_mem = outputs.begin()->second.get_memory(); + cldnn::mem_lock output_ptr (output_mem, get_test_stream()); + + auto ref_output_mem = get_ref_results(); + cldnn::mem_lock output_ptr_ref (ref_output_mem, get_test_stream()); + + size_t count = 0; + float max_diff = 0.f; + float avg = 0.f; + for (size_t i = 0; i < output_ptr_ref.size(); ++i) { + auto abs_diff = std::abs((float)output_ptr_ref[i] - (float)output_ptr[i]); + if (max_diff < abs_diff) + max_diff = abs_diff; + avg += abs_diff; + count++; + OPENVINO_ASSERT(abs_diff < 10); + } + GPU_DEBUG_LOG << "---> count: " << count << ", max_diff:" << max_diff << ", avg_diff: " << (avg/count) << std::endl; + OPENVINO_ASSERT((avg/count) < 1); + } }; using shared_dims = std::tuple; @@ -3427,6 +3535,9 @@ TEST_F(fully_connected_gpu_tests, compressed_int4_scale_dyn_quan_dynamic_f_input this->test_compressed_int4_scale_dyn_quan(false, true, 511, true); } +TEST_F(fully_connected_gpu_tests, compressed_int4_scale_dynamic_quantize_edge_case) { + this->test_compressed_int4_scale_dyn_quan_weight_i4(true, 359, 1536, 2560); +} TEST_F(fully_connected_gpu_tests, compressed_scale_bias) { this->test_compressed_scale_bias(false); From fd62aad2a49604e9eaa5190a976a2d70ab6c55f2 Mon Sep 17 00:00:00 2001 From: Luo Cheng Date: Wed, 21 Aug 2024 16:02:34 +0800 Subject: [PATCH 062/117] [CPU] Reuse Q*K buffer to optimize SDPA first inference latency (#26110) ### Details: - *Reuse Q*K buffer to optimize SDPA first inference latency - *Unroll softmax to avoid data dependency* - *...* ### Tickets: - *[150094](https://jira.devtools.intel.com/browse/CVS-150094)* --- .../kernels/scaled_attn/softmax_kernel.hpp | 179 ++++++++++++++---- .../intel_cpu/src/nodes/scaled_attn.cpp | 33 +--- 2 files changed, 150 insertions(+), 62 deletions(-) diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp index 95d2cb7a90f737..3cf74aa57bedca 100644 --- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp +++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp @@ -22,20 +22,35 @@ namespace XARCH { #if defined(HAVE_AVX2) inline void exp_ps_avx2(__m256& src) { - static __m256 exp_ln_flt_min_f = _mm256_castsi256_ps(_mm256_set1_epi32(0xc2aeac50)); // log(FLT_MIN) - static __m256 exp_ln_flt_max_f = _mm256_castsi256_ps(_mm256_set1_epi32(0x42b17218)); // log(FLT_MAX) - static __m256 exp_log2ef = _mm256_castsi256_ps(_mm256_set1_epi32(0x3fb8aa3b)); // log2(e) - static __m256 half = _mm256_castsi256_ps(_mm256_set1_epi32(0x3f000000)); // 0.5f - static __m256 ln2f = _mm256_castsi256_ps(_mm256_set1_epi32(0x3f317218)); // ln(2) - static __m256 one = _mm256_castsi256_ps(_mm256_set1_epi32(0x3f800000)); // 1.0f - static __m256i exponent_bias = _mm256_set1_epi32(0x0000007f); // 127 +#define REPEAT8(x) x, x, x, x, x, x, x, x + static const uint32_t c_min[] = {REPEAT8(0xc2aeac50)}; + static const uint32_t c_max[] = {REPEAT8(0x42b17218)}; + static const uint32_t c_e[] = {REPEAT8(0x3fb8aa3b)}; + static const uint32_t c_half[] = {REPEAT8(0x3f000000)}; + static const uint32_t c_ln2[] = {REPEAT8(0x3f317218)}; + static const uint32_t c_1[] = {REPEAT8(0x3f800000)}; + static const uint32_t c_bias[] = {REPEAT8(0x0000007f)}; + static const uint32_t c_p1[] = {REPEAT8(0x3f7ffffb)}; + static const uint32_t c_p2[] = {REPEAT8(0x3efffee3)}; + static const uint32_t c_p3[] = {REPEAT8(0x3e2aad40)}; + static const uint32_t c_p4[] = {REPEAT8(0x3d2b9d0d)}; + static const uint32_t c_p5[] = {REPEAT8(0x3c07cfce)}; + static const uint32_t c_2[] = {REPEAT8(0x40000000)}; +#undef REPEAT8 static constexpr int n_mantissa_bits = 23; - static __m256 exp_pol1 = _mm256_castsi256_ps(_mm256_set1_epi32(0x3f7ffffb)); // p1 = 0.999999701f - static __m256 exp_pol2 = _mm256_castsi256_ps(_mm256_set1_epi32(0x3efffee3)); // p2 = 0.499991506f - static __m256 exp_pol3 = _mm256_castsi256_ps(_mm256_set1_epi32(0x3e2aad40)); // p3 = 0.166676521f - static __m256 exp_pol4 = _mm256_castsi256_ps(_mm256_set1_epi32(0x3d2b9d0d)); // p4 = 0.0418978221f - static __m256 exp_pol5 = _mm256_castsi256_ps(_mm256_set1_epi32(0x3c07cfce)); // p5 = 0.00828929059f - static __m256 two = _mm256_castsi256_ps(_mm256_set1_epi32(0x40000000)); // 2 + __m256 exp_ln_flt_min_f = _mm256_loadu_ps(reinterpret_cast(c_min)); // log(FLT_MIN) + __m256 exp_ln_flt_max_f = _mm256_loadu_ps(reinterpret_cast(c_max)); // log(FLT_MAX) + __m256 exp_log2ef = _mm256_loadu_ps(reinterpret_cast(c_e)); // log2(e) + __m256 half = _mm256_loadu_ps(reinterpret_cast(c_half)); // 0.5f + __m256 ln2f = _mm256_loadu_ps(reinterpret_cast(c_ln2)); // ln(2) + __m256 one = _mm256_loadu_ps(reinterpret_cast(c_1)); // 1.0f + __m256i exponent_bias = _mm256_loadu_si256(reinterpret_cast(c_bias));// 127 + __m256 exp_pol1 = _mm256_loadu_ps(reinterpret_cast(c_p1)); // p1 = 0.999999701f + __m256 exp_pol2 = _mm256_loadu_ps(reinterpret_cast(c_p2)); // p2 = 0.499991506f + __m256 exp_pol3 = _mm256_loadu_ps(reinterpret_cast(c_p3)); // p3 = 0.166676521f + __m256 exp_pol4 = _mm256_loadu_ps(reinterpret_cast(c_p4)); // p4 = 0.0418978221f + __m256 exp_pol5 = _mm256_loadu_ps(reinterpret_cast(c_p5)); // p5 = 0.00828929059f + __m256 two = _mm256_loadu_ps(reinterpret_cast(c_2)); // 2 // exp(x) = // = exp(n * ln(2) + r) // divide x by ln(2) and get quot and rem // = 2^n * exp(r) // simplify the exp(n*ln(2)) expression @@ -167,14 +182,46 @@ inline void scale_add2_reduce_max(float* a, float& max) { size_t i = 0; #if defined(HAVE_AVX512F) - auto v_max = _mm512_set1_ps(std::numeric_limits::lowest()); + auto v_max0 = _mm512_set1_ps(std::numeric_limits::lowest()); + auto v_max1 = v_max0; + auto v_max2 = v_max0; + auto v_max3 = v_max0; auto v_scale = _mm512_set1_ps(scale); - auto v_a = v_max; auto v_zeroi32 = _mm512_setzero_epi32(); auto v_nfltmax = _mm512_set1_ps(-FLT_MAX); auto kmask_xor = _cvtu32_mask16(select_nfltmax_at_0 ? 0xFFFF : 0); auto v_alibi_slope = _mm512_set1_ps(alibi_slope); + __m512 v_a; // process vector body + // unroll to avoid dependency caused by _mm256_max_ps + for (; i + 4 * vec_len_f32_avx512 <= size; i += 4 * vec_len_f32_avx512) { + #define ITEM(n) \ + v_a = _mm512_loadu_ps(a + i + n * vec_len_f32_avx512); \ + v_a = _mm512_mul_ps(v_a, v_scale); \ + if (has_alibi) { \ + auto v_lookup = _mm512_loadu_ps(alibi_lookup + i + n * vec_len_f32_avx512); \ + v_a = _mm512_fmadd_ps(v_lookup, v_alibi_slope, v_a); \ + } \ + if (has_attn_mask) { \ + auto v_mask = mm512_uni_loadu_ps(attn_mask + i + n * vec_len_f32_avx512); \ + v_a = _mm512_add_ps(v_a, v_mask); \ + } \ + if (has_causal_mask) { \ + auto v_maski8 = _mm_loadu_si128(reinterpret_cast<__m128i const*>(causal_mask + i + n * vec_len_f32_avx512)); \ + auto v_maski32 = _mm512_cvtepi8_epi32(v_maski8); \ + auto kmask = _mm512_cmp_epi32_mask(v_maski32, v_zeroi32, _MM_CMPINT_NE); \ + kmask = _kxor_mask16(kmask, kmask_xor); \ + v_a = _mm512_mask_blend_ps(kmask, v_a, v_nfltmax); \ + } \ + v_max##n = _mm512_max_ps(v_max##n, v_a); \ + _mm512_storeu_ps(a + i + n * vec_len_f32_avx512, v_a); + + ITEM(0); + ITEM(1); + ITEM(2); + ITEM(3); + #undef ITEM + } while (i + vec_len_f32_avx512 <= size) { v_a = _mm512_loadu_ps(a + i); v_a = _mm512_mul_ps(v_a, v_scale); @@ -196,7 +243,7 @@ inline void scale_add2_reduce_max(float* a, kmask = _kxor_mask16(kmask, kmask_xor); // reverse, mask at ==0 v_a = _mm512_mask_blend_ps(kmask, v_a, v_nfltmax); // mask => -FLT_MAX } - v_max = _mm512_max_ps(v_max, v_a); + v_max0 = _mm512_max_ps(v_max0, v_a); _mm512_storeu_ps(a + i, v_a); i += vec_len_f32_avx512; } @@ -224,22 +271,58 @@ inline void scale_add2_reduce_max(float* a, kmask = _kxor_mask16(kmask, kmask_xor); // reverse, mask at ==0 v_a = _mm512_mask_blend_ps(kmask, v_a, v_nfltmax); // mask => -FLT_MAX } - v_max = _mm512_mask_max_ps(v_max, mask, v_a, v_max); + v_max0 = _mm512_mask_max_ps(v_max0, mask, v_a, v_max0); _mm512_mask_storeu_ps(a + i, mask, v_a); i += (size - i); } - max = _mm512_reduce_max_ps(v_max); + v_max0 = _mm512_max_ps(v_max0, v_max1); + v_max2 = _mm512_max_ps(v_max2, v_max3); + v_max0 = _mm512_max_ps(v_max0, v_max2); + max = _mm512_reduce_max_ps(v_max0); #elif defined(HAVE_AVX2) - auto v_max = _mm256_set1_ps(std::numeric_limits::lowest()); + auto v_max0 = _mm256_set1_ps(std::numeric_limits::lowest()); + auto v_max1 = v_max0; + auto v_max2 = v_max0; + auto v_max3 = v_max0; + __m256 v_a; auto v_scale = _mm256_set1_ps(scale); - auto v_a = v_max; auto v_zeroi32 = _mm256_setzero_si256(); auto v_mask_xor = _mm256_set1_epi32(select_nfltmax_at_0 ? -1 : 0); auto v_nfltmax = _mm256_set1_ps(-FLT_MAX); auto v_alibi_slope = _mm256_set1_ps(alibi_slope); // process vector body + // unroll to avoid dependency caused by _mm512_max_ps + for (; i + 4 * vec_len_f32_avx2 <= size; i += 4 * vec_len_f32_avx2) { + #define ITEM(n) \ + v_a = _mm256_loadu_ps(a + i + n * vec_len_f32_avx2); \ + v_a = _mm256_mul_ps(v_a, v_scale); \ + if (has_alibi) { \ + auto v_lookup = _mm256_loadu_ps(alibi_lookup + i + n * vec_len_f32_avx2); \ + v_a = _mm256_fmadd_ps(v_lookup, v_alibi_slope, v_a); \ + } \ + if (has_attn_mask) { \ + auto v_mask = mm256_uni_loadu_ps(attn_mask + i + n * vec_len_f32_avx2); \ + v_a = _mm256_add_ps(v_a, v_mask); \ + } \ + if (has_causal_mask) { \ + auto v_maski8 = _mm_loadu_si128(reinterpret_cast<__m128i const*>(causal_mask + i + n * vec_len_f32_avx2)); \ + auto v_maski32 = _mm256_cvtepi8_epi32(v_maski8); \ + v_maski32 = _mm256_cmpeq_epi32(v_maski32, v_zeroi32);\ + v_maski32 = _mm256_xor_si256(v_maski32, v_mask_xor);\ + v_a = _mm256_blendv_ps(v_nfltmax, v_a, _mm256_castsi256_ps(v_maski32)); \ + } \ + v_max##n = _mm256_max_ps(v_max##n, v_a); \ + _mm256_storeu_ps(a + i + n * vec_len_f32_avx2, v_a); + + ITEM(0); + ITEM(1); + ITEM(2); + ITEM(3); + #undef ITEM + } + while (i + vec_len_f32_avx2 <= size) { v_a = _mm256_loadu_ps(a + i); v_a = _mm256_mul_ps(v_a, v_scale); @@ -262,7 +345,7 @@ inline void scale_add2_reduce_max(float* a, v_a = _mm256_blendv_ps(v_nfltmax, v_a, _mm256_castsi256_ps(v_maski32)); // mask => -FLT_MAX } - v_max = _mm256_max_ps(v_max, v_a); + v_max0 = _mm256_max_ps(v_max0, v_a); _mm256_storeu_ps(a + i, v_a); i += vec_len_f32_avx2; } @@ -291,14 +374,17 @@ inline void scale_add2_reduce_max(float* a, v_a = _mm256_blendv_ps(v_nfltmax, v_a, _mm256_castsi256_ps(v_maski32)); // mask => -FLT_MAX } - v_a = _mm256_blendv_ps(v_max, v_a, _mm256_castsi256_ps(mask)); - v_max = _mm256_max_ps(v_max, v_a); + v_a = _mm256_blendv_ps(v_max0, v_a, _mm256_castsi256_ps(mask)); + v_max0 = _mm256_max_ps(v_max0, v_a); _mm256_maskstore_ps(a + i, mask, v_a); i += (size - i); } - hmax(v_max); - max = _mm256_cvtss_f32(v_max); + v_max0 = _mm256_max_ps(v_max0, v_max1); + v_max2 = _mm256_max_ps(v_max2, v_max3); + v_max0 = _mm256_max_ps(v_max0, v_max2); + hmax(v_max0); + max = _mm256_cvtss_f32(v_max0); #elif defined(OPENVINO_ARCH_ARM64) auto v_max = vdupq_n_f32(std::numeric_limits::lowest()); auto v_scale = vdupq_n_f32(scale); @@ -364,21 +450,36 @@ inline void scale_add2_reduce_max(float* a, } #if defined(HAVE_AVX512F) -inline void exp_ps_avx512(__m512& src) { - static __m512 exp_ln_flt_min_f = _mm512_castsi512_ps(_mm512_set1_epi32(0xc2aeac50)); // log(FLT_MIN) - static __m512 exp_ln_flt_max_f = _mm512_castsi512_ps(_mm512_set1_epi32(0x42b17218)); // log(FLT_MAX) - static __m512 exp_log2ef = _mm512_castsi512_ps(_mm512_set1_epi32(0x3fb8aa3b)); // log2(e) - static __m512 half = _mm512_castsi512_ps(_mm512_set1_epi32(0x3f000000)); // 0.5f - static __m512 ln2f = _mm512_castsi512_ps(_mm512_set1_epi32(0x3f317218)); // ln(2) - static __m512 one = _mm512_castsi512_ps(_mm512_set1_epi32(0x3f800000)); // 1.0f - static __m512i exponent_bias = _mm512_set1_epi32(0x0000007f); // 127 +static inline void exp_ps_avx512(__m512& src) { +#define REPEAT16(x) x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x + static const uint32_t c_min[] = {REPEAT16(0xc2aeac50)}; + static const uint32_t c_max[] = {REPEAT16(0x42b17218)}; + static const uint32_t c_e[] = {REPEAT16(0x3fb8aa3b)}; + static const uint32_t c_half[] = {REPEAT16(0x3f000000)}; + static const uint32_t c_ln2[] = {REPEAT16(0x3f317218)}; + static const uint32_t c_1[] = {REPEAT16(0x3f800000)}; + static const uint32_t c_bias[] = {REPEAT16(0x0000007f)}; + static const uint32_t c_p1[] = {REPEAT16(0x3f7ffffb)}; + static const uint32_t c_p2[] = {REPEAT16(0x3efffee3)}; + static const uint32_t c_p3[] = {REPEAT16(0x3e2aad40)}; + static const uint32_t c_p4[] = {REPEAT16(0x3d2b9d0d)}; + static const uint32_t c_p5[] = {REPEAT16(0x3c07cfce)}; + static const uint32_t c_2[] = {REPEAT16(0x40000000)}; +#undef REPEAT16 static constexpr int n_mantissa_bits = 23; - static __m512 exp_pol1 = _mm512_castsi512_ps(_mm512_set1_epi32(0x3f7ffffb)); // p1 = 0.999999701f - static __m512 exp_pol2 = _mm512_castsi512_ps(_mm512_set1_epi32(0x3efffee3)); // p2 = 0.499991506f - static __m512 exp_pol3 = _mm512_castsi512_ps(_mm512_set1_epi32(0x3e2aad40)); // p3 = 0.166676521f - static __m512 exp_pol4 = _mm512_castsi512_ps(_mm512_set1_epi32(0x3d2b9d0d)); // p4 = 0.0418978221f - static __m512 exp_pol5 = _mm512_castsi512_ps(_mm512_set1_epi32(0x3c07cfce)); // p5 = 0.00828929059f - static __m512 two = _mm512_castsi512_ps(_mm512_set1_epi32(0x40000000)); // 2 + __m512 exp_ln_flt_min_f = _mm512_loadu_ps(reinterpret_cast(c_min)); // log(FLT_MIN) + __m512 exp_ln_flt_max_f = _mm512_loadu_ps(reinterpret_cast(c_max)); // log(FLT_MAX) + __m512 exp_log2ef = _mm512_loadu_ps(reinterpret_cast(c_e)); // log2(e) + __m512 half = _mm512_loadu_ps(reinterpret_cast(c_half)); // 0.5f + __m512 ln2f = _mm512_loadu_ps(reinterpret_cast(c_ln2)); // ln(2) + __m512 one = _mm512_loadu_ps(reinterpret_cast(c_1)); // 1.0f + __m512i exponent_bias = _mm512_load_epi32(c_bias); // 127 + __m512 exp_pol1 = _mm512_loadu_ps(reinterpret_cast(c_p1)); // p1 = 0.999999701f + __m512 exp_pol2 = _mm512_loadu_ps(reinterpret_cast(c_p2)); // p2 = 0.499991506f + __m512 exp_pol3 = _mm512_loadu_ps(reinterpret_cast(c_p3)); // p3 = 0.166676521f + __m512 exp_pol4 = _mm512_loadu_ps(reinterpret_cast(c_p4)); // p4 = 0.0418978221f + __m512 exp_pol5 = _mm512_loadu_ps(reinterpret_cast(c_p5)); // p5 = 0.00828929059f + __m512 two = _mm512_loadu_ps(reinterpret_cast(c_2)); // 2 // exp(x) = // = exp(n * ln(2) + r) // divide x by ln(2) and get quot and rem // = 2^n * exp(r) // simplify the exp(n*ln(2)) expression diff --git a/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp b/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp index 7471ebc33c9809..72c9bf4b0a7285 100644 --- a/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp +++ b/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp @@ -204,22 +204,15 @@ struct MHAKernel { // k: [B, H, kv_len, S] // v: [B, H, kv_len, S] const GraphContext::CPtr context; - dnnl::memory::desc q_md; - dnnl::memory::desc k_md; - dnnl::memory::desc weight_md; - dnnl::memory::desc v_md; dnnl::memory::desc out_md; - dnnl::memory attn_score; - dnnl::memory attn_weight; PlainTensor fp32_out; PlainTensor qk_scratch_a; PlainTensor qk_scratch_b; PlainTensor wv_scratch_a; PlainTensor wv_scratch_b; + PlainTensor weight_score; std::vector wsp; size_t wsp_size_per_thread = 0; - dnnl::matmul qk_prim; - dnnl::matmul wv_prim; using tag = dnnl::memory::format_tag; using dt = dnnl::memory::data_type; struct brgemmKey { @@ -294,8 +287,6 @@ struct MHAKernel { } qk_gemm_ptr = qk_result.first; - dnnl::memory::desc attn_md(make_dnnl_dims({B, H, q_len, kv_len}), dt::f32, tag::abcd); - weight_md = dnnl::memory::desc(make_dnnl_dims({B, H, q_len, kv_len}), qkv_dt, tag::abcd); if (has_out_transpose) out_md = dnnl::memory::desc(make_dnnl_dims({B, q_len, H, head_size}), qkv_dt, tag::abcd); else @@ -308,7 +299,7 @@ struct MHAKernel { brgemmKey wv_key = {q_len, head_size, kv_len, - kv_len, + kv_len * (in_type == ov::element::Type_t::f32 ? 1 : 2), present_key.stride(2), static_cast(out_md.get_strides()[ldc_index]), false, @@ -334,10 +325,8 @@ struct MHAKernel { qk_scratch_b.resize({B, Hk, qk_gemm_ptr->get_scratch_b_size() / data_size}); wv_scratch_b.resize({B, Hk, wv_gemm_ptr->get_scratch_b_size() / data_size}); - if (!attn_score || attn_md.get_size() > attn_score.get_desc().get_size()) { - attn_score = dnnl::memory(attn_md, strm.get_engine()); - attn_weight = dnnl::memory(weight_md, strm.get_engine()); - } + const size_t m_block_size = qk_gemm_ptr->get_mblk_size(); + weight_score.resize({static_cast(parallel_get_max_threads()), H, m_block_size, kv_len}); if (has_out_transpose) { fp32_out.resize({B, q_len, H, head_size}); } else { @@ -362,9 +351,6 @@ struct MHAKernel { const auto Hk = present_key.size(1); const auto kv_len = present_key.size(2); size_t h_each_group_len = H / Hk; - PlainTensor score, weight; - score.resize({B, H, q_len, kv_len}, static_cast(attn_score.get_data_handle())); - weight.resize({B, H, q_len, kv_len}, static_cast(attn_weight.get_data_handle())); const size_t m_block_size = qk_gemm_ptr->get_mblk_size(); auto m_blocks = (q_len + m_block_size - 1) / m_block_size; bool is_bf16 = precision_of::value == ov::element::bf16; @@ -378,13 +364,13 @@ struct MHAKernel { }); // attention - parallel_for3d(B, H, m_blocks, [&](size_t b, size_t h, size_t m_blk) { + parallel_for3d(B, H, m_blocks, [&](size_t ithr, size_t b, size_t h, size_t m_blk) { auto m_start = m_blk * m_block_size; auto m_end = std::min(m_start + m_block_size, q_len); auto m_cnt = m_end - m_start; size_t tid = parallel_get_thread_num(); T* q_ptr = &query.at({b, h, m_start, 0}); - float* c_ptr = &score.at({b, h, m_start, 0}); + float* c_ptr = weight_score.ptr(ithr, h, 0, 0); T* k_ptr = &qk_scratch_b.at({b, h / h_each_group_len, 0}); qk_gemm_ptr->executeGemm(m_cnt < m_block_size, q_ptr, @@ -417,8 +403,9 @@ struct MHAKernel { for (size_t m = m_start; m < m_end; m++) { // apply attention mask & sofmax auto ncausal = auto_causal ? (kv_len - q_len + m + 1) : kv_len; - attn_softmax(&score.at({b, h, m, 0}), - &weight.at({b, h, m, 0}), + auto score = weight_score.ptr(ithr, h, m - m_start); + attn_softmax(score, + reinterpret_cast(score), d_scale, alibi_ptr + m * alibi_stride, attn_mask_ptr + m * attn_mask_stride, @@ -429,7 +416,7 @@ struct MHAKernel { precision_of::value, precision_of::value); } - T* w_ptr = &weight.at({b, h, m_start, 0}); + auto* w_ptr = reinterpret_cast(weight_score.ptr(ithr, h, 0, 0)); float* fp32_out_ptr; if (is_bf16) { fp32_out_ptr = has_out_transpose ? &fp32_out.at({b, m_start, h, 0}) : &fp32_out.at({b, h, m_start, 0}); From d84c2b53d1cd4dc052ff76d425bd1f8491c0e574 Mon Sep 17 00:00:00 2001 From: Anatoliy Talamanov Date: Wed, 21 Aug 2024 11:30:56 +0100 Subject: [PATCH 063/117] Update GenAI NPU doc (#26060) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --------- Co-authored-by: Maciej Smyk Co-authored-by: Karol Blaszczak --- .../llm_inference_guide/genai-guide-npu.rst | 70 +++++++++---------- 1 file changed, 33 insertions(+), 37 deletions(-) diff --git a/docs/articles_en/learn-openvino/llm_inference_guide/genai-guide-npu.rst b/docs/articles_en/learn-openvino/llm_inference_guide/genai-guide-npu.rst index 516adc225240fd..8a07b0dc05e73e 100644 --- a/docs/articles_en/learn-openvino/llm_inference_guide/genai-guide-npu.rst +++ b/docs/articles_en/learn-openvino/llm_inference_guide/genai-guide-npu.rst @@ -8,60 +8,56 @@ This guide will give you extra details on how to utilize NPU with the GenAI flav :doc:`See the installation guide <../../get-started/install-openvino/install-openvino-genai>` for information on how to start. -Export an LLM model via Hugging Face Optimum-Intel -################################################## +Prerequisites +############# -1. Create a python virtual environment and install the correct components for exporting a model: +Install required dependencies: - .. code-block:: console +.. code-block:: console - python -m venv export-npu-env - export-npu-env\Scripts\activate - pip install transformers>=4.42.4 openvino==2024.2.0 openvino-tokenizers==2024.2.0 nncf==2.11.0 onnx==1.16.1 optimum-intel@git+https://github.com/huggingface/optimum-intel.git + python -m venv npu-env + npu-env\Scripts\activate + pip install optimum-intel nncf==2.11 onnx==1.16.1 + pip install --pre openvino openvino-tokenizers openvino-genai --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly + +Export an LLM model via Hugging Face Optimum-Intel +################################################## -2. A chat-tuned TinyLlama model is used in this example. The following conversion & optimization settings are recommended when using the NPU: +A chat-tuned TinyLlama model is used in this example. The following conversion & optimization settings are recommended when using the NPU: - .. code-block:: python +.. code-block:: python - optimum-cli export openvino -m TinyLlama/TinyLlama-1.1B-Chat-v1.0 --weight-format int4 --sym --group-size 128 --ratio 1.0 TinyLlama + optimum-cli export openvino -m TinyLlama/TinyLlama-1.1B-Chat-v1.0 --weight-format int4 --sym --group-size 128 --ratio 1.0 TinyLlama Run generation using OpenVINO GenAI -########################################## - -1. Create a python virtual environment and install the correct components for running the model on the NPU via OpenVINO GenAI: - - .. code-block:: console - - python -m venv run-npu-env - run-npu-env\Scripts\activate - pip install openvino>=2024.3.1 openvino-tokenizers>=2024.3.1 openvino-genai>=2024.3.1 +################################### -2. Perform generation using the new GenAI API +Use the following code snippet to perform generation with OpenVINO GenAI API: - .. tab-set:: +.. tab-set:: - .. tab-item:: Python - :sync: py + .. tab-item:: Python + :sync: py - .. code-block:: python + .. code-block:: python - import openvino_genai as ov_genai - pipe = ov_genai.LLMPipeline(model_path, "NPU") - print(pipe.generate("The Sun is yellow because", max_new_tokens=100)) + import openvino_genai as ov_genai + pipe = ov_genai.LLMPipeline(model_path, "NPU") + print(pipe.generate("The Sun is yellow because", max_new_tokens=100)) - .. tab-item:: C++ - :sync: cpp + .. tab-item:: C++ + :sync: cpp - .. code-block:: cpp + .. code-block:: cpp - #include "openvino/genai/llm_pipeline.hpp" - #include + #include "openvino/genai/llm_pipeline.hpp" + #include - int main(int argc, char* argv[]) { - std::string model_path = argv[1]; - ov::genai::LLMPipeline pipe(model_path, "NPU"); - std::cout << pipe.generate("The Sun is yellow because", ov::genai::max_new_tokens(100)); - } + int main(int argc, char* argv[]) { + std::string model_path = argv[1]; + ov::genai::LLMPipeline pipe(model_path, "NPU"); + std::cout << pipe.generate("The Sun is yellow because", ov::genai::max_new_tokens(100)); + } Additional configuration options ################################ From fdde9f15321a3531063781c6a818da96ed4b29e0 Mon Sep 17 00:00:00 2001 From: Alina Kladieva Date: Wed, 21 Aug 2024 14:41:26 +0200 Subject: [PATCH 064/117] Temporarily remove TF layer tests from required on ARM (#26158) There are currently test failures --- .github/workflows/linux_arm64.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/linux_arm64.yml b/.github/workflows/linux_arm64.yml index d38eda93e7d2b8..225fd632ee81c3 100644 --- a/.github/workflows/linux_arm64.yml +++ b/.github/workflows/linux_arm64.yml @@ -434,7 +434,7 @@ jobs: Overall_Status: name: ci/gha_overall_status_linux_arm64 needs: [Smart_CI, Build, Debian_Packages, Samples, ONNX_Runtime, CXX_Unit_Tests, Python_Unit_Tests, CPU_Functional_Tests, - TensorFlow_Models_Tests, PyTorch_Models_Tests, Openvino_tokenizers, TensorFlow_Layer_Tests] + TensorFlow_Models_Tests, PyTorch_Models_Tests, Openvino_tokenizers] if: ${{ always() }} runs-on: ubuntu-latest steps: From 54f58b86be2f7b15159abffd5544477276342ac9 Mon Sep 17 00:00:00 2001 From: Alexandra Sidorova Date: Wed, 21 Aug 2024 17:10:16 +0400 Subject: [PATCH 065/117] [Snippets][CPU] Enabled dynamic MHA FP32 tokenization on x64 (#25500) ### Details: - *The PR enables dynamic FP32 MHA tokenization on x64 platforms :tada:* - *`std::vector.resize()` which was used for buffer scratchpad allocation is very expensive operation due to default constructor of elements. This PR replace `std::vector.resize()` with CPU Node Scratchpad memory which can be shared between nodes. Also since each thread must have the own scratchpad memory, we allocated `size * threads_max` - however, in execution thread count can be less (depends on parallel work amount). Now we allocate only `size * n_threads` where `nthreads` is real count of working threads.* - *Fixed dimension K validation in `BrgemmBlocking` pass: one of inputs can have dynamic value of this dimension* - *Fixed `utils::broadcast_merge_dim()` and supported broadcasting of integer values in IterHandlers. Added unit tests for `utils::broadcast_merge_dim()`* ### Tickets: - *149900* ### Prerequisites: - [x] https://github.com/openvinotoolkit/openvino/pull/25326 - [x] https://github.com/openvinotoolkit/openvino/pull/25378 - [x] https://github.com/openvinotoolkit/openvino/pull/25623 - [x] https://github.com/openvinotoolkit/openvino/pull/25638 - [x] https://github.com/openvinotoolkit/openvino/pull/25745 - [x] https://github.com/openvinotoolkit/openvino/pull/25957 - [x] https://github.com/openvinotoolkit/openvino/pull/25733 --- .../include/snippets/lowered/pass/pass.hpp | 2 +- .../snippets/include/snippets/utils/utils.hpp | 5 + .../snippets/src/lowered/expression.cpp | 4 +- .../src/lowered/pass/brgemm_blocking.cpp | 6 +- .../src/lowered/pass/iter_handler.cpp | 20 ++-- .../src/lowered/pass/propagate_subtensors.cpp | 10 +- .../snippets/src/pass/mha_tokenization.cpp | 20 +++- src/common/snippets/src/utils/utils.cpp | 15 ++- .../include/utils/broadcast_dim_merge.hpp | 28 ++++++ .../tests/src/utils/broadcast_merge_dim.cpp | 56 +++++++++++ src/plugins/intel_cpu/src/node.h | 2 +- src/plugins/intel_cpu/src/nodes/subgraph.cpp | 93 +++++++++---------- src/plugins/intel_cpu/src/nodes/subgraph.h | 17 +++- .../transformation_pipeline.cpp | 5 +- 14 files changed, 201 insertions(+), 82 deletions(-) create mode 100644 src/common/snippets/tests/include/utils/broadcast_dim_merge.hpp create mode 100644 src/common/snippets/tests/src/utils/broadcast_merge_dim.cpp diff --git a/src/common/snippets/include/snippets/lowered/pass/pass.hpp b/src/common/snippets/include/snippets/lowered/pass/pass.hpp index 5833b695b0bba8..446f96d30a27cf 100644 --- a/src/common/snippets/include/snippets/lowered/pass/pass.hpp +++ b/src/common/snippets/include/snippets/lowered/pass/pass.hpp @@ -20,7 +20,7 @@ namespace pass { * @brief Base class for transformations on linear IR * @ingroup snippets */ -class PassBase { +class PassBase : public std::enable_shared_from_this { public: PassBase() = default; virtual ~PassBase() = default; diff --git a/src/common/snippets/include/snippets/utils/utils.hpp b/src/common/snippets/include/snippets/utils/utils.hpp index e9a7e7d1ca9523..22665f41827ce3 100644 --- a/src/common/snippets/include/snippets/utils/utils.hpp +++ b/src/common/snippets/include/snippets/utils/utils.hpp @@ -124,6 +124,11 @@ std::string vector2str(const std::vector& values) { bool broadcast_merge_dim(size_t& dst, const size_t& d1, const size_t& d2); +// If one of the dims is dynamic, return the other dim (might also be dynamic) +// If both dims are static, they must be equal - this is the difference from the utility above +// Can be used in SpecificLoopIterationHandlers +bool merge_dynamic_dim(size_t& dst, const size_t& d1, const size_t& d2); + VectorDims pshape_to_vdims(const PartialShape&); ov::PartialShape vdims_to_pshape(const VectorDims&); diff --git a/src/common/snippets/src/lowered/expression.cpp b/src/common/snippets/src/lowered/expression.cpp index 8b30872e0b1328..3c4391da3a7250 100644 --- a/src/common/snippets/src/lowered/expression.cpp +++ b/src/common/snippets/src/lowered/expression.cpp @@ -175,11 +175,11 @@ ExpressionPtr Expression::clone_with_new_inputs(const ExpressionMap& expr_map, } ExpressionPort Expression::get_input_port(size_t i) { - return ExpressionPort(this->shared_from_this(), ExpressionPort::Type::Input, i); + return ExpressionPort(shared_from_this(), ExpressionPort::Type::Input, i); } ExpressionPort Expression::get_output_port(size_t i) { - return ExpressionPort(this->shared_from_this(), ExpressionPort::Type::Output, i); + return ExpressionPort(shared_from_this(), ExpressionPort::Type::Output, i); } std::vector Expression::get_input_ports() { diff --git a/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp b/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp index d689b183456bc1..090175c7466be3 100644 --- a/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp +++ b/src/common/snippets/src/lowered/pass/brgemm_blocking.cpp @@ -102,8 +102,10 @@ std::tuple BrgemmBlockingBase::get_blocking_params(const const auto& m = *++out_preordered_dims.rbegin(); const auto& n = *out_preordered_dims.rbegin(); - const auto& k = *in_0_planar_dims.rbegin(); - OPENVINO_ASSERT(k == *++in_1_planar_dims.rbegin(), "Brgemm input descriptors have different K dimension value."); + const auto& k0 = *in_0_planar_dims.rbegin(); + const auto& k1 = *++in_1_planar_dims.rbegin(); + size_t k = 0; + OPENVINO_ASSERT(utils::merge_dynamic_dim(k, k0, k1), "Brgemm input descriptors have incompatible K dimension value."); // Ticket: 113745 // TODO: extend block size selection heuristics diff --git a/src/common/snippets/src/lowered/pass/iter_handler.cpp b/src/common/snippets/src/lowered/pass/iter_handler.cpp index 3e035628df476f..9c9ab69351c7bd 100644 --- a/src/common/snippets/src/lowered/pass/iter_handler.cpp +++ b/src/common/snippets/src/lowered/pass/iter_handler.cpp @@ -49,13 +49,13 @@ bool UpdateMemoryAccessCounts::run(LinearIR& linear_ir, LinearIR::constExprIt be } std::shared_ptr UpdateMemoryAccessCounts::merge(const std::shared_ptr& other) { - const auto merged_pass = std::make_shared(m_count); - if (other == nullptr) - return merged_pass; + if (!other) + return shared_from_this(); const auto casted_pass = ov::as_type_ptr(other); - if (!casted_pass || m_count != casted_pass->m_count) + size_t merged_count; + if (!casted_pass || !ov::snippets::utils::merge_dynamic_dim(merged_count, m_count, casted_pass->m_count)) return nullptr; - return merged_pass; + return std::make_shared(merged_count); } SetFillOffset::SetFillOffset(size_t offset) : RangedPass(), m_offset(offset) {} @@ -71,13 +71,13 @@ bool SetFillOffset::run(LinearIR& linear_ir, LinearIR::constExprIt begin, Linear } std::shared_ptr SetFillOffset::merge(const std::shared_ptr& other) { - const auto merged_pass = std::make_shared(m_offset); - if (other == nullptr) - return merged_pass; + if (!other) + return shared_from_this(); const auto casted_pass = ov::as_type_ptr(other); - if (!casted_pass || m_offset != casted_pass->m_offset) + size_t merged_offset; + if (!casted_pass || !ov::snippets::utils::merge_dynamic_dim(merged_offset, m_offset, casted_pass->m_offset)) return nullptr; - return merged_pass; + return std::make_shared(merged_offset); } bool SetLoopIncrementOne::run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) { diff --git a/src/common/snippets/src/lowered/pass/propagate_subtensors.cpp b/src/common/snippets/src/lowered/pass/propagate_subtensors.cpp index c89274a728c4c9..53fb344f4d9e8a 100644 --- a/src/common/snippets/src/lowered/pass/propagate_subtensors.cpp +++ b/src/common/snippets/src/lowered/pass/propagate_subtensors.cpp @@ -175,13 +175,13 @@ bool UpdateSubtensors::run(LinearIR& linear_ir, LinearIR::constExprIt begin, Lin } std::shared_ptr UpdateSubtensors::merge(const std::shared_ptr& other) { - const auto merged_pass = std::make_shared(m_tail_size); - if (other == nullptr) - return merged_pass; + if (!other) + return shared_from_this(); const auto casted_pass = ov::as_type_ptr(other); - if (!casted_pass || m_tail_size != casted_pass->m_tail_size) + size_t merged_size; + if (!casted_pass || !ov::snippets::utils::merge_dynamic_dim(merged_size, m_tail_size, casted_pass->m_tail_size)) return nullptr; - return merged_pass; + return std::make_shared(merged_size); } } // namespace pass diff --git a/src/common/snippets/src/pass/mha_tokenization.cpp b/src/common/snippets/src/pass/mha_tokenization.cpp index 483cdcd8564265..d1d8526534f62d 100644 --- a/src/common/snippets/src/pass/mha_tokenization.cpp +++ b/src/common/snippets/src/pass/mha_tokenization.cpp @@ -472,9 +472,25 @@ ov::snippets::pass::TokenizeMHASnippets::TokenizeMHASnippets(const SnippetsToken // TODO [75567]: move this plugin-specific constraint to the plugin callback const auto last_node = ordered_ops.back(); - if (potential_body_params_count + last_node->get_output_size() + hidden_virtual_ports_count + uniqie_buffer_reg_group_count > 11) { + const auto io_count = potential_body_params_count + last_node->get_output_size() + hidden_virtual_ports_count; + const auto data_count = io_count + uniqie_buffer_reg_group_count; + auto available_regs = config.get_data_ptr_gpr_count(); + // [150148, 150149] Currently Snippets don't have mechanism of spilling registers on stack. + // Due to this limitation we have to skip tokenization of some subgraphs + // if we need more registers than we have on the target machine. + // `config.get_data_ptr_gpr_count()` provides available data registers count (including parameters, results and buffers) + // after excluding 2 registers for work amounts. + // However, MHA Subgraph has `SplitLoops` optimization which adds outermost blocked Loop by M. This Loop requires + // the separate own register for `work_amount` also. Thus, we have to decrement `available_regs` count in MHA case. + // Need to notice that in general we have enough count of available registers. + // But in rare cases (when there are a lot of parameters/results, the heuristic value of their number is `5`) + // the count of available registers might be not enough and we have to not tokenize these subgraphs. + // So only for these rare cases we decrement `available_regs` value. + if (io_count > 5) + available_regs--; + + if (data_count > available_regs) return false; - } // If backend doesn't enable dynamic MHA tokenization, return false if (!config.is_dynamic_mha_token_enabled()) { diff --git a/src/common/snippets/src/utils/utils.cpp b/src/common/snippets/src/utils/utils.cpp index cd64958207d958..e7381fe6754758 100644 --- a/src/common/snippets/src/utils/utils.cpp +++ b/src/common/snippets/src/utils/utils.cpp @@ -103,10 +103,21 @@ auto get_non_scalar_constant_count_for_fq(const std::shared_ptr + + +namespace ov { +namespace test { +namespace snippets { + +// D1, D2, Result +using BroadcastMergeDimParams = std::tuple; + +class BroadcastMergeDimTest : public testing::TestWithParam { +public: + static std::string getTestCaseName(testing::TestParamInfo obj); + +protected: + void SetUp() override; + BroadcastMergeDimParams m_dims = {}; +}; + +} // namespace snippets +} // namespace test +} // namespace ov diff --git a/src/common/snippets/tests/src/utils/broadcast_merge_dim.cpp b/src/common/snippets/tests/src/utils/broadcast_merge_dim.cpp new file mode 100644 index 00000000000000..52ed6116822a9d --- /dev/null +++ b/src/common/snippets/tests/src/utils/broadcast_merge_dim.cpp @@ -0,0 +1,56 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "utils/broadcast_dim_merge.hpp" + +#include "common_test_utils/ov_test_utils.hpp" +#include "snippets/utils/utils.hpp" + +namespace ov { +namespace test { +namespace snippets { + +std::string BroadcastMergeDimTest::getTestCaseName(testing::TestParamInfo obj) { + BroadcastMergeDimParams params = obj.param; + std::ostringstream result; + result << "D0=" << ov::snippets::utils::value2str(std::get<0>(params)) << "_"; + result << "D1=" << ov::snippets::utils::value2str(std::get<1>(params)) << "_"; + result << "DST=" << ov::snippets::utils::value2str(std::get<2>(params)); + return result.str(); +} + +void BroadcastMergeDimTest::SetUp() { + m_dims = this->GetParam(); +} + +TEST_P(BroadcastMergeDimTest, BrodcastMergeDim) { + size_t d1, d2, dst, result; + std::tie(d1, d2, dst) = this->m_dims; + ASSERT_TRUE(ov::snippets::utils::broadcast_merge_dim(result, d1, d2)); + ASSERT_EQ(result, dst); +} + +namespace BrodcastMergeDimInstantiation { + +constexpr size_t dynamic = ov::snippets::utils::get_dynamic_value(); + +const std::vector dimension_cases = { + {10, 10, 10}, + {10, 1, 10}, + {1, 10, 10}, + {dynamic, 10, 10}, + {10, dynamic, 10}, + {dynamic, dynamic, dynamic}, + {dynamic, 1, dynamic}, + {1, dynamic, dynamic}, +}; + +INSTANTIATE_TEST_SUITE_P(smoke_Snippets_BrodcastMergeDim, BroadcastMergeDimTest, + ::testing::ValuesIn(dimension_cases), + BroadcastMergeDimTest::getTestCaseName); + +} // namespace BrodcastMergeDimInstantiation +} // namespace snippets +} // namespace test +} // namespace ov \ No newline at end of file diff --git a/src/plugins/intel_cpu/src/node.h b/src/plugins/intel_cpu/src/node.h index 2095907b860508..f3eb606bf3e322 100644 --- a/src/plugins/intel_cpu/src/node.h +++ b/src/plugins/intel_cpu/src/node.h @@ -773,7 +773,7 @@ class Node { NameFromType(getType())); } - MemoryPtr getScratchPadMem(const DnnlMemoryDescPtr& desc) { + MemoryPtr getScratchPadMem(const MemoryDescPtr& desc) { if (!scratchpadMem || !scratchpadMem->getDesc().isCompatible(*desc)) { scratchpadMem = context->getScratchPad(curNumaNode)->createScratchPadMem(desc); } diff --git a/src/plugins/intel_cpu/src/nodes/subgraph.cpp b/src/plugins/intel_cpu/src/nodes/subgraph.cpp index 25ea10ce805622..b676f54e27c2d0 100644 --- a/src/plugins/intel_cpu/src/nodes/subgraph.cpp +++ b/src/plugins/intel_cpu/src/nodes/subgraph.cpp @@ -72,16 +72,15 @@ class SubgraphStaticExecutor : public Subgraph::SubgraphExecutor { const std::shared_ptr& snippet, const std::vector& start_offset_in, const std::vector& start_offset_out, - const std::shared_ptr& snippet_config) - : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out) { - init_runtime_params(snippet_config); - } + const std::shared_ptr& snippet_config, + const BufferScratchpadAllocator& allocator) + : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out, snippet_config, allocator) {} void exec(const std::vector& inMemPtrs, const std::vector& outMemPtrs) override { const auto& callable = m_schedule->get_callable(); - auto initializer = [&](jit_snippets_call_args& call_args) { - init_call_args(call_args, inMemPtrs, outMemPtrs); + auto initializer = [&](jit_snippets_call_args& call_args, size_t ithr) { + init_call_args(call_args, inMemPtrs, outMemPtrs, ithr); }; auto caller = [&](jit_snippets_call_args& call_args, const size_t* indexes) { callable(&call_args, indexes); @@ -97,17 +96,15 @@ class SubgraphStaticExecutor : public Subgraph::SubgraphExecutor { protected: typedef void (*kernel)(const void*, const void*); - inline void init_call_args(jit_snippets_call_args& call_args, const std::vector& srcMemPtrs, const std::vector& dstMemPtrs) { + inline void init_call_args(jit_snippets_call_args& call_args, const std::vector& srcMemPtrs, + const std::vector& dstMemPtrs, size_t ithr) { for (size_t i = 0; i < srcMemPtrs.size(); i++) call_args.src_ptrs[i] = srcMemPtrs[i]->getDataAs() + m_start_offset_in[i]; for (size_t i = 0; i < dstMemPtrs.size(); i++) call_args.dst_ptrs[i] = dstMemPtrs[i]->getDataAs() + m_start_offset_out[i]; - if (m_buffer_scratchpad_size > 0) { - call_args.buffer_scratchpad_ptr = - reinterpret_cast(m_buffer_scratchpad.data()) + parallel_get_thread_num() * m_buffer_scratchpad_size; - } + update_scratchpad_ptr(call_args.buffer_scratchpad_ptr, ithr); } }; @@ -118,9 +115,13 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor { const std::shared_ptr& snippet, const std::vector& start_offset_in, const std::vector& start_offset_out, - const std::shared_ptr& snippet_config) - : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out) { - init_runtime_params(snippet_config); + const std::shared_ptr& snippet_config, + const BufferScratchpadAllocator& allocator) + : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out, snippet_config, allocator) { + buffer_offsets = snippet_config->buffer_cluster_offsets; + data_offsets = snippet_config->io_data_offsets; + loop_args = snippet_config->loop_args; + reset_exec_table_state = snippet_config->kernel_executor_table->get_state_reset(); } void exec(const std::vector& inMemPtrs, const std::vector& outMemPtrs) override { @@ -137,8 +138,8 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor { std::vector dst_ptrs; init_original_ptrs(inMemPtrs, outMemPtrs, src_ptrs, dst_ptrs); - auto initializer = [&](jit_snippets_call_args& call_args) { - init_call_args(call_args); + auto initializer = [&](jit_snippets_call_args& call_args, size_t ithr) { + init_call_args(call_args, ithr); }; auto caller = [&](jit_snippets_call_args& call_args, const size_t* indexes) { update_ptrs(call_args, src_ptrs, dst_ptrs, indexes); @@ -155,13 +156,11 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor { protected: typedef void (*dynamic_kernel)(const void *); - inline void init_call_args(jit_snippets_call_args& call_args) { + inline void init_call_args(jit_snippets_call_args& call_args, size_t ithr) { call_args.register_loops(loop_args); std::copy(buffer_offsets.cbegin(), buffer_offsets.cend(), call_args.buffer_offsets); - if (m_buffer_scratchpad_size > 0) - call_args.buffer_scratchpad_ptr = - reinterpret_cast(m_buffer_scratchpad.data()) + parallel_get_thread_num() * m_buffer_scratchpad_size; + update_scratchpad_ptr(call_args.buffer_scratchpad_ptr, ithr); } inline void init_original_ptrs(const std::vector& srcMemPtrs, const std::vector& dstMemPtrs, @@ -196,14 +195,6 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor { } } - void init_runtime_params(const std::shared_ptr& snippet_config) override { - SubgraphExecutor::init_runtime_params(snippet_config); - buffer_offsets = snippet_config->buffer_cluster_offsets; - data_offsets = snippet_config->io_data_offsets; - loop_args = snippet_config->loop_args; - reset_exec_table_state = snippet_config->kernel_executor_table->get_state_reset(); - }; - std::vector buffer_offsets = {}; std::vector> data_offsets = {}; std::vector loop_args = {}; @@ -757,10 +748,15 @@ void Subgraph::optimizeIR() { } void Subgraph::prepareParams() { - const auto cache = context->getParamsCache(); + const auto& cache = context->getParamsCache(); - auto builder = [this, cache](const SubgraphKey& key) -> std::shared_ptr { + auto builder = [this, &cache](const SubgraphKey& key) -> std::shared_ptr { const auto& snippet = subgraph_attrs->snippet; + + SubgraphExecutor::BufferScratchpadAllocator allocator = [this](size_t size) { + return getScratchPadMem(std::make_shared(ov::element::u8, intel_cpu::Shape{size})); + }; + if (is_dynamic) { // Dynamic case: // 1. Generate JIT code if needed @@ -777,7 +773,7 @@ void Subgraph::prepareParams() { snippet->get_runtime_configurator()->set_kernel_executor_table(code_gen->get()->lowering_result.kernel_executor_table); } const auto& snippet_config = ov::as_type_ptr(snippet->update_runtime_config()); - return std::make_shared(key.attrs, code_gen, start_offset_in, start_offset_out, snippet_config); + return std::make_shared(key.attrs, code_gen, start_offset_in, start_offset_out, snippet_config, allocator); } else { // Static case: // 1. Update runtime config to get static scheduling data (io data offsets, parallel domain) which will be compiled in JIT code @@ -788,7 +784,7 @@ void Subgraph::prepareParams() { [&snippet_config](const SubgraphCodeGeneratorKey& key) -> std::shared_ptr { return std::make_shared(key.attrs, snippet_config); }); - return std::make_shared(key.attrs, code_gen_result.first, start_offset_in, start_offset_out, snippet_config); + return std::make_shared(key.attrs, code_gen_result.first, start_offset_in, start_offset_out, snippet_config, allocator); } }; @@ -875,26 +871,25 @@ Subgraph::SubgraphCodeGenerator::SubgraphCodeGenerator(const std::shared_ptr& snippet_attrs, const std::shared_ptr& snippet, const std::vector& start_offset_in, - const std::vector& start_offset_out) + const std::vector& start_offset_out, + const std::shared_ptr& snippet_config, + const BufferScratchpadAllocator& allocator) : m_schedule(snippet->get()), m_start_offset_in(start_offset_in), m_start_offset_out(start_offset_out) { OPENVINO_ASSERT(m_schedule, "Schedule is empty!"); -#if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS) - const auto target = std::dynamic_pointer_cast(snippet_attrs->snippet->get_generator()->get_target_machine()); - enabled_segfault_detector = target && target->debug_config.enable_segfault_detector; -#endif -} - -void Subgraph::SubgraphExecutor::init_runtime_params(const std::shared_ptr& snippet_config) { OPENVINO_ASSERT(snippet_config, "Runtime Config is empty!"); - - m_buffer_scratchpad_size = snippet_config->buffer_scratchpad_size; - OPENVINO_ASSERT(!ov::snippets::utils::is_dynamic_value(m_buffer_scratchpad_size), "Undefined buffer scratchpad size!"); - m_buffer_scratchpad.resize(m_buffer_scratchpad_size * parallel_get_max_threads(), 0); - init_parallel_domain(snippet_config, m_parallel_exec_domain); m_harness_work_amount = std::accumulate(m_parallel_exec_domain.cbegin(), m_parallel_exec_domain.cend(), size_t(1), std::multiplies()); m_nthreads = std::min(parallel_get_max_threads(), static_cast(m_harness_work_amount)); + + m_buffer_scratchpad_size = snippet_config->buffer_scratchpad_size; + OPENVINO_ASSERT(!ov::snippets::utils::is_dynamic_value(m_buffer_scratchpad_size), "Undefined buffer scratchpad size!"); + m_buffer_scratchpad = allocator(static_cast(m_nthreads) * m_buffer_scratchpad_size); + +#if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS) + const auto target = std::dynamic_pointer_cast(snippet_attrs->snippet->get_generator()->get_target_machine()); + enabled_segfault_detector = target && target->debug_config.enable_segfault_detector; +#endif } #if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS) @@ -914,7 +909,7 @@ void Subgraph::SubgraphExecutor::segfault_detector() { } #endif -void Subgraph::SubgraphExecutor::parallel_for6d(const std::function& initializer, +void Subgraph::SubgraphExecutor::parallel_for6d(const std::function& initializer, const std::function& caller) { const auto& dom = m_parallel_exec_domain; @@ -924,7 +919,7 @@ void Subgraph::SubgraphExecutor::parallel_for6d(const std::function& initializer, +void Subgraph::SubgraphExecutor::parallel_forNd(const std::function& initializer, const std::function& caller) { const auto& dom = m_parallel_exec_domain; @@ -948,7 +943,7 @@ void Subgraph::SubgraphExecutor::parallel_forNd(const std::function; + SubgraphExecutor(const std::shared_ptr& snippet_attrs, const std::shared_ptr& snippet, const std::vector& start_offset_in, - const std::vector& start_offset_out); + const std::vector& start_offset_out, + const std::shared_ptr& snippet_config, + const BufferScratchpadAllocator& allocator); virtual ~SubgraphExecutor() = default; virtual void exec(const std::vector& inMemPtrs, const std::vector& outMemPtrs) = 0; protected: - void parallel_for6d(const std::function& initializer, + void parallel_for6d(const std::function& initializer, const std::function& caller); - void parallel_forNd(const std::function& initializer, + void parallel_forNd(const std::function& initializer, const std::function& caller); - virtual void init_runtime_params(const std::shared_ptr& snippet_config); + inline void update_scratchpad_ptr(void*& scratchpad_ptr, size_t ithr) const { + if (m_buffer_scratchpad_size > 0) + scratchpad_ptr = m_buffer_scratchpad->getDataAs() + ithr * m_buffer_scratchpad_size; + } std::shared_ptr m_schedule; // Holds index of output used as in execution domain @@ -142,7 +149,7 @@ class Subgraph::SubgraphExecutor { size_t m_harness_work_amount = 0; // Buffer scratchpad - std::vector m_buffer_scratchpad = {}; + MemoryPtr m_buffer_scratchpad = nullptr; size_t m_buffer_scratchpad_size = 0; const size_t rank6D = 6; diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp index 98da1be4c74876..43862022462ada 100644 --- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp +++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp @@ -893,17 +893,16 @@ void Transformations::MainSnippets(void) { // ARM has 32 gprs. After excluding 2 registers for work amounts, 1 register for runtime parameters, 1 platform register, // 3 registers for temporary use, and 2 stack related registers, it has 23 remaining registers. size_t data_ptr_gpr_count = 23; + bool is_dynamic_mha_token_enabled = false; #else // X64 has 16 gprs. After excluding 2 registers for work amounts, 1 register for runtime parameters, // and 2 stack related registers, it has 11 remaining registers. size_t data_ptr_gpr_count = 11; + bool is_dynamic_mha_token_enabled = true; #endif // The optimization "SplitDimensionM" depends on target machine (thread count). // To avoid uncontrolled behavior in tests, we disabled the optimization when there is Config::SnippetsMode::IgnoreCallback bool split_m_dimension = !ignoreCallback; - // [113198] Add dynamic Subgraph with MHA pattern inside execution support - // To enable dynamic MHA in tests, this flag is on when there is Config::SnippetsMode::IgnoreCallback - bool is_dynamic_mha_token_enabled = ignoreCallback; // [122706] Some 3D MHA Patterns have perf regressions when Transpose op is tokenized std::set mha_supported_transpose_ranks = { 4 }; snippets::pass::SnippetsTokenization::Config tokenization_config(concurrency, data_ptr_gpr_count, split_m_dimension, From f79109963afc1ccce394b13d56e85fa3debe36de Mon Sep 17 00:00:00 2001 From: Gorokhov Dmitriy Date: Wed, 21 Aug 2024 16:04:57 +0400 Subject: [PATCH 066/117] [CPU] Fix debug assertion in oneDNN Matmul Brgemm kernel (#26087) ### Details: - OneDNN Matmul Brgemm kernel contains wrong debug assertion which lead to functional failurs on systems with avx2_vnni support. ### Tickets: - [CVS-149880](https://jira.devtools.intel.com/browse/CVS-149880) --- src/plugins/intel_cpu/thirdparty/onednn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/intel_cpu/thirdparty/onednn b/src/plugins/intel_cpu/thirdparty/onednn index 6b99866a4531e3..6237cb7cc6df35 160000 --- a/src/plugins/intel_cpu/thirdparty/onednn +++ b/src/plugins/intel_cpu/thirdparty/onednn @@ -1 +1 @@ -Subproject commit 6b99866a4531e38a74d1de36d5b366c54c5e6cc3 +Subproject commit 6237cb7cc6df3591bf0113fdc546fab724d4d55b From a07e2bc449a9cb4f0dc2a1e1f6dca97f3acd49d3 Mon Sep 17 00:00:00 2001 From: Alicja Miloszewska Date: Wed, 21 Aug 2024 15:34:06 +0200 Subject: [PATCH 067/117] [OV JS] Remove extra assets from tests (#25712) ### Details: - Remove testing models from repository - Add `setup.js` script that will be called once to download testing models - Before running the suite check if model is downloaded, add top describe to *.test.js files ### Notes: Currently there is no global setup file for native [node test runner](https://github.com/nodejs/node/issues/49732) as in other test runner e.g. [jest](https://jestjs.io/docs/configuration#globalsetup-string) ### Tickets: - [CVS-146345](https://jira.devtools.intel.com/browse/CVS-146345) --------- Co-authored-by: Vishniakov Nikolai --- src/bindings/js/node/.gitignore | 1 + src/bindings/js/node/package.json | 3 +- .../js/node/scripts/download_runtime.js | 18 +- src/bindings/js/node/tests/unit/basic.test.js | 481 +++++++++--------- .../js/node/tests/unit/compiled_model.test.js | 46 +- src/bindings/js/node/tests/unit/core.test.js | 85 ++-- .../js/node/tests/unit/infer_request.test.js | 469 ++++++++--------- src/bindings/js/node/tests/unit/model.test.js | 211 ++++---- .../js/node/tests/unit/partial_shape.test.js | 20 +- .../tests/unit/pre_post_processor.test.js | 244 ++++----- .../js/node/tests/unit/read_model.test.js | 137 ++--- src/bindings/js/node/tests/unit/setup.js | 9 + .../js/node/tests/unit/tensor.test.js | 397 ++++++++------- .../unit/test_models/test_model_fp32.bin | Bin 337592 -> 0 bytes .../unit/test_models/test_model_fp32.xml | 467 ----------------- src/bindings/js/node/tests/unit/utils.js | 60 ++- 16 files changed, 1147 insertions(+), 1501 deletions(-) create mode 100644 src/bindings/js/node/tests/unit/setup.js delete mode 100644 src/bindings/js/node/tests/unit/test_models/test_model_fp32.bin delete mode 100644 src/bindings/js/node/tests/unit/test_models/test_model_fp32.xml diff --git a/src/bindings/js/node/.gitignore b/src/bindings/js/node/.gitignore index 6bbca841fe2db9..38782682575826 100644 --- a/src/bindings/js/node/.gitignore +++ b/src/bindings/js/node/.gitignore @@ -3,6 +3,7 @@ dist build types ov_runtime +tests/unit/test_models *.exp diff --git a/src/bindings/js/node/package.json b/src/bindings/js/node/package.json index 43f0a264571c9e..a3544a6136cccf 100644 --- a/src/bindings/js/node/package.json +++ b/src/bindings/js/node/package.json @@ -18,7 +18,8 @@ "build": "npm run tsc", "prepare": "npm run build", "lint": "eslint .", - "test": "node --test ./tests/unit/*.test.js", + "test_setup": "node ./tests/unit/setup.js", + "test": "npm run test_setup && node --test ./tests/unit/*.test.js", "test:e2e": "mocha ./tests/e2e/electron-app.test.js", "tsc": "tsc", "postinstall": "npm run install_runtime", diff --git a/src/bindings/js/node/scripts/download_runtime.js b/src/bindings/js/node/scripts/download_runtime.js index f3aa3dce849c4d..775b4aa6c754c9 100644 --- a/src/bindings/js/node/scripts/download_runtime.js +++ b/src/bindings/js/node/scripts/download_runtime.js @@ -61,7 +61,7 @@ class RuntimeExistsError extends Error { async function downloadRuntime(destinationPath, config = { force: false, ignoreIfExists: true, proxy: null }) { const { version } = packageJson; const osInfo = await getOsInfo(); - const isRuntimeDirectoryExists = await checkIfDirectoryExists(destinationPath); + const isRuntimeDirectoryExists = await checkIfPathExists(destinationPath); if (isRuntimeDirectoryExists && !config.force) { if (config.ignoreIfExists) { @@ -87,7 +87,7 @@ async function downloadRuntime(destinationPath, config = { force: false, ignoreI await fs.mkdir(tempDirectoryPath); console.log('Downloading OpenVINO runtime archive...'); - await downloadFile(runtimeArchiveUrl, filename, tempDirectoryPath, config.proxy); + await downloadFile(runtimeArchiveUrl, tempDirectoryPath, filename, config.proxy); console.log('OpenVINO runtime archive downloaded.'); await removeDirectory(destinationPath); @@ -139,16 +139,16 @@ async function getOsInfo() { } /** - * Check if directory exists. + * Check if path exists. * * @async - * @function checkIfDirectoryExists - * @param {string} directoryPath - The directory path. + * @function checkIfPathExists + * @param {string} path - The path to directory or file. * @returns {Promise} */ -async function checkIfDirectoryExists(directoryPath) { +async function checkIfPathExists(path) { try { - await fs.access(directoryPath); + await fs.access(path); return true; } catch (error) { if (error.code === codeENOENT) { @@ -210,7 +210,7 @@ async function removeDirectory(path) { * @param {string} [proxy=null] - (Optional) The proxy URL. * @returns {Promise} */ -function downloadFile(url, filename, destination, proxy = null) { +function downloadFile(url, destination, filename, proxy = null) { const timeout = 5000; const fullPath = path.resolve(destination, filename); const file = createWriteStream(fullPath); @@ -281,4 +281,4 @@ function unarchive(tarFilePath, dest) { }); } -module.exports = { downloadRuntime }; +module.exports = { downloadRuntime, downloadFile, checkIfPathExists }; diff --git a/src/bindings/js/node/tests/unit/basic.test.js b/src/bindings/js/node/tests/unit/basic.test.js index e7447b3c863655..4b4913fb52b7d2 100644 --- a/src/bindings/js/node/tests/unit/basic.test.js +++ b/src/bindings/js/node/tests/unit/basic.test.js @@ -4,78 +4,83 @@ const { addon: ov } = require('../..'); const assert = require('assert'); -const { describe, it } = require('node:test'); -const { getModelPath } = require('./utils.js'); +const { describe, it, before } = require('node:test'); +const { testModels, getModelPath, isModelAvailable } = require('./utils.js'); -const testXml = getModelPath().xml; -const core = new ov.Core(); -const model = core.readModelSync(testXml); -const compiledModel = core.compileModelSync(model, 'CPU'); -const modelLike = [[model], - [compiledModel]]; +describe('ov basic tests.', () => { -it('Core.getAvailableDevices()', () => { - const devices = core.getAvailableDevices(); - - assert.ok(devices.includes('CPU')); -}); - -describe('Core.getVersions()', () => { - - it('getVersions(validDeviceName: string)', () => { - const deviceVersion = core.getVersions('CPU'); - assert.strictEqual(typeof deviceVersion, 'object'); - assert.strictEqual(typeof deviceVersion.CPU, 'object'); - assert.strictEqual(typeof deviceVersion.CPU.buildNumber, 'string'); - assert.strictEqual(typeof deviceVersion.CPU.description, 'string'); + before(async () => { + await isModelAvailable(testModels.testModelFP32); }); - it('getVersions() throws if no arguments are passed into the function', () => { - assert.throws( - () => core.getVersions(), - { message: 'getVersions() method expects 1 argument of string type.' } - ); - }); + const testXml = getModelPath().xml; + const core = new ov.Core(); + const model = core.readModelSync(testXml); + const compiledModel = core.compileModelSync(model, 'CPU'); + const modelLike = [[model], + [compiledModel]]; - it('getVersions() throws if non string coercable arguments are passed into the function', () => { - assert.throws( - () => core.getVersions({ deviceName: 'CPU' }), - { message: 'The argument in getVersions() method must be a string or convertible to a string.' } - ); - }); + it('Core.getAvailableDevices()', () => { + const devices = core.getAvailableDevices(); -}); + assert.ok(devices.includes('CPU')); + }); + describe('Core.getVersions()', () => { -it('CompiledModel type', () => { - assert.ok(compiledModel instanceof ov.CompiledModel); -}); + it('getVersions(validDeviceName: string)', () => { + const deviceVersion = core.getVersions('CPU'); + assert.strictEqual(typeof deviceVersion, 'object'); + assert.strictEqual(typeof deviceVersion.CPU, 'object'); + assert.strictEqual(typeof deviceVersion.CPU.buildNumber, 'string'); + assert.strictEqual(typeof deviceVersion.CPU.description, 'string'); + }); -it('compileModel.createInferRequest()', () => { - const ir = compiledModel.createInferRequest(); - assert.ok(ir instanceof ov.InferRequest); -}); + it('getVersions() throws if no arguments are passed into the function', () => { + assert.throws( + () => core.getVersions(), + { message: 'getVersions() method expects 1 argument of string type.' } + ); + }); -describe('Core.compileModelSync()', () => { - const tput = { 'PERFORMANCE_HINT': 'THROUGHPUT' }; + it('getVersions() throws if non string coercable arguments are passed into the function', () => { + assert.throws( + () => core.getVersions({ deviceName: 'CPU' }), + { message: 'The argument in getVersions() method must be a string or convertible to a string.' } + ); + }); - it('compileModelSync(model:Model, deviceName: string, config: {}) ', () => { - const cm = core.compileModelSync(model, 'CPU', tput); - assert.deepStrictEqual(cm.output(0).shape, [1, 10]); }); - it('compileModelSync(model:model_path, deviceName: string, config: {}) ', () => { - const cm = core.compileModelSync(testXml, 'CPU', tput); - assert.equal(cm.inputs.length, 1); + it('CompiledModel type', () => { + assert.ok(compiledModel instanceof ov.CompiledModel); }); - it('compileModelSync(model:model_path, deviceName: string) ', () => { - const cm = core.compileModelSync(testXml, 'CPU'); - assert.deepStrictEqual(cm.output(0).shape, [1, 10]); + it('compileModel.createInferRequest()', () => { + const ir = compiledModel.createInferRequest(); + assert.ok(ir instanceof ov.InferRequest); }); - it('compileModelSync(model, device, config) throws when config is a string', () => { - const expectedMsg = ("'compileModelSync' method called with incorrect parameters.\n" + + describe('Core.compileModelSync()', () => { + const tput = { 'PERFORMANCE_HINT': 'THROUGHPUT' }; + + it('compileModelSync(model:Model, deviceName: string, config: {}) ', () => { + const cm = core.compileModelSync(model, 'CPU', tput); + assert.deepStrictEqual(cm.output(0).shape, [1, 10]); + }); + + it('compileModelSync(model:model_path, deviceName: string, config: {}) ', () => { + const cm = core.compileModelSync(testXml, 'CPU', tput); + assert.equal(cm.inputs.length, 1); + }); + + it('compileModelSync(model:model_path, deviceName: string) ', () => { + const cm = core.compileModelSync(testXml, 'CPU'); + assert.deepStrictEqual(cm.output(0).shape, [1, 10]); + }); + + it('compileModelSync(model, device, config) throws when config is a string', () => { + const expectedMsg = ('\'compileModelSync\' method called with incorrect parameters.\n' + 'Provided signature: (object, string, string) \n' + 'Allowed signatures:\n' + '- (string, string)\n' + @@ -83,21 +88,21 @@ describe('Core.compileModelSync()', () => { '- (string, string, object)\n' + '- (Model, string, object)\n').replace(/[()]/g, '\\$&'); - assert.throws( - () => core.compileModelSync(model, 'CPU', 'string'), - new RegExp(expectedMsg), - ); - }); + assert.throws( + () => core.compileModelSync(model, 'CPU', 'string'), + new RegExp(expectedMsg), + ); + }); - it('compileModelSync(model, device, config) throws when config value is not a string', () => { - assert.throws( - () => core.compileModelSync(model, 'CPU', { 'PERFORMANCE_HINT': tput }), - /Cannot convert to ov::Any/ - ); - }); + it('compileModelSync(model, device, config) throws when config value is not a string', () => { + assert.throws( + () => core.compileModelSync(model, 'CPU', { 'PERFORMANCE_HINT': tput }), + /Cannot convert to ov::Any/ + ); + }); - it('compileModelSync(model) throws if the number of arguments is invalid', () => { - const expectedMsg = ("'compileModelSync' method called with incorrect parameters.\n" + + it('compileModelSync(model) throws if the number of arguments is invalid', () => { + const expectedMsg = ('\'compileModelSync\' method called with incorrect parameters.\n' + 'Provided signature: (object) \n' + 'Allowed signatures:\n' + '- (string, string)\n' + @@ -105,228 +110,230 @@ describe('Core.compileModelSync()', () => { '- (string, string, object)\n' + '- (Model, string, object)\n').replace(/[()]/g, '\\$&'); - assert.throws( - () => core.compileModelSync(model), - new RegExp(expectedMsg), - ); - }); -}); - -describe('Core.compileModel()', () => { - const tput = { 'PERFORMANCE_HINT': 'THROUGHPUT' }; - - it('compileModel(model:Model, deviceName: string, config: {}) ', () => { - core.compileModel(model, 'CPU', tput).then(cm => { - assert.deepStrictEqual(cm.output(0).shape, [1, 10]); + assert.throws( + () => core.compileModelSync(model), + new RegExp(expectedMsg), + ); }); - }); - it('compileModel(model:model_path, deviceName: string, config: {}) ', () => { - core.compileModel(testXml, 'CPU', tput).then(cm => { - assert.equal(cm.inputs.length, 1); - }); + describe('Core.compileModel()', () => { + const tput = { 'PERFORMANCE_HINT': 'THROUGHPUT' }; - }); + it('compileModel(model:Model, deviceName: string, config: {}) ', () => { + core.compileModel(model, 'CPU', tput).then(cm => { + assert.deepStrictEqual(cm.output(0).shape, [1, 10]); + }); - it('compileModel(model:model_path, deviceName: string) ', () => { - core.compileModel(testXml, 'CPU').then(cm => { - assert.deepStrictEqual(cm.output(0).shape, [1, 10]); }); - }); - - it('compileModel(model, device, config) throws when config isn\'t an object', () => { - assert.throws( - () => core.compileModel(model, 'CPU', 'string').then(), - "Argument #3 must be an Object." - ); - }); - - it('compileModel(model, device, config) throws when config value is not a string', () => { - assert.throws( - () => core.compileModel(model, 'CPU', { 'PERFORMANCE_HINT': tput }).then(), - /Cannot convert to ov::Any/ - ); - }); - - it('compileModel(model) throws if the number of arguments is invalid', () => { - assert.throws( - () => core.compileModel(model).then(), - /Invalid number of arguments/ - ); - }); - -}); + it('compileModel(model:model_path, deviceName: string, config: {}) ', () => { + core.compileModel(testXml, 'CPU', tput).then(cm => { + assert.equal(cm.inputs.length, 1); + }); -describe('Output class', () => { + }); - it('Output type', () => { - assert.ok(model.output() instanceof ov.Output); - }); + it('compileModel(model:model_path, deviceName: string) ', () => { + core.compileModel(testXml, 'CPU').then(cm => { + assert.deepStrictEqual(cm.output(0).shape, [1, 10]); + }); - it('ConstOutput type', () => { - assert.ok(compiledModel.output() instanceof ov.ConstOutput); - }); + }); - modelLike.forEach(([obj]) => { - it('Output getters and properties', () => { - assert.strictEqual(obj.outputs.length, 1); - // tests for an obj with one output - assert.strictEqual(obj.output().toString(), 'fc_out'); - assert.strictEqual(obj.output(0).toString(), 'fc_out'); - assert.strictEqual(obj.output('fc_out').toString(), 'fc_out'); - assert.deepStrictEqual(obj.output(0).shape, [1, 10]); - assert.deepStrictEqual(obj.output(0).getShape(), [1, 10]); - assert.strictEqual(obj.output().getAnyName(), 'fc_out'); - assert.strictEqual(obj.output().anyName, 'fc_out'); + it('compileModel(model, device, config) throws when config isn\'t an object', () => { + assert.throws( + () => core.compileModel(model, 'CPU', 'string').then(), + 'Argument #3 must be an Object.' + ); }); - }); -}); + it('compileModel(model, device, config) throws when config value is not a string', () => { + assert.throws( + () => core.compileModel(model, 'CPU', { 'PERFORMANCE_HINT': tput }).then(), + /Cannot convert to ov::Any/ + ); + }); -describe('Input class for ov::Input', () => { + it('compileModel(model) throws if the number of arguments is invalid', () => { + assert.throws( + () => core.compileModel(model).then(), + /Invalid number of arguments/ + ); + }); - it('Output type', () => { - assert.ok(model.input() instanceof ov.Output); }); - it('ConstOutput type', () => { - assert.ok(compiledModel.input() instanceof ov.ConstOutput); - }); + describe('Output class', () => { - modelLike.forEach(([obj]) => { - it('input() is typeof object', () => { - assert.strictEqual(typeof obj.input(), 'object'); + it('Output type', () => { + assert.ok(model.output() instanceof ov.Output); }); - it('inputs property', () => { - assert.strictEqual(obj.inputs.length, 1); + it('ConstOutput type', () => { + assert.ok(compiledModel.output() instanceof ov.ConstOutput); }); - it('input().toString()', () => { - assert.strictEqual(obj.input().toString(), 'data'); + modelLike.forEach(([obj]) => { + it('Output getters and properties', () => { + assert.strictEqual(obj.outputs.length, 1); + // tests for an obj with one output + assert.strictEqual(obj.output().toString(), 'fc_out'); + assert.strictEqual(obj.output(0).toString(), 'fc_out'); + assert.strictEqual(obj.output('fc_out').toString(), 'fc_out'); + assert.deepStrictEqual(obj.output(0).shape, [1, 10]); + assert.deepStrictEqual(obj.output(0).getShape(), [1, 10]); + assert.strictEqual(obj.output().getAnyName(), 'fc_out'); + assert.strictEqual(obj.output().anyName, 'fc_out'); + }); }); - it('input(idx: number).ToString() method', () => { - assert.strictEqual(obj.input(0).toString(), 'data'); - }); + }); - it('input(tensorName: string).ToString() method', () => { - assert.strictEqual(obj.input('data').toString(), 'data'); - }); + describe('Input class for ov::Input', () => { - it('input().getAnyName() and anyName', () => { - assert.strictEqual(obj.input().getAnyName(), 'data'); - assert.strictEqual(obj.input().anyName, 'data'); + it('Output type', () => { + assert.ok(model.input() instanceof ov.Output); }); - it('input(idx).shape property with dimensions', () => { - assert.deepStrictEqual(obj.input(0).shape, [1, 3, 32, 32]); - assert.deepStrictEqual(obj.input(0).getShape(), [1, 3, 32, 32]); + it('ConstOutput type', () => { + assert.ok(compiledModel.input() instanceof ov.ConstOutput); }); - }); -}); + modelLike.forEach(([obj]) => { + it('input() is typeof object', () => { + assert.strictEqual(typeof obj.input(), 'object'); + }); -describe('Test exportModel()/importModel()', () => { - const userStream = compiledModel.exportModelSync(); - const epsilon = 0.5; - const tensor = Float32Array.from({ length: 3072 }, () => (Math.random() + epsilon)); - const inferRequest = compiledModel.createInferRequest(); - const res1 = inferRequest.infer([tensor]); + it('inputs property', () => { + assert.strictEqual(obj.inputs.length, 1); + }); - it('Test importModelSync(stream, device)', () => { - const newCompiled = core.importModelSync(userStream, 'CPU'); - const newInferRequest = newCompiled.createInferRequest(); - const res2 = newInferRequest.infer([tensor]); + it('input().toString()', () => { + assert.strictEqual(obj.input().toString(), 'data'); + }); - assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); - }); + it('input(idx: number).ToString() method', () => { + assert.strictEqual(obj.input(0).toString(), 'data'); + }); - it('Test importModelSync(stream, device, config)', () => { - const newCompiled = core.importModelSync(userStream, 'CPU', { 'NUM_STREAMS': 1 }); - const newInferRequest = newCompiled.createInferRequest(); - const res2 = newInferRequest.infer([tensor]); + it('input(tensorName: string).ToString() method', () => { + assert.strictEqual(obj.input('data').toString(), 'data'); + }); - assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); - }); + it('input().getAnyName() and anyName', () => { + assert.strictEqual(obj.input().getAnyName(), 'data'); + assert.strictEqual(obj.input().anyName, 'data'); + }); - it('Test importModelSync(stream, device) throws', () => { - assert.throws( - () => core.importModelSync(epsilon, 'CPU'), - /The first argument must be of type Buffer./ - ); - }); + it('input(idx).shape property with dimensions', () => { + assert.deepStrictEqual(obj.input(0).shape, [1, 3, 32, 32]); + assert.deepStrictEqual(obj.input(0).getShape(), [1, 3, 32, 32]); + }); + }); - it('Test importModelSync(stream, device) throws', () => { - assert.throws( - () => core.importModelSync(userStream, tensor), - /The second argument must be of type String./ - ); - }); - it('Test importModelSync(stream, device, config: tensor) throws', () => { - assert.throws( - () => core.importModelSync(userStream, 'CPU', tensor), - /NotFound: Unsupported property 0 by CPU plugin./ - ); }); - it('Test importModelSync(stream, device, config: string) throws', () => { - const testString = 'test'; - assert.throws( - () => core.importModelSync(userStream, 'CPU', testString), - /Passed Napi::Value must be an object./ - ); - }); + describe('Test exportModel()/importModel()', () => { + const userStream = compiledModel.exportModelSync(); + const epsilon = 0.5; + const tensor = Float32Array.from({ length: 3072 }, () => (Math.random() + epsilon)); + const inferRequest = compiledModel.createInferRequest(); + const res1 = inferRequest.infer([tensor]); - it('Test importModelSync(stream, device, config: unsupported property) \ - throws', () => { - const tmpDir = '/tmp'; - assert.throws( - () => core.importModelSync(userStream, 'CPU', { 'CACHE_DIR': tmpDir }), - /Unsupported property CACHE_DIR by CPU plugin./ - ); - }); + it('Test importModelSync(stream, device)', () => { + const newCompiled = core.importModelSync(userStream, 'CPU'); + const newInferRequest = newCompiled.createInferRequest(); + const res2 = newInferRequest.infer([tensor]); - it('Test importModel(stream, device)', () => { - core.importModel(userStream, 'CPU').then(newCompiled => { + assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); + }); + + it('Test importModelSync(stream, device, config)', () => { + const newCompiled = core.importModelSync(userStream, 'CPU', { 'NUM_STREAMS': 1 }); const newInferRequest = newCompiled.createInferRequest(); const res2 = newInferRequest.infer([tensor]); + assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); }); - }); - it('Test importModel(stream, device, config)', () => { - core.importModel(userStream, 'CPU', { 'NUM_STREAMS': 1 }).then( - newCompiled => { + it('Test importModelSync(stream, device) throws', () => { + assert.throws( + () => core.importModelSync(epsilon, 'CPU'), + /The first argument must be of type Buffer./ + ); + }); + + it('Test importModelSync(stream, device) throws', () => { + assert.throws( + () => core.importModelSync(userStream, tensor), + /The second argument must be of type String./ + ); + }); + it('Test importModelSync(stream, device, config: tensor) throws', () => { + assert.throws( + () => core.importModelSync(userStream, 'CPU', tensor), + /NotFound: Unsupported property 0 by CPU plugin./ + ); + }); + + it('Test importModelSync(stream, device, config: string) throws', () => { + const testString = 'test'; + assert.throws( + () => core.importModelSync(userStream, 'CPU', testString), + /Passed Napi::Value must be an object./ + ); + }); + + it('Test importModelSync(stream, device, config: unsupported property) \ + throws', () => { + const tmpDir = '/tmp'; + assert.throws( + () => core.importModelSync(userStream, 'CPU', { 'CACHE_DIR': tmpDir }), + /Unsupported property CACHE_DIR by CPU plugin./ + ); + }); + + it('Test importModel(stream, device)', () => { + core.importModel(userStream, 'CPU').then(newCompiled => { const newInferRequest = newCompiled.createInferRequest(); const res2 = newInferRequest.infer([tensor]); - assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); }); - }); + }); - it('Test importModel(stream, device) throws', () => { - assert.throws( - () => core.importModel(epsilon, 'CPU').then(), - /'importModel' method called with incorrect parameters./ - ); - }); + it('Test importModel(stream, device, config)', () => { + core.importModel(userStream, 'CPU', { 'NUM_STREAMS': 1 }).then( + newCompiled => { + const newInferRequest = newCompiled.createInferRequest(); + const res2 = newInferRequest.infer([tensor]); - it('Test importModel(stream, device) throws', () => { - assert.throws( - () => core.importModel(userStream, tensor).then(), - /'importModel' method called with incorrect parameters./ - ); - }); + assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); + }); + }); + + it('Test importModel(stream, device) throws', () => { + assert.throws( + () => core.importModel(epsilon, 'CPU').then(), + /'importModel' method called with incorrect parameters./ + ); + }); + + it('Test importModel(stream, device) throws', () => { + assert.throws( + () => core.importModel(userStream, tensor).then(), + /'importModel' method called with incorrect parameters./ + ); + }); + + it('Test importModel(stream, device, config: string) throws', () => { + const testString = 'test'; + assert.throws( + () => core.importModel(userStream, 'CPU', testString).then(), + /'importModel' method called with incorrect parameters./ + ); + }); - it('Test importModel(stream, device, config: string) throws', () => { - const testString = 'test'; - assert.throws( - () => core.importModel(userStream, 'CPU', testString).then(), - /'importModel' method called with incorrect parameters./ - ); }); }); diff --git a/src/bindings/js/node/tests/unit/compiled_model.test.js b/src/bindings/js/node/tests/unit/compiled_model.test.js index 6b33296131b04d..2d1169b0783e2e 100644 --- a/src/bindings/js/node/tests/unit/compiled_model.test.js +++ b/src/bindings/js/node/tests/unit/compiled_model.test.js @@ -4,17 +4,21 @@ const { addon: ov } = require('../..'); const assert = require('assert'); -const { describe, it } = require('node:test'); -const { getModelPath } = require('./utils.js'); +const { describe, it, before } = require('node:test'); +const { testModels, getModelPath, isModelAvailable } = require('./utils.js'); -const testXml = getModelPath().xml; -const core = new ov.Core(); -const properties = { - "AUTO_BATCH_TIMEOUT": '1' -}; -const compiledModel = core.compileModelSync(testXml, 'BATCH:CPU', properties); +describe('ov.CompiledModel tests', () => { -describe('setProperty() / getProperty()', () => { + before(async () => { + await isModelAvailable(testModels.testModelFP32); + }); + + const testXml = getModelPath().xml; + const core = new ov.Core(); + const properties = { + 'AUTO_BATCH_TIMEOUT': '1', + }; + const compiledModel = core.compileModelSync(testXml, 'BATCH:CPU', properties); describe('getProperty()', () => { it('returns the value of property from compiled model', () => { @@ -26,7 +30,7 @@ describe('setProperty() / getProperty()', () => { /'getProperty' method called with incorrect parameters/ ); }); - it('throws an error when called with property name that does not exists', ()=>{ + it('throws an error when called with property name that does not exists', () => { assert.throws( () => compiledModel.getProperty('PROPERTY_THAT_DOES_NOT_EXIST') ); @@ -35,10 +39,10 @@ describe('setProperty() / getProperty()', () => { describe('setProperty()', () => { it('sets a properties for compiled model', () => { - properties["AUTO_BATCH_TIMEOUT"] = '1000'; + properties['AUTO_BATCH_TIMEOUT'] = '1000'; assert.doesNotThrow(() => compiledModel.setProperty(properties)); }); - + it('throws an error when called without an object argument', () => { assert.throws( () => compiledModel.setProperty(), @@ -47,30 +51,30 @@ describe('setProperty() / getProperty()', () => { }); it('throws an error when called with wrong argument', () => { assert.throws( - () => compiledModel.setProperty(123), - /'setProperty' method called with incorrect parameters/ + () => compiledModel.setProperty(123), + /'setProperty' method called with incorrect parameters/ ); }); - + it('throws an error when called with multiple arguments', () => { assert.throws( - () => compiledModel.setProperty({"PERFORMANCE_HINT": "THROUGHPUT"}, {"NUM_STREAMS": "AUTO"}), + () => compiledModel.setProperty({'PERFORMANCE_HINT': 'THROUGHPUT'}, {'NUM_STREAMS': 'AUTO'}), /'setProperty' method called with incorrect parameters/ ); }); - + it('returns the set property of the compiled model', () => { - properties["AUTO_BATCH_TIMEOUT"] = '123'; + properties['AUTO_BATCH_TIMEOUT'] = '123'; compiledModel.setProperty(properties); assert.strictEqual(compiledModel.getProperty('AUTO_BATCH_TIMEOUT'), 123); }); - + it('retains the last set property when set multiple times', () => { - compiledModel.setProperty({"AUTO_BATCH_TIMEOUT": '321'}); + compiledModel.setProperty({'AUTO_BATCH_TIMEOUT': '321'}); compiledModel.setProperty({'AUTO_BATCH_TIMEOUT': '132'}); assert.strictEqual(compiledModel.getProperty('AUTO_BATCH_TIMEOUT'), 132); }); - + it('allows to pass empty object', () => { assert.doesNotThrow(() => compiledModel.setProperty({})); }); diff --git a/src/bindings/js/node/tests/unit/core.test.js b/src/bindings/js/node/tests/unit/core.test.js index 2c70428b66b7c1..69d8720d97a380 100644 --- a/src/bindings/js/node/tests/unit/core.test.js +++ b/src/bindings/js/node/tests/unit/core.test.js @@ -6,64 +6,67 @@ const { addon: ov } = require('../..'); const assert = require('assert'); const { describe, it } = require('node:test'); -const core = new ov.Core(); +describe('ov.Core tests', () => { -it('Core.setProperty()', () => { - const tmpDir = '/tmp'; + const core = new ov.Core(); - core.setProperty({ 'CACHE_DIR': tmpDir }); + it('Core.setProperty()', () => { + const tmpDir = '/tmp'; - const cacheDir = core.getProperty('CACHE_DIR'); + core.setProperty({ 'CACHE_DIR': tmpDir }); - assert.equal(cacheDir, tmpDir); -}); + const cacheDir = core.getProperty('CACHE_DIR'); -it('Core.setProperty(\'CPU\')', () => { - const tmpDir = '/tmp'; + assert.equal(cacheDir, tmpDir); + }); - core.setProperty('CPU', { 'CACHE_DIR': tmpDir }); + it('Core.setProperty(\'CPU\')', () => { + const tmpDir = '/tmp'; - const cacheDir = core.getProperty('CPU', 'CACHE_DIR'); + core.setProperty('CPU', { 'CACHE_DIR': tmpDir }); - assert.equal(cacheDir, tmpDir); -}); + const cacheDir = core.getProperty('CPU', 'CACHE_DIR'); -it('Core.getProperty(\'CPU\', \'SUPPORTED_PROPERTIES\') is Array', () => { - const supportedPropertiesArray = core.getProperty('CPU', 'SUPPORTED_PROPERTIES'); + assert.equal(cacheDir, tmpDir); + }); - assert.ok(Array.isArray(supportedPropertiesArray)); -}); + it('Core.getProperty(\'CPU\', \'SUPPORTED_PROPERTIES\') is Array', () => { + const supportedPropertiesArray = core.getProperty('CPU', 'SUPPORTED_PROPERTIES'); -it('Core.setProperty(\'CPU\', { \'NUM_STREAMS\': 5 })', () => { - const streams = 5; + assert.ok(Array.isArray(supportedPropertiesArray)); + }); - core.setProperty('CPU', { 'NUM_STREAMS': streams }); - const result = core.getProperty('CPU', 'NUM_STREAMS'); + it('Core.setProperty(\'CPU\', { \'NUM_STREAMS\': 5 })', () => { + const streams = 5; - assert.equal(result, streams); -}); + core.setProperty('CPU', { 'NUM_STREAMS': streams }); + const result = core.getProperty('CPU', 'NUM_STREAMS'); -it('Core.setProperty(\'CPU\', { \'INFERENCE_NUM_THREADS\': 3 })', () => { - const threads = 3; + assert.equal(result, streams); + }); - core.setProperty('CPU', { 'INFERENCE_NUM_THREADS': threads }); - const result = core.getProperty('CPU', 'INFERENCE_NUM_THREADS'); + it('Core.setProperty(\'CPU\', { \'INFERENCE_NUM_THREADS\': 3 })', () => { + const threads = 3; - assert.equal(result, threads); -}); + core.setProperty('CPU', { 'INFERENCE_NUM_THREADS': threads }); + const result = core.getProperty('CPU', 'INFERENCE_NUM_THREADS'); -it('Core.addExtension() with empty parameters', () => { - assert.throws( - () => core.addExtension(), - /addExtension method applies one argument of string type/ - ); -}); + assert.equal(result, threads); + }); + + it('Core.addExtension() with empty parameters', () => { + assert.throws( + () => core.addExtension(), + /addExtension method applies one argument of string type/ + ); + }); -it('Core.addExtension(\'not_exists\') with non-existed library', () => { - const notExistsExt = 'not_exists'; + it('Core.addExtension(\'not_exists\') with non-existed library', () => { + const notExistsExt = 'not_exists'; - assert.throws( - () => core.addExtension(notExistsExt), - /Cannot load library 'not_exists'/ - ); + assert.throws( + () => core.addExtension(notExistsExt), + /Cannot load library 'not_exists'/ + ); + }); }); diff --git a/src/bindings/js/node/tests/unit/infer_request.test.js b/src/bindings/js/node/tests/unit/infer_request.test.js index bdc54fc4f4d086..8dc16cd195430a 100644 --- a/src/bindings/js/node/tests/unit/infer_request.test.js +++ b/src/bindings/js/node/tests/unit/infer_request.test.js @@ -4,277 +4,286 @@ const { addon: ov } = require('../..'); const assert = require('assert'); -const { describe, it } = require('node:test'); -const { getModelPath } = require('./utils.js'); +const { describe, it, before } = require('node:test'); +const { testModels, isModelAvailable, getModelPath } = require('./utils.js'); const epsilon = 0.5; // To avoid very small numbers const testXml = getModelPath().xml; -const core = new ov.Core(); -const model = core.readModelSync(testXml); -const compiledModel = core.compileModelSync(model, 'CPU'); - -const inferRequest = compiledModel.createInferRequest(); -const inferRequestAsync = compiledModel.createInferRequest(); - -const tensorData = Float32Array.from({ length: 3072 }, () => (Math.random() + epsilon)); -const tensor = new ov.Tensor( - ov.element.f32, - [1, 3, 32, 32], - tensorData, -); -const resTensor = new ov.Tensor( - ov.element.f32, - [1, 10], - tensorData.slice(-10), -); - -const tensorLike = [[tensor], - [tensorData]]; - -describe('InferRequest', () => { - - tensorLike.forEach(([tl]) => { - const result = inferRequest.infer({ data: tl }); - const label = tl instanceof Float32Array ? 'TypedArray[]' : 'Tensor[]'; - it(`Test infer(inputData: { [inputName: string]: ${label} })`, () => { - assert.deepStrictEqual(Object.keys(result), ['fc_out']); - assert.deepStrictEqual(result['fc_out'].data.length, 10); - }); - }); - tensorLike.forEach(([tl]) => { - const result = inferRequest.infer([tl]); - const label = tl instanceof Float32Array ? 'TypedArray[]' : 'Tensor[]'; - it(`Test infer(inputData: ${label})`, () => { - assert.deepStrictEqual(Object.keys(result), ['fc_out']); - assert.deepStrictEqual(result['fc_out'].data.length, 10); - }); +describe('ov.InferRequest tests', () => { + before(async () => { + await isModelAvailable(testModels.testModelFP32); }); - it('Test infer(TypedArray) throws', () => { - assert.throws( - () => inferRequest.infer(tensorData), - {message: /TypedArray cannot be passed directly into infer\(\) method./}); - }); + const core = new ov.Core(); + const model = core.readModelSync(testXml); + const compiledModel = core.compileModelSync(model, 'CPU'); - const buffer = new ArrayBuffer(tensorData.length); - const inputMessagePairs = [ - ['string', 'Cannot create a tensor from the passed Napi::Value.'], - [tensorData.slice(-10), 'Memory allocated using shape and element::type mismatch passed data\'s size'], - [new Float32Array(buffer, 4), 'TypedArray.byteOffset has to be equal to zero.'], - [{}, /Invalid argument/], // Test for object that is not Tensor - ]; + const inferRequest = compiledModel.createInferRequest(); + const inferRequestAsync = compiledModel.createInferRequest(); + + const tensorData = Float32Array.from({ length: 3072 }, () => (Math.random() + epsilon)); + const tensor = new ov.Tensor( + ov.element.f32, + [1, 3, 32, 32], + tensorData, + ); + const resTensor = new ov.Tensor( + ov.element.f32, + [1, 10], + tensorData.slice(-10), + ); + + const tensorLike = [[tensor], + [tensorData]]; + + describe('InferRequest', () => { + + tensorLike.forEach(([tl]) => { + const result = inferRequest.infer({ data: tl }); + const label = tl instanceof Float32Array ? 'TypedArray[]' : 'Tensor[]'; + it(`Test infer(inputData: { [inputName: string]: ${label} })`, () => { + assert.deepStrictEqual(Object.keys(result), ['fc_out']); + assert.deepStrictEqual(result['fc_out'].data.length, 10); + }); + }); + + tensorLike.forEach(([tl]) => { + const result = inferRequest.infer([tl]); + const label = tl instanceof Float32Array ? 'TypedArray[]' : 'Tensor[]'; + it(`Test infer(inputData: ${label})`, () => { + assert.deepStrictEqual(Object.keys(result), ['fc_out']); + assert.deepStrictEqual(result['fc_out'].data.length, 10); + }); - inputMessagePairs.forEach( ([tl, msg]) => { - it(`Test infer([data]) throws ${msg}`, () => { - assert.throws( - () => inferRequest.infer([tl]), - {message: new RegExp(msg)}); }); - it(`Test infer({ data: tl}) throws ${msg}`, () => { + + it('Test infer(TypedArray) throws', () => { assert.throws( - () => inferRequest.infer({data: tl}), - {message: new RegExp(msg)}); + () => inferRequest.infer(tensorData), + {message: /TypedArray cannot be passed directly into infer\(\) method./}); }); - }); - it('Test inferAsync(inputData: { [inputName: string]: Tensor })', () => { - inferRequestAsync.inferAsync({ data: tensor }).then(result => { - assert.ok(result['fc_out'] instanceof ov.Tensor); - assert.deepStrictEqual(Object.keys(result), ['fc_out']); - assert.deepStrictEqual(result['fc_out'].data.length, 10);} - ); - }); + const buffer = new ArrayBuffer(tensorData.length); + const inputMessagePairs = [ + ['string', 'Cannot create a tensor from the passed Napi::Value.'], + [tensorData.slice(-10), 'Memory allocated using shape and element::type mismatch passed data\'s size'], + [new Float32Array(buffer, 4), 'TypedArray.byteOffset has to be equal to zero.'], + [{}, /Invalid argument/], // Test for object that is not Tensor + ]; + + inputMessagePairs.forEach( ([tl, msg]) => { + it(`Test infer([data]) throws ${msg}`, () => { + assert.throws( + () => inferRequest.infer([tl]), + {message: new RegExp(msg)}); + }); + it(`Test infer({ data: tl}) throws ${msg}`, () => { + assert.throws( + () => inferRequest.infer({data: tl}), + {message: new RegExp(msg)}); + }); + }); - it('Test inferAsync(inputData: Tensor[])', () => { - inferRequestAsync.inferAsync([ tensor ]).then(result => { - assert.ok(result['fc_out'] instanceof ov.Tensor); - assert.deepStrictEqual(Object.keys(result), ['fc_out']); - assert.deepStrictEqual(result['fc_out'].data.length, 10); + it('Test inferAsync(inputData: { [inputName: string]: Tensor })', () => { + inferRequestAsync.inferAsync({ data: tensor }).then(result => { + assert.ok(result['fc_out'] instanceof ov.Tensor); + assert.deepStrictEqual(Object.keys(result), ['fc_out']); + assert.deepStrictEqual(result['fc_out'].data.length, 10);} + ); }); - }); - it('Test inferAsync([data]) throws: Cannot create a tensor from the passed Napi::Value.', () => { - assert.throws( - () => inferRequestAsync.inferAsync(['string']).then(), - /Cannot create a tensor from the passed Napi::Value./ - ); - }); + it('Test inferAsync(inputData: Tensor[])', () => { + inferRequestAsync.inferAsync([ tensor ]).then(result => { + assert.ok(result['fc_out'] instanceof ov.Tensor); + assert.deepStrictEqual(Object.keys(result), ['fc_out']); + assert.deepStrictEqual(result['fc_out'].data.length, 10); + }); + }); - it('Test inferAsync({ data: "string"}) throws: Cannot create a tensor from the passed Napi::Value.', () => { - assert.throws( - () => inferRequestAsync.inferAsync({data: 'string'}).then(), - /Cannot create a tensor from the passed Napi::Value./ - ); - }); + it('Test inferAsync([data]) throws: Cannot create a tensor from the passed Napi::Value.', () => { + assert.throws( + () => inferRequestAsync.inferAsync(['string']).then(), + /Cannot create a tensor from the passed Napi::Value./ + ); + }); - it('Test setInputTensor(tensor)', () => { - inferRequest.setInputTensor(tensor); - const t1 = inferRequest.getInputTensor(); - assert.deepStrictEqual(tensor.data[0], t1.data[0]); - }); + it('Test inferAsync({ data: "string"}) throws: Cannot create a tensor from the passed Napi::Value.', () => { + assert.throws( + () => inferRequestAsync.inferAsync({data: 'string'}).then(), + /Cannot create a tensor from the passed Napi::Value./ + ); + }); - it('Test setInputTensor(object) throws when passed object is not a Tensor.', () => { - assert.throws( - () => inferRequest.setInputTensor({}), - {message: /Argument #[0-9]+ must be a Tensor./} - ); - }); + it('Test setInputTensor(tensor)', () => { + inferRequest.setInputTensor(tensor); + const t1 = inferRequest.getInputTensor(); + assert.deepStrictEqual(tensor.data[0], t1.data[0]); + }); - it('Test setInputTensor(idx, tensor)', () => { - inferRequest.setInputTensor(0, tensor); - const t1 = inferRequest.getInputTensor(); - assert.deepStrictEqual(tensor.data[0], t1.data[0]); - }); + it('Test setInputTensor(object) throws when passed object is not a Tensor.', () => { + assert.throws( + () => inferRequest.setInputTensor({}), + {message: /Argument #[0-9]+ must be a Tensor./} + ); + }); - it('Test setInputTensor(idx, tensor) throws', () => { - const testIdx = 10; - assert.throws ( - () => inferRequest.setInputTensor(testIdx, tensor), - {message: /Input port for index [0-9]+ was not found!/} - ); - }); + it('Test setInputTensor(idx, tensor)', () => { + inferRequest.setInputTensor(0, tensor); + const t1 = inferRequest.getInputTensor(); + assert.deepStrictEqual(tensor.data[0], t1.data[0]); + }); - it('Test setInputTensor(idx, object) throws when passed object is not a Tensor.', () => { - assert.throws( - () => inferRequest.setInputTensor(0, {}), - {message: /Argument #[0-9]+ must be a Tensor./} - ); - }); + it('Test setInputTensor(idx, tensor) throws', () => { + const testIdx = 10; + assert.throws ( + () => inferRequest.setInputTensor(testIdx, tensor), + {message: /Input port for index [0-9]+ was not found!/} + ); + }); - it('Test setInputTensor(tensor, tensor) throws', () => { - assert.throws( - () => inferRequest.setInputTensor(resTensor, tensor), - {message: / invalid argument./} - ); - }); + it('Test setInputTensor(idx, object) throws when passed object is not a Tensor.', () => { + assert.throws( + () => inferRequest.setInputTensor(0, {}), + {message: /Argument #[0-9]+ must be a Tensor./} + ); + }); - it('Test setOutputTensor(tensor)', () => { - inferRequest.setOutputTensor(resTensor); - const res2 = inferRequest.getOutputTensor(); - assert.deepStrictEqual(resTensor.data[0], res2.data[0]); - }); + it('Test setInputTensor(tensor, tensor) throws', () => { + assert.throws( + () => inferRequest.setInputTensor(resTensor, tensor), + {message: / invalid argument./} + ); + }); - it('Test setOutputTensor(object) throws when passed object is not a Tensor.', () => { - assert.throws( - () => inferRequest.setOutputTensor({}), - {message: /Argument #[0-9]+ must be a Tensor./} - ); - }); + it('Test setOutputTensor(tensor)', () => { + inferRequest.setOutputTensor(resTensor); + const res2 = inferRequest.getOutputTensor(); + assert.deepStrictEqual(resTensor.data[0], res2.data[0]); + }); - it('Test setOutputTensor(idx, tensor) throws', () => { - const testIdx = 10; - assert.throws ( - () => inferRequest.setOutputTensor(testIdx, tensor), - {message: /Output port for index [0-9]+ was not found!/} - ); - }); + it('Test setOutputTensor(object) throws when passed object is not a Tensor.', () => { + assert.throws( + () => inferRequest.setOutputTensor({}), + {message: /Argument #[0-9]+ must be a Tensor./} + ); + }); - it('Test setOutputTensor(idx, tensor)', () => { - inferRequest.setOutputTensor(0, resTensor); - const res2 = inferRequest.getOutputTensor(); - assert.deepStrictEqual(resTensor.data[0], res2.data[0]); - }); + it('Test setOutputTensor(idx, tensor) throws', () => { + const testIdx = 10; + assert.throws ( + () => inferRequest.setOutputTensor(testIdx, tensor), + {message: /Output port for index [0-9]+ was not found!/} + ); + }); - it('Test setOutputTensor(idx, tensor) throws when passed object is not a Tensor.', () => { - assert.throws( - () => inferRequest.setOutputTensor(0, {}), - {message: /Argument #[0-9]+ must be a Tensor./} - ); - }); + it('Test setOutputTensor(idx, tensor)', () => { + inferRequest.setOutputTensor(0, resTensor); + const res2 = inferRequest.getOutputTensor(); + assert.deepStrictEqual(resTensor.data[0], res2.data[0]); + }); - it('Test setOutputTensor() - pass two tensors', () => { - assert.throws( - () => inferRequest.setOutputTensor(resTensor, tensor), - {message: / invalid argument./}); - }); + it('Test setOutputTensor(idx, tensor) throws when passed object is not a Tensor.', () => { + assert.throws( + () => inferRequest.setOutputTensor(0, {}), + {message: /Argument #[0-9]+ must be a Tensor./} + ); + }); - it('Test setTensor(string, tensor)', () => { - inferRequest.setTensor('fc_out', resTensor); - const res2 = inferRequest.getTensor('fc_out'); - assert.ok(res2 instanceof ov.Tensor); - assert.deepStrictEqual(resTensor.data[0], res2.data[0]); - }); + it('Test setOutputTensor() - pass two tensors', () => { + assert.throws( + () => inferRequest.setOutputTensor(resTensor, tensor), + {message: / invalid argument./}); + }); - it('Test setTensor(string, object) - throws', () => { - const testName = 'testName'; - assert.throws( - () => inferRequest.setTensor(testName, tensor), - {message: /Port for tensor name testName was not found./}); - }); + it('Test setTensor(string, tensor)', () => { + inferRequest.setTensor('fc_out', resTensor); + const res2 = inferRequest.getTensor('fc_out'); + assert.ok(res2 instanceof ov.Tensor); + assert.deepStrictEqual(resTensor.data[0], res2.data[0]); + }); - it('Test setTensor(string, object) - throws', () => { - assert.throws( - () => inferRequest.setTensor('fc_out', {}), - {message: /Argument #[0-9]+ must be a Tensor./}); - }); + it('Test setTensor(string, object) - throws', () => { + const testName = 'testName'; + assert.throws( + () => inferRequest.setTensor(testName, tensor), + {message: /Port for tensor name testName was not found./}); + }); - it('Test setTensor(string, tensor) - pass one arg', () => { - assert.throws( - () => inferRequest.setTensor('fc_out'), - {message: / invalid argument./} - ); - }); + it('Test setTensor(string, object) - throws', () => { + assert.throws( + () => inferRequest.setTensor('fc_out', {}), + {message: /Argument #[0-9]+ must be a Tensor./}); + }); - it('Test setTensor(string, tensor) - pass args in wrong order', () => { - assert.throws( - () => inferRequest.setTensor(resTensor, 'fc_out'), - {message: / invalid argument./} - ); - }); + it('Test setTensor(string, tensor) - pass one arg', () => { + assert.throws( + () => inferRequest.setTensor('fc_out'), + {message: / invalid argument./} + ); + }); - it('Test setTensor(string, tensor) - pass number as first arg', () => { - assert.throws( - () => inferRequest.setTensor(123, 'fc_out'), - {message: / invalid argument/} - ); - }); + it('Test setTensor(string, tensor) - pass args in wrong order', () => { + assert.throws( + () => inferRequest.setTensor(resTensor, 'fc_out'), + {message: / invalid argument./} + ); + }); - const irGetters = compiledModel.createInferRequest(); - irGetters.setInputTensor(tensor); - irGetters.infer(); + it('Test setTensor(string, tensor) - pass number as first arg', () => { + assert.throws( + () => inferRequest.setTensor(123, 'fc_out'), + {message: / invalid argument/} + ); + }); - it('Test getTensor(tensorName)', () => { - const t1 = irGetters.getTensor('data'); - assert.ok(t1 instanceof ov.Tensor); - assert.deepStrictEqual(tensor.data[0], t1.data[0]); - }); + const irGetters = compiledModel.createInferRequest(); + irGetters.setInputTensor(tensor); + irGetters.infer(); - it('Test getTensor(Output)', () => { - const input = irGetters.getCompiledModel().input(); - const t1 = irGetters.getTensor(input); - assert.ok(t1 instanceof ov.Tensor); - assert.deepStrictEqual(tensor.data[0], t1.data[0]); - }); + it('Test getTensor(tensorName)', () => { + const t1 = irGetters.getTensor('data'); + assert.ok(t1 instanceof ov.Tensor); + assert.deepStrictEqual(tensor.data[0], t1.data[0]); + }); - it('Test getInputTensor()', () => { - const t1 = irGetters.getInputTensor(); - assert.ok(t1 instanceof ov.Tensor); - assert.deepStrictEqual(tensor.data[0], t1.data[0]); - }); + it('Test getTensor(Output)', () => { + const input = irGetters.getCompiledModel().input(); + const t1 = irGetters.getTensor(input); + assert.ok(t1 instanceof ov.Tensor); + assert.deepStrictEqual(tensor.data[0], t1.data[0]); + }); - it('Test getInputTensor(idx)', () => { - const t1 = irGetters.getInputTensor(0); - assert.ok(t1 instanceof ov.Tensor); - assert.deepStrictEqual(tensor.data[0], t1.data[0]); - }); + it('Test getInputTensor()', () => { + const t1 = irGetters.getInputTensor(); + assert.ok(t1 instanceof ov.Tensor); + assert.deepStrictEqual(tensor.data[0], t1.data[0]); + }); - it('Test getOutputTensor(idx?)', () => { - const res1 = irGetters.getOutputTensor(); - const res2 = irGetters.getOutputTensor(0); - assert.ok(res1 instanceof ov.Tensor); - assert.ok(res2 instanceof ov.Tensor); - assert.deepStrictEqual(res1.data[0], res2.data[0]); - }); + it('Test getInputTensor(idx)', () => { + const t1 = irGetters.getInputTensor(0); + assert.ok(t1 instanceof ov.Tensor); + assert.deepStrictEqual(tensor.data[0], t1.data[0]); + }); + + it('Test getOutputTensor(idx?)', () => { + const res1 = irGetters.getOutputTensor(); + const res2 = irGetters.getOutputTensor(0); + assert.ok(res1 instanceof ov.Tensor); + assert.ok(res2 instanceof ov.Tensor); + assert.deepStrictEqual(res1.data[0], res2.data[0]); + }); - it('Test getCompiledModel()', () => { - const ir = compiledModel.createInferRequest(); - const cm = ir.getCompiledModel(); - assert.ok(cm instanceof ov.CompiledModel); - const ir2 = cm.createInferRequest(); - const res2 = ir2.infer([tensorData]); - const res1 = ir.infer([tensorData]); - assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); + it('Test getCompiledModel()', () => { + const ir = compiledModel.createInferRequest(); + const cm = ir.getCompiledModel(); + assert.ok(cm instanceof ov.CompiledModel); + const ir2 = cm.createInferRequest(); + const res2 = ir2.infer([tensorData]); + const res1 = ir.infer([tensorData]); + assert.deepStrictEqual(res1['fc_out'].data[0], res2['fc_out'].data[0]); + }); }); + }); diff --git a/src/bindings/js/node/tests/unit/model.test.js b/src/bindings/js/node/tests/unit/model.test.js index 7728f13a25dce9..e374c0b3ab3cad 100644 --- a/src/bindings/js/node/tests/unit/model.test.js +++ b/src/bindings/js/node/tests/unit/model.test.js @@ -4,45 +4,51 @@ const { addon: ov } = require('../..'); const assert = require('assert'); -const { describe, it } = require('node:test'); -const { getModelPath } = require('./utils.js'); -const testXml = getModelPath().xml; -const core = new ov.Core(); -const model = core.readModelSync(testXml); -const clonedModel = model.clone(); - -describe('Node.js Model.isDynamic()', () => { - it('should return a boolean value indicating if the model is dynamic', () => { - const result = model.isDynamic(); - assert.strictEqual( - typeof result, - 'boolean', - 'isDynamic() should return a boolean value' - ); - }); +const { describe, it, before } = require('node:test'); +const { testModels, getModelPath, isModelAvailable } = require('./utils.js'); + +describe('ov.Model tests', () => { - it('should not accept any arguments', () => { - assert.throws( - () => { - model.isDynamic('unexpected argument'); - }, - /^Error: isDynamic\(\) does not accept any arguments\.$/, - 'Expected isDynamic to throw an error when called with arguments' - ); + before(async () => { + await isModelAvailable(testModels.testModelFP32); }); - it('returns false for a static model', () => { - const expectedStatus = false; - assert.strictEqual( - model.isDynamic(), - expectedStatus, - 'Expected isDynamic to return false for a static model' - ); + const testXml = getModelPath().xml; + const core = new ov.Core(); + const model = core.readModelSync(testXml); + const clonedModel = model.clone(); + + describe('Model.isDynamic()', () => { + it('should return a boolean value indicating if the model is dynamic', () => { + const result = model.isDynamic(); + assert.strictEqual( + typeof result, + 'boolean', + 'isDynamic() should return a boolean value' + ); + }); + + it('should not accept any arguments', () => { + assert.throws( + () => { + model.isDynamic('unexpected argument'); + }, + /^Error: isDynamic\(\) does not accept any arguments\.$/, + 'Expected isDynamic to throw an error when called with arguments' + ); + }); + + it('returns false for a static model', () => { + const expectedStatus = false; + assert.strictEqual( + model.isDynamic(), + expectedStatus, + 'Expected isDynamic to return false for a static model' + ); + }); }); -}); -describe('Node.js getFriendlyName() / setFriendlyName()', () => { - describe('getFriendlyName()', () => { + describe('Model.getFriendlyName()', () => { it('returns the unique name of the model if no friendly name is set', () => { const expectedName = 'test_model'; assert.strictEqual(model.getFriendlyName(), expectedName); @@ -54,7 +60,7 @@ describe('Node.js getFriendlyName() / setFriendlyName()', () => { ); }); }); - describe('setFriendlyName()', () => { + describe('Model.setFriendlyName()', () => { it('sets a friendly name for the model', () => { assert.doesNotThrow(() => model.setFriendlyName('MyFriendlyName')); }); @@ -94,84 +100,85 @@ describe('Node.js getFriendlyName() / setFriendlyName()', () => { assert.strictEqual(model.getFriendlyName(), 'Model1'); }); }); -}); -describe('Model.getOutputSize()', () => { + describe('Model.getOutputSize()', () => { - it('should return a number indicating number of outputs for the model', () => { - const result = model.getOutputSize(); - assert.strictEqual(typeof result, 'number', 'getOutputSize() should return a number'); - }); + it('should return a number indicating number of outputs for the model', () => { + const result = model.getOutputSize(); + assert.strictEqual(typeof result, 'number', 'getOutputSize() should return a number'); + }); - it('should not accept any arguments', () => { - assert.throws(() => { - model.getOutputSize('unexpected argument'); - }, /^Error: getOutputSize\(\) does not accept any arguments\.$/, 'Expected getOutputSize to throw an error when called with arguments'); - }); + it('should not accept any arguments', () => { + assert.throws(() => { + model.getOutputSize('unexpected argument'); + }, /^Error: getOutputSize\(\) does not accept any arguments\.$/, 'Expected getOutputSize to throw an error when called with arguments'); + }); - it('should return 1 for the default model', () => { - assert.strictEqual(model.getOutputSize(), 1, 'Expected getOutputSize to return 1 for the default model'); + it('should return 1 for the default model', () => { + assert.strictEqual(model.getOutputSize(), 1, 'Expected getOutputSize to return 1 for the default model'); + }); }); -}); -describe('Model.getOutputElementType()', () => { - it('should return a string for the element type ', () => { - const result = model.getOutputElementType(0); - assert.strictEqual(typeof result, 'string', - 'getOutputElementType() should return a string'); - }); + describe('Model.getOutputElementType()', () => { + it('should return a string for the element type ', () => { + const result = model.getOutputElementType(0); + assert.strictEqual(typeof result, 'string', + 'getOutputElementType() should return a string'); + }); - it('should accept a single integer argument', () => { - assert.throws(() => { - model.getOutputElementType(); - }, /'getOutputElementType' method called with incorrect parameters/, - 'Should throw when called without arguments'); - - assert.throws(() => { - model.getOutputElementType('unexpected argument'); - }, /'getOutputElementType' method called with incorrect parameters/, - 'Should throw on non-number argument'); - - assert.throws(() => { - model.getOutputElementType(0, 1); - }, /'getOutputElementType' method called with incorrect parameters/, - 'Should throw on multiple arguments'); - - assert.throws(() => { - model.getOutputElementType(3.14); - }, /'getOutputElementType' method called with incorrect parameters/, - 'Should throw on non-integer number'); - }); + it('should accept a single integer argument', () => { + assert.throws(() => { + model.getOutputElementType(); + }, /'getOutputElementType' method called with incorrect parameters/, + 'Should throw when called without arguments'); + + assert.throws(() => { + model.getOutputElementType('unexpected argument'); + }, /'getOutputElementType' method called with incorrect parameters/, + 'Should throw on non-number argument'); + + assert.throws(() => { + model.getOutputElementType(0, 1); + }, /'getOutputElementType' method called with incorrect parameters/, + 'Should throw on multiple arguments'); + + assert.throws(() => { + model.getOutputElementType(3.14); + }, /'getOutputElementType' method called with incorrect parameters/, + 'Should throw on non-integer number'); + }); - it('should return a valid element type for the default model', () => { - const elementType = model.getOutputElementType(0); - assert.ok(typeof elementType === 'string' && elementType.length > 0, - `Expected a non-empty string, got ${elementType}`); - }); + it('should return a valid element type for the default model', () => { + const elementType = model.getOutputElementType(0); + assert.ok(typeof elementType === 'string' && elementType.length > 0, + `Expected a non-empty string, got ${elementType}`); + }); - it('should throw an error for out-of-range index', () => { - const outputSize = model.getOutputSize(); - assert.throws( - () => { model.getOutputElementType(outputSize); }, - /^Error: /, - 'Should throw for out-of-range index' - ); + it('should throw an error for out-of-range index', () => { + const outputSize = model.getOutputSize(); + assert.throws( + () => { model.getOutputElementType(outputSize); }, + /^Error: /, + 'Should throw for out-of-range index' + ); + }); }); -}); -describe('Model.clone()', () => { - it('should return an object of type model', () => { - assert.ok(clonedModel instanceof ov.Model, 'clone() should return a model'); - }); + describe('Model.clone()', () => { + it('should return an object of type model', () => { + assert.ok(clonedModel instanceof ov.Model, 'clone() should return a model'); + }); - it('should return a model that is a clone of the calling model', () => { - assert.deepStrictEqual(clonedModel, model, "Cloned Model should be exactly equal to the calling model"); - }); - - it('should not accept any arguments', () => { - assert.throws( - () => model.clone("Unexpected argument").then(), - /'clone' method called with incorrect parameters./ - ); + it('should return a model that is a clone of the calling model', () => { + assert.deepStrictEqual(clonedModel, model, 'Cloned Model should be exactly equal to the calling model'); + }); + + it('should not accept any arguments', () => { + assert.throws( + () => model.clone('Unexpected argument').then(), + /'clone' method called with incorrect parameters./ + ); + }); }); + }); diff --git a/src/bindings/js/node/tests/unit/partial_shape.test.js b/src/bindings/js/node/tests/unit/partial_shape.test.js index 98f7d372ce8191..e46af099f03e27 100644 --- a/src/bindings/js/node/tests/unit/partial_shape.test.js +++ b/src/bindings/js/node/tests/unit/partial_shape.test.js @@ -9,46 +9,46 @@ const { describe, it } = require('node:test'); const staticShape = '1, 3, 224, 224'; const dynamicShape = '?, -1, 1..3, 224'; -describe('PartialShape', () => { - it('Allows create empty shape', () => { +describe('ov.PartialShape tests', () => { + it('allows create empty shape', () => { const partialShape = new ov.PartialShape(); assert.strictEqual(partialShape.toString(), '[]'); }); - it('Should detect static shape', () => { + it('should detect static shape', () => { const partialShape = new ov.PartialShape(staticShape); assert.ok(partialShape.isStatic()); }); - it('Should detect dynamic shape', () => { + it('should detect dynamic shape', () => { const partialShape = new ov.PartialShape(dynamicShape); assert.strictEqual(partialShape.isStatic(), false); }); - it('Should return shape as string for static shape', () => { + it('should return shape as string for static shape', () => { const partialShape = new ov.PartialShape(staticShape); assert.strictEqual(partialShape.toString(), '[1,3,224,224]'); }); - it('Should return shape as string for dynamic shape', () => { + it('should return shape as string for dynamic shape', () => { const partialShape = new ov.PartialShape(dynamicShape); assert.strictEqual(partialShape.toString(), '[?,?,1..3,224]'); }); - it('Should return array with dimensions for dynamic shape', () => { + it('should return array with dimensions for dynamic shape', () => { const partialShape = new ov.PartialShape(staticShape); - assert.deepStrictEqual(partialShape.getDimensions(), [1,3,224,224]); + assert.deepStrictEqual(partialShape.getDimensions(), [1, 3, 224, 224]); }); - it('Should return array with dimensions for dynamic shape', () => { + it('should return array with dimensions for dynamic shape', () => { const partialShape = new ov.PartialShape(dynamicShape); - assert.deepStrictEqual(partialShape.getDimensions(), [-1,-1,[1,3],224]); + assert.deepStrictEqual(partialShape.getDimensions(), [-1, -1, [1, 3], 224]); }); }); diff --git a/src/bindings/js/node/tests/unit/pre_post_processor.test.js b/src/bindings/js/node/tests/unit/pre_post_processor.test.js index a4570ce5fdd6a4..f3068f52581732 100644 --- a/src/bindings/js/node/tests/unit/pre_post_processor.test.js +++ b/src/bindings/js/node/tests/unit/pre_post_processor.test.js @@ -4,161 +4,167 @@ const { addon: ov } = require('../..'); const assert = require('assert'); -const { describe, it } = require('node:test'); -const { getModelPath } = require('./utils.js'); +const { describe, it, before } = require('node:test'); +const { testModels, getModelPath, isModelAvailable } = require('./utils.js'); -const testXml = getModelPath().xml; -const core = new ov.Core(); -const model = core.readModelSync(testXml); +describe('ov.preprocess.PrePostProcessor tests', () => { -describe('PrePostProcess', () => { - - it('input() ', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input()); + before(async () => { + await isModelAvailable(testModels.testModelFP32); }); - it('input(size_t input_index)', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0)); - }); + const testXml = getModelPath().xml; + const core = new ov.Core(); + const model = core.readModelSync(testXml); - it('input(const std::string& tensor_name)', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input('data')); - }); + describe('PrePostProcess', () => { - it('output() ', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).output()); - }); + it('input() ', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input()); + }); - it('output(size_t output_index)', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).output(0)); - }); + it('input(size_t input_index)', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0)); + }); - it('output(const std::string& tensor_name)', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).output('fc_out')); - }); + it('input(const std::string& tensor_name)', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input('data')); + }); -}); + it('output() ', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).output()); + }); -describe('InputInfo', () => { - it('tensor()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor()); - }); + it('output(size_t output_index)', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).output(0)); + }); - it('preprocess()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).preprocess()); - }); + it('output(const std::string& tensor_name)', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).output('fc_out')); + }); - it('model()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).model()); }); - it('tensor(param) throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor(0), + describe('InputInfo', () => { + it('tensor()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor()); + }); + + it('preprocess()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).preprocess()); + }); + + it('model()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).model()); + }); + + it('tensor(param) throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor(0), /Function does not take any parameters./); - }); + }); - it('preprocess(param) throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).preprocess(0), + it('preprocess(param) throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).preprocess(0), /Function does not take any parameters./); - }); + }); - it('model(param) throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).model(0), + it('model(param) throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).model(0), /Function does not take any parameters./); - }); + }); - it('tensor().setElementType()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setElementType(ov.element.u8)); - }); + it('tensor().setElementType()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setElementType(ov.element.u8)); + }); - it('tensor().setElementType() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setElementType(), + it('tensor().setElementType() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setElementType(), /Wrong number of parameters./); - }); + }); - it('tensor().setElementType() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setElementType('invalidType'), + it('tensor().setElementType() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setElementType('invalidType'), /Cannot create ov::element::Type/); - }); + }); - it('tensor().SetShape()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setShape([1, 10])); - }); + it('tensor().SetShape()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setShape([1, 10])); + }); - it('tensor().SetShape() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setShape(), + it('tensor().SetShape() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setShape(), /Wrong number of parameters./); - }); + }); - it('tensor().setLayout()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setLayout('NHWC')); - }); + it('tensor().setLayout()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setLayout('NHWC')); + }); - it('tensor().setLayout() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).tensor().setLayout(), + it('tensor().setLayout() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).tensor().setLayout(), /Wrong number of parameters./); - }); + }); - it('preprocess().resize()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).preprocess().resize( - ov.preprocess.resizeAlgorithm.RESIZE_LINEAR, - )); - }); + it('preprocess().resize()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).preprocess().resize( + ov.preprocess.resizeAlgorithm.RESIZE_LINEAR, + )); + }); - it('preprocess().resize() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).preprocess().resize( - ov.preprocess.resizeAlgorithm.RESIZE_LINEAR, 'extraArg', - ), + it('preprocess().resize() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).preprocess().resize( + ov.preprocess.resizeAlgorithm.RESIZE_LINEAR, 'extraArg', + ), /Wrong number of parameters./); - }); + }); - it('preprocess().resize() no arg throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).preprocess().resize(), + it('preprocess().resize() no arg throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).preprocess().resize(), /Wrong number of parameters./); - }); + }); - it('model().setLayout()', () => { - assert.doesNotThrow(() => - new ov.preprocess.PrePostProcessor(model).input(0).model().setLayout('NCHW')); - }); + it('model().setLayout()', () => { + assert.doesNotThrow(() => + new ov.preprocess.PrePostProcessor(model).input(0).model().setLayout('NCHW')); + }); - it('model().setLayout() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).model().setLayout('NCHW', 'extraArg'), + it('model().setLayout() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).model().setLayout('NCHW', 'extraArg'), /Wrong number of parameters./); - }); + }); - it('model().setLayout() throws', () => { - assert.throws(() => - new ov.preprocess.PrePostProcessor(model).input(0).model().setLayout('invalidLayout') - ); - }); + it('model().setLayout() throws', () => { + assert.throws(() => + new ov.preprocess.PrePostProcessor(model).input(0).model().setLayout('invalidLayout') + ); + }); -}); + }); -describe('OutputInfo', () => { + describe('OutputInfo', () => { it('tensor()', () => { assert.doesNotThrow(() => new ov.preprocess.PrePostProcessor(model).output(0).tensor()); @@ -167,7 +173,7 @@ describe('OutputInfo', () => { it('tensor(param) throws', () => { assert.throws(() => new ov.preprocess.PrePostProcessor(model).output(0).tensor(0), - /Function does not take any parameters./); + /Function does not take any parameters./); }); it('tensor().setElementType()', () => { @@ -178,13 +184,13 @@ describe('OutputInfo', () => { it('tensor().setElementType() throws', () => { assert.throws(() => new ov.preprocess.PrePostProcessor(model).output(0).tensor().setElementType(), - /Wrong number of parameters./); + /Wrong number of parameters./); }); it('tensor().setElementType() throws', () => { assert.throws(() => new ov.preprocess.PrePostProcessor(model).output(0).tensor().setElementType('invalidType'), - /Cannot create ov::element::Type/); + /Cannot create ov::element::Type/); }); it('tensor().setLayout()', () => { @@ -195,7 +201,9 @@ describe('OutputInfo', () => { it('tensor().setLayout() throws', () => { assert.throws(() => new ov.preprocess.PrePostProcessor(model).output(0).tensor().setLayout(), - /Wrong number of parameters./); + /Wrong number of parameters./); }); }); + +}); diff --git a/src/bindings/js/node/tests/unit/read_model.test.js b/src/bindings/js/node/tests/unit/read_model.test.js index dbc9fc2e876b7d..47fc584fe54e9e 100644 --- a/src/bindings/js/node/tests/unit/read_model.test.js +++ b/src/bindings/js/node/tests/unit/read_model.test.js @@ -5,81 +5,90 @@ const fs = require('node:fs'); const { addon: ov } = require('../..'); const assert = require('assert'); -const { describe, it } = require('node:test'); -const { getModelPath } = require('./utils.js'); +const { describe, it, before } = require('node:test'); +const { testModels, isModelAvailable, getModelPath } = require('./utils.js'); const { xml: modelPath, bin: weightsPath } = getModelPath(); -const modelFile = fs.readFileSync(modelPath); -const modelStr = fs.readFileSync(modelPath, 'utf8'); -const weightsFile = fs.readFileSync(weightsPath); -const weightsTensor = new ov.Tensor(ov.element.u8, [weightsFile.buffer.byteLength], new Uint8Array(weightsFile.buffer)); - -const core = new ov.Core(); - -describe('Core.readModeSync', () => { - it('readModeSync(xmlPath) ', () => { - const model = core.readModelSync(modelPath); - assert.ok(model instanceof ov.Model); - assert.equal(model.inputs.length, 1); - }); - it('readModeSync(xmlPath, weightsPath) ', () => { - const model = core.readModelSync(modelPath, weightsPath); - assert.ok(model instanceof ov.Model); - assert.equal(model.inputs.length, 1); - }); +describe('Tests for reading model.', () => { - it('readModeSync throws', () => { - assert.throws( - () => core.readModelSync(core), - /'readModelSync' method called with incorrect parameters./, - ) + before(async () => { + await isModelAvailable(testModels.testModelFP32); }); - it('readModelSync(modelString, weightsTensor) ', () => { - const model = core.readModelSync( - modelStr, - weightsTensor, - ); - assert.ok(model instanceof ov.Model); - assert.equal(model.inputs.length, 1); - }); + const modelFile = fs.readFileSync(modelPath); + const modelStr = fs.readFileSync(modelPath, 'utf8'); + const weightsFile = fs.readFileSync(weightsPath); + const weightsTensor = new ov.Tensor(ov.element.u8, [weightsFile.buffer.byteLength], new Uint8Array(weightsFile.buffer)); - it('readModelSync(modelUint8ArrayBuffer, weightsUint8ArrayBuffer) ', () => { - const model = core.readModelSync( - new Uint8Array(modelFile.buffer), - new Uint8Array(weightsFile.buffer), - ); - assert.ok(model instanceof ov.Model); - assert.equal(model.inputs.length, 1); - }); -}); + const core = new ov.Core(); -describe('Core.readModel', () => { - it('readModel(xmlPath) ', async () => { - const model = await core.readModel(modelPath); - assert.equal(model.inputs.length, 1); - }); + describe('Core.readModeSync', () => { + it('readModeSync(xmlPath) ', () => { + const model = core.readModelSync(modelPath); + assert.ok(model instanceof ov.Model); + assert.equal(model.inputs.length, 1); + }); - it('readModel(xmlPath, weightsPath) ', async () => { - const model = await core.readModel(modelPath, weightsPath); - assert.equal(model.inputs.length, 1); - }); + it('readModeSync(xmlPath, weightsPath) ', () => { + const model = core.readModelSync(modelPath, weightsPath); + assert.ok(model instanceof ov.Model); + assert.equal(model.inputs.length, 1); + }); - it('readModel(modelString, weightsTensor) ', async () => { - const model = await core.readModel( - modelStr, - weightsTensor, - ); - assert.ok(model instanceof ov.Model); - assert.equal(model.inputs.length, 1); + it('readModeSync throws', () => { + assert.throws( + () => core.readModelSync(core), + /'readModelSync' method called with incorrect parameters./, + ); + }); + + it('readModelSync(modelString, weightsTensor) ', () => { + const model = core.readModelSync( + modelStr, + weightsTensor, + ); + assert.ok(model instanceof ov.Model); + assert.equal(model.inputs.length, 1); + }); + + it('readModelSync(modelUint8ArrayBuffer, weightsUint8ArrayBuffer) ', () => { + const model = core.readModelSync( + new Uint8Array(modelFile.buffer), + new Uint8Array(weightsFile.buffer), + ); + assert.ok(model instanceof ov.Model); + assert.equal(model.inputs.length, 1); + }); }); - it('readModel(modelUint8ArrayBuffer, weightsUint8ArrayBuffer) ', async () => { - const model = await core.readModel( - new Uint8Array(modelFile.buffer), - new Uint8Array(weightsFile.buffer), - ); - assert.equal(model.inputs.length, 1); + describe('Core.readModel', () => { + it('readModel(xmlPath) ', async () => { + const model = await core.readModel(modelPath); + assert.equal(model.inputs.length, 1); + }); + + it('readModel(xmlPath, weightsPath) ', async () => { + const model = await core.readModel(modelPath, weightsPath); + assert.equal(model.inputs.length, 1); + }); + + it('readModel(modelString, weightsTensor) ', async () => { + const model = await core.readModel( + modelStr, + weightsTensor, + ); + assert.ok(model instanceof ov.Model); + assert.equal(model.inputs.length, 1); + }); + + it('readModel(modelUint8ArrayBuffer, weightsUint8ArrayBuffer) ', async () => { + const model = await core.readModel( + new Uint8Array(modelFile.buffer), + new Uint8Array(weightsFile.buffer), + ); + assert.equal(model.inputs.length, 1); + }); }); + }); diff --git a/src/bindings/js/node/tests/unit/setup.js b/src/bindings/js/node/tests/unit/setup.js new file mode 100644 index 00000000000000..b4885d24157abe --- /dev/null +++ b/src/bindings/js/node/tests/unit/setup.js @@ -0,0 +1,9 @@ +const { testModels, downloadTestModel } = require('./utils.js'); + +if (require.main === module) { + main(); +} + +async function main() { + await downloadTestModel(testModels.testModelFP32); +} diff --git a/src/bindings/js/node/tests/unit/tensor.test.js b/src/bindings/js/node/tests/unit/tensor.test.js index 79e0a66a9cdfe7..45d974f54cd6c0 100644 --- a/src/bindings/js/node/tests/unit/tensor.test.js +++ b/src/bindings/js/node/tests/unit/tensor.test.js @@ -7,243 +7,246 @@ const assert = require('assert'); const { test, describe, it } = require('node:test'); const getRandomBigInt = require('random-bigint'); -const shape = [1, 3, 224, 224]; -const elemNum = 1 * 3 * 224 * 224; -const data = Float32Array.from({ length: elemNum }, () => Math.random() ); -const params = [ - [ov.element.i8, 'i8', Int8Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.u8, 'u8', Uint8Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.i16, 'i16', Int16Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.u16, 'u16', Uint16Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.i32, 'i32', Int32Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.u32, 'u32', Uint32Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.f32, 'f32', Float32Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.f64, 'f64', Float64Array.from({ length: elemNum }, () => Math.random() )], - [ov.element.i64, 'i64', BigInt64Array.from({ length: elemNum }, () => getRandomBigInt(10) )], - [ov.element.u64, 'u64', BigUint64Array.from({ length: elemNum }, () => getRandomBigInt(10) )], -]; - -test('Test for number of arguments in tensor', () => { - assert.throws( () => new ov.Tensor(ov.element.f32, shape, data, params), - {message: /Invalid number of arguments for Tensor constructor./}); -}); - -describe('Tensor without data parameters', () => { - it('Tensor should have array with zeros and numbers of elements according to the shape', () => { - const tensor = new ov.Tensor(ov.element.f32, shape); - assert.strictEqual(tensor.data.length, elemNum); +describe('ov.Tensor tests', () => { + + const shape = [1, 3, 224, 224]; + const elemNum = 1 * 3 * 224 * 224; + const data = Float32Array.from({ length: elemNum }, () => Math.random() ); + const params = [ + [ov.element.i8, 'i8', Int8Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.u8, 'u8', Uint8Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.i16, 'i16', Int16Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.u16, 'u16', Uint16Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.i32, 'i32', Int32Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.u32, 'u32', Uint32Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.f32, 'f32', Float32Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.f64, 'f64', Float64Array.from({ length: elemNum }, () => Math.random() )], + [ov.element.i64, 'i64', BigInt64Array.from({ length: elemNum }, () => getRandomBigInt(10) )], + [ov.element.u64, 'u64', BigUint64Array.from({ length: elemNum }, () => getRandomBigInt(10) )], + ]; + + test('Test for number of arguments in tensor', () => { + assert.throws( () => new ov.Tensor(ov.element.f32, shape, data, params), + {message: /Invalid number of arguments for Tensor constructor./}); + }); + + describe('Tensor without data parameters', () => { + it('Tensor should have array with zeros and numbers of elements according to the shape', () => { + const tensor = new ov.Tensor(ov.element.f32, shape); + assert.strictEqual(tensor.data.length, elemNum); + }); }); -}); -describe('Tensor data', () => { + describe('Tensor data', () => { - params.forEach(([type, stringType, data]) => { - it(`Set tensor data with ${stringType} element type`, () => { - const tensor = new ov.Tensor(type, shape, data); - assert.deepStrictEqual(tensor.data, data); + params.forEach(([type, stringType, data]) => { + it(`set tensor data with ${stringType} element type`, () => { + const tensor = new ov.Tensor(type, shape, data); + assert.deepStrictEqual(tensor.data, data); + }); }); - }); - it('Create string tensor', () => { - const str_arr = ['text', 'more text', 'even more text']; - const tensor = new ov.Tensor(str_arr); - assert.deepStrictEqual(tensor.data, str_arr); - }); + it('create string tensor', () => { + const str_arr = ['text', 'more text', 'even more text']; + const tensor = new ov.Tensor(str_arr); + assert.deepStrictEqual(tensor.data, str_arr); + }); - it('Create string tensor', () => { - const str_arr = ['text', 'more text', 'even more text']; - const tensor = new ov.Tensor(str_arr); - assert.deepStrictEqual(tensor.data, str_arr); - }); + it('create string tensor', () => { + const str_arr = ['text', 'more text', 'even more text']; + const tensor = new ov.Tensor(str_arr); + assert.deepStrictEqual(tensor.data, str_arr); + }); - it('String tensor - passed array does not contain string elements', () => { - const str_arr = ['text', true]; - assert.throws(() => { new ov.Tensor(str_arr);}, - /The array passed to create string tensor must contain only strings./ - ); - }); + it('string tensor - passed array does not contain string elements', () => { + const str_arr = ['text', true]; + assert.throws(() => { new ov.Tensor(str_arr);}, + /The array passed to create string tensor must contain only strings./ + ); + }); - it('Set string tensor data', () => { - const str_arr = ['H', 'e', 'l', 'l', 'o']; - const tensor = new ov.Tensor(ov.element.string, [1, 1, 1, 5]); - tensor.data = str_arr; - assert.deepStrictEqual(tensor.data, str_arr); - }); + it('set string tensor data', () => { + const str_arr = ['H', 'e', 'l', 'l', 'o']; + const tensor = new ov.Tensor(ov.element.string, [1, 1, 1, 5]); + tensor.data = str_arr; + assert.deepStrictEqual(tensor.data, str_arr); + }); - it('Test tensor getData()', () => { - const tensor = new ov.Tensor(ov.element.f32, shape, data); - assert.deepStrictEqual(tensor.getData(), data); - }); + it('test tensor getData()', () => { + const tensor = new ov.Tensor(ov.element.f32, shape, data); + assert.deepStrictEqual(tensor.getData(), data); + }); - it('Test tensor.data setter - different element type throws', () => { - const float64_data = Float64Array.from([1, 2, 3] ); - const tensor = new ov.Tensor(ov.element.f32, [1, 3]); - assert.throws(() => { - tensor.data = float64_data;}, - /Passed array must have the same size as the Tensor!/ - ); - }); + it('test tensor.data setter - different element type throws', () => { + const float64_data = Float64Array.from([1, 2, 3] ); + const tensor = new ov.Tensor(ov.element.f32, [1, 3]); + assert.throws(() => { + tensor.data = float64_data;}, + /Passed array must have the same size as the Tensor!/ + ); + }); - it('Test tensor.data setter - different element length throws', () => { - const float64_data = Float64Array.from([1, 2, 3] ); - const tensor = new ov.Tensor(ov.element.f64, [1, 2]); - assert.throws(() => { - tensor.data = float64_data;}, - /Passed array must have the same size as the Tensor!/ - ); - }); + it('test tensor.data setter - different element length throws', () => { + const float64_data = Float64Array.from([1, 2, 3] ); + const tensor = new ov.Tensor(ov.element.f64, [1, 2]); + assert.throws(() => { + tensor.data = float64_data;}, + /Passed array must have the same size as the Tensor!/ + ); + }); - it('Test tensor.data setter', () => { - const testString = 'test'; - const tensor = new ov.Tensor(ov.element.f64, [1, 2]); - assert.throws(() => { - tensor.data = testString;}, - /Passed argument must be TypedArray, or Array if the tensor type is string./ - ); - }); + it('test tensor.data setter', () => { + const testString = 'test'; + const tensor = new ov.Tensor(ov.element.f64, [1, 2]); + assert.throws(() => { + tensor.data = testString;}, + /Passed argument must be TypedArray, or Array if the tensor type is string./ + ); + }); - it('Test tensor.data setter', () => { - const tensor = new ov.Tensor(ov.element.f32, shape); - tensor.data = data; - assert.deepStrictEqual(tensor.getData(), data); - }); + it('test tensor.data setter', () => { + const tensor = new ov.Tensor(ov.element.f32, shape); + tensor.data = data; + assert.deepStrictEqual(tensor.getData(), data); + }); - it('Set tensor data with Float32Array created from ArrayBuffer', () => { - const size = elemNum * 4; - const buffer = new ArrayBuffer(size); - const view = new Float32Array(buffer); - view.set(data); - const tensor = new ov.Tensor(ov.element.f32, shape, view); - assert.deepStrictEqual(tensor.data, data); - }); + it('set tensor data with Float32Array created from ArrayBuffer', () => { + const size = elemNum * 4; + const buffer = new ArrayBuffer(size); + const view = new Float32Array(buffer); + view.set(data); + const tensor = new ov.Tensor(ov.element.f32, shape, view); + assert.deepStrictEqual(tensor.data, data); + }); - it('Set tensor data with too big Float32Array', () => { - const size = elemNum * 8; - const buffer = new ArrayBuffer(size); - const view = new Float32Array(buffer); - view.set(data); - assert.throws( () => new ov.Tensor(ov.element.f32, shape, view), - {message: /Memory allocated using shape and element::type mismatch/}); - }); + it('set tensor data with too big Float32Array', () => { + const size = elemNum * 8; + const buffer = new ArrayBuffer(size); + const view = new Float32Array(buffer); + view.set(data); + assert.throws( () => new ov.Tensor(ov.element.f32, shape, view), + {message: /Memory allocated using shape and element::type mismatch/}); + }); - it('Third argument of a tensor cannot be an ArrayBuffer', () => { - assert.throws( - () => new ov.Tensor(ov.element.f32, shape, new ArrayBuffer(1234)), - {message: /Third argument of a tensor must be TypedArray./}); - }); + it('third argument of a tensor cannot be an ArrayBuffer', () => { + assert.throws( + () => new ov.Tensor(ov.element.f32, shape, new ArrayBuffer(1234)), + {message: /Third argument of a tensor must be TypedArray./}); + }); - it('Third argument of a tensor cannot be an array object', () => { - assert.throws( - () => new ov.Tensor(ov.element.f32, shape, [1, 2, 3, 4]), - {message: /Third argument of a tensor must be TypedArray./}); + it('third argument of a tensor cannot be an array object', () => { + assert.throws( + () => new ov.Tensor(ov.element.f32, shape, [1, 2, 3, 4]), + {message: /Third argument of a tensor must be TypedArray./}); + }); }); -}); -describe('Tensor shape', () => { + describe('Tensor shape', () => { - it('ov::Shape from an array object', () => { - const tensor = new ov.Tensor(ov.element.f32, [1, 3, 224, 224], data); - assert.deepStrictEqual(tensor.getShape(), [1, 3, 224, 224]); - }); + it('ov::Shape from an array object', () => { + const tensor = new ov.Tensor(ov.element.f32, [1, 3, 224, 224], data); + assert.deepStrictEqual(tensor.getShape(), [1, 3, 224, 224]); + }); - it('ov::Shape from an array object with floating point numbers', () => { - const tensor = + it('ov::Shape from an array object with floating point numbers', () => { + const tensor = new ov.Tensor(ov.element.f32, [1, 3.0, 224.8, 224.4], data); - assert.deepStrictEqual(tensor.getShape(), [1, 3, 224, 224]); - }); + assert.deepStrictEqual(tensor.getShape(), [1, 3, 224, 224]); + }); - it('Array argument to create ov::Shape can only contain numbers', () => { - assert.throws( - () => new ov.Tensor(ov.element.f32, ['1', 3, 224, 224], data), - {message: /Passed array must contain only numbers/}); - }); + it('array argument to create ov::Shape can only contain numbers', () => { + assert.throws( + () => new ov.Tensor(ov.element.f32, ['1', 3, 224, 224], data), + {message: /Passed array must contain only numbers/}); + }); - it('ov::Shape from TypedArray -> Int32Array', () => { - const shp = Int32Array.from([1, 224, 224, 3]); - const tensor = new ov.Tensor(ov.element.f32, shp, data); - assert.deepStrictEqual(tensor.getShape(), [1, 224, 224, 3]); - }); + it('ov::Shape from TypedArray -> Int32Array', () => { + const shp = Int32Array.from([1, 224, 224, 3]); + const tensor = new ov.Tensor(ov.element.f32, shp, data); + assert.deepStrictEqual(tensor.getShape(), [1, 224, 224, 3]); + }); - it('Cannot create ov::Shape from Float32Array', () => { - const shape = Float32Array.from([1, 224, 224, 3]); - assert.throws( - () => new ov.Tensor(ov.element.f32, shape, data), - /Passed argument must be an Int32Array or a Uint32Array./ - ); - }); + it('cannot create ov::Shape from Float32Array', () => { + const shape = Float32Array.from([1, 224, 224, 3]); + assert.throws( + () => new ov.Tensor(ov.element.f32, shape, data), + /Passed argument must be an Int32Array or a Uint32Array./ + ); + }); - it('Cannot create ov::Shape from ArrayBuffer', () => { - const shape = Int32Array.from([1, 224, 224, 3]); - assert.throws( - () => new ov.Tensor(ov.element.f32, shape.buffer, data), - /Passed argument must be of type Array or TypedArray./ - ); - }); + it('cannot create ov::Shape from ArrayBuffer', () => { + const shape = Int32Array.from([1, 224, 224, 3]); + assert.throws( + () => new ov.Tensor(ov.element.f32, shape.buffer, data), + /Passed argument must be of type Array or TypedArray./ + ); + }); - it('getShape() method does not accept parameters', () => { - const tensor = new ov.Tensor(ov.element.f32, [1, 3, 224, 224], data); - assert.throws( - () => tensor.getShape(1, 2, 3), - { message: 'No parameters are allowed for the getShape() method.'} - ); + it('getShape() method does not accept parameters', () => { + const tensor = new ov.Tensor(ov.element.f32, [1, 3, 224, 224], data); + assert.throws( + () => tensor.getShape(1, 2, 3), + { message: 'No parameters are allowed for the getShape() method.'} + ); + }); }); -}); -describe('Tensor element type', () => { - params.forEach(([elemType, val]) => { - it(`Comparison of ov.element.${elemType} to string ${val}`, () => { - assert.strictEqual(elemType, val); + describe('Tensor element type', () => { + params.forEach(([elemType, val]) => { + it(`comparison of ov.element.${elemType} to string ${val}`, () => { + assert.strictEqual(elemType, val); + }); }); - }); - params.forEach(([elemType, , data]) => { - it(`Comparison of ov.element ${elemType} got from Tensor object`, () => { - const tensor = new ov.Tensor(elemType, shape, data); - assert.strictEqual(tensor.getElementType(), elemType); + params.forEach(([elemType, , data]) => { + it(`comparison of ov.element ${elemType} got from Tensor object`, () => { + const tensor = new ov.Tensor(elemType, shape, data); + assert.strictEqual(tensor.getElementType(), elemType); + }); }); }); -}); -describe('Tensor getSize', () => { + describe('Tensor getSize', () => { - it('getSize returns the correct total number of elements', () => { - const tensor = new ov.Tensor(ov.element.f32, shape, data); - const expectedSize = shape.reduce((acc, dim) => acc * dim, 1); - assert.strictEqual(tensor.getSize(), expectedSize); - }); + it('getSize returns the correct total number of elements', () => { + const tensor = new ov.Tensor(ov.element.f32, shape, data); + const expectedSize = shape.reduce((acc, dim) => acc * dim, 1); + assert.strictEqual(tensor.getSize(), expectedSize); + }); - it('getSize should throw an error if arguments are provided', () => { - const tensor = new ov.Tensor(ov.element.f32, shape, data); - assert.throws( - () => tensor.getSize(1), - { message: 'getSize() does not accept any arguments.' } - ); + it('getSize should throw an error if arguments are provided', () => { + const tensor = new ov.Tensor(ov.element.f32, shape, data); + assert.throws( + () => tensor.getSize(1), + { message: 'getSize() does not accept any arguments.' } + ); + }); }); -}); -describe('Tensor getSize for various shapes', () => { + describe('Tensor getSize for various shapes', () => { - it('calculates size correctly for a common image data shape [3, 224, 224]', () => { - const shape = [3, 224, 224]; - const expectedSize = 3*224*224; - const tensorData = new Float32Array(expectedSize).fill(0); - const tensor = new ov.Tensor(ov.element.f32, shape, tensorData); - assert.strictEqual(tensor.getSize(), expectedSize); - }); + it('calculates size correctly for a common image data shape [3, 224, 224]', () => { + const shape = [3, 224, 224]; + const expectedSize = 3*224*224; + const tensorData = new Float32Array(expectedSize).fill(0); + const tensor = new ov.Tensor(ov.element.f32, shape, tensorData); + assert.strictEqual(tensor.getSize(), expectedSize); + }); - it('calculates size correctly for a scalar wrapped in a tensor [1]', () => { - const shape = [1]; - const expectedSize = 1; - const tensorData = new Float32Array(expectedSize).fill(0); - const tensor = new ov.Tensor(ov.element.f32, shape, tensorData); - assert.strictEqual(tensor.getSize(), expectedSize); - }); + it('calculates size correctly for a scalar wrapped in a tensor [1]', () => { + const shape = [1]; + const expectedSize = 1; + const tensorData = new Float32Array(expectedSize).fill(0); + const tensor = new ov.Tensor(ov.element.f32, shape, tensorData); + assert.strictEqual(tensor.getSize(), expectedSize); + }); - it('calculates size correctly for a vector [10]', () => { - const shape = [10]; - const expectedSize = 10; - const tensorData = new Float32Array(expectedSize).fill(0); - const tensor = new ov.Tensor(ov.element.f32, shape, tensorData); - assert.strictEqual(tensor.getSize(), expectedSize); + it('calculates size correctly for a vector [10]', () => { + const shape = [10]; + const expectedSize = 10; + const tensorData = new Float32Array(expectedSize).fill(0); + const tensor = new ov.Tensor(ov.element.f32, shape, tensorData); + assert.strictEqual(tensor.getSize(), expectedSize); + }); }); }); diff --git a/src/bindings/js/node/tests/unit/test_models/test_model_fp32.bin b/src/bindings/js/node/tests/unit/test_models/test_model_fp32.bin deleted file mode 100644 index b5f85e4108314c14a05efa9e4e2e149cf446b87d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 337592 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

pg0IZ22vGgPF(b_tKG=Z75mq2ZqCwNJdv2$nhj# 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 diff --git a/src/bindings/js/node/tests/unit/test_models/test_model_fp32.xml b/src/bindings/js/node/tests/unit/test_models/test_model_fp32.xml deleted file mode 100644 index dcf0cd74b068ac..00000000000000 --- a/src/bindings/js/node/tests/unit/test_models/test_model_fp32.xml +++ /dev/null @@ -1,467 +0,0 @@ - - - - - - - - 1 - 3 - 32 - 32 - - - - - - - - 16 - 3 - 5 - 5 - - - - - - - - 1 - 3 - 32 - 32 - - - 16 - 3 - 5 - 5 - - - - - 1 - 16 - 32 - 32 - - - - - - - - 1 - 16 - 1 - 1 - - - - - - - 1 - 16 - 32 - 32 - - - 1 - 16 - 1 - 1 - - - - - 1 - 16 - 32 - 32 - - - - - - - 1 - 16 - 32 - 32 - - - - - 1 - 16 - 32 - 32 - - - - - - - - 1 - 16 - 32 - 32 - - - - - 1 - 16 - 16 - 16 - - - - - - - - 32 - 16 - 5 - 5 - - - - - - - - 1 - 16 - 16 - 16 - - - 32 - 16 - 5 - 5 - - - - - 1 - 32 - 16 - 16 - - - - - - - - 1 - 32 - 1 - 1 - - - - - - - 1 - 32 - 16 - 16 - - - 1 - 32 - 1 - 1 - - - - - 1 - 32 - 16 - 16 - - - - - - - - 64 - 32 - 3 - 3 - - - - - - - - 1 - 32 - 16 - 16 - - - 64 - 32 - 3 - 3 - - - - - 1 - 64 - 18 - 18 - - - - - - - - 1 - 64 - 1 - 1 - - - - - - - 1 - 64 - 18 - 18 - - - 1 - 64 - 1 - 1 - - - - - 1 - 64 - 18 - 18 - - - - - - - 1 - 64 - 18 - 18 - - - - - 1 - 64 - 18 - 18 - - - - - - - - 1 - 64 - 18 - 18 - - - - - 1 - 64 - 9 - 9 - - - - - - - - 2 - - - - - - - - 1 - 64 - 9 - 9 - - - 2 - - - - - 1 - 5184 - - - - - - - - 10 - 5184 - - - - - - - - 1 - 5184 - - - 10 - 5184 - - - - - 1 - 10 - - - - - - - - 1 - 10 - - - - - - - 1 - 10 - - - 1 - 10 - - - - - 1 - 10 - - - - - - - - 1 - 10 - - - - - 1 - 10 - - - - - - - 1 - 10 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/bindings/js/node/tests/unit/utils.js b/src/bindings/js/node/tests/unit/utils.js index ebe126d6c74129..cf541a332b103f 100644 --- a/src/bindings/js/node/tests/unit/utils.js +++ b/src/bindings/js/node/tests/unit/utils.js @@ -3,15 +3,67 @@ // SPDX-License-Identifier: Apache-2.0 const path = require('path'); +const fs = require('node:fs/promises'); +const { downloadFile, checkIfPathExists } = require('../../scripts/download_runtime'); -module.exports = { getModelPath }; +const modelDir = 'tests/unit/test_models/'; +const testModels = { + testModelFP32: { + xml: 'test_model_fp32.xml', + bin: 'test_model_fp32.bin', + xmlURL: + 'https://raw.githubusercontent.com/openvinotoolkit/testdata/master/models/test_model/test_model_fp32.xml', + binURL: + 'https://media.githubusercontent.com/media/openvinotoolkit/testdata/master/models/test_model/test_model_fp32.bin', + }, +}; + +module.exports = { + getModelPath, + downloadTestModel, + isModelAvailable, + testModels, +}; function getModelPath(isFP16=false) { - const basePath = 'tests/unit/test_models/'; const modelName = `test_model_fp${isFP16 ? 16 : 32}`; return { - xml: path.join(basePath, `${modelName}.xml`), - bin: path.join(basePath, `${modelName}.bin`), + xml: path.join(modelDir, `${modelName}.xml`), + bin: path.join(modelDir, `${modelName}.bin`), }; } + +async function downloadTestModel(model) { + const modelsDir = './tests/unit/test_models'; + try { + const ifModelsDirectoryExists = await checkIfPathExists(modelsDir); + if (!ifModelsDirectoryExists) { + await fs.mkdir(modelDir); + } + + const modelPath = path.join(modelsDir, model.xml); + const modelExists = await checkIfPathExists(modelPath); + if (modelExists) return; + + const { env } = process; + const proxyUrl = env.http_proxy || env.HTTP_PROXY || env.npm_config_proxy; + + await downloadFile(model.xmlURL, modelsDir, model.xml, proxyUrl); + await downloadFile(model.binURL, modelsDir, model.bin, proxyUrl); + } catch(error) { + console.error(`Failed to download the model: ${error}.`); + throw error; + } +} + +async function isModelAvailable(model) { + const baseArtifactsDir = './tests/unit/test_models'; + const modelPath = path.join(baseArtifactsDir, model.xml); + const modelExists = await checkIfPathExists(modelPath); + if (modelExists) return; + + console.log('\n\nTestModel cannot be found.\nPlease run `npm run test_setup`.\n\n'); + process.exit(1); + +} From 3afad8df203a9354b314e32c79d088e358a043b8 Mon Sep 17 00:00:00 2001 From: Aleksandr Voron Date: Wed, 21 Aug 2024 15:52:32 +0200 Subject: [PATCH 068/117] [CPU][ARM] Upgrade ACL to 24.08 (#26137) - [x] Performance check ### Tickets: - [CVS-150178](https://jira.devtools.intel.com/browse/CVS-150178) --- src/plugins/intel_cpu/thirdparty/ComputeLibrary | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/intel_cpu/thirdparty/ComputeLibrary b/src/plugins/intel_cpu/thirdparty/ComputeLibrary index c5dd7753d0475f..f1929dc994d8e5 160000 --- a/src/plugins/intel_cpu/thirdparty/ComputeLibrary +++ b/src/plugins/intel_cpu/thirdparty/ComputeLibrary @@ -1 +1 @@ -Subproject commit c5dd7753d0475ffec0f192f3181fe67a1d761680 +Subproject commit f1929dc994d8e5afae5c77ca66446344119a8592 From 6f899d293a10bc100c8fbc39fc0009d31601a51d Mon Sep 17 00:00:00 2001 From: Haiqi Pan Date: Wed, 21 Aug 2024 22:37:31 +0800 Subject: [PATCH 069/117] Move INFERENCE_PRECISION_HINT test to optional conformance for meta-plugin (#25598) ### Details: - *Move INFERENCE_PRECISION_HINT test to optional conformance for meta-plugin* ### Tickets: - *147702* --------- Co-authored-by: Chen Peter --- .../src/ov_plugin/properties.cpp | 11 ++++++----- .../shared/include/base/ov_behavior_test_utils.hpp | 6 ++++++ .../github/skip_configs/CPU/expected_failures_API.csv | 2 +- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/ov_plugin/properties.cpp b/src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/ov_plugin/properties.cpp index 5ed1e4269d69c4..594f4c68b61dc9 100644 --- a/src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/ov_plugin/properties.cpp +++ b/src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/ov_plugin/properties.cpp @@ -88,11 +88,12 @@ INSTANTIATE_TEST_SUITE_P(ov_plugin_mandatory, OVCheckChangePropComplieModleGetPr ::testing::Values(ov::AnyMap({}))), OVCheckChangePropComplieModleGetPropTests_DEVICE_ID::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(ov_plugin_mandatory, OVCheckChangePropComplieModleGetPropTests_InferencePrecision, - ::testing::Combine( - ::testing::Values(ov::test::utils::target_device), - ::testing::Values(ov::AnyMap({}))), - OVCheckChangePropComplieModleGetPropTests_InferencePrecision::getTestCaseName); +/* Add prefix mandatory_ to suffix (getTestCaseName) of HW plugin test cases */ +INSTANTIATE_TEST_SUITE_P( + ov_plugin, + OVCheckChangePropComplieModleGetPropTests_InferencePrecision, + ::testing::Combine(::testing::Values(ov::test::utils::target_device), ::testing::Values(ov::AnyMap({}))), + MARK_MANDATORY_FOR_HW_DEVICE(OVCheckChangePropComplieModleGetPropTests_InferencePrecision::getTestCaseName)); INSTANTIATE_TEST_SUITE_P(ov_plugin, OVCheckMetricsPropsTests_ModelDependceProps, ::testing::Combine( diff --git a/src/tests/functional/plugin/shared/include/base/ov_behavior_test_utils.hpp b/src/tests/functional/plugin/shared/include/base/ov_behavior_test_utils.hpp index 9de110a82b3032..686a3c797ba917 100644 --- a/src/tests/functional/plugin/shared/include/base/ov_behavior_test_utils.hpp +++ b/src/tests/functional/plugin/shared/include/base/ov_behavior_test_utils.hpp @@ -30,6 +30,12 @@ #include "common_test_utils/subgraph_builders/concat_with_params.hpp" #include "common_test_utils/subgraph_builders/split_concat.hpp" +#define MARK_MANDATORY_FOR_HW_DEVICE(GET_TEST_NAME) \ + [&](const testing::TestParamInfo& info) { \ + std::string name = GET_TEST_NAME(info); \ + return sw_plugin_in_target_device(ov::test::utils::target_device) ? "" : "mandatory_" + name; \ + } + namespace ov { namespace test { namespace behavior { diff --git a/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_API.csv b/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_API.csv index 52b257b6251142..ba96df69cf0887 100644 --- a/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_API.csv +++ b/src/tests/test_utils/functional_test_utils/layer_tests_summary/github/skip_configs/CPU/expected_failures_API.csv @@ -1,5 +1,5 @@ Test Name,Fix Priority -ov_plugin_mandatory/OVCheckChangePropComplieModleGetPropTests_InferencePrecision.ChangeCorrectProperties/target_device=CPU_,1.0 +ov_plugin/OVCheckChangePropComplieModleGetPropTests_InferencePrecision.ChangeCorrectProperties/mandatory_target_device=CPU_,1.0 ov_compiled_model_mandatory/OVClassCompiledModelGetPropertyTest_MODEL_PRIORITY.GetMetricNoThrow/3,1.0 ov_compiled_model_mandatory/OVClassCompiledModelGetPropertyTest_MODEL_PRIORITY.GetMetricNoThrow/2,1.0 ov_compiled_model_mandatory/OVClassCompiledModelGetPropertyTest_MODEL_PRIORITY.GetMetricNoThrow/1,1.0 From 407f0bcf25454f90a0c7a05ecaafe224e6ffc71c Mon Sep 17 00:00:00 2001 From: Andrei Kashchikhin Date: Wed, 21 Aug 2024 16:29:27 +0100 Subject: [PATCH 070/117] [CI] [GHA] Do not checkout latest oneDNN on U22 in nightly (#26150) ### Details: - GPU tests are only enabled for U20. Checking out the latest oneDNN via https://github.com/openvinotoolkit/openvino/blob/0b8eb87e0efa9030be47d661fe94b3c8beb655fd/.github/workflows/job_build_linux.yml#L71 breaks the build on U22: [like this one](https://github.com/openvinotoolkit/openvino/actions/runs/10481070002/job/29030046664) and prevents other nightly tests from executing. - This PR limits the checkout of the latest oneDNN to U20 only. This will unblock the nightly tests that run on U22 for now. - Later, it might be better to separate the builds for GPU/other test jobs. ### Tickets: - *149805* --- .github/workflows/job_build_linux.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/job_build_linux.yml b/.github/workflows/job_build_linux.yml index 8fd35f48172a85..564cd8e58c38a7 100644 --- a/.github/workflows/job_build_linux.yml +++ b/.github/workflows/job_build_linux.yml @@ -69,7 +69,7 @@ jobs: # Ticket: 139627 - name: Checkout the latest OneDNN for GPU in nightly - if: ${{ inputs.event-name == 'schedule' }} + if: ${{ inputs.event-name == 'schedule' && inputs.os == 'ubuntu_20_04' }} # GPU tests are enabled only on U20 working-directory: ${{ env.OPENVINO_REPO }}/src/plugins/intel_gpu/thirdparty/onednn_gpu run: | git fetch origin From 9d09d0a8fbf356cf3b6b11d4ca39485d82f45e79 Mon Sep 17 00:00:00 2001 From: Andrew Kwangwoong Park Date: Thu, 22 Aug 2024 01:39:30 +0900 Subject: [PATCH 071/117] [GPU] Fix segfault in layer tests for onnx_tests.test_lstm.TestLSTM (#26159) ### Details: - This issue occurs after https://github.com/openvinotoolkit/openvino/pull/26032 - Fix segfault in layer tests for onnx_tests.test_lstm.TestLSTM ### Tickets: - [CVS-150221](https://jira.devtools.intel.com/browse/CVS-150221) --- src/plugins/intel_gpu/src/graph/include/reshape_inst.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/intel_gpu/src/graph/include/reshape_inst.h b/src/plugins/intel_gpu/src/graph/include/reshape_inst.h index d5a60138a50777..a94f48a6ec92dd 100644 --- a/src/plugins/intel_gpu/src/graph/include/reshape_inst.h +++ b/src/plugins/intel_gpu/src/graph/include/reshape_inst.h @@ -44,7 +44,7 @@ struct typed_program_node : public typed_program_node_base { return false; // oneDNN supports padded input of outer axis only for buffer fusing on static shape - if (!has_outer_padding_offset() && get_users().front()->get_preferred_impl_type() == impl_types::onednn) + if (!has_outer_padding_offset() && get_users().size() == 1 && get_users().front()->get_preferred_impl_type() == impl_types::onednn) return false; // TODO: If user is RoPE or MVN and dynamic padding exists, ouput padding propagation is not supported in the base mode From 9ef7e23da022f20e128d6b2265aeb4cdf22f382c Mon Sep 17 00:00:00 2001 From: ge0rdi Date: Wed, 21 Aug 2024 18:42:33 +0200 Subject: [PATCH 072/117] [NPU] Fix ze_loader dependency (#26157) ### Details: Commit ad4eb09 introduced dynamic loading of ze_loader so that it is loaded only when really needed. Recent changes in `ZeroRemoteTensor` caused NPU plugin binary to import from ze_loader directly. This commit should fix that and the NPU binary should have no longer dependency on ze_loader. ### Tickets: - None --- src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp b/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp index d27ee74d9e5d1e..4ac1d75fe57f10 100644 --- a/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp +++ b/src/plugins/intel_npu/src/backend/src/zero_remote_tensor.cpp @@ -7,6 +7,7 @@ #include #include "intel_npu/al/config/common.hpp" +#include "intel_npu/utils/zero/zero_api.hpp" #include "openvino/core/type/element_iterator.hpp" #include "zero_utils.hpp" From 50ffcbc7e96a46ff7799a6330ad63230bdd525e7 Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Wed, 21 Aug 2024 23:45:05 +0400 Subject: [PATCH 073/117] Fixed pattern for patching TBB config files (#26167) ### Details: - To fix issues with tokenizers build - See https://github.com/openvinotoolkit/openvino_tokenizers/pull/229 --- src/bindings/python/wheel/setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bindings/python/wheel/setup.py b/src/bindings/python/wheel/setup.py index d91523659a0a78..f88d9bd3da7592 100644 --- a/src/bindings/python/wheel/setup.py +++ b/src/bindings/python/wheel/setup.py @@ -487,7 +487,7 @@ def copy_package_data(self, src_dirs): tbb_replacements = { # change the path where the TBBConfig.cmake is installed (/lib/cmake/TBB -> openvino/cmake) - r"(\{CMAKE_CURRENT_LIST_FILE\})": r"\1/fake_dir", + r"(_IMPORT_PREFIX \"\$\{CMAKE_CURRENT_LIST_FILE\})": r"\1/fake_dir", # change the path where the libraries are installed (/lib -> openvino/libs) r"(\{_IMPORT_PREFIX\})\/(.*)\/(.+\.[lib|dylib|so|dll])": rf"\1/{WHEEL_LIBS_INSTALL_DIR}/\3", # change the path where the include files are installed (/include -> openvino/include) From 28950f660e0344984ab553ada973eec4465d20ff Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Thu, 22 Aug 2024 00:26:56 +0400 Subject: [PATCH 074/117] [Common FE] Document get_input_by_reference better (#26165) **Details:** Document get_input_by_reference better **Ticket:** TBD Signed-off-by: Kazantsev, Roman --- .../common/include/openvino/frontend/node_context.hpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/frontends/common/include/openvino/frontend/node_context.hpp b/src/frontends/common/include/openvino/frontend/node_context.hpp index 98243fab0e9c63..c184d59eb32ab0 100644 --- a/src/frontends/common/include/openvino/frontend/node_context.hpp +++ b/src/frontends/common/include/openvino/frontend/node_context.hpp @@ -48,7 +48,12 @@ class FRONTEND_API NodeContext { FRONT_END_NOT_IMPLEMENTED(get_input); } - /// \brief Returns the input by reference. The reference value can be changed by consuming operation + /// \brief Returns output of Variable node (or Variable value). + /// Variable is a special node that stores a value represented with a sub-graph. + /// Variable has a concrete value at each conversion step. + /// The current (consuming) operation node can change its value + /// so consumers of this Variable will have a new value at next conversion steps. + /// See ov::frontend::Variable class for more details. virtual Output get_input_by_reference(int idx) const { FRONT_END_NOT_IMPLEMENTED(get_input_by_reference); } From 711f06026f7ba35f4c2482f0e3d398d1be51ab12 Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Thu, 22 Aug 2024 01:39:35 +0400 Subject: [PATCH 075/117] Revert "Temporarily remove TF layer tests from required on ARM" (#26169) Reverts openvinotoolkit/openvino#26158 Issue with TBB on ARM was fixed. --- .github/workflows/linux_arm64.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/linux_arm64.yml b/.github/workflows/linux_arm64.yml index 225fd632ee81c3..d38eda93e7d2b8 100644 --- a/.github/workflows/linux_arm64.yml +++ b/.github/workflows/linux_arm64.yml @@ -434,7 +434,7 @@ jobs: Overall_Status: name: ci/gha_overall_status_linux_arm64 needs: [Smart_CI, Build, Debian_Packages, Samples, ONNX_Runtime, CXX_Unit_Tests, Python_Unit_Tests, CPU_Functional_Tests, - TensorFlow_Models_Tests, PyTorch_Models_Tests, Openvino_tokenizers] + TensorFlow_Models_Tests, PyTorch_Models_Tests, Openvino_tokenizers, TensorFlow_Layer_Tests] if: ${{ always() }} runs-on: ubuntu-latest steps: From 1335be030909df842b92144ef99da680bbdcbe55 Mon Sep 17 00:00:00 2001 From: Steve Yoo Date: Thu, 22 Aug 2024 07:02:41 +0900 Subject: [PATCH 076/117] [GPU] Enable fc 4d for MatMul (#24642) ### Details: - *Enable fc 4d for MatMul to calculate 4x2* ### Tickets: - *132334* --- .../intel_gpu/src/graph/fully_connected.cpp | 4 +- .../test_cases/fully_connected_gpu_test.cpp | 37 +++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/src/plugins/intel_gpu/src/graph/fully_connected.cpp b/src/plugins/intel_gpu/src/graph/fully_connected.cpp index cc6d849bcfabe0..b09416585e3fed 100644 --- a/src/plugins/intel_gpu/src/graph/fully_connected.cpp +++ b/src/plugins/intel_gpu/src/graph/fully_connected.cpp @@ -117,7 +117,7 @@ layout fully_connected_inst::calc_output_layout(fully_connected_node const& node feature = std::max({input_layout.spatial(0), input_layout.spatial(1), input_layout.spatial(2)}); } - if (desc->input_size > 3) { + if (desc->input_size > 4) { input_layout.set_partial_shape(reshape_to_2d(input_pshape, feature)); } if (weights_pshape.size() != 2) { @@ -127,6 +127,8 @@ layout fully_connected_inst::calc_output_layout(fully_connected_node const& node auto output_size = tensor(input_layout.batch(), weights_layout.batch(), 1, 1); if (desc->input_size == 3) { output_size = tensor(input_layout.batch(), input_layout.feature(), 1, weights_layout.batch()); + } else if (desc->input_size == 4) { + output_size = tensor(input_layout.batch(), input_layout.feature(), weights_layout.batch(), input_layout.spatial(1)); } format output_format = get_preferred_format(node, impl_param); diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp index fa3e375cbecfc5..3f0b43a861873b 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp @@ -371,6 +371,43 @@ TEST(fully_connected_gpu, no_biases_fc_i32) { } } +TEST(fully_connected_gpu, no_biases_4d_input) { + // Input : 1x256x256x384 + // Output : 1x256x256x1536 + // Weights: 1536x384x1x1 + + const int32_t input_b = 1, input_f = 256, input_y = 256, input_x = 384, // size of the whole input buffer + weight_b = 1536, weight_f = 384, weight_y = 1, weight_x = 1; // size of the whole weights buffer + + auto& engine = get_test_engine(); + + auto input_prim = engine.allocate_memory({ data_types::f32, format::bfyx, { input_b, input_f, input_x, input_y } }); + auto weights_prim = engine.allocate_memory({ data_types::f32, format::bfyx, { weight_b, weight_f, weight_x, weight_y } }); + + std::vector input_data(input_b * input_f * input_y * input_x, 0); + std::vector weights_data(weight_b * weight_f * weight_y * weight_x, 0); + + set_values(input_prim, std::move(input_data)); + set_values(weights_prim, std::move(weights_data)); + + auto input = input_layout("input", input_prim->get_layout()); + auto w_data = data("weights", weights_prim); + auto fc = fully_connected("fc_prim", input_info("input"), "weights", "", 4, 2); + topology topology; + topology.add(input); + topology.add(w_data); + topology.add(fc); + + network network(engine, topology, get_test_default_config(engine)); + network.set_input_data("input", input_prim); + + auto outputs = network.execute(); + ASSERT_EQ(outputs.begin()->second.get_layout().batch(), input_b); + ASSERT_EQ(outputs.begin()->second.get_layout().feature(), input_f); + ASSERT_EQ(outputs.begin()->second.get_layout().spatial(1), input_y); + ASSERT_EQ(outputs.begin()->second.get_layout().spatial(0), weight_b); +} + TEST(fully_connected_gpu, xb_f32_batch_1) { // Input : 3x1 // Output : 4x1 From abbf944fe17249dac6fcdec0e75c84cf306186ef Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Thu, 22 Aug 2024 03:13:27 +0400 Subject: [PATCH 077/117] [TF FE] Stabilize L2Loss layer tests on all platforms (#26151) **Details:** Stabilize L2Loss layer tests on all platforms **Ticket:** 104863 --------- Signed-off-by: Kazantsev, Roman --- .../tensorflow_tests/test_tf_L2Loss.py | 40 +++++++++++-------- 1 file changed, 24 insertions(+), 16 deletions(-) diff --git a/tests/layer_tests/tensorflow_tests/test_tf_L2Loss.py b/tests/layer_tests/tensorflow_tests/test_tf_L2Loss.py index e43808fbb688a6..ddd14eb2ae23ea 100644 --- a/tests/layer_tests/tensorflow_tests/test_tf_L2Loss.py +++ b/tests/layer_tests/tensorflow_tests/test_tf_L2Loss.py @@ -1,38 +1,46 @@ # Copyright (C) 2018-2024 Intel Corporation # SPDX-License-Identifier: Apache-2.0 +import numpy as np import pytest import tensorflow as tf from common.tf_layer_test_class import CommonTFLayerTest +rng = np.random.default_rng(233453) + class TestL2Loss(CommonTFLayerTest): - def create_l2_loss_net(self, input_shape): + def _prepare_input(self, inputs_info): + assert 'input:0' in inputs_info, "Test error: inputs_info must contain `input`" + input_shape = inputs_info['input:0'] + inputs_data = {} + inputs_data['input:0'] = rng.uniform(-2.0, 2.0, input_shape).astype(self.input_type) + return inputs_data + + def create_l2_loss_net(self, input_shape, input_type): + self.input_type = input_type tf.compat.v1.reset_default_graph() # Create the graph and model with tf.compat.v1.Session() as sess: - input = tf.compat.v1.placeholder(tf.float32, input_shape, 'input') + input = tf.compat.v1.placeholder(input_type, input_shape, 'input') tf.raw_ops.L2Loss(t=input, name='l2_loss') tf.compat.v1.global_variables_initializer() - tf_net = sess.graph_def return tf_net, None - test_data_basic = [ - dict(input_shape=[1, 2]), - dict(input_shape=[2, 3, 4]), - ] - - @pytest.mark.parametrize("params", test_data_basic) + @pytest.mark.parametrize("input_shape", [[], [2], [1, 2], [2, 3, 4]]) + @pytest.mark.parametrize("input_type", [np.float16, np.float32, np.float64]) @pytest.mark.precommit @pytest.mark.nightly - def test_l2_loss_basic(self, params, ie_device, precision, ir_version, temp_dir, + def test_l2_loss_basic(self, input_shape, input_type, + ie_device, precision, ir_version, temp_dir, use_legacy_frontend): - if ie_device == 'GPU': - pytest.xfail('104863') - if use_legacy_frontend: - pytest.skip("L2Loss is not supported by legacy FE.") - self._test(*self.create_l2_loss_net(**params), + custom_eps = None + if input_type == np.float16: + custom_eps = 3 * 1e-3 + if ie_device == 'GPU' and input_shape == []: + pytest.skip("150321: Accessing out-of-range dimension on GPU") + self._test(*self.create_l2_loss_net(input_shape, input_type), ie_device, precision, ir_version, temp_dir=temp_dir, - use_legacy_frontend=use_legacy_frontend) + use_legacy_frontend=use_legacy_frontend, custom_eps=custom_eps) From 486fd0b48c2fd38696b9847d715e3c445335e24a Mon Sep 17 00:00:00 2001 From: Zhiyuan Tan <66934674+BHbean@users.noreply.github.com> Date: Thu, 22 Aug 2024 14:59:20 +0800 Subject: [PATCH 078/117] [DOCS] [GSoC] add docs about how to build OV on RISC-V devices (#26056) ### Details: - *add `build_riscv64.md` file giving instructions on how to build OV on RISC-V devices* ### Tickets: - *N/A* --- docs/dev/build.md | 1 + docs/dev/build_riscv64.md | 131 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 132 insertions(+) create mode 100644 docs/dev/build_riscv64.md diff --git a/docs/dev/build.md b/docs/dev/build.md index c70ef73f527fc4..5aca51f0632654 100644 --- a/docs/dev/build.md +++ b/docs/dev/build.md @@ -22,6 +22,7 @@ The articles below provide the basic informations about the process of building * [Raspbian Stretch](./build_raspbian.md) * [Web Assembly](./build_webassembly.md) * [Docker Image](https://github.com/openvinotoolkit/docker_ci/tree/master/dockerfiles/ubuntu18/build_custom) +* [Linux RISC-V](./build_riscv64.md) > **NOTE**: For the details on how to build static OpenVINO, refer to [Building static OpenVINO libraries](static_libaries.md) diff --git a/docs/dev/build_riscv64.md b/docs/dev/build_riscv64.md new file mode 100644 index 00000000000000..75d3782004f4dc --- /dev/null +++ b/docs/dev/build_riscv64.md @@ -0,0 +1,131 @@ +# Cross compile OpenVINOâ„¢ Runtime for RISCV64 systems +This guide shows how to build OpenVINO Runtime for 64-bit RISC-V devices. Due to limited resources, cross compilation is used now for building OpenVINO targeting RISC-V development boards. + +Cross compilation was tested on the following hosts: +- Ubuntu 22.04 (64-bit), x64 + +The software was validated on the following devices: +- [Lichee Pi 4A](https://wiki.sipeed.com/hardware/en/lichee/th1520/lp4a.html) with RVV 0.7.1 +- [Banana Pi BPI-F3](https://www.banana-pi.org/en/banana-pi-sbcs/175.html) with RVV 1.0 + + +## Software requirements + +- [CMake](https://cmake.org/download/) 3.13 or higher +- GCC 7.5 or higher (for non-RVV) / [xuantie-gnu-toolchain](https://github.com/XUANTIE-RV/xuantie-gnu-toolchain) (for RVV) +- Python 3.10 for OpenVINO Runtime Python API + +## How to build +0. Prerequisite: +- For target with RVV - build `xuantie-gnu-toolchain` and `qemu`: + ```sh + git clone https://github.com/XUANTIE-RV/xuantie-gnu-toolchain.git + cd xuantie-gnu-toolchain + ./configure --prefix= + make linux build-qemu -j$(nproc) + ``` +- For target without RVV - build `riscv-gnu-toolchain`: + ```sh + git clone https://github.com/riscv-collab/riscv-gnu-toolchain.git + cd riscv-gnu-toolchain + ./configure --prefix=/opt/riscv + make linux build-qemu -j$(nproc) + ``` + > **NOTE**: The `build-qemu` target is optional, as it is used to build the `qemu` simulator. However, it is recommended to build the `qemu` simulator, since it is much more convenient to validate the software on your host than on your devices. More information can be seen [here](https://github.com/riscv-collab/riscv-gnu-toolchain). + +1. Clone OpenVINO repository and init submodules: + ```sh + git clone --recursive https://github.com/openvinotoolkit/openvino.git + cd openvino + ``` + +2. Install build dependencies using the `install_build_dependencies.sh` script in the + project root folder. + ```sh + sudo ./install_build_dependencies.sh + ``` + +3. Create a build folder: + ```sh + mkdir build && cd build + ``` + +4. To cross compile OpenVINO Runtime for RISC-V devices, run `cmake` with specified `CMAKE_TOOLCHAIN_FILE` and `RISCV_TOOLCHAIN_ROOT`. +- For target with RVV: + ```sh + cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX= \ + -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/ \ + -DRISCV_TOOLCHAIN_ROOT= + ``` + > **NOTE**: To build OpenVINO Runtime for different versions of RVV, you just need to specify corresponding toolchain files. For exmaple, you can replace `` with `riscv64-071-thead-gnu.toolchain.cmake` for RVV 0.7.1 and `riscv64-100-thead-gnu.toolchain.cmake` for RVV 1.0 respectively. +- For target without RVV: + ```sh + cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX= \ + -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/riscv64-gnu.toolchain.cmake \ + -DRISCV_TOOLCHAIN_ROOT=/opt/riscv + ``` + > **NOTE**: The `riscv-gnu-toolchain` is build as there are essential files used for cross compilation under `/opt/riscv/sysroot`. The latest stable versions of Clang or GCC both support compiling source code into RISC-V instructions, so it is acceptable to choose your preferable compilers by specifying `-DCMAKE_C_COMPILER` and `CMAKE_CXX_COMPILER`. But remember to add the key `-DCMAKE_SYSROOT=/opt/riscv/sysroot`, otherwise many fundamental headers and libs could not be found during cross compilation. + + Then run `make` to build the project: + ```sh + make install -j$(nproc) + ``` + +### (Optional) Build the OpenVINO Runtime Python API +To enable cross-compilation with python, the library `libpython3-dev:riscv64` should be on the host machine. + +When installing packages using the utilities `apt` or `apt-get` the packages are downloaded from apt software repositories. On Ubuntu the apt software repositories are defined in the `/etc/apt/sources.list` file or in separate files under the `/etc/apt/sources.list.d/` directory. Host machine contains host-specific repositories (for example, x86-x64) in these files. + +1. Add riscv64 repositories to download riscv64-specific packages: + ```sh + echo deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ jammy main >> riscv64-sources.list + echo deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ jammy universe >> riscv64-sources.list + echo deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ jammy-updates main >> riscv64-sources.list + echo deb [arch=riscv64] http://ports.ubuntu.com/ubuntu-ports/ jammy-security main >> riscv64-sources.list + mv riscv64-sources.list /etc/apt/sources.list.d/ + dpkg --add-architecture riscv64 + apt-get update -o Dir::Etc::sourcelist=/etc/apt/sources.list.d/riscv64-sources.list + ``` + +2. Install `libpython3-dev:riscv64` using `apt-get`: + ```sh + apt-get install -y --no-install-recommends libpython3-dev:riscv64 + ``` + Create symbolink to allow python to find `riscv64-linux-gnu/python3.10/pyconfig.h` in `/usr/include/python3.10/` (this header is initially stored in `/usr/include/riscv64-linux-gnu/`) + ```sh + ln -s /usr/include/riscv64-linux-gnu/ /usr/include/python3.10/ + ``` + +3. Add the keys `-DENABLE_PYTHON=ON -DENABLE_WHEEL=ON` to cmake command during OpenVINO build. + +> **Note**: Currently only Python 3.10 on Ubuntu 22.04 is verified. So the target device must have Python 3.10 in this case. + +### RISC-V Emulation software +In order to test applications without hardware one can use emulation software. The command line example to launch executable file with riscv64 emulation: +```sh +/bin/qemu-riscv64 -cpu= +``` + +For example, to emulate RVV 0.7.1: +```sh +/bin/qemu-riscv64 -cpu rv64,x-v=true,vext_spec=v0.7.1 +``` + +Or to emulate RVV 1.0: +```sh +/bin/qemu-riscv64 -cpu rv64,x-v=true,vext_spec=v1.0 +``` + +> **Note**: If you are using official `qemu` instead of modified version by Xuantie, you should specify the CPU model with `-cpu rv64,v=true,vext_spec=v1.0` (for `qemu` version greater than `8.0`). + +## See also + + * [OpenVINO README](../../README.md) + * [OpenVINO Developer Documentation](index.md) + * [OpenVINO Get Started](./get_started.md) + * [How to build OpenVINO](build.md) + From 45a6f33e630ff4c15b96fb8ee50d7ef489a563a1 Mon Sep 17 00:00:00 2001 From: Przemyslaw Wysocki Date: Thu, 22 Aug 2024 11:05:47 +0200 Subject: [PATCH 079/117] Allow `numpy==1.26` in MO for Python 3.12 enablement (#26118) ### Details: - `numpy==1.27` is the first version to support Python 3.12 - kaldi, mxnet and caffee will most likely fail with Python 3.12, TBD how to handle it - cc @culhatsker ### Tickets: - CVS-150017 --- tools/mo/requirements_caffe.txt | 2 +- tools/mo/requirements_kaldi.txt | 2 +- tools/mo/requirements_mxnet.txt | 2 +- tools/mo/requirements_onnx.txt | 2 +- tools/mo/requirements_tf.txt | 2 +- tools/mo/requirements_tf2.txt | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/tools/mo/requirements_caffe.txt b/tools/mo/requirements_caffe.txt index a8932f1873daaf..2806576890500c 100644 --- a/tools/mo/requirements_caffe.txt +++ b/tools/mo/requirements_caffe.txt @@ -1,5 +1,5 @@ -c ../constraints.txt -numpy>=1.16.6,<1.26 +numpy>=1.16.6,<1.27 networkx protobuf defusedxml diff --git a/tools/mo/requirements_kaldi.txt b/tools/mo/requirements_kaldi.txt index b31121df7bfa84..1365904679bd5f 100644 --- a/tools/mo/requirements_kaldi.txt +++ b/tools/mo/requirements_kaldi.txt @@ -1,5 +1,5 @@ -c ../constraints.txt -numpy>=1.16.6,<1.26 +numpy>=1.16.6,<1.27 networkx defusedxml requests diff --git a/tools/mo/requirements_mxnet.txt b/tools/mo/requirements_mxnet.txt index 8b6561f761b00d..bb4ec290ed5912 100644 --- a/tools/mo/requirements_mxnet.txt +++ b/tools/mo/requirements_mxnet.txt @@ -1,5 +1,5 @@ -c ../constraints.txt -numpy>=1.16.6,<1.24 +numpy>=1.16.6,<1.27 mxnet networkx defusedxml diff --git a/tools/mo/requirements_onnx.txt b/tools/mo/requirements_onnx.txt index f1f52bb03c25fa..28484f314a9d60 100644 --- a/tools/mo/requirements_onnx.txt +++ b/tools/mo/requirements_onnx.txt @@ -1,5 +1,5 @@ -c ../constraints.txt -numpy>=1.16.6,<1.26 +numpy>=1.16.6,<1.27 onnx networkx defusedxml diff --git a/tools/mo/requirements_tf.txt b/tools/mo/requirements_tf.txt index f83e3ee69f4321..abf7c3a5f6400d 100644 --- a/tools/mo/requirements_tf.txt +++ b/tools/mo/requirements_tf.txt @@ -1,7 +1,7 @@ -c ../constraints.txt h5py tensorflow>=1.15.5,<2.17.0 -numpy>=1.16.6,<1.26 +numpy>=1.16.6,<1.27 networkx defusedxml requests diff --git a/tools/mo/requirements_tf2.txt b/tools/mo/requirements_tf2.txt index af80835e3728fe..be055b38cdefa7 100644 --- a/tools/mo/requirements_tf2.txt +++ b/tools/mo/requirements_tf2.txt @@ -1,7 +1,7 @@ -c ../constraints.txt h5py tensorflow>=2.5,<2.17.0 -numpy>=1.16.6,<1.26 +numpy>=1.16.6,<1.27 networkx defusedxml requests From e26f63e397bb4b00540c698b3c7186e25999c36c Mon Sep 17 00:00:00 2001 From: Piotr Kowalczyk Date: Thu, 22 Aug 2024 11:12:31 +0200 Subject: [PATCH 080/117] [GPU]: Added initial support for bitwise shifts with unittests. (#26046) ### Details: - Added support for bitwise shifts in gpu plugin - updated tests ### Tickets: - *CVS-149424* --- .../intel_gpu/plugin/primitives_list.hpp | 4 +- .../include/intel_gpu/primitives/eltwise.hpp | 4 + src/plugins/intel_gpu/src/graph/eltwise.cpp | 16 ++- .../intel_gpu/src/graph/impls/cpu/eltwise.cpp | 8 ++ .../intel_gpu/src/graph/impls/ocl/eltwise.cpp | 8 ++ .../impls/ocl/kernel_selector_helper.cpp | 4 + .../graph/impls/ocl/kernel_selector_helper.h | 5 + .../src/kernel_selector/common_types.h | 2 + .../kernels/eltwise/eltwise_kernel_base.cpp | 8 ++ .../kernels/eltwise/eltwise_kernel_ref.cpp | 2 + .../intel_gpu/src/plugin/ops/constant.cpp | 8 +- .../intel_gpu/src/plugin/ops/eltwise.cpp | 12 +++ .../single_layer_tests/eltwise.cpp | 22 +++++ .../unit/test_cases/eltwise_gpu_test.cpp | 97 +++++++++++++++---- .../include/common_test_utils/test_enums.hpp | 4 +- .../src/node_builders/eltwise.cpp | 6 ++ .../common_test_utils/src/test_enums.cpp | 6 ++ 17 files changed, 192 insertions(+), 24 deletions(-) diff --git a/src/plugins/intel_gpu/include/intel_gpu/plugin/primitives_list.hpp b/src/plugins/intel_gpu/include/intel_gpu/plugin/primitives_list.hpp index e61542a0c50dfc..408f3dfb7cf2d4 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/plugin/primitives_list.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/plugin/primitives_list.hpp @@ -265,8 +265,10 @@ REGISTER_FACTORY(v12, ScatterElementsUpdate); REGISTER_FACTORY(v13, Multinomial); REGISTER_FACTORY(v13, ScaledDotProductAttention); -// ------------------------------ Supported v14 ops ----------------------------- // +// ------------------------------ Supported v15 ops ----------------------------- // REGISTER_FACTORY(v15, ROIAlignRotated); +REGISTER_FACTORY(v15, BitwiseRightShift); +REGISTER_FACTORY(v15, BitwiseLeftShift); // --------------------------- Supported internal ops --------------------------- // REGISTER_FACTORY(internal, NonMaxSuppressionIEInternal); diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/eltwise.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/eltwise.hpp index 81612a8c660558..7913435324e89d 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/primitives/eltwise.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/eltwise.hpp @@ -54,6 +54,10 @@ enum class eltwise_mode : int32_t { is_inf, /// @brief Eltwise is nan. is_nan, + /// @brief Eltwise bitwise right shift. + right_shift, + /// @brief Eltwise bitwise left shift. + left_shift, }; /// @brief Performs elementwise operations (sum, subtract, max or product) on two input primitives diff --git a/src/plugins/intel_gpu/src/graph/eltwise.cpp b/src/plugins/intel_gpu/src/graph/eltwise.cpp index c55d84e73c6293..0791a44014a079 100644 --- a/src/plugins/intel_gpu/src/graph/eltwise.cpp +++ b/src/plugins/intel_gpu/src/graph/eltwise.cpp @@ -79,7 +79,9 @@ layout eltwise_inst::calc_output_layout(eltwise_node const& node, kernel_impl_pa eltwise_mode::floor_mod, eltwise_mode::logic_and, eltwise_mode::logic_or, - eltwise_mode::logic_xor}; + eltwise_mode::logic_xor, + eltwise_mode::right_shift, + eltwise_mode::left_shift}; if (std::find(eltwise_int_modes.begin(), eltwise_int_modes.end(), mode) == eltwise_int_modes.end()) CLDNN_ERROR_MESSAGE(desc->id, "Requested eltwise mode is not supported for integer types."); } @@ -177,7 +179,9 @@ std::vector eltwise_inst::calc_output_layouts(eltwise_node const& /*node eltwise_mode::floor_mod, eltwise_mode::logic_and, eltwise_mode::logic_or, - eltwise_mode::logic_xor}; + eltwise_mode::logic_xor, + eltwise_mode::right_shift, + eltwise_mode::left_shift}; OPENVINO_ASSERT((std::find(eltwise_int_modes.begin(), eltwise_int_modes.end(), mode) != eltwise_int_modes.end()), desc->id + "Requested eltwise mode is not supported for integer types."); @@ -305,6 +309,12 @@ std::string eltwise_inst::to_string(eltwise_node const& node) { case eltwise_mode::is_nan: str_mode = "is_nan"; break; + case eltwise_mode::right_shift: + str_mode = "right_shift"; + break; + case eltwise_mode::left_shift: + str_mode = "left_shift"; + break; default: str_mode = "not supported mode"; break; @@ -428,6 +438,8 @@ void eltwise_inst::check_inputs_count(eltwise_node const& node) { case eltwise_mode::squared_diff: case eltwise_mode::pow: case eltwise_mode::floor_mod: + case eltwise_mode::right_shift: + case eltwise_mode::left_shift: OPENVINO_ASSERT(inputs_number == 2, "Node id: ", node.id(), ". Invalid eltwise inputs number (should be equal to 2). Actual: ", inputs_number); break; diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp index eb10f340d2656b..8b95cfc626fa44 100644 --- a/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp +++ b/src/plugins/intel_gpu/src/graph/impls/cpu/eltwise.cpp @@ -29,6 +29,8 @@ #include "openvino/op/is_finite.hpp" #include "openvino/op/is_inf.hpp" #include "openvino/op/is_nan.hpp" +#include "openvino/op/bitwise_right_shift.hpp" +#include "openvino/op/bitwise_left_shift.hpp" namespace cldnn { namespace cpu { @@ -166,6 +168,12 @@ struct eltwise_impl : public typed_primitive_impl { case eltwise_mode::is_nan: op = std::make_shared(); break; + case eltwise_mode::right_shift: + op = std::make_shared(); + break; + case eltwise_mode::left_shift: + op = std::make_shared(); + break; default: OPENVINO_THROW("[GPU] Couldn't create eltwise operation: unsupported eltwise operation (", static_cast(mode), ")"); } diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp index 1b4a63a1c240ad..0e85aa7e294d21 100644 --- a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp +++ b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp @@ -171,6 +171,7 @@ attach_eltwise_impl::attach_eltwise_impl() { data_types::i8, data_types::u8, data_types::i32, + data_types::u32, data_types::i64 }; @@ -193,12 +194,14 @@ attach_eltwise_impl::attach_eltwise_impl() { std::make_tuple(data_types::f16, format::yxfb), std::make_tuple(data_types::i8, format::yxfb), std::make_tuple(data_types::u8, format::yxfb), + std::make_tuple(data_types::u32, format::yxfb), std::make_tuple(data_types::i32, format::yxfb), std::make_tuple(data_types::i64, format::yxfb), std::make_tuple(data_types::f32, format::bfyx), std::make_tuple(data_types::f16, format::bfyx), std::make_tuple(data_types::u8, format::bfyx), + std::make_tuple(data_types::u32, format::bfyx), std::make_tuple(data_types::i8, format::bfyx), std::make_tuple(data_types::i32, format::bfyx), std::make_tuple(data_types::i64, format::bfyx), @@ -207,6 +210,7 @@ attach_eltwise_impl::attach_eltwise_impl() { std::make_tuple(data_types::f16, format::byxf), std::make_tuple(data_types::i8, format::byxf), std::make_tuple(data_types::u8, format::byxf), + std::make_tuple(data_types::u32, format::byxf), std::make_tuple(data_types::i32, format::byxf), std::make_tuple(data_types::i64, format::byxf), @@ -219,6 +223,7 @@ attach_eltwise_impl::attach_eltwise_impl() { std::make_tuple(data_types::f16, format::bfzyx), std::make_tuple(data_types::i8, format::bfzyx), std::make_tuple(data_types::u8, format::bfzyx), + std::make_tuple(data_types::u32, format::bfzyx), std::make_tuple(data_types::i32, format::bfzyx), std::make_tuple(data_types::i64, format::bfzyx), @@ -226,6 +231,7 @@ attach_eltwise_impl::attach_eltwise_impl() { std::make_tuple(data_types::f16, format::bfwzyx), std::make_tuple(data_types::i8, format::bfwzyx), std::make_tuple(data_types::u8, format::bfwzyx), + std::make_tuple(data_types::u32, format::bfwzyx), std::make_tuple(data_types::i32, format::bfwzyx), std::make_tuple(data_types::i64, format::bfwzyx), @@ -233,6 +239,7 @@ attach_eltwise_impl::attach_eltwise_impl() { std::make_tuple(data_types::f16, format::bfuwzyx), std::make_tuple(data_types::i8, format::bfuwzyx), std::make_tuple(data_types::u8, format::bfuwzyx), + std::make_tuple(data_types::u32, format::bfuwzyx), std::make_tuple(data_types::i32, format::bfuwzyx), std::make_tuple(data_types::i64, format::bfuwzyx), @@ -240,6 +247,7 @@ attach_eltwise_impl::attach_eltwise_impl() { std::make_tuple(data_types::f16, format::bfvuwzyx), std::make_tuple(data_types::i8, format::bfvuwzyx), std::make_tuple(data_types::u8, format::bfvuwzyx), + std::make_tuple(data_types::u32, format::bfvuwzyx), std::make_tuple(data_types::i32, format::bfvuwzyx), std::make_tuple(data_types::i64, format::bfvuwzyx), diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.cpp index 2ebcebd3b0b48f..1e6d06755a7a86 100644 --- a/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.cpp +++ b/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.cpp @@ -173,6 +173,8 @@ kernel_selector::data_type to_data_type(data_types dt) { return kernel_selector::data_type::UINT8; case cldnn::data_types::i32: return kernel_selector::data_type::INT32; + case cldnn::data_types::u32: + return kernel_selector::data_type::UINT32; case cldnn::data_types::i64: return kernel_selector::data_type::INT64; case cldnn::data_types::f16: @@ -198,6 +200,8 @@ data_types from_data_type(kernel_selector::data_type dt) { return cldnn::data_types::u8; case kernel_selector::data_type::INT32: return cldnn::data_types::i32; + case kernel_selector::data_type::UINT32: + return cldnn::data_types::u32; case kernel_selector::data_type::INT64: return cldnn::data_types::i64; case kernel_selector::data_type::F16: diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h b/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h index e17fb1c7045c17..59a7e8e9627b14 100644 --- a/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h +++ b/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h @@ -200,7 +200,12 @@ inline kernel_selector::eltwise_mode convert_to_eltwise_mode(eltwise_mode mode) return kernel_selector::eltwise_mode::IS_INF; case eltwise_mode::is_nan: return kernel_selector::eltwise_mode::IS_NAN; + case eltwise_mode::right_shift: + return kernel_selector::eltwise_mode::RIGHT_SHIFT; + case eltwise_mode::left_shift: + return kernel_selector::eltwise_mode::LEFT_SHIFT; default: + OPENVINO_ASSERT(false, "Unsupported eltwise mode!"); return kernel_selector::eltwise_mode::ADD; } } diff --git a/src/plugins/intel_gpu/src/kernel_selector/common_types.h b/src/plugins/intel_gpu/src/kernel_selector/common_types.h index bf96ff16aa4c8f..12e685e0b091f6 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/common_types.h +++ b/src/plugins/intel_gpu/src/kernel_selector/common_types.h @@ -304,6 +304,8 @@ enum class EltwiseMode { IS_FINITE, IS_INF, IS_NAN, + RIGHT_SHIFT, + LEFT_SHIFT, }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp index 94b6ac46e9362f..da46e89002e2c4 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp +++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_base.cpp @@ -49,6 +49,8 @@ uint32_t GetNumberOfInputs(EltwiseMode m) { case EltwiseMode::LOGIC_XOR: case EltwiseMode::SQUARED_DIFF: case EltwiseMode::FLOOR_MOD: + case EltwiseMode::RIGHT_SHIFT: + case EltwiseMode::LEFT_SHIFT: return 2; case EltwiseMode::SQRT: case EltwiseMode::RSQRT: @@ -313,6 +315,12 @@ JitConstants EltwiseKernelBase::GetOperationsJitConstants(const eltwise_params& case EltwiseMode::IS_NAN: op += "(isnan(" + input0_str + "))"; break; + case EltwiseMode::RIGHT_SHIFT: + op += "(" + input0_str + " >> " + input1_str + ")"; + break; + case EltwiseMode::LEFT_SHIFT: + op += "(" + input0_str + " << " + input1_str + ")"; + break; default: break; } diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_ref.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_ref.cpp index 1f598759fb1580..71f72d68089f25 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_ref.cpp +++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/eltwise/eltwise_kernel_ref.cpp @@ -14,12 +14,14 @@ ParamsKey EltwiseKernelRef::GetSupportedKey() const { k.EnableInputDataType(Datatype::INT8); k.EnableInputDataType(Datatype::UINT8); k.EnableInputDataType(Datatype::INT32); + k.EnableInputDataType(Datatype::UINT32); k.EnableInputDataType(Datatype::INT64); k.EnableOutputDataType(Datatype::F16); k.EnableOutputDataType(Datatype::F32); k.EnableOutputDataType(Datatype::INT8); k.EnableOutputDataType(Datatype::UINT8); k.EnableOutputDataType(Datatype::INT32); + k.EnableOutputDataType(Datatype::UINT32); k.EnableOutputDataType(Datatype::INT64); k.EnableDifferentTypes(); k.EnableAllInputLayout(); diff --git a/src/plugins/intel_gpu/src/plugin/ops/constant.cpp b/src/plugins/intel_gpu/src/plugin/ops/constant.cpp index ec48aff9736a9a..f87c2b39848d09 100644 --- a/src/plugins/intel_gpu/src/plugin/ops/constant.cpp +++ b/src/plugins/intel_gpu/src/plugin/ops/constant.cpp @@ -22,6 +22,7 @@ #include "openvino/op/util/op_types.hpp" #include "openvino/op/loop.hpp" #include "openvino/op/tensor_iterator.hpp" +#include "openvino/op/util/binary_elementwise_bitwise.hpp" #include "intel_gpu/primitives/data.hpp" #include "intel_gpu/runtime/debug_configuration.hpp" @@ -126,6 +127,10 @@ static void create_data(ProgramBuilder& p, const ov::Shape& const_shape, const s } } +static bool is_btiwise(Node* node) { + return dynamic_cast(node) != nullptr; +} + static void CreateConstantOp(ProgramBuilder& p, const std::shared_ptr& op) { ov::Shape constDims = op->get_shape(); auto constUsers = op->get_output_target_inputs(0); @@ -137,7 +142,8 @@ static void CreateConstantOp(ProgramBuilder& p, const std::shared_ptr bool { if (ov::op::util::is_binary_elementwise_arithmetic(op) || ov::op::util::is_binary_elementwise_logical(op) || - ov::op::util::is_binary_elementwise_comparison(op)) { + ov::op::util::is_binary_elementwise_comparison(op) || + is_btiwise(op)) { return true; } else { return false; diff --git a/src/plugins/intel_gpu/src/plugin/ops/eltwise.cpp b/src/plugins/intel_gpu/src/plugin/ops/eltwise.cpp index 0c70da0938da59..2866e9151e214d 100644 --- a/src/plugins/intel_gpu/src/plugin/ops/eltwise.cpp +++ b/src/plugins/intel_gpu/src/plugin/ops/eltwise.cpp @@ -29,6 +29,8 @@ #include "openvino/op/xor.hpp" #include "openvino/op/power.hpp" #include "openvino/op/floor_mod.hpp" +#include "openvino/op/bitwise_right_shift.hpp" +#include "openvino/op/bitwise_left_shift.hpp" #include "intel_gpu/primitives/activation.hpp" #include "intel_gpu/primitives/eltwise.hpp" @@ -198,6 +200,14 @@ static void CreateIsNaNOp(ProgramBuilder& p, const std::shared_ptr& op) { + CreateElementwiseOp(p, op, cldnn::eltwise_mode::right_shift); +} + +static void CreateBitwiseLeftShiftOp(ProgramBuilder& p, const std::shared_ptr& op) { + CreateElementwiseOp(p, op, cldnn::eltwise_mode::left_shift); +} + REGISTER_FACTORY_IMPL(v1, Add); REGISTER_FACTORY_IMPL(v1, Multiply); REGISTER_FACTORY_IMPL(v1, Maximum); @@ -220,6 +230,8 @@ REGISTER_FACTORY_IMPL(v1, Mod); REGISTER_FACTORY_IMPL(v10, IsFinite); REGISTER_FACTORY_IMPL(v10, IsInf); REGISTER_FACTORY_IMPL(v10, IsNaN); +REGISTER_FACTORY_IMPL(v15, BitwiseRightShift); +REGISTER_FACTORY_IMPL(v15, BitwiseLeftShift); } // namespace intel_gpu } // namespace ov diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp index 526bde9495661d..c5447983ba9492 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp @@ -66,8 +66,30 @@ std::vector eltwiseOpTypes = { EltwiseTypes::MOD }; +std::vector smoke_intOnly_eltwiseOpTypes = { + EltwiseTypes::RIGHT_SHIFT +}; + +std::vector intOnly_netPrecisions = { + ov::element::i32 +}; + ov::AnyMap additional_config = {}; +INSTANTIATE_TEST_SUITE_P( + smoke_intOnly_CompareWithRefs, + EltwiseLayerTest, + ::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inShapes)), + ::testing::ValuesIn(smoke_intOnly_eltwiseOpTypes), + ::testing::ValuesIn(secondaryInputTypes), + ::testing::ValuesIn(opTypes), + ::testing::ValuesIn(intOnly_netPrecisions), + ::testing::Values(ov::element::undefined), + ::testing::Values(ov::element::undefined), + ::testing::Values(ov::test::utils::DEVICE_GPU), + ::testing::Values(additional_config)), + EltwiseLayerTest::getTestCaseName); + INSTANTIATE_TEST_SUITE_P( smoke_CompareWithRefs, EltwiseLayerTest, diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/eltwise_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/eltwise_gpu_test.cpp index 690e570e42ec68..1ae82b70ff1d41 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/eltwise_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/eltwise_gpu_test.cpp @@ -170,8 +170,8 @@ void run_eltwise_generic_test(cldnn::eltwise_mode mode) { } -template -int8_t eltwise_bool_execute(cldnn::eltwise_mode mode, T x, T y) { +template +TOut eltwise_int_execute(cldnn::eltwise_mode mode, T x, T y) { switch (mode) { case eltwise_mode::eq: return x == y; @@ -189,13 +189,17 @@ int8_t eltwise_bool_execute(cldnn::eltwise_mode mode, T x, T y) { return x && y; case eltwise_mode::logic_or: return x || y; + case eltwise_mode::right_shift: + return x >> y; + case eltwise_mode::left_shift: + return x << y; default: - return (int8_t)0; + return (TOut)0; } } -template -VVVVF eltwise_bool_reference(VVVVF &input1, VVVVF &input2, +template +VVVVF eltwise_int_reference(VVVVF &input1, VVVVF &input2, cldnn::eltwise_mode mode, int input_padding_y = 0, int input_padding_x = 0, int output_padding_y = 0, int output_padding_x = 0) { @@ -206,14 +210,14 @@ VVVVF eltwise_bool_reference(VVVVF &input1, VVVVF &input2, size_t output_f = input1[0].size(); size_t output_y = input1[0][0].size() + 2 * padding_y; size_t output_x = input1[0][0][0].size() + 2 * padding_x; - VVVVF output(output_b, VVVF(output_f, VVF(output_y, VF(output_x)))); + VVVVF output(output_b, VVVF(output_f, VVF(output_y, VF(output_x)))); T res; for (size_t b = 0; b < output_b; ++b) { for (size_t f = 0; f < output_f; ++f) { for (size_t y = 0; y < input1[0][0].size(); ++y) { for (size_t x = 0; x < input1[0][0][0].size(); ++x) { - res = eltwise_bool_execute(mode, input1[b][f][y][x], input2[b][f][y][x]); + res = eltwise_int_execute(mode, input1[b][f][y][x], input2[b][f][y][x]); output[b][f][y + padding_y][x + padding_x] = res; } } @@ -222,14 +226,28 @@ VVVVF eltwise_bool_reference(VVVVF &input1, VVVVF &input2, return output; } -template -void generic_eltwise_bool_test(cldnn::format test_input_fmt, int input_b, int input_f, int input_y, int input_x, cldnn::eltwise_mode mode, - int input_padding_y, int input_padding_x, int output_padding_y, int output_padding_x) { +template +void generic_eltwise_int_test(cldnn::format test_input_fmt, + int input_b, + int input_f, + int input_y, + int input_x, + cldnn::eltwise_mode mode, + int input_padding_y, + int input_padding_x, + int output_padding_y, + int output_padding_x, + int input1_min_val, + int input1_max_val, + int input2_min_val, + int input2_max_val) { + static_assert(std::is_integral::value, "T must be an integral type"); + static_assert(std::is_integral::value, "TOut must be an integral type"); + tests::random_generator rg(GET_SUITE_NAME); - int min_random = -2, max_random = 2; - VVVVF input1_rnd = rg.generate_random_4d(input_b, input_f, input_y, input_x, min_random, max_random); - VVVVF input2_rnd = rg.generate_random_4d(input_b, input_f, input_y, input_x, min_random, max_random); + VVVVF input1_rnd = rg.generate_random_4d(input_b, input_f, input_y, input_x, input1_min_val, input1_max_val); + VVVVF input2_rnd = rg.generate_random_4d(input_b, input_f, input_y, input_x, input2_min_val, input2_max_val); VF input1_rnd_vec = flatten_4d(test_input_fmt, input1_rnd); VF input2_rnd_vec = flatten_4d(test_input_fmt, input2_rnd); @@ -257,9 +275,9 @@ void generic_eltwise_bool_test(cldnn::format test_input_fmt, int input_b, int in auto output_memory = outputs.at("eltwise").get_memory(); auto output_layout = output_memory->get_layout(); - cldnn::mem_lock output_ptr(output_memory, get_test_stream()); + cldnn::mem_lock output_ptr(output_memory, get_test_stream()); - VVVVF output_cpu = eltwise_bool_reference(input1_rnd, input2_rnd, mode, input_padding_y, input_padding_x, output_padding_y, output_padding_x); + VVVVF output_cpu = eltwise_int_reference(input1_rnd, input2_rnd, mode, input_padding_y, input_padding_x, output_padding_y, output_padding_x); ASSERT_EQ(output_layout.format.value, test_input_fmt.value); auto output_tensor = output_layout.get_padded_dims(); int x_size = output_tensor[3]; @@ -273,9 +291,11 @@ void generic_eltwise_bool_test(cldnn::format test_input_fmt, int input_b, int in ASSERT_EQ(b_size, (int)output_cpu.size()); bool test_is_correct = true; - VF output_cpu_vec = flatten_4d(test_input_fmt, output_cpu); + VF output_cpu_vec = flatten_4d(test_input_fmt, output_cpu); for (size_t i = 0; i < output_cpu_vec.size(); ++i) { - if (output_cpu_vec[i] != output_ptr[i]) { + const TOut cpu_val = output_cpu_vec[i]; + const TOut gpu_val = output_ptr[i]; + if (cpu_val != gpu_val) { test_is_correct = false; break; } @@ -299,8 +319,39 @@ void run_eltwise_bool_generic_test(cldnn::eltwise_mode mode) cldnn::format test_inputs_fmt = cldnn::format::bfyx; std::pair input_size = { 227, 227 }; - generic_eltwise_bool_test(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, 0, 0, 0, 0); - generic_eltwise_bool_test(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, 0, 0, 0, 0); + generic_eltwise_int_test(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, 0, 0, 0, 0, -2, 2, -2, 2); + generic_eltwise_int_test(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, 0, 0, 0, 0, -2, 2, -2, 2); +} + +void run_eltwise_int_shift_generic_test(cldnn::eltwise_mode mode) { + OPENVINO_ASSERT(mode == eltwise_mode::right_shift || mode == eltwise_mode::left_shift, + "Only right_shift amd left_shift mode is supported for this test"); + cldnn::format test_inputs_fmt = cldnn::format::bfyx; + const int dim_size = 227; + +#define ELTWISE_INT_TEST_CASES(type) \ + generic_eltwise_int_test(test_inputs_fmt, \ + 1, \ + 1, \ + dim_size, \ + dim_size, \ + mode, \ + 0, \ + 0, \ + 0, \ + 0, \ + 0, \ + static_cast(std::numeric_limits::max()) / 2, \ + 0, \ + ((sizeof(type) * 8) - 1) / 2); + + ELTWISE_INT_TEST_CASES(int8_t); + ELTWISE_INT_TEST_CASES(uint8_t); + ELTWISE_INT_TEST_CASES(int32_t); + ELTWISE_INT_TEST_CASES(uint32_t); + ELTWISE_INT_TEST_CASES(int64_t); + +#undef ELTWISE_INT_TEST_CASES } } // namespace @@ -3894,6 +3945,14 @@ TEST(eltwise_gpu_bool, eltwise_or) { run_eltwise_bool_generic_test(cldnn::eltwise_mode::logic_or); } +TEST(eltwise_gpu, eltwise_right_shift) { + run_eltwise_int_shift_generic_test(cldnn::eltwise_mode::right_shift); +} + +TEST(eltwise_gpu, eltwise_left_shift) { + run_eltwise_int_shift_generic_test(cldnn::eltwise_mode::left_shift); +} + TEST(eltwise_gpu, eltwise_div) { run_eltwise_generic_test(cldnn::eltwise_mode::div); } diff --git a/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp b/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp index 7b8e4b8834f854..8a7fe4fec02874 100644 --- a/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp +++ b/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp @@ -60,7 +60,9 @@ enum EltwiseTypes { BITWISE_AND, BITWISE_NOT, BITWISE_OR, - BITWISE_XOR + BITWISE_XOR, + RIGHT_SHIFT, + LEFT_SHIFT }; enum SqueezeOpType { diff --git a/src/tests/test_utils/common_test_utils/src/node_builders/eltwise.cpp b/src/tests/test_utils/common_test_utils/src/node_builders/eltwise.cpp index 262ceb30187137..b5c792aa26e021 100644 --- a/src/tests/test_utils/common_test_utils/src/node_builders/eltwise.cpp +++ b/src/tests/test_utils/common_test_utils/src/node_builders/eltwise.cpp @@ -6,8 +6,10 @@ #include "openvino/op/add.hpp" #include "openvino/op/bitwise_and.hpp" +#include "openvino/op/bitwise_left_shift.hpp" #include "openvino/op/bitwise_not.hpp" #include "openvino/op/bitwise_or.hpp" +#include "openvino/op/bitwise_right_shift.hpp" #include "openvino/op/bitwise_xor.hpp" #include "openvino/op/divide.hpp" #include "openvino/op/erf.hpp" @@ -51,6 +53,10 @@ std::shared_ptr make_eltwise(const ov::Output& in0, return std::make_shared(in0, in1); case ov::test::utils::EltwiseTypes::BITWISE_XOR: return std::make_shared(in0, in1); + case ov::test::utils::EltwiseTypes::RIGHT_SHIFT: + return std::make_shared(in0, in1); + case ov::test::utils::EltwiseTypes::LEFT_SHIFT: + return std::make_shared(in0, in1); default: { OPENVINO_THROW("Incorrect type of Eltwise operation"); } diff --git a/src/tests/test_utils/common_test_utils/src/test_enums.cpp b/src/tests/test_utils/common_test_utils/src/test_enums.cpp index 83ab16fc34d2d0..219aeec1e9fa50 100644 --- a/src/tests/test_utils/common_test_utils/src/test_enums.cpp +++ b/src/tests/test_utils/common_test_utils/src/test_enums.cpp @@ -82,6 +82,12 @@ std::ostream& operator<<(std::ostream& os, const ov::test::utils::EltwiseTypes t case ov::test::utils::EltwiseTypes::BITWISE_XOR: os << "BitwiseXor"; break; + case ov::test::utils::EltwiseTypes::RIGHT_SHIFT: + os << "BitwiseRightShift"; + break; + case ov::test::utils::EltwiseTypes::LEFT_SHIFT: + os << "BitwiseLeftShift"; + break; default: throw std::runtime_error("NOT_SUPPORTED_OP_TYPE"); } From 49601012d05a9e5bb5b36ce42e96668a80d2c893 Mon Sep 17 00:00:00 2001 From: Mingyu Kim Date: Thu, 22 Aug 2024 19:28:34 +0900 Subject: [PATCH 081/117] [GPU] propagate fc output type for dynamic quantization case (#26133) ### Details: - When FC output type is undefined, propagate the original input type - Otherwise, dynamic_quantized type is propagated ### Tickets: - 149663 --- .../dynamic_quantize_fully_connected.cpp | 7 +++- .../transformations/fc_horizontal_fusion.cpp | 13 +++++- .../dynamic/dynamic_fc_horizontal_fusion.cpp | 42 ++++++++++++++++--- .../dynamic/matmul_weights_decompression.cpp | 6 +-- 4 files changed, 56 insertions(+), 12 deletions(-) diff --git a/src/plugins/intel_gpu/src/plugin/transformations/dynamic_quantize_fully_connected.cpp b/src/plugins/intel_gpu/src/plugin/transformations/dynamic_quantize_fully_connected.cpp index a2e4a1a38983c8..eb16213bcb936c 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations/dynamic_quantize_fully_connected.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations/dynamic_quantize_fully_connected.cpp @@ -64,13 +64,18 @@ DynamicQuantizeFullyConnected::DynamicQuantizeFullyConnected(uint64_t group_size auto dyn_quan = std::make_shared(m_data, shape_group_size, element::f16); auto optional_w_zp = m_fc->get_input_size() > 4 ? m_fc->get_input_node_shared_ptr(4) : std::make_shared(); + auto output_type = m_fc->get_output_type(); + if (output_type == ov::element::undefined) + output_type = m_fc->get_input_element_type(0); + auto new_fc = std::make_shared(dyn_quan->output(0), m_fc->get_input_node_shared_ptr(1), m_fc->get_input_node_shared_ptr(2), m_fc->get_input_node_shared_ptr(3), optional_w_zp, dyn_quan->output(1), - m_fc->get_output_type()); + output_type); + ov::replace_node(m_fc, new_fc); new_fc->set_friendly_name(m_fc->get_friendly_name()); diff --git a/src/plugins/intel_gpu/src/plugin/transformations/fc_horizontal_fusion.cpp b/src/plugins/intel_gpu/src/plugin/transformations/fc_horizontal_fusion.cpp index 14bb5596b1cc12..a5ec6c0060ef81 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations/fc_horizontal_fusion.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations/fc_horizontal_fusion.cpp @@ -169,9 +169,18 @@ FullyConnectedHorizontalFusion::FullyConnectedHorizontalFusion() { // Create new fc with merged weights, bias, scale, zp std::shared_ptr new_fc; if (fused_zps) - new_fc = std::make_shared(input_node, fused_weight, fused_bias, fused_scale, fused_zps); + new_fc = std::make_shared(input_node, + fused_weight, + fused_bias, + fused_scale, + fused_zps, + fc_nodes[0]->get_output_type()); else - new_fc = std::make_shared(input_node, fused_weight, fused_bias, fused_scale); + new_fc = std::make_shared(input_node, + fused_weight, + fused_bias, + fused_scale, + fc_nodes[0]->get_output_type()); auto new_fc_name = fc_nodes[0]->get_friendly_name() + "_fused"; new_fc->set_friendly_name(new_fc_name); diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_fc_horizontal_fusion.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_fc_horizontal_fusion.cpp index 4aad7f554a0dfa..47dfb8ab3b80da 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_fc_horizontal_fusion.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_fc_horizontal_fusion.cpp @@ -38,7 +38,9 @@ using FullyConnectedHorizontalFusionParams = std::tuple; // has biahs + bool, // has bias + uint64_t // dynamic_quantization_group_size + >; class FullyConnectedHorizontalFusion : public testing::WithParamInterface, @@ -53,6 +55,7 @@ class FullyConnectedHorizontalFusion : public testing::WithParamInterface& m_pool_gpr_idxs; + Reg64 m_aux_gpr_idx {}; + bool m_is_preserved = false; +}; +} // namespace + /* ================== jit_loop_begin_emitter ====================== */ jit_loop_begin_emitter::jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, @@ -30,12 +76,6 @@ jit_loop_begin_emitter::jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generat in_out_type_ = emitter_in_out_map::gpr_to_gpr; } -size_t jit_loop_begin_emitter::aux_gprs_count() const { - // We should have aux GPR to store Loop arguments from `runtime_args` - // where we will take all needed information about the current loop: work amount - return is_work_amount_dynamic ? 1 : 0; -} - void jit_loop_begin_emitter::validate_arguments(const std::vector &in, const std::vector &out) const { OV_CPU_JIT_EMITTER_ASSERT(in.empty(), "Invalid inputs size: expected 0 got " + std::to_string(in.size())); // Note: the only expected output is work amount register (communicated to jit_loop_end_emitter) @@ -59,10 +99,10 @@ void jit_loop_begin_emitter::emit_impl(const std::vector& in, const std: Reg64 reg_work_amount = Reg64(static_cast(out.back())); if (is_work_amount_dynamic) { - Reg64 reg_runtime_params = abi_param1; // defined by jit_kernel_emitter - Reg64 reg_loop_args_ptr = Reg64(static_cast(aux_gpr_idxs[0])); + jit_aux_gpr_holder gpr_holder(h, aux_gpr_idxs, out); // loop_begin has only output registers + Reg64 reg_loop_args_ptr = gpr_holder.get_reg(); const auto id_offset = loop_id * sizeof(jit_snippets_call_args::loop_args_t); - h->mov(reg_loop_args_ptr, h->ptr[reg_runtime_params + GET_OFF(loop_args)]); + h->mov(reg_loop_args_ptr, h->ptr[abi_param1 + GET_OFF(loop_args)]); h->mov(reg_work_amount, h->ptr[reg_loop_args_ptr + id_offset + GET_OFF_LOOP_ARGS(m_work_amount)]); } else { h->mov(reg_work_amount, work_amount); @@ -141,37 +181,37 @@ void jit_loop_end_emitter::emit_code(const std::vector &in, const std::v jit_emitter::emit_code(in, out, pool_vec_idxs, pool_gpr_idxs); } -size_t jit_loop_end_emitter::aux_gprs_count() const { - // We should have aux GPR to store Loop arguments from `runtime_args` - // where we will take all needed information about the current loop: data pointer shifts - return are_ptr_shifts_dynamic ? 1 : 0; -} - void jit_loop_end_emitter::emit_impl(const std::vector& in, const std::vector& out) const { std::vector data_ptr_reg_idxs; // the last input is actually a work_amount reg data_ptr_reg_idxs.reserve(num_inputs + num_outputs); std::copy(in.begin(), in.end() - 1, std::back_inserter(data_ptr_reg_idxs)); - const auto id_offset = loop_id * sizeof(jit_snippets_call_args::loop_args_t); - Reg64 reg_increments = are_ptr_shifts_dynamic ? Reg64(static_cast(aux_gpr_idxs[0])) : Reg64(); - auto apply_increments = [&](bool use_runtime_args, size_t field_offset, const std::vector& increments, size_t scale) { - if (use_runtime_args) { - Reg64 reg_runtime_params = abi_param1; /* defined by jit_kernel_emitter */ - h->mov(reg_increments, h->ptr[reg_runtime_params + GET_OFF(loop_args)]); - h->mov(reg_increments, h->ptr[reg_increments + id_offset + field_offset]); - } - for (size_t idx = 0; idx < data_ptr_reg_idxs.size(); idx++) { - const auto& increment = increments[idx]; - if (is_incremented[idx] && increment != 0) { - if (ov::snippets::utils::is_dynamic_value(increment)) { - OV_CPU_JIT_EMITTER_ASSERT(use_runtime_args, "Loop argument structure cannot be pushed to aux GPR"); - h->add(Reg64(static_cast(data_ptr_reg_idxs[idx])), h->ptr[reg_increments + idx * sizeof(int64_t)]); - } else { - h->add(Reg64(static_cast(data_ptr_reg_idxs[idx])), increment * scale * data_sizes[idx]); + Reg64 reg_increments; + auto add_increments = [&]() { + for (size_t idx = 0; idx < data_ptr_reg_idxs.size(); idx++) { + const auto& increment = increments[idx]; + if (is_incremented[idx] && increment != 0) { + if (ov::snippets::utils::is_dynamic_value(increment)) { + OV_CPU_JIT_EMITTER_ASSERT(use_runtime_args, "Loop argument structure cannot be pushed to aux GPR"); + h->add(Reg64(static_cast(data_ptr_reg_idxs[idx])), h->ptr[reg_increments + idx * sizeof(int64_t)]); + } else { + h->add(Reg64(static_cast(data_ptr_reg_idxs[idx])), increment * scale * data_sizes[idx]); + } } } + }; + + const auto id_offset = loop_id * sizeof(jit_snippets_call_args::loop_args_t); + if (use_runtime_args) { + jit_aux_gpr_holder gpr_holder(h, aux_gpr_idxs, in); // loop_end has only input registers + reg_increments = gpr_holder.get_reg(); + h->mov(reg_increments, h->ptr[abi_param1 + GET_OFF(loop_args)]); + h->mov(reg_increments, h->ptr[reg_increments + id_offset + field_offset]); + add_increments(); + } else { + add_increments(); } }; diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp index d7444dfd55cebc..262bba39b7d74c 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp @@ -31,7 +31,8 @@ class jit_loop_begin_emitter: public jit_emitter { void validate_arguments(const std::vector &in, const std::vector &out) const override; void emit_impl(const std::vector& in, const std::vector& out) const override; - size_t aux_gprs_count() const override; + // `jit_loop_begin_emitter` handles manually aux_gpr allocation using `jit_aux_gpr_holder` + size_t aux_gprs_count() const override { return 0; } std::shared_ptr loop_begin_label = nullptr; std::shared_ptr loop_end_label = nullptr; @@ -61,7 +62,8 @@ class jit_loop_end_emitter: public jit_emitter { void validate_arguments(const std::vector &in, const std::vector &out) const override; void emit_impl(const std::vector& in, const std::vector& out) const override; - size_t aux_gprs_count() const override; + // `jit_loop_end_emitter` handles manually aux_gpr allocation using `jit_aux_gpr_holder` + size_t aux_gprs_count() const override { return 0; } static ov::snippets::lowered::ExpressionPtr get_loop_begin_expr(const ov::snippets::lowered::ExpressionPtr& expr); diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp index 19f1b230cd2c58..62edcba0de74e3 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/mha.cpp @@ -527,6 +527,35 @@ INSTANTIATE_TEST_SUITE_P( ::testing::Values(CPUTestUtils::empty_plugin_config)), MHA::getTestCaseName); +std::vector> inputShapes_4D_WithMul_dynamic{ + { + {PartialShape{-1, -1, -1, -1}, {{1, 128, 3, 64}, {1, 70, 3, 19}, {1, 128, 3, 64}, {1, 68, 6, 87}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 128, 1, 64}, {2, 49, 1, 19}, {1, 128, 1, 64}, {2, 13, 6, 87}}}, + {PartialShape{1}, {{1}, {1}, {1}, {1} }}, + {PartialShape{-1, -1, -1, -1}, {{2, 1, 128, 128}, {1, 1, 70, 49}, {2, 1, 128, 128}, {1, 1, 68, 13}}}, + {PartialShape{-1, -1, -1, -1}, {{1, 128, 3, 64}, {1, 49, 3, 19}, {1, 128, 3, 64}, {2, 13, 6, 87}}}, + }, + { + {PartialShape{-1, -1, 12, 64}, {{1, 70, 12, 64}, {1, 20, 12, 64}, {1, 20, 12, 64}, {1, 20, 12, 64}, {1, 70, 12, 64}}}, + {PartialShape{-1, -1, 12, 64}, {{1, 35, 12, 64}, {2, 10, 12, 64}, {2, 1, 12, 64}, {2, 10, 12, 64}, {1, 35, 12, 64}}}, + {PartialShape{-1, 12, 64, -1}, {{1, 12, 64, 35}, {1, 12, 64, 10}, {1, 12, 64, 10}, {1, 12, 64, 1}, {1, 12, 64, 35}}}, + {PartialShape{-1, 12, -1, -1}, {{2, 12, 70, 35}, {1, 12, 20, 10}, {1, 12, 20, 10}, {1, 12, 20, 1}, {2, 12, 70, 35}}}, + {PartialShape{-1, -1, 12, 64}, {{1, 35, 12, 64}, {1, 10, 12, 64}, {1, 10, 12, 64}, {1, 10, 12, 64}, {1, 35, 12, 64}}}, + } +}; + +INSTANTIATE_TEST_SUITE_P(smoke_Snippets_DynMHA_4D_WithMul, + MHAWithDynamicMul, + ::testing::Combine(::testing::ValuesIn(inputShapes_4D_WithMul_dynamic), + ::testing::ValuesIn(precision_f32(5)), + ::testing::Values(ov::element::f32), + ::testing::Values(MHA::default_thread_count), + ::testing::Values(1), + ::testing::Values(1), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(CPUTestUtils::empty_plugin_config)), + MHAWithDynamicMul::getTestCaseName); + } // namespace } // namespace snippets } // namespace test diff --git a/src/tests/functional/plugin/shared/include/snippets/mha.hpp b/src/tests/functional/plugin/shared/include/snippets/mha.hpp index f73dba5d4ad5ce..0a1733a6099242 100644 --- a/src/tests/functional/plugin/shared/include/snippets/mha.hpp +++ b/src/tests/functional/plugin/shared/include/snippets/mha.hpp @@ -11,7 +11,7 @@ namespace ov { namespace test { namespace snippets { -typedef std::tuple, // Input shapes +typedef std::tuple, // Input shapes std::vector, // Input Element types ov::element::Type, // Inference precision bool, // With Multiply @@ -23,72 +23,101 @@ typedef std::tuple, // Input shapes > MHAParams; -class MHA : public testing::WithParamInterface, - virtual public ov::test::SnippetsTestsCommon { -public: - static std::string getTestCaseName(testing::TestParamInfo obj); +typedef std::tuple, // Input shapes + std::vector, // Input Element types + ov::element::Type, // Inference precision + size_t, // Thread count + size_t, // Expected num nodes + size_t, // Expected num subgraphs + std::string, // Target Device + ov::AnyMap // Config + > +MHAWithDynamicMulParams; +class MHABase : virtual public ov::test::SnippetsTestsCommon { +public: constexpr static size_t default_thread_count = 0; protected: void SetUp() override; - void compile_model() override; void generate_inputs(const std::vector& targetInputStaticShapes) override; - virtual std::shared_ptr get_subgraph(); + virtual std::shared_ptr get_subgraph() const = 0; + virtual void init_params(std::vector& input_shapes, ov::element::Type& prc, ov::AnyMap& additional_config) = 0; - bool m_with_mul = false; size_t m_thread_count; std::vector m_input_types; }; +class MHA : public testing::WithParamInterface, + virtual public MHABase { +public: + static std::string getTestCaseName(testing::TestParamInfo obj); + +protected: + std::shared_ptr get_subgraph() const override; + void init_params(std::vector& input_shapes, ov::element::Type& prc, ov::AnyMap& additional_config) override; + + bool m_with_mul = false; +}; + class MHASelect : public MHA { protected: void generate_inputs(const std::vector& targetInputStaticShapes) override; - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAWOTransposeOnInputs : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAWOTranspose : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAMulAdd : public MHA { - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHATransposedB : public MHA { - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAINT8MatMul : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAQuantMatMul0 : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAFQAfterMatMul : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAFQ : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; }; class MHAWithExtractedReshape : public MHA { protected: - std::shared_ptr get_subgraph() override; + std::shared_ptr get_subgraph() const override; +}; + +class MHAWithDynamicMul : public testing::WithParamInterface, + virtual public MHABase { +public: + static std::string getTestCaseName(testing::TestParamInfo obj); + +protected: + std::shared_ptr get_subgraph() const override; + void init_params(std::vector& input_shapes, ov::element::Type& prc, ov::AnyMap& additional_config) override; }; } // namespace snippets diff --git a/src/tests/functional/plugin/shared/src/snippets/mha.cpp b/src/tests/functional/plugin/shared/src/snippets/mha.cpp index 9b5cbe2bafaf43..956b115213e3f1 100644 --- a/src/tests/functional/plugin/shared/src/snippets/mha.cpp +++ b/src/tests/functional/plugin/shared/src/snippets/mha.cpp @@ -14,6 +14,51 @@ namespace ov { namespace test { namespace snippets { +void MHABase::compile_model() { + if (m_thread_count != default_thread_count) + core->set_property(targetDevice, ov::inference_num_threads(m_thread_count)); + SubgraphBaseTest::compile_model(); +} + +void MHABase::generate_inputs(const std::vector& targetInputStaticShapes) { + inputs.clear(); + const auto& model_inputs = function->inputs(); + + 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 + 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(), targetInputStaticShapes[i], in_data); + inputs.insert({model_input.get_node_shared_ptr(), tensor}); + } +} + +void MHABase::SetUp() { + std::vector input_shapes; + ov::element::Type prc; + ov::AnyMap additional_config; + init_params(input_shapes, prc, additional_config); + init_input_shapes(input_shapes); + + const auto subgraph_model = get_subgraph(); + function = subgraph_model->getOriginal(); + + configuration.insert(additional_config.begin(), additional_config.end()); + if (!configuration.count("SNIPPETS_MODE")) { + configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"}); + } + + setInferenceType(prc); + inType = outType = prc; + if (prc == ov::element::bf16) + rel_threshold = 0.05f; +} + std::string MHA::getTestCaseName(testing::TestParamInfo obj) { std::vector input_shapes; std::vector elem_types; @@ -54,60 +99,46 @@ std::string MHA::getTestCaseName(testing::TestParamInfo obj) { std::vector input_shapes; + std::vector elem_types; ov::element::Type prc; + size_t thread_count; + std::string target_device; + size_t num_nodes, num_subgraphs; ov::AnyMap additional_config; - std::tie(input_shapes, - m_input_types, - prc, - m_with_mul, - m_thread_count, - ref_num_nodes, - ref_num_subgraphs, - targetDevice, - additional_config) = this->GetParam(); - init_input_shapes(input_shapes); + std::tie(input_shapes, elem_types, prc, thread_count, num_nodes, num_subgraphs, target_device, additional_config) = obj.param; - const auto subgraph_model = get_subgraph(); - function = subgraph_model->getOriginal(); + std::ostringstream result; + for (size_t i = 0; i < input_shapes.size(); i++) + result << "IS[" << i << "]=" << input_shapes[i] << "_"; + for (size_t i = 0; i < elem_types.size(); i++) + result << "T[" << i << "]=" << elem_types[i] << "_"; + result << "ThreadNum=" << thread_count << "_"; + result << "PRC=" << prc << "_"; + result << "#N=" << num_nodes << "_"; + result << "#S=" << num_subgraphs << "_"; + result << "targetDevice=" << target_device << "_"; - configuration.insert(additional_config.begin(), additional_config.end()); - if (!configuration.count("SNIPPETS_MODE")) { - configuration.insert({"SNIPPETS_MODE", "IGNORE_CALLBACK"}); + if (!additional_config.empty()) { + result << "_PluginConf"; + for (auto& item : additional_config) { + result << "_" << item.first << "=" << item.second.as(); + } } - - setInferenceType(prc); - inType = outType = prc; - if (prc == ov::element::bf16) - rel_threshold = 0.05f; + return result.str(); } -void MHA::compile_model() { - if (m_thread_count != default_thread_count) - core->set_property(targetDevice, ov::inference_num_threads(m_thread_count)); - SubgraphBaseTest::compile_model(); +void MHA::init_params(std::vector& input_shapes, ov::element::Type& prc, ov::AnyMap& additional_config) { + std::tie(input_shapes, m_input_types, prc, m_with_mul, m_thread_count, ref_num_nodes, ref_num_subgraphs, + targetDevice, additional_config) = this->GetParam(); } -void MHA::generate_inputs(const std::vector& targetInputStaticShapes) { - inputs.clear(); - const auto& model_inputs = function->inputs(); - - 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 - 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(), targetInputStaticShapes[i], in_data); - inputs.insert({model_input.get_node_shared_ptr(), tensor}); - } +void MHAWithDynamicMul::init_params(std::vector& input_shapes, ov::element::Type& prc, ov::AnyMap& additional_config) { + std::tie(input_shapes, m_input_types, prc, m_thread_count, ref_num_nodes, ref_num_subgraphs, targetDevice, additional_config) = this->GetParam(); } -std::shared_ptr MHA::get_subgraph() { +std::shared_ptr MHA::get_subgraph() const { bool is_with_reshape = std::all_of(inputDynamicShapes.begin(), inputDynamicShapes.end(), [](const PartialShape& ps){ return ps.is_static(); }); return std::make_shared(inputDynamicShapes, m_input_types, m_with_mul, is_with_reshape); } @@ -143,46 +174,50 @@ void MHASelect::generate_inputs(const std::vector& targetInputStaticS } } -std::shared_ptr MHASelect::get_subgraph() { +std::shared_ptr MHASelect::get_subgraph() const { return std::make_shared(inputDynamicShapes, m_input_types); } -std::shared_ptr MHAWOTransposeOnInputs::get_subgraph() { +std::shared_ptr MHAWOTransposeOnInputs::get_subgraph() const { return std::make_shared(inputDynamicShapes); } -std::shared_ptr MHAWOTranspose::get_subgraph() { +std::shared_ptr MHAWOTranspose::get_subgraph() const { return std::make_shared(inputDynamicShapes, m_input_types); } -std::shared_ptr MHAINT8MatMul::get_subgraph() { +std::shared_ptr MHAINT8MatMul::get_subgraph() const { return std::make_shared(inputDynamicShapes); } -std::shared_ptr MHAQuantMatMul0::get_subgraph() { +std::shared_ptr MHAQuantMatMul0::get_subgraph() const { return std::make_shared(inputDynamicShapes); } -std::shared_ptr MHAFQAfterMatMul::get_subgraph() { +std::shared_ptr MHAFQAfterMatMul::get_subgraph() const { return std::make_shared(inputDynamicShapes); } -std::shared_ptr MHAFQ::get_subgraph() { +std::shared_ptr MHAFQ::get_subgraph() const { return std::make_shared(inputDynamicShapes); } -std::shared_ptr MHAMulAdd::get_subgraph() { +std::shared_ptr MHAMulAdd::get_subgraph() const { return std::make_shared(inputDynamicShapes); } -std::shared_ptr MHATransposedB::get_subgraph() { +std::shared_ptr MHATransposedB::get_subgraph() const { return std::make_shared(inputDynamicShapes, true); } -std::shared_ptr MHAWithExtractedReshape::get_subgraph() { +std::shared_ptr MHAWithExtractedReshape::get_subgraph() const { return std::make_shared(inputDynamicShapes, false); } +std::shared_ptr MHAWithDynamicMul::get_subgraph() const { + return std::make_shared(inputDynamicShapes, m_input_types); +} + TEST_P(MHA, CompareWithRefImpl) { SKIP_IF_CURRENT_TEST_IS_DISABLED() run(); @@ -250,6 +285,12 @@ TEST_P(MHAWithExtractedReshape, CompareWithRefImpl) { validateNumSubgraphs(); } +TEST_P(MHAWithDynamicMul, CompareWithRefImpl) { + SKIP_IF_CURRENT_TEST_IS_DISABLED() + run(); + validateNumSubgraphs(); +} + } // namespace snippets } // namespace test } // namespace ov diff --git a/src/tests/ov_helpers/ov_snippets_models/include/subgraph_mha.hpp b/src/tests/ov_helpers/ov_snippets_models/include/subgraph_mha.hpp index 60af12e27e5f48..90ab47214effee 100644 --- a/src/tests/ov_helpers/ov_snippets_models/include/subgraph_mha.hpp +++ b/src/tests/ov_helpers/ov_snippets_models/include/subgraph_mha.hpp @@ -70,6 +70,32 @@ class MHASplitMFunction : public MHAFunction { std::vector reshapes; }; +/* Graph: + * Transpose1[0,2,3,1] Parameter + * \ / + * Transpose0[0,2,1,3] Multiply + * \ / + * MatMul0 + * \ / + * Add + * Softmax Transpose2[0,2,1,3] + * \ / + * MatMul1 + * Transpose3[0,2,1,3] + */ +class MHAWithDynamicMulFunction : public SnippetsFunctionBase { +public: + explicit MHAWithDynamicMulFunction(const std::vector& inputShapes, const std::vector& precisions) + : SnippetsFunctionBase(inputShapes), precisions(precisions) { + OPENVINO_ASSERT(input_shapes.size() == 5, "Got invalid number of input shapes"); + OPENVINO_ASSERT(precisions.size() == 5, "Got invalid number of input precisions"); + } +protected: + std::shared_ptr initOriginal() const override; + + const std::vector precisions; +}; + /* Graph: * Transpose1[0,2,1,3] Constant * \ / diff --git a/src/tests/ov_helpers/ov_snippets_models/src/subgraph_mha.cpp b/src/tests/ov_helpers/ov_snippets_models/src/subgraph_mha.cpp index 3ca78918f5e925..c47cb754b5b891 100644 --- a/src/tests/ov_helpers/ov_snippets_models/src/subgraph_mha.cpp +++ b/src/tests/ov_helpers/ov_snippets_models/src/subgraph_mha.cpp @@ -231,6 +231,37 @@ std::shared_ptr MHASplitMFunction::initReference() const { return std::make_shared(results, ngraphParams, "mha"); } +std::shared_ptr MHAWithDynamicMulFunction::initOriginal() const { + auto transpose0Param = std::make_shared(precisions[0], input_shapes[0]); + auto transpose1Param = std::make_shared(precisions[1], input_shapes[1]); + auto mulParam = std::make_shared(precisions[2], input_shapes[2]); + auto addParam = std::make_shared(precisions[3], input_shapes[3]); + auto transpose2Param = std::make_shared(precisions[4], input_shapes[4]); + ov::ParameterVector ngraphParam = {transpose0Param, transpose1Param, mulParam, addParam, transpose2Param}; + + const auto rank = input_shapes[0].size(); + const auto fusion_order = get_fusion_order(rank); + const auto decomposed_order = get_decomposed_order(rank); + + const auto transpose0Const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{rank}, fusion_order); + const auto transpose1Const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{rank}, decomposed_order); + const auto transpose2Const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{rank}, fusion_order); + const auto transpose3Const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{rank}, fusion_order); + + const auto transpose0 = std::make_shared(transpose0Param, transpose0Const); + const auto transpose1 = std::make_shared(transpose1Param, transpose1Const); + const auto mul = std::make_shared(transpose1, mulParam); + const auto matMul0 = std::make_shared(transpose0, mul); + const auto add = std::make_shared(matMul0, addParam); + const auto softMax = std::make_shared(add, rank - 1); + const auto transpose2 = std::make_shared(transpose2Param, transpose2Const); + const auto matMul1 = std::make_shared(softMax, transpose2); + const auto transpose3 = std::make_shared(matMul1, transpose3Const); + + ov::ResultVector results{std::make_shared(transpose3)}; + return std::make_shared(results, ngraphParam, "mha"); +} + std::shared_ptr MHAMatMul0TransposeFunction::initOriginal() const { auto transpose0Param = std::make_shared(precisions[0], input_shapes[0]); auto transpose1Param = std::make_shared(precisions[1], input_shapes[1]); From bd7dc80242ee349da4c327ccaf7809932e3cff58 Mon Sep 17 00:00:00 2001 From: Vladimir Paramuzov Date: Thu, 22 Aug 2024 15:52:25 +0400 Subject: [PATCH 084/117] [GPU] Fix move per channel eltwise pass (#26154) ### Details: - Fixes regression after #24401 ### Tickets: - *CVS-150278* - *CVS-149636* - *CVS-149620* --- .../move_eltwise_up_data_movement.cpp | 3 ++- .../move_eltwise_up_data_movement_test.cpp | 20 +++++++++++++++++++ .../src/plugin/transformations_pipeline.cpp | 6 +++++- 3 files changed, 27 insertions(+), 2 deletions(-) diff --git a/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp b/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp index fd9e7417261b81..82efb3699b2c40 100644 --- a/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp @@ -167,7 +167,8 @@ ov::pass::MoveEltwiseUpThroughDataMovPerChannel::MoveEltwiseUpThroughDataMovPerC }; auto eltw_data_flow_in = - ov::pass::pattern::wrap_type(); + ov::pass::pattern::wrap_type( + pattern::consumers_count(1)); auto eltw_const_in = ov::pass::pattern::wrap_type(const_predicate); auto eltwise_pattern = ov::pass::pattern::wrap_type({eltw_data_flow_in, eltw_const_in}, diff --git a/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp b/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp index 374cd208fefb7d..07eb3ec2b3e983 100644 --- a/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp +++ b/src/common/transformations/tests/common_optimizations/move_eltwise_up_data_movement_test.cpp @@ -446,6 +446,26 @@ TEST_F(MoveEltwiseUpThroughDataMovTest, PerChannelEltwiseSqueezeIllegal_1) { manager.register_pass(); } +TEST_F(MoveEltwiseUpThroughDataMovTest, PerChannelEltwiseSqueezeIllegal_2) { + const ov::Shape shape{10, 20, 1, 1}; + // Data movement op with multiple consumers is not applicable + auto input = std::make_shared(ov::element::f32, shape); + + auto squeeze_const = ov::opset8::Constant::create(ov::element::i64, ov::Shape{}, {2}); // {10, 20, 1} + auto squeeze = std::make_shared(input, squeeze_const); + + auto per_channel_const1 = ov::opset8::Constant::create(ov::element::f32, {10, 1, 1}, {0.5}); + auto add1 = std::make_shared(squeeze, per_channel_const1); + + auto per_channel_const2 = ov::opset8::Constant::create(ov::element::f32, {10, 1, 1}, {0.5}); + auto add2 = std::make_shared(squeeze, per_channel_const2); + + auto add3 = std::make_shared(add1, add2); + + model = std::make_shared(ov::NodeVector{add3}, ov::ParameterVector{input}); + manager.register_pass(); +} + TEST_F(MoveEltwiseUpThroughDataMovTest, PerChannelReshapeMultiply) { const ov::Shape shape{1, 3, 20}; const std::vector target_shape = {1, 3, 4, 5}; diff --git a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp index f5cb6783d4b080..fc62f68af2f6a2 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp @@ -794,7 +794,7 @@ void TransformationsPipeline::apply(std::shared_ptr func) { ov::op::v1::Broadcast::get_type_info_static(), ov::op::v3::Broadcast::get_type_info_static(), }; - manager.register_pass(allowed_data_movement_ops); + manager.register_pass(allowed_data_movement_ops); manager.register_pass(); manager.register_pass(); @@ -842,6 +842,10 @@ void TransformationsPipeline::apply(std::shared_ptr func) { manager.register_pass(); manager.register_pass(); manager.register_pass(); + + // This pass should be done after asymmetric quantization matching as it can move zp subtraction upper in the graph + manager.register_pass(); + manager.register_pass(); const size_t zp_pad_size = device_info.supports_immad ? 16 : 32; From 3c34cc6520bd386ee572a417fa779bcd416efa3c Mon Sep 17 00:00:00 2001 From: Damian Kurek Date: Thu, 22 Aug 2024 14:46:48 +0200 Subject: [PATCH 085/117] [GPU] Improve maximum value calculation in softmax BF kernel (#26101) ### Details: - Calculate maximum values for each work-item while fetching data, slightly improving performance - Remove one loop - Decrease private memory fetch ### Tickets: - 150093 --- .../cl_kernels/softmax_gpu_bf.cl | 48 +++++++------------ 1 file changed, 18 insertions(+), 30 deletions(-) diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/softmax_gpu_bf.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/softmax_gpu_bf.cl index c391afdc4adbb4..990da1509558bd 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/softmax_gpu_bf.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/softmax_gpu_bf.cl @@ -87,6 +87,7 @@ KERNEL (softmax_gpu_continuous_bfyx)( INPUT0_TYPE my_chunk[STACK_SIZE]; INPUT0_TYPE my_sum = UNIT_VAL_ZERO; + INPUT0_TYPE my_maximum = -UNIT_VAL_MAX; __local INPUT0_TYPE lg_storage[SLM_SIZE]; @@ -108,6 +109,7 @@ KERNEL (softmax_gpu_continuous_bfyx)( unroll_for (int j = 0; j < OPT_BLOCK_SIZE; j++) { my_chunk[input_idx+j] = vec_tmp[j]; + my_maximum = max(my_maximum, vec_tmp[j]); } } @@ -115,6 +117,7 @@ KERNEL (softmax_gpu_continuous_bfyx)( { BLOCK_TYPE vec_tmp = BLOCK_READ(input, aligned_data_offset + input_idx * get_sub_group_size()); my_chunk[input_idx] = vec_tmp; + my_maximum = max(my_maximum, vec_tmp); } } #else @@ -125,11 +128,13 @@ KERNEL (softmax_gpu_continuous_bfyx)( BLOCK_TYPE vec_tmp = BLOCK_READ(input, aligned_data_offset + input_idx * get_sub_group_size()); #if SUBGROUP_BLOCK_SIZE == 1 my_chunk[input_idx] = vec_tmp; + my_maximum = max(my_maximum, vec_tmp); #else unroll_for (int j = 0; j < SUBGROUP_BLOCK_SIZE; j++) { INPUT0_TYPE tmp = vec_tmp[j]; my_chunk[input_idx+j] = tmp; + my_maximum = max(my_maximum, tmp); } #endif } @@ -138,29 +143,23 @@ KERNEL (softmax_gpu_continuous_bfyx)( for (; input_idx < items_num; input_idx++) { - my_chunk[input_idx] = input[aligned_data_offset + get_sub_group_local_id() + input_idx * get_sub_group_size()]; + INPUT0_TYPE tmp = input[aligned_data_offset + get_sub_group_local_id() + input_idx * get_sub_group_size()]; + my_chunk[input_idx] = tmp; + my_maximum = max(my_maximum, tmp); } if (in_data_set_idx < aligned_offset) { INPUT0_TYPE tmp = input[data_set_offset + in_data_set_idx]; my_chunk[input_idx++] = tmp; + my_maximum = max(my_maximum, tmp); } if (in_data_set_idx < actual_leftovers) { INPUT0_TYPE tmp = input[leftover_idx]; my_chunk[input_idx++] = tmp; - } - - INPUT0_TYPE my_maximum = -UNIT_VAL_MAX; - { - const uint num_iters = input_idx; - - for (uint j=0; j Date: Thu, 22 Aug 2024 15:52:16 +0200 Subject: [PATCH 086/117] Use AvgPool-14 in PT FE (#25471) ### Details: - Extend PT FE with AvgPool-14 - Move the `count_include_pad` workaround subgraph from PT FE to a downgrade transformation - The subgraph in downgrade transformations is defined in https://github.com/openvinotoolkit/openvino/blob/master/src/common/transformations/src/transformations/op_conversions/convert_avgpool_downgrade.cpp#L52 - The new `RoundingType::CEIL_TORCH` has impact only on the output shape - Out of two tests which previously have been xfailed due to output shape mismatch one is still failing, but now due to accuracy validation failure - No old tests were broken by upgrading to V14, so it seems the subgraph has issue with this edge case specifically - The edge case is connected to `count_include_pad:True`, and `pad` value, depending on the latter FP16 test case sometimes passes, but FP32 always fails - Since CPU Plugin is calling oneDNN AvgPool implementation there may be some difference in results calculation or an issue with parameter preprocessing before calling oneDNN function - Continued in XXXXX ### Tickets: - CVS-133929 --------- Co-authored-by: Michal Lukaszewski --- src/frontends/pytorch/src/op/avg_poolnd.cpp | 24 ++----------------- .../layer_tests/pytorch_tests/test_pooling.py | 18 +++++--------- 2 files changed, 8 insertions(+), 34 deletions(-) diff --git a/src/frontends/pytorch/src/op/avg_poolnd.cpp b/src/frontends/pytorch/src/op/avg_poolnd.cpp index 65e1e3ba92dc97..03c32259b45091 100644 --- a/src/frontends/pytorch/src/op/avg_poolnd.cpp +++ b/src/frontends/pytorch/src/op/avg_poolnd.cpp @@ -40,35 +40,15 @@ OutputVector translate_avg_poolnd(const NodeContext& context) { } ov::op::RoundingType rounding_type = ov::op::RoundingType::FLOOR; if (!(context.input_is_none(4))) { - rounding_type = context.const_input(4) ? ov::op::RoundingType::CEIL : ov::op::RoundingType::FLOOR; + rounding_type = context.const_input(4) ? ov::op::RoundingType::CEIL_TORCH : ov::op::RoundingType::FLOOR; } if (!(context.input_is_none(5))) { count_include_pad = context.const_input(5); } PYTORCH_OP_CONVERSION_CHECK(context.input_is_none(6), "Translation for aten::avg_pool2d do not support divisor_override input."); - // Although ov::AvgPool provides exclude_pad=false, - // The corner case of Average Pooling with ceil_mode on - // PyTorch allows sliding window go off bound, which leads to this accommodation. - // More detail on https://github.com/pytorch/pytorch/issues/57178 - if (count_include_pad) { - auto zero = context.mark_node(v0::Constant::create(element::f32, Shape{}, {0})); - zero = context.mark_node(std::make_shared(zero, input)); - auto zero_i32 = context.mark_node(v0::Constant::create(element::i32, Shape{}, {0})); - Output rank; - std::tie(std::ignore, rank) = get_shape_rank(context, input); - auto pad_values = get_input_as_i32(context, 3); - auto pads_len = context.mark_node(v0::Constant::create(element::i32, Shape{}, {pads.size()})); - auto pads_diff = context.mark_node(std::make_shared(rank, pads_len)); - auto pads_remaining = context.mark_node(std::make_shared(zero_i32, pads_diff)); - auto padding = context.mark_node( - std::make_shared(OutputVector{std::move(pads_remaining), std::move(pad_values)}, 0)); - input = context.mark_node(std::make_shared(input, padding, padding, zero, ov::op::PadMode::CONSTANT)); - pads = Shape(pads.size(), 0); - } - return {context.mark_node( - std::make_shared(input, strides, pads, pads, kernel, !count_include_pad, rounding_type))}; + std::make_shared(input, strides, pads, pads, kernel, !count_include_pad, rounding_type))}; }; } // namespace op diff --git a/tests/layer_tests/pytorch_tests/test_pooling.py b/tests/layer_tests/pytorch_tests/test_pooling.py index 0cf2446abd1125..32c8a973cb1c92 100644 --- a/tests/layer_tests/pytorch_tests/test_pooling.py +++ b/tests/layer_tests/pytorch_tests/test_pooling.py @@ -17,10 +17,9 @@ {'kernel_size': [2, 1], 'stride': [2, 1], 'padding': 0}, {'kernel_size': [2, 1], 'stride': None, 'padding': 0}, {'kernel_size': [2, 1], 'stride': [], 'padding': 0}, + {'kernel_size': [8, 8], 'stride': [8, 4], 'padding': 1}, ] -d2_params_corner_case = [{'kernel_size': [8, 8], 'stride': [8, 4], 'padding': 1}] - d1_params = [{'kernel_size': 3, 'stride': 1, 'padding': 0}, {'kernel_size': (4,), 'stride': 1, 'padding': 1}, {'kernel_size': 4, 'stride': (5,), 'padding': 2}, @@ -144,14 +143,7 @@ def test_avg_pool1d(self, params, ceil_mode, count_include_pad, ie_device, preci dynamic_shapes=False) @pytest.mark.parametrize( - "params", - d2_params - + [ - pytest.param( - {"kernel_size": [8, 8], "stride": [8, 4], "padding": 1}, - marks=pytest.mark.xfail(reason="Sliding windows that would start in the right padded are ignored.") - ) - ]) + "params", d2_params) @pytest.mark.parametrize("ceil_mode", [True, False]) @pytest.mark.parametrize("count_include_pad", [True, False]) @pytest.mark.nightly @@ -161,6 +153,8 @@ def test_avg_pool1d(self, params, ceil_mode, count_include_pad, ie_device, preci @pytest.mark.xfail(condition=platform.system() == 'Darwin' and platform.machine() == 'arm64', reason='Ticket - 122715') def test_avg_pool2d(self, params, ceil_mode, count_include_pad, ie_device, precision, ir_version): + if ceil_mode and count_include_pad and np.array_equal(np.array(params["kernel_size"]), np.array([8, 8])): + pytest.xfail("Ticket - 150292") self._test(*self.create_model("avg_pool2d", **params, ceil_mode=ceil_mode, count_include_pad=count_include_pad), ie_device, precision, ir_version, trace_model=True, freeze_model=False, dynamic_shapes=False) @@ -190,7 +184,7 @@ def test_max_pool1d(self, params, ceil_mode, dilation, ie_device, precision, ir_ self._test(*self.create_model("max_pool1d", **params, ceil_mode=ceil_mode, dilation=dilation), ie_device, precision, ir_version, kwargs_to_prepare_input={'ndim': 3}, dynamic_shapes=False) - @pytest.mark.parametrize("params", d2_params + d2_params_corner_case) + @pytest.mark.parametrize("params", d2_params) @pytest.mark.parametrize("ceil_mode", [True, False]) @pytest.mark.parametrize("dilation", [1, 2]) @pytest.mark.parametrize("dtype", [torch.float32, torch.int32]) @@ -227,7 +221,7 @@ def test_max_pool1d_indices(self, params, ceil_mode, dilation, ie_device, precis self._test(*self.create_model("max_pool1d_with_indices", **params, ceil_mode=ceil_mode, dilation=dilation), ie_device, precision, ir_version, kwargs_to_prepare_input={'ndim': 3}, dynamic_shapes=False) - @pytest.mark.parametrize("params", d2_params + d2_params_corner_case) + @pytest.mark.parametrize("params", d2_params) @pytest.mark.parametrize("ceil_mode", [True, False]) @pytest.mark.parametrize("dilation", [1, 2]) @pytest.mark.nightly From f50a8764d5b4804ab1f126e6be11328c53ed7ca0 Mon Sep 17 00:00:00 2001 From: Tatiana Savina Date: Thu, 22 Aug 2024 16:31:40 +0200 Subject: [PATCH 087/117] [DOCS] Bump zipp in docs (#26179) ### Details: recreates PR 25474 ### Tickets: - *ticket-id* --- docs/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 5703503a9ba158..a3873d9e77c27e 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -46,4 +46,4 @@ sphinxcontrib-qthelp==1.0.3 sphinxcontrib-serializinghtml==1.1.9 toml==0.10.2 urllib3==1.26.19 -zipp==3.4.1 \ No newline at end of file +zipp==3.19.1 \ No newline at end of file From 407b012ce353b991a04a094e8de691fc477fd96d Mon Sep 17 00:00:00 2001 From: Vladimir Paramuzov Date: Thu, 22 Aug 2024 18:40:38 +0400 Subject: [PATCH 088/117] [GPU] SYCL infra for GPU plugin and GHA pipeline (#26067) Co-authored-by: Ilya Lavrenov --- .github/dockerfiles/docker_tag | 2 +- .../ubuntu_22_04_x64_dpcpp/Dockerfile | 95 +++++++++++++++++++ .github/workflows/ubuntu_22_dpcpp.yml | 90 ++++++++++++++++++ .../compile_flags/os_flags.cmake | 2 + .../scaled_attn/executor_pa_common.hpp | 1 + src/plugins/intel_gpu/CMakeLists.txt | 4 + .../intel_gpu/graph/kernel_impl_params.hpp | 2 +- .../primitives/implementation_desc.hpp | 1 + .../runtime/engine_configuration.hpp | 2 + .../intel_gpu/src/graph/CMakeLists.txt | 10 ++ .../intel_gpu/src/graph/impls/sycl/README.md | 16 ++++ .../graph/impls/sycl/primitive_sycl_base.h | 90 ++++++++++++++++++ .../src/graph/impls/sycl/register.cpp | 17 ++++ .../src/graph/impls/sycl/register.hpp | 23 +++++ src/plugins/intel_gpu/src/graph/program.cpp | 6 ++ src/plugins/intel_gpu/src/plugin/plugin.cpp | 4 + .../intel_gpu/src/plugin/remote_context.cpp | 5 + .../intel_gpu/src/runtime/CMakeLists.txt | 11 +++ .../intel_gpu/src/runtime/device_query.cpp | 1 + src/plugins/intel_gpu/src/runtime/engine.cpp | 5 + .../intel_gpu/src/runtime/kernels_cache.cpp | 4 +- .../intel_gpu/src/runtime/kernels_factory.cpp | 4 +- src/plugins/intel_gpu/src/runtime/memory.cpp | 4 +- .../src/runtime/ocl/ocl_engine_factory.hpp | 3 + .../intel_gpu/src/runtime/ocl/sycl_engine.cpp | 37 ++++++++ .../intel_gpu/src/runtime/ocl/sycl_engine.hpp | 28 ++++++ .../intel_gpu/src/runtime/ocl/sycl_stream.cpp | 30 ++++++ .../intel_gpu/src/runtime/ocl/sycl_stream.hpp | 26 +++++ src/plugins/intel_gpu/src/runtime/stream.cpp | 4 +- .../intel_gpu/tests/unit/CMakeLists.txt | 5 + .../intel_npu/src/plugin/CMakeLists.txt | 2 +- 31 files changed, 526 insertions(+), 8 deletions(-) create mode 100644 .github/dockerfiles/ov_build/ubuntu_22_04_x64_dpcpp/Dockerfile create mode 100644 .github/workflows/ubuntu_22_dpcpp.yml create mode 100644 src/plugins/intel_gpu/src/graph/impls/sycl/README.md create mode 100644 src/plugins/intel_gpu/src/graph/impls/sycl/primitive_sycl_base.h create mode 100644 src/plugins/intel_gpu/src/graph/impls/sycl/register.cpp create mode 100644 src/plugins/intel_gpu/src/graph/impls/sycl/register.hpp create mode 100644 src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.cpp create mode 100644 src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.hpp create mode 100644 src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.cpp create mode 100644 src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.hpp diff --git a/.github/dockerfiles/docker_tag b/.github/dockerfiles/docker_tag index 38479d3f7437dc..5bd51d5f04378a 100644 --- a/.github/dockerfiles/docker_tag +++ b/.github/dockerfiles/docker_tag @@ -1 +1 @@ -pr-25992 \ No newline at end of file +pr-26067 diff --git a/.github/dockerfiles/ov_build/ubuntu_22_04_x64_dpcpp/Dockerfile b/.github/dockerfiles/ov_build/ubuntu_22_04_x64_dpcpp/Dockerfile new file mode 100644 index 00000000000000..292ae46cab94a3 --- /dev/null +++ b/.github/dockerfiles/ov_build/ubuntu_22_04_x64_dpcpp/Dockerfile @@ -0,0 +1,95 @@ +FROM openvinogithubactions.azurecr.io/dockerhub/ubuntu:22.04 + +USER root + +# APT configuration +RUN echo 'Acquire::Retries "10";' > /etc/apt/apt.conf && \ + echo 'APT::Get::Assume-Yes "true";' >> /etc/apt/apt.conf && \ + echo 'APT::Get::Fix-Broken "true";' >> /etc/apt/apt.conf && \ + echo 'APT::Get::no-install-recommends "true";' >> /etc/apt/apt.conf + +ENV DEBIAN_FRONTEND="noninteractive" \ + TZ="Europe/London" + +RUN apt-get update && \ + apt-get install software-properties-common && \ + add-apt-repository --yes --no-update ppa:git-core/ppa && \ + add-apt-repository --yes --no-update ppa:deadsnakes/ppa && \ + apt-get update && \ + apt-get install \ + wget \ + curl \ + git \ + ca-certificates \ + gpg-agent \ + tzdata \ + libtbb2 \ + # Pythons \ + python3.11-dev \ + python3.11-venv \ + python3.11-distutils \ + default-jdk \ + && \ + rm -rf /var/lib/apt/lists/* + + +# Install OneAPI Toolkit +RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | tee /usr/share/keyrings/intel-oneapi-archive-keyring.gpg > /dev/null +RUN echo "deb [signed-by=/usr/share/keyrings/intel-oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main " > /etc/apt/sources.list.d/oneAPI.list + +RUN apt-get update && \ + apt-get install \ + intel-oneapi-compiler-dpcpp-cpp=2024.2.1-1079 \ + && \ + rm -rf /var/lib/apt/lists/* + +# Install build dependencies +ADD install_build_dependencies.sh /install_build_dependencies.sh +RUN chmod +x /install_build_dependencies.sh && \ + /install_build_dependencies.sh && \ + rm -rf /var/lib/apt/lists/* + +# Install sscache +ARG SCCACHE_VERSION="v0.7.5" +ENV SCCACHE_HOME="/opt/sccache" \ + SCCACHE_PATH="/opt/sccache/sccache" + +RUN mkdir ${SCCACHE_HOME} && cd ${SCCACHE_HOME} && \ + SCCACHE_ARCHIVE="sccache-${SCCACHE_VERSION}-x86_64-unknown-linux-musl.tar.gz" && \ + curl -SLO https://github.com/mozilla/sccache/releases/download/${SCCACHE_VERSION}/${SCCACHE_ARCHIVE} && \ + tar -xzf ${SCCACHE_ARCHIVE} --strip-components=1 && rm ${SCCACHE_ARCHIVE} + +# Setup pip +ENV PIP_VERSION="24.0" +RUN curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \ + python3 get-pip.py --no-cache-dir pip==${PIP_VERSION} && \ + python3.11 get-pip.py --no-cache-dir pip==${PIP_VERSION} && \ + rm -f get-pip.py + +# Use Python 3.11 as default +# Using venv here 'cause other methods to switch the default Python on Ubuntu break both system and wheels build +RUN python3.11 -m venv venv +ENV PATH="/venv/bin:$SCCACHE_HOME:$PATH" + +ENV PIP_CACHE_DIR=/mount/caches/pip/linux/${PIP_VERSION} + +# OneAPI env +ENV ONEAPI_ROOT=/opt/intel/oneapi +ENV PKG_CONFIG_PATH=/opt/intel/oneapi/compiler/2024.2/lib/pkgconfig +ENV DIAGUTIL_PATH=/opt/intel/oneapi/dpcpp-ct/2024.2/etc/dpct/sys_check/sys_check.sh:/opt/intel/oneapi/debugger/2024.2/etc/debugger/sys_check/sys_check.py:/opt/intel/oneapi/compiler/2024.2/etc/compiler/sys_check/sys_check.sh +ENV MANPATH=/opt/intel/oneapi/debugger/2024.2/share/man:/opt/intel/oneapi/compiler/2024.2/share/man: +ENV GDB_INFO=/opt/intel/oneapi/debugger/2024.2/share/info/ +ENV CMAKE_PREFIX_PATH=/opt/intel/oneapi/compiler/2024.2 +ENV CMPLR_ROOT=/opt/intel/oneapi/compiler/2024.2 +ENV INFOPATH=/opt/intel/oneapi/debugger/2024.2/share/info +ENV LIBRARY_PATH=/opt/intel/oneapi/compiler/2024.2/lib +ENV OCL_ICD_FILENAMES=/opt/intel/oneapi/compiler/2024.2/lib/libintelocl.so +ENV LD_LIBRARY_PATH=/opt/intel/oneapi/debugger/2024.2/opt/debugger/lib:/opt/intel/oneapi/compiler/2024.2/opt/compiler/lib:/opt/intel/oneapi/compiler/2024.2/lib +ENV NLSPATH=/opt/intel/oneapi/mkl/2024.2/share/locale/%l_%t/%N:/opt/intel/oneapi/compiler/2024.2/lib/compiler/locale/%l_%t/%N +ENV PATH=$PATH:/opt/intel/oneapi/dev-utilities/2024.2/bin:/opt/intel/oneapi/debugger/2024.2/opt/debugger/bin:/opt/intel/oneapi/compiler/2024.2/bin +ENV INTEL_PYTHONHOME=/opt/intel/oneapi/debugger/2024.2/opt/debugger +ENV CPATH=/opt/intel/oneapi/dpl/2022.6/include:/opt/intel/oneapi/dev-utilities/2024.2/include: + +# Set Intel DPC++ as a default compiler +ENV CC=icx +ENV CXX=icpx diff --git a/.github/workflows/ubuntu_22_dpcpp.yml b/.github/workflows/ubuntu_22_dpcpp.yml new file mode 100644 index 00000000000000..4af7b08a334996 --- /dev/null +++ b/.github/workflows/ubuntu_22_dpcpp.yml @@ -0,0 +1,90 @@ +name: Linux (Ubuntu 22.04, Python 3.11, Intel DPC++ Compiler) +on: + workflow_dispatch: + pull_request: + merge_group: + +concurrency: + # github.ref is not unique in post-commit + group: ${{ github.event_name == 'push' && github.run_id || github.ref }}-ubuntu-22-dpcpp + cancel-in-progress: true + +permissions: read-all + +jobs: + Smart_CI: + runs-on: ubuntu-latest + outputs: + affected_components: "${{ steps.smart_ci.outputs.affected_components }}" + changed_components: "${{ steps.smart_ci.outputs.changed_components }}" + skip_workflow: "${{ steps.smart_ci.outputs.skip_workflow }}" + steps: + - name: checkout action + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + sparse-checkout: .github/actions/smart-ci + + - name: Get affected components + id: smart_ci + uses: ./.github/actions/smart-ci + with: + repository: ${{ github.repository }} + pr: ${{ github.event.number }} + commit_sha: ${{ github.sha }} + ref_name: ${{ github.ref_name }} + component_pattern: "category: (.*)" + repo_token: ${{ secrets.GITHUB_TOKEN }} + skip_when_only_listed_labels_set: 'docs' + skip_when_only_listed_files_changed: '*.md,*.rst,*.png,*.jpg,*.svg' + + - name: Show affected components + run: | + echo "${{ toJSON(steps.smart_ci.outputs.affected_components) }}" + shell: bash + + Docker: + needs: Smart_CI + runs-on: aks-linux-4-cores-16gb-docker-build + container: + image: openvinogithubactions.azurecr.io/docker_build:0.2 + volumes: + - /mount:/mount + outputs: + images: "${{ steps.handle_docker.outputs.images }}" + steps: + - name: Checkout + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + + - uses: ./.github/actions/handle_docker + id: handle_docker + with: + images: | + ov_build/ubuntu_22_04_x64_dpcpp + registry: 'openvinogithubactions.azurecr.io' + dockerfiles_root_dir: '.github/dockerfiles' + changed_components: ${{ needs.smart_ci.outputs.changed_components }} + + Build: + needs: [Docker, Smart_CI] + if: "!needs.smart_ci.outputs.skip_workflow" + uses: ./.github/workflows/job_build_linux.yml + with: + runner: 'aks-linux-16-cores-32gb' + container: '{"image": "${{ fromJSON(needs.docker.outputs.images).ov_build.ubuntu_22_04_x64_dpcpp }}", "volumes": ["/mount:/mount"], "options": "-e SCCACHE_AZURE_BLOB_CONTAINER -e SCCACHE_AZURE_CONNECTION_STRING"}' + affected-components: ${{ needs.smart_ci.outputs.affected_components }} + event-name: ${{ github.event_name }} + os: 'ubuntu_22_04_dpcpp' + + Overall_Status: + name: ci/gha_overall_status_ubuntu_22.04_dpcpp + needs: [Smart_CI, Build] + if: ${{ always() }} + runs-on: ubuntu-latest + steps: + - name: Check status of all jobs + if: >- + ${{ + contains(needs.*.result, 'failure') || + contains(needs.*.result, 'cancelled') + }} + run: exit 1 diff --git a/cmake/developer_package/compile_flags/os_flags.cmake b/cmake/developer_package/compile_flags/os_flags.cmake index a49dce9bce7b50..bb80787ee3d811 100644 --- a/cmake/developer_package/compile_flags/os_flags.cmake +++ b/cmake/developer_package/compile_flags/os_flags.cmake @@ -289,6 +289,8 @@ endif() if(NOT DEFINED CMAKE_CXX_STANDARD) if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") set(CMAKE_CXX_STANDARD 14) + elseif(OV_COMPILER_IS_INTEL_LLVM) + set(CMAKE_CXX_STANDARD 17) else() set(CMAKE_CXX_STANDARD 11) endif() diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp index 46e06466d5f8ba..237860ec692e76 100644 --- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp +++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp @@ -34,6 +34,7 @@ struct PagedAttentionExecutor { static const size_t ID_ALIBI_SLOPES = 11; // [H|0], float static const size_t ID_MAX_CONTEXT_LEN = 12; // [] virtual void execute(const std::vector& inputs, const std::vector outputs) = 0; + virtual ~PagedAttentionExecutor() = default; }; #ifdef OPENVINO_ARCH_X86_64 diff --git a/src/plugins/intel_gpu/CMakeLists.txt b/src/plugins/intel_gpu/CMakeLists.txt index 53b4a203301c77..795d259b277e2b 100644 --- a/src/plugins/intel_gpu/CMakeLists.txt +++ b/src/plugins/intel_gpu/CMakeLists.txt @@ -8,6 +8,10 @@ endif() set (TARGET_NAME "openvino_intel_gpu_plugin") +if(OV_COMPILER_IS_INTEL_LLVM) + find_package(IntelSYCL REQUIRED) +endif() + if((CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG) AND CMAKE_CXX_STANDARD GREATER_EQUAL 20) set(CMAKE_CXX_FLAGS "-Wno-error=deprecated ${CMAKE_CXX_FLAGS}") endif() diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp index fa8a8807bbd92c..3e8887fbb2f7ee 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp @@ -90,7 +90,7 @@ struct kernel_impl_params final { , primary_input_idx(0) { } - virtual ~kernel_impl_params() = default; + ~kernel_impl_params() = default; const layout& get_input_layout(size_t idx = 0) const { OPENVINO_ASSERT(input_layouts.size() > idx, diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/implementation_desc.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/implementation_desc.hpp index 4e5c53d6b37e3e..e84311a9cfb592 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/primitives/implementation_desc.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/implementation_desc.hpp @@ -18,6 +18,7 @@ enum class impl_types : uint8_t { common = 1 << 1, ocl = 1 << 2, onednn = 1 << 3, + sycl = 1 << 4, any = 0xFF, }; diff --git a/src/plugins/intel_gpu/include/intel_gpu/runtime/engine_configuration.hpp b/src/plugins/intel_gpu/include/intel_gpu/runtime/engine_configuration.hpp index 042fa7cfd3dc67..e81dd9dec9d2f5 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/runtime/engine_configuration.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/runtime/engine_configuration.hpp @@ -11,11 +11,13 @@ namespace cldnn { /// @brief Defines available engine types enum class engine_types : int32_t { ocl, + sycl }; inline std::ostream& operator<<(std::ostream& os, const engine_types& type) { switch (type) { case engine_types::ocl: os << "ocl"; break; + case engine_types::sycl: os << "sycl"; break; default: os << "unknown"; break; } diff --git a/src/plugins/intel_gpu/src/graph/CMakeLists.txt b/src/plugins/intel_gpu/src/graph/CMakeLists.txt index db25a90e42b446..d82984205c0307 100644 --- a/src/plugins/intel_gpu/src/graph/CMakeLists.txt +++ b/src/plugins/intel_gpu/src/graph/CMakeLists.txt @@ -4,6 +4,7 @@ set(TARGET_NAME "openvino_intel_gpu_graph") +file(GLOB_RECURSE SYCL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/impls/sycl/*") file(GLOB_RECURSE LIBRARY_SRC "${INCLUDE_DIR}/*.h" "${INCLUDE_DIR}/*.hpp" @@ -22,6 +23,10 @@ if (NOT ENABLE_ONEDNN_FOR_GPU) endforeach(SOURCE_FILE) endif() +if(NOT OV_COMPILER_IS_INTEL_LLVM) + list(REMOVE_ITEM LIBRARY_SRC ${SYCL_SOURCES}) +endif() + add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC}) target_include_directories(${TARGET_NAME} PUBLIC @@ -33,6 +38,11 @@ target_include_directories(${TARGET_NAME} PUBLIC target_compile_options(${TARGET_NAME} PRIVATE $<$:$,/Os,-Os>>) +if(OV_COMPILER_IS_INTEL_LLVM) + add_sycl_to_target(TARGET ${TARGET_NAME} SOURCES ${SYCL_SOURCES}) + target_compile_definitions(${TARGET_NAME} PUBLIC OV_GPU_WITH_SYCL) +endif() + target_link_libraries(${TARGET_NAME} PUBLIC OpenCL::OpenCL openvino::shape_inference) target_link_libraries(${TARGET_NAME} PRIVATE openvino_intel_gpu_kernels openvino_intel_gpu_runtime diff --git a/src/plugins/intel_gpu/src/graph/impls/sycl/README.md b/src/plugins/intel_gpu/src/graph/impls/sycl/README.md new file mode 100644 index 00000000000000..851ef8f5d18519 --- /dev/null +++ b/src/plugins/intel_gpu/src/graph/impls/sycl/README.md @@ -0,0 +1,16 @@ +# How to build with DPC++ support + +1. Install OneAPI base toolkit. Guide: https://www.intel.com/content/www/us/en/docs/oneapi/installation-guide-linux/2024-0/installation.html +2. Export environment: + $ source /opt/intel/oneapi/setvars.sh + +3. configure cmake with the following additional options: + - `-DCMAKE_CXX_FLAGS:STRING=--gcc-install-dir=/lib/gcc/x86_64-linux-gnu/12/ -DCMAKE_C_FLAGS:STRING=--gcc-install-dir=/lib/gcc/x86_64-linux-gnu/12/` + - This WA is needed if multiple GCC version available in the system + - `-DCMAKE_CXX_STANDARD:STRING=17` + - Sycl requires c++17 + - `-DENABLE_SYSTEM_OPENCL=OFF` + - May help to avoid opencl icd/header conflicts as sycl package may have no clhpp headers + - `-DCMAKE_C_COMPILER:FILEPATH=icx -DCMAKE_CXX_COMPILER:FILEPATH=icpx` + - For now find_package(IntelSYCL) doesn't work if compiler is not icpx +4. make -j$(nproc) diff --git a/src/plugins/intel_gpu/src/graph/impls/sycl/primitive_sycl_base.h b/src/plugins/intel_gpu/src/graph/impls/sycl/primitive_sycl_base.h new file mode 100644 index 00000000000000..a6b0e3512e80b3 --- /dev/null +++ b/src/plugins/intel_gpu/src/graph/impls/sycl/primitive_sycl_base.h @@ -0,0 +1,90 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "primitive_inst.h" +#include "intel_gpu/runtime/memory.hpp" +#include "register.hpp" +#include "utils.hpp" +#include "runtime/ocl/ocl_event.hpp" + +#include + +#include "sycl/sycl.hpp" + +namespace cldnn { +namespace sycl { + +static std::mutex cacheAccessMutex; + +template +struct typed_primitive_sycl_impl : public typed_primitive_impl { + const engine* _engine; + + typed_primitive_sycl_impl(const engine& engine, const ExecutionConfig& config, std::shared_ptr weights_reorder = nullptr) + : typed_primitive_impl(weights_reorder, "sycl_kernel"), + _engine(&engine) { } + + typed_primitive_sycl_impl() + : typed_primitive_impl({}, "undef"), + _engine(nullptr) { + } + + bool is_cpu() const override { return false; } + bool is_onednn() const override { return false; } + + void save(BinaryOutputBuffer& ob) const override { + } + + void load(BinaryInputBuffer& ib) override { + } + +protected: + void init_kernels(const kernels_cache&, const kernel_impl_params&) override { } + + void set_arguments_impl(typed_primitive_inst& instance) override { + if (instance.can_be_optimized()) + return; + } + + void update_dispatch_data(const kernel_impl_params& impl_params) override {} + + void set_arguments_impl(typed_primitive_inst& instance, kernel_arguments_data& args) override { + if (instance.can_be_optimized()) { + return; + } + } + + event::ptr execute_impl(const std::vector& /* events */, + typed_primitive_inst& instance) override { + auto& network = instance.get_network(); + auto& stream = network.get_stream(); + auto net_id = network.get_id(); + event::ptr event; + + + return event; + } + + static event::ptr to_ocl_event(stream& stream, ::sycl::event e) { + if (stream.get_queue_type() == QueueTypes::out_of_order) { + auto native_events = get_native<::sycl::backend::opencl, ::sycl::event>(e); + std::vector events; + for (auto& e : native_events) { + events.push_back(std::make_shared(cl::Event(e, true))); + } + return events.empty() ? stream.create_user_event(true) : stream.group_events(events); + } else { + return stream.create_user_event(true); + } + } + + std::vector get_internal_buffer_layouts_impl() const override { + return {}; + } +}; + +} // namespace sycl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/graph/impls/sycl/register.cpp b/src/plugins/intel_gpu/src/graph/impls/sycl/register.cpp new file mode 100644 index 00000000000000..9d2ae6808fbfc6 --- /dev/null +++ b/src/plugins/intel_gpu/src/graph/impls/sycl/register.cpp @@ -0,0 +1,17 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "register.hpp" + +namespace cldnn { +namespace sycl { + +#define REGISTER_SYCL_IMPL(prim) \ + static detail::attach_##prim##_sycl attach_##prim + +void register_implementations() { +} + +} // namespace sycl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/graph/impls/sycl/register.hpp b/src/plugins/intel_gpu/src/graph/impls/sycl/register.hpp new file mode 100644 index 00000000000000..38fa9df02c5d88 --- /dev/null +++ b/src/plugins/intel_gpu/src/graph/impls/sycl/register.hpp @@ -0,0 +1,23 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + + +namespace cldnn { +namespace sycl { +void register_implementations(); + +namespace detail { + +#define REGISTER_SYCL_IMPL(prim) \ + struct attach_##prim##_sycl { \ + attach_##prim##_sycl(); \ + } + +#undef REGISTER_SYCL_IMPL + +} // namespace detail +} // namespace sycl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/graph/program.cpp b/src/plugins/intel_gpu/src/graph/program.cpp index 820bb87f4a9d6f..40d858c38fe85a 100644 --- a/src/plugins/intel_gpu/src/graph/program.cpp +++ b/src/plugins/intel_gpu/src/graph/program.cpp @@ -75,6 +75,9 @@ #ifdef ENABLE_ONEDNN_FOR_GPU #include "impls/onednn/register.hpp" #endif +#ifdef OV_GPU_WITH_SYCL +#include "impls/sycl/register.hpp" +#endif #include "kernel_base.h" @@ -257,6 +260,9 @@ void program::init_primitives() { onednn::register_implementations(); #endif cpu::register_implementations(); +#ifdef OV_GPU_WITH_SYCL + sycl::register_implementations(); +#endif is_initialized = true; } } diff --git a/src/plugins/intel_gpu/src/plugin/plugin.cpp b/src/plugins/intel_gpu/src/plugin/plugin.cpp index e3f7c2cfe2f6b5..69bc3a912fda43 100644 --- a/src/plugins/intel_gpu/src/plugin/plugin.cpp +++ b/src/plugins/intel_gpu/src/plugin/plugin.cpp @@ -145,7 +145,11 @@ Plugin::Plugin() { register_primitives(); // Set OCL runtime which should be always available +#ifdef OV_GPU_WITH_SYCL + cldnn::device_query device_query(cldnn::engine_types::sycl, cldnn::runtime_types::ocl); +#else cldnn::device_query device_query(cldnn::engine_types::ocl, cldnn::runtime_types::ocl); +#endif m_device_map = device_query.get_available_devices(); // Set default configs for each device diff --git a/src/plugins/intel_gpu/src/plugin/remote_context.cpp b/src/plugins/intel_gpu/src/plugin/remote_context.cpp index b36fe7f38a776e..6d24eaea401689 100644 --- a/src/plugins/intel_gpu/src/plugin/remote_context.cpp +++ b/src/plugins/intel_gpu/src/plugin/remote_context.cpp @@ -28,7 +28,12 @@ Type extract_object(const ov::AnyMap& params, const ov::Property& p) { RemoteContextImpl::RemoteContextImpl(const std::string& device_name, std::vector devices) : m_device_name(device_name) { OPENVINO_ASSERT(devices.size() == 1, "[GPU] Currently context can be created for single device only"); +#ifdef OV_GPU_WITH_SYCL + const auto engine_type = cldnn::engine_types::sycl; +#else const auto engine_type = cldnn::engine_types::ocl; +#endif + const auto runtime_type = cldnn::runtime_types::ocl; m_engine = cldnn::engine::create(engine_type, runtime_type, devices.front()); diff --git a/src/plugins/intel_gpu/src/runtime/CMakeLists.txt b/src/plugins/intel_gpu/src/runtime/CMakeLists.txt index 1439620b71e386..23fce3a3354756 100644 --- a/src/plugins/intel_gpu/src/runtime/CMakeLists.txt +++ b/src/plugins/intel_gpu/src/runtime/CMakeLists.txt @@ -21,6 +21,12 @@ set(LIBRARY_SOURCES_ALL ${LIBRARY_SOURCES_OCL} ) +file(GLOB_RECURSE SYCL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/ocl/sycl_*.cpp") + +if(NOT OV_COMPILER_IS_INTEL_LLVM) + list(REMOVE_ITEM LIBRARY_SOURCES_ALL ${SYCL_SOURCES}) +endif() + add_library(${TARGET_NAME} STATIC ${LIBRARY_SOURCES_ALL}) if(NOT BUILD_SHARED_LIBS) @@ -44,6 +50,11 @@ target_compile_options(${TARGET_NAME} PRIVATE add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME}) +if(OV_COMPILER_IS_INTEL_LLVM) + add_sycl_to_target(TARGET ${TARGET_NAME} SOURCES ${SYCL_SOURCES}) + target_compile_definitions(${TARGET_NAME} PUBLIC OV_GPU_WITH_SYYCL) +endif() + ov_set_threading_interface_for(${TARGET_NAME}) target_link_libraries(${TARGET_NAME} PRIVATE diff --git a/src/plugins/intel_gpu/src/runtime/device_query.cpp b/src/plugins/intel_gpu/src/runtime/device_query.cpp index 7cb419deee4f19..4306e7aada874b 100644 --- a/src/plugins/intel_gpu/src/runtime/device_query.cpp +++ b/src/plugins/intel_gpu/src/runtime/device_query.cpp @@ -17,6 +17,7 @@ device_query::device_query(engine_types engine_type, int ctx_device_id, int target_tile_id) { switch (engine_type) { + case engine_types::sycl: case engine_types::ocl: { if (runtime_type != runtime_types::ocl) throw std::runtime_error("Unsupported runtime type for ocl engine"); diff --git a/src/plugins/intel_gpu/src/runtime/engine.cpp b/src/plugins/intel_gpu/src/runtime/engine.cpp index e8879905ffe40a..7d1d016b77b5ff 100644 --- a/src/plugins/intel_gpu/src/runtime/engine.cpp +++ b/src/plugins/intel_gpu/src/runtime/engine.cpp @@ -252,6 +252,11 @@ void engine::subtract_memory_used(uint64_t bytes, allocation_type type) { std::shared_ptr engine::create(engine_types engine_type, runtime_types runtime_type, const device::ptr device) { std::shared_ptr ret; switch (engine_type) { +#ifdef OV_GPU_WITH_SYCL + case engine_types::sycl: + ret = ocl::create_sycl_engine(device, runtime_type); + break; +#endif // OV_GPU_WITH_SYCL case engine_types::ocl: ret = ocl::create_ocl_engine(device, runtime_type); break; diff --git a/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp b/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp index 3f19b348cca600..d6dcaf5dd72d14 100644 --- a/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp +++ b/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp @@ -620,7 +620,7 @@ void kernels_cache::add_to_cached_kernels(const std::vector& kernel } void kernels_cache::save(BinaryOutputBuffer& ob) const { - OPENVINO_ASSERT(_engine.type() == engine_types::ocl, "[GPU] Not supported engine type"); + OPENVINO_ASSERT(_engine.type() == engine_types::ocl || _engine.type() == engine_types::sycl, "[GPU] Not supported engine type"); ob << _cached_binaries.size(); for (auto& cached_binary : _cached_binaries) { @@ -630,7 +630,7 @@ void kernels_cache::save(BinaryOutputBuffer& ob) const { } void kernels_cache::load(BinaryInputBuffer& ib) { - OPENVINO_ASSERT(_engine.type() == engine_types::ocl, "[GPU] Not supported engine type"); + OPENVINO_ASSERT(_engine.type() == engine_types::ocl || _engine.type() == engine_types::sycl, "[GPU] Not supported engine type"); std::unordered_map> precompiled_kernels; diff --git a/src/plugins/intel_gpu/src/runtime/kernels_factory.cpp b/src/plugins/intel_gpu/src/runtime/kernels_factory.cpp index 7dd7be87365204..448afa863609f3 100644 --- a/src/plugins/intel_gpu/src/runtime/kernels_factory.cpp +++ b/src/plugins/intel_gpu/src/runtime/kernels_factory.cpp @@ -10,7 +10,9 @@ namespace kernels_factory { std::shared_ptr create(engine& engine, cl_context context, cl_kernel kernel, std::string entry_point) { switch (engine.type()) { - case engine_types::ocl: return ocl::create_ocl_kernel(engine, context, kernel, entry_point); + case engine_types::sycl: + case engine_types::ocl: + return ocl::create_ocl_kernel(engine, context, kernel, entry_point); default: throw std::runtime_error("Unsupported engine type in kernels_factory::create"); } } diff --git a/src/plugins/intel_gpu/src/runtime/memory.cpp b/src/plugins/intel_gpu/src/runtime/memory.cpp index 4e7f9b37c393f7..5e79af34c6ce14 100644 --- a/src/plugins/intel_gpu/src/runtime/memory.cpp +++ b/src/plugins/intel_gpu/src/runtime/memory.cpp @@ -47,7 +47,9 @@ memory::memory(engine* engine, const layout& layout, allocation_type type, std:: std::unique_ptr surfaces_lock::create(engine_types engine_type, std::vector mem, const stream& stream) { switch (engine_type) { - case engine_types::ocl: return std::unique_ptr(new ocl::ocl_surfaces_lock(mem, stream)); + case engine_types::sycl: + case engine_types::ocl: + return std::unique_ptr(new ocl::ocl_surfaces_lock(mem, stream)); default: throw std::runtime_error("Unsupported engine type in surfaces_lock::create"); } } diff --git a/src/plugins/intel_gpu/src/runtime/ocl/ocl_engine_factory.hpp b/src/plugins/intel_gpu/src/runtime/ocl/ocl_engine_factory.hpp index fad0a483e0c988..2ddfe28ceeb214 100644 --- a/src/plugins/intel_gpu/src/runtime/ocl/ocl_engine_factory.hpp +++ b/src/plugins/intel_gpu/src/runtime/ocl/ocl_engine_factory.hpp @@ -14,6 +14,9 @@ namespace ocl { // Factory for ocl_engine creation. It's moved outside of ocl_engine class to avoid possible CL includes conflict // between different engines in engine.cpp file std::shared_ptr create_ocl_engine(const device::ptr device, runtime_types runtime_type); +#ifdef OV_GPU_WITH_SYCL +std::shared_ptr create_sycl_engine(const device::ptr device, runtime_types runtime_type); +#endif // OV_GPU_WITH_SYCL } // namespace ocl } // namespace cldnn diff --git a/src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.cpp b/src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.cpp new file mode 100644 index 00000000000000..b5da32efbfa8c0 --- /dev/null +++ b/src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "sycl_engine.hpp" +#include "sycl_stream.hpp" + + +namespace cldnn { +namespace ocl { + + +sycl_engine::sycl_engine(const device::ptr dev, runtime_types runtime_type) + : ocl_engine(dev, runtime_type) { + sycl_context = cldnn::make_unique<::sycl::context>(sycl::make_context<::sycl::backend::opencl>(get_cl_context().get())); +} + +stream::ptr sycl_engine::create_stream(const ExecutionConfig& config) const { + return std::make_shared(*this, config); +} + +stream::ptr sycl_engine::create_stream(const ExecutionConfig& config, void* handle) const { + return std::make_shared(*this, config, handle); +} + +std::shared_ptr create_sycl_engine(const device::ptr device, runtime_types runtime_type) { + return std::make_shared(device, runtime_type); +} + +::sycl::context& sycl_engine::get_sycl_context() const { + OPENVINO_ASSERT(sycl_context != nullptr); + + return *sycl_context; +} + +} // namespace ocl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.hpp b/src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.hpp new file mode 100644 index 00000000000000..253f6af6795db9 --- /dev/null +++ b/src/plugins/intel_gpu/src/runtime/ocl/sycl_engine.hpp @@ -0,0 +1,28 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include "ocl_engine.hpp" + +#include "sycl/sycl.hpp" + + +namespace cldnn { +namespace ocl { + +class sycl_engine : public ocl_engine { +public: + sycl_engine(const device::ptr dev, runtime_types runtime_type); + + stream_ptr create_stream(const ExecutionConfig& config) const override; + stream_ptr create_stream(const ExecutionConfig& config, void *handle) const override; + + ::sycl::context& get_sycl_context() const; + std::unique_ptr<::sycl::context> sycl_context = nullptr; +}; + +} // namespace ocl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.cpp b/src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.cpp new file mode 100644 index 00000000000000..e9be7a060ba2e4 --- /dev/null +++ b/src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.cpp @@ -0,0 +1,30 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "sycl_stream.hpp" +#include "intel_gpu/runtime/utils.hpp" +#include "sycl_engine.hpp" + +namespace cldnn { +namespace ocl { + + +sycl_stream::sycl_stream(const sycl_engine& engine, const ExecutionConfig& config) + : ocl_stream(engine, config) { + sycl_queue = cldnn::make_unique<::sycl::queue>(::sycl::make_queue<::sycl::backend::opencl>(get_cl_queue().get(), engine.get_sycl_context())); +} + + +sycl_stream::sycl_stream(const sycl_engine &engine, const ExecutionConfig& config, void *handle) + : ocl_stream(engine, config, handle) { + sycl_queue = cldnn::make_unique<::sycl::queue>(::sycl::make_queue<::sycl::backend::opencl>(get_cl_queue().get(), engine.get_sycl_context())); +} + +::sycl::queue& sycl_stream::get_sycl_queue() { + OPENVINO_ASSERT(sycl_queue != nullptr); + return *sycl_queue; +} + +} // namespace ocl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.hpp b/src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.hpp new file mode 100644 index 00000000000000..208b155d519dba --- /dev/null +++ b/src/plugins/intel_gpu/src/runtime/ocl/sycl_stream.hpp @@ -0,0 +1,26 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "ocl_stream.hpp" +#include "sycl_engine.hpp" + +#include "sycl/sycl.hpp" + + +namespace cldnn { +namespace ocl { + +class sycl_stream : public ocl_stream { +public: + sycl_stream(const sycl_engine& engine, const ExecutionConfig& config); + sycl_stream(const sycl_engine &engine, const ExecutionConfig& config, void *handle); + + ::sycl::queue& get_sycl_queue(); + std::unique_ptr<::sycl::queue> sycl_queue = nullptr; +}; + +} // namespace ocl +} // namespace cldnn diff --git a/src/plugins/intel_gpu/src/runtime/stream.cpp b/src/plugins/intel_gpu/src/runtime/stream.cpp index 0ee63a78b806e5..0fab4d38a1402a 100644 --- a/src/plugins/intel_gpu/src/runtime/stream.cpp +++ b/src/plugins/intel_gpu/src/runtime/stream.cpp @@ -12,7 +12,9 @@ namespace cldnn { QueueTypes stream::detect_queue_type(engine_types engine_type, void* queue_handle) { switch (engine_type) { - case engine_types::ocl: return ocl::ocl_stream::detect_queue_type(queue_handle); + case engine_types::sycl: + case engine_types::ocl: + return ocl::ocl_stream::detect_queue_type(queue_handle); default: throw std::runtime_error("Invalid engine type"); } } diff --git a/src/plugins/intel_gpu/tests/unit/CMakeLists.txt b/src/plugins/intel_gpu/tests/unit/CMakeLists.txt index 8bff8f56c50156..2c7a4b12735cc0 100644 --- a/src/plugins/intel_gpu/tests/unit/CMakeLists.txt +++ b/src/plugins/intel_gpu/tests/unit/CMakeLists.txt @@ -11,6 +11,11 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") ov_add_compiler_flags(/wd4305) endif() +if(OV_COMPILER_IS_INTEL_LLVM) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=lld") + string(REPLACE "-pie" "" CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") +endif() + set(TARGET_NAME "ov_gpu_unit_tests") file(GLOB_RECURSE SOURCES_MAIN diff --git a/src/plugins/intel_npu/src/plugin/CMakeLists.txt b/src/plugins/intel_npu/src/plugin/CMakeLists.txt index f071d001d44994..30e4eae254de90 100644 --- a/src/plugins/intel_npu/src/plugin/CMakeLists.txt +++ b/src/plugins/intel_npu/src/plugin/CMakeLists.txt @@ -66,7 +66,7 @@ target_include_directories(${TARGET_NAME} ${NPU_PLUGIN_SOURCE_DIR}/thirdparty/level-zero-ext ) -if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU") +if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR OV_COMPILER_IS_INTEL_LLVM) target_compile_options(${TARGET_NAME} PRIVATE -mavx2 -mf16c) elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") target_compile_options(${TARGET_NAME} PRIVATE /arch:AVX2) From b38eb133e9fa0676441e807291a04ed243d639be Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Fri, 23 Aug 2024 01:45:48 +0400 Subject: [PATCH 089/117] Cmake: generalized THREADING=OMP to work on supported platforms (#26175) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --- cmake/dependencies.cmake | 94 +++++----- .../developer_package/packaging/archive.cmake | 2 + .../packaging/common-libraries.cmake | 2 + .../packaging/debian/debian.cmake | 2 + cmake/developer_package/packaging/npm.cmake | 2 + cmake/developer_package/packaging/nsis.cmake | 2 + .../developer_package/packaging/rpm/rpm.cmake | 2 + cmake/features.cmake | 14 +- cmake/templates/OpenVINOConfig.cmake.in | 54 +++++- .../OpenVINODeveloperPackageConfig.cmake.in | 3 +- ...DeveloperPackageConfigRelocatable.cmake.in | 4 +- src/bindings/python/CMakeLists.txt | 4 +- src/bindings/python/wheel/CMakeLists.txt | 5 - src/bindings/python/wheel/setup.py | 8 + src/cmake/ov_parallel.cmake | 168 ++++++++++-------- src/common/util/src/file_util.cpp | 4 +- 16 files changed, 230 insertions(+), 140 deletions(-) diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake index 2ebfceb8b9612e..a152ff85c9c768 100644 --- a/cmake/dependencies.cmake +++ b/cmake/dependencies.cmake @@ -9,55 +9,55 @@ ov_set_temp_directory(TEMP "${CMAKE_SOURCE_DIR}") ## Intel OMP package if(THREADING STREQUAL "OMP") - reset_deps_cache(OMP) - if(WIN32 AND X86_64) - RESOLVE_DEPENDENCY(OMP - ARCHIVE_WIN "iomp.zip" - TARGET_PATH "${TEMP}/omp" - ENVIRONMENT "OMP" - VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*" - SHA256 "62c68646747fb10f19b53217cb04a1e10ff93606f992e6b35eb8c31187c68fbf" - USE_NEW_LOCATION TRUE) - elseif(LINUX AND X86_64 AND OPENVINO_GNU_LIBC) - RESOLVE_DEPENDENCY(OMP - ARCHIVE_LIN "iomp.tgz" - TARGET_PATH "${TEMP}/omp" - ENVIRONMENT "OMP" - VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*" - SHA256 "7832b16d82513ee880d97c27c7626f9525ebd678decf6a8fe6c38550f73227d9" - USE_NEW_LOCATION TRUE) - elseif(APPLE AND X86_64) - RESOLVE_DEPENDENCY(OMP - ARCHIVE_MAC "iomp_20190130_mac.tgz" - TARGET_PATH "${TEMP}/omp" - ENVIRONMENT "OMP" - VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*" - SHA256 "591ea4a7e08bbe0062648916f42bded71d24c27f00af30a8f31a29b5878ea0cc" - USE_NEW_LOCATION TRUE) - else() - message(WARNING "Pre-built Intel OMP is not available on current platform. System OMP will be used.") - find_package(OpenMP) - if(OpenMP_CXX_FOUND) - foreach(OpenMP_LIB ${OpenMP_CXX_LIBRARIES}) - string(FIND ${OpenMP_LIB} "omp" OpenMP_LIB_OMP_INDEX) - if(NOT OpenMP_LIB_OMP_INDEX EQUAL -1) - cmake_path(GET OpenMP_LIB PARENT_PATH OpenMP_LIB_DIR) - set(OMP_LIB ${OpenMP_LIB} CACHE FILEPATH "Path to OMP library") - set(OMP ${OpenMP_LIB_DIR} CACHE FILEPATH "Path to OMP root folder") - return() - endif() - endforeach() + # check whether the compiler supports OpenMP at all + find_package(OpenMP) + + if(NOT OpenMP_CXX_FOUND) + message(WARNING "Compiler does not support OpenMP standard. Falling back to SEQ threading") + set(THREADING "SEQ") + set(ENABLE_INTEL_OPENMP OFF) + endif() + + if(ENABLE_INTEL_OPENMP) + reset_deps_cache(OMP) + if(WIN32 AND X86_64) + RESOLVE_DEPENDENCY(INTEL_OMP + ARCHIVE_WIN "iomp.zip" + TARGET_PATH "${TEMP}/omp" + ENVIRONMENT "INTEL_OMP" + VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*" + SHA256 "62c68646747fb10f19b53217cb04a1e10ff93606f992e6b35eb8c31187c68fbf" + USE_NEW_LOCATION TRUE) + elseif(LINUX AND X86_64 AND OPENVINO_GNU_LIBC) + RESOLVE_DEPENDENCY(INTEL_OMP + ARCHIVE_LIN "iomp.tgz" + TARGET_PATH "${TEMP}/omp" + ENVIRONMENT "INTEL_OMP" + VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*" + SHA256 "7832b16d82513ee880d97c27c7626f9525ebd678decf6a8fe6c38550f73227d9" + USE_NEW_LOCATION TRUE) + elseif(APPLE AND X86_64) + RESOLVE_DEPENDENCY(INTEL_OMP + ARCHIVE_MAC "iomp_20190130_mac.tgz" + TARGET_PATH "${TEMP}/omp" + ENVIRONMENT "INTEL_OMP" + VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*" + SHA256 "591ea4a7e08bbe0062648916f42bded71d24c27f00af30a8f31a29b5878ea0cc" + USE_NEW_LOCATION TRUE) + endif() + + if(INTEL_OMP) + update_deps_cache(INTEL_OMP "${INTEL_OMP}" "Path to OMP root folder") + debug_message(STATUS "intel_omp=" ${INTEL_OMP}) + + ov_cpack_add_component(omp HIDDEN) + file(GLOB_RECURSE source_list "${INTEL_OMP}/*${CMAKE_SHARED_LIBRARY_SUFFIX}*") + install(FILES ${source_list} + DESTINATION ${OV_CPACK_RUNTIMEDIR} + COMPONENT intel_omp + ${OV_CPACK_COMP_OPENMP_EXCLUDE_ALL}) endif() - message(FATAL_ERROR "System OpenMP has not been found") endif() - update_deps_cache(OMP "${OMP}" "Path to OMP root folder") - debug_message(STATUS "intel_omp=" ${OMP}) - - ov_cpack_add_component(omp HIDDEN) - file(GLOB_RECURSE source_list "${OMP}/*${CMAKE_SHARED_LIBRARY_SUFFIX}*") - install(FILES ${source_list} - DESTINATION ${OV_CPACK_RUNTIMEDIR} - COMPONENT omp) endif() ## TBB package diff --git a/cmake/developer_package/packaging/archive.cmake b/cmake/developer_package/packaging/archive.cmake index da6c676de6c574..6df5145ae2e488 100644 --- a/cmake/developer_package/packaging/archive.cmake +++ b/cmake/developer_package/packaging/archive.cmake @@ -74,6 +74,8 @@ macro(ov_define_component_include_rules) # tbb unset(OV_CPACK_COMP_TBB_EXCLUDE_ALL) unset(OV_CPACK_COMP_TBB_DEV_EXCLUDE_ALL) + # openmp + unset(OV_CPACK_COMP_OPENMP_EXCLUDE_ALL) # licensing unset(OV_CPACK_COMP_LICENSING_EXCLUDE_ALL) # samples diff --git a/cmake/developer_package/packaging/common-libraries.cmake b/cmake/developer_package/packaging/common-libraries.cmake index 4ec96dc28b53e8..581c9144c1b907 100644 --- a/cmake/developer_package/packaging/common-libraries.cmake +++ b/cmake/developer_package/packaging/common-libraries.cmake @@ -79,6 +79,8 @@ macro(ov_define_component_include_rules) # tbb set(OV_CPACK_COMP_TBB_EXCLUDE_ALL EXCLUDE_FROM_ALL) set(OV_CPACK_COMP_TBB_DEV_EXCLUDE_ALL EXCLUDE_FROM_ALL) + # openmp + set(OV_CPACK_COMP_OPENMP_EXCLUDE_ALL EXCLUDE_FROM_ALL) # licensing if(CPACK_GENERATOR STREQUAL "CONAN") unset(OV_CPACK_COMP_LICENSING_EXCLUDE_ALL) diff --git a/cmake/developer_package/packaging/debian/debian.cmake b/cmake/developer_package/packaging/debian/debian.cmake index c7f49419111cea..f133428d66ec74 100644 --- a/cmake/developer_package/packaging/debian/debian.cmake +++ b/cmake/developer_package/packaging/debian/debian.cmake @@ -82,6 +82,8 @@ macro(ov_define_component_include_rules) # tbb set(OV_CPACK_COMP_TBB_EXCLUDE_ALL EXCLUDE_FROM_ALL) set(OV_CPACK_COMP_TBB_DEV_EXCLUDE_ALL EXCLUDE_FROM_ALL) + # openmp + set(OV_CPACK_COMP_OPENMP_EXCLUDE_ALL EXCLUDE_FROM_ALL) # licensing set(OV_CPACK_COMP_LICENSING_EXCLUDE_ALL EXCLUDE_FROM_ALL) # samples diff --git a/cmake/developer_package/packaging/npm.cmake b/cmake/developer_package/packaging/npm.cmake index 24453965125348..2a2509cdcae65a 100644 --- a/cmake/developer_package/packaging/npm.cmake +++ b/cmake/developer_package/packaging/npm.cmake @@ -61,6 +61,8 @@ macro(ov_define_component_include_rules) # tbb unset(OV_CPACK_COMP_TBB_EXCLUDE_ALL) set(OV_CPACK_COMP_TBB_DEV_EXCLUDE_ALL EXCLUDE_FROM_ALL) + # openmp + unset(OV_CPACK_COMP_OPENMP_EXCLUDE_ALL) # licensing unset(OV_CPACK_COMP_LICENSING_EXCLUDE_ALL) # samples diff --git a/cmake/developer_package/packaging/nsis.cmake b/cmake/developer_package/packaging/nsis.cmake index f5f9a233e8b87f..d7d8ed152c49d9 100644 --- a/cmake/developer_package/packaging/nsis.cmake +++ b/cmake/developer_package/packaging/nsis.cmake @@ -116,6 +116,8 @@ macro(ov_define_component_include_rules) # tbb unset(OV_CPACK_COMP_TBB_EXCLUDE_ALL) unset(OV_CPACK_COMP_TBB_DEV_EXCLUDE_ALL) + # openmp + unset(OV_CPACK_COMP_OPENMP_EXCLUDE_ALL) # licensing unset(OV_CPACK_COMP_LICENSING_EXCLUDE_ALL) # samples diff --git a/cmake/developer_package/packaging/rpm/rpm.cmake b/cmake/developer_package/packaging/rpm/rpm.cmake index 7c9fb4f22a372d..b7c482555bd131 100644 --- a/cmake/developer_package/packaging/rpm/rpm.cmake +++ b/cmake/developer_package/packaging/rpm/rpm.cmake @@ -73,6 +73,8 @@ macro(ov_define_component_include_rules) # tbb set(OV_CPACK_COMP_TBB_EXCLUDE_ALL EXCLUDE_FROM_ALL) set(OV_CPACK_COMP_TBB_DEV_EXCLUDE_ALL EXCLUDE_FROM_ALL) + # openmp + set(OV_CPACK_COMP_OPENMP_EXCLUDE_ALL EXCLUDE_FROM_ALL) # licensing set(OV_CPACK_COMP_LICENSING_EXCLUDE_ALL EXCLUDE_FROM_ALL) # samples diff --git a/cmake/features.cmake b/cmake/features.cmake index fa11b1894dfbba..d37c113e866ab8 100644 --- a/cmake/features.cmake +++ b/cmake/features.cmake @@ -85,8 +85,9 @@ ov_dependent_option (ENABLE_PKGCONFIG_GEN "Enable openvino.pc pkg-config file ge # # "OneDNN library based on OMP or TBB or Sequential implementation: TBB|OMP|SEQ" -if(RISCV64) +if(RISCV64 OR ANDROID) # oneDNN does not support non-SEQ for RISC-V architecture + # on Android we experience SEGFAULT during compilation set(THREADING_DEFAULT "SEQ") else() set(THREADING_DEFAULT "TBB") @@ -101,6 +102,17 @@ if(NOT THREADING IN_LIST THREADING_OPTIONS) message(FATAL_ERROR "THREADING should be set to either ${THREADING_OPTIONS}") endif() +if(X86_64 AND (WIN32 OR LINUX)) + # we have a precompiled version of Intel OMP only for this platforms + set(ENABLE_INTEL_OPENMP_DEFAULT ON) + # temporart override to OFF for testing purposes + set(ENABLE_INTEL_OPENMP_DEFAULT OFF) +else() + set(ENABLE_INTEL_OPENMP_DEFAULT OFF) +endif() + +ov_dependent_option (ENABLE_INTEL_OPENMP "Enables usage of Intel OpenMP instead of default compiler one" ${ENABLE_INTEL_OPENMP_DEFAULT} "THREADING STREQUAL SEQ" OFF) + if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") AND (BUILD_SHARED_LIBS OR (LINUX AND X86_64))) set(ENABLE_TBBBIND_2_5_DEFAULT ON) diff --git a/cmake/templates/OpenVINOConfig.cmake.in b/cmake/templates/OpenVINOConfig.cmake.in index af8dd1596c4a39..a276cf2c24eb66 100644 --- a/cmake/templates/OpenVINOConfig.cmake.in +++ b/cmake/templates/OpenVINOConfig.cmake.in @@ -10,6 +10,7 @@ # The following components are supported: # # * `Runtime`: OpenVINO C++ and C Core & Inference Runtime, frontend common +# * `Threading`: OpenVINO threading backend for parallel.hpp # * `JAX`: OpenVINO JAX frontend # * `ONNX`: OpenVINO ONNX frontend # * `Paddle`: OpenVINO Paddle frontend @@ -25,6 +26,10 @@ # # find_package(OpenVINO REQUIRED COMPONENTS Runtime ONNX) # +# If OpenVINO's openvino/core/parallel.hpp is required: +# +# find_package(OpenVINO REQUIRED COMPONENTS Runtime Threading) +# # Imported Targets: # ------ # @@ -150,9 +155,25 @@ macro(_ov_find_dependency dep) unset(cmake_fd_quiet_arg) endmacro() +macro(_ov_find_openmp) + set(_ov_threading "@THREADING@") + set(_ov_enable_intel_omp "@ENABLE_INTEL_OPENMP@") + + if(_ov_threading STREQUAL "OMP") + if(_ov_enable_intel_omp) + # TODO: write code to import iomp libraries + else() + _ov_find_dependency(OpenMP) + endif() + endif() + + unset(_ov_enable_intel_omp) + unset(_ov_threading) +endmacro() + macro(_ov_find_tbb) - set(THREADING "@THREADING@") - if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") + set(_ov_threading "@THREADING@") + if(_ov_threading STREQUAL "TBB" OR _ov_threading STREQUAL "TBB_AUTO") set(enable_pkgconfig_tbb "@tbb_FOUND@") # try tbb.pc @@ -224,6 +245,8 @@ macro(_ov_find_tbb) unset(enable_system_tbb) _ov_find_dependency(TBB + # we need to find at least the same version as we compiled with + @TBB_VERSION@ COMPONENTS tbb tbbmalloc ${find_package_tbb_extra_args}) unset(find_package_tbb_extra_args) @@ -245,6 +268,8 @@ macro(_ov_find_tbb) endif() unset(install_tbbbind) endif() + + unset(_ov_threading) endmacro() macro(_ov_find_pugixml) @@ -494,9 +519,14 @@ if(NOT TARGET openvino) endif() endif() +macro(_ov_enable_threading_interface) + _ov_find_tbb() + _ov_find_openmp() +endmacro() + if(NOT _OV_ENABLE_OPENVINO_BUILD_SHARED) # common openvino dependencies - _ov_find_tbb() + _ov_enable_threading_interface() _ov_find_itt() _ov_find_pugixml() @@ -549,6 +579,7 @@ endif() # set(${CMAKE_FIND_PACKAGE_NAME}_Runtime_FOUND ON) +set(${CMAKE_FIND_PACKAGE_NAME}_Threading_FOUND ON) set(${CMAKE_FIND_PACKAGE_NAME}_ONNX_FOUND @ENABLE_OV_ONNX_FRONTEND@) set(${CMAKE_FIND_PACKAGE_NAME}_Paddle_FOUND @ENABLE_OV_PADDLE_FRONTEND@) @@ -571,6 +602,23 @@ if(NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS) set(${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS Runtime) endif() +if(Threading IN_LIST ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS) + _ov_enable_threading_interface() + + if(TARGET TBB::tbb) + set(_ov_threading_lib TBB::tbb) + elseif(TARGET IntelOpenMP::OpenMP_CXX) + set(_ov_threading_lib IntelOpenMP::OpenMP_CXX) + elseif(TARGET OpenMP::OpenMP_CXX) + set(_ov_threading_lib OpenMP::OpenMP_CXX) + endif() + + if(_ov_threading_lib) + set_property(TARGET openvino::runtime APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${_ov_threading_lib}) + unset(_ov_threading_lib) + endif() +endif() + # # Apply common functions # diff --git a/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in b/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in index fe3f82a513e08c..22eb432a97400a 100644 --- a/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in +++ b/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in @@ -70,11 +70,12 @@ find_dependency(OpenVINODeveloperScripts NO_DEFAULT_PATH) find_dependency(OpenVINO + COMPONENTS ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS} PATHS "${CMAKE_CURRENT_LIST_DIR}" NO_CMAKE_FIND_ROOT_PATH NO_DEFAULT_PATH) -_ov_find_tbb() +_ov_enable_threading_interface() _ov_find_pugixml() include("${CMAKE_CURRENT_LIST_DIR}/openvino_developer_package_targets.cmake") diff --git a/cmake/templates/OpenVINODeveloperPackageConfigRelocatable.cmake.in b/cmake/templates/OpenVINODeveloperPackageConfigRelocatable.cmake.in index 613058cecc45a7..be8fc1fa802e23 100644 --- a/cmake/templates/OpenVINODeveloperPackageConfigRelocatable.cmake.in +++ b/cmake/templates/OpenVINODeveloperPackageConfigRelocatable.cmake.in @@ -52,14 +52,14 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR OFF) # # OpenVINO_DIR is supposed to be set as an environment variable -find_dependency(OpenVINO) +find_dependency(OpenVINO COMPONENTS ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS}) find_dependency(OpenVINODeveloperScripts PATHS "${CMAKE_CURRENT_LIST_DIR}" NO_CMAKE_FIND_ROOT_PATH NO_DEFAULT_PATH) -_ov_find_tbb() +_ov_enable_threading_interface() _ov_find_pugixml() include("${CMAKE_CURRENT_LIST_DIR}/OpenVINODeveloperPackageTargets.cmake") diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index dc816d73fa79b1..666b6bcd0d6969 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -251,7 +251,9 @@ endmacro() macro(ov_define_setup_py_dependencies) foreach(_target # Python API dependencies - _pyopenvino py_ov_frontends + pyopenvino py_ov_frontends + # C API + openvino_c # plugins ov_plugins # frontends diff --git a/src/bindings/python/wheel/CMakeLists.txt b/src/bindings/python/wheel/CMakeLists.txt index 97b5795c7a7e2c..b12921280c84c4 100644 --- a/src/bindings/python/wheel/CMakeLists.txt +++ b/src/bindings/python/wheel/CMakeLists.txt @@ -126,11 +126,6 @@ else() --plat-name=${PLATFORM_TAG}) endif() -# dev target includes c headers and we need to include c bindings -if(TARGET openvino_c) - list(APPEND ov_setup_py_deps openvino_c) -endif() - add_custom_command(OUTPUT ${openvino_wheel_path} COMMAND ${setup_py_env} ${wheel_build_command} diff --git a/src/bindings/python/wheel/setup.py b/src/bindings/python/wheel/setup.py index f88d9bd3da7592..b19c64f3d5d811 100644 --- a/src/bindings/python/wheel/setup.py +++ b/src/bindings/python/wheel/setup.py @@ -122,6 +122,12 @@ "rpath": LIBS_RPATH, "binary_dir": OPENVINO_BINARY_DIR, }, + "intel_openmp_libs": { + "name": "intel_omp", + "prefix": f"{BUILD_BASE}/libs.intel_omp", + "install_dir": OV_RUNTIME_LIBS_DIR, + "binary_dir": OPENVINO_BINARY_DIR, + }, "pugixml_libs": { "name": "pugixml", "prefix": f"{BUILD_BASE}/libs.pugixml", @@ -476,6 +482,8 @@ def copy_package_data(self, src_dirs): os.makedirs(package_cmake_dir, exist_ok=True) openvino_replacements = { + # change the location of TBBConfig.cmake (runtime/3rdparty/tbb -> openvino/cmake) + r"(\{PACKAGE_PREFIX_DIR\})\/runtime\/3rdparty\/tbb": rf"\1/{WHEEL_PACKAGE_DIR}/cmake", # change the path where the libraries are installed (runtime/lib/intel64/Release -> openvino/libs) r"(\{_IMPORT_PREFIX\})\/(.*)\/(.+\.[lib|dylib|so|dll])": rf"\1/{WHEEL_LIBS_INSTALL_DIR}/\3", # change the path where the include files are installed (runtime/include -> openvino/include) diff --git a/src/cmake/ov_parallel.cmake b/src/cmake/ov_parallel.cmake index cfb69ce7b1445f..51549b82baa6f6 100644 --- a/src/cmake/ov_parallel.cmake +++ b/src/cmake/ov_parallel.cmake @@ -249,6 +249,80 @@ macro(ov_find_package_tbb) endif() endmacro() +macro(ov_find_package_openmp) + # check whether the compiler supports OpenMP at all + find_package(OpenMP) + + # check if Intel OpenMP is downloaded and override system library + if(THREADING STREQUAL "OMP") + if(INTEL_OMP) + if(WIN32) + set(iomp_lib_name libiomp5md) + else() + set(iomp_lib_name iomp5) + endif() + + set(lib_rel_path ${INTEL_OMP}/lib) + set(lib_dbg_path ${lib_rel_path}) + + find_library(INTEL_OMP_LIBRARIES_RELEASE NAMES ${iomp_lib_name} PATHS ${lib_rel_path} REQUIRED NO_DEFAULT_PATH) + list(APPEND iomp_imported_configurations RELEASE) + + # try to find debug libraries as well + if(WIN32) + set(iomp_link_flags + # avoid linking default OpenMP + # https://learn.microsoft.com/en-us/cpp/parallel/openmp/reference/openmp-library-reference?view=msvc-170 + INTERFACE_LINK_OPTIONS -nodefaultlib:vcomp) + + # location of .lib file + string(REPLACE ".dll" ".lib" INTEL_OMP_IMPLIB_RELEASE "${INTEL_OMP_LIBRARIES_RELEASE}") + set(iomp_implib_location_release + IMPORTED_IMPLIB_RELEASE "${INTEL_OMP_IMPLIB_RELEASE}") + + find_library(INTEL_OMP_LIBRARIES_DEBUG NAMES ${iomp_lib_name} PATHS ${lib_dbg_path} NO_DEFAULT_PATH) + if(INTEL_OMP_LIBRARIES_DEBUG) + string(REPLACE ".dll" ".lib" INTEL_OMP_IMPLIB_DEBUG "${INTEL_OMP_LIBRARIES_DEBUG}") + + list(APPEND iomp_imported_configurations DEBUG) + set(iomp_imported_locations_debug + IMPORTED_LOCATION_DEBUG "${INTEL_OMP_LIBRARIES_DEBUG}" + IMPORTED_IMPLIB_DEBUG "${INTEL_OMP_IMPLIB_DEBUG}") + else() + set(iomp_map_imported_debug_configuration MAP_IMPORTED_CONFIG_DEBUG Release) + message(WARNING "OMP Debug binaries are missed.") + endif() + endif() + + # create imported target + if(NOT TARGET IntelOpenMP::OpenMP_CXX) + add_library(IntelOpenMP::OpenMP_CXX SHARED IMPORTED) + set_property(TARGET IntelOpenMP::OpenMP_CXX APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${iomp_imported_configurations}) + set_target_properties(IntelOpenMP::OpenMP_CXX PROPERTIES + # reuse standard OpenMP compiler flags + INTERFACE_COMPILE_OPTIONS ${OpenMP_CXX_FLAGS} + # location of release library (both .dll and lib.) + IMPORTED_LOCATION_RELEASE "${INTEL_OMP_LIBRARIES_RELEASE}" + ${iomp_implib_location_release} + # the same for debug libs + ${iomp_imported_locations_debug} + # linker flags to override system OpenMP + ${iomp_link_flags} + # map imported configurations if required + ${iomp_map_imported_debug_configuration} + MAP_IMPORTED_CONFIG_MINSIZEREL Release + MAP_IMPORTED_CONFIG_RELWITHDEBINFO Release) + endif() + endif() + + # falling back to system OpenMP then + if(NOT TARGET IntelOpenMP::OpenMP_CXX) + _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} OpenMP::OpenMP_CXX) + endif() + endif() +endmacro() + function(ov_set_threading_interface_for TARGET_NAME) if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO" AND NOT TBB_FOUND) # find TBB @@ -316,95 +390,33 @@ function(ov_set_threading_interface_for TARGET_NAME) set(OV_THREAD_DEFINE "OV_THREAD_SEQ") - if (THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") - if (TBB_FOUND) + if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") + if(TBB_FOUND) set(OV_THREAD_DEFINE "OV_THREAD_TBB") _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} TBB::tbb) target_compile_definitions(${TARGET_NAME} ${COMPILE_DEF_TYPE} TBB_PREVIEW_WAITING_FOR_WORKERS=1) - else () + else() set(THREADING "SEQ" PARENT_SCOPE) message(WARNING "TBB was not found by the configured TBB_DIR path.\ SEQ method will be used for ${TARGET_NAME}") - endif () - elseif (THREADING STREQUAL "OMP") - if (WIN32) - set(omp_lib_name libiomp5md) - elseif (ARM OR AARCH64) - get_filename_component(OpenMP_CXX_LIB_NAME ${OMP_LIB} NAME) - string(REGEX REPLACE "^lib" "" OpenMP_CXX_LIB_NAME ${OpenMP_CXX_LIB_NAME}) - string(REGEX REPLACE "\\.[^.]*$" "" OpenMP_CXX_LIB_NAME ${OpenMP_CXX_LIB_NAME}) - set(omp_lib_name ${OpenMP_CXX_LIB_NAME}) - else () - set(omp_lib_name iomp5) - endif () - - if (NOT OpenVINO_SOURCE_DIR) - # TODO: dead code since ov_parallel.cmake is not used outside of OpenVINO build - if (WIN32) - set(lib_rel_path ${IE_LIB_REL_DIR}) - set(lib_dbg_path ${IE_LIB_DBG_DIR}) - else () - set(lib_rel_path ${IE_EXTERNAL_DIR}/omp/lib) - set(lib_dbg_path ${lib_rel_path}) - endif () - else () - if (ARM OR AARCH64) - set(lib_rel_path ${OMP}) - else() - set(lib_rel_path ${OMP}/lib) - endif () - set(lib_dbg_path ${lib_rel_path}) - endif () - - if (NOT OMP_LIBRARIES_RELEASE) - find_library(OMP_LIBRARIES_RELEASE ${omp_lib_name} ${lib_rel_path} NO_DEFAULT_PATH) - message(STATUS "OMP Release lib: ${OMP_LIBRARIES_RELEASE}") - if (NOT LINUX) - find_library(OMP_LIBRARIES_DEBUG ${omp_lib_name} ${lib_dbg_path} NO_DEFAULT_PATH) - if (OMP_LIBRARIES_DEBUG) - message(STATUS "OMP Debug lib: ${OMP_LIBRARIES_DEBUG}") - else () - message(WARNING "OMP Debug binaries are missed.") - endif () - endif () - endif () + endif() + elseif(THREADING STREQUAL "OMP") + ov_find_package_openmp() - if (NOT OMP_LIBRARIES_RELEASE) - message(WARNING "Intel OpenMP not found. Intel OpenMP support will be disabled. ${OV_THREAD_DEFINE} is defined") - set(THREADING "SEQ" PARENT_SCOPE) - else () + if(TARGET IntelOpenMP::OpenMP_CXX) set(OV_THREAD_DEFINE "OV_THREAD_OMP") - - if (WIN32) - target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} /openmp) - target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} /Qopenmp) - _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "-nodefaultlib:vcomp") - else() - target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} -fopenmp) - endif () - - # Debug binaries are optional. - if (OMP_LIBRARIES_DEBUG AND NOT LINUX) - if (WIN32) - _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "$<$:${OMP_LIBRARIES_DEBUG}>;$<$>:${OMP_LIBRARIES_RELEASE}>") - else() - # TODO: handle multi-config generators case - if (CMAKE_BUILD_TYPE STREQUAL "Debug") - _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_DEBUG}) - else() - _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE}) - endif () - endif () - else () - # Link Release library to all configurations. - _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE}) - endif () - endif () - endif () + _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} IntelOpenMP::OpenMP_CXX) + elseif(TARGET OpenMP::OpenMP_CXX) + set(OV_THREAD_DEFINE "OV_THREAD_OMP") + _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} OpenMP::OpenMP_CXX) + else() + message(FATAL_ERROR "Internal error: OpenMP is not supported by compiler. Switch to SEQ should be performed before") + endif() + endif() target_compile_definitions(${TARGET_NAME} ${COMPILE_DEF_TYPE} -DOV_THREAD=${OV_THREAD_DEFINE}) - if (NOT THREADING STREQUAL "SEQ") + if(NOT THREADING STREQUAL "SEQ") find_package(Threads REQUIRED) _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} Threads::Threads) endif() diff --git a/src/common/util/src/file_util.cpp b/src/common/util/src/file_util.cpp index 2846355e9aeb5f..c9bf331bbfe6d3 100644 --- a/src/common/util/src/file_util.cpp +++ b/src/common/util/src/file_util.cpp @@ -340,7 +340,7 @@ void ov::util::convert_path_win_style(std::string& path) { #ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT -# ifdef __APPLE__ +# ifdef __clang__ # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wdeprecated-declarations" # endif @@ -372,7 +372,7 @@ std::wstring ov::util::string_to_wstring(const std::string& string) { # endif } -# ifdef __APPLE__ +# ifdef __clang__ # pragma clang diagnostic pop # endif From c8839fa5339faa2b7cb1cfac1863717574c85d6b Mon Sep 17 00:00:00 2001 From: Maxim Vafin Date: Thu, 22 Aug 2024 22:50:15 +0200 Subject: [PATCH 090/117] [PT FE] Remove opset usage (#26181) ### Details: - *Remove usage of opset* ### Tickets: - *ticket-id* --- .../frontend/pytorch/node_context.hpp | 12 +- src/frontends/pytorch/src/node_context.cpp | 6 +- src/frontends/pytorch/src/op/log_softmax.cpp | 8 +- .../src/op/native_multi_head_attention.cpp | 181 ++++++------- .../transforms/prim_list_unpack_replacer.cpp | 237 +++++++++--------- src/frontends/pytorch/src/utils.cpp | 130 +++++----- 6 files changed, 303 insertions(+), 271 deletions(-) diff --git a/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp b/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp index 110beedb8b2020..d97c2ef694a1eb 100644 --- a/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp +++ b/src/frontends/pytorch/include/openvino/frontend/pytorch/node_context.hpp @@ -53,13 +53,21 @@ class NodeContext : public frontend::NodeContext { // TODO: int due to base class uses it, but naturally it should be size_t for PT Output get_input(int index) const override { size_t index_ = static_cast(index); - FRONT_END_GENERAL_CHECK(!m_decoder->input_is_none(index_), "Input doesn't exist with index: ", index); + FRONT_END_GENERAL_CHECK(!m_decoder->input_is_none(index_), + "Input doesn't exist with index: ", + index, + " for operation ", + get_op_type()); auto input = m_decoder_inputs.at(index); if (input == 0) { // Case when input can be inlined (possible only for fx decoder) if (m_decoder->is_input_inlined(index_)) { auto inlined_input = m_decoder->inlined_input(index_); - FRONT_END_GENERAL_CHECK(inlined_input.size() == 1, "Incorrect inlined input with index:", index); + FRONT_END_GENERAL_CHECK(inlined_input.size() == 1, + "Incorrect inlined input with index: ", + index, + " for operation ", + get_op_type()); return inlined_input[0]; } } diff --git a/src/frontends/pytorch/src/node_context.cpp b/src/frontends/pytorch/src/node_context.cpp index efc3bb107eb7f0..565b0cdbd39385 100644 --- a/src/frontends/pytorch/src/node_context.cpp +++ b/src/frontends/pytorch/src/node_context.cpp @@ -152,7 +152,11 @@ OutputVector NodeContext::inputs() const { // Case when input can be inlined (possible only for fx decoder) if (m_decoder->is_input_inlined(i)) { auto inlined_input = m_decoder->inlined_input(i); - FRONT_END_GENERAL_CHECK(inlined_input.size() == 1, "Incorrect inlined input with index:", i); + FRONT_END_GENERAL_CHECK(inlined_input.size() == 1, + "Incorrect inlined input with index: ", + i, + " for operation ", + get_op_type()); res.push_back(inlined_input[0]); continue; } diff --git a/src/frontends/pytorch/src/op/log_softmax.cpp b/src/frontends/pytorch/src/op/log_softmax.cpp index 6fb2e1c6be3241..500df2bf36bc20 100644 --- a/src/frontends/pytorch/src/op/log_softmax.cpp +++ b/src/frontends/pytorch/src/op/log_softmax.cpp @@ -2,8 +2,10 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/log_softmax.hpp" + #include "openvino/frontend/pytorch/node_context.hpp" -#include "openvino/opsets/opset10.hpp" +#include "openvino/op/convert.hpp" #include "utils.hpp" namespace ov { @@ -30,11 +32,11 @@ OutputVector translate_log_softmax_common(const NodeContext& context, bool is_fx const auto target_dtype_i64 = context.const_input(2); const auto target_dtype = convert_dtype(target_dtype_i64); if (elem_type != target_dtype) { - input = context.mark_node(std::make_shared(input, target_dtype)); + input = context.mark_node(std::make_shared(input, target_dtype)); } } - const auto log_softmax = context.mark_node(std::make_shared(input, dim)); + const auto log_softmax = context.mark_node(std::make_shared(input, dim)); return {log_softmax}; }; diff --git a/src/frontends/pytorch/src/op/native_multi_head_attention.cpp b/src/frontends/pytorch/src/op/native_multi_head_attention.cpp index 3da7a0e5402669..cb8e33750d9a22 100644 --- a/src/frontends/pytorch/src/op/native_multi_head_attention.cpp +++ b/src/frontends/pytorch/src/op/native_multi_head_attention.cpp @@ -3,7 +3,23 @@ // #include "openvino/frontend/pytorch/node_context.hpp" -#include "openvino/opsets/opset10.hpp" +#include "openvino/op/add.hpp" +#include "openvino/op/broadcast.hpp" +#include "openvino/op/concat.hpp" +#include "openvino/op/divide.hpp" +#include "openvino/op/gather.hpp" +#include "openvino/op/logical_not.hpp" +#include "openvino/op/matmul.hpp" +#include "openvino/op/multiply.hpp" +#include "openvino/op/reduce_sum.hpp" +#include "openvino/op/reshape.hpp" +#include "openvino/op/select.hpp" +#include "openvino/op/shape_of.hpp" +#include "openvino/op/slice.hpp" +#include "openvino/op/softmax.hpp" +#include "openvino/op/sqrt.hpp" +#include "openvino/op/transpose.hpp" +#include "openvino/op/unsqueeze.hpp" #include "pt_framework_node.hpp" #include "utils.hpp" @@ -46,77 +62,69 @@ OutputVector translate_native_multi_head_attention(const NodeContext& context) { const auto average_weights = context.const_input(11); const auto minus_inf = - context.mark_node(opset10::Constant::create(element::f32, Shape{}, {-std::numeric_limits::infinity()})); - const auto embed_dim_i64 = context.mark_node(std::make_shared(embed_dim, element::i64)); - const auto num_head_i64 = context.mark_node(std::make_shared(num_head, element::i64)); - - const auto neg_one_1d = context.mark_node(opset10::Constant::create(element::i64, Shape{1}, {-1})); - const auto zero_1d = context.mark_node(opset10::Constant::create(element::i64, Shape{1}, {0})); - const auto one_1d = context.mark_node(opset10::Constant::create(element::i64, Shape{1}, {1})); - const auto two_1d = context.mark_node(opset10::Constant::create(element::i64, Shape{1}, {2})); - const auto three_1d = context.mark_node(opset10::Constant::create(element::i64, Shape{1}, {3})); - const auto heads_1d = context.mark_node(std::make_shared(num_head_i64, zero_1d)); - - const auto ev_1_slice_1d = context.mark_node(std::make_shared(one_1d, embed_dim_i64)); - const auto ev_2_slice_1d = context.mark_node(std::make_shared(two_1d, embed_dim_i64)); - const auto ev_3_slice_1d = context.mark_node(std::make_shared(three_1d, embed_dim_i64)); - - const auto qkv_shape = context.mark_node(std::make_shared(query)); - const auto batch_size = context.mark_node(std::make_shared(qkv_shape, zero_1d, zero_1d)); - const auto seq_size = context.mark_node(std::make_shared(qkv_shape, one_1d, zero_1d)); - const auto embed_div_heads = context.mark_node(std::make_shared(embed_dim_i64, heads_1d, true)); + context.mark_node(v0::Constant::create(element::f32, Shape{}, {-std::numeric_limits::infinity()})); + const auto embed_dim_i64 = context.mark_node(std::make_shared(embed_dim, element::i64)); + const auto num_head_i64 = context.mark_node(std::make_shared(num_head, element::i64)); + + const auto neg_one_1d = context.mark_node(v0::Constant::create(element::i64, Shape{1}, {-1})); + const auto zero_1d = context.mark_node(v0::Constant::create(element::i64, Shape{1}, {0})); + const auto one_1d = context.mark_node(v0::Constant::create(element::i64, Shape{1}, {1})); + const auto two_1d = context.mark_node(v0::Constant::create(element::i64, Shape{1}, {2})); + const auto three_1d = context.mark_node(v0::Constant::create(element::i64, Shape{1}, {3})); + const auto heads_1d = context.mark_node(std::make_shared(num_head_i64, zero_1d)); + + const auto ev_1_slice_1d = context.mark_node(std::make_shared(one_1d, embed_dim_i64)); + const auto ev_2_slice_1d = context.mark_node(std::make_shared(two_1d, embed_dim_i64)); + const auto ev_3_slice_1d = context.mark_node(std::make_shared(three_1d, embed_dim_i64)); + + const auto qkv_shape = context.mark_node(std::make_shared(query)); + const auto batch_size = context.mark_node(std::make_shared(qkv_shape, zero_1d, zero_1d)); + const auto seq_size = context.mark_node(std::make_shared(qkv_shape, one_1d, zero_1d)); + const auto embed_div_heads = context.mark_node(std::make_shared(embed_dim_i64, heads_1d, true)); const auto query_proj_weight = - context.mark_node(std::make_shared(qkv_weight, zero_1d, ev_1_slice_1d, one_1d, zero_1d)); + context.mark_node(std::make_shared(qkv_weight, zero_1d, ev_1_slice_1d, one_1d, zero_1d)); const auto key_proj_weight = - context.mark_node(std::make_shared(qkv_weight, ev_1_slice_1d, ev_2_slice_1d, one_1d, zero_1d)); + context.mark_node(std::make_shared(qkv_weight, ev_1_slice_1d, ev_2_slice_1d, one_1d, zero_1d)); const auto value_proj_weight = - context.mark_node(std::make_shared(qkv_weight, ev_2_slice_1d, ev_3_slice_1d, one_1d, zero_1d)); + context.mark_node(std::make_shared(qkv_weight, ev_2_slice_1d, ev_3_slice_1d, one_1d, zero_1d)); const auto query_proj_bias = - context.mark_node(std::make_shared(qkv_bias, zero_1d, ev_1_slice_1d, one_1d, zero_1d)); + context.mark_node(std::make_shared(qkv_bias, zero_1d, ev_1_slice_1d, one_1d, zero_1d)); const auto key_proj_bias = - context.mark_node(std::make_shared(qkv_bias, ev_1_slice_1d, ev_2_slice_1d, one_1d, zero_1d)); + context.mark_node(std::make_shared(qkv_bias, ev_1_slice_1d, ev_2_slice_1d, one_1d, zero_1d)); const auto value_proj_bias = - context.mark_node(std::make_shared(qkv_bias, ev_2_slice_1d, ev_3_slice_1d, one_1d, zero_1d)); - - const auto query_weighted = - context.mark_node(std::make_shared(query, query_proj_weight, false, true)); - const auto key_weighted = context.mark_node(std::make_shared(key, key_proj_weight, false, true)); - const auto value_weighted = - context.mark_node(std::make_shared(value, value_proj_weight, false, true)); - - const auto query_biased = context.mark_node(std::make_shared(query_weighted, query_proj_bias)); - const auto key_biased = context.mark_node(std::make_shared(key_weighted, key_proj_bias)); - const auto value_biased = context.mark_node(std::make_shared(value_weighted, value_proj_bias)); - - const auto qkv_reshape_dims = context.mark_node( - std::make_shared(OutputVector{batch_size, seq_size, heads_1d, neg_one_1d}, 0)); - const auto qv_transpose_dims = context.mark_node(opset10::Constant::create(element::i64, Shape{4}, {0, 2, 1, 3})); - const auto k_transpose_dims = context.mark_node(opset10::Constant::create(element::i64, Shape{4}, {0, 2, 3, 1})); - - const auto query_reshaped = - context.mark_node(std::make_shared(query_biased, qkv_reshape_dims, false)); - const auto key_reshaped = - context.mark_node(std::make_shared(key_biased, qkv_reshape_dims, false)); - const auto value_reshaped = - context.mark_node(std::make_shared(value_biased, qkv_reshape_dims, false)); - - const auto query_transposed = - context.mark_node(std::make_shared(query_reshaped, qv_transpose_dims)); - const auto key_transposed = context.mark_node(std::make_shared(key_reshaped, k_transpose_dims)); - const auto value_transposed = - context.mark_node(std::make_shared(value_reshaped, qv_transpose_dims)); - - const auto scale_one = context.mark_node(std::make_shared(one_1d, query_transposed)); - const auto scale_dim = context.mark_node(std::make_shared(embed_div_heads, query_transposed)); - const auto scale_dim_sqrt = context.mark_node(std::make_shared(scale_dim)); - const auto scale = context.mark_node(std::make_shared(scale_one, scale_dim_sqrt)); + context.mark_node(std::make_shared(qkv_bias, ev_2_slice_1d, ev_3_slice_1d, one_1d, zero_1d)); + + const auto query_weighted = context.mark_node(std::make_shared(query, query_proj_weight, false, true)); + const auto key_weighted = context.mark_node(std::make_shared(key, key_proj_weight, false, true)); + const auto value_weighted = context.mark_node(std::make_shared(value, value_proj_weight, false, true)); + + const auto query_biased = context.mark_node(std::make_shared(query_weighted, query_proj_bias)); + const auto key_biased = context.mark_node(std::make_shared(key_weighted, key_proj_bias)); + const auto value_biased = context.mark_node(std::make_shared(value_weighted, value_proj_bias)); + + const auto qkv_reshape_dims = + context.mark_node(std::make_shared(OutputVector{batch_size, seq_size, heads_1d, neg_one_1d}, 0)); + const auto qv_transpose_dims = context.mark_node(v0::Constant::create(element::i64, Shape{4}, {0, 2, 1, 3})); + const auto k_transpose_dims = context.mark_node(v0::Constant::create(element::i64, Shape{4}, {0, 2, 3, 1})); + + const auto query_reshaped = context.mark_node(std::make_shared(query_biased, qkv_reshape_dims, false)); + const auto key_reshaped = context.mark_node(std::make_shared(key_biased, qkv_reshape_dims, false)); + const auto value_reshaped = context.mark_node(std::make_shared(value_biased, qkv_reshape_dims, false)); + + const auto query_transposed = context.mark_node(std::make_shared(query_reshaped, qv_transpose_dims)); + const auto key_transposed = context.mark_node(std::make_shared(key_reshaped, k_transpose_dims)); + const auto value_transposed = context.mark_node(std::make_shared(value_reshaped, qv_transpose_dims)); + + const auto scale_one = context.mark_node(std::make_shared(one_1d, query_transposed)); + const auto scale_dim = context.mark_node(std::make_shared(embed_div_heads, query_transposed)); + const auto scale_dim_sqrt = context.mark_node(std::make_shared(scale_dim)); + const auto scale = context.mark_node(std::make_shared(scale_one, scale_dim_sqrt)); const auto query_key_transpose_dot_product = - context.mark_node(std::make_shared(query_transposed, key_transposed)); + context.mark_node(std::make_shared(query_transposed, key_transposed)); - auto scaled_dot_product = - context.mark_node(std::make_shared(query_key_transpose_dot_product, scale)); + auto scaled_dot_product = context.mark_node(std::make_shared(query_key_transpose_dot_product, scale)); // Mask handling if (!context.input_is_none(9) && !context.input_is_none(12)) { @@ -125,61 +133,58 @@ OutputVector translate_native_multi_head_attention(const NodeContext& context) { // non-boolean to boolean masks if (atten_mask.get_element_type() == element::boolean) { const auto minus_inf_conv = - context.mark_node(std::make_shared(minus_inf, scaled_dot_product)); - const auto mask_inverse = context.mark_node(std::make_shared(atten_mask)); - atten_mask = context.mark_node(std::make_shared(atten_mask, scaled_dot_product)); - atten_mask = context.mark_node(std::make_shared(mask_inverse, atten_mask, minus_inf_conv)); + context.mark_node(std::make_shared(minus_inf, scaled_dot_product)); + const auto mask_inverse = context.mark_node(std::make_shared(atten_mask)); + atten_mask = context.mark_node(std::make_shared(atten_mask, scaled_dot_product)); + atten_mask = context.mark_node(std::make_shared(mask_inverse, atten_mask, minus_inf_conv)); } else { // Once int/float mask type is supported in PyTorch, // remove this assert to allow for such masks in OV PYTORCH_OP_CONVERSION_CHECK(1, "Non-boolean masks are not supported."); - atten_mask = context.mark_node(std::make_shared(atten_mask, scaled_dot_product)); + atten_mask = context.mark_node(std::make_shared(atten_mask, scaled_dot_product)); } // If mask type is 1 (only key-padding) then mask's shape is (N, S). // It must be reshaped to (N, 1, 1, S) to properly broadcast it proper dims in the next step if (context.const_input(12) == 1) { - const auto target_mask_reshape = context.mark_node( - std::make_shared(OutputVector{batch_size, one_1d, one_1d, seq_size}, 0)); - atten_mask = context.mark_node(std::make_shared(atten_mask, target_mask_reshape, false)); + const auto target_mask_reshape = + context.mark_node(std::make_shared(OutputVector{batch_size, one_1d, one_1d, seq_size}, 0)); + atten_mask = context.mark_node(std::make_shared(atten_mask, target_mask_reshape, false)); } // All mask types should be broadcast to this shape, // Except for type 2 which already has this shape if (context.const_input(12) != 2) { const auto target_mask_shape = context.mark_node( - std::make_shared(OutputVector{batch_size, heads_1d, seq_size, seq_size}, 0)); - atten_mask = context.mark_node(std::make_shared(atten_mask, target_mask_shape)); + std::make_shared(OutputVector{batch_size, heads_1d, seq_size, seq_size}, 0)); + atten_mask = context.mark_node(std::make_shared(atten_mask, target_mask_shape)); } - scaled_dot_product = context.mark_node(std::make_shared(scaled_dot_product, atten_mask)); + scaled_dot_product = context.mark_node(std::make_shared(scaled_dot_product, atten_mask)); } - const auto scaled_dot_product_softmax = - context.mark_node(std::make_shared(scaled_dot_product, -1)); + const auto scaled_dot_product_softmax = context.mark_node(std::make_shared(scaled_dot_product, -1)); const auto scaled_dot_product_attention = - context.mark_node(std::make_shared(scaled_dot_product_softmax, value_transposed)); + context.mark_node(std::make_shared(scaled_dot_product_softmax, value_transposed)); const auto sdp_reshape_dims = - context.mark_node(std::make_shared(OutputVector{batch_size, seq_size, neg_one_1d}, 0)); + context.mark_node(std::make_shared(OutputVector{batch_size, seq_size, neg_one_1d}, 0)); // Undo transpose (transpose back to original qv shape) const auto scaled_dot_product_attention_transposed = - context.mark_node(std::make_shared(scaled_dot_product_attention, qv_transpose_dims)); + context.mark_node(std::make_shared(scaled_dot_product_attention, qv_transpose_dims)); const auto scaled_dot_product_attention_reshaped = context.mark_node( - std::make_shared(scaled_dot_product_attention_transposed, sdp_reshape_dims, false)); + std::make_shared(scaled_dot_product_attention_transposed, sdp_reshape_dims, false)); const auto scaled_dot_product_attention_weighted = context.mark_node( - std::make_shared(scaled_dot_product_attention_reshaped, proj_weight, false, true)); + std::make_shared(scaled_dot_product_attention_reshaped, proj_weight, false, true)); const auto scaled_dot_product_attention_biased = - context.mark_node(std::make_shared(scaled_dot_product_attention_weighted, proj_bias)); + context.mark_node(std::make_shared(scaled_dot_product_attention_weighted, proj_bias)); if (average_weights) { - const auto target_div_shape = context.mark_node(std::make_shared(scaled_dot_product)); - const auto heads_div = context.mark_node(std::make_shared(heads_1d, target_div_shape)); - const auto heads_div_conv = - context.mark_node(std::make_shared(heads_div, scaled_dot_product)); - scaled_dot_product = - context.mark_node(std::make_shared(scaled_dot_product, heads_div_conv, false)); - scaled_dot_product = context.mark_node(std::make_shared(scaled_dot_product, one_1d)); + const auto target_div_shape = context.mark_node(std::make_shared(scaled_dot_product)); + const auto heads_div = context.mark_node(std::make_shared(heads_1d, target_div_shape)); + const auto heads_div_conv = context.mark_node(std::make_shared(heads_div, scaled_dot_product)); + scaled_dot_product = context.mark_node(std::make_shared(scaled_dot_product, heads_div_conv, false)); + scaled_dot_product = context.mark_node(std::make_shared(scaled_dot_product, one_1d)); } if (need_weights) { diff --git a/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp b/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp index 27d1245d475c56..5560c9ff225e9d 100644 --- a/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp +++ b/src/frontends/pytorch/src/transforms/prim_list_unpack_replacer.cpp @@ -8,8 +8,25 @@ #include #include "openvino/core/rt_info.hpp" +#include "openvino/op/add.hpp" +#include "openvino/op/broadcast.hpp" +#include "openvino/op/concat.hpp" +#include "openvino/op/divide.hpp" +#include "openvino/op/gather.hpp" +#include "openvino/op/greater.hpp" +#include "openvino/op/mod.hpp" +#include "openvino/op/non_zero.hpp" +#include "openvino/op/range.hpp" +#include "openvino/op/reshape.hpp" +#include "openvino/op/shape_of.hpp" +#include "openvino/op/slice.hpp" +#include "openvino/op/split.hpp" +#include "openvino/op/squeeze.hpp" +#include "openvino/op/subtract.hpp" +#include "openvino/op/tile.hpp" +#include "openvino/op/unsqueeze.hpp" #include "openvino/op/util/framework_node.hpp" -#include "openvino/opsets/opset10.hpp" +#include "openvino/op/variadic_split.hpp" #include "openvino/pass/pattern/matcher.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "utils.hpp" @@ -19,6 +36,8 @@ namespace frontend { namespace pytorch { namespace pass { +using namespace ov::op; + PrimListUnpackReplacer::PrimListUnpackReplacer() { auto list_unpack = ov::pass::pattern::wrap_type(); @@ -41,213 +60,195 @@ PrimListUnpackReplacer::PrimListUnpackReplacer() { // allow for last chunk to be smaller if data is not equally divisible. auto split_size = torch_split->get_input_source_output(1); // Using number of ListUnpack outputs. - auto num_out_m_1 = opset10::Constant::create(split_size.get_element_type(), - Shape{1}, - {list_unpack->get_output_size() - 1}); - auto const_neg_1 = opset10::Constant::create(split_size.get_element_type(), Shape{1}, {-1}); - auto split_lenghts_m_1 = rg.make(split_size, num_out_m_1); + auto num_out_m_1 = + v0::Constant::create(split_size.get_element_type(), Shape{1}, {list_unpack->get_output_size() - 1}); + auto const_neg_1 = v0::Constant::create(split_size.get_element_type(), Shape{1}, {-1}); + auto split_lenghts_m_1 = rg.make(split_size, num_out_m_1); NodeVector concat_inputs{split_lenghts_m_1, const_neg_1}; - auto split_lenghts = rg.make(concat_inputs, 0); - split = rg.make(torch_split->get_input_source_output(0), - torch_split->get_input_source_output(2), - split_lenghts); + auto split_lenghts = rg.make(concat_inputs, 0); + split = rg.make(torch_split->get_input_source_output(0), + torch_split->get_input_source_output(2), + split_lenghts); } else { - split = rg.make(torch_split->get_input_source_output(0), - torch_split->get_input_source_output(2), - torch_split->get_input_source_output(1)); + split = rg.make(torch_split->get_input_source_output(0), + torch_split->get_input_source_output(2), + torch_split->get_input_source_output(1)); } copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, split); return true; - } - - if (auto split_with_sizes = cast_fw_node(input_node, "aten::split_with_sizes")) { + } else if (auto split_with_sizes = cast_fw_node(input_node, "aten::split_with_sizes")) { auto split_lengths = concat_list_construct(split_with_sizes->get_input_source_output(1)); - auto split = rg.make(split_with_sizes->get_input_source_output(0), - split_with_sizes->get_input_source_output(2), - split_lengths); + auto split = rg.make(split_with_sizes->get_input_source_output(0), + split_with_sizes->get_input_source_output(2), + split_lengths); copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, split); return true; - } - - if (auto chunk = cast_fw_node(input_node, "aten::chunk")) { + } else if (auto chunk = cast_fw_node(input_node, "aten::chunk")) { if (list_unpack->get_output_size() == 1) { list_unpack->output(0).replace(input_node->input_value(0)); return true; } auto input_tensor = chunk->get_input_source_output(0); auto chunks = chunk->get_input_source_output(1); - chunks = rg.make(chunks, element::i32); + chunks = rg.make(chunks, element::i32); auto dim = chunk->get_input_source_output(2); - auto tensor_0 = opset10::Constant::create(element::i32, Shape{1}, {0}); - auto tensor_neg_1 = opset10::Constant::create(element::i32, Shape{1}, {-1}); + auto tensor_0 = v0::Constant::create(element::i32, Shape{1}, {0}); + auto tensor_neg_1 = v0::Constant::create(element::i32, Shape{1}, {-1}); - auto input_shape = rg.make(input_tensor, element::i32); - auto input_dimension = rg.make(input_shape, dim, tensor_0); + auto input_shape = rg.make(input_tensor, element::i32); + auto input_dimension = rg.make(input_shape, dim, tensor_0); - auto init_chunk_size = rg.make(input_dimension, chunks, true); + auto init_chunk_size = rg.make(input_dimension, chunks, true); // Add 1 if input is not evenly divisible by chunks - auto last_chunk_size = rg.make(input_dimension, chunks); - auto is_last_nonzero = rg.make(last_chunk_size, tensor_0); - auto is_last_nonzero_int = rg.make(is_last_nonzero, element::i32); + auto last_chunk_size = rg.make(input_dimension, chunks); + auto is_last_nonzero = rg.make(last_chunk_size, tensor_0); + auto is_last_nonzero_int = rg.make(is_last_nonzero, element::i32); - auto chunk_size = rg.make(init_chunk_size, is_last_nonzero_int); + auto chunk_size = rg.make(init_chunk_size, is_last_nonzero_int); auto split_lengths_even_size = - opset10::Constant::create(element::i32, Shape{1}, {list_unpack->get_output_size() - 1}); - auto split_lengths_even = rg.make(chunk_size, split_lengths_even_size); + v0::Constant::create(element::i32, Shape{1}, {list_unpack->get_output_size() - 1}); + auto split_lengths_even = rg.make(chunk_size, split_lengths_even_size); - auto split_lengths = rg.make(OutputVector{split_lengths_even, tensor_neg_1}, 0); - auto sliced_chunks = rg.make(input_tensor, dim, split_lengths); + auto split_lengths = rg.make(OutputVector{split_lengths_even, tensor_neg_1}, 0); + auto sliced_chunks = rg.make(input_tensor, dim, split_lengths); copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, sliced_chunks); return true; - } - - if (auto tensor_split = cast_fw_node(input_node, "aten::tensor_split")) { + } else if (auto tensor_split = cast_fw_node(input_node, "aten::tensor_split")) { auto rank = tensor_split->input(1).get_partial_shape().rank(); if (rank.is_dynamic()) { add_exception_to_fw_node(tensor_split, "aten::tensor_split: dynamic rank is not supported."); return false; } - auto const_0 = opset10::Constant::create(element::i32, Shape{1}, {0}); - auto const_1 = opset10::Constant::create(element::i32, Shape{1}, {1}); - auto const_0_scalar = opset10::Constant::create(element::i32, Shape{}, {0}); - auto const_1_scalar = opset10::Constant::create(element::i32, Shape{}, {1}); - auto const_max = opset10::Constant::create(element::i32, Shape{1}, {std::numeric_limits::max()}); - auto const_neg_1 = opset10::Constant::create(element::i32, Shape{1}, {-1}); + auto const_0 = v0::Constant::create(element::i32, Shape{1}, {0}); + auto const_1 = v0::Constant::create(element::i32, Shape{1}, {1}); + auto const_0_scalar = v0::Constant::create(element::i32, Shape{}, {0}); + auto const_1_scalar = v0::Constant::create(element::i32, Shape{}, {1}); + auto const_max = v0::Constant::create(element::i32, Shape{1}, {std::numeric_limits::max()}); + auto const_neg_1 = v0::Constant::create(element::i32, Shape{1}, {-1}); auto input = tensor_split->get_input_source_output(0); auto indices_or_sections = tensor_split->get_input_source_output(1); - indices_or_sections = std::make_shared(indices_or_sections, element::i32); - auto dim = rg.make(tensor_split->get_input_source_output(2), const_0); - auto list_num_outs = opset10::Constant::create(element::i32, Shape{1}, {list_unpack->get_output_size()}); - auto list_num_outs_scalar = - opset10::Constant::create(element::i32, Shape{}, {list_unpack->get_output_size()}); + indices_or_sections = std::make_shared(indices_or_sections, element::i32); + auto dim = rg.make(tensor_split->get_input_source_output(2), const_0); + auto list_num_outs = v0::Constant::create(element::i32, Shape{1}, {list_unpack->get_output_size()}); + auto list_num_outs_scalar = v0::Constant::create(element::i32, Shape{}, {list_unpack->get_output_size()}); if (rank.get_length() == 0) { - auto input_shape = rg.make(input, element::i32); - auto axis_size = rg.make(input_shape, dim, const_0); - auto minimum_split_size = rg.make(axis_size, indices_or_sections); - auto maximum_split_size = rg.make(minimum_split_size, const_1); - auto num_splits_with_max_size = rg.make(axis_size, indices_or_sections); - auto num_splits_with_min_size = - rg.make(indices_or_sections, num_splits_with_max_size); - auto splits_max_size = rg.make(maximum_split_size, num_splits_with_max_size); - auto splits_min_size = rg.make(minimum_split_size, num_splits_with_min_size); - - auto split_sizes = rg.make(OutputVector{splits_max_size, splits_min_size}, 0); + auto input_shape = rg.make(input, element::i32); + auto axis_size = rg.make(input_shape, dim, const_0); + auto minimum_split_size = rg.make(axis_size, indices_or_sections); + auto maximum_split_size = rg.make(minimum_split_size, const_1); + auto num_splits_with_max_size = rg.make(axis_size, indices_or_sections); + auto num_splits_with_min_size = rg.make(indices_or_sections, num_splits_with_max_size); + auto splits_max_size = rg.make(maximum_split_size, num_splits_with_max_size); + auto splits_min_size = rg.make(minimum_split_size, num_splits_with_min_size); + + auto split_sizes = rg.make(OutputVector{splits_max_size, splits_min_size}, 0); // Reshape is used to make number of outputs static. - auto split_sizes_known_length = rg.make(split_sizes, list_num_outs, false); - auto splits = rg.make(input, dim, split_sizes_known_length); + auto split_sizes_known_length = rg.make(split_sizes, list_num_outs, false); + auto splits = rg.make(input, dim, split_sizes_known_length); copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, splits->outputs()); return true; } else { - auto range = - rg.make(const_0_scalar, list_num_outs_scalar, const_1_scalar, element::i32); - auto range_plus_1 = rg.make(range, const_1); + auto range = rg.make(const_0_scalar, list_num_outs_scalar, const_1_scalar, element::i32); + auto range_plus_1 = rg.make(range, const_1); auto sections = - rg.make(OutputVector{const_0, std::move(indices_or_sections), const_max}, 0); + rg.make(OutputVector{const_0, std::move(indices_or_sections), const_max}, 0); - auto starts_tensor = rg.make(sections, const_0, const_neg_1, const_1, const_0); + auto starts_tensor = rg.make(sections, const_0, const_neg_1, const_1, const_0); auto starts = - rg.make(starts_tensor, const_0_scalar, list_unpack->get_output_size())->outputs(); - auto stops_tensor = rg.make(sections, const_1, const_max, const_1, const_0); + rg.make(starts_tensor, const_0_scalar, list_unpack->get_output_size())->outputs(); + auto stops_tensor = rg.make(sections, const_1, const_max, const_1, const_0); auto stops = - rg.make(stops_tensor, const_0_scalar, list_unpack->get_output_size())->outputs(); + rg.make(stops_tensor, const_0_scalar, list_unpack->get_output_size())->outputs(); OutputVector outputs{}; for (size_t i = 0; i < list_unpack->get_output_size(); i++) { - auto slice = rg.make(input, starts[i], stops[i], const_1, dim); + auto slice = rg.make(input, starts[i], stops[i], const_1, dim); outputs.push_back(slice); } copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, outputs); return true; } - } - - if (auto broadcast_tensors = cast_fw_node(input_node, "aten::broadcast_tensors")) { + } else if (auto broadcast_tensors = cast_fw_node(input_node, "aten::broadcast_tensors")) { auto tensors = cast_fw_node(broadcast_tensors->input_value(0).get_node_shared_ptr(), "prim::ListConstruct"); if (!tensors) { add_exception_to_fw_node(input_node, "aten::broadcast_tensors: only prim::ListConstruct supported as input."); return false; } - Output final_shape_t = opset10::Constant::create(element::i32, Shape{}, {0}); + Output final_shape_t = v0::Constant::create(element::i32, Shape{}, {0}); for (auto& input : tensors->inputs()) { - auto tensor_shape = rg.make(input.get_source_output(), element::i32); + auto tensor_shape = rg.make(input.get_source_output(), element::i32); final_shape_t = - rg.make(final_shape_t, tensor_shape, ov::op::BroadcastType::BIDIRECTIONAL); + rg.make(final_shape_t, tensor_shape, ov::op::BroadcastType::BIDIRECTIONAL); } - auto final_shape = rg.make(final_shape_t, element::i32); + auto final_shape = rg.make(final_shape_t, element::i32); OutputVector outputs; for (auto& input : tensors->inputs()) { - outputs.push_back(rg.make(input.get_source_output(), final_shape)); + outputs.push_back(rg.make(input.get_source_output(), final_shape)); } copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, outputs); return true; - } - - if (auto unbind = cast_fw_node(input_node, "aten::unbind")) { + } else if (auto unbind = cast_fw_node(input_node, "aten::unbind")) { const auto input = unbind->get_input_source_output(0); const auto axis = unbind->get_input_source_output(1); const auto num_splits = list_unpack->get_output_size(); - auto split = rg.make(input, axis, num_splits); + auto split = rg.make(input, axis, num_splits); OutputVector outputs; for (auto& output : split->outputs()) { - const auto squeeze = rg.make(output, axis); + const auto squeeze = rg.make(output, axis); outputs.push_back(squeeze); } copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, outputs); return true; - } - if (auto where = cast_fw_node(input_node, "aten::where")) { + } else if (auto where = cast_fw_node(input_node, "aten::where")) { const auto input = where->get_input_source_output(0); - auto non_zero = rg.make(input); - auto axis = opset10::Constant::create(element::i32, Shape{}, {0}); + auto non_zero = rg.make(input); + auto axis = v0::Constant::create(element::i32, Shape{}, {0}); const auto num_splits = list_unpack->get_output_size(); - auto split = rg.make(non_zero, axis, num_splits); + auto split = rg.make(non_zero, axis, num_splits); OutputVector outputs; for (auto& output : split->outputs()) { - const auto squeeze = rg.make(output, axis); + const auto squeeze = rg.make(output, axis); outputs.push_back(squeeze); } copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, outputs); return true; - } - if (auto nonzero_numpy = cast_fw_node(input_node, "aten::nonzero_numpy")) { + } else if (auto nonzero_numpy = cast_fw_node(input_node, "aten::nonzero_numpy")) { const auto input = nonzero_numpy->get_input_source_output(0); - auto non_zero = rg.make(input); - auto axis = opset10::Constant::create(element::i32, Shape{}, {0}); + auto non_zero = rg.make(input); + auto axis = v0::Constant::create(element::i32, Shape{}, {0}); const auto num_splits = list_unpack->get_output_size(); - auto split = rg.make(non_zero, axis, num_splits); + auto split = rg.make(non_zero, axis, num_splits); OutputVector outputs; for (auto& output : split->outputs()) { - const auto squeeze = rg.make(output, axis); + const auto squeeze = rg.make(output, axis); outputs.push_back(squeeze); } copy_runtime_info_and_name(list_unpack, rg.get(), {input_node}); replace_node(list_unpack, outputs); return true; - } - - if (auto meshgrid = cast_fw_node(input_node, "aten::meshgrid")) { + } else if (auto meshgrid = cast_fw_node(input_node, "aten::meshgrid")) { // Input - ListConstruct auto meshgrid_input_node = cast_fw_node(meshgrid->input_value(0).get_node_shared_ptr(), "prim::ListConstruct"); @@ -278,24 +279,24 @@ PrimListUnpackReplacer::PrimListUnpackReplacer() { } NodeVector cat_shapes{}; NodeVector reshapes{}; - auto const_neg_1 = opset10::Constant::create(element::i32, Shape{1}, {-1}); - auto const_1 = opset10::Constant::create(element::i32, Shape{1}, {1}); + auto const_neg_1 = v0::Constant::create(element::i32, Shape{1}, {-1}); + auto const_1 = v0::Constant::create(element::i32, Shape{1}, {1}); int input_idx = 0; for (auto& input : meshgrid_inputs) { - auto reshaped_input = rg.make(input, const_neg_1, false); - auto shape = rg.make(reshaped_input, element::i32); + auto reshaped_input = rg.make(input, const_neg_1, false); + auto shape = rg.make(reshaped_input, element::i32); cat_shapes.push_back(shape); NodeVector cat_inputs(meshgrid_inputs.size(), const_1); cat_inputs[input_idx] = shape; input_idx++; - auto input_cat = rg.make(cat_inputs, 0); - auto reshape_cat = rg.make(reshaped_input, input_cat, false); + auto input_cat = rg.make(cat_inputs, 0); + auto reshape_cat = rg.make(reshaped_input, input_cat, false); reshapes.push_back(reshape_cat); } - auto cat = rg.make(cat_shapes, 0); + auto cat = rg.make(cat_shapes, 0); OutputVector outputs{}; for (auto& reshape : reshapes) { - auto out = rg.make(reshape, cat, ov::op::BroadcastType::BIDIRECTIONAL); + auto out = rg.make(reshape, cat, ov::op::BroadcastType::BIDIRECTIONAL); outputs.push_back(out); } if (indexing == "xy" && outputs.size() >= 2) { @@ -304,17 +305,15 @@ PrimListUnpackReplacer::PrimListUnpackReplacer() { copy_runtime_info_and_name(list_unpack, rg.get(), {input_node, meshgrid_input_node}); replace_node(list_unpack, outputs); return true; - } - - if (auto shape_of = std::dynamic_pointer_cast(input_node)) { + } else if (auto shape_of = std::dynamic_pointer_cast(input_node)) { // case aten::size as input // Number of ListUnpack outputs should be equal to rank of input shape. - auto axis_0 = opset10::Constant::create(element::i32, Shape{}, {0}); - auto split = rg.make(shape_of, axis_0, list_unpack->get_output_size()); + auto axis_0 = v0::Constant::create(element::i32, Shape{}, {0}); + auto split = rg.make(shape_of, axis_0, list_unpack->get_output_size()); OutputVector res; for (auto& output : split->outputs()) { - auto squeeze = rg.make(output, axis_0); + auto squeeze = rg.make(output, axis_0); res.push_back(squeeze); } @@ -322,17 +321,15 @@ PrimListUnpackReplacer::PrimListUnpackReplacer() { replace_node(list_unpack, res); return true; - } - - if (auto slice = std::dynamic_pointer_cast(input_node)) { + } else if (auto slice = std::dynamic_pointer_cast(input_node)) { // case aten::slice as input // Number of ListUnpack outputs should be equal to rank of input shape. - auto axis_0 = opset10::Constant::create(element::i32, Shape{}, {0}); - auto split = rg.make(slice, axis_0, list_unpack->get_output_size()); + auto axis_0 = v0::Constant::create(element::i32, Shape{}, {0}); + auto split = rg.make(slice, axis_0, list_unpack->get_output_size()); OutputVector res; for (auto& output : split->outputs()) { - auto squeeze = rg.make(output, axis_0); + auto squeeze = rg.make(output, axis_0); res.push_back(squeeze); } diff --git a/src/frontends/pytorch/src/utils.cpp b/src/frontends/pytorch/src/utils.cpp index b096da45f25437..df35f11fee1d75 100644 --- a/src/frontends/pytorch/src/utils.cpp +++ b/src/frontends/pytorch/src/utils.cpp @@ -7,8 +7,22 @@ #include "op_table.hpp" #include "openvino/core/rt_info.hpp" #include "openvino/frontend/pytorch/decoder.hpp" +#include "openvino/op/add.hpp" +#include "openvino/op/broadcast.hpp" +#include "openvino/op/concat.hpp" #include "openvino/op/convert_promote_types.hpp" -#include "openvino/opsets/opset10.hpp" +#include "openvino/op/divide.hpp" +#include "openvino/op/gather.hpp" +#include "openvino/op/mod.hpp" +#include "openvino/op/range.hpp" +#include "openvino/op/reduce_prod.hpp" +#include "openvino/op/reshape.hpp" +#include "openvino/op/select.hpp" +#include "openvino/op/shape_of.hpp" +#include "openvino/op/slice.hpp" +#include "openvino/op/squeeze.hpp" +#include "openvino/op/subtract.hpp" +#include "openvino/op/unsqueeze.hpp" #include "openvino/util/log.hpp" #include "pt_framework_node.hpp" #include "translate_session.hpp" @@ -17,6 +31,8 @@ namespace ov { namespace frontend { namespace pytorch { +using namespace ov::op; + void num_inputs_check(const NodeContext& context, size_t min_inputs, size_t max_inputs) { auto num_inputs = context.get_input_size(); FRONT_END_OP_CONVERSION_CHECK(num_inputs >= min_inputs, "Got less inputs than expected"); @@ -38,12 +54,12 @@ Output make_optional_bias(const Output& base_op, if (!context.input_is_none(bias_input_idx)) { auto bias = context.get_input(bias_input_idx); if (!unsqueeze_dims.empty()) { - auto indices = opset10::Constant::create(element::i32, {unsqueeze_dims.size()}, unsqueeze_dims); + auto indices = v0::Constant::create(element::i32, {unsqueeze_dims.size()}, unsqueeze_dims); context.mark_node(indices); - bias = make_shared(bias, indices); + bias = make_shared(bias, indices); context.mark_output(bias); } - return make_shared(context.mark_output(base_op), bias); + return make_shared(context.mark_output(base_op), bias); } else { return base_op; } @@ -52,28 +68,28 @@ Output make_optional_bias(const Output& base_op, Output reshape_channelwise(const NodeContext& context, const Output& data, const Output& shape_source) { - auto input_shape = context.mark_node(std::make_shared(shape_source, element::i32)); - auto input_rank = context.mark_node(std::make_shared(input_shape, element::i32)); - auto one_const = context.mark_node(opset10::Constant::create(element::i32, Shape{1}, {1})); - auto two_const = context.mark_node(opset10::Constant::create(element::i32, Shape{1}, {2})); - auto tail_shape_rank = context.mark_node(std::make_shared(input_rank, two_const)); - auto tail_shape = context.mark_node(std::make_shared(one_const, tail_shape_rank)); - auto channels_dim = context.mark_node(std::make_shared(data, element::i32)); + auto input_shape = context.mark_node(std::make_shared(shape_source, element::i32)); + auto input_rank = context.mark_node(std::make_shared(input_shape, element::i32)); + auto one_const = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {1})); + auto two_const = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {2})); + auto tail_shape_rank = context.mark_node(std::make_shared(input_rank, two_const)); + auto tail_shape = context.mark_node(std::make_shared(one_const, tail_shape_rank)); + auto channels_dim = context.mark_node(std::make_shared(data, element::i32)); auto new_shape = - context.mark_node(std::make_shared(OutputVector{one_const, channels_dim, tail_shape}, 0)); + context.mark_node(std::make_shared(OutputVector{one_const, channels_dim, tail_shape}, 0)); - return context.mark_node(std::make_shared(data, new_shape, false)); + return context.mark_node(std::make_shared(data, new_shape, false)); } std::tuple, Output> get_shape_rank(const NodeContext& context, const Output& x, bool as_scalar, element::Type output_type) { - auto shape = context.mark_node(std::make_shared(x, output_type)); - Output rank = context.mark_node(std::make_shared(shape, output_type)); + auto shape = context.mark_node(std::make_shared(x, output_type)); + Output rank = context.mark_node(std::make_shared(shape, output_type)); if (as_scalar) { - auto axis_0 = context.mark_node(opset10::Constant::create(output_type, Shape{}, {0})); - rank = context.mark_node(std::make_shared(rank, axis_0)); + auto axis_0 = context.mark_node(v0::Constant::create(output_type, Shape{}, {0})); + rank = context.mark_node(std::make_shared(rank, axis_0)); } return std::make_tuple(shape, rank); } @@ -81,24 +97,24 @@ std::tuple, Output> get_shape_rank(const NodeContext& context Output reshape_kernel_for_group(const NodeContext& context, const Output& kernel, int64_t groups) { using std::make_shared; - auto axis_0 = opset10::Constant::create(element::i32, Shape{}, {0}); - auto groups_const = opset10::Constant::create(element::i32, Shape{1}, {groups}); - auto neg_1_const = opset10::Constant::create(element::i32, Shape{1}, {-1}); + auto axis_0 = v0::Constant::create(element::i32, Shape{}, {0}); + auto groups_const = v0::Constant::create(element::i32, Shape{1}, {groups}); + auto neg_1_const = v0::Constant::create(element::i32, Shape{1}, {-1}); - auto kernel_shape = std::make_shared(kernel, element::i32); - auto c_out_idx = opset10::Constant::create(element::i32, Shape{}, {0}); - auto kernel_shape_0 = make_shared(kernel_shape, c_out_idx, axis_0); - auto kernel_shape_0_uns = make_shared(kernel_shape_0, axis_0); - auto c_out_value = make_shared(kernel_shape_0_uns, groups_const); + auto kernel_shape = std::make_shared(kernel, element::i32); + auto c_out_idx = v0::Constant::create(element::i32, Shape{}, {0}); + auto kernel_shape_0 = make_shared(kernel_shape, c_out_idx, axis_0); + auto kernel_shape_0_uns = make_shared(kernel_shape_0, axis_0); + auto c_out_value = make_shared(kernel_shape_0_uns, groups_const); - auto start = opset10::Constant::create(element::i32, Shape{1}, {2}); - auto stop = opset10::Constant::create(element::i32, Shape{1}, {std::numeric_limits::max()}); - auto step = opset10::Constant::create(element::i32, Shape{1}, {1}); - auto remaining_shape = make_shared(kernel_shape, start, stop, step); + auto start = v0::Constant::create(element::i32, Shape{1}, {2}); + auto stop = v0::Constant::create(element::i32, Shape{1}, {std::numeric_limits::max()}); + auto step = v0::Constant::create(element::i32, Shape{1}, {1}); + auto remaining_shape = make_shared(kernel_shape, start, stop, step); auto new_kernel_shape = - make_shared(OutputVector{groups_const, c_out_value, neg_1_const, remaining_shape}, 0); - auto res = make_shared(kernel, new_kernel_shape, false); + make_shared(OutputVector{groups_const, c_out_value, neg_1_const, remaining_shape}, 0); + auto res = make_shared(kernel, new_kernel_shape, false); context.mark_nodes({axis_0, groups_const, kernel_shape, @@ -121,22 +137,22 @@ std::shared_ptr get_axes_range(const NodeContext& context, int input_id) { }; std::shared_ptr get_node_axes_range(const NodeContext& context, const Output& x) { - auto start = std::make_shared(element::i32, Shape{}, 0); - auto step = std::make_shared(element::i32, Shape{}, 1); + auto start = std::make_shared(element::i32, Shape{}, 0); + auto step = std::make_shared(element::i32, Shape{}, 1); Output reduced_rank; std::tie(std::ignore, reduced_rank) = get_shape_rank(context, x, true); - return context.mark_node(std::make_shared(start, reduced_rank, step, element::i32)); + return context.mark_node(std::make_shared(start, reduced_rank, step, element::i32)); }; Output normalize_axis(const NodeContext& context, const Output& axis, const Output& rank) { - auto axis_rank = context.mark_node(std::make_shared(axis, rank)); - return context.mark_node(std::make_shared(axis_rank, rank)); + auto axis_rank = context.mark_node(std::make_shared(axis, rank)); + return context.mark_node(std::make_shared(axis_rank, rank)); } std::shared_ptr numel(const NodeContext& context, const Output& x, element::Type output_type) { - auto input_shape = context.mark_node(std::make_shared(x, output_type)); - auto axes = context.mark_node(opset10::Constant::create(output_type, Shape({1}), {0})); - return context.mark_node(std::make_shared(input_shape, axes, false)); + auto input_shape = context.mark_node(std::make_shared(x, output_type)); + auto axes = context.mark_node(v0::Constant::create(output_type, Shape({1}), {0})); + return context.mark_node(std::make_shared(input_shape, axes, false)); }; namespace { @@ -166,14 +182,14 @@ element::Type convert_dtype(int64_t pt_type) { }; Output apply_dtype(const NodeContext& context, size_t dtype_port, const Output& input_tensor) { - if (std::dynamic_pointer_cast( + if (std::dynamic_pointer_cast( context.get_input_from_visible_context(dtype_port).get_node_shared_ptr())) { auto dtype = convert_dtype(context.const_input(dtype_port)); - return context.mark_node(std::make_shared(input_tensor, dtype)); + return context.mark_node(std::make_shared(input_tensor, dtype)); } else if (const auto& fw_node = cast_fw_node(context.get_input(static_cast(dtype_port)).get_node_shared_ptr(), "prim::dtype")) { auto out_tensor = fw_node->input_value(0); - return context.mark_node(std::make_shared(input_tensor, out_tensor)); + return context.mark_node(std::make_shared(input_tensor, out_tensor)); } else { FRONT_END_OP_CONVERSION_CHECK(false, "Couldn't get dtype input"); } @@ -189,13 +205,13 @@ Output concat_list_construct(const Output& input) { if (auto list_construct = cast_fw_node(input.get_node_shared_ptr(), "prim::ListConstruct")) { auto list_inputs = list_construct->input_values(); OutputVector node_vector; - auto zero = opset10::Constant::create(element::i32, Shape{}, {0}); + auto zero = v0::Constant::create(element::i32, Shape{}, {0}); for (size_t i = 0; i < list_inputs.size(); i++) { auto node = concat_list_construct(list_inputs[i]); - auto unsqueezed_node = std::make_shared(node, zero); + auto unsqueezed_node = std::make_shared(node, zero); node_vector.push_back(unsqueezed_node); } - return std::make_shared(node_vector, 0); + return std::make_shared(node_vector, 0); } return input; } @@ -409,11 +425,11 @@ void align_eltwise_input_types(const NodeContext& context, // If only one input is PyScalar, replace it with const to mitigate issues with dynamic type caused by dynamic // shape. if (is_lhs_python_scalar && !is_rhs_python_scalar) { - tmp_lhs = context.mark_node(std::make_shared(const_0, lhs)); - tmp_rhs = context.mark_node(std::make_shared(const_1, rhs)); + tmp_lhs = context.mark_node(std::make_shared(const_0, lhs)); + tmp_rhs = context.mark_node(std::make_shared(const_1, rhs)); } else if (!is_lhs_python_scalar && is_rhs_python_scalar) { - tmp_lhs = context.mark_node(std::make_shared(const_1, lhs)); - tmp_rhs = context.mark_node(std::make_shared(const_0, rhs)); + tmp_lhs = context.mark_node(std::make_shared(const_1, lhs)); + tmp_rhs = context.mark_node(std::make_shared(const_0, rhs)); } auto at = context.mark_node( @@ -422,15 +438,15 @@ void align_eltwise_input_types(const NodeContext& context, if (dst_type.is_dynamic()) { // Add ConvertLike on original node to not remove changes to shape done to differentiate between tensors and // scalars. - lhs = context.mark_node(std::make_shared(lhs, at->output(0))); - rhs = context.mark_node(std::make_shared(rhs, at->output(1))); + lhs = context.mark_node(std::make_shared(lhs, at->output(0))); + rhs = context.mark_node(std::make_shared(rhs, at->output(1))); } else { // Cast to destination type if (dst_type != lhs_type) { - lhs = context.mark_node(std::make_shared(lhs, dst_type)); + lhs = context.mark_node(std::make_shared(lhs, dst_type)); } if (dst_type != rhs_type) { - rhs = context.mark_node(std::make_shared(rhs, dst_type)); + rhs = context.mark_node(std::make_shared(rhs, dst_type)); } } return; @@ -442,7 +458,7 @@ void align_output_types(const NodeContext& context, OutputVector& outputs) { if (dtype_any.is()) { auto dtype = dtype_any.as(); if (dtype.is_static() && dtype != outputs[i].get_element_type()) { - outputs[i] = std::make_shared(outputs[i], dtype); + outputs[i] = std::make_shared(outputs[i], dtype); } } } @@ -547,9 +563,9 @@ Output masked_fill(ov::pass::NodeRegistry& rg, const Output& data, const Output& mask, const Output& value) { - auto _value = rg.make(value, data); - auto bool_mask = rg.make(mask, element::boolean); - return rg.make(bool_mask, _value, data); + auto _value = rg.make(value, data); + auto bool_mask = rg.make(mask, element::boolean); + return rg.make(bool_mask, _value, data); } Output concat_list_from_inputs(const NodeContext& context, size_t begin, size_t end) { From c85902d9b5b2f73b44c08b14e2133c201b7a91cc Mon Sep 17 00:00:00 2001 From: Egor Duplenskii Date: Thu, 22 Aug 2024 23:47:20 +0200 Subject: [PATCH 091/117] [INSTALL] Fix setupvars.sh corrupted installation directory (#26166) Both 'cd' and 'pwd -P' print the directory name Installation directory should be printed only once --- scripts/setupvars/setupvars.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/setupvars/setupvars.sh b/scripts/setupvars/setupvars.sh index 54eefc25714400..dd67bf330630c1 100755 --- a/scripts/setupvars/setupvars.sh +++ b/scripts/setupvars/setupvars.sh @@ -6,7 +6,7 @@ abs_path () { script_path=$(eval echo "$1") directory=$(dirname "$script_path") - builtin cd "$directory" || exit + builtin cd "$directory" >/dev/null 2>&1 || exit pwd -P } From eb16f7fbd0d450d51894e07ef1888c71505b4b0a Mon Sep 17 00:00:00 2001 From: Taylor Yeonbok Lee Date: Thu, 22 Aug 2024 14:47:54 -0700 Subject: [PATCH 092/117] [GPU] Optimize fc_bf_tiled kernel for large K + small N case (#26054) ### Details: - Optimize fc_bf_tiled kernel for large K + small N case by setting K_TILE_SIZE 4 - Perf gain on MTL (U7 155H + 32GB RAM + driver 31.0.101.5333) ![image](https://github.com/user-attachments/assets/2e6537fe-90d4-47e1-8d56-f816d3471559) (No regression and on par on llama3 INT4 default and phi-3 mini INT4 default) ### Tickets: - 149212 --- .../fully_connected_gpu_bf_tiled.cl | 23 ++++++-- .../include/batch_headers/fetch_weights.cl | 10 ++++ .../include/batch_headers/int4_utils.cl | 13 +++++ .../cl_kernels/reorder_weights_int4.cl | 24 ++++++++ .../fully_connected_kernel_bf_tiled.cpp | 55 ++++++++++++++++--- .../kernels/reorder/reorder_weights_int4.cpp | 5 ++ 6 files changed, 115 insertions(+), 15 deletions(-) diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl index 0366f602d69982..92be3f31f97f3f 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/fully_connected_gpu_bf_tiled.cl @@ -108,7 +108,7 @@ KERNEL(quantize_input)( #define OUTPUT_BLOCK_WRITE(ptr, offset, val) BLOCK_WRITEN(OUTPUT_TYPE, TILE_OFM, ptr, offset, val) #define SLM_FILTER_VEC MAKE_VECTOR_TYPE(ACCUMULATOR_TYPE, TILE_OFM) -#define SLM_FILTER_PACKED_VEC MAKE_VECTOR_TYPE(FILTER_TYPE, FILTER_LOAD_BLOCK_SIZE) +#define SLM_FILTER_PACKED_VEC MAKE_VECTOR_TYPE(FILTER_TYPE, FILTER_ACTUAL_LOAD_BLOCK_SIZE) #define SLM_FILTER_UNPACKED_VEC MAKE_VECTOR_TYPE(ACCUMULATOR_TYPE, FILTER_ELEMENTS_PER_LOAD) @@ -311,6 +311,9 @@ inline void FUNC(fc_bf_tiled_kernel_default)( #if TILE_OFM != 2 #error "FC bf_tiled kernel: can't use SLM optimization with TILE_OFM != 2" #endif + #if FILTER_LAYOUT_OS_IYX_OSV16 && TILE_K != 4 + #error "FC bf_tiled kernel: can't use SLM optimization with TILE_K != 2 && OS_IYX_OSV16 layout" + #endif // Skip first barrier synchronization if there is only single outer loop iteration. #if MAIN_LOOP_ELEMENTS_COUNT / (TILE_IFM * SIMD) > 1 @@ -319,12 +322,19 @@ inline void FUNC(fc_bf_tiled_kernel_default)( __local SLM_FILTER_VEC* slm_wei_vec = (__local SLM_FILTER_VEC*)wei_local_mem; - uint weights_idx = weights_offset + local_id * SIMD * FILTER_LOAD_ITERS * FILTER_LOAD_BLOCK_SIZE; + uint weights_idx = weights_offset + local_id * SIMD * FILTER_LOAD_ITERS * FILTER_ACTUAL_LOAD_BLOCK_SIZE; uint wei_local_idx = local_id * SIMD * FILTER_LOAD_ITERS * FILTER_LOAD_BLOCK_SIZE + sglid; - unroll_for(uint load_iter = 0; load_iter < FILTER_LOAD_ITERS; ++load_iter) { - SLM_FILTER_PACKED_VEC wei_packed = BLOCK_READN(FILTER_TYPE, FILTER_LOAD_BLOCK_SIZE, weights, weights_idx); + #if FILTER_LAYOUT_OS_IYX_OSV16 + SLM_FILTER_PACKED_VEC wei_packed0 = BLOCK_READN(FILTER_TYPE, FILTER_ACTUAL_LOAD_BLOCK_SIZE, weights, weights_idx); + SLM_FILTER_PACKED_VEC wei_packed1 = BLOCK_READN(FILTER_TYPE, FILTER_ACTUAL_LOAD_BLOCK_SIZE, weights, (weights_idx + ((IFM_SIZE / 2) * 16))); + SLM_FILTER_UNPACKED_VEC wei_unpacked; + wei_unpacked.s0123 = UNPACK_INT4(ACCUMULATOR_TYPE, *((INT4_PACKED_TYPE_PRELOAD*)&wei_packed0)); + wei_unpacked.s4567 = UNPACK_INT4(ACCUMULATOR_TYPE, *((INT4_PACKED_TYPE_PRELOAD*)&wei_packed1)); + #else + SLM_FILTER_PACKED_VEC wei_packed = BLOCK_READN(FILTER_TYPE, FILTER_LOAD_BLOCK_SIZE/*4*/, weights, weights_idx); SLM_FILTER_UNPACKED_VEC wei_unpacked = UNPACK_INT4(ACCUMULATOR_TYPE, *((INT4_PACKED_TYPE_PRELOAD*)&wei_packed)); + #endif ACCUMULATOR_TYPE* w = (ACCUMULATOR_TYPE*)(&wei_unpacked); unroll_for(uint fi = 0; fi < TILE_OFM; ++fi) { unroll_for(uint kii = 0; kii < FILTER_LOAD_BLOCK_SIZE; ++kii) { @@ -383,8 +393,7 @@ inline void FUNC(fc_bf_tiled_kernel_default)( #endif #undef STORE_TO_SLM - - weights_idx += SIMD * FILTER_LOAD_BLOCK_SIZE; + weights_idx += SIMD * FILTER_ACTUAL_LOAD_BLOCK_SIZE; } wei_local_idx = sglid; @@ -478,6 +487,8 @@ inline void FUNC(fc_bf_tiled_kernel_default)( } #if TILE_OFM == 1 && FILTER_LAYOUT_OS_IS_YX_OSV32_ISV2 weights_offset += TILE_K_OFM_PACKED * 2 * SIMD; + #elif FILTER_LAYOUT_OS_IYX_OSV16 && TILE_OFM == 2 && USE_SLM == 1 + weights_offset += TILE_K_OFM_PACKED / 2 * SIMD; #else weights_offset += TILE_K_OFM_PACKED * SIMD; #endif diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/fetch_weights.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/fetch_weights.cl index 531bd0838a3aa0..7135673c8c5dc8 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/fetch_weights.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/fetch_weights.cl @@ -405,6 +405,16 @@ inline uint get_os_zyxi_osv16_index(uint o, uint i, uint z, uint y, uint x, uint ((o) / (sub_group_size))*CAT(prefix, _OFM_PITCH) \ ) +#define GET_FILTER_OS_IYX_OSV_INDEX_INT4_PACKED(prefix, o, i, y, x, sub_group_size) \ + CAT(prefix, _OFFSET) + \ + ((o) % (sub_group_size)) + \ + (sub_group_size)*( \ + (x)*CAT(prefix, _X_PITCH) + \ + (y)*CAT(prefix, _Y_PITCH) + \ + (i)*CAT(prefix, _IFM_PITCH) + \ + ((o) / (sub_group_size))*(CAT(prefix, _OFM_PITCH)/2) \ + ) + #define GET_FILTER_OS_IS_YX_OSV_ISV_INDEX_INT4_PACKED(prefix, o, i, y, x, sub_group_size) \ CAT(prefix, _OFFSET) + \ ((o) % (sub_group_size)) + \ diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl index fb257169a8b78c..d919d1ce1104ab 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/include/batch_headers/int4_utils.cl @@ -143,12 +143,24 @@ inline half4 unpack_to_half(uint4x4_t v) __attribute__((overloadable)) { return (half4)(f0.s0, f0.s1, f1.s0, f1.s1); } +inline half4 unpack_to_half_osv32_isv2(uint4x4_t v) __attribute__((overloadable)) { + half2 f0 = unpack_to_half(v.s0); + half2 f1 = unpack_to_half(v.s1); + return (half4)(f0.s0, f0.s1, f1.s0, f1.s1); +} + inline half4 unpack_to_half(int4x4_t v) __attribute__((overloadable)) { half2 f0 = unpack_to_half(v.s0); half2 f1 = unpack_to_half(v.s1); return (half4)(f0.s0, f0.s1, f1.s0, f1.s1); } +inline half4 unpack_to_half_osv32_isv2(int4x4_t v) __attribute__((overloadable)) { + half2 f0 = unpack_to_half(v.s0); + half2 f1 = unpack_to_half(v.s1); + return (half4)(f0.s0, f0.s1, f1.s0, f1.s1); +} + inline half8 unpack_to_half(uint4x8_t v) __attribute__((overloadable)) { half2 f0 = unpack_to_half(v.s0); half2 f1 = unpack_to_half(v.s1); @@ -211,4 +223,5 @@ inline uchar8 unpack_to_uchar_osv32_isv2(uint4x8_t v) __attribute__((overloadabl #define UNPACK_INT4x2(target_type, value) CAT(unpack_to_, target_type)(value) #define UNPACK_INT4x2_OSV32_ISV2(target_type, value) CAT(CAT(unpack_to_, target_type), _osv32_isv2)(value) +#define UNPACK_INT4x4_OSV32_ISV2(target_type, value) CAT(CAT(unpack_to_, target_type), _osv32_isv2)(value) #define UNPACK_TRANSPOSED_INT4x2(target_type, value) CAT(unpack_transposed_to_, target_type)(value) diff --git a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/reorder_weights_int4.cl b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/reorder_weights_int4.cl index 1b3239d082ec2a..90a7e8bd8feecc 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/reorder_weights_int4.cl +++ b/src/plugins/intel_gpu/src/kernel_selector/cl_kernels/reorder_weights_int4.cl @@ -28,6 +28,30 @@ KERNEL(reorder_weights_int4)(const __global INPUT0_TYPE* input, __global OUTPUT_ OUTPUT_TYPE out = in0 | (in1 << 4); output[out_byte_offset] = out; +#elif defined(OUTPUT_LAYOUT_OS_IYX_OSV16) + // osv32_isv2 layout for int4 packed weight + // f0_k0k1 | f1_k0k1 | .... | f15_k0k1 + // f0_k2k3 | f1_k2k3 | .... | f15_k2k3 + // f0_k3k4 | f1_k3k4 | .... | f15_k3k4 + // ... + // f0_k(K/2-2)k(K/2-1) | f1_k(K/2-2)k(K/2-1) | ....f15_k(K/2-2)k(K/2-1) + // ------------------------------------- + // f16_k2k3 | f17_k2k3 | ... | f31_k2k3 + // ... + const unsigned o = (uint)get_global_id(0); + const unsigned i = (uint)get_global_id(1) * 2; + + const uint input0_offset = GET_FILTER_INDEX(INPUT0, 0, o, i, 0, 0); + + INPUT0_TYPE in1 = input[input0_offset / 2] & 0xFF; + + INPUT0_TYPE packed_out_channels = in1; + + const uint output_idx = GET_FILTER_OS_IYX_OSV_INDEX_INT4_PACKED(OUTPUT, o, i/2, 0, 0, 16); // Calculate offset as osv16 due to packing + output[output_idx] = packed_out_channels; + + + #elif defined(OUTPUT_LAYOUT_OS_IYX_OSV32) // os_iyx osv32 layout for int4 packed weight // k0_f0f16 | k0_f1f17 | .... | k0_f15f31 || k1_f0f16 | k1_f1f17 | ... | k1_f15f31 diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp index 61919c10b816ff..db42bc969b4a32 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp +++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_bf_tiled.cpp @@ -97,6 +97,19 @@ static bool should_dynamic_quantize(const fully_connected_params& params) { return false; } +static bool is_weight_with_small_ofm(const fully_connected_params& params, size_t output_f) { + size_t min_num_threads = params.engineInfo.computeUnitsCount * simd; + GPU_DEBUG_TRACE_DETAIL << "out_ofm (== weight N dim) size " << output_f << " is small compared to the available threads. " + << "(computeUnitsCount : " << params.engineInfo.computeUnitsCount + << " min_num_threads : " << min_num_threads << ")" << std::endl; + GPU_DEBUG_TRACE_DETAIL << "Use ofm_tile size 1 if the batch size is 1." << std::endl; + return (output_f / 2 /*most frequently used tile_ofm*/ <= min_num_threads); +} + +static bool is_weight_with_large_ifm(const fully_connected_params& fc_params) { + return (fc_params.weights.IFM().v >= fc_params.weights.OFM().v * 3 && fc_params.weights.OFM().v <= 4096); +} + FullyConnected_bf_tiled::FullyConnected_bf_tiled() : FullyConnectedKernelBase("fully_connected_gpu_bf_tiled") { for (unsigned tile_b = 1; tile_b <= 32; ++tile_b) for (unsigned tile_ofm = 1; tile_ofm <= 4; tile_ofm *= 2) @@ -324,14 +337,18 @@ FullyConnected_bf_tiled::GetAutoTuneParams(const fully_connected_params& params, if (params.weights.GetDType() == WeightsType::UINT4 || params.weights.GetDType() == WeightsType::INT4) { if (!params.is_shape_agnostic && batch == 1) { // Tuning for Meteor Lake - size_t min_num_threads = params.engineInfo.computeUnitsCount * simd; - if (output_f / 2 <= min_num_threads && params.weights.GetLayout() == WeightsLayout::os_is_yx_osv32_isv2) { - GPU_DEBUG_TRACE_DETAIL << "FC bf tiled: Set ofm_tile 1. (output_f : " << output_f - << ", computeUnitsCount : " << params.engineInfo.computeUnitsCount - << " min_num_threads : " << min_num_threads << ")" << std::endl; - return selector.Default(tune_params(1, 1, 4, 2, 1, 1, EXE_MODE_DEFAULT)); + if (is_weight_with_small_ofm(params, output_f)) { + if (params.weights.GetLayout() == WeightsLayout::os_is_yx_osv32_isv2) { + return selector.Default(tune_params(1, 1, 4, 2, 1, 1, EXE_MODE_DEFAULT)); + } else if (params.weights.GetLayout() == WeightsLayout::os_iyx_osv16) { + return selector.Default(tune_params(1, 1, 4, 4, 1, 1, EXE_MODE_DEFAULT)); + } } else { - return selector.Default(tune_params(1, 2, 4, 2, 1, 1, EXE_MODE_DEFAULT)); + if (params.weights.GetLayout() == WeightsLayout::os_iyx_osv16) { + return selector.Default(tune_params(1, 1, 4, 4, 1, 1, EXE_MODE_DEFAULT)); + } else { + return selector.Default(tune_params(1, 2, 4, 2, 1, 1, EXE_MODE_DEFAULT)); + } } } else { // Try to use SLM kernels if possible @@ -343,7 +360,10 @@ FullyConnected_bf_tiled::GetAutoTuneParams(const fully_connected_params& params, selector.Case(tune_params(8, 2, 2, 4, 1, 1, EXE_MODE_DEFAULT, KernelType::SLM)) .Case(tune_params(8, 2, 1, 4, 1, 1, EXE_MODE_DEFAULT, KernelType::SLM)); } - return selector.Default(tune_params(8, 2, 1, 4, 1, 1, EXE_MODE_DEFAULT)); + if (params.weights.GetLayout() == WeightsLayout::os_iyx_osv16) + return selector.Default(tune_params(8, 1, 1, 4, 1, 1, EXE_MODE_DEFAULT)); + else + return selector.Default(tune_params(8, 2, 1, 4, 1, 1, EXE_MODE_DEFAULT)); } } else if (params.compressed && params.engineInfo.supports_immad) { return selector.Default(tune_params(1, 1, 1, 4, 1, 1, EXE_MODE_DEFAULT)); @@ -480,6 +500,8 @@ JitConstants FullyConnected_bf_tiled::GetJitConstants(const fully_connected_para } if (params.weights.GetLayout() == WeightsLayout::os_is_yx_osv32_isv2) jit.AddConstant(MakeJitConstant("W_IDX", "fi * TILE_K + kii")); + else if (params.weights.GetLayout() == WeightsLayout::os_iyx_osv16) + jit.AddConstant(MakeJitConstant("W_IDX", "fi * TILE_K + kii")); else jit.AddConstant(MakeJitConstant("W_IDX", "kii * TILE_OFM + fi")); @@ -512,9 +534,17 @@ JitConstants FullyConnected_bf_tiled::GetJitConstants(const fully_connected_para jit.AddConstant(MakeJitConstant("USE_SLM", 1)); jit.AddConstant(MakeJitConstant("LWS_BATCHES", lws_batches)); jit.AddConstant(MakeJitConstant("FILTER_LOAD_ITERS", weights_load_iters)); + + if (params.weights.GetLayout() == WeightsLayout::os_iyx_osv16) { + jit.AddConstant(MakeJitConstant("FILTER_ACTUAL_LOAD_BLOCK_SIZE", block_read_size / 2)); + jit.Merge(make_int4_packed_type_jit_constant("INT4_PACKED_TYPE_PRELOAD", params.weights.GetDType(), weights_elements_per_load / 2)); + } else { + jit.AddConstant(MakeJitConstant("FILTER_ACTUAL_LOAD_BLOCK_SIZE", block_read_size)); + jit.Merge(make_int4_packed_type_jit_constant("INT4_PACKED_TYPE_PRELOAD", params.weights.GetDType(), weights_elements_per_load)); + } + jit.AddConstant(MakeJitConstant("FILTER_LOAD_BLOCK_SIZE", block_read_size)); jit.AddConstant(MakeJitConstant("FILTER_ELEMENTS_PER_LOAD", weights_elements_per_load)); - jit.Merge(make_int4_packed_type_jit_constant("INT4_PACKED_TYPE_PRELOAD", params.weights.GetDType(), weights_elements_per_load)); } else { jit.AddConstant(MakeJitConstant("USE_SLM", 0)); } @@ -675,9 +705,16 @@ KernelsData FullyConnected_bf_tiled::GetTunedKernelsDataByIndex(const Params &pa return {}; tune_params tparams = GetAutoTuneParams(fc_params, KernelType::ANY, autoTuneIndex); + auto output_f = get_output_aligned_bf_size(fc_params, false).second; WeightsLayout weights_layout = WeightsLayout::os_iyx_osv16; if (fc_params.compressed && fc_params.inputs[0].GetDType() == Datatype::F16 + && (fc_params.weights.GetDType() == WeightsType::INT4 || fc_params.weights.GetDType() == WeightsType::UINT4) + && is_weight_with_small_ofm(fc_params, output_f) && is_weight_with_large_ifm(fc_params) + && (fc_params.weights.GetLayout() == WeightsLayout::oiyx || fc_params.weights.GetLayout() == WeightsLayout::os_iyx_osv16)) { + // Large K + Small N case to use [osv16 + TILE_K 4] + TILE_OFM 1 for batch 1 + weights_layout = WeightsLayout::os_iyx_osv16; + } else if (fc_params.compressed && fc_params.inputs[0].GetDType() == Datatype::F16 // ioyx => os_is_yx_osv32_isv2 is not supported yet && (fc_params.weights.GetLayout() == WeightsLayout::oiyx || fc_params.weights.GetLayout() == WeightsLayout::os_is_yx_osv32_isv2) && (fc_params.weights.GetDType() == WeightsType::INT4 || fc_params.weights.GetDType() == WeightsType::UINT4)) { diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_weights_int4.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_weights_int4.cpp index 0a8a2e168fe3bd..cd55dacd4c9c7a 100644 --- a/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_weights_int4.cpp +++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/reorder/reorder_weights_int4.cpp @@ -6,6 +6,7 @@ #include "kernel_selector_common.h" #include "kernel_selector_params.h" #include "kernel_selector_utils.h" +#include "common_types.h" namespace kernel_selector { @@ -17,6 +18,7 @@ ParamsKey ReorderWeightsKernelInt4::GetSupportedKey() const { k.EnableOutputWeightsType(WeightsType::INT4); k.EnableInputWeightsLayout(WeightsLayout::oiyx); k.EnableInputWeightsLayout(WeightsLayout::ioyx); + k.EnableOutputWeightsLayout(WeightsLayout::os_iyx_osv16); k.EnableOutputWeightsLayout(WeightsLayout::os_iyx_osv32); k.EnableOutputWeightsLayout(WeightsLayout::os_is_yx_osv32_isv2); k.EnableOutputWeightsLayout(WeightsLayout::oiyx); @@ -40,6 +42,8 @@ ReorderWeightsKernelInt4::DispatchData ReorderWeightsKernelInt4::SetDefault(cons dispatchData.gws = { Align(output.OFM().v, 32) / 2, output.IFM().v, 1 }; } else if (output.GetLayout() == WeightsLayout::os_is_yx_osv32_isv2) { dispatchData.gws = { Align(output.OFM().v, 32), output.IFM().v / 2, 1 }; + } else if (output.GetLayout() == WeightsLayout::os_iyx_osv16) { + dispatchData.gws = { Align(output.OFM().v, 16), output.IFM().v / 2, 1 }; } else { dispatchData.gws = { CeilDiv(output.LogicalSize(), 2), 1, 1 }; } @@ -60,6 +64,7 @@ bool ReorderWeightsKernelInt4::Validate(const Params& params) const { bool supported_case = input.GetLayout() == WeightsLayout::oiyx && output.GetLayout() == WeightsLayout::os_iyx_osv32; supported_case |= input.GetLayout() == WeightsLayout::oiyx && output.GetLayout() == WeightsLayout::os_is_yx_osv32_isv2; + supported_case |= input.GetLayout() == WeightsLayout::oiyx && output.GetLayout() == WeightsLayout::os_iyx_osv16; supported_case |= input.GetLayout() == WeightsLayout::ioyx && output.GetLayout() == WeightsLayout::oiyx; supported_case |= input.GetLayout() == WeightsLayout::ioyx && output.GetLayout() == WeightsLayout::os_iyx_osv32; return supported_case; From f6d4b4014e00c2513a1143eb3253e9890c97c6e6 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 23 Aug 2024 04:47:53 +0000 Subject: [PATCH 093/117] Bump idna from 3.4 to 3.7 in /docs (#26189) Bumps [idna](https://github.com/kjd/idna) from 3.4 to 3.7.

Release notes

Sourced from idna's releases.

v3.7

What's Changed

  • Fix issue where specially crafted inputs to encode() could take exceptionally long amount of time to process. [CVE-2024-3651]

Thanks to Guido Vranken for reporting the issue.

Full Changelog: https://github.com/kjd/idna/compare/v3.6...v3.7

Changelog

Sourced from idna's changelog.

3.7 (2024-04-11) ++++++++++++++++

  • Fix issue where specially crafted inputs to encode() could take exceptionally long amount of time to process. [CVE-2024-3651]

Thanks to Guido Vranken for reporting the issue.

3.6 (2023-11-25) ++++++++++++++++

  • Fix regression to include tests in source distribution.

3.5 (2023-11-24) ++++++++++++++++

  • Update to Unicode 15.1.0
  • String codec name is now "idna2008" as overriding the system codec "idna" was not working.
  • Fix typing error for codec encoding
  • "setup.cfg" has been added for this release due to some downstream lack of adherence to PEP 517. Should be removed in a future release so please prepare accordingly.
  • Removed reliance on a symlink for the "idna-data" tool to comport with PEP 517 and the Python Packaging User Guide for sdist archives.
  • Added security reporting protocol for project

Thanks Jon Ribbens, Diogo Teles Sant'Anna, Wu Tingfeng for contributions to this release.

Commits
  • 1d365e1 Release v3.7
  • c1b3154 Merge pull request #172 from kjd/optimize-contextj
  • 0394ec7 Merge branch 'master' into optimize-contextj
  • cd58a23 Merge pull request #152 from elliotwutingfeng/dev
  • 5beb28b More efficient resolution of joiner contexts
  • 1b12148 Update ossf/scorecard-action to v2.3.1
  • d516b87 Update Github actions/checkout to v4
  • c095c75 Merge branch 'master' into dev
  • 60a0a4c Fix typo in GitHub Actions workflow key
  • 5918a0e Merge branch 'master' into dev
  • Additional commits viewable in compare view

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=idna&package-manager=pip&previous-version=3.4&new-version=3.7)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/openvinotoolkit/openvino/network/alerts).
Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- docs/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index a3873d9e77c27e..84813255ac7694 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -8,7 +8,7 @@ certifi==2024.7.4 colorama==0.4.6 Cython==0.29.33 docutils==0.20 -idna==3.4 +idna==3.7 imagesize==1.3.0 importlib-metadata==4.8.0 iniconfig==1.1.1 From e4bcb7a8385d0902747450f54ed82902abc01fef Mon Sep 17 00:00:00 2001 From: hyunback kim Date: Fri, 23 Aug 2024 14:43:05 +0900 Subject: [PATCH 094/117] [GPU] Fix to get bad groups size bug in compressed_fc static shape. (#26145) SD3.int4 static bad accuracy problem, fixed it. ### Tickets: - *146778* --------- Signed-off-by: hyunback --- .../graph_optimizer/prepare_quantization.cpp | 3 +- .../test_cases/fully_connected_gpu_test.cpp | 90 +++++++++++++++++++ 2 files changed, 91 insertions(+), 2 deletions(-) diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_quantization.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_quantization.cpp index c17490488b629e..9563a1531cb886 100644 --- a/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_quantization.cpp +++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_quantization.cpp @@ -511,8 +511,7 @@ static void optimize_weights_decompression_parameters(fully_connected_node& fc_n auto need_reorder = [&](size_t dep_id) { auto dep_layout = fc_node.get_input_layout(dep_id); auto dep_pshape = dep_layout.get_partial_shape(); - - auto groups_count = dep_pshape[dep_pshape.size() - 1].get_length(); + auto groups_count = dep_pshape[1].get_length(); return groups_count > 1; }; diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp index 3f0b43a861873b..7a9519ba48c05a 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp @@ -3451,6 +3451,96 @@ TEST(fully_connected_3d_onednn_gpu, no_biases_int8) { ASSERT_EQ(-52.0f, output_ptr[b * output_f + 3]); } } + +TEST(fully_connected_3d_onednn_gpu, compressed_int4_scale_static) { + tests::random_generator rg(GET_SUITE_NAME); + + auto& engine = get_test_engine(); + if (!engine.get_device_info().supports_immad) + return; + + long int batch_num = 2; + long int ifm_num = 64; + long int ofm_num = 4; + long int scales_group_size = 32; + + auto input_mem = engine.allocate_memory({ { 1, batch_num, ifm_num, 1}, data_types::f16, format::bfyx }); + auto weights_mem = engine.allocate_memory({ {ofm_num, ifm_num, 1, 1}, data_types::u4, format::bfyx }); + auto scale_mem = engine.allocate_memory({ {ofm_num, ifm_num / scales_group_size, 1, 1}, data_types::f16, format::bfyx }); + auto dcomp_zp_mem = engine.allocate_memory({ {1, 1, 1, 1}, data_types::u8, format::bfyx }); + + set_values(dcomp_zp_mem, {8}); + + auto input_data = rg.generate_random_1d(batch_num * ifm_num, -2.0f, 2.0f); + set_values(input_mem, input_data); + + auto weigths_data = rg.generate_random_1d(ofm_num * ifm_num / 2, 0, 10); + set_values(weights_mem, weigths_data); + + auto scale_data = rg.generate_random_1d(ofm_num * ifm_num / scales_group_size, -4.0f, 4.0f); + set_values(scale_mem, scale_data); + + auto in_layout = layout{ {1, batch_num, ifm_num, 1}, data_types::f16, format::bfyx }; + + auto fc_prim = fully_connected("fc_prim", input_info("input"), "weights", "", "scale", "dcomp_zp", data_types::f16, 3, 4); + + fc_prim.decompression_zero_point_scalar = 8; + + auto get_ref_results = [&]() { + topology topology( + input_layout("input", in_layout), + data("weights", weights_mem), + data("scale", scale_mem), + data("dcomp_zp", dcomp_zp_mem), + fc_prim + ); + + auto config = get_test_default_config(engine); + ov::intel_gpu::ImplementationDesc fc_impl_desc = { format::bfyx, "fully_connected_gpu_bfyx_ref", impl_types::ocl }; + config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ {"fc_prim", fc_impl_desc} })); + + network network(engine, topology, config); + network.set_input_data("input", input_mem); + + auto outputs = network.execute(); + OPENVINO_ASSERT(outputs.size() == 1); + OPENVINO_ASSERT(outputs.begin()->first == "fc_prim"); + + auto output_layout = outputs.begin()->second.get_layout(); + auto output_mem = outputs.begin()->second.get_memory(); + + return engine.reinterpret_buffer(*output_mem, output_layout); + }; + + topology topology( + input_layout("input", in_layout), + data("weights", weights_mem), + data("scale", scale_mem), + data("dcomp_zp", dcomp_zp_mem), + fc_prim + ); + + auto config = get_test_default_config(engine); + config.set_property(ov::intel_gpu::optimize_data(true)); + + network::ptr network = get_network(engine, topology, config, get_test_stream_ptr(), false); + + network->set_input_data("input", input_mem); + + auto outputs = network->execute(); + ASSERT_EQ(outputs.size(), size_t(1)); + ASSERT_EQ(outputs.begin()->first, "fc_prim"); + + auto output_mem = outputs.begin()->second.get_memory(); + cldnn::mem_lock output_ptr (output_mem, get_test_stream()); + + auto ref_output_mem = get_ref_results(); + cldnn::mem_lock output_ptr_ref (ref_output_mem, get_test_stream()); + + for (size_t i = 0; i < output_ptr_ref.size(); i++) { + ASSERT_NEAR(output_ptr_ref[i], output_ptr[i], 9.0) << "i = " << i << std::endl; + } +} #endif TEST_F(fully_connected_gpu_tests, compressed_scale_zp_bias) { From 1f3edda195cba4f46d3cbbf0d9f0f5d867e80a6b Mon Sep 17 00:00:00 2001 From: Mateusz Mikolajczyk Date: Fri, 23 Aug 2024 08:08:42 +0200 Subject: [PATCH 095/117] [Transformations] Add downgrade transformation for ScatterNDUpdate15 with Reduction::None (#26113) ### Details: - *Add downgrade transformation from ScatterNDUpdate15 with Reduction::None to ScatterNDUpdate3* - *...* ### Tickets: - *CVS-149830* --------- Co-authored-by: Roman Kazantsev --- .../convert_scatter_nd_update15_downgrade.hpp | 24 +++++++++ .../common_optimizations.cpp | 2 + .../common_optimizations/nop_elimination.cpp | 6 ++- .../convert_scatter_nd_update15_downgrade.cpp | 39 ++++++++++++++ .../common_optimizations/nop_elimination.cpp | 22 ++++++++ ...ert_scatter_nd_update15_downgrade_test.cpp | 54 +++++++++++++++++++ .../transformation_pipeline.cpp | 2 + .../test_tf_SparseTensorDenseMatMul.py | 2 - 8 files changed, 147 insertions(+), 4 deletions(-) create mode 100644 src/common/transformations/include/transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp create mode 100644 src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp create mode 100644 src/common/transformations/tests/op_conversions/convert_scatter_nd_update15_downgrade_test.cpp diff --git a/src/common/transformations/include/transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp new file mode 100644 index 00000000000000..dfaab66e22501c --- /dev/null +++ b/src/common/transformations/include/transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp @@ -0,0 +1,24 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "openvino/pass/graph_rewrite.hpp" +#include "transformations_visibility.hpp" + +namespace ov { +namespace pass { +/** + * @ingroup ov_transformation_common_api + * @brief Converts ScatterNDUpdate version 15 to ScatterNDUpdate version 3 if ScatterNDUpdate reduction attribute is set + * to None. + */ +class TRANSFORMATIONS_API ConvertScatterNDUpdate15ToScatterNDUpdate3 : public MatcherPass { +public: + OPENVINO_RTTI("ConvertScatterNDUpdate15ToScatterNDUpdate3", "0"); + ConvertScatterNDUpdate15ToScatterNDUpdate3(); +}; + +} // namespace pass +} // namespace ov diff --git a/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp b/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp index d7ca44e7ddad34..500d003bd4642e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp @@ -92,6 +92,7 @@ #include "transformations/op_conversions/convert_roi_align_v3_to_v9.hpp" #include "transformations/op_conversions/convert_roi_align_v9_to_v3.hpp" #include "transformations/op_conversions/convert_scatter_elements_update12_downgrade.hpp" +#include "transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp" #include "transformations/op_conversions/convert_slice_to_strided_slice.hpp" #include "transformations/op_conversions/convert_softmax_downgrade.hpp" #include "transformations/op_conversions/convert_softmax_upgrade.hpp" @@ -231,6 +232,7 @@ bool ov::pass::CommonOptimizations::run_on_model(const std::shared_ptr(); ADD_MATCHER(fq_fusions, FakeQuantizeMulFusion) diff --git a/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp b/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp index 13da1c4d9082fc..782c25c2bf03ae 100644 --- a/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp @@ -789,8 +789,10 @@ pass::EliminateEltwise::EliminateEltwise() { pass::EliminateScatterUpdate::EliminateScatterUpdate() { MATCHER_SCOPE(EliminateScatterUpdate); - auto scatter_pattern = - pattern::wrap_type(); + auto scatter_pattern = pattern::wrap_type(); matcher_pass_callback callback = [=](pattern::Matcher& m) { auto scatter = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp new file mode 100644 index 00000000000000..94b2955ee818cc --- /dev/null +++ b/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp @@ -0,0 +1,39 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp" + +#include "itt.hpp" +#include "openvino/core/rt_info.hpp" +#include "openvino/op/scatter_nd_update.hpp" +#include "openvino/pass/pattern/op/wrap_type.hpp" +#include "transformations/utils/utils.hpp" + +ov::pass::ConvertScatterNDUpdate15ToScatterNDUpdate3::ConvertScatterNDUpdate15ToScatterNDUpdate3() { + MATCHER_SCOPE(ConvertScatterNDUpdate15ToScatterNDUpdate3); + + const auto scatter_v15_pattern = pattern::wrap_type(); + + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const auto scatter_v15 = std::dynamic_pointer_cast(m.get_match_root()); + if (!scatter_v15 || transformation_callback(scatter_v15)) { + return false; + } + if (scatter_v15->get_reduction() != ov::op::v15::ScatterNDUpdate::Reduction::NONE) { + return false; + } + const auto scatter_v3 = std::make_shared(scatter_v15->input_value(0), + scatter_v15->input_value(1), + scatter_v15->input_value(2)); + + scatter_v3->set_friendly_name(scatter_v15->get_friendly_name()); + copy_runtime_info(scatter_v15, scatter_v3); + replace_node(scatter_v15, scatter_v3); + + return true; + }; + + auto m = std::make_shared(scatter_v15_pattern, matcher_name); + register_matcher(m, callback); +} diff --git a/src/common/transformations/tests/common_optimizations/nop_elimination.cpp b/src/common/transformations/tests/common_optimizations/nop_elimination.cpp index e9b4bf3d8be3d1..9ee362104b24d0 100644 --- a/src/common/transformations/tests/common_optimizations/nop_elimination.cpp +++ b/src/common/transformations/tests/common_optimizations/nop_elimination.cpp @@ -1746,3 +1746,25 @@ TEST_F(TransformationTestsF, TransposeElimination) { model_ref = std::make_shared(OutputVector{result}, ParameterVector{data}); } } + +TEST_F(TransformationTestsF, ScatterNDUpdates15Elimination) { + { + auto data = std::make_shared(element::f32, PartialShape{100, 256, 10, 15}); + auto indices = std::make_shared(element::i32, PartialShape{25, 0, 3}); + auto updates = std::make_shared(element::f32, PartialShape{25, 0, 15}); + auto relu = std::make_shared(data); + auto scatter = std::make_shared(relu, indices, updates); + + auto result = std::make_shared(scatter); + model = std::make_shared(OutputVector{result}, ParameterVector{data, indices, updates}); + manager.register_pass(); + } + { + auto data = std::make_shared(element::f32, PartialShape{100, 256, 10, 15}); + auto indices = std::make_shared(element::i32, PartialShape{25, 0, 3}); + auto updates = std::make_shared(element::f32, PartialShape{25, 0, 15}); + auto relu = std::make_shared(data); + auto result = std::make_shared(relu); + model_ref = std::make_shared(OutputVector{result}, ParameterVector{data, indices, updates}); + } +} diff --git a/src/common/transformations/tests/op_conversions/convert_scatter_nd_update15_downgrade_test.cpp b/src/common/transformations/tests/op_conversions/convert_scatter_nd_update15_downgrade_test.cpp new file mode 100644 index 00000000000000..b2a126efe7803e --- /dev/null +++ b/src/common/transformations/tests/op_conversions/convert_scatter_nd_update15_downgrade_test.cpp @@ -0,0 +1,54 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp" + +#include + +#include + +#include "common_test_utils/ov_test_utils.hpp" +#include "openvino/opsets/opset15.hpp" +#include "openvino/opsets/opset4.hpp" +#include "openvino/pass/manager.hpp" +#include "transformations/utils/utils.hpp" +using namespace ov; +using namespace testing; + +namespace { +using Reduction = ov::opset15::ScatterNDUpdate::Reduction; + +std::shared_ptr create_v15_model(const Reduction reduction_type) { + const auto data = std::make_shared(ov::element::f32, ov::Shape{1000, 256, 10, 15}); + const auto indices = std::make_shared(ov::element::i32, ov::Shape{25, 125, 3}); + const auto updates = std::make_shared(ov::element::f32, ov::Shape{25, 125, 15}); + const auto scatter_nd = std::make_shared(data, indices, updates, reduction_type); + scatter_nd->set_friendly_name("scatter_nd15"); + return std::make_shared(scatter_nd->outputs(), ov::ParameterVector{data, indices, updates}); +} + +std::shared_ptr create_v3_model() { + const auto data = std::make_shared(ov::element::f32, ov::Shape{1000, 256, 10, 15}); + const auto indices = std::make_shared(ov::element::i32, ov::Shape{25, 125, 3}); + const auto updates = std::make_shared(ov::element::f32, ov::Shape{25, 125, 15}); + const auto scatter_nd = std::make_shared(data, indices, updates); + scatter_nd->set_friendly_name("scatter_nd15"); + + return std::make_shared(scatter_nd->outputs(), ov::ParameterVector{data, indices, updates}); +} + +} // namespace + +TEST_F(TransformationTestsF, ConvertScatterNDUpdate15ToScatterNDUpdate3_no_reduction) { + manager.register_pass(); + model = create_v15_model(Reduction::NONE); + model_ref = create_v3_model(); + comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES); + comparator.enable(FunctionsComparator::CmpValues::ATTRIBUTES); +} + +TEST_F(TransformationTestsF, ConvertScatterNDUpdate15ToScatterNDUpdate3_reduction) { + manager.register_pass(); + model = create_v15_model(Reduction::PROD); +} diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp index 43862022462ada..54a038c9492db6 100644 --- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp +++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp @@ -58,6 +58,7 @@ #include "transformations/op_conversions/convert_reduce_to_pooling.hpp" #include "transformations/op_conversions/convert_roi_align_v3_to_v9.hpp" #include "transformations/op_conversions/convert_roi_align_v9_to_v3.hpp" +#include "transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp" #include "transformations/op_conversions/convert_sequences_to_tensor_iterator.hpp" #include "transformations/op_conversions/convert_shuffle_channels3.hpp" #include "transformations/op_conversions/convert_slice_to_strided_slice.hpp" @@ -636,6 +637,7 @@ void Transformations::PreLpt(const std::vector& defaultPrecis CPU_DISABLE_PASS_COMMON(manager, ov::pass::ConvertTopK11ToTopK3); CPU_DISABLE_PASS_COMMON(manager, ov::pass::HSwishDecomposition); CPU_DISABLE_PASS_COMMON(manager, ov::pass::MatMulConstTransposesExtraction); + CPU_DISABLE_PASS_COMMON(manager, ov::pass::ConvertScatterNDUpdate15ToScatterNDUpdate3); CPU_DISABLE_PASS_X64(manager, ov::pass::HSigmoidDecomposition); CPU_DISABLE_PASS_X64(manager, ov::pass::ReduceL1Decomposition); diff --git a/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py index 1eb31a753b6bfd..49df4226a7fcb2 100644 --- a/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py +++ b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseMatMul.py @@ -91,8 +91,6 @@ def test_sparse_tensor_dense_mat_mul(self, data_type, indices_type, a_shape, b_shape, nnz, ie_device, precision, ir_version, temp_dir, use_legacy_frontend): - if ie_device == 'GPU': - pytest.skip("149830: ScatterNDUpdate-15 is not supported on GPU") self._test(*self.create_sparse_tensor_dense_mat_mul_net(data_type, indices_type, adjoint_a, adjoint_b, a_shape, b_shape, nnz), From 0ced13225dcdb83833c89e24b3fb1fcdd395a948 Mon Sep 17 00:00:00 2001 From: Xiake Sun Date: Fri, 23 Aug 2024 14:25:34 +0800 Subject: [PATCH 096/117] Fix performance profiling on GPU with oneDNN support (#26174) Fix performance profiling on GPU with oneDNN support, so that benchmark_app can get performance counter and dump exec graph on DG2 and further platform with oneDNN support. CVS-150346 --------- Co-authored-by: Sergey Shlyapnikov --- .../src/graph/impls/onednn/primitive_onednn_base.h | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h index 573c29b115842e..57fd4afbe933d6 100644 --- a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h +++ b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h @@ -560,10 +560,14 @@ struct typed_primitive_onednn_impl : public typed_primitive_impl { stream.wait(); std::vector duration = dnnl::get_profiling_data(stream.get_onednn_stream(), dnnl::profiling_data_kind::time); - OPENVINO_ASSERT(duration.size() == 1, "[GPU] oneDNN profiling data is expected to have info only for single primitive ", + if (duration.empty()) { + event = std::make_shared(0); + } else { + OPENVINO_ASSERT(duration.size() == 1, "[GPU] oneDNN profiling data is expected to have info only for single primitive ", "actual number is ", duration.size()); + event = std::make_shared(duration[0]); + } - event = std::make_shared(duration[0]); } else { // If oneDNN primitive is the output primitive or it's user is CPU implementation, then enqueue marker // with empty events wait list (which will trigger wait for all previously enqueued tasks) and From 2fd35c95acd379a41601208258e4056bed7377e3 Mon Sep 17 00:00:00 2001 From: David Pava Date: Fri, 23 Aug 2024 09:29:48 +0300 Subject: [PATCH 097/117] [NPU] Removing a ref to fix workload type testing errors (#26186) ### Details: - Removing a ref to fix workload type testing errors ### Tickets: --- src/plugins/intel_npu/src/plugin/src/compiled_model.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp b/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp index 54942d1416208e..d584c62704fbf9 100644 --- a/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp +++ b/src/plugins/intel_npu/src/plugin/src/compiled_model.cpp @@ -214,7 +214,7 @@ void CompiledModel::configure_stream_executors() { } void CompiledModel::initialize_properties() { - const auto& pluginSupportedProperties = + const auto pluginSupportedProperties = get_plugin()->get_property(ov::supported_properties.name(), {}).as>(); const auto isPropertySupported = [&pluginSupportedProperties](const std::string& name) { return std::any_of(pluginSupportedProperties.begin(), From 36e7b30b4fc8a3ec9c9112fba72b9c3c9b9c8d24 Mon Sep 17 00:00:00 2001 From: Oleg Pipikin Date: Fri, 23 Aug 2024 08:50:35 +0200 Subject: [PATCH 098/117] Optimization of raw meta data serialization (#26115) ### Details: - Optimization of raw meta data serialization - Fix legacy meta data creation ### Tickets: - CVS-123381 --- src/core/dev_api/openvino/core/meta_data.hpp | 14 ++++ src/core/src/pass/serialize.cpp | 22 ++++-- .../serialization/rt_info_serialization.cpp | 78 +++++++++++++++++++ src/frontends/ir/src/ir_deserializer.cpp | 67 ++++++++++------ 4 files changed, 153 insertions(+), 28 deletions(-) diff --git a/src/core/dev_api/openvino/core/meta_data.hpp b/src/core/dev_api/openvino/core/meta_data.hpp index 3b0debaff3763e..221aca96080d65 100644 --- a/src/core/dev_api/openvino/core/meta_data.hpp +++ b/src/core/dev_api/openvino/core/meta_data.hpp @@ -6,6 +6,10 @@ #include "openvino/core/any.hpp" +namespace pugi { +class xml_node; +} + namespace ov { /** @@ -32,4 +36,14 @@ class OPENVINO_API Meta { virtual ~Meta() = default; }; +class MetaDataWithPugixml : public Meta { +public: + /** + * @brief Returns meta unchanged meta information. Throws ov::Exception if the meta was potentially changed + * + * @return const pugi::xml_node& with meta information + */ + virtual const pugi::xml_node& get_pugi_node() const = 0; +}; + } // namespace ov diff --git a/src/core/src/pass/serialize.cpp b/src/core/src/pass/serialize.cpp index 17da51b5831c99..1d5e295e8dbe23 100644 --- a/src/core/src/pass/serialize.cpp +++ b/src/core/src/pass/serialize.cpp @@ -916,11 +916,23 @@ void serialize_rt_info(pugi::xml_node& root, const std::string& name, const ov:: child.append_attribute("name").set_value(name.c_str()); } if (data.is>()) { - std::shared_ptr meta = data.as>(); - ov::AnyMap& map = *meta; - for (const auto& it : map) { - serialize_rt_info(child, it.first, it.second); - } + auto meta = data.as>(); + do { + if (auto meta_with_pugixml_node = std::dynamic_pointer_cast(meta)) { + if (auto pugi_node = meta_with_pugixml_node->get_pugi_node()) { + root.remove_child(child); + auto added_node = root.append_copy(pugi_node); + OPENVINO_ASSERT(added_node, "Cannot add pugixml node with name: ", name); + added_node.set_name(name.c_str()); + break; + } + } + // Meta in ov::Meta cannot be accessed by MetaDataWithPugixml::get_pugi_node. Read it as ov::AnyMap + ov::AnyMap& map = *meta; + for (const auto& it : map) { + serialize_rt_info(child, it.first, it.second); + } + } while (false); } else if (data.is()) { const ov::AnyMap& any_map = data.as(); for (const auto& it : any_map) { diff --git a/src/core/tests/pass/serialization/rt_info_serialization.cpp b/src/core/tests/pass/serialization/rt_info_serialization.cpp index 2664ab5edca18a..412625d45d53d9 100644 --- a/src/core/tests/pass/serialization/rt_info_serialization.cpp +++ b/src/core/tests/pass/serialization/rt_info_serialization.cpp @@ -10,6 +10,7 @@ #include "openvino/frontend/manager.hpp" #include "openvino/opsets/opset8.hpp" #include "openvino/pass/manager.hpp" +#include "openvino/runtime/core.hpp" #include "transformations/rt_info/attributes.hpp" class RTInfoSerializationTest : public ov::test::TestsCommon { @@ -221,3 +222,80 @@ TEST_F(RTInfoSerializationTest, tag_names_verification) { ASSERT_EQ(model_rt_info[item.first], item.second); }); } + +TEST(OvSerializationTests, SerializeRawMeta) { + std::string ir_with_rt_info = R"V0G0N( + + + + + + + 3 + 20 + 20 + + + + + + + 3 + 20 + 20 + + + + + + + + + + + + + + + + +)V0G0N"; + ov::Core core; + { + // Don't read meta data. Copy raw pugixml::node from MetaDataWithPugixml to serialized model + auto model = core.read_model(ir_with_rt_info, ov::Tensor()); + + std::stringstream model_ss, weights_ss; + ov::pass::Serialize(model_ss, weights_ss).run_on_model(model); + + auto serialized_model = model_ss.str(); + EXPECT_EQ(0, serialized_model.compare(ir_with_rt_info)); + } + + { + // Don't read meta data. Fully serialize AnyMap with meta + auto model = core.read_model(ir_with_rt_info, ov::Tensor()); + auto custom_rt_info1_value = model->get_rt_info("custom_rt_info1", "item0"); + EXPECT_EQ(0, custom_rt_info1_value.compare("testvalue1")); + auto custom_rt_info2_value = model->get_rt_info("custom_rt_info2", "item0"); + EXPECT_EQ(0, custom_rt_info2_value.compare("testvalue2")); + + std::stringstream model_ss, weights_ss; + ov::pass::Serialize(model_ss, weights_ss).run_on_model(model); + + auto serialized_model = model_ss.str(); + EXPECT_EQ(0, serialized_model.compare(ir_with_rt_info)); + } + + { + auto model = core.read_model(ir_with_rt_info, ov::Tensor()); + auto custom_rt_info1_value = model->get_rt_info("custom_rt_info1", "item0"); + EXPECT_EQ(0, custom_rt_info1_value.compare("testvalue1")); + + std::stringstream model_ss, weights_ss; + ov::pass::Serialize(model_ss, weights_ss).run_on_model(model); + + auto serialized_model = model_ss.str(); + EXPECT_EQ(0, serialized_model.compare(ir_with_rt_info)); + } +} diff --git a/src/frontends/ir/src/ir_deserializer.cpp b/src/frontends/ir/src/ir_deserializer.cpp index 8c8aec333e107e..68900b150514bc 100644 --- a/src/frontends/ir/src/ir_deserializer.cpp +++ b/src/frontends/ir/src/ir_deserializer.cpp @@ -584,10 +584,17 @@ std::shared_ptr ov::XmlDeserializer::parse_function(const pugi::xml_n return function; } -class MetaDataParser : public ov::Meta { +class MetaDataParser : public ov::MetaDataWithPugixml { public: - MetaDataParser(const std::string& name, const pugi::xml_node& meta) : m_name(name) { + MetaDataParser(const std::string& name, const pugi::xml_node& meta, bool accessible_by_pugixml_node = true) + : m_name(name), + m_accessible_by_pugixml_node(accessible_by_pugixml_node) { m_meta.append_copy(meta); + if (accessible_by_pugixml_node) { + m_meta_node = m_meta.child(m_name.c_str()); + } else { + m_meta_node = pugi::xml_node(); + } } operator const ov::AnyMap&() const override { @@ -600,6 +607,14 @@ class MetaDataParser : public ov::Meta { return m_parsed_map; } + const pugi::xml_node& get_pugi_node() const override { + if (!m_meta_node.empty() && !m_accessible_by_pugixml_node) { + // Meta cannot be accessed by pugixml node. Return empty node + m_meta_node = pugi::xml_node(); + } + return m_meta_node; + }; + private: bool has_attr(const pugi::xml_node& node, const std::string& name = "value") const { auto attr = node.attribute(name.c_str()); @@ -646,14 +661,18 @@ class MetaDataParser : public ov::Meta { void parse() const { std::call_once(m_oc, [this]() { + m_accessible_by_pugixml_node = false; const pugi::xml_node& node = m_meta.child(m_name.c_str()); m_parsed_map = parse_node(node); }); } + pugi::xml_document m_meta; const std::string m_name; mutable ov::AnyMap m_parsed_map; mutable std::once_flag m_oc; + mutable std::atomic_bool m_accessible_by_pugixml_node; + mutable pugi::xml_node m_meta_node; }; void ov::XmlDeserializer::read_meta_data(const std::shared_ptr& model, const pugi::xml_node& meta_section) { @@ -681,29 +700,31 @@ void ov::XmlDeserializer::read_meta_data(const std::shared_ptr& model void ov::XmlDeserializer::read_legacy_meta_data(const std::shared_ptr& model, const std::unordered_set& names, const pugi::xml_node& root_section) { - const auto& read_meta = [](const std::shared_ptr& model, - const std::string& name, - const pugi::xml_node& meta_section) { - auto& rt_info = model->get_rt_info(); - if (name == "meta_data") { - for (const auto& data : meta_section.children()) { - const std::string& section_name = data.name(); - // Rename cli_parameters to conversion_parameters - if (section_name == "cli_parameters") { - std::shared_ptr meta = std::make_shared("cli_parameters", data); - rt_info["conversion_parameters"] = meta; - } else if (!data.attribute("value").empty()) { - rt_info[data.name()] = pugixml::get_str_attr(data, "value"); - } else { - OPENVINO_THROW("Unsupported legacy argument: ", data.name()); + const auto& read_meta = + [](const std::shared_ptr& model, const std::string& name, const pugi::xml_node& meta_section) { + auto& rt_info = model->get_rt_info(); + if (name == "meta_data") { + for (const auto& data : meta_section.children()) { + const std::string& section_name = data.name(); + // Rename cli_parameters to conversion_parameters + if (section_name == "cli_parameters") { + std::shared_ptr meta = std::make_shared("cli_parameters", data); + rt_info["conversion_parameters"] = meta; + } else if (!data.attribute("value").empty()) { + rt_info[data.name()] = pugixml::get_str_attr(data, "value"); + } else { + OPENVINO_THROW("Unsupported legacy argument: ", data.name()); + } } + } else if (name == "quantization_parameters") { + // Rename quantization_parameters to optimization + // Legacy implementation. Have to be parsed inside MetaDataParser. Do not allow to serialize it as raw + // pugi::xml_node. + std::shared_ptr meta = + std::make_shared("quantization_parameters", meta_section, false); + rt_info["optimization"] = meta; } - } else if (name == "quantization_parameters") { - // Rename quantization_parameters to optimization - std::shared_ptr meta = std::make_shared("quantization_parameters", meta_section); - rt_info["optimization"] = meta; - } - }; + }; for (const auto& it : names) read_meta(model, it, root_section.child(it.c_str())); } From 8a08bb9c5f901da89596070d189d2aa67879de34 Mon Sep 17 00:00:00 2001 From: tadamczx <156996781+tadamczx@users.noreply.github.com> Date: Fri, 23 Aug 2024 08:51:47 +0200 Subject: [PATCH 099/117] [DOCS] Simplified snippets setting to work in every environment (#26193) ### Details: - *item1* - *...* ### Tickets: - *ticket-id* --- docs/sphinx_setup/conf.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/sphinx_setup/conf.py b/docs/sphinx_setup/conf.py index 5b679d10213774..ea144ca84d6154 100644 --- a/docs/sphinx_setup/conf.py +++ b/docs/sphinx_setup/conf.py @@ -113,8 +113,6 @@ "show_prev_next": False, } -snippet_root = os.getenv("SNIPPET_ROOT", "") - html_sidebars = { "**": ["search-field.html", "sidebar-nav-bs.html", "sidebar-ethical-ads.html"] } @@ -123,7 +121,8 @@ 'current_language': 'English', #'languages': (('English', '/latest'), ('Chinese', '/cn/latest')), 'doxygen_mapping_file': '@DOXYGEN_MAPPING_FILE@', - 'doxygen_snippet_root': snippet_root, + # go back fours 3 steps down in directory to reach openvino dir + 'doxygen_snippet_root': os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')), 'default_mode': 'light' } From 6d0d7716ac193e77ee1e63013c3072e3984f746e Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Fri, 23 Aug 2024 16:20:36 +0400 Subject: [PATCH 100/117] [MO Tests] Switch off legacy test_reduce_lp test (#26196) **Details:** Switch off legacy test_reduce_lp test **Ticket:** 150423 --------- Signed-off-by: Kazantsev, Roman --- tools/mo/unit_tests/mo/ops/ReduceOps_test.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/mo/unit_tests/mo/ops/ReduceOps_test.py b/tools/mo/unit_tests/mo/ops/ReduceOps_test.py index f1cbc19d331a3a..947fc95c38ab9f 100644 --- a/tools/mo/unit_tests/mo/ops/ReduceOps_test.py +++ b/tools/mo/unit_tests/mo/ops/ReduceOps_test.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 import pytest +import unittest import numpy as np @@ -21,6 +22,7 @@ class TestReduceLpTest(): + @unittest.skip("Skipped due to function array_equal failure") @pytest.mark.parametrize("shape, axes, keepdims, p",[ ([3, 2, 2], [0], True, 1), ([3, 2, 2], [0], True, 2), From c7a19b341f6f61e62290f36495e9702d1e088812 Mon Sep 17 00:00:00 2001 From: Egor Duplenskii Date: Fri, 23 Aug 2024 12:51:59 +0200 Subject: [PATCH 101/117] [CPU] Fix BatchToSpace handling of outputs containing dimension 1 (#26188) By avoiding potential 'size_t' underflow. Also completely avoid evaluating an execute for empty output shapes. Fix `generate_inputs()` for BatchToSpace single layer tests as well ### Tickets: - 148774 - 145275 --- .../intel_cpu/src/nodes/batch_to_space.cpp | 12 ++--- .../intel_cpu/src/nodes/batch_to_space.h | 6 +++ .../single_layer_tests/batch_to_space.cpp | 52 ++++++++++++++++++- 3 files changed, 63 insertions(+), 7 deletions(-) diff --git a/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp b/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp index afaf3c7ca6358a..6979e939521eb6 100644 --- a/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp +++ b/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp @@ -183,11 +183,11 @@ void BatchToSpace::batchToSpaceKernel() { begin[1] = (blockShape[1] - 1 - oAdd[1]) / blockShape[1] / blockSize; finish[1] = (outShape5D[1] - 1 - oAdd[1]) / blockShape[1] / blockSize; begin[2] = (blockShape[2] - 1 - oAdd[2]) / blockShape[2]; - finish[2] = (outShape5D[2] - 1 - oAdd[2]) / blockShape[2]; + finish[2] = (outShape5D[2] + blockShape[2] - 1 - oAdd[2]) / blockShape[2]; begin[3] = (blockShape[3] - 1 - oAdd[3]) / blockShape[3]; - finish[3] = (outShape5D[3] - 1 - oAdd[3]) / blockShape[3]; + finish[3] = (outShape5D[3] + blockShape[3] - 1 - oAdd[3]) / blockShape[3]; begin[4] = (blockShape[4] - 1 - oAdd[4]) / blockShape[4]; - finish[4] = (outShape5D[4] - 1 - oAdd[4]) / blockShape[4]; + finish[4] = (outShape5D[4] + blockShape[4] - 1 - oAdd[4]) / blockShape[4]; const int64_t addTmpOC = blocked ? 0lu : oAdd[1]; const int64_t addTmpOc = blocked ? oAdd[1] : 0lu; indxStart[1] = begin[1] > indxStart[1] ? begin[1] : indxStart[1]; @@ -198,15 +198,15 @@ void BatchToSpace::batchToSpaceKernel() { const size_t srcIdx1 = srcIdx0 + indxStart[1] * inSpatialStep * blockSize; const size_t dstIdx1 = dstIdx0 + tmpOC * outSpatialStep * blockSize; const size_t itEnd = blocked ? ((block - 1) * blockShape[1] + oAdd[1]) / blockSize : 0lu; - for (size_t i2 = begin[2]; i2 < finish[2] + 1; ++i2) { + for (size_t i2 = begin[2]; i2 < finish[2]; ++i2) { const int64_t tmpOd = i2 * blockShape[2] + oAdd[2]; const size_t srcIdx2 = srcIdx1 + i2 * inShape5D[3] * inShape5D[4] * blockSize; const size_t dstIdx2 = dstIdx1 + tmpOd * outShape5D[3] * outShape5D[4] * blockSize; - for (size_t i3 = begin[3]; i3 < finish[3] + 1; ++i3) { + for (size_t i3 = begin[3]; i3 < finish[3]; ++i3) { const int64_t tmpOh = i3 * blockShape[3] + oAdd[3]; const size_t srcIdx3 = srcIdx2 + i3 * inShape5D[4] * blockSize; const size_t dstIdx3 = dstIdx2 + tmpOh * outShape5D[4] * blockSize; - for (size_t i4 = begin[4]; i4 < finish[4] + 1; ++i4) { + for (size_t i4 = begin[4]; i4 < finish[4]; ++i4) { const int64_t tmpOw = i4 * blockShape[4] + oAdd[4]; const size_t srcIdx4 = srcIdx3 + i4 * blockSize; const size_t dstIdx4 = dstIdx3 + tmpOw * blockSize; diff --git a/src/plugins/intel_cpu/src/nodes/batch_to_space.h b/src/plugins/intel_cpu/src/nodes/batch_to_space.h index 724ed9536bae6c..1b583f74bd7905 100644 --- a/src/plugins/intel_cpu/src/nodes/batch_to_space.h +++ b/src/plugins/intel_cpu/src/nodes/batch_to_space.h @@ -16,6 +16,12 @@ class BatchToSpace : public Node { void getSupportedDescriptors() override {}; void initSupportedPrimitiveDescriptors() override; + + // output shape can potentially be empty + bool isExecutable() const override { + return !hasEmptyInputTensors() && !hasEmptyOutputTensors(); + } + void execute(dnnl::stream strm) override; bool created() const override; diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/batch_to_space.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/batch_to_space.cpp index 4af67e8258774f..4d1a4660b1bd8a 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/batch_to_space.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/batch_to_space.cpp @@ -77,7 +77,11 @@ class BatchToSpaceCPULayerTest : public testing::WithParamInterface dynamicInputShapesZeroDimOutput = { + {{-1, -1, -1, -1, -1}, {{2, 16, 1, 5, 5}}}, + {{5}, {{5}, {5}, {5}}}, + {{5}, {{5}, {5}, {5}}}, + {{5}, {{5}, {5}, {5}}} +}; + +const std::vector blockShapeZeroDimOutput = {1, 1, 2, 1, 1}; +const std::vector cropsBeginZeroDimOutput = {0, 0, 0, 0, 0}; +const std::vector cropsEndZeroDimOutput = {0, 0, 2, 0, 0}; + +const auto dynamicBatchToSpaceParamsSetZeroDimOutput = ::testing::Combine(::testing::Values(dynamicInputShapesZeroDimOutput), + ::testing::Values(blockShapeZeroDimOutput), + ::testing::Values(cropsBeginZeroDimOutput), + ::testing::Values(cropsEndZeroDimOutput), + ::testing::Values(ov::element::Type_t::f32), + ::testing::Values(CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}))); + +INSTANTIATE_TEST_SUITE_P(smoke_DynamicBatchToSpaceCPULayerTestCaseZeroDimOutput, + BatchToSpaceCPULayerTest, + dynamicBatchToSpaceParamsSetZeroDimOutput, + BatchToSpaceCPULayerTest::getTestCaseName); + +std::vector dynamicInputShapesOutputDimOne = { + {{-1, -1, -1, -1, -1}, {{2, 16, 1, 5, 5}}}, + {{5}, {{5}, {5}, {5}}}, + {{5}, {{5}, {5}, {5}}}, + {{5}, {{5}, {5}, {5}}} +}; + +const std::vector blockShapeOutputDimOne = {1, 1, 2, 1, 1}; +const std::vector cropsBeginOutputDimOne = {0, 0, 0, 0, 0}; +const std::vector cropsEndOutputDimOne = {0, 0, 1, 0, 0}; + +const auto dynamicBatchToSpaceParamsSetOutputDimOne = ::testing::Combine(::testing::Values(dynamicInputShapesOutputDimOne), + ::testing::Values(blockShapeOutputDimOne), + ::testing::Values(cropsBeginOutputDimOne), + ::testing::Values(cropsEndOutputDimOne), + ::testing::Values(ov::element::Type_t::f32), + ::testing::Values(CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}))); + +INSTANTIATE_TEST_SUITE_P(smoke_DynamicBatchToSpaceCPULayerTestCaseOutputDimOne, + BatchToSpaceCPULayerTest, + dynamicBatchToSpaceParamsSetOutputDimOne, + BatchToSpaceCPULayerTest::getTestCaseName); + } // namespace } // namespace test } // namespace ov From 94e95ecc048c819e3db0be5d3142f2b62f6e4617 Mon Sep 17 00:00:00 2001 From: Michael Frank Hansen Date: Fri, 23 Aug 2024 04:02:43 -0700 Subject: [PATCH 102/117] Releases/ovms 2024/3 (#26126) Platform list: changed incorrect CPU description from 8490H to 8480+ System config XLS: changed incorrect CPU description from 8490H to 8480+ Download spreadsheet: new OVMS results for OV-2024.3 CSV file: new OVMS results for OV-2024.3 --------- Co-authored-by: Karol Blaszczak --- .../about-openvino/performance-benchmarks.rst | 3 +- .../OV-2024.3-Performance-Data.xlsx | Bin 302284 -> 305774 bytes .../OV-2024.3-platform_list.pdf | Bin 242429 -> 239931 bytes .../OV-2024.3-system-info-detailed.xlsx | Bin 78255 -> 78345 bytes .../benchmarks_files/OVMS-benchmark-data.csv | 156 +++++++++--------- 5 files changed, 79 insertions(+), 80 deletions(-) diff --git a/docs/articles_en/about-openvino/performance-benchmarks.rst b/docs/articles_en/about-openvino/performance-benchmarks.rst index 96ddcff022e237..7f838d62b18f1c 100644 --- a/docs/articles_en/about-openvino/performance-benchmarks.rst +++ b/docs/articles_en/about-openvino/performance-benchmarks.rst @@ -206,12 +206,11 @@ You can also test performance for your system yourself, following the guide on

Disclaimers

- * Intel® Distribution of OpenVINO™ toolkit performance results are based on release 2024.3, as of July 31, 2024. * OpenVINO Model Server performance results are based on release - 2024.2, as of June 28, 2024. + 2024.3, as of Aug. 19, 2024. The results may not reflect all publicly available updates. Intel technologies' features and benefits depend on system configuration and may require enabled hardware, software, or service diff --git a/docs/sphinx_setup/_static/benchmarks_files/OV-2024.3-Performance-Data.xlsx b/docs/sphinx_setup/_static/benchmarks_files/OV-2024.3-Performance-Data.xlsx index e89b5991029ad6317a8d401d3bf1e03e171bc9bb..05de7365749228b3ec06d971cf0adca40da9f32b 100644 GIT binary patch delta 111680 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 Sk2mm7?k^8hS% z^6a08GL{UCCo80{?oTGZX!4C)?vvuGVPY>tZf-8WpX<~60wgcv+L|X~ZJb3PGg%93 zB}cqTfcVlggG@QK-DRBBFm|rqLyF;6}{nyU7SJJqe zl0?$t^iOk{*icppEwi1?pUak+Rzj6_UG$7GGdGp>xq7?gy>@*VqY7p_RilV=VN4U8 z5|U?Pl?Y{opy%qys}wzBFFn@xAlrAE;Ae(fKx;+s^;D_|T6=o7v)T9UL`%+g+NFHO z1r1g0L2D3fN=XuBjfaxJ@fUdShsAV9+>j%&?MFu+$b+Or;;0X)rw^_aex7*ZXustB zD{mq%{6A`1!ePSHNaC2L_>w8Dh!t}x6B`s;88%M=a@B`)FHZ*}Pj1ZyZ?bS_u89jk z$UR|IH{x?(t$bs`^Ou6j%@~QsXN_FI)9#$>4G7%f0uNDimX>X_`F2=i%LbP_hJ!?w zx10N-&|1p%$y?UxwkxA3xlB20V10XCcR)bCy1YfR$SI_eimNE2BKN}RPY(j2OK@E| zH!-FmUh626g*N;t#N#M=j~^m?vmYb?ynez}?sQhp+TXFkgF@dzKUsu$^6n&2C0NtnXjOcDZ0yNA^M*4GO#W??Nt zG>!WkIF+`TfhR5a(V37_OWGio9?J4e(4isugVlAG+e6Yl<+V-&6Vi?ub>WnhKN}uA zFp0TnRmvwF4;HkQMrikJWR^xH7zwMZHz;7Q2=>fPnZOPLq+bflrEzM~E~ECUfwgE8 zxPKfcu4hXgd*RA|&y>oyJ%<(WKdSP(6OW~2D@b5c@#B%(LcARWD1}V>>~>M<2ov0y z+kblWu>XI0cg~f&el}bh$TQ~&ksdmvJRK2u;7*AfyDS2gk)%7v%in88L>H(WKK#&R z#-hsX4~G;?$d2F{d>IjG%*QK*f3Uk=p1x=1(c9E__Kh_-p2a`tQIqzDe`saoJqc|z z_>@i-xF`lCy+52+b*hH(E@|Y^)M{b+&a3h{3;sivOS8U)v0jWknDyzA*x2p0u_h>- zA>0@KY)Y+VGLP>&E%yB@%T>ZQ?kBBa4;ZbH7hDAdFm{@%ZvzShWDf%bgzzsDc-Szw z+dEks+uK{yd)V4ksp}{laH9GdSpEcY2xo?EvpU+z5pO6tXH|pBf`Q>nkUK_*(We{; zB4z&cjGoao!A7m65SCwM-}szdFVL8$6eGqj;TY^+J zD=MP_a4Y9p7W&}*d~cqqOcPw6zXJmcE=MQph8Ndb%4IGlvIcoc(Qs-lb&>u`{nWQk z%}%Tur$RF;!0NdEO=gtRAb$HM!FWC#Sj<|n*iw|D8RVdi2>h6pO_xQdo#6*sL;6{u zS7E6~54<0XCd=!d4^6EC@G@A=-a<2chTi-Q82&pO0H_)qT(b%+BvB)i@!Vd5VFLPX zEB8L;S7nXa>(qa~20<#o3ZN0f)%!W`6v=$=7Th|`@o#? zU=fVwbeh{0NsFFAl8Qu)vWze$oQ3>1yK-nFThQRW$V;u25lm2hAx$y|rrM zyfncWy9Vl**M4>Fi7;Pb`;2Z<6h7}X6!zZh#(v`3IX^lq6ecThOK*Z2kE-QBiUfAt zrKk&3WD+I}Sbcj8UX8{PgblL3*eew)WM+tYit`lHiZ46oi_ z^TTHy8g-_|+j#9fBI739H%sp)gkFDK_+ZY%52y(;CY+%GiA!Ur9slot3&$|;xrVM?#jD~K>kKigmx4p zX~>H>-tGf*4nfR3*l=+OYhSB+1 zG)^{W`zTt5PoGOA}2E!1bEoBF9Xu zxLOndgyt$8S!p|OG}f1GhLz$DZT5L&Q0Dt~VCoe3m2?Zbxl+EO^6m*9PvHyR3(4|3 zR=&>i{bDuXnjgghTr+*ZC!S$lt1j&6={BFnaV7kYs!M4S%Z1J6EUDmHs{%i(#i~8G zpd;0?Z0Fxi>(1K1)oL^ayn)t?}p%ywWpA@%jI+#=HhMI^_9#j@U8 zr@&dW%g+*=4@}6{URzuybf8_1MMgOmMICXHv>BIvz{tzqtyz&$A=ZY+kRsf!_I;CO z@9dl&_A*Iwuca6MHd~V0ZGQA7&<}V5``Q~FpN0^CWtcfR$)VYWV>P@oe7jr_-V8PS zL`Xx*`Gp4k)#&i14GaY22HmI!PYnzhw;E(b6ub%f4w~;yNEw!r&c@Y-Zf`k*fb{G_ z)M3VUz1!6&GF(M0;lk8|O}w2tm}XqKzTIA$r_ij5md{8Zru|hdtA0joc2k-b1{XCa zl{3EaTT%;R4F2PzbDL&q;VrMON;}#IHHL~N$C`jkLQR;&(Oi4(o0Ov^VTJ)<+pkkT z(*VRDcM!bU%e3Z)%EE0<)i^qJBH&s*`w6f~I!Ot%DCEbUyOxIjHoL@<0Xhki*729o z>J9mHYRK?39;qD+7c<1JCv+rFDKxFlmDV~FlJ6B$3U(8w)`Fm)%dDE^b?Kav%9c7Z zq@pvmpLtgb5Sff_p~{@I`^}~@o}41Qy6h+a%yR55mrCwZsK}Vq(Pnf=UWA3D9h2{% z9$=|nlqF@E-P>gJdt)-upr;7wZyv0W{cj`{`P2Z*RMaVU#;MfH)Hy5Bo6tD@s1Jhw zb97f-S~&8*nok8R>5c&l!1Q0j&raHm++;)yy@BzCDD;-#C%eq#l!3o+vzI<=>DD-O zr2P{_Lq#FI+f7nBj_!nlZWAw&dy_Z+naPir68&tL!`MN5MoEP9+YY;c1MTguJC;E5 zkarO-NnAuses65?@*wQ2f35lg$R`-|ih99wH!YcaC&1Xw)N2mVwuoJsKB~}JP}AC% zNhBqeNj4r#P0q@NBJGVZ*i^k&$Lv!o_`xz1Xo`Q~o^!e#Qu4~jIeh81I=WSck7P|0 zA^@j|Or_sr(^PLmSAS!o&4`aj$B)(XCT1SKOG(vV?O5_eLb~WY-FhXkATjZp;2uM?;UDOy!wZJ#>GLCw=hZkHc6uM#ETtpw_3Q zu+%*{xO487jp|7MBx*d{OR8lTW*NXJaR9IFx1%a(v?OtOFE|(z)=79n#6|Xl=4=Cu z8{v7j_<=!ffkc*)Ligz5G{R*uU`hur-HP-vT@T}@5}I*{@gI3$ZPf}9RVk(Evwa&F zJf8PoXgYz=ZA$%2Q5ET^Yc*yv;|8K^awZE5i{dU%=XUY>Z3C&`F8ExPO|lLf1SFMvD&bqU=i~o zMV>v@5kffJSuwZWtjR?yCzj>~V}yc9l%mmnX}U>#w-xoDc0ta_+e9$y&t`YJWg##; zFHBBO(k6^LA}ZybFE|3AXS3KZ{~p(4-C!`t!gJ~H{2l(V@_wLn(TjE(aP>8{aFtLX z>VhZ#-gLo^HM*9V%p)3SRzS^gtKTlmebdNbL?)?U$0B)ao@tFo8Wyeg&zh07c@gB> z`(*eUdj;4%c_)%GQcxRd#c~dr`yTZ7OV*QiFKds{Tp2bYX-Dx6$`uPzmPt1=MutGO zqCf4RoeC2tv6yD6)^}<`7o!<%=z5qh4NsJ^vmdA?p#0k-8&zel$W{Q??H}+oAvj=E z=$WNn{^oy$Pzm&Zo1xJRHS8C#f6^7YK49K%gAw&Bg|aqDA~0vDJX5-#6o-z^5=(4< z8ZoJjlby2!R_^143${pBJNLTXZKnO?b*Gihq-1WQF6OT^x2meNvkC`8lTifEPi|lz zL5IBD=6g6d%s>QFu;Ox$Sh$BH{$#?CV^>~Jq&bAMXt{o z-39sO_Hn2&kT3Cjuw`-Xnhkk%rcSM+z-bUDEvk>lt#8F?=NcmGC~i8QDt&u`nAb5v->f%g7$rKoJt+EC0F4 zcve+Iwl&{! zTQ*aNTN+2M{mfHPuPZ2Np>tB1_w#?%FZ48IwT=fE5D*m1fALOI!9oMrPz=#sZPg86 zn&hoU`rt-sr&3VKO{@WS6Bdd>`m~{2;%v@%Z@3mNj*j%<5AmCjtg0-LN0R%-)M!TJ z|;K}oW^ zwx#|wTtvon;6?vNR3l24hZB)m2wxcT9#fwTOwjUXW)Ex=~Rw0%F3-UYI9bDEVq_zh649&XPq1W_`5~I{&$JDO) zh|xn9CVaNZx{65Va_J@Apn96W*l)G`&!<#&c?eHtTAE0x3>dM<{745%-(>S+HyZ*# zjm|iu@X(2TTh6ZkkV5o-NYSH)0BFT!F(Quc(me4H_ByANKtOBRCW>vRRh++FVxm+T z%G#c2s(ozpuyaw1ZHUtVgQWl1o2U0$AV|!6d6%%J=><3-62-Zys&{Roo{qjOFymT;dQmJE{BAu97?ea`3 z%)r0rdCzLQ(jBeP^NK(v6gQ?SS!2fut~HWb>i`w+J@0}n0uRDC0{A<3^3IA`IF>Z) zGcUCt)bRP4dMsfti&%kDoh9_UtI|shH6-y!TjZ&A4EvT*w(NKuaJV`=_EIdNlVgKu zWh9auLwP$E#Ul*{fANn)5W$W^5#e+8H!hX_Zzt2(Vyv-PL z;xCv3L)%P;qHUYxPbkwaCFn{yt^y3G-L~7-{Evp?6(o|nNOC%aA$yH;&C1zk4KYk5 z`_yE4c*$6P0YXtml0MDIa4|L*#t89~XpaIqV7I_BkO6{Qo>6U6^c*R3FC48nuXavK z0}MviMkcRBRsWh)JwI)D73#*Ond{((coqg^e=NM2v)_!FMNKox6Pu_Sa?n1ZsOkAL z;JzajMpIC>B0cPVC-9nijFfKc&D`9DYKLxUhF{&-3OC|kofq*YLdU)lJrQ^`e^)$) zLqJNLH33wkG9}Lg+^D}dpi%obG(Fg#>se{t6=_O+euccG$WTthxz`J|TNlesEh!01 z;7|2S*fUlux|_VnIwSExPDk-I#$6LQkglufzWRDPVwXJL!RTY*jfaaV)aieNW`lnu z_6?(s-3V&}XIr)bm)GTV_rK_Rlt?EW^gC8oAOddsByU4FEzkGj1EKOO<c>$E3w@DvHwNJ!!EN`}3|lslkF0r5#a( zJZ;|S4cAGEMw-M9XPhcE`Nl7!RS9@o8KrtRo&1~Kl_*#)>7*9onBSHG@~Q=sQ7<>@ z5JUt^vC3CK1!`a$mfLiE3Mo7j5l&(fI&0-2hoXZ9?N6!{ROL3v_Fa81C~+t&fIqo) z$c!=#H2YpWRHdUwo-!K0M#48EmFXU!84@gwN%HO zE(&f-;3h0^Nxy>L!i|ouUCibVX;FnBH@gK~K4s>m<$1SDOhi0(eQROjdM5HSv-Gi0 zdt{N~Dpc*k!t6rIkf&Rw>0WE80rCZua7&qHYSF*BVK5R1Mx%J!rO~akM^+t?eKk#f z7&0{?tFf;Gf*t8P0HS58b#G5Oi{&1)*$^j7rb7OK1Ax7gmoJYNkaZI>SB227&N-J~rwFZX6%UQ(U zj&cu|GAQw=<7?9-jNv~Q2zFB6^NSQF3IIRHMcth- zTtC0K46nQQ3eP8wm+4i6m^{X(_MKFhZT7TQeGN1hzGIhdx{eis_bVr(;kEAc={)^i zmN^!$Cb0A$8~w9_b{`je)n1RUJ$v>f%j;C8bO0PX7fb6ELAFl2!nAE^^fz%sj?RC2 ztWRAz4Nn2Cm~*P&dV5z`G}{W1bu)ObQ+e1QnsnEuRIqhku8z7#L4thaz+~l3-mk-+ z@B4RShJt!Gr%c|TN1yNKcXzryzA*7~GqhH&1Rj?seD9{&=uGgk6os3u-VfAd-K((d=QNFmy%{BpID^uFa9)1pwPt)>?2zD-_YNl2n z0-Tmkd6}$7wB7$$C7J(^m6XmuR!#p{N$Fg#$!`2(W%(5#B{OkMPDhoU#md2Lz7YD~ zcLuzcG56*FJiaN#qEWM*GF?Qc5i6_xH+HIs&fSLGw!JQ+>2F^VnVEA^D(Vc9TqX`4 zi{$}9HfuXWZj&|-Tavyk9)Oq8Qfhsxh%Cf8=~#SJcHh+MfaapE`|$<4ee4g&?n^6F|ip<=bsQ3wmnMKR#qSnBjYwF z)A}9HY3wW~^mrK^3v?On&aF1&v;RVYuaSF`SQO&?kd`_lmrnp7;|a<{^rEj<i-9T#P3+iGcdxhig9X_Lgu>>r?O$9e=!I4SON6)@uovVqULQg!kc=Hv;II=h7J z2xw$^l_)Q;GJ%wQ=m-elNom{xq-7hN*Q%tH<42CaRh~GI!d?f z8YX^?*<7}Ljd7$W&&=fG{F9$)O|^KQTck%D*o*milAi+{AdB7S>$UJwk>v+*7}`i{M+BDnInstBmN z?yfH8gFnsi8DFqqqr+rmNTy;*DaS|o7bm`je5RXWt|jt;f}y)f30u3!W(W~+i`Xc9 z-7#FptVKqJM^$}34K51wd>!qF#To4MdcXVJJp%^gFjj8_dOwb?J`D2seZMb$ZsF98 z{F>7+S_uU7J}*WUejX=BTLt`jUcbIhUJU3N{J!sxT4&R0^}k;4woevEcXRnazrP1Z z7dKyO&z-k>ygm>JevT$(0B_6o3VD9-uV<^R1Ur1)pJAm4H-6twSEYdW?Do(5($*iJ zcfi|ZZSUvubIS{XIh?@`;PdvrG|k@N`(gNsI_W`nJ7Cp-JB8$Q=@wj;1t?*W4$G*&9c z0|Oi*<2X-J=h^EEwM=eXM$ea`mpO0$HmJT-U2p@_+-^VM7h5U-72sK~Jg~@g+ym8g zKZCIjLiM+>L1}}vYzl?Q4YpfVIC$fl1obtdYwY;O1bONY)RhK_HX{Slv3{{xN&`4@_pFc3JY^%b_ zsUUbgMGjY9uTg z{&j8mEKBZ9M7GeVP}z0WGhlP&%c+-7(eKWVh11_kf%`j@a)Oi6C8R)m2{JXY6iNc z(vnoc!gG_r#aJ%&_p_*ExG^d7;NE)rD2-wn`85ds&op)rQrR1?wz|FU5H>x;U=0c% zNIL_K*k;Ze?Y-Io__H40Z}9sKYj=R5p^j%}9i0`7*TK*P0YIRo4Op`beG^ozP)R8q zo>P^zv_4aFEx4j$y;&amulu#Tjgj#H*ch(AlrkqmQj-TddAq+*H3+y_I&IYx`%EF- zMV6L{zm$9Cd5tBux~}XUmPY^kpF2F$n5g#Z5~IseN8HTuDh#64MIxEsLq>q9jTqs_ z{&o!i#*q~blu7Lv7+o!l`<1VW#4uou^?FKq6TMbSZ0ig0T`o4Az4T87Q+OZ>s%!{( zZC;pc-RwX7sHN$}DMcq?(tN*v z*qJwOP)y+RPjwNcYZa2eAm`+}DV+viM`(0qf(Ju0$F`!tJTt}BCREi_S-X(Gg|*Rt zY#~bp*KvpfnKE29$ zAvJYDWxb>Q!rI~$Iex}sc8AK){>rt_nIeZiuR)bjeQy>oUR9c_EH%jG_x*I}FHN9Q zab)dw20>gLZ3;WRtgfLq0`FtrN6#NRMkX2cBePR^`WkdAch@s~@NVV7swb*kGw&1nP z3y6ySs?K+rVdOb!JiZ#J`|v$<_ggy7j>$;<+R@+FOC2k{lub%dpt!Ar*2JXa_D@<( z5LqDNZ*B3ZfokHy3L{mgS)XI%-HR~96z$lt4grY%#kw1C29B*DhMiLgg2x!z&{CG4 zE2SS9LAJ;)PzJy2TId@T0f86UecYz>#~Kb`_nJpfdb z?oca0p}{4aF7vXL2HUfIaO5jUZOyqi9zb6G7Z?sf2!w_(FJaYCDP`p@Ja#lc2oW!D z93OBA@7Ujb6et%zG0wSWl#p42gEPQB?cd9EdRv1GA-)FHfVKy=CiG;!iH=-&f{5vf z&6Z04x)*v(b0o;KhE#&RX2C|6f$88g^g5;ATQq#)i==-bBZLNtuMJejMI_)xv%l48 zQyt&#G7Ch;OQ-CJexo&9!@R&BG(}8Ry$!InY?gcLpH01+&JuCCqwQ7^Jv1E<=IlF^ zg+YLE&4Z-Z8+K=`_Jt@Xy)cJ^Q!IySj~!lrMY6gighvy$&(`&tMUh>dl1#7#Q6v2T zWDzNRu~#X+A1^97hO9!bq7(t5?8}ejMKYrhiwg{E9WyXj&FDmWi!Oe=!1sa|prp-> zP^gs~sImZ!5hruUBk&5`I>sfc#sP@Xbyi`#K9$cybTr0fA~9J-Fe#Qwr73lc5ipY0 zR%D4$1Ub>}RH$zgZPg?j_SE}6s|!J4_!Slm2l-fo)d7XwXzTF6>LiVI1wK2`5lcuxmm?vs&2R1Rr0RyEv_5AlM(v%tQx14`V(y2d zSPsC&jfNiQywqh4aV|bGDy--*Nm^-AR1O{NialboIY9xoD!YeGgcfD*b#$X1K_TSM z)8elu=xdXwvmoPxm$`i=okl9L%wJsdlVuM(q=)?rO)-jY|JRg$+j$p>v$*)dL3+~S zZ!$?+R`}jdNRq9q;jiC~BW8e6x{Qgz2s$5*=ebQ`7^}NV&FpDhR1PAl6@GSWFBlIz z8HG|79_#o_leV1KSPK_&D+cc|X-U^~HQQuqIkbUTcoWvAVE>BpfE+d*pBEYRF`p9y zvnb-#U&h@oaZ5<3|3p*%6RmXUm#4Q$yzh-67GdLsr(=(6(NSgV006;6{{;cc`l=d{ zYI)9+S}PwsfxXZI*(5^sSU9s5F&wdh6iYJqxA1YHV zmr&cUVA?3NA@>h$0Fthy{7rF}ApmGH?%U<&-r~@&eSa3!xzC+!lUtWXKL@;}!DS|I zw(pXQP>Y6-G6g^S8e`)07La+#&Z)=Lldxf=FqekWuEXqYmG`pw>Uv)6TbrfE<&oOq z1fZ4ECkrX*^28E8##hM2re5eHZQPtqKCi-aawR(~V#i_10i)1ft&49)EVF2W8YsRL zE->zpX(Ebh5X!YCjtlZQ$g0C+jz9ZqmPRcF;}C${xVu zUX0piJ%ZR~EsoMwn0Wg0J^SN&*W)=3;VSQ%z6lu8_{^7CdC{@?;*!a#bI4V zRocBGJt7FYTwGv_l<%xJta06T@m!1)j@Xg4?N`<{DV#J+kttwX=nANs2PIUAm{bRh+axPCo$ zW*gFq3}P+z#fv)V$%f1cY=ceC_V8kY)sn0;P8?!wo|AYziHKbJgRgNd^}dNUiyIbi zAX?$Br}e`dZE!pL1!Jo&>V1|gGY;6(^X}=o3Asp)6Ouj|@|JAfl(F^@94uTV#9HhxJJ#Thg#T%mbYe6Z$3G`-@xgFSrQ_)DTw&^=4^X$FBV}E2k*zMDiVi6t-l!qk zO!1%zVNHiK>y5s~4~^)MeNo`Km+yk)?&8!$;Pw3X%Y0sl^|wS%*|5;HPaxn7)HV2e z?W>{nw+ndAVne;qw^@sSqYalb6$Y)!SwbqfyiC#TFRF69Q(9LmE)_JSqt1M(Lzjzz zdUoQ8h|cC@%RX}jSy=fN@PU-nv;h}rufGJ8b;BU+eG!i+U_;o?%F5|Ar>^HweFf;P zW-wAU{g6QQT2P^lWuro+VBCPAawye@T*fAps$h8mN3WK>`rvkgr0HKH#Uy)D(inY7 zsk=T1hK3uFsR zM*&QoxuS@R>|v>wyJ?;5rceCe@Ckd>Wc_lRA`}NgB9E{dz}6&!rv=%`g?Ld4UsCtH z9l3vu_jP@1*C#czc@20Oq-Rh?_KMtAC{`3A^NU40i4@GvU7@s;qHg?!4C7dxnWL#h z3LJD;DBO+4)ax)SKD+@x>N<5r03Uc-sk6WksmYswBgEBh?V8P{1g;E3f0HC3Hu$_; zRJ?x0b5wuLTxhZt$aMZ^hsUh`6>Ag}rL!W_#+a<4oZ)+gdR-3rk5~pd`otz1B7r2y z2M>AD0kkL1y}F6NVNjjiiAf8J#woYOaI06lfQt>y8k};HN)>=|hkwpLQ{CX1Hml8A zys1g%e_(cM)#9vRlp_ggy=Vphuq@_ zH$XAurc&DW{3ZTij{iw?g#icb_HQS(ge4Uv-ChrjRX>j~Z+>63Jd;oJom|TO6PWQ& zpgH{ATJ=#qK<+9t=`Nk91-yDwM7FWfFopS;{7?6rDU}*AvIIVoN<>=0v>fRSJ%PEP zlLT`F$@S)DS6Z!>TW1eor8vl6lz}D*kj4ZEd6m|+F1I(-2uL^f*v0axWqO_021{FI5@KAg0`B-PlQP0{sDZ7VCgsPNHo-EV&3Q zVsxSTt!w`57Q>u&-F`EMosvxNPfphh@vk@^DP}`fun>a;#qeP%==6n<$Dyc}Pz?Tu#b`pgm$QRclblS&cCZ_gn z#2?MRi$edp(}6AFcRQhn-GRoL#Qm7x+{kp1cbQosErzN42cy1{D9B^JwW)=I)ahk) zUlh$tn{--Ff_|1!kqypiwR8AIXvFf#O)Y@3d_;nFLH+{1p-XqE6Tj7nS;hLM{r8WZ zfnN!B#}!OUp5I9xJO*YauUurx>kL$ivCB5s&}oM=yZCB1>N_=B;s0{}3gW+~II;LB zi*i2~Kr8D`;w4O%vnFcoQZHPGeKYvLJjOZ_C}TOk3l6N-V&A6Zn<~`~o0kc|OB^g! zngZGDG?dKArF6MiRx(YB%6TWtSyM@GFZ?M8z1Q-4#`Kt2d-Yy|o0`n#NuQVzj22=XO)}c<|8XR=B1{r+6IJ&)eW?NR%Wu zq9`N6K>2HtxjmPtIMJ5|h%9j0SY(~z)lqhqAme&O4-iXd45!{GJzH)o8(k)ndf>oq z?Vu3DuLa@XQihYCMdwb1d=Y8Tifec2i;B@D_{FSW03j%jvb8@5Xd zPqfH6?Tb+&MWggcYkn9Fbr)hpwkUv^XV)M&uSNR#D+ft1qcYi?pGwv)ppPNwJ6wED z+R()tP2MDM|0-l=v!esVC%7{v5)d;cI>|yQq#B_r9d$BFA4Xm5>7Jw;=AFq<5cB#< zX$0YzCe;`f4V^U(NkfIu!KqRE?+BaKQjjeQ2~w8(bdQfN(*` z)O{t%QRZOcU%nW^se&9t9rVU+mIl$b{X+hj!8)O93y6_J^;)E9g4r@@^2(x3Ii0c1 zG8dBk-g=xT!I7_)3N9g}CE~x+>u^IQsoLqN@1C0Aa(1cqK)4^>5^DZzykquk_4cj2 zYxdxlldP0ZrRe}JOb&CN5(tRr0xE$dyyqfbAM{R1nFn3v?N2=Z4!PcKT zyR2&LYt(Z#r6s!`a7h_Blrc`rQC^wy{k1KJ>U0$5k-<2mWg<$|{3LWzc4@h@Rf-yv zmt%*<0NJEr6`cVh;0cbyOruLab3BsX{2xDn&~ zV(_F&a5#3-8+S0lCTI28&yYR8E^M4rV&m~6i%T*y{|2#$i8Y?L3=w|n$M&9|TqW)~ zkdjHk0meO#0=AYAk8muKu?i%S8@Cr=U!sr|Y>;v|wKHsCY{2ax=%$N?cRZ!!1ScW6 zk&XXk=XwR8w(KeOR5C{s%ll%8r>bxeb+)9@a*+lK1(Iydci?X6 ztLN%3z34rOjEh~kK7VoNAS_m^O1CBeuL%h+iRx_M+vNFffAVW{B+Sv`_iSwo^` zlB*&2E}}ooO*~#sJJVAfg|79EA=2j*|so z1#Y^W-C(UZFyRLTBi>pL$rKXRm zMy$lI3%Hx< z0)&miH$p;?bm~nu(_Ygy(h2DC`sEYUO7{7`)s%tbD;OYCfR$~(*FJX0xv1*}07KHV z3jo3;jNMjHCl`JdX>pW@f3tqi(5WjH(`#jBXsliC3^}pvPUXm!C)el4w|b95N#zU_sGvQg`6?T`a2C&(&)UQ`NH#ABGprIuG|L2=UEnPTFb z?00dS_~GtG>`lD~U-q8iX)qaJh;Uher$JrWgFa?pfe48rH)7yv`e=IZRlEGC z_Z;VsgYUzW$gYQKJcmd>=X$bo4sAq1gs=V`RV(iiJFnOb#G`_zZeC!RAO@p;`YXIH z_cWsG%`4+$C74U{OG!WhLCzDhJqi2yQ+L(bI5GvrEg~qgqP7cf4KWvh74J`@w~R#= zP*xJuxT~@VX%!4bgJR+D%(J2WCn;{kfvGt`AdZM96&@9&4>%;!Z8gLEM`2CF#{TKc z=(xk8MK68$*h0ntc$Wyf+v`;_4At{@3qDcv@EN5)!XGH(TykJ51AWz+4h#*$f&Ydu zzU5Dm7illR1vVGJa`3bOOE`qz9+23Fx1;$)0VS|kG52T`}A{9o^hwv;6M!vV;@8BXM14N!MiR@ zCO+%gtiLjxJyj^kbkbSfEq@%+$t1v3@m=u{9xj(0(8F#+bB=l-+XGwt8xa@`eEm`C zhjnc(^c!pRvwT#BsZW@MUMh$M7W%Sm^y^Xr0|4b7oz__M+A-yUqUFkWoh$e9^BWF=9m?3}#oJ42j|%jx&Sx z5|AI0nfJ+yHZ`7yW!_LUdI!q(x28fWJm*AESFv&8u5si}zx!}qB73Q9Ka5X|YMLme zvshZ9cf94;B3Os9Nc9`z2GnoYHL3CWH%f6AGcv>1V$3WkN0EoxUzMT2&OQk~c$dvk*0YiH zjwTNIkRmT~`bId%6-i20y>Ah&h4taha#An16i1=nL=zl8~!UcWS$;-I`(n~vR(`RP*+a?uqZM7TZS_b7q|9w3kxR`v0U>AJq;eJ<8ZS*U{{$N{ zw@OWyPm}6fBCYxOdm%q$hw!SUC9iBs338sWWq^|bY6!;O{xOOIJd0Bk6JVAoel3nL z9+x?!uSFal<3Yaba$nl22(fMF6i?=ePu)w{Ns(%%x&E0`a0xZUSH!XJWIB5R0>7HC z+`y;P=6JEMaAQ^-_nZ_(Rai!(Q2)&7;yfgFR4Et{WsvR9DDNkkhL}trKG7A{H4VG~ z9T90G0U;@m=|7h`c|07}0pe)NmGm6biC^i<6Z@crg_t;`G@Z4R>M#;#NUJVY&96@K z6+Grj6iLklD0ijUjc{+w4OkCDvu4xR}a;C(Cx;J&Ly9ii^6EBSlK%B*0P* z85b@R9qmo_*>l90Kaj)|Ri>C4M&Rsoah}gKtyGx;uTMj^qmpfj05_kq#{d$fQG8@f-43vrxgK*vn@e%Q zz2&K7guMJ!`5c<^0nGx729OjO3>*(S%YLwk)D&~(a10im`Qw8J(dh?wlD5c5vuVl} zq#umLRem^<}~^IccjO<*u@5$Xd~&ohzuqPwQ4iso#M;A zM%S8Ke)Gf$KzoEHrH8l@hS#X0!n;0Uq8%h=ED$K>G=}@{q|)Vc5z2?83JKsrGKr5l zf>li1Pl{<(QM|*QOCo;&=Lssl>%JXnw;lV8FHESCVP26>=DE^}6_S5k(EHYMvm`@u zj|*1dOf4?60B`mw;GyS2R|&{UKm*f%KQE6Bo~qFd(2G8{ebQTB`TNJ%M1B)HO=rr2 ziGt0F=R#vavgng&3;Zj>w;Rtojxg0m-i?72d46uqoxJ6k)@#5me$G?;atWmuX!#Uy zMna8Ls0VWVYv1Z76_V^>BQ#Ogda(!)x%8 zTiM+MK+PY$xtfPix*rK&y1(3_LL?_zNz}thRkqY~B@YVk{rvjztm)A6{rr&kwYuv^ zdsh+nbH5qa`?=lPdj$BoBZz%9YklYc^n0y&2{;=6%_uuDI@DiRI$rFBuXk5A-Gwcn^R2` zK@Z*!B&J1#R~2`YY1g0O~p+CViiS4j?4Z8Ilml8$_ zFqCD&L;%_O@7<^`ZLb0CGnx?-0W9&R&yxU}MW_{?&Hor1tj802OJeIE?qs2GiQx!~ zU|dzDYdYk@j`}>e$$moMh>KC*Tg0X?@XYA5un#3=7iGhSOmngnd5H@ZI|_xEkVFi@KJgEUnBmp;6_ z-Ca-II&WKoIH%U6sNID`?v>TDV$D!MJZU;7(#bF*USenkp5e*3ObK9ZdYypiG%D#Q z*yYeS+S8X5Onr0ce8tG+hxu$_vU`yb=^8HeGOoJs1tKSziCRdtL;%zrc8nmAo?sD$ z5;h$CbGb_tqhJQNn{*53!xT#4d8nWH9|d__TCjZ%hPHL`TlSo}%d}B$A+E8`1w^-K z#kXy&LA{}{fuEp*(JsC5%b2wC;)qmILU%Lr)b?OOzq_tYHy`(**WdC5$ZrM0WUII| zOSl~XB^LvhV6oqYNPsTUCkwRuSk!q+3Iyg6S={sU zvj7VwA=pPor5-cL5;IR?y!4J2vG3EvLXc}Ti!JQPOs6Mq&RC6&EpPM0JLLHothF@e znK~g&Dmn1m`E2EXrWgNbdPTcUpI9SsrZTOtSa}&VkyS8Y&uVaMjS27j_$UTVX1Nb6 z8IuDnPRV703?ZDlUO5gGLJ-_A+i_Hy%TwOacy&b@3b?>0uh7IkMp=qbQ;6L@rp{_~ za;aPvF~IhGkL0dNZXp6ogH?JF(ucKFDdJPHFwr`e&5AzGVcr}+GniHwEhPUOx7#ou z$2N+Hk17d3G^QeCE8hYqL?&27sH8eUft>CyeH>|keqdgc$@*}6A<}H(V!8PLsQRYx zu$!RYMhzP$jcwbuZ8kQWr18J8ZQHh!#5Ag(?yMT zuueQyrRFG+N(bf4EQ1Dvva6UYx5MOBp$<2KoOtUSust(7gQ66{fbYwq2L(>+{(<2- z3QcYDtcNFoF&IWcTQ<|1hNU=M#vYI)|BmVsoN(~8V>~APoP4UY@BP%XY>2C*^fI@dH`Vdoko0y;#xoS78;Rh@8 z8A-q91$UrSg)rIKZ>D_XTgilh=9oBn&fWj-z~Og?pJI6#FSDLLVo4?Ge_y>)dB>B`3Sl?-DNMP~Ga!Y*hq{^~ zb8&g5N8<>rV2LPf!D8h=(0jj|)rC*~gO#KRP9$@6FBxm2Q900+H3h~!D)$|e`foCm z0@@EvO1g+hbx>in8My{qNh{s!;se=tO*ABGZP|^M@KYwwP2a3n$K|dvp&W;_uFO#< z`dZ;tWEI``TIUZmkLKmY(UCICLY?Lh8>5dEbtzPHPH|Q`Lm|;(A67++xqkgp9_aHl z{jAXRmdWTKWOA~94FxcK8-#EC5Tv|hc<4KL&WM{c?e|8rx%M#HEy2_)V+dg{f95CNpa?Jud0^Z0ErZ?)r@}q$Ll4Wl z^2*{Xu;NM99iOzJF2LwV+`$DyaEeOYf*L2jJ|r}hVmR}`F+)gz9qp+4NE083GTNwJ z^c%osoG)IO-UN8Bs7CLhvu0#y=Wt5At`Ig$?^Hn9=%9>{mr#FG${)F=MCaTo<`_!x zo~(~fdrKOFUn1c+ToXD5GN^uzmkV9_b&2Y%a47jo zS|GzwuW(w@HYEk^3v^>g*F;SBa;ri1fen7|SeYuNMSdXXGc}%jYe_}oN{qe_+8&Yj z07-BC7B4|NZ(pz;F7Oh_CEkEhMEpwuAV*cBNiH}XlOW=siP?)a!cFn>t&-|ra8gAo zH3jeALfkUX3Eni7EXH(DvF5;CfQ6O9#DOaNM6d1(S=Dh&T;FaKg{sq6%VJv&@R)98E-uGPfq6VXu%_VM#$XK5lC3xt)LZ~gL9+xMmq zRr+4jYjB^9EtvdAE_Fpo=&ueG7}VV#m>aMgnG%g3Chtdj_g)@NFAr1~&7ZXW4f$8j zNCqfn68aI;-W?%7RNTIvDLvG#1<+O^71b08_(|=pZ}g%j5GAFi6Djrtes9B;alyUH z|0srfgP3cLC(3AVhNrcukmwbB1r`ZM*5@7+l?^ENgKyt8U_$V+k@D`hj8utxSHr|C zsnPjP4to-B%k)|4LFL*z>@Zz3X#5N_^u5+;{EE!%tZCEgkacQ+ly|$nHpui1ngF|B zm%9ebYfM4TRXaI-luJ@_XpnlnD{P=A6U-E*jYl&P@>nxf-F-!xc5f&_Ib5B8Qc=Ig|t@v2l*;%?B(oI|afY|0+Z{i0gsOl%I$ zlLQiwpI4yD%6<(4tgP%A=%cj1v!AHERcO@xEt{`nh5m}$|9vS+-BWPT*j9_Got?h> z=W-K;L3=8g;s$cb!MaKVPh6Z*GUi!U@0vXn#TwH2hfVm>GU%pMj;j@yn7wa0jBMGS zey8SO?mT|n2D|I<=ESI>h36d(cJYtUnSS)BwxzNqcG|cZVD7}9R5V(yNlw>hlF@3p zyxHqMzSWoEx3d_;A$5S36B-vyLbh2&URmThD?W8qF5BWSy`x@$GG`KFU{jo}jYfg) z74Zg|n~o$E6{j)dQJlt#L4_`JnmsUzTH!IUY&0};aR%WxGF+-+&v%ki`{E(Be(B@6 z$%wsal+FAbKzyIc@s;-evc)sp^sXcfvz*c`5XNTB5?;lGS*FF8RN9`V+ESAOZqXZ0^5H|fjB zb+&-N(nq~oY&SqEZ8hE_`DZsx8nl`PA}mQSX1_@<8o19)HVnbKdj~`LjjF6tMiL_% zU-$^<#4%R8l{h{PrLe(9Hp>5w)wt$K6u&n{1h^v@xI5pyIgdmE+hA9z=c zlCkkgg0d9ftdsvDs^6Uy4-xM5qqJeR2eK{B_wFk&l-sj?hqYt{zU(U8Xr`#i>j zq}Z?EP-AxNd%nLLPK_ z?4wU}K`BiW^CB`s`5{-#8nlMpQq=w_w_!S?JY>GUY~u<(^czY98+bNdUBeP_yMj6Y z=}Rna7qG-pLs!$geWrCd{c!4A%K3EVx`@ih(?1kv(&3)Tpy6_-8WECjNcK$-gc0foto$fUdmB!z=cNWaH!b0l;vYHYc`rN?qf2zx?s=& zQxMa%PuK+wdo$eaKT5(DigaXvcre-}Ss3g#U4MOb@sl)HrSmrnM%VZxM!+Z^D55 zv^i00FL+!pJh6$*J#-&4##84(r-< z@(p=GB>h*WSDi~tO~f}3^kIAbGyHRS^G-85Jid)OK)YQ@X4vv(P8Lkp4dh7uG2Ed# z3#7Y7|L2Dj6-tG{dST2+9vTadz?!mDya|m9@#a~owoy)?KW)>5dVaG-Ama9VYoKz& zM4gFuYJV$tqg%TTmW|U}z4Nr!<`y3kGEXd)2Z18KGBt~Fz zGD{aYz>BZu`@V9w*Aw4>A)dgxRw&!2Nd8kC*Dh5IoBV!eL3B~JY_ebbNEmnYx*lKz znIB^J*ac&8HL1nMB1ph)TO?M^Y58`Xujv2sTl9zxp}M*J)y&FuVl^1aPRh&>G2g1) z4;4$-08ZZ6^q1=$cVXtb1>KBhe?jc83P}AFK&ZuRu>*M${#>u>%*|!pYD{;zD#V|` zS_T%4j6+9U0=I)`Pp@ubr^fcN>;)}QV9g?J%1_#!$2lJz4hmhpb1&m@C!_sS4|H&R z{q%hO@r2Xk_v6ld^KHweCp{Cu4x%6Ks#-tn|Dy0DDNcA#{% zuyM$$gWNfl`hMWhae3=}z<~La4qf|YcnWNmJZq0N&fr$Q5sTEACXZpN_&1@#Lujsp zJ&O_9L-f_k8*q=&o z5}co+{JSMh7$t6&&u3lV`dcKMGhe4{0ZA9pF|X zKgqSxFMbZW=Psnfl2t9z3r3a&zZ#G10Q+gvq3Com#*5i({&mRX7|rG%sePiSP$gk% z{^^D-gZe*{FhlP+0X?7~XVJ-ft)}^Qmry{>lp@rR?GH80Dk7z8=a+Ye^hnz*XM|N=q0|ALFHxaKku&~zy0O6?73A+2O+rA5j?A|KRfRGIoP ze7Qdfb26Cyu#@Qr;vou@&ThsVpVN1loiXkpvdf?lW9x+s7g?w-c(gjLek)$L#1W$e zRY0l!^rs{r`3bVkK{4mv4DvSfrb3m3eQi4HIS>;;e*33DoX+d$ zA0x!mdS)KLSxhzq9JYM3MB{&0)3FARfwd(VGd_4=&X%Y zo}DGzr|I%+y1B+1A!Q%~Lj%U6Dg3uTXg1#PaNE%)Ev#SyOWOHc3(-C<4)k9Ra4x|Z z?*Z%rLWTe3Bj_~$Q1vNW>&cV7Hb<>dc*S@D{f} z==J!q>+|V4s0rWu>FW7^;T8VFSeR4MjZ6Ik9gJxWLS=IB zUnYB4D5`dTkIYXW6@H#7^zIxAAbLC!mNKmw4k?g@^rt`5M?dK{o+$cAtmx*v6u%QY*)+ge#5lg~|(X3UZ$ z>a+9W3Qr@ei`yubjY?BP80v@@ZL&U0 z=X`Q2=w2MFE~#-9|BVx}!*o9$pxNbrZb~(DBB*pju6NQ~HThb#oTueYAVnz7k_fpT zvp8@({R$WmLAj%y+WXYw!y!2You=vc*kHuJ*6x9`AGF|)aEjp*Y1h;@?<$=}&^{fi zJxivYcS%o#5$i}SNf9g4n{BWb{_UQ~=IG52)jRHY*!w5H`Fv1Wo|X8=No-CpLeI-Ukz2LH!^|b?ia(UeqRMKgON&>p>h5U zsC9M}jyH(^#df+C)JAcj`u1(UBT4@U2o}KfAJSR8uH6@~(|;(p8lB`J8PNzL#bVs` z7lx@1ZZkW9}qp>vb|CSCbU%j!mZ>#cJy-STUGp?!7)T-_aZh<;ZTwxYn|{1b5i@vl$t za(pl*K1Thhs5eo24k(+xP#f+?*-Jj?7F%4LBAO9`-*y?2w@&0Vkdr+JiV7pnkZ@1p zQZIFoiAJx8e`+0UBI>9{m|{seagFLx7ijZ?4EvfEEbd>g(65o@QO&ip1#l?*MMM?z zHMMl)e7qrG`hJeMrtfR)qajN03J}0YQ?(|7#DanC{L2=NKU|zA!6!h3l#t3}DUg)% zG|^sW*_rzLiQ0%kfEXo}J&;rpU}ruAx>J)bsgmd>D8x(erve7PBl(XSNSBWC>;3?V zquS2{#psNi+)oCk27dq^7QO0aKlB0pF<9c%tP|$L!MBSt^|#A*p8jMV*=R#Ock%nZ z{LFOSUfT{mc?91Abe>?55`JaWTW&%r;=~njXi-IZxk}8%>pD++US22?XgrbF>PWuR zJjSjt(&IkIu2g~?l9ORcUe30__k0-yP{lnz?A73D#2CQ(+-$_uo7@=1{nXOezqW*& z{C@8Y>!DT_0d)DlNwF2LGRtF^hRdZ=<^Q0OM+!63=i=(DmPXllp^W1YY^{l<8b6p# zn7hJEs0(tF339CeFQE?WSw8``=dA&@Tw`oLWwx)yrY!+gWD*oB~_D9L)(>Wk=gV!>hVhJB(Lg?;A|A(vh6ACHuJp3ktA zbgqJZQR1(s1Dyo*6{e>|hAaX3R;P6(l3FPN?!hj|$^A(57 zx44m>QS0InqRWxOi`B|97=vpLSI))_bxnOX)%70_^8Y5$_1v^CSNNb+8*+i~yRu+4 zBi=UHe=RYBS(Ci4?fw9*@2*c5*ZUvm>$lqv+w0p-pKlMl=kG;rMTh!tXV@wW=A0dT zI{bXN9}iD=hfz^YmzfCs>j3{|m#4$i)y>WB?N7Unb`Q_jblwlw$E(@*ULzNe&%&|M zm+^Ca{Lh!06<+V#-Syem!6Nx41iMSU&+Cir^C0=AFGvhM*SDAVbNyNb`YgT=p10-q z-ld+=_ubyp$0|Gh&wcy%@h<%8-K>x6{_Vr@?Rmhv*`t-ay~B%R4ZzvhB%UY||M+Zc zOIm%6`g8ddb=V~T$e+5&kB_&BugA9rA@qKa2}RHGw6V_rcC4@eT=EsOAeld)rD(O)cQb_46(E{psSpCtupi$ZMt{BFDP7$MMr* zW|XZgHT{_Sq;&i>N70fzFiBIjo}!rQGORStYHtrKt6okUF!l1GGvbs5d^Iy^dFHrA zTxyc-2OF5VEZK5Y0h?_?W4(v#N0Nw)`aWqsRPaFAF_;hCW_3>yr^!fjVEz84>8aAsf2d5g;jxMSs(tOe5(h&)2a(`{r-7v#{4z6XV=!2 zb&@GmEtY241pK3&yw z@CL&$?Z9+F`B6|L{lHOk?uc~B0ZaR7Q0w_^&gqHZkHjXp@n83{ar-vP4}Q3`l9ir7 zhk-$szh8lj$Ra7P#*B!LzSaueS$=@NmaxrB?e{#jm)v7TePLiap~4sx6dr9{Gr()! z#aYz})XVY6!URoqL6sC%&7YWtN=IR&r#^Y>_P5O`V=Vf?3kE69`i!807WZUKLC)l9 zd({YXg6czriWT?ILb&zTn!__z(jp6OcpX=$q@QVmOK1veU+fk?H03blJ-?cNehe?hv$yuV3Djg=RQ zr=l@Q)ju#_Z!*1^wN&F&b>kMtk;!jyGsUI*L1@TuDhdDzftFEA%xP_;?qL`xUQ#ZS zV#WZaoz>*ux%?fWFkEFM^}j_msv8`-)!YRm|KML{;^9Lf;bqT@Kql!BHj-O)COW#0 zs=94!C+-I9)0G*C*!e@#4$QzNx@NMQXtJoX#;+^D%${TPo~Gh{x8a_{Lk3FVoNkz~#jjW^m^Sw}*L?XKjXp)e9!%z&v@{3Q zzRejO8T^Ga)NX8$!RP3&NLqs1pGs_~>xDq#(st!w8!@j=cBtQ}SvDbxUlCDQDD7XW zu?QQBe(Jn%=g^rqpTYj^-7KbSM5xl>z$qQV*CSJhE|ucllvlx{US+gLbrW= zui835fOcSHSll`pQKkMEYs_LFEn?e--8i}sp19UHBYq~3tN$u?KW3Nfo-OAM!!zhG zrg{v}kLsgS(j)a{rK;-*GAL}%rt6(H4F+M8q<-%ZU(K!C{1xq-0%iqkE>Z<$24`2t zG>CNB(aUtZfA-3a(5GZw1e3z9KSp(p*NvT+-p?_d{7b?~x%MHR={_+j|K-ODrif*vHUyw7kV z#3^a$nz3lw-dgBSfKG#F@SFk8vs-seka;0rK3o?t88{eWB>*52%5LBUi?oYi{Zj2S zy3SdU{SkKL(K!5_Jh+Hm7=p<(V8I;Y{XHxbY99HH$%M#`L;snpp6sw zwxX*qm1k)^RRykNg1LdCBhdT}_Cdr#W&FwwGT8H`x|E5X`#3gkun}>h(MDj>We9^k zVBXf!1Vwe>(t20jWFUVY4IZZ*((}X60ME$P=Mx4-`$R* zJR=T0kE`ly{vmG0d(v|W zyA?`oi_}=bCac1Vry?UUW2^NTX7z}tbT97a!&CqM4!XyLtrihSY=fy;MeS!MJ;gHa z8ylaXHtAv5dGu}^eC97z_DY@c&ebo>sfgy&420@B@jAvk!JWdkn27xY7z1}p#_Tok zI8_?0+Qh<-Da96-4*VfH7KM

n^Ke-4PHfSP>F74ynUxlom0)EstDbvHPotUY*0I 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

RHQEuedSx&bL=raT>lN$5738TiP_xQ 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 diff --git a/docs/sphinx_setup/_static/benchmarks_files/OV-2024.3-platform_list.pdf b/docs/sphinx_setup/_static/benchmarks_files/OV-2024.3-platform_list.pdf index 09af72d6e37995a633f3aabe7c9f15be6c5f43bb..2de5261f98d5c60cdb275e5ee25c117d20aa2fbb 100644 GIT binary patch delta 89831 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

pb9N1l%vrKEV=f?W>L2 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 diff --git a/docs/sphinx_setup/_static/benchmarks_files/OV-2024.3-system-info-detailed.xlsx b/docs/sphinx_setup/_static/benchmarks_files/OV-2024.3-system-info-detailed.xlsx index ab54576e0099f9c40d23ffaa973f67ccd541ef44..361ec61fe0807ede0b1ba205353e3b5c7a3484f1 100644 GIT binary patch delta 65325 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 delta 65190 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 diff --git a/docs/sphinx_setup/_static/benchmarks_files/OVMS-benchmark-data.csv b/docs/sphinx_setup/_static/benchmarks_files/OVMS-benchmark-data.csv index 3ca1c7cc313491..10f573d9140388 100644 --- a/docs/sphinx_setup/_static/benchmarks_files/OVMS-benchmark-data.csv +++ b/docs/sphinx_setup/_static/benchmarks_files/OVMS-benchmark-data.csv @@ -1,78 +1,78 @@ -Network model,Release,IE-Type,Platform name,Throughput-OVMS-INT8,Throughput-OV-INT8,Throughput-OVMS-FP32,Throughput-OV-FP32, -begin_rec,,,,,,,, -bert-base-cased,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,484.765,486.962,181.829,179.94 -bert-base-cased,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,430.151,434.276,157.835,158.277 -bert-base-cased,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,101.044,102.838,35.727,36.57 -bert-base-cased,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,100.741,103.322,35.046,36.607 -bert-base-cased,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,26.124,26.329,17.155,17.387 -end_rec,,,,,,,, -begin_rec,,,,,,,, -bert-large-uncased,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,41.302,41.994,14.937,14.482 -bert-large-uncased,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,36.595,37.1,13.114,13.03 -bert-large-uncased,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,10.076,10.145,3.267,3.246 -bert-large-uncased,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,10.161,10.203,3.287,3.26 -bert-large-uncased,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,2.422,2.424,1.447,1.427 -end_rec,,,,,,,, -begin_rec,,,,,,,, -Efficientdet-D0,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,433.166,479.055,285.65,287.547 -Efficientdet-D0,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,367.395,407,251.401,257.516 -Efficientdet-D0,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,132.153,149.424,57.682,61.811 -Efficientdet-D0,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,124.984,142.514,50.265,53.089 -Efficientdet-D0,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,47.048,50.328,30.026,31.473 -end_rec,,,,,,,, -begin_rec,,,,,,,, -mask_rcnn_resnet50_atrous_coco,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,6.323,6.488,1.978,1.868 -mask_rcnn_resnet50_atrous_coco,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,5.637,5.742,1.715,1.633 -mask_rcnn_resnet50_atrous_coco,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,1.302,1.276,0.396,0.373 -mask_rcnn_resnet50_atrous_coco,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,1.307,1.28,0.374,0.36 -mask_rcnn_resnet50_atrous_coco,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,0.381,0.35,0.181,0.15 -end_rec,,,,,,,, -begin_rec,,,,,,,, -Mobilenet-V2 ,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,7578.115,12346.3,3354.203,3938.523 -Mobilenet-V2 ,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,7513.034,10367.947,2915.906,3349.306 -Mobilenet-V2 ,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,2152.015,2740.691,745.81,882.839 -Mobilenet-V2 ,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,2093.311,2822.613,667.391,795.616 -Mobilenet-V2 ,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,615.392,719.715,381.686,454.574 -end_rec,,,,,,,, -begin_rec,,,,,,,, -Resnet-50,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,2354.173,2482.832,639.577,645.443 -Resnet-50,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,2070.726,2177.751,571.252,575.778 -Resnet-50,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,440.402,458.622,114.169,116.577 -Resnet-50,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,448.464,470.586,111.785,114.628 -Resnet-50,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,114.267,118.502,57.29,58.233 -end_rec,,,,,,,, -begin_rec,,,,,,,, -SSD-Resnet34-1200 ,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,44.587,47.293,12.111,12.248 -SSD-Resnet34-1200 ,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,38.784,40.602,10.521,10.613 -SSD-Resnet34-1200 ,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,7.736,7.821,2.034,2.011 -SSD-Resnet34-1200 ,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,7.953,8.033,2.083,2.058 -SSD-Resnet34-1200 ,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,1.951,1.936,1.04,1.014 -end_rec,,,,,,,, -begin_rec,,,,,,,, -SSD_Mobilenet_V1_Coco,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,4753.674,4933.241,1370.423,1379.026 -SSD_Mobilenet_V1_Coco,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,4165.318,4276.949,1197.151,1222.112 -SSD_Mobilenet_V1_Coco,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,920.957,1001.56,270.597,281.293 -SSD_Mobilenet_V1_Coco,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,941.323,1030.464,256.649,266.715 -SSD_Mobilenet_V1_Coco,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,256.291,266.245,129.84,135.453 -end_rec,,,,,,,, -begin_rec,,,,,,,, -Unet-Camvid--0001 ,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,73.871,78.016,18.23,18.374 -Unet-Camvid--0001 ,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,64.573,67.713,15.815,16.023 -Unet-Camvid--0001 ,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,12.572,12.669,3.28,3.254 -Unet-Camvid--0001 ,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,12.779,12.894,3.315,3.299 -Unet-Camvid--0001 ,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,2.99,2.971,1.549,1.542 -end_rec,,,,,,,, -begin_rec,,,,,,,, -Yolo_V3_Tiny,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,1863.229,2344.128,775.001,786.09 -Yolo_V3_Tiny,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,1669.35,2066.437,675.625,703.203 -Yolo_V3_Tiny,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,430.441,505.532,146.284,151.09 -Yolo_V3_Tiny,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,419.347,513.112,142.009,148.117 -Yolo_V3_Tiny,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,117.889,133.312,63.598,69.377 -end_rec,,,,,,,, -begin_rec,,,,,,,, -Yolo_V8n,OV-2024.2,xeon,Intel® Xeon® 8260M CPU-only,,705.714,845.484,316.319,388.763 -Yolo_V8n,OV-2024.2,xeon,Intel® Xeon® Gold 6238M CPU-only,,641.815,746.965,278.824,338.806 -Yolo_V8n,OV-2024.2,core,Intel® Core™ i9-11900K CPU-only,,154.54,205.294,67.744,75.634 -Yolo_V8n,OV-2024.2,core,Intel® Core™ i7-11700K CPU-only,,149.289,199.997,65.243,72.677 -Yolo_V8n,OV-2024.2,core,Intel® Core™ i3-10100 CPU-only,,55.999,68.155,34.454,38.544 -end_rec,,,,,,,, \ No newline at end of file +Network model,Release,IE-Type,Platform name,Throughput-OVMS-INT8,Throughput-OV-INT8,Throughput-OVMS-FP32,Throughput-OV-FP32,UOM_T +begin_rec,,,,,,,, +bert-base-cased,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,479.649,482.878,180.7,179.541,FPS +bert-base-cased,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,428.173,430.397,156.73,159.276,FPS +bert-base-cased,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,100.783,101.983,35.711,36.35,FPS +bert-base-cased,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,98.441,102.62,34.303,36.096,FPS +bert-base-cased,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,26.185,26.436,17.108,17.395,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +bert-large-uncased,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,41.872,42.401,14.949,14.473,FPS +bert-large-uncased,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,37.05,37.864,13.075,13.031,FPS +bert-large-uncased,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,10.047,10.111,3.259,3.237,FPS +bert-large-uncased,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,9.961,10.167,3.236,3.224,FPS +bert-large-uncased,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,2.43,2.427,1.447,1.428,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +Efficientdet-D0,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,439.435,485.287,274.772,272.856,FPS +Efficientdet-D0,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,376.1,415.275,253.829,259.188,FPS +Efficientdet-D0,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,131.735,148.558,57.036,59.907,FPS +Efficientdet-D0,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,119.798,140.129,,,FPS +Efficientdet-D0,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,47.382,50.573,30.226,31.492,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +mask_rcnn_resnet50_atrous_coco,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,6.306,6.364,1.96,1.868,FPS +mask_rcnn_resnet50_atrous_coco,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,5.652,5.771,1.714,1.639,FPS +mask_rcnn_resnet50_atrous_coco,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,1.309,1.267,0.396,0.371,FPS +mask_rcnn_resnet50_atrous_coco,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,1.293,1.271,0.355,0.346,FPS +mask_rcnn_resnet50_atrous_coco,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,0.38,0.352,0.182,0.151,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +Mobilenet-V2 ,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,7563.199,12406.597,3336.015,3972.673,FPS +Mobilenet-V2 ,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,7475.62,10373.146,2934.976,3381.725,FPS +Mobilenet-V2 ,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,2158.818,2742.363,740.988,874.037,FPS +Mobilenet-V2 ,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,2042.633,2809.471,631.59,759.984,FPS +Mobilenet-V2 ,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,614.174,718.416,381.882,455.793,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +Resnet-50,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,2356.238,2483.3,628.616,635.411,FPS +Resnet-50,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,2071.836,2202.317,568.945,575.057,FPS +Resnet-50,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,440.533,458.665,113.442,116.116,FPS +Resnet-50,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,441.7,469.848,107.395,113.605,FPS +Resnet-50,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,114.045,118.024,57.165,58.366,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +SSD-Resnet34-1200 ,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,44.499,47.251,12.074,12.167,FPS +SSD-Resnet34-1200 ,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,38.714,40.662,10.504,10.653,FPS +SSD-Resnet34-1200 ,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,7.756,7.818,2.029,2.005,FPS +SSD-Resnet34-1200 ,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,7.929,8.032,2.072,2.054,FPS +SSD-Resnet34-1200 ,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,1.947,1.937,1.037,1.008,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +SSD_Mobilenet_V1_Coco,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,4732.691,4875.291,1362.268,1375.237,FPS +SSD_Mobilenet_V1_Coco,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,4168.575,4279.825,1199.883,1226.189,FPS +SSD_Mobilenet_V1_Coco,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,921.041,1001.672,268.066,280.987,FPS +SSD_Mobilenet_V1_Coco,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,915.4,1028.233,244.534,260.822,FPS +SSD_Mobilenet_V1_Coco,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,256.018,266.401,129.917,135.312,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +Unet-Camvid--0001 ,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,73.429,77.693,18.104,17.938,FPS +Unet-Camvid--0001 ,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,64.29,67.517,15.777,15.927,FPS +Unet-Camvid--0001 ,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,12.574,12.628,3.267,3.253,FPS +Unet-Camvid--0001 ,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,12.718,12.881,3.272,3.297,FPS +Unet-Camvid--0001 ,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,2.995,2.976,1.555,1.53,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +Yolo_V3_Tiny,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,1842.129,2317.052,755.451,777.681,FPS +Yolo_V3_Tiny,OV-2024.3,xeon,Intel® Xeon® Gold 6238M CPU-only,1667.812,2056.27,675.447,704.412,FPS +Yolo_V3_Tiny,OV-2024.3,core,Intel® Core™ i9-11900K CPU-only,431.387,504.093,145.92,151.499,FPS +Yolo_V3_Tiny,OV-2024.3,core,Intel® Core™ i7-11700K CPU-only,409.268,516.794,139.903,147.235,FPS +Yolo_V3_Tiny,OV-2024.3,core,Intel® Core™ i3-10100 CPU-only,117.276,133.578,65.341,69.29,FPS +end_rec,,,,,,,, +begin_rec,,,,,,,, +Yolo_V8n,OV-2024.3,xeon,Intel® Xeon® 8260M CPU-only,,,314.652,386.299,FPS +Yolo_V8n,OV-2024.34,xeon,Intel® Xeon® Gold 6238M CPU-only,,,282.302,340.845,FPS +Yolo_V8n,OV-2024.65,core,Intel® Core™ i9-11900K CPU-only,153.817,204.691,67.421,74.996,FPS +Yolo_V8n,OV-2024.96,core,Intel® Core™ i7-11700K CPU-only,143.19,197.409,62.948,70.913,FPS +Yolo_V8n,OV-2024.127,core,Intel® Core™ i3-10100 CPU-only,56.244,67.968,34.396,38.576,FPS +end_rec,,,,,,,, From 8d112571ff8e4924c92e5b55582851c1316c52c8 Mon Sep 17 00:00:00 2001 From: Piotr Kowalczyk Date: Fri, 23 Aug 2024 13:43:57 +0200 Subject: [PATCH 103/117] [Spec]: Updated bitwise shift operation specification. (#26183) ### Details: - Updated spec of bitwise shift operation for cases where result is undefined. --- .../operation-specs/bitwise/bitwise-left-shift-15.rst | 3 +++ .../operation-specs/bitwise/bitwise-right-shift-15.rst | 3 +++ 2 files changed, 6 insertions(+) diff --git a/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-left-shift-15.rst b/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-left-shift-15.rst index e7116188685024..3e47e835fcdac8 100644 --- a/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-left-shift-15.rst +++ b/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-left-shift-15.rst @@ -25,7 +25,10 @@ After broadcasting input tensors *a* and *b*, *BitwiseLeftShift* performs a bitw .. note:: If the number of shifts is negative, or if it equals or exceeds the total number of bits in the type **T**, the behavior can be undefined or implementation-defined (depends on the hardware). + + Unsigned integer shift is always performed modulo 2^n where n is the number of bits in the type **T**. + When signed integer shift operation overflows (the result does not fit in the result type), the behavior is undefined. **Attributes**: diff --git a/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-right-shift-15.rst b/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-right-shift-15.rst index 5ec3b3768fc23c..6dc3aeb23f7cfd 100644 --- a/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-right-shift-15.rst +++ b/docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/bitwise/bitwise-right-shift-15.rst @@ -26,6 +26,9 @@ After broadcasting input tensors *a* and *b*, *BitwiseRightShift* performs a bit If the number of shifts is negative, or if it equals or exceeds the total number of bits in the type **T**, the behavior can be undefined or implementation-defined (depends on the hardware). + Unsigned integer shift is always performed modulo 2^n where n is the number of bits in the type **T**. + + When signed integer shift operation overflows (the result does not fit in the result type), the behavior is undefined. **Attributes**: From 2cc38fe190a9d0af459b8d9039c00cdb481d1316 Mon Sep 17 00:00:00 2001 From: Katarzyna Mitrus Date: Fri, 23 Aug 2024 13:54:11 +0200 Subject: [PATCH 104/117] [CPU] BitwiseLeftShift & BitwiseRightShift CPU implementation (#26007) ### Details: - BitwiseLeftShift & BitwiseRightShift CPU base implementation - [Update] Added dedicated CPU tests class for BitwiseShift ops to specify data ----------------------------- - Related PR: https://github.com/openvinotoolkit/openvino/pull/25857 ### Tickets: - 148536 --- src/plugins/intel_cpu/src/cpu_types.cpp | 4 + src/plugins/intel_cpu/src/cpu_types.h | 2 + src/plugins/intel_cpu/src/nodes/eltwise.cpp | 35 ++- .../classes/bitwise_shift.cpp | 160 +++++++++++++ .../classes/bitwise_shift.hpp | 39 +++ .../single_layer_tests/classes/eltwise.cpp | 1 + .../instances/common/bitwise_shift.cpp | 222 ++++++++++++++++++ .../single_layer_tests/eltwise.cpp | 53 +++++ .../skip_tests_config.cpp | 2 + .../shared_test_classes/base/utils/ranges.hpp | 2 + .../src/single_op/eltwise.cpp | 8 + .../tensorflow_tests/test_tf_BitwiseShift.py | 6 +- 12 files changed, 527 insertions(+), 7 deletions(-) create mode 100644 src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.cpp create mode 100644 src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.hpp create mode 100644 src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/bitwise_shift.cpp diff --git a/src/plugins/intel_cpu/src/cpu_types.cpp b/src/plugins/intel_cpu/src/cpu_types.cpp index cd6021a40a5a8c..759f771a1f6172 100644 --- a/src/plugins/intel_cpu/src/cpu_types.cpp +++ b/src/plugins/intel_cpu/src/cpu_types.cpp @@ -94,6 +94,8 @@ static const TypeToNameMap& get_type_to_name_tbl() { {"BitwiseNot", Type::Eltwise}, {"BitwiseOr", Type::Eltwise}, {"BitwiseXor", Type::Eltwise}, + {"BitwiseLeftShift", Type::Eltwise}, + {"BitwiseRightShift", Type::Eltwise}, {"Reshape", Type::Reshape}, {"Squeeze", Type::Reshape}, {"Unsqueeze", Type::Reshape}, @@ -445,6 +447,8 @@ std::string algToString(const Algorithm alg) { CASE(EltwiseBitwiseNot); CASE(EltwiseBitwiseOr); CASE(EltwiseBitwiseXor); + CASE(EltwiseBitwiseLeftShift); + CASE(EltwiseBitwiseRightShift); CASE(FQCommon); CASE(FQQuantization); CASE(FQBinarization); diff --git a/src/plugins/intel_cpu/src/cpu_types.h b/src/plugins/intel_cpu/src/cpu_types.h index 6834225c1f2515..6624b21b3e8295 100644 --- a/src/plugins/intel_cpu/src/cpu_types.h +++ b/src/plugins/intel_cpu/src/cpu_types.h @@ -201,6 +201,8 @@ enum class Algorithm { EltwiseBitwiseNot, EltwiseBitwiseOr, EltwiseBitwiseXor, + EltwiseBitwiseLeftShift, + EltwiseBitwiseRightShift, // FakeQuantize algorithms FQCommon, diff --git a/src/plugins/intel_cpu/src/nodes/eltwise.cpp b/src/plugins/intel_cpu/src/nodes/eltwise.cpp index 940185453746eb..1a8986557692a2 100644 --- a/src/plugins/intel_cpu/src/nodes/eltwise.cpp +++ b/src/plugins/intel_cpu/src/nodes/eltwise.cpp @@ -19,8 +19,10 @@ #include "openvino/core/parallel.hpp" #include "openvino/opsets/opset1.hpp" #include "openvino/op/bitwise_and.hpp" +#include "openvino/op/bitwise_left_shift.hpp" #include "openvino/op/bitwise_not.hpp" #include "openvino/op/bitwise_or.hpp" +#include "openvino/op/bitwise_right_shift.hpp" #include "openvino/op/bitwise_xor.hpp" #include "pooling.h" #include "selective_build.h" @@ -1281,6 +1283,12 @@ const std::map& Eltwise::getIn {op::v13::BitwiseXor::get_type_info_static(), [](const std::shared_ptr& op, Eltwise& node) { node.algorithm = Algorithm::EltwiseBitwiseXor; }}, + {op::v15::BitwiseLeftShift::get_type_info_static(), [](const std::shared_ptr& op, Eltwise& node) { + node.algorithm = Algorithm::EltwiseBitwiseLeftShift; + }}, + {op::v15::BitwiseRightShift::get_type_info_static(), [](const std::shared_ptr& op, Eltwise& node) { + node.algorithm = Algorithm::EltwiseBitwiseRightShift; + }}, }; return initializers; } @@ -1965,6 +1973,14 @@ class BitwiseRefExecutor : public EltwiseRefBaseExecutor { *dst_ptr_f = src_f[0] ^ src_f[1]; break; } + case Algorithm::EltwiseBitwiseLeftShift: { + *dst_ptr_f = src_f[0] << src_f[1]; + break; + } + case Algorithm::EltwiseBitwiseRightShift: { + *dst_ptr_f = src_f[0] >> src_f[1]; + break; + } default: OPENVINO_THROW("Unsupported operation type for Eltwise executor"); } @@ -2121,6 +2137,8 @@ size_t Eltwise::getOpInputsNum() const { case Algorithm::EltwiseBitwiseAnd: case Algorithm::EltwiseBitwiseOr: case Algorithm::EltwiseBitwiseXor: + case Algorithm::EltwiseBitwiseLeftShift: + case Algorithm::EltwiseBitwiseRightShift: return 2; case Algorithm::EltwiseBitwiseNot: return 1; @@ -2159,7 +2177,9 @@ void Eltwise::initSupportedPrimitiveDescriptors() { Algorithm::EltwiseBitwiseAnd, Algorithm::EltwiseBitwiseNot, Algorithm::EltwiseBitwiseOr, - Algorithm::EltwiseBitwiseXor); + Algorithm::EltwiseBitwiseXor, + Algorithm::EltwiseBitwiseLeftShift, + Algorithm::EltwiseBitwiseRightShift); }; std::vector supportedPrecisions = isBitwise(algorithm) ? @@ -2190,7 +2210,10 @@ void Eltwise::initSupportedPrimitiveDescriptors() { #else bool canUseOptimizedImpl = mayiuse(x64::sse41) && getInputShapeAtPort(0).getRank() <= MAX_ELTWISE_DIM_RANK; // TODO: Add EltwiseLog algorithm support for JIT implementation - canUseOptimizedImpl &= !one_of(getAlgorithm(), Algorithm::EltwiseLog); + canUseOptimizedImpl &= !one_of(getAlgorithm(), + Algorithm::EltwiseLog, + Algorithm::EltwiseBitwiseLeftShift, + Algorithm::EltwiseBitwiseRightShift); bool canUseOptimizedShapeAgnosticImpl = isDynamicNode() && canUseOptimizedImpl; #endif @@ -3102,13 +3125,17 @@ bool Eltwise::canFuse(const NodePtr& node) const { Algorithm::EltwiseBitwiseAnd, Algorithm::EltwiseBitwiseNot, Algorithm::EltwiseBitwiseOr, - Algorithm::EltwiseBitwiseXor) || + Algorithm::EltwiseBitwiseXor, + Algorithm::EltwiseBitwiseLeftShift, + Algorithm::EltwiseBitwiseRightShift) || one_of(node->getAlgorithm(), Algorithm::EltwiseLog, Algorithm::EltwiseBitwiseAnd, Algorithm::EltwiseBitwiseNot, Algorithm::EltwiseBitwiseOr, - Algorithm::EltwiseBitwiseXor)) { + Algorithm::EltwiseBitwiseXor, + Algorithm::EltwiseBitwiseLeftShift, + Algorithm::EltwiseBitwiseRightShift)) { return false; } diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.cpp new file mode 100644 index 00000000000000..31d922d7d1356e --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.cpp @@ -0,0 +1,160 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "bitwise_shift.hpp" + +#include "common_test_utils/node_builders/constant.hpp" +#include "common_test_utils/node_builders/eltwise.hpp" +#include "gtest/gtest.h" +#include "internal_properties.hpp" +#include "openvino/core/type/element_type.hpp" +#include "openvino/runtime/properties.hpp" +#include "utils/cpu_test_utils.hpp" + +using namespace CPUTestUtils; + +namespace ov { +namespace test { +using ov::test::utils::EltwiseTypes; +using ov::test::utils::InputLayerType; +using ov::test::utils::OpType; + +std::string BitwiseShiftLayerCPUTest::getTestCaseName(testing::TestParamInfo obj) { + EltwiseTestParams basicParamsSet; + CPUSpecificParams cpuParams; + fusingSpecificParams fusingParams; + bool enforceSnippets; + ov::AnyMap val_map; + std::tie(basicParamsSet, cpuParams, fusingParams, enforceSnippets, val_map) = obj.param; + + std::ostringstream result; + result << EltwiseLayerTest::getTestCaseName(testing::TestParamInfo(basicParamsSet, 0)); + result << CPUTestsBase::getTestCaseName(cpuParams); + result << CpuTestWithFusing::getTestCaseName(fusingParams); + result << "_enforceSnippets=" << enforceSnippets; + + return result.str(); +} + +ov::Tensor BitwiseShiftLayerCPUTest::generate_eltwise_input(const ov::element::Type& type, + const ov::Shape& shape, + const size_t in_idx) { + ov::AnyMap any_map = std::get<4>(GetParam()); + const uint32_t max_val = any_map["max_val"].as(); + if (in_idx == 1) { + auto shifts_any = any_map["shift"]; + std::vector shifts_vec = shifts_any.as>(); + shift_const = std::make_shared(type, shape, shifts_vec); + return shift_const->get_tensor_view(); + } + return ov::test::utils::create_and_fill_tensor_consistently(type, shape, max_val + 1, 0, 1); +} + +void BitwiseShiftLayerCPUTest::generate_inputs(const std::vector& targetInputStaticShapes) { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + inputs.insert({funcInput.get_node_shared_ptr(), + generate_eltwise_input(funcInput.get_element_type(), targetInputStaticShapes[i], i)}); + } +} + +void BitwiseShiftLayerCPUTest::SetUp() { + EltwiseTestParams basicParamsSet; + CPUSpecificParams cpuParams; + fusingSpecificParams fusingParams; + bool enforceSnippets; + ov::AnyMap val_map; + std::tie(basicParamsSet, cpuParams, fusingParams, enforceSnippets, val_map) = this->GetParam(); + std::vector shapes; + ElementType netType; + utils::InputLayerType secondaryInputType; + ov::test::utils::OpType opType; + ov::AnyMap additionalConfig; + + std::tie(shapes, + eltwiseType, + secondaryInputType, + opType, + netType, + inType, + outType, + targetDevice, + additionalConfig) = basicParamsSet; + abs_threshold = 0; + + std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; + std::tie(postOpMgrPtr, fusedOps) = fusingParams; + + shapes.resize(2); + switch (opType) { + case ov::test::utils::OpType::SCALAR: { + std::vector identityShapes(shapes[0].second.size(), {1}); + shapes[1] = {{}, identityShapes}; + break; + } + case ov::test::utils::OpType::VECTOR: + if (shapes[1].second.empty()) { + shapes[1] = shapes[0]; + } + break; + default: + FAIL() << "Unsupported Secondary operation type"; + } + + init_input_shapes(shapes); + configuration.insert(additionalConfig.begin(), additionalConfig.end()); + updateSelectedType("ref", netType, configuration); + + if (enforceSnippets) { + configuration.insert(ov::intel_cpu::snippets_mode(ov::intel_cpu::SnippetsMode::IGNORE_CALLBACK)); + } else { + configuration.insert(ov::intel_cpu::snippets_mode(ov::intel_cpu::SnippetsMode::DISABLE)); + } + + ov::ParameterVector parameters{std::make_shared(netType, inputDynamicShapes.front())}; + std::shared_ptr secondaryInput; + switch (secondaryInputType) { + case utils::InputLayerType::PARAMETER: { + auto param = std::make_shared(netType, inputDynamicShapes.back()); + secondaryInput = param; + parameters.push_back(param); + break; + } + case utils::InputLayerType::CONSTANT: { + auto pShape = inputDynamicShapes.back(); + ov::Shape shape; + if (pShape.is_static()) { + shape = pShape.get_shape(); + } else { + ASSERT_TRUE(pShape.rank().is_static()); + shape = std::vector(pShape.rank().get_length(), 1); + for (size_t i = 0; i < pShape.size(); ++i) { + if (pShape[i].is_static()) { + shape[i] = pShape[i].get_length(); + } + } + } + + std::ignore = generate_eltwise_input(netType, shape, 1); + secondaryInput = shift_const; + break; + } + default: { + FAIL() << "Unsupported InputLayerType"; + } + } + + auto eltwise = utils::make_eltwise(parameters[0], secondaryInput, eltwiseType); + function = makeNgraphFunction(netType, parameters, eltwise, "Eltwise"); +} + +TEST_P(BitwiseShiftLayerCPUTest, CompareWithRefs) { + run(); + CheckPluginRelatedResults(compiledModel, std::set{"Eltwise", "Subgraph"}); +} + +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.hpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.hpp new file mode 100644 index 00000000000000..ed68071415077d --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/bitwise_shift.hpp @@ -0,0 +1,39 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include + +#include "common_test_utils/ov_tensor_utils.hpp" +#include "eltwise.hpp" +#include "shared_test_classes/base/ov_subgraph.hpp" +#include "shared_test_classes/single_op/eltwise.hpp" +#include "utils/cpu_test_utils.hpp" +#include "utils/fusing_test_utils.hpp" + +using namespace CPUTestUtils; + +namespace ov { +namespace test { + +typedef std::tuple + BitshiftLayerCPUTestParamsSet; + +class BitwiseShiftLayerCPUTest : public testing::WithParamInterface, + virtual public SubgraphBaseTest, + public CPUTestUtils::CpuTestWithFusing { +public: + static std::string getTestCaseName(testing::TestParamInfo obj); + + ov::Tensor generate_eltwise_input(const ov::element::Type& type, const ov::Shape& shape, size_t in_idx = 0); + void generate_inputs(const std::vector& targetInputStaticShapes) override; + void SetUp() override; + +private: + utils::EltwiseTypes eltwiseType; + std::shared_ptr shift_const; +}; +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp index 8541928c244cd1..d7cfe80d22f617 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/eltwise.cpp @@ -106,6 +106,7 @@ ov::Tensor EltwiseLayerCPUTest::generate_eltwise_input(const ov::element::Type& break; } } + ov::test::utils::InputGenerateData in_data; in_data.start_from = params.start_from; in_data.range = params.range; diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/bitwise_shift.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/bitwise_shift.cpp new file mode 100644 index 00000000000000..db1f59195abed7 --- /dev/null +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/bitwise_shift.cpp @@ -0,0 +1,222 @@ +// Copyright (C) 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "custom/single_layer_tests/classes/bitwise_shift.hpp" + +#include "custom/single_layer_tests/classes/eltwise.hpp" +#include "utils/cpu_test_utils.hpp" +#include "utils/filter_cpu_info.hpp" +#include "utils/fusing_test_utils.hpp" + +using namespace CPUTestUtils; + +namespace ov { +namespace test { +namespace Eltwise { + +std::vector shift_1{1}; +uint32_t max_val = 3; +auto val_map_1_2 = ov::AnyMap{{"shift", shift_1}, {"max_val", max_val}}; + +static const std::vector> bitwise_in_shapes_4D = { + {{{-1, -1, -1, -1}, {{1, 3, 2, 2}, {1, 3, 1, 1}}}, {{1, 3, 2, 2}, {{1, 3, 2, 2}}}}, + {{{-1, -1, -1, -1}, {{2, 64, 2, 2}, {1, 64, 1, 1}}}, {{1, 64, 2, 2}, {{1, 64, 2, 2}}}}, +}; + +const auto params_4D_bitwise_shift = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(bitwise_in_shapes_4D), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::ValuesIn(secondaryInputTypes()), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i8, ov::element::Type_t::u8, ov::element::Type_t::i32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::ValuesIn( + {CPUSpecificParams({nhwc, nhwc}, {nhwc}, {}, "ref"), CPUSpecificParams({nchw, nchw}, {nchw}, {}, "ref")}), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_1_2)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_4D_BitwiseShift, + BitwiseShiftLayerCPUTest, + params_4D_bitwise_shift, + BitwiseShiftLayerCPUTest::getTestCaseName); + +const auto params_4D_bitwise_shift_i32_cast = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(bitwise_in_shapes_4D), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::ValuesIn(secondaryInputTypes()), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i16, ov::element::Type_t::u16, ov::element::Type_t::u32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::ValuesIn({CPUSpecificParams({nhwc, nhwc}, {nhwc}, {}, "ref_I32$/"), + CPUSpecificParams({nchw, nchw}, {nchw}, {}, "ref_I32$/")}), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_1_2)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_4D_BitwiseShift_i32_cast, + BitwiseShiftLayerCPUTest, + params_4D_bitwise_shift_i32_cast, + BitwiseShiftLayerCPUTest::getTestCaseName); + +std::vector shift_14{15}; +uint32_t max_val_63 = 63; +auto val_map_overflow_cast = ov::AnyMap{{"shift", shift_14}, {"max_val", max_val_63}}; + +const auto params_4D_bitwise_shift_overflow_i32_cast = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(bitwise_in_shapes_4D), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::ValuesIn(secondaryInputTypes()), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn( + {ov::element::Type_t::i16, ov::element::Type_t::u16, ov::element::Type_t::u32, ov::element::Type_t::i32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::ValuesIn({CPUSpecificParams({nhwc, nhwc}, {nhwc}, {}, "ref_I32$/"), + CPUSpecificParams({nchw, nchw}, {nchw}, {}, "ref_I32$/")}), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_overflow_cast)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_4D_BitwiseShift_overflow_i32_cast, + BitwiseShiftLayerCPUTest, + params_4D_bitwise_shift_overflow_i32_cast, + BitwiseShiftLayerCPUTest::getTestCaseName); + +std::vector shift_7{7}; +uint32_t max_val_15 = 15; +auto val_map_overflow_8_cast = ov::AnyMap{{"shift", shift_7}, {"max_val", max_val_15}}; + +const auto params_4D_bitwise_shift_overflow_8 = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(bitwise_in_shapes_4D), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::ValuesIn(secondaryInputTypes()), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i8, ov::element::Type_t::u8}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::ValuesIn( + {CPUSpecificParams({nhwc, nhwc}, {nhwc}, {}, "ref"), CPUSpecificParams({nchw, nchw}, {nchw}, {}, "ref")}), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_overflow_8_cast)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_4D_BitwiseShift_overflow_8, + BitwiseShiftLayerCPUTest, + params_4D_bitwise_shift_overflow_8, + BitwiseShiftLayerCPUTest::getTestCaseName); + +std::vector multi_shift_5{0, 1, 2, 3, 4}; +uint32_t max_val_7 = 7; +auto val_map_multi_shift_5 = ov::AnyMap{{"shift", multi_shift_5}, {"max_val", max_val_7}}; + +static const std::vector> bitwise_in_shapes_5D_1D = { + {{2, 17, 8, 4, 5}, {5}}, +}; + +const auto params_5D_1D_bitwise_shift = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(bitwise_in_shapes_5D_1D)), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::Values(ov::test::utils::InputLayerType::PARAMETER), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i8, ov::element::Type_t::u8, ov::element::Type_t::i32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::Values(CPUSpecificParams({ncdhw, x}, {ncdhw}, {}, {})), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_multi_shift_5)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_5D_1D_BitwiseShift, + BitwiseShiftLayerCPUTest, + params_5D_1D_bitwise_shift, + BitwiseShiftLayerCPUTest::getTestCaseName); + +const auto params_5D_1D_bitwise_shift_cast_i32 = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(bitwise_in_shapes_5D_1D)), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::Values(ov::test::utils::InputLayerType::PARAMETER), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i16, ov::element::Type_t::u16, ov::element::Type_t::u32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::Values(CPUSpecificParams({ncdhw, x}, {ncdhw}, {}, "ref_I32$/")), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_multi_shift_5)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_5D_1D_BitwiseShift_cast_i32, + BitwiseShiftLayerCPUTest, + params_5D_1D_bitwise_shift_cast_i32, + BitwiseShiftLayerCPUTest::getTestCaseName); + +static const std::vector> bitwise_in_shapes_4D_1D = { + {{2, 3, 4, 5}, {5}}, +}; + +const auto params_4D_1D_bitwise_shift = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(bitwise_in_shapes_4D_1D)), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::Values(ov::test::utils::InputLayerType::PARAMETER), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i8, ov::element::Type_t::u8, ov::element::Type_t::i32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::Values(CPUSpecificParams({nchw, x}, {nchw}, {}, {})), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_multi_shift_5)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_4D_1D_BitwiseShift, + BitwiseShiftLayerCPUTest, + params_4D_1D_bitwise_shift, + BitwiseShiftLayerCPUTest::getTestCaseName); + +const auto params_4D_1D_bitwise_shift_cast_i32 = ::testing::Combine( + ::testing::Combine( + ::testing::ValuesIn(static_shapes_to_test_representation(bitwise_in_shapes_4D_1D)), + ::testing::ValuesIn({ov::test::utils::EltwiseTypes::LEFT_SHIFT, ov::test::utils::EltwiseTypes::RIGHT_SHIFT}), + ::testing::Values(ov::test::utils::InputLayerType::PARAMETER), + ::testing::ValuesIn({ov::test::utils::OpType::VECTOR}), + ::testing::ValuesIn({ov::element::Type_t::i16, ov::element::Type_t::u16, ov::element::Type_t::u32}), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::element::Type_t::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(ov::AnyMap())), + ::testing::Values(CPUSpecificParams({nchw, x}, {nchw}, {}, "ref_I32$/")), + ::testing::Values(emptyFusingSpec), + ::testing::Values(false), + ::testing::Values(val_map_multi_shift_5)); + +INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs_4D_1D_BitwiseShift_cast_i32, + BitwiseShiftLayerCPUTest, + params_4D_1D_bitwise_shift_cast_i32, + BitwiseShiftLayerCPUTest::getTestCaseName); + +} // namespace Eltwise +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp index d524266cb97470..8f1ae45ad3bd03 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp @@ -90,6 +90,11 @@ std::vector eltwise_op_types_dynamic = { EltwiseTypes::POWER, }; +std::vector bitshift_types = { + EltwiseTypes::LEFT_SHIFT, + EltwiseTypes::RIGHT_SHIFT +}; + ov::test::Config additional_config = {}; const auto multiply_params = ::testing::Combine( @@ -176,5 +181,53 @@ const auto single_thread_params = ::testing::Combine( INSTANTIATE_TEST_SUITE_P(smoke_SingleThread, EltwiseLayerTest, single_thread_params, EltwiseLayerTest::getTestCaseName); +std::vector intOnly_netPrecisions = { + ov::element::i32, + ov::element::i8, + ov::element::u8, + ov::element::u16, + ov::element::i16, + ov::element::u32, +}; + +std::vector> in_shapes_static_small_set = { + {{2}}, + {{2, 10}, {1}}, + {{4, 3, 8}, {1, 8}}, + {{2, 7, 5, 4}, {1, 7, 1, 1}}, + {{1, 7, 5, 1}, {2, 7, 1, 4}}, +}; + +const auto bitwise_shift_params_static = ::testing::Combine( + ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(in_shapes_static_small_set)), + ::testing::ValuesIn(bitshift_types), + ::testing::ValuesIn(secondary_input_types), + ::testing::ValuesIn(op_types_dynamic), + ::testing::ValuesIn(intOnly_netPrecisions), + ::testing::Values(ov::element::undefined), + ::testing::Values(ov::element::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(additional_config)); + +INSTANTIATE_TEST_SUITE_P(smoke_shared_CompareWithRefs_BitwiseShift_Static, + EltwiseLayerTest, + bitwise_shift_params_static, + EltwiseLayerTest::getTestCaseName); + +const auto bitwise_shift_params_dynamic = ::testing::Combine( + ::testing::ValuesIn(in_shapes_dynamic), + ::testing::ValuesIn(bitshift_types), + ::testing::ValuesIn(secondary_input_types_dynamic), + ::testing::ValuesIn(op_types_dynamic), + ::testing::ValuesIn(intOnly_netPrecisions), + ::testing::Values(ov::element::undefined), + ::testing::Values(ov::element::undefined), + ::testing::Values(ov::test::utils::DEVICE_CPU), + ::testing::Values(additional_config)); + +INSTANTIATE_TEST_SUITE_P(smoke_shared_CompareWithRefs_BitwiseShift_Dynamic, + EltwiseLayerTest, + bitwise_shift_params_dynamic, + EltwiseLayerTest::getTestCaseName); } // namespace diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp index 50fab4febfa150..7f26517360bb16 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp @@ -308,6 +308,8 @@ std::vector disabledTestPatterns() { R"(.*smoke_TestsROIAlign.*)", // Issue: 148527 R"(.*Snippets.*MatMulTransposeB.*i8.*i8.*)", + // Issue: 136881 + R"(.*smoke_CompareWithRefs_4D_BitwiseShift_overflow_i32_cast.*_eltwise_op_type=BitwiseLeft.*_model_type=.*(i16|u16).*)", }; // fp32 floor for bf16 models: conversion issue diff --git a/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp b/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp index e57803f3add6a6..188b72ecbef530 100644 --- a/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp +++ b/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp @@ -238,6 +238,8 @@ static std::map inputRanges = { {ov::op::v1::Add::get_type_info_static(), Range({{0, 15}}, {{0, 8, 32}})}, {ov::op::v15::ROIAlignRotated::get_type_info_static(), Range({{0, 15}}, {{0, 8, 32}})}, {ov::op::v1::BatchToSpace::get_type_info_static(), Range({{0, 15}}, {{0, 8, 32}})}, + {ov::op::v15::BitwiseLeftShift::get_type_info_static(), Range({{0, 5}, {0, 4}}, {})}, + {ov::op::v15::BitwiseRightShift::get_type_info_static(), Range({{0, 5}, {0, 4}}, {})}, }; class ModelRange { diff --git a/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp b/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp index 359782bf3173be..b62f1c5e369037 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp @@ -123,6 +123,14 @@ void EltwiseLayerTest::SetUp() { secondary_input = std::make_shared(tensor); break; } + case EltwiseTypes::LEFT_SHIFT: + case EltwiseTypes::RIGHT_SHIFT: { + in_data.start_from = 0; + in_data.range = 4; + auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data); + secondary_input = std::make_shared(tensor); + break; + } default: { in_data.start_from = 1; in_data.range = 9; diff --git a/tests/layer_tests/tensorflow_tests/test_tf_BitwiseShift.py b/tests/layer_tests/tensorflow_tests/test_tf_BitwiseShift.py index 1f4aee829652d3..cfef63bcc58f6f 100644 --- a/tests/layer_tests/tensorflow_tests/test_tf_BitwiseShift.py +++ b/tests/layer_tests/tensorflow_tests/test_tf_BitwiseShift.py @@ -61,15 +61,15 @@ def create_bitwise_net(self, x_shape, y_shape, is_y_const, input_type, op_type): @pytest.mark.parametrize('x_shape', [[4], [3, 4], [1, 2, 3, 4]]) @pytest.mark.parametrize('y_shape', [[1], [4], [2, 3, 4]]) @pytest.mark.parametrize('is_y_const', [True, False]) - # Element types supported by evaluate, to be updated with further enablement - @pytest.mark.parametrize('input_type', [np.int32]) + @pytest.mark.parametrize('input_type', [np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64]) @pytest.mark.parametrize("op_type", ['RightShift', 'LeftShift']) @pytest.mark.precommit @pytest.mark.nightly def test_bitwise(self, x_shape, y_shape, is_y_const, input_type, op_type, ie_device, precision, ir_version, temp_dir, use_legacy_frontend): if ie_device == 'GPU': - pytest.skip("148540: Bitwise ops are not supported on GPU") + pytest.skip("149424: Bitwise ops are not supported on GPU") if use_legacy_frontend: pytest.skip("BitwiseShift ops are supported only by new TF FE") self._test(*self.create_bitwise_net(x_shape=x_shape, y_shape=y_shape, is_y_const=is_y_const, From fa2d87aab6a304bd70680fce336d2f1ae9ca3797 Mon Sep 17 00:00:00 2001 From: Nikolay Shchegolev Date: Fri, 23 Aug 2024 16:11:44 +0400 Subject: [PATCH 105/117] [CPU] Weights hash mismatch (#26023) ### Details: - *'DnnlExtensionUtils::computeWeightsStringHash' taking into account the raw pointers, but it does not work for internal blobs. Need to estimate blob content to get right hash.* ### Tickets: - *CVS-148943* --- .../intel_cpu/src/dnnl_extension_utils.cpp | 4 +- .../intel_cpu/src/dnnl_extension_utils.h | 4 +- src/plugins/intel_cpu/src/node.h | 2 +- .../src/nodes/executors/dnnl/dnnl_utils.cpp | 3 +- src/plugins/intel_cpu/src/nodes/rnn.cpp | 299 +++++++++++------- src/plugins/intel_cpu/src/nodes/rnn.h | 23 +- 6 files changed, 210 insertions(+), 125 deletions(-) diff --git a/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp b/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp index 6b2c83ecc5d8cb..ca5e6ab6c1438a 100644 --- a/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp +++ b/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp @@ -266,8 +266,8 @@ bool DnnlExtensionUtils::isUnarySupportedAsPostOp(Algorithm alg) { #endif } -std::string DnnlExtensionUtils::computeWeightsStringHash(const std::shared_ptr memory, - const std::shared_ptr dstDesc) { +std::string DnnlExtensionUtils::computeWeightsStringHash(const std::shared_ptr& memory, + const std::shared_ptr& dstDesc) { const auto desc_hash = dnnl::impl::primitive_hashing::get_md_hash(*dstDesc->getDnnlDesc().get()); return std::to_string(desc_hash) + "_" + std::to_string(reinterpret_cast(memory->getData())); } diff --git a/src/plugins/intel_cpu/src/dnnl_extension_utils.h b/src/plugins/intel_cpu/src/dnnl_extension_utils.h index cdc6342e8963fd..7a968ea3c71c3d 100644 --- a/src/plugins/intel_cpu/src/dnnl_extension_utils.h +++ b/src/plugins/intel_cpu/src/dnnl_extension_utils.h @@ -102,13 +102,15 @@ class DnnlExtensionUtils { static dnnl_memory_desc_t clone_desc(const_dnnl_memory_desc_t cdesc); static const char* query_pd_info(const_dnnl_primitive_desc_t pd); static bool isUnarySupportedAsPostOp(Algorithm alg); + /** * @brief Computes weights string hash based on weights memory and requested descriptor * @param memory Weights memory pointer * @param dstDesc descriptor defining weights representation after repacking * @return string hash */ - static std::string computeWeightsStringHash(const std::shared_ptr memory, const std::shared_ptr dstDesc); + static std::string computeWeightsStringHash(const std::shared_ptr& memory, + const std::shared_ptr& dstDesc); }; } // namespace intel_cpu diff --git a/src/plugins/intel_cpu/src/node.h b/src/plugins/intel_cpu/src/node.h index f3eb606bf3e322..a336e45c020d8a 100644 --- a/src/plugins/intel_cpu/src/node.h +++ b/src/plugins/intel_cpu/src/node.h @@ -737,7 +737,7 @@ class Node { impl_desc_type implType); void prepareMemory(const std::vector& intDescs); - void prepareMemory(const DnnlMemoryDescPtr& intDesc, size_t indx); + virtual void prepareMemory(const DnnlMemoryDescPtr& intDesc, size_t indx); void prepareMemory(dnnl::primitive_desc_iterator& itpd); MemoryPtr prepareWeightMemory(DnnlMemoryDescPtr dstWeightDesc, DnnlMemoryDescPtr srcWeightDesc = nullptr); diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp index bdcece78b28fa6..fa273ac3d6c3ff 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp @@ -81,8 +81,7 @@ MemoryPtr prepareWeightsMemory(const DnnlMemoryDescPtr srcWeightDesc, MemoryPtr ptr; if (globalWeightCache && dnnl::memory::format_kind::blocked == dstWeightDesc->getDnnlDesc().get_format_kind()) { - const auto string_hash = DnnlExtensionUtils::computeWeightsStringHash(weightsMem, dstWeightDesc); - ptr = *globalWeightCache->findOrCreate(string_hash, create); + ptr = *globalWeightCache->findOrCreate(DnnlExtensionUtils::computeWeightsStringHash(weightsMem, dstWeightDesc), create); } else { ptr = create(); } diff --git a/src/plugins/intel_cpu/src/nodes/rnn.cpp b/src/plugins/intel_cpu/src/nodes/rnn.cpp index 40c61e2a2b0737..221549234072bb 100644 --- a/src/plugins/intel_cpu/src/nodes/rnn.cpp +++ b/src/plugins/intel_cpu/src/nodes/rnn.cpp @@ -3,31 +3,24 @@ // #include "rnn.h" -#include "utils/general_utils.h" -#include "nodes/common/cpu_memcpy.h" -#include "nodes/common/cpu_convert.h" -#include "input.h" -#include "dnnl_extension_utils.h" -#include "memory_desc/dnnl_blocked_memory_desc.h" -#include "memory_desc/cpu_memory_desc_utils.h" + #include "common/primitive_hashing_utils.hpp" -#include +#include "memory_desc/cpu_memory_desc_utils.h" +#include "nodes/common/cpu_convert.h" +#include "nodes/common/cpu_memcpy.h" +#include "nodes/input.h" +#include "nodes/reorder.h" +#include "openvino/core/parallel.hpp" #include "shape_inference/shape_inference_ngraph.hpp" #include "transformations/utils/utils.hpp" #include "ov_ops/augru_cell.hpp" #include "ov_ops/augru_sequence.hpp" - #include "openvino/op/gru_cell.hpp" #include "openvino/op/gru_sequence.hpp" #include "openvino/op/lstm_sequence.hpp" #include "openvino/op/rnn_cell.hpp" #include "openvino/op/rnn_sequence.hpp" -#include "openvino/core/node.hpp" - -#include -#include -#include using namespace dnnl; @@ -768,75 +761,116 @@ void RNN::fillSequenceDesc() { createDescriptor(inCandidate, outCandidate); } -template -void RNN::fillWeights(const int *gate_map, const size_t wIdx, const size_t rIdx) { - const auto& weightPrec = DnnlExtensionUtils::DataTypeToElementType(inDataTypes[wIdx]); - const auto& targetWeightDataType = weightsByinputDataType.at(inDataTypes[xIdx]); - const auto& targetWeightPrec = DnnlExtensionUtils::DataTypeToElementType(targetWeightDataType); - - // create weight blobs (data and state part) - const VectorDims dims_w = {L, D, DC, G, SC}; - auto w_data_desc = DnnlBlockedMemoryDesc(Shape(dims_w), targetWeightDataType, getWeightsFormatTagByDims(dims_w)); - MemoryPtr w_data_mem = std::make_shared(getEngine(), w_data_desc); - auto w_ptr = static_cast(w_data_mem->getData()); - - if (w_ptr == nullptr) - THROW_CPU_NODE_ERR("has unallocated internal blob."); - - const VectorDims dims_s = {L, D, SC, G, SC}; - auto w_state_desc = DnnlBlockedMemoryDesc(Shape(dims_s), targetWeightDataType, getWeightsFormatTagByDims(dims_s)); - MemoryPtr w_state_mem = std::make_shared(getEngine(), w_state_desc); - auto r_ptr = static_cast(w_state_mem->getData()); - if (r_ptr == nullptr) - THROW_CPU_NODE_ERR("has unallocated internal blob."); - - const size_t ie_w_vec_size = getInputShapeAtPort(wIdx).getElementsCount(); - const size_t ie_r_vec_size = getInputShapeAtPort(rIdx).getElementsCount(); - +template +void RNN::fillWeights() { + using DataType = typename element_type_traits::value_type; if (getParentEdgeAt(wIdx)->getParent()->getType() != Type::Input) { THROW_CPU_NODE_ERR("expects Constant for port ", wIdx); } - auto wConstBlob = static_cast(getParentEdgeAt(wIdx)->getParent().get())->getMemoryPtr(); - + auto w_const_blob = static_cast(getParentEdgeAt(wIdx)->getParent().get())->getMemoryPtr(); if (getParentEdgeAt(rIdx)->getParent()->getType() != Type::Input) { THROW_CPU_NODE_ERR("expects Constant for port ", rIdx); } - auto rConstBlob = static_cast(getParentEdgeAt(rIdx)->getParent().get())->getMemoryPtr(); + auto r_const_blob = static_cast(getParentEdgeAt(rIdx)->getParent().get())->getMemoryPtr(); - std::vector ie_w_vec(ie_w_vec_size), ie_r_vec(ie_r_vec_size); + const auto& weightPrec = DnnlExtensionUtils::DataTypeToElementType(inDataTypes[wIdx]); + const auto& targetWeightDataType = weightsByinputDataType.at(inDataTypes[xIdx]); + const auto& targetWeightPrec = DnnlExtensionUtils::DataTypeToElementType(targetWeightDataType); - auto ie_w_ptr = ie_w_vec.data(); - auto ie_r_ptr = ie_r_vec.data(); + const VectorDims dims_w = {L, D, DC, G, SC}; + auto w_data_desc = std::make_shared(Shape(dims_w), targetWeightDataType, getWeightsFormatTagByDims(dims_w)); - cpu_convert(wConstBlob->getData(), ie_w_ptr, weightPrec, targetWeightPrec, ie_w_vec_size); - cpu_convert(rConstBlob->getData(), ie_r_ptr, weightPrec, targetWeightPrec, ie_r_vec_size); + auto create_w = [&]() { + MemoryPtr w_data_mem = std::make_shared(getEngine(), w_data_desc); + auto w_ptr = reinterpret_cast(w_data_mem->getData()); + if (w_ptr == nullptr) { + THROW_CPU_NODE_ERR("has unallocated internal blob."); + } + std::vector ie_w_vec; + DataType* ie_w_ptr = nullptr; - const int step = SC * G; + if (weightPrec != targetWeightPrec) { + const size_t ie_w_vec_size = getInputShapeAtPort(wIdx).getElementsCount(); + ie_w_vec.resize(ie_w_vec_size); + ie_w_ptr = ie_w_vec.data(); - for (size_t g = 0; g < G; g++) { - for (size_t out_i = 0; out_i < SC; out_i++) { - Prec *l_w_ptr = w_ptr + gate_map[g] * SC + out_i; + cpu_convert(w_const_blob->getData(), ie_w_ptr, weightPrec, targetWeightPrec, ie_w_vec_size); + } else { + ie_w_ptr = reinterpret_cast(w_const_blob->getData()); + } + + const uint64_t step = SC * G; + const uint64_t SC_DC = SC * DC; + parallel_for2d(G, SC, [&](size_t g, size_t out_i) { + DataType* l_w_ptr = w_ptr + m_gate_map[g] * SC + out_i; + DataType* s_w_ptr = ie_w_ptr + out_i * DC + g * SC_DC; for (size_t in_i = 0; in_i < DC; in_i++) { - *l_w_ptr = *ie_w_ptr; - ie_w_ptr++; + *l_w_ptr = *s_w_ptr; + s_w_ptr++; l_w_ptr += step; } + }); + + return w_data_mem; + }; + + const VectorDims dims_s = {L, D, SC, G, SC}; + auto w_state_desc = std::make_shared(Shape(dims_s), targetWeightDataType, getWeightsFormatTagByDims(dims_s)); + + auto create_r = [&]() { + MemoryPtr w_state_mem = std::make_shared(getEngine(), w_state_desc); + auto r_ptr = reinterpret_cast(w_state_mem->getData()); + if (r_ptr == nullptr) { + THROW_CPU_NODE_ERR("has unallocated internal blob."); + } + std::vector ie_r_vec; + DataType* ie_r_ptr = nullptr; + + if (weightPrec != targetWeightPrec) { + const size_t ie_r_vec_size = getInputShapeAtPort(rIdx).getElementsCount(); + ie_r_vec.resize(ie_r_vec_size); + ie_r_ptr = ie_r_vec.data(); - Prec *l_r_ptr = r_ptr + gate_map[g] * SC + out_i; + cpu_convert(r_const_blob->getData(), ie_r_ptr, weightPrec, targetWeightPrec, ie_r_vec_size); + } else { + ie_r_ptr = reinterpret_cast(r_const_blob->getData()); + } + + const uint64_t step = SC * G; + const uint64_t SC_2 = SC * SC; + parallel_for2d(G, SC, [&](size_t g, size_t out_i) { + DataType* l_r_ptr = r_ptr + m_gate_map[g] * SC + out_i; + DataType* s_r_ptr = ie_r_ptr + out_i * SC + g * SC_2; for (size_t in_i = 0; in_i < SC; in_i++) { - *l_r_ptr = *ie_r_ptr; - ie_r_ptr++; + *l_r_ptr = *s_r_ptr; + s_r_ptr++; l_r_ptr += step; } - } + }); + + return w_state_mem; + }; + + if (auto weight_cache = context->getWeightsCache()) { + const std::string hash_w = getName() + "_0_" + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_data_desc->getDnnlDesc().get())); + m_initial_weights[0] = *weight_cache->findOrCreate(hash_w, create_w); + + const std::string hash_r = getName() + "_1_" + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_state_desc->getDnnlDesc().get())); + m_initial_weights[1] = *weight_cache->findOrCreate(hash_r, create_r); + } else { + m_initial_weights[0] = create_w(); + m_initial_weights[1] = create_r(); } - internalBlobs.push_back(w_data_mem); - internalBlobs.push_back(w_state_mem); } -template -void RNN::fillBiases(const int *gate_map) { - using dataType = typename element_type_traits::value_type; +template +void RNN::fillBiases() { + using DataType = typename element_type_traits::value_type; + + if (getParentEdgeAt(bIdx)->getParent()->getType() != Type::Input) { + THROW_CPU_NODE_ERR("expects Constant for port ", bIdx); + } + auto b_const_blob = static_cast(getParentEdgeAt(bIdx)->getParent().get())->getMemoryPtr(); if (inDataTypes[bIdx] != memory::data_type::f32) { THROW_CPU_NODE_ERR("doesn't support bias data type: ", DnnlExtensionUtils::DataTypeToElementType(inDataTypes[bIdx])); @@ -844,31 +878,70 @@ void RNN::fillBiases(const int *gate_map) { VectorDims dims_b = { L, D, Gb, SC }; - auto _data_type = DnnlExtensionUtils::ElementTypeToDataType(Prec); - auto w_bias_data_desc = DnnlBlockedMemoryDesc(Shape(dims_b), _data_type, getWeightsFormatTagByDims(dims_b)); - MemoryPtr w_bias_data_mem = std::make_shared(getEngine(), w_bias_data_desc); - auto b_ptr = static_cast(w_bias_data_mem->getData()); - if (b_ptr == nullptr) - THROW_CPU_NODE_ERR("has unallocated internal blob."); - - auto *constInputNode = dynamic_cast(getParentEdgeAt(bIdx)->getParent().get()); - auto constBlob = constInputNode->getMemoryPtr(); - auto const elementsCount = constBlob->getSize() / constBlob->getDesc().getPrecision().size(); - - std::vector ie_b_vec(elementsCount); - cpu_convert(constBlob->getData(), - &ie_b_vec[0], - DnnlExtensionUtils::DataTypeToElementType(constBlob->getDataType()), - Prec, - elementsCount); - - for (size_t g = 0; g < Gb; g++) { - dataType *l_b_ptr = b_ptr + gate_map[g] * SC; - const dataType *l_ie_b_ptr = &ie_b_vec[g * SC]; - cpu_memcpy(l_b_ptr, l_ie_b_ptr, SC * sizeof(typename element_type_traits::value_type)); + auto dnnl_type = DnnlExtensionUtils::ElementTypeToDataType(ET); + auto w_bias_data_desc = std::make_shared(Shape(dims_b), dnnl_type, getWeightsFormatTagByDims(dims_b)); + + auto create = [&]() { + MemoryPtr w_bias_data_mem = std::make_shared(getEngine(), w_bias_data_desc); + auto b_ptr = reinterpret_cast(w_bias_data_mem->getData()); + if (b_ptr == nullptr) { + THROW_CPU_NODE_ERR("has unallocated internal blob."); + } + + std::vector ie_b_vec; + DataType* ie_b_ptr = nullptr; + + if (dnnl_type != b_const_blob->getDataType()) { + const size_t ie_b_vec_size = getInputShapeAtPort(bIdx).getElementsCount(); + ie_b_vec.resize(ie_b_vec_size); + ie_b_ptr = ie_b_vec.data(); + + cpu_convert(b_const_blob->getData(), ie_b_ptr, DnnlExtensionUtils::DataTypeToElementType(b_const_blob->getDataType()), ET, ie_b_vec_size); + } else { + ie_b_ptr = reinterpret_cast(b_const_blob->getData()); + } + + const uint64_t step = SC * sizeof(DataType); + parallel_for(Gb, [&](size_t g) { + DataType* l_b_ptr = b_ptr + m_gate_map[g] * SC; + const DataType* l_ie_b_ptr = ie_b_ptr + g * SC; + cpu_memcpy(l_b_ptr, l_ie_b_ptr, step); + }); + + return w_bias_data_mem; + }; + + if (auto weight_cache = context->getWeightsCache()) { + const std::string hash_str = getName() + "_2_" + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_bias_data_desc->getDnnlDesc().get())); + m_initial_weights[2] = *weight_cache->findOrCreate(hash_str, create); + } else { + m_initial_weights[2] = create(); + } +} + +void RNN::prepareMemory(const DnnlMemoryDescPtr& new_desc, size_t idx) { + if (idx >= 3lu) { + THROW_CPU_NODE_ERR("got invalid weights index: ", idx); + } + + auto create = [&]() { + Memory memory{getEngine(), m_initial_weights[idx]->getDescPtr(), m_initial_weights[idx]->getData()}; + MemoryPtr res_ptr = std::make_shared(getEngine(), new_desc); + node::Reorder::reorderData(memory, *res_ptr, context->getParamsCache()); + return res_ptr; + }; + + MemoryPtr res_ptr; + if (auto weight_cache = context->getWeightsCache()) { + const std::string hash_str = getName() + "_" + std::to_string(idx) + "_" + + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*new_desc->getDnnlDesc().get())); + res_ptr = *weight_cache->findOrCreate(hash_str, create); + m_weights_pull.insert(res_ptr); + } else { + res_ptr = create(); } - // @todo replace push_back with copy assignment by index, since order matters - internalBlobs.push_back(w_bias_data_mem); + + internalBlobMemory[idx] = res_ptr; } void RNN::copyWeightsData() { @@ -891,52 +964,58 @@ void RNN::copyWeightsData() { * ====== GRU ====== * OV - URO, onednn - URO */ - const int gate_map_lstm[] = {1, 0, 2, 3}; // FICO -> IFCO - const int gate_map_gru[] = {0, 1, 2, 3}; - const int gate_map_rnn[] = {0}; - const int *gate_map; - const int gate_map_lstm_size = sizeof(gate_map_lstm) / sizeof(int); - const int gate_map_gru_size = sizeof(gate_map_gru) / sizeof(int); - const int gate_map_rnn_size = sizeof(gate_map_rnn) / sizeof(int); + static const uint64_t gate_map_lstm[] = {1, 0, 2, 3}; // FICO -> IFCO + static const uint64_t gate_map_gru[] = {0, 1, 2, 3}; + static const uint64_t gate_map_rnn[] = {0}; + const uint64_t gate_map_lstm_size = sizeof(gate_map_lstm) / sizeof(uint64_t); + const uint64_t gate_map_gru_size = sizeof(gate_map_gru) / sizeof(uint64_t); + const uint64_t gate_map_rnn_size = sizeof(gate_map_rnn) / sizeof(uint64_t); if (cell_type == dnnl::algorithm::vanilla_lstm) { - gate_map = gate_map_lstm; + m_gate_map = gate_map_lstm; if (G > gate_map_lstm_size) { THROW_CPU_NODE_ERR(". G isn't equal to the size of gate_map."); } } else if (cell_type == dnnl::algorithm::vanilla_gru || cell_type == dnnl::algorithm::vanilla_augru) { - gate_map = gate_map_gru; + m_gate_map = gate_map_gru; if (G > gate_map_gru_size) { THROW_CPU_NODE_ERR(". G isn't equal to the size of gate_map"); } } else if (cell_type == dnnl::algorithm::lbr_gru || cell_type == dnnl::algorithm::lbr_augru) { - gate_map = gate_map_gru; + m_gate_map = gate_map_gru; if (G > gate_map_gru_size) { THROW_CPU_NODE_ERR(". G isn't equal to the size of gate_map."); } } else if (cell_type == dnnl::algorithm::vanilla_rnn) { - gate_map = gate_map_rnn; + m_gate_map = gate_map_rnn; if (G > gate_map_rnn_size) { THROW_CPU_NODE_ERR(". G isn't equal to the size of gate_map."); } } else { - gate_map = gate_map_gru; + m_gate_map = gate_map_gru; if (G > gate_map_gru_size) { THROW_CPU_NODE_ERR(". G isn't equal to the size of gate_map."); } } - const auto& dataType = inDataTypes[xIdx]; - if (one_of(dataType, memory::data_type::bf16, memory::data_type::f16)) { - fillWeights(gate_map, wIdx, rIdx); - } else if (dataType == memory::data_type::f32) { - fillWeights(gate_map, wIdx, rIdx); - } else if (dataType == memory::data_type::u8 || dataType == memory::data_type::s8) { - fillWeights(gate_map, wIdx, rIdx); - } else { - THROW_CPU_NODE_ERR("has unsupported data type: ", DnnlExtensionUtils::DataTypeToElementType(dataType)); + switch (inDataTypes[xIdx]) { + case memory::data_type::bf16: + case memory::data_type::f16: + fillWeights(); + break; + case memory::data_type::f32: + fillWeights(); + break; + case memory::data_type::u8: + case memory::data_type::s8: + fillWeights(); + break; + default: + THROW_CPU_NODE_ERR("has unsupported data type: ", DnnlExtensionUtils::DataTypeToElementType(inDataTypes[xIdx])); } - fillBiases(gate_map); + fillBiases(); + + internalBlobMemory.resize(3); } namespace { @@ -1253,7 +1332,9 @@ void RNN::executeDynamicImpl(dnnl::stream strm) { void RNN::cleanup() { if (!isDynamicNode()) { - internalBlobs.clear(); + m_initial_weights[0].reset(); + m_initial_weights[1].reset(); + m_initial_weights[2].reset(); } for (auto it : fusedWith) { diff --git a/src/plugins/intel_cpu/src/nodes/rnn.h b/src/plugins/intel_cpu/src/nodes/rnn.h index 2ee4c6c9341915..937a67f5f1fd5a 100644 --- a/src/plugins/intel_cpu/src/nodes/rnn.h +++ b/src/plugins/intel_cpu/src/nodes/rnn.h @@ -4,14 +4,10 @@ #pragma once -#include +#include "node.h" +#include "common/dnnl_executor.h" #include "memory_desc/dnnl_blocked_memory_desc.h" -#include -#include -#include - -#include "common/dnnl_executor.h" namespace ov { namespace intel_cpu { @@ -61,13 +57,14 @@ class RNN : public Node { bool verifyWeightsPrecision(const ov::element::Type& layerPrec, const ov::element::Type& weightsPrec); - template - void fillWeights(const int* gate_map, const size_t wIdx, const size_t rIdx); - template - void fillBiases(const int* gate_map); + template + void fillWeights(); + template + void fillBiases(); void copyWeightsData(); + void prepareMemory(const DnnlMemoryDescPtr& intDesc, size_t indx) override; class RnnDnnlExecutor : public DnnlExecutor { public: RnnDnnlExecutor(const dnnl::primitive_desc& pd); @@ -161,6 +158,12 @@ class RNN : public Node { float inputScale = 0.f; float inputShift = 0.f; std::vector weightsScales; + + const uint64_t* m_gate_map; + // Need to reorder from the initial memory descs due to limited Reorders set. + MemoryPtr m_initial_weights[3] = { nullptr, nullptr, nullptr }; + // Need to keep cache objects. Otherwise, they will be erased from the global cache. + std::unordered_set m_weights_pull; }; } // namespace node From 6a87630e023240ca87eec645ac4948c9a039030c Mon Sep 17 00:00:00 2001 From: Jorge Ragde Date: Fri, 23 Aug 2024 05:12:15 -0700 Subject: [PATCH 106/117] [ARM][CPU] Implement LogicalNot JIT Emitter for ARM64 SIMD in OpenVino (#24809) ### Details: - *Added LogicalNot JIT Emitter* ### Tickets: - *Closes #24445 ([Implement CPU plugin just-in-time emitter for LogicalNot operation](https://github.com/openvinotoolkit/openvino/issues/24445))* --- .../plugin/aarch64/jit_eltwise_emitters.cpp | 64 ++++++++++++++++++- .../plugin/aarch64/jit_eltwise_emitters.hpp | 30 ++++++++- .../nodes/executors/aarch64/jit_eltwise.cpp | 1 + .../aarch64/jit_uni_eltwise_generic.cpp | 2 + .../single_layer_tests/classes/activation.cpp | 5 ++ .../single_layer_tests/activation.cpp | 1 + .../single_op/activation.hpp | 1 + .../include/common_test_utils/test_enums.hpp | 1 + .../src/node_builders/activation.cpp | 3 + 9 files changed, 106 insertions(+), 2 deletions(-) diff --git a/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.cpp index 3d29173788d658..4a1e1b429cee7c 100644 --- a/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.cpp +++ b/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.cpp @@ -1031,6 +1031,68 @@ void jit_is_nan_emitter::register_table_entries() { push_arg_entry_of("zero", 0x00000000, true); } +/// LOGICAL_NOT /// +jit_logical_not_emitter::jit_logical_not_emitter(dnnl::impl::cpu::aarch64::jit_generator* host, + dnnl::impl::cpu::aarch64::cpu_isa_t host_isa, + const std::shared_ptr& node) + : jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) { + prepare_table(); + } + +jit_logical_not_emitter::jit_logical_not_emitter(dnnl::impl::cpu::aarch64::jit_generator* host, + dnnl::impl::cpu::aarch64::cpu_isa_t host_isa, + const ov::element::Type exec_prc) + : jit_emitter(host, host_isa, exec_prc) { + prepare_table(); + } + +size_t jit_logical_not_emitter::get_inputs_count() const { + return 1; +} + +size_t jit_logical_not_emitter::get_aux_vecs_count() const { + return 1; +} + +size_t jit_logical_not_emitter::get_aux_gprs_count() const { + return 1; +} + +void jit_logical_not_emitter::emit_impl(const std::vector& in_vec_idxs, + const std::vector& out_vec_idxs) const { + if (host_isa_ == dnnl::impl::cpu::aarch64::asimd) { + emit_isa(in_vec_idxs, out_vec_idxs); + } else { + OV_CPU_JIT_EMITTER_THROW("Can't create jit eltwise kernel"); + } +} + +template +void jit_logical_not_emitter::emit_isa(const std::vector& in_vec_idxs, + const std::vector& out_vec_idxs) const { + OV_CPU_JIT_EMITTER_ASSERT(exec_prc_ == ov::element::f32, "unsupported precision: " + exec_prc_.to_string()); + + using TReg = typename dnnl::impl::cpu::aarch64::cpu_isa_traits::TReg; + TReg src = TReg(in_vec_idxs[0]); + TReg dst = TReg(out_vec_idxs[0]); + TReg tmp1 = TReg(aux_vec_idxs[0]); + + h->eor(tmp1.b16, tmp1.b16, tmp1.b16); + h->fcmeq(tmp1.s, tmp1.s, src.s); + h->ld1r(dst.s, table_val2("one")); + h->and_(dst.b16, dst.b16, tmp1.b16); +} + +void jit_logical_not_emitter::register_table_entries() { + // Registers constant values that comply with the IEEE 754 standard. + push_arg_entry_of("one", 0x3f800000, true); +} + +std::set> jit_logical_not_emitter::get_supported_precisions( + const std::shared_ptr& node) { + return {{element::f32}}; +} + /// MAX /// jit_maximum_emitter::jit_maximum_emitter(dnnl::impl::cpu::aarch64::jit_generator* host, dnnl::impl::cpu::aarch64::cpu_isa_t host_isa, @@ -1905,4 +1967,4 @@ std::set> jit_tanh_emitter::get_supported_precisions( } // namespace aarch64 } // namespace intel_cpu -} // namespace ov +} // namespace ov \ No newline at end of file diff --git a/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.hpp index 0152a5bd3d99e1..6b4d201d5fe99e 100644 --- a/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.hpp +++ b/src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.hpp @@ -465,6 +465,34 @@ class jit_is_inf_emitter : public jit_emitter { bool detect_positive; }; +class jit_logical_not_emitter : public jit_emitter { +public: + jit_logical_not_emitter(dnnl::impl::cpu::aarch64::jit_generator* host, + dnnl::impl::cpu::aarch64::cpu_isa_t host_isa, + const ov::element::Type exec_prc = ov::element::f32); + + jit_logical_not_emitter(dnnl::impl::cpu::aarch64::jit_generator* host, + dnnl::impl::cpu::aarch64::cpu_isa_t host_isa, + const std::shared_ptr& node); + + size_t get_inputs_count() const override; + + size_t get_aux_vecs_count() const override; + + size_t get_aux_gprs_count() const override; + + static std::set> get_supported_precisions( + const std::shared_ptr& node = nullptr); + +private: + void emit_impl(const std::vector& in_vec_idxs, const std::vector& out_vec_idxs) const override; + + template + void emit_isa(const std::vector& in_vec_idxs, const std::vector& out_vec_idxs) const; + + void register_table_entries() override; +}; + class jit_mod_emitter : public jit_emitter { public: jit_mod_emitter(dnnl::impl::cpu::aarch64::jit_generator *host, @@ -754,4 +782,4 @@ class jit_tanh_emitter : public jit_emitter { } // namespace aarch64 } // namespace intel_cpu -} // namespace ov +} // namespace ov \ No newline at end of file diff --git a/src/plugins/intel_cpu/src/nodes/executors/aarch64/jit_eltwise.cpp b/src/plugins/intel_cpu/src/nodes/executors/aarch64/jit_eltwise.cpp index c82d0a459314a8..d8d33163c1febe 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/aarch64/jit_eltwise.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/aarch64/jit_eltwise.cpp @@ -32,6 +32,7 @@ bool JitEltwiseExecutor::isSupported( Algorithm::EltwiseIsFinite, Algorithm::EltwiseIsInf, Algorithm::EltwiseIsNaN, + Algorithm::EltwiseLogicalNot, Algorithm::EltwiseMaximum, Algorithm::EltwiseMinimum, Algorithm::EltwiseMish, diff --git a/src/plugins/intel_cpu/src/nodes/kernels/aarch64/jit_uni_eltwise_generic.cpp b/src/plugins/intel_cpu/src/nodes/kernels/aarch64/jit_uni_eltwise_generic.cpp index f05081c0a03e99..34e9af7feeaf44 100644 --- a/src/plugins/intel_cpu/src/nodes/kernels/aarch64/jit_uni_eltwise_generic.cpp +++ b/src/plugins/intel_cpu/src/nodes/kernels/aarch64/jit_uni_eltwise_generic.cpp @@ -651,6 +651,7 @@ std::shared_ptr jit_uni_eltwise_generic::create_eltwise_emitte OV_CASE(Algorithm::EltwiseHswish, ov::intel_cpu::aarch64::jit_hswish_emitter), OV_CASE(Algorithm::EltwiseIsFinite, ov::intel_cpu::aarch64::jit_is_finite_emitter), OV_CASE(Algorithm::EltwiseIsInf, ov::intel_cpu::aarch64::jit_is_inf_emitter), + OV_CASE(Algorithm::EltwiseLogicalNot, ov::intel_cpu::aarch64::jit_logical_not_emitter), OV_CASE(Algorithm::EltwiseIsNaN, ov::intel_cpu::aarch64::jit_is_nan_emitter), OV_CASE(Algorithm::EltwiseMaximum, ov::intel_cpu::aarch64::jit_maximum_emitter), OV_CASE(Algorithm::EltwiseMinimum, ov::intel_cpu::aarch64::jit_minimum_emitter), @@ -827,6 +828,7 @@ std::set> eltwise_precision_helper::get_supported_pre OV_CASE(Algorithm::EltwiseIsFinite, jit_is_finite_emitter), OV_CASE(Algorithm::EltwiseIsInf, jit_is_inf_emitter), OV_CASE(Algorithm::EltwiseIsNaN, jit_is_nan_emitter), + OV_CASE(Algorithm::EltwiseLogicalNot, jit_logical_not_emitter), OV_CASE(Algorithm::EltwiseMaximum, jit_maximum_emitter), OV_CASE(Algorithm::EltwiseMinimum, jit_minimum_emitter), OV_CASE(Algorithm::EltwiseMish, jit_mish_emitter), diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp index 4d47eb9ed2b78b..e563a89e3106ec 100644 --- a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp +++ b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp @@ -76,6 +76,10 @@ void ActivationLayerCPUTest::generate_inputs(const std::vector& targe startFrom = -1; range = 2; resolution = 128; + } else if (activationType == utils::ActivationTypes::LogicalNot) { + startFrom = 0; + range = 2; + resolution = 1; } else { startFrom = 0; range = 15; @@ -189,6 +193,7 @@ std::string ActivationLayerCPUTest::getPrimitiveType(const utils::ActivationType (activation_type == utils::ActivationTypes::Relu) || (activation_type == utils::ActivationTypes::Sigmoid) || (activation_type == utils::ActivationTypes::Swish) || + (activation_type == utils::ActivationTypes::LogicalNot) || (activation_type == utils::ActivationTypes::Tanh))) { return "jit"; } diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/activation.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/activation.cpp index ff91ef9321a99b..54165df77d4dfb 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/activation.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/activation.cpp @@ -58,6 +58,7 @@ const std::map>> activationTypes {ActivationTypes::IsFinite, {}}, {ActivationTypes::IsInf, {}}, {ActivationTypes::IsNaN, {{}}}, + {ActivationTypes::LogicalNot, {}}, }; // List of operations that should be tested also with integer precision diff --git a/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/activation.hpp b/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/activation.hpp index 5f3369495889ac..ceafc663d245de 100644 --- a/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/activation.hpp +++ b/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/activation.hpp @@ -70,6 +70,7 @@ static std::map activationNames = { {ActivationTypes::IsInf, "IsInf"}, {ActivationTypes::IsFinite, "IsFinite"}, {ActivationTypes::IsNaN, "IsNaN"}, + {ActivationTypes::LogicalNot, "LogicalNot"}, }; typedef std::tuple< diff --git a/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp b/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp index 8a7fe4fec02874..cf791e04e3c2a0 100644 --- a/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp +++ b/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp @@ -119,6 +119,7 @@ enum ActivationTypes { SoftPlus, Swish, HSigmoid, + LogicalNot, RoundHalfToEven, RoundHalfAwayFromZero, GeluErf, diff --git a/src/tests/test_utils/common_test_utils/src/node_builders/activation.cpp b/src/tests/test_utils/common_test_utils/src/node_builders/activation.cpp index dd4440df190574..a1c3387dce704f 100644 --- a/src/tests/test_utils/common_test_utils/src/node_builders/activation.cpp +++ b/src/tests/test_utils/common_test_utils/src/node_builders/activation.cpp @@ -28,6 +28,7 @@ #include "openvino/op/is_inf.hpp" #include "openvino/op/is_nan.hpp" #include "openvino/op/log.hpp" +#include "openvino/op/logical_not.hpp" #include "openvino/op/mish.hpp" #include "openvino/op/negative.hpp" #include "openvino/op/parameter.hpp" @@ -153,6 +154,8 @@ std::shared_ptr make_activation(const ov::Output& in, return std::make_shared(in); case ov::test::utils::ActivationTypes::IsNaN: return std::make_shared(in); + case ov::test::utils::ActivationTypes::LogicalNot: + return std::make_shared(in); default: OPENVINO_THROW("Can't create layer for this activation type"); } From c3d953bf1a5db7e2f3dada5118963256231d16a4 Mon Sep 17 00:00:00 2001 From: Sergey Shlyapnikov Date: Fri, 23 Aug 2024 16:12:43 +0400 Subject: [PATCH 107/117] [GPU] Extend RemoteTensor API (#26038) The idea of these changes is to allow more flexible interaction between remote tensors and host tensors, enabling the implementation of features like swap_blocks in vLLM ### Details: - Made `ITensor::copy_to()` function virtual to allow proper underlying implementation call of `copy_to()` for ov::Tensor - Added `copy_to(const std::shared_ptr& dst)` and `copy_from(const std::shared_ptr& src)` functions to `IRemoteTensor` class, and pure virtual functions `copy_to(const std::shared_ptr& dst, size_t src_offset, size_t dst_offset, ov::Shape roi_shape)` and `copy_from(const std::shared_ptr& src, size_t src_offset, size_t dst_offset, ov::Shape roi_shape)`, which are supposed to be defined in the RemoteTensor implementation itself - Allowed RemoteTensor as dst argument for `ITensor::copy_to()` with a corresponding redirecting `IRemoteTensor::copy_from()` call - Added `RoiRemoteTensor` to implement region-specific copying for remote tensors - Added `copy_to(ov::Tensor& dst)` and `copy_from(ov::Tensor& src)` to `ov::RemoteTensor` class, allowing to interact with any host tensors, remote tensors, ROI remote tensors - Refactored `copy_to()` / `copy_from()` methods of `ocl_memory` class ### Tickets: - *ticket-id* --- .../src/pyopenvino/core/remote_tensor.cpp | 92 ++++- .../python/src/pyopenvino/core/tensor.cpp | 43 +- .../tests/test_runtime/test_remote_api.py | 146 ++++++- src/core/dev_api/openvino/runtime/itensor.hpp | 2 +- src/core/src/runtime/itensor.cpp | 8 +- .../openvino/runtime/iremote_tensor.hpp | 18 + .../openvino/runtime/remote_tensor.hpp | 25 +- src/inference/src/cpp/remote_tensor.cpp | 58 +-- src/inference/src/dev/make_tensor.cpp | 148 +++++-- .../include/intel_gpu/plugin/common_utils.hpp | 2 +- .../intel_gpu/plugin/remote_context.hpp | 1 - .../intel_gpu/plugin/remote_tensor.hpp | 3 + .../include/intel_gpu/primitives/data.hpp | 6 +- .../include/intel_gpu/runtime/memory.hpp | 56 ++- .../intel_gpu/src/plugin/common_utils.cpp | 12 +- .../intel_gpu/src/plugin/remote_tensor.cpp | 200 +++++++++- .../src/plugin/sync_infer_request.cpp | 100 +++-- .../intel_gpu/src/runtime/ocl/ocl_memory.cpp | 369 ++++++++---------- .../intel_gpu/src/runtime/ocl/ocl_memory.hpp | 21 +- .../intel_gpu/tests/functional/CMakeLists.txt | 1 + .../gpu_remote_tensor_tests.cpp | 335 ++++++++++++++++ .../unit/module_tests/usm_memory_test.cpp | 249 +++++++----- 22 files changed, 1457 insertions(+), 438 deletions(-) diff --git a/src/bindings/python/src/pyopenvino/core/remote_tensor.cpp b/src/bindings/python/src/pyopenvino/core/remote_tensor.cpp index 141e1eaa39c47d..26658c62140228 100644 --- a/src/bindings/python/src/pyopenvino/core/remote_tensor.cpp +++ b/src/bindings/python/src/pyopenvino/core/remote_tensor.cpp @@ -14,6 +14,23 @@ namespace py = pybind11; void regclass_RemoteTensor(py::module m) { py::class_> cls(m, "RemoteTensor"); + cls.def(py::init([](RemoteTensorWrapper& tensor_wrapper, ov::Coordinate& begin, ov::Coordinate& end) { + return RemoteTensorWrapper(ov::RemoteTensor(tensor_wrapper.tensor, begin, end)); + }), + py::arg("remote_tensor"), + py::arg("begin"), + py::arg("end"), + R"( + Constructs a RoiRemoteTensor object using a specified range of coordinates on an existing RemoteTensor. + + :param remote_tensor: The RemoteTensor object on which the RoiRemoteTensor will be based. + :type remote_tensor: openvino.RemoteTensor + :param begin: The starting coordinates for the tensor bound. + :type begin: openvino.runtime.Coordinate + :param end: The ending coordinates for the tensor bound. + :type end: openvino.runtime.Coordinate + )"); + cls.def( "get_device_name", [](RemoteTensorWrapper& self) { @@ -44,13 +61,82 @@ void regclass_RemoteTensor(py::module m) { cls.def( "copy_to", - [](RemoteTensorWrapper& self, py::object& dst) { - Common::utils::raise_not_implemented(); + [](RemoteTensorWrapper& self, RemoteTensorWrapper& dst) { + self.tensor.copy_to(dst.tensor); + }, + py::arg("target_tensor"), + R"( + Copy tensor's data to a destination remote tensor. The destination tensor should have the same element type. + In case of RoiTensor, the destination tensor should also have the same shape. + + :param target_tensor: The destination remote tensor to which the data will be copied. + :type target_tensor: openvino.RemoteTensor + )"); + + cls.def( + "copy_to", + [](RemoteTensorWrapper& self, ov::Tensor& dst) { + self.tensor.copy_to(dst); + }, + py::arg("target_tensor"), + R"( + Copy tensor's data to a destination tensor. The destination tensor should have the same element type. + In case of RoiTensor, the destination tensor should also have the same shape. + + :param target_tensor: The destination tensor to which the data will be copied. + :type target_tensor: openvino.Tensor + )"); + + cls.def( + "copy_from", + [](RemoteTensorWrapper& self, RemoteTensorWrapper& src) { + self.tensor.copy_from(src.tensor); + }, + py::arg("source_tensor"), + R"( + Copy source remote tensor's data to this tensor. Tensors should have the same element type. + In case of RoiTensor, tensors should also have the same shape. + + :param source_tensor: The source remote tensor from which the data will be copied. + :type source_tensor: openvino.RemoteTensor + )"); + + cls.def( + "copy_from", + [](RemoteTensorWrapper& self, ov::Tensor& src) { + self.tensor.copy_from(src); + }, + py::arg("source_tensor"), + R"( + Copy source tensor's data to this tensor. Tensors should have the same element type and shape. + In case of RoiTensor, tensors should also have the same shape. + + :param source_tensor: The source tensor from which the data will be copied. + :type source_tensor: openvino.Tensor + )"); + + cls.def( + "get_shape", + [](RemoteTensorWrapper& self) { + return self.tensor.get_shape(); }, R"( - This method is not implemented. + Gets Tensor's shape. + + :rtype: openvino.Shape )"); + cls.def( + "get_byte_size", + [](RemoteTensorWrapper& self) { + return self.tensor.get_byte_size(); + }, + R"( + Gets Tensor's size in bytes. + + :rtype: int + )"); + cls.def_property_readonly( "data", [](RemoteTensorWrapper& self) { diff --git a/src/bindings/python/src/pyopenvino/core/tensor.cpp b/src/bindings/python/src/pyopenvino/core/tensor.cpp index fad7d36f6dc0ea..20c9b9aeec6ff3 100644 --- a/src/bindings/python/src/pyopenvino/core/tensor.cpp +++ b/src/bindings/python/src/pyopenvino/core/tensor.cpp @@ -9,6 +9,7 @@ #include "openvino/runtime/tensor.hpp" #include "pyopenvino/core/common.hpp" +#include "pyopenvino/core/remote_tensor.hpp" namespace py = pybind11; @@ -156,7 +157,7 @@ void regclass_Tensor(py::module m) { R"( Constructs Tensor using port from node. Type and shape will be taken from the port. - + :param port: Output port from a node. :type param: openvino.runtime.Output )"); @@ -185,7 +186,7 @@ void regclass_Tensor(py::module m) { R"( Constructs Tensor using port from node. Type and shape will be taken from the port. - + :param port: Output port from a node. :type param: openvino.runtime.ConstOutput )"); @@ -389,6 +390,23 @@ void regclass_Tensor(py::module m) { py::arg("target_tensor"), R"( Copy tensor's data to a destination tensor. The destination tensor should have the same element type and shape. + + :param target_tensor: The destination tensor to which the data will be copied. + :type target_tensor: openvino.Tensor + )"); + + cls.def( + "copy_to", + [](ov::Tensor& self, RemoteTensorWrapper& dst) { + return self.copy_to(dst.tensor); + }, + py::arg("target_tensor"), + R"( + Copy tensor's data to a destination remote tensor. The destination remote tensor should have the same element type. + In case of RoiRemoteTensor, the destination tensor should also have the same shape. + + :param target_tensor: The destination remote tensor to which the data will be copied. + :type target_tensor: openvino.RemoteTensor )"); cls.def( @@ -396,9 +414,26 @@ void regclass_Tensor(py::module m) { [](ov::Tensor& self, ov::Tensor& source) { return source.copy_to(self); }, - py::arg("source"), + py::arg("source_tensor"), R"( Copy source tensor's data to this tensor. Tensors should have the same element type and shape. + + :param source_tensor: The source tensor from which the data will be copied. + :type source_tensor: openvino.Tensor + )"); + + cls.def( + "copy_from", + [](ov::Tensor& self, RemoteTensorWrapper& source) { + return source.tensor.copy_to(self); + }, + py::arg("source_tensor"), + R"( + Copy source remote tensor's data to this tensor. Tensors should have the same element type. + In case of RoiTensor, tensors should also have the same shape. + + :param source_tensor: The source remote tensor from which the data will be copied. + :type source_tensor: openvino.RemoteTensor )"); cls.def( @@ -436,7 +471,7 @@ void regclass_Tensor(py::module m) { &ov::Tensor::is_continuous, R"( Reports whether the tensor is continuous or not. - :return: True if the tensor is continuous, otherwise False. + :return: True if the tensor is continuous, otherwise False. :rtype: bool )"); diff --git a/src/bindings/python/tests/test_runtime/test_remote_api.py b/src/bindings/python/tests/test_runtime/test_remote_api.py index 7b5d1c7a5ab98b..fb9c87703ea161 100644 --- a/src/bindings/python/tests/test_runtime/test_remote_api.py +++ b/src/bindings/python/tests/test_runtime/test_remote_api.py @@ -91,10 +91,6 @@ def test_create_device_tensor_gpu(): _ = ov.RemoteTensor(np.ones((1, 2, 3))) assert "No constructor defined!" in str(constructor_error.value) - with pytest.raises(RuntimeError) as copy_to_error: - _ = tensor.copy_to(None) - assert "This function is not implemented." in str(copy_to_error.value) - with pytest.raises(RuntimeError) as data_error: _ = tensor.data assert "This function is not implemented." in str(data_error.value) @@ -129,3 +125,145 @@ def test_va_context(): with pytest.raises(RuntimeError) as context_error: _ = ov.VAContext(core, None) assert "user handle is nullptr!" in str(context_error.value) + + +@pytest.mark.skipif( + "GPU" not in os.environ.get("TEST_DEVICE", ""), + reason="Test can be only performed on GPU device!", +) +def test_copy_host_to_device_gpu(): + core = ov.Core() + context = core.get_default_context("GPU") + assert isinstance(context, ov.RemoteContext) + assert "GPU" in context.get_device_name() + + host_tensor_ref = ov.Tensor(ov.Type.f32, ov.Shape([1, 2, 3])) + + random_arr = np.random.rand(*host_tensor_ref.shape).astype(np.float32) + host_tensor_ref.data[:] = random_arr + + # allocate remote tensor with smaller shape and expect proper reallocation + device_tensor = context.create_tensor(ov.Type.f32, ov.Shape([1, 1, 1]), {}) + + # copy to device tensor from host tensor + host_tensor_ref.copy_to(device_tensor) + + assert host_tensor_ref.get_shape() == device_tensor.get_shape() + assert host_tensor_ref.get_byte_size() == device_tensor.get_byte_size() + + host_tensor_res = ov.Tensor(ov.Type.f32, ov.Shape([1, 2, 3])) + + # copy from device tensor from host tensor + host_tensor_res.copy_from(device_tensor) + + assert np.array_equal(host_tensor_res.data, host_tensor_ref.data) + + +@pytest.mark.skipif( + "GPU" not in os.environ.get("TEST_DEVICE", ""), + reason="Test can be only performed on GPU device!", +) +def test_copy_device_to_host_gpu(): + core = ov.Core() + context = core.get_default_context("GPU") + assert isinstance(context, ov.RemoteContext) + assert "GPU" in context.get_device_name() + + host_tensor_ref = ov.Tensor(ov.Type.f32, ov.Shape([1, 2, 3])) + + random_arr = np.random.rand(*host_tensor_ref.shape).astype(np.float32) + host_tensor_ref.data[:] = random_arr + + # allocate remote tensor with smaller shape and expect proper reallocation + device_tensor = context.create_tensor(ov.Type.f32, ov.Shape([1, 1, 1]), {}) + + # copy from host tensor to device tensor + device_tensor.copy_from(host_tensor_ref) + + assert host_tensor_ref.get_shape() == device_tensor.get_shape() + assert host_tensor_ref.get_byte_size() == device_tensor.get_byte_size() + + host_tensor_res = ov.Tensor(ov.Type.f32, ov.Shape([1, 2, 3])) + + # copy to host tensor from device tensor + device_tensor.copy_to(host_tensor_res) + + assert np.array_equal(host_tensor_res.data, host_tensor_ref.data) + + +@pytest.mark.skipif( + "GPU" not in os.environ.get("TEST_DEVICE", ""), + reason="Test can be only performed on GPU device!", +) +def test_roi_copy_host_to_device_gpu(): + core = ov.Core() + context = core.get_default_context("GPU") + assert isinstance(context, ov.RemoteContext) + assert "GPU" in context.get_device_name() + + host_tensor_ref = ov.Tensor(ov.Type.f32, ov.Shape([4, 4, 4])) + + random_arr = np.random.rand(*host_tensor_ref.shape).astype(np.float32) + host_tensor_ref.data[:] = random_arr + + begin_roi = ov.runtime.Coordinate([0, 0, 0]) + end_roi = ov.runtime.Coordinate([3, 4, 4]) + roi_host_tensor_ref = ov.Tensor(host_tensor_ref, begin_roi, end_roi) + + device_tensor = context.create_tensor(ov.Type.f32, ov.Shape([4, 4, 4]), {}) + roi_device_tensor = ov.RemoteTensor(device_tensor, begin_roi, end_roi) + + # copy to roi device tensor from roi host tensor + roi_host_tensor_ref.copy_to(roi_device_tensor) + + assert roi_host_tensor_ref.get_shape() == roi_device_tensor.get_shape() + assert roi_host_tensor_ref.get_byte_size() == roi_device_tensor.get_byte_size() + + host_tensor_res = ov.Tensor(ov.Type.f32, roi_host_tensor_ref.get_shape()) + + # copy from roi device tensor from roi host tensor + host_tensor_res.copy_from(roi_device_tensor) + + host_tensor_wo_roi = ov.Tensor(ov.Type.f32, roi_host_tensor_ref.get_shape()) + host_tensor_wo_roi.copy_from(roi_host_tensor_ref) + + assert np.array_equal(host_tensor_res.data, host_tensor_wo_roi.data) + + +@pytest.mark.skipif( + "GPU" not in os.environ.get("TEST_DEVICE", ""), + reason="Test can be only performed on GPU device!", +) +def test_roi_copy_device_to_host_gpu(): + core = ov.Core() + context = core.get_default_context("GPU") + assert isinstance(context, ov.RemoteContext) + assert "GPU" in context.get_device_name() + + host_tensor_ref = ov.Tensor(ov.Type.f32, ov.Shape([4, 4, 4])) + + random_arr = np.random.rand(*host_tensor_ref.shape).astype(np.float32) + host_tensor_ref.data[:] = random_arr + + begin_roi = ov.runtime.Coordinate([1, 2, 1]) + end_roi = ov.runtime.Coordinate([3, 4, 4]) + roi_host_tensor_ref = ov.Tensor(host_tensor_ref, begin_roi, end_roi) + + device_tensor = context.create_tensor(ov.Type.f32, ov.Shape([4, 4, 4]), {}) + roi_device_tensor = ov.RemoteTensor(device_tensor, begin_roi, end_roi) + + # copy from roi host tensor to roi device tensor + roi_device_tensor.copy_from(roi_host_tensor_ref) + + assert roi_host_tensor_ref.get_shape() == roi_device_tensor.get_shape() + assert roi_host_tensor_ref.get_byte_size() == roi_device_tensor.get_byte_size() + + host_tensor_res = ov.Tensor(ov.Type.f32, roi_host_tensor_ref.get_shape()) + + # copy to roi host tensor from roi remote tensor + host_tensor_res.copy_from(roi_device_tensor) + + host_tensor_wo_roi = ov.Tensor(ov.Type.f32, roi_host_tensor_ref.get_shape()) + host_tensor_wo_roi.copy_from(roi_host_tensor_ref) + + assert np.array_equal(host_tensor_res.data, host_tensor_wo_roi.data) diff --git a/src/core/dev_api/openvino/runtime/itensor.hpp b/src/core/dev_api/openvino/runtime/itensor.hpp index 27e5814dc97308..ab04205632ffe3 100644 --- a/src/core/dev_api/openvino/runtime/itensor.hpp +++ b/src/core/dev_api/openvino/runtime/itensor.hpp @@ -81,7 +81,7 @@ class OPENVINO_API ITensor : public std::enable_shared_from_this { * * @param dst destination tensor */ - void copy_to(const std::shared_ptr& dst) const; + virtual void copy_to(const std::shared_ptr& dst) const; protected: virtual ~ITensor(); diff --git a/src/core/src/runtime/itensor.cpp b/src/core/src/runtime/itensor.cpp index b1b517426b9f67..caa19d8c8ea36b 100644 --- a/src/core/src/runtime/itensor.cpp +++ b/src/core/src/runtime/itensor.cpp @@ -56,8 +56,6 @@ void ITensor::copy_to(const std::shared_ptr& dst) const { OPENVINO_ASSERT(dst, "Destination tensor was not initialized."); OPENVINO_ASSERT(!dynamic_cast(this), "Default copy to doesn't support copy from remote tensor."); - OPENVINO_ASSERT(!std::dynamic_pointer_cast(dst), - "Default copy to doesn't support copy to remote tensor."); OPENVINO_ASSERT(dst->get_element_type() == get_element_type(), "Tensor element types are not equal. (src: ", get_element_type(), @@ -70,6 +68,12 @@ void ITensor::copy_to(const std::shared_ptr& dst) const { dst->set_shape(shape); } + if (std::dynamic_pointer_cast(dst)) { + auto remote_tensor_dst = std::dynamic_pointer_cast(dst); + remote_tensor_dst->copy_from(shared_from_this()); + return; + } + auto* src_data = static_cast(data()); auto* dst_data = static_cast(dst->data()); ov::Strides src_strides{get_byte_size()}; diff --git a/src/inference/dev_api/openvino/runtime/iremote_tensor.hpp b/src/inference/dev_api/openvino/runtime/iremote_tensor.hpp index 39a5102ac35833..35d912448a1b35 100644 --- a/src/inference/dev_api/openvino/runtime/iremote_tensor.hpp +++ b/src/inference/dev_api/openvino/runtime/iremote_tensor.hpp @@ -33,5 +33,23 @@ class OPENVINO_RUNTIME_API IRemoteTensor : public ITensor { * @return Device name */ virtual const std::string& get_device_name() const = 0; + + void copy_to(const std::shared_ptr& dst) const override { + const auto zero_offset = 0; + copy_to(dst, zero_offset, zero_offset, {}); + } + + virtual void copy_from(const std::shared_ptr& src) { + const auto zero_offset = 0; + copy_from(src, zero_offset, zero_offset, {}); + } + + virtual void copy_to(const std::shared_ptr& dst, size_t src_offset, size_t dst_offset, const ov::Shape& roi_shape) const { + OPENVINO_NOT_IMPLEMENTED; + }; + + virtual void copy_from(const std::shared_ptr& src, size_t src_offset, size_t dst_offset, const ov::Shape& roi_shape) { + OPENVINO_NOT_IMPLEMENTED; + }; }; } // namespace ov diff --git a/src/inference/include/openvino/runtime/remote_tensor.hpp b/src/inference/include/openvino/runtime/remote_tensor.hpp index 7d979b531f10df..e8d62d34f07fdf 100644 --- a/src/inference/include/openvino/runtime/remote_tensor.hpp +++ b/src/inference/include/openvino/runtime/remote_tensor.hpp @@ -24,6 +24,19 @@ class OPENVINO_RUNTIME_API RemoteTensor : public Tensor { using Tensor::Tensor; public: + /// @brief Default constructor + RemoteTensor() = default; + + /** + * @brief Constructs region of interest (ROI) tensor from another remote tensor. + * @note Does not perform memory allocation internally + * @param other original tensor + * @param begin start coordinate of ROI object inside of the original object. + * @param end end coordinate of ROI object inside of the original object. + * @note A Number of dimensions in `begin` and `end` must match number of dimensions in `other.get_shape()` + */ + RemoteTensor(const RemoteTensor& other, const Coordinate& begin, const Coordinate& end); + /** * @brief Checks OpenVINO remote type. * @param tensor Tensor which type is checked. @@ -43,7 +56,17 @@ class OPENVINO_RUNTIME_API RemoteTensor : public Tensor { template T* data() = delete; - void copy_to(ov::Tensor& dst) const = delete; + /** + * @brief Copies data from this RemoteTensor to the specified destination tensor. + * @param dst The destination tensor to which data will be copied. + */ + void copy_to(ov::Tensor& dst) const; + + /** + * @brief Copies data from the specified source tensor to this RemoteTensor. + * @param src The source tensor from which data will be copied. + */ + void copy_from(const ov::Tensor& src); /** * @brief Returns a map of device-specific parameters required for low-level diff --git a/src/inference/src/cpp/remote_tensor.cpp b/src/inference/src/cpp/remote_tensor.cpp index 4862abab9bd0fe..1e6512672fff5a 100644 --- a/src/inference/src/cpp/remote_tensor.cpp +++ b/src/inference/src/cpp/remote_tensor.cpp @@ -13,6 +13,24 @@ namespace ov { +#define OV_REMOTE_TENSOR_STATEMENT(remote_tensor, ...) \ + OPENVINO_ASSERT(_impl != nullptr, "Tensor was not initialized."); \ + auto remote_tensor = std::dynamic_pointer_cast(_impl); \ + OPENVINO_ASSERT(remote_tensor, "Tensor is not remote."); \ + try { \ + __VA_ARGS__; \ + } catch (const std::exception& ex) { \ + OPENVINO_THROW(ex.what()); \ + } catch (...) { \ + OPENVINO_THROW("Unexpected exception"); \ + } + +RemoteTensor::RemoteTensor(const RemoteTensor& owner, const Coordinate& begin, const Coordinate& end) { + OPENVINO_ASSERT(get_tensor_impl(owner)._ptr, "Cannot create RoiRemoteTensor on top of empty tensor"); + _impl = make_tensor(std::dynamic_pointer_cast(owner._impl), begin, end); + _so = owner._so; +} + void RemoteTensor::type_check(const Tensor& tensor, const std::map>& type_info) { OPENVINO_ASSERT(tensor, "Could not check empty tensor type"); auto remote_tensor = std::dynamic_pointer_cast(get_tensor_impl(tensor)._ptr); @@ -39,33 +57,27 @@ void RemoteTensor::type_check(const Tensor& tensor, const std::map(_impl); - try { - AnyMap paramMap; + auto get_params_impl = [](const std::shared_ptr& remote_tensor, + const std::shared_ptr& so) { + ov::AnyMap params_map; for (auto&& param : remote_tensor->get_properties()) { - paramMap.emplace(param.first, Any{param.second, _so}); + params_map.emplace(param.first, Any{param.second, so}); } - return paramMap; - } catch (const std::exception& ex) { - OPENVINO_THROW(ex.what()); - } catch (...) { - OPENVINO_THROW("Unexpected exception"); - } + return params_map; + }; + + OV_REMOTE_TENSOR_STATEMENT(remote_tensor, return get_params_impl(remote_tensor, _so)); +} + +void RemoteTensor::copy_to(ov::Tensor& dst) const { + OV_REMOTE_TENSOR_STATEMENT(remote_tensor, remote_tensor->copy_to(get_tensor_impl(dst)._ptr)); +} + +void RemoteTensor::copy_from(const ov::Tensor& src) { + OV_REMOTE_TENSOR_STATEMENT(remote_tensor, remote_tensor->copy_from(get_tensor_impl(src)._ptr)); } std::string RemoteTensor::get_device_name() const { - OPENVINO_ASSERT(_impl != nullptr, "Tensor was not initialized."); - auto remote_tensor = std::dynamic_pointer_cast(_impl); - OPENVINO_ASSERT(remote_tensor, "Tensor is not remote."); - type_check(*this); - try { - return remote_tensor->get_device_name(); - } catch (const std::exception& ex) { - OPENVINO_THROW(ex.what()); - } catch (...) { - OPENVINO_THROW("Unexpected exception"); - } + OV_REMOTE_TENSOR_STATEMENT(remote_tensor, return remote_tensor->get_device_name()); } } // namespace ov diff --git a/src/inference/src/dev/make_tensor.cpp b/src/inference/src/dev/make_tensor.cpp index 7f532875f7d567..748340e0de570f 100644 --- a/src/inference/src/dev/make_tensor.cpp +++ b/src/inference/src/dev/make_tensor.cpp @@ -284,21 +284,53 @@ std::shared_ptr make_tensor(const element::Type element_type, const Sha } /** - * @brief ROI tensor on other tensor + * @brief Base class for representing a Region of Interest (ROI) on another tensor * ROI tensor holds the owner */ -class RoiTensor : public ITensor { +class BaseRoiTensor { public: - RoiTensor(const std::shared_ptr& owner, const Coordinate& begin, const Coordinate& end) + BaseRoiTensor(const std::shared_ptr& owner, const Coordinate& begin, const Coordinate& end) : m_owner{owner}, m_shape{make_roi_shape(owner->get_shape(), begin, end)}, m_capacity{m_shape}, - m_offset{std::inner_product(begin.begin(), begin.end(), get_strides().begin(), static_cast(0))} { - OPENVINO_ASSERT(get_element_type().bitwidth() >= 8, - "ROI Tensor for types with bitwidths less then 8 bit is not implemented. Tensor type: ", - get_element_type()); + m_offset{ + std::inner_product(begin.begin(), begin.end(), m_owner->get_strides().begin(), static_cast(0))} { + OPENVINO_ASSERT(m_owner->get_element_type().bitwidth() >= 8, + "ROI Tensor for types with bitwidths less than 8 bit is not implemented. Tensor type: ", + m_owner->get_element_type()); + } + + void set_shape(ov::Shape new_shape) { + OPENVINO_ASSERT(new_shape.size() == m_shape.size()); + for (auto new_dim = new_shape.cbegin(), max_dim = m_capacity.cbegin(); new_dim != new_shape.cend(); + ++max_dim, ++new_dim) { + OPENVINO_ASSERT(*new_dim <= *max_dim, + "Cannot set new shape: ", + new_shape, + " for ROI tensor! Dimension: ", + std::distance(new_shape.cbegin(), new_dim), + " is not compatible."); + } + + m_shape = std::move(new_shape); } +protected: + std::shared_ptr m_owner; + Shape m_shape; + const Shape m_capacity; + const size_t m_offset; +}; + +/** + * @brief Tensor representing a Region of Interest (ROI) on another host tensor + * ROI tensor holds the owner + */ +class RoiTensor : public BaseRoiTensor, public ITensor { +public: + RoiTensor(const std::shared_ptr& owner, const Coordinate& begin, const Coordinate& end) + : BaseRoiTensor(owner, begin, end) {} + const element::Type& get_element_type() const override { return m_owner->get_element_type(); } @@ -312,34 +344,96 @@ class RoiTensor : public ITensor { } void set_shape(ov::Shape new_shape) override { - OPENVINO_ASSERT(new_shape.size() == m_shape.size()); - for (auto new_dim = new_shape.cbegin(), max_dim = m_capacity.cbegin(); new_dim != new_shape.cend(); - ++max_dim, ++new_dim) { - OPENVINO_ASSERT(*new_dim <= *max_dim, - "Cannot set new shape: ", - new_shape, - " for ROI tensor! Dimension: ", - std::distance(new_shape.cbegin(), new_dim), - " is not compatible."); - } - - m_shape = std::move(new_shape); + BaseRoiTensor::set_shape(new_shape); } void* data(const element::Type& element_type) const override { auto owner_data = m_owner->data(element_type); return static_cast(owner_data) + m_offset; } +}; -private: - std::shared_ptr m_owner; - Shape m_shape; - const Shape m_capacity; - const size_t m_offset; +/** + * @brief Tensor representing a Region of Interest (ROI) on another device tensor + * ROI tensor holds the owner + */ +class RoiRemoteTensor : public BaseRoiTensor, public IRemoteTensor { +public: + RoiRemoteTensor(const std::shared_ptr& owner, const Coordinate& begin, const Coordinate& end) + : BaseRoiTensor(owner, begin, end) {} + + const element::Type& get_element_type() const override { + return m_owner->get_element_type(); + } + + const Strides& get_strides() const override { + return m_owner->get_strides(); + } + + const Shape& get_shape() const override { + return m_shape; + } + + void set_shape(ov::Shape new_shape) override { + BaseRoiTensor::set_shape(new_shape); + } + + void copy_to(const std::shared_ptr& dst) const override { + auto owner_remote_tensor = std::dynamic_pointer_cast(m_owner); + + if (std::dynamic_pointer_cast(dst)) { + OPENVINO_ASSERT(get_shape() == dst->get_shape(), + "Cannot copy to RoiRemoteTensor. Shapes are not equal. (src: ", + get_shape(), + " != dst: ", + dst->get_shape(), + ")"); + + auto dst_roi_remote_tensor = std::dynamic_pointer_cast(dst); + owner_remote_tensor->copy_to(dst_roi_remote_tensor->m_owner, + m_offset, + dst_roi_remote_tensor->m_offset, + m_shape); + } else { + owner_remote_tensor->copy_to(dst, m_offset, 0, m_shape); + } + }; + + void copy_from(const std::shared_ptr& src) override { + auto owner_remote_tensor = std::dynamic_pointer_cast(m_owner); + + OPENVINO_ASSERT(src->get_shape() == get_shape(), + "Cannot copy to RoiRemoteTensor. Shapes are not equal. (src: ", + src->get_shape(), + " != dst: ", + get_shape(), + ")"); + + if (std::dynamic_pointer_cast(src)) { + const auto src_roi_remote_tensor = std::dynamic_pointer_cast(src); + owner_remote_tensor->copy_from(src_roi_remote_tensor->m_owner, + src_roi_remote_tensor->m_offset, + m_offset, + m_shape); + } else { + owner_remote_tensor->copy_from(src, 0, m_offset, m_shape); + } + }; + + const AnyMap& get_properties() const override { + auto remote_tensor = std::dynamic_pointer_cast(m_owner); + return remote_tensor->get_properties(); + }; + + const std::string& get_device_name() const override { + auto remote_tensor = std::dynamic_pointer_cast(m_owner); + return remote_tensor->get_device_name(); + } }; /** * @brief Creates ROI tensor + * It determines whether the tensor is remote tensor or regular tensor and returns the appropriate ROI tensor type * * @param other Tensor what owns the memory * @param begin Begin coordinates @@ -350,7 +444,11 @@ class RoiTensor : public ITensor { std::shared_ptr make_tensor(const std::shared_ptr& other, const Coordinate& begin, const Coordinate& end) { - return std::make_shared(other, begin, end); + if (std::dynamic_pointer_cast(other)) { + return std::make_shared(other, begin, end); + } else { + return std::make_shared(other, begin, end); + } } namespace util { diff --git a/src/plugins/intel_gpu/include/intel_gpu/plugin/common_utils.hpp b/src/plugins/intel_gpu/include/intel_gpu/plugin/common_utils.hpp index 2c0f812a7504c5..3c14895befb101 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/plugin/common_utils.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/plugin/common_utils.hpp @@ -143,7 +143,7 @@ void convert_and_copy(const ov::ITensor* src, cldnn::stream& stream, const cldnn::layout& src_layout = cldnn::layout({}, ov::element::undefined, cldnn::format::bfyx, cldnn::padding())); void convert_and_copy(const cldnn::memory::ptr src, ov::ITensor const* dst, const cldnn::stream& stream); -void convert_and_copy(const ov::ITensor* src, ov::ITensor const* dst, const cldnn::stream& stream); +void convert_and_copy(const ov::ITensor* src, ov::ITensor* dst, const cldnn::stream& stream); void convert_and_copy(const cldnn::memory::ptr src, cldnn::memory::ptr dst, cldnn::stream& stream); } // namespace intel_gpu diff --git a/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_context.hpp b/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_context.hpp index 679e11446751a6..1851b9c0ea9582 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_context.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_context.hpp @@ -37,7 +37,6 @@ class RemoteContextImpl : public ov::IRemoteContext { ov::SoPtr create_host_tensor(const ov::element::Type type, const ov::Shape& shape) override; ov::SoPtr create_tensor(const ov::element::Type& type, const ov::Shape& shape, const ov::AnyMap& params) override; - cldnn::engine& get_engine() { return *m_engine; } ov::intel_gpu::gpu_handle_param get_external_queue() const { return m_external_queue; } diff --git a/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_tensor.hpp b/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_tensor.hpp index f7f72cc77a16a3..44bef310805f54 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_tensor.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/plugin/remote_tensor.hpp @@ -48,6 +48,9 @@ class RemoteTensorImpl : public ov::IRemoteTensor { const ov::Shape& get_shape() const override; const ov::Strides& get_strides() const override; + void copy_to(const std::shared_ptr& dst, size_t src_offset, size_t dst_offset, const ov::Shape& roi_shape) const override; + void copy_from(const std::shared_ptr& src, size_t src_offset, size_t dst_offset, const ov::Shape& roi_shape) override; + void allocate(); bool deallocate() noexcept; diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp index 5425865f65b74e..7bc020c2529a88 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp @@ -89,6 +89,8 @@ struct data : public primitive_base { size_t dst_offset = 0; while (dst_offset < data_size) { + const bool is_blocking = false; + const size_t src_offset = 0; size_t copy_size = (data_size > (dst_offset + DATA_BLOCK_SIZE)) ? DATA_BLOCK_SIZE : (data_size - dst_offset); if (buf_flag) { ib >> make_data(_buf1.data(), copy_size); @@ -96,14 +98,14 @@ struct data : public primitive_base { ev2->wait(); ev2 = nullptr; } - ev1 = mem->copy_from(strm, _buf1.data(), false, dst_offset, copy_size); + ev1 = mem->copy_from(strm, _buf1.data(), src_offset, dst_offset, copy_size, is_blocking); } else { ib >> make_data(_buf2.data(), copy_size); if (ev1 != nullptr) { ev1->wait(); ev1 = nullptr; } - ev2 = mem->copy_from(strm, _buf2.data(), false, dst_offset, copy_size); + ev2 = mem->copy_from(strm, _buf2.data(), src_offset, dst_offset, copy_size, is_blocking); } dst_offset += DATA_BLOCK_SIZE; buf_flag = !buf_flag; diff --git a/src/plugins/intel_gpu/include/intel_gpu/runtime/memory.hpp b/src/plugins/intel_gpu/include/intel_gpu/runtime/memory.hpp index 867b553ebf16f9..a40823dc7a1f27 100644 --- a/src/plugins/intel_gpu/include/intel_gpu/runtime/memory.hpp +++ b/src/plugins/intel_gpu/include/intel_gpu/runtime/memory.hpp @@ -81,11 +81,44 @@ struct memory { return true; } - virtual event::ptr copy_from(stream& /* stream */, const memory& /* other */, bool blocking = true) = 0; - virtual event::ptr copy_from(stream& /* stream */, const void* /* host_ptr */, bool blocking = true, size_t dst_offset = 0, size_t data_size = 0) = 0; - virtual event::ptr copy_to(stream& stream, memory& other, bool blocking = true) { return other.copy_from(stream, *this, blocking); } - virtual event::ptr copy_to(stream& /* stream */, void* /* host_ptr */, bool blocking = true) = 0; + // Device <== Host + virtual event::ptr copy_from(stream& stream, const void* src_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) = 0; + + // Device <== Device + virtual event::ptr copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) = 0; + + // Device ==> Host + virtual event::ptr copy_to(stream& stream, void* dst_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const = 0; + + // Device ==> Device + virtual event::ptr copy_to(stream& stream, memory& dst_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const { + return dst_mem.copy_from(stream, *this, src_offset, dst_offset, size, blocking); + } + + virtual event::ptr copy_from(stream& stream, const memory& src_mem, bool blocking = true) { + const auto zero_offset = 0; + const auto data_size = src_mem._bytes_count; + return copy_from(stream, src_mem, zero_offset, zero_offset, data_size, blocking); + } + + virtual event::ptr copy_from(stream& stream, const void* src_ptr, bool blocking = true) { + const auto zero_offset = 0; + const auto data_size = _bytes_count; + return copy_from(stream, src_ptr, zero_offset, zero_offset, data_size, blocking); + } + + virtual event::ptr copy_to(stream& stream, memory& other, bool blocking = true) const { + const auto zero_offset = 0; + const auto data_size = other._bytes_count; + return copy_to(stream, other, zero_offset, zero_offset, data_size, blocking); + } + + virtual event::ptr copy_to(stream& stream, void* dst_ptr, bool blocking = true) const { + const auto zero_offset = 0; + const auto data_size = _bytes_count; + return copy_to(stream, dst_ptr, zero_offset, zero_offset, data_size, blocking); + } #ifdef ENABLE_ONEDNN_FOR_GPU virtual dnnl::memory get_onednn_memory(dnnl::memory::desc /* desc */, int64_t offset = 0) const { @@ -124,17 +157,14 @@ struct simple_attached_memory : memory { #endif 0}; }; - event::ptr copy_from(stream& /* stream */, const memory& /* other */, bool /* blocking */) override { - OPENVINO_THROW("[GPU] copy_from is not implemented for simple_attached_memory"); - } - event::ptr copy_from(stream& /* stream */, const void* /* host_ptr */, bool /* blocking */, size_t /* dst_offset */, size_t /* data_size */) override { - OPENVINO_THROW("[GPU] copy_from is not implemented for simple_attached_memory"); + event::ptr copy_from(stream& stream, const void* src_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) override { + OPENVINO_NOT_IMPLEMENTED; } - event::ptr copy_to(stream& /* stream */, memory& /* other */, bool /* blocking */) override { - OPENVINO_THROW("[GPU] copy_to is not implemented for simple_attached_memory"); + event::ptr copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) override { + OPENVINO_NOT_IMPLEMENTED; } - event::ptr copy_to(stream& /* stream */, void* /* host_ptr */, bool /* blocking */) override { - OPENVINO_THROW("[GPU] copy_to is not implemented for simple_attached_memory"); + event::ptr copy_to(stream& stream, void* dst_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const override { + OPENVINO_NOT_IMPLEMENTED; } private: diff --git a/src/plugins/intel_gpu/src/plugin/common_utils.cpp b/src/plugins/intel_gpu/src/plugin/common_utils.cpp index 292686c5bd0707..2daeb09c90a5bf 100644 --- a/src/plugins/intel_gpu/src/plugin/common_utils.cpp +++ b/src/plugins/intel_gpu/src/plugin/common_utils.cpp @@ -10,6 +10,7 @@ #include "openvino/core/type/element_type.hpp" #include "openvino/runtime/tensor.hpp" +#include "openvino/runtime/make_tensor.hpp" #include "openvino/op/util/op_types.hpp" #include @@ -199,7 +200,7 @@ void convert_and_copy(const cldnn::memory::ptr src, cldnn::memory::ptr dst, cldn dst->copy_from(stream, tmp_tensor.data(), blocking); } -void convert_and_copy(const ov::ITensor* src, ov::ITensor const* dst, const cldnn::stream& stream) { +void convert_and_copy(const ov::ITensor* src, ov::ITensor* dst, const cldnn::stream& stream) { auto src_et = src->get_element_type(); auto dst_et = dst->get_element_type(); @@ -210,11 +211,16 @@ void convert_and_copy(const ov::ITensor* src, ov::ITensor const* dst, const cldn std::unique_ptr> src_lock = nullptr; std::unique_ptr> dst_lock = nullptr; + ov::Tensor tmp_tensor; if (auto remote = dynamic_cast(src)) { auto mem = remote->get_original_memory(); src_lock.reset(new cldnn::mem_lock(mem, stream)); src_ptr = src_lock->data(); + } else if (dynamic_cast(src)) { + tmp_tensor = ov::Tensor(src_et, src->get_shape()); + src->copy_to(get_tensor_impl(tmp_tensor)._ptr); + src_ptr = tmp_tensor.data(); } else { src_ptr = src->data(); } @@ -223,6 +229,10 @@ void convert_and_copy(const ov::ITensor* src, ov::ITensor const* dst, const cldn auto mem = remote->get_original_memory(); dst_lock.reset(new cldnn::mem_lock(mem, stream)); dst_ptr = dst_lock->data(); + } else if (auto remote = dynamic_cast(dst)) { + tmp_tensor = ov::Tensor(dst_et, src->get_shape()); + ::convert_and_copy(src_ptr, src_et, tmp_tensor.data(), dst_et, size, cldnn::layout({}, ov::element::undefined, cldnn::format::bfyx, cldnn::padding())); + remote->copy_from(get_tensor_impl(tmp_tensor)._ptr); } else { dst_ptr = dst->data(); } diff --git a/src/plugins/intel_gpu/src/plugin/remote_tensor.cpp b/src/plugins/intel_gpu/src/plugin/remote_tensor.cpp index c240ad8fcc7060..278e1b30d81439 100644 --- a/src/plugins/intel_gpu/src/plugin/remote_tensor.cpp +++ b/src/plugins/intel_gpu/src/plugin/remote_tensor.cpp @@ -14,6 +14,125 @@ namespace ov { namespace intel_gpu { +namespace { +static ov::Strides calculate_strides(const ov::Shape& shape, const ov::element::Type& element_type) { + ov::Strides strides{}; + if (element_type.bitwidth() < 8) + return strides; + + if (!shape.empty()) { + strides.resize(shape.size()); + strides.back() = shape.back() == 0 ? 0 : element_type.size(); + std::copy(shape.rbegin(), shape.rend() - 1, strides.rbegin() + 1); + std::partial_sum(strides.rbegin(), strides.rend(), strides.rbegin(), std::multiplies()); + } + + return strides; +} + +struct MemWrapper { + MemWrapper(cldnn::stream& stream, cldnn::memory_ptr mem_ptr, void* data_ptr) + : m_stream(stream) + , m_mem_ptr(mem_ptr) + , m_data_ptr(data_ptr) { + OPENVINO_ASSERT((m_data_ptr != nullptr) != (m_mem_ptr != nullptr), "[GPU] Invalid memory configuration"); + } + + void copy_to(MemWrapper& dst, size_t src_offset, size_t dst_offset, size_t size) const { + const bool is_blocking = true; + if (m_data_ptr != nullptr) { + OPENVINO_ASSERT(dst.m_mem_ptr, "[GPU] Unexpected host to host copy call for Remote Tensors"); + + // Device <== Host + dst.m_mem_ptr->copy_from(m_stream, m_data_ptr, src_offset, dst_offset, size, is_blocking); + } else { + if (dst.m_data_ptr != nullptr) { + // Device ==> Host + m_mem_ptr->copy_to(m_stream, dst.m_data_ptr, src_offset, dst_offset, size, is_blocking); + } else { + // Device ==> Device + m_mem_ptr->copy_to(m_stream, *dst.m_mem_ptr, src_offset, dst_offset, size, is_blocking); + } + } + } + +private: + cldnn::stream& m_stream; + cldnn::memory_ptr m_mem_ptr = nullptr; + void* m_data_ptr = nullptr; +}; + +static void copy_roi_recursively(const MemWrapper& src_mem, + MemWrapper& dst_mem, + const size_t axis, + const size_t src_offset, + const size_t dst_offset, + const ov::Shape& roi_shape, + const ov::Strides& src_strides, + const ov::Strides& dst_strides, + const ov::Strides& roi_strides) { + if (axis == roi_shape.size() - 1) { + // Copy the innermost dimension + const auto size = roi_strides[axis] * roi_shape[axis]; + src_mem.copy_to(dst_mem, src_offset, dst_offset, size); + } else { + // Check if the current dimension and all inner dimensions can be copied as a single chunk + bool can_copy_as_chunk = true; + for (size_t i = axis; i < roi_shape.size(); i++) { + if (src_strides[i] != roi_strides[i] || dst_strides[i] != roi_strides[i]) { + can_copy_as_chunk = false; + break; + } + } + + if (can_copy_as_chunk) { + const auto chunk_size = roi_strides[axis] * roi_shape[axis]; + src_mem.copy_to(dst_mem, src_offset, dst_offset, chunk_size); + } else { + for (size_t i = 0; i < roi_shape[axis]; i++) { + const auto src_offset_new = src_offset + i * src_strides[axis]; + const auto dst_offset_new = dst_offset + i * dst_strides[axis]; + copy_roi_recursively(src_mem, dst_mem, axis + 1, src_offset_new, dst_offset_new, roi_shape, src_strides, dst_strides, roi_strides); + } + } + } +} + +static void copy_roi(const MemWrapper& src_mem, + MemWrapper& dst_mem, + const size_t src_offset, + const size_t dst_offset, + const ov::Strides& src_strides, + const ov::Strides& dst_strides, + const ov::Strides& roi_strides, + const ov::Shape& src_shape, + const ov::Shape& dst_shape, + const ov::Shape& roi_shape) { + const size_t start_axis = 0; + copy_roi_recursively(src_mem, dst_mem, start_axis, src_offset, dst_offset, roi_shape, src_strides, dst_strides, roi_strides); +} + +static void validate_and_check_shapes(const std::shared_ptr& src, + const std::shared_ptr& dst, + const ov::Shape& roi_shape) { + OPENVINO_ASSERT(src->get_element_type() == dst->get_element_type(), + "[GPU] Tensor element types are not equal. (src: ", + src->get_element_type(), + " != dst: ", + dst->get_element_type(), + ")"); + OPENVINO_ASSERT(src->get_element_type().bitwidth() >= 8, "[GPU] Unsupported element type for copying: ", src->get_element_type()); + + // If it's a simple copy_to/copy_from call, then change dst shape + if (roi_shape.empty()) { + const auto& shape = src->get_shape(); + if (shape != dst->get_shape()) { + dst->set_shape(shape); + } + } +} +} // namespace + TensorType RemoteTensorImpl::allocation_type_to_tensor_type(cldnn::allocation_type t) { switch (t) { case cldnn::allocation_type::cl_mem: return TensorType::BT_BUF_INTERNAL; @@ -57,27 +176,86 @@ const ov::Shape& RemoteTensorImpl::get_shape() const { } void RemoteTensorImpl::update_strides() { - if (m_element_type.bitwidth() < 8) - return; - auto& shape = get_shape(); - m_strides.clear(); - if (!shape.empty()) { - m_strides.resize(shape.size()); - m_strides.back() = shape.back() == 0 ? 0 : m_element_type.size(); - std::copy(shape.rbegin(), shape.rend() - 1, m_strides.rbegin() + 1); - std::partial_sum(m_strides.rbegin(), m_strides.rend(), m_strides.rbegin(), std::multiplies()); - } + m_strides = calculate_strides(get_shape(), m_element_type); } const ov::Strides& RemoteTensorImpl::get_strides() const { return m_strides; } +void RemoteTensorImpl::copy_to(const std::shared_ptr& dst, + size_t src_offset, + size_t dst_offset, + const ov::Shape& roi_shape) const { + validate_and_check_shapes(shared_from_this(), dst, roi_shape); + + auto& stream = m_context->get_engine().get_service_stream(); + auto dst_remote_tensor = std::dynamic_pointer_cast(dst); + auto shape = roi_shape.empty() ? get_shape() : roi_shape; + + ov::Strides roi_strides = calculate_strides(shape, m_element_type); + if (dst_remote_tensor != nullptr) { + GPU_DEBUG_TRACE_DETAIL << "Copying from RemoteTensor (" << get_memory()->get_allocation_type() << ") to RemoteTensor (" + << dst_remote_tensor->get_memory()->get_allocation_type() << "), src_offset=" << src_offset << ", dst_offset=" + << dst_offset << ", roi_shape=" << shape << ", src_shape=" << get_shape() << ", dst_shape=" << dst->get_shape() << "\n"; + + auto src_mem = MemWrapper(stream, get_memory(), nullptr); + auto dst_mem = MemWrapper(stream, dst_remote_tensor->get_memory(), nullptr); + + copy_roi(src_mem, dst_mem, src_offset, dst_offset, get_strides(), dst->get_strides(), roi_strides, get_shape(), dst->get_shape(), shape); + } else { + GPU_DEBUG_TRACE_DETAIL << "Copying from RemoteTensor (" << get_memory()->get_allocation_type() << ") to host tensor, src_offset=" + << src_offset << ", dst_offset=" << dst_offset << ", roi_shape=" << shape << ", src_shape=" << get_shape() + << ", dst_shape=" << dst->get_shape() << "\n"; + + OPENVINO_ASSERT(!std::dynamic_pointer_cast(dst), "[GPU] Unsupported Remote Tensor type"); + + auto src_mem = MemWrapper(stream, get_memory(), nullptr); + auto dst_mem = MemWrapper(stream, nullptr, dst->data()); + + copy_roi(src_mem, dst_mem, src_offset, dst_offset, get_strides(), dst->get_strides(), roi_strides, get_shape(), dst->get_shape(), shape); + } +} + +void RemoteTensorImpl::copy_from(const std::shared_ptr& src, + size_t src_offset, + size_t dst_offset, + const ov::Shape& roi_shape) { + validate_and_check_shapes(src, shared_from_this(), roi_shape); + auto shape = roi_shape.empty() ? get_shape() : roi_shape; + + auto& stream = m_context->get_engine().get_service_stream(); + auto src_remote_tensor = std::dynamic_pointer_cast(src); + + ov::Strides roi_strides = calculate_strides(shape, m_element_type); + if (src_remote_tensor != nullptr) { + GPU_DEBUG_TRACE_DETAIL << "Copying from RemoteTensor (" << src_remote_tensor->get_memory()->get_allocation_type() << ") to RemoteTensor (" + << get_memory()->get_allocation_type() << "), src_offset=" << src_offset << ", dst_offset=" + << dst_offset << ", roi_shape=" << shape << ", src_shape" << src->get_shape() << ", dst_shape=" << get_shape() << "\n"; + + auto src_mem = MemWrapper(stream, src_remote_tensor->get_memory(), nullptr); + auto dst_mem = MemWrapper(stream, get_memory(), nullptr); + + copy_roi(src_mem, dst_mem, src_offset, dst_offset, src->get_strides(), get_strides(), roi_strides, src->get_shape(), get_shape(), shape); + } else { + GPU_DEBUG_TRACE_DETAIL << "Copying from host tensor to RemoteTensor (" << get_memory()->get_allocation_type() << "), src_offset=" + << src_offset << ", dst_offset=" << dst_offset << ", roi_shape=" << shape << ", src_shape" << src->get_shape() + << ", dst_shape=" << get_shape() << "\n"; + + OPENVINO_ASSERT(!std::dynamic_pointer_cast(src), "[GPU] Unsupported Remote Tensor type"); + + auto src_mem = MemWrapper(stream, nullptr, src->data()); + auto dst_mem = MemWrapper(stream, get_memory(), nullptr); + + copy_roi(src_mem, dst_mem, src_offset, dst_offset, src->get_strides(), get_strides(), roi_strides, src->get_shape(), get_shape(), shape); + } +} + const AnyMap& RemoteTensorImpl::get_properties() const { return m_properties; } - void RemoteTensorImpl::set_shape(ov::Shape shape) { +void RemoteTensorImpl::set_shape(ov::Shape shape) { m_layout.set_partial_shape(ov::PartialShape{shape}); m_shape = shape; diff --git a/src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp b/src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp index 1ae9cbb81715c4..5e0c6e8c884fdc 100644 --- a/src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp +++ b/src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp @@ -356,13 +356,15 @@ void SyncInferRequest::wait() { OPENVINO_ASSERT(m_user_outputs.count(port_idx) > 0, "[GPU] Output index ", port_idx, " is not found in output tensors map"); auto output_tensor_wrapper = m_user_outputs.at(port_idx); auto output_tensor = output_tensor_wrapper.ptr; - auto remote_ptr = std::dynamic_pointer_cast(output_tensor); - bool is_remote = remote_ptr != nullptr; + auto remote_tensor_impl_ptr = std::dynamic_pointer_cast(output_tensor); + auto iremote_tensor_ptr = std::dynamic_pointer_cast(output_tensor); + bool is_remote_tensor_impl = remote_tensor_impl_ptr != nullptr; + bool is_generic_remote = iremote_tensor_ptr != nullptr && remote_tensor_impl_ptr == nullptr; bool is_dynamic = port.get_partial_shape().is_dynamic(); - if (is_remote) { + if (is_remote_tensor_impl || is_generic_remote) { GPU_DEBUG_TRACE_DETAIL << internal_name << " handle output tensor (remote) with index: " << port_idx << ": " - << remote_ptr->get_original_memory()->buffer_ptr() << std::endl; + << remote_tensor_impl_ptr->get_original_memory()->buffer_ptr() << std::endl; } else { GPU_DEBUG_TRACE_DETAIL << internal_name << " handle output tensor (host) with index: " << port_idx << ": " << output_tensor->data() << std::endl; @@ -400,7 +402,7 @@ void SyncInferRequest::wait() { auto usm_host_tensor = std::dynamic_pointer_cast(output_tensor); if (usm_host_tensor && output_memory) need_reallocate = usm_host_tensor->get_impl()->get_original_memory()->size() < output_memory->size(); - else if (!is_remote && output_memory) + else if (!is_remote_tensor_impl && output_memory) need_reallocate = output_tensor_wrapper.actual_size < output_memory->size(); if (need_reallocate) { @@ -418,19 +420,31 @@ void SyncInferRequest::wait() { // mapping remote blobs not needed - // let the user take care of them explicitly - if (!is_remote && output_memory) { - auto dst_ptr = static_cast(output_tensor->data()); - bool same_mem = same_host_mem(output_memory, dst_ptr); - if (!same_mem && output_memory->size()) { - GPU_DEBUG_TRACE_DETAIL << internal_name << " with index " << port_idx << " copy from: " << output_memory->buffer_ptr() << " to " - << (!is_remote ? output_tensor->data() : remote_ptr->get_original_memory()->buffer_ptr()) << std::endl; - if (auto ev = copy_output_data(output_memory, *output_tensor)) { - copy_events.push_back(ev); + if (!is_remote_tensor_impl && output_memory) { + if (!is_generic_remote) { + auto dst_ptr = static_cast(output_tensor->data()); + bool same_mem = same_host_mem(output_memory, dst_ptr); + if (!same_mem && output_memory->size()) { + GPU_DEBUG_TRACE_DETAIL << internal_name << " with index " << port_idx << " copy from: " << output_memory->buffer_ptr() << " to " + << (!is_remote_tensor_impl ? output_tensor->data() : remote_tensor_impl_ptr->get_original_memory()->buffer_ptr()) << std::endl; + if (auto ev = copy_output_data(output_memory, *output_tensor)) { + copy_events.push_back(ev); + } + } + } else { + OPENVINO_ASSERT(!is_dynamic, "[GPU] Unsupported RemoteTensor type for dynamic output"); + + auto plugin_tensor = m_plugin_outputs.at(port_idx); + if (is_convert_required(plugin_tensor.ptr->get_element_type(), iremote_tensor_ptr->get_element_type())) { + auto& stream = m_graph->get_network()->get_stream(); + convert_and_copy(plugin_tensor.ptr.get(), iremote_tensor_ptr.get(), stream); + } else { + iremote_tensor_ptr->copy_from(plugin_tensor.ptr); } } - } else if (is_remote && is_dynamic) { + } else if (is_remote_tensor_impl && is_dynamic) { auto& stream = m_graph->get_network()->get_stream(); - auto user_mem = remote_ptr->get_original_memory(); + auto user_mem = remote_tensor_impl_ptr->get_original_memory(); if (user_mem->get_allocation_type() == cldnn::allocation_type::cl_mem && output_memory->get_allocation_type() != cldnn::allocation_type::cl_mem) { // WA: Copy between cl_mem and usm memory may fail for some reason (driver bug?) // so this explicit memcpy is used to provide correct output for cl_mem output in dynamic cases @@ -519,14 +533,16 @@ TensorWrapper SyncInferRequest::create_or_share_device_tensor(const TensorWrappe bool is_dynamic = port_pshape.is_dynamic(); OPENVINO_ASSERT(std::dynamic_pointer_cast(user_tensor) == nullptr, "[GPU] Unexpected remote tensor"); auto usm_host_tensor = std::dynamic_pointer_cast(user_tensor); + auto generic_remote_tensor = std::dynamic_pointer_cast(user_tensor); // Note: currently, using USM Host memory for dGPUs in some scenarios (LLMs) leads to performance degradation, // so apply wider USM Host memory type detection only for iGPUs - auto user_tensor_mem_type = engine.detect_usm_allocation_type(user_tensor->data()); + auto user_tensor_mem_type = !generic_remote_tensor ? engine.detect_usm_allocation_type(user_tensor->data()) + : cldnn::allocation_type::unknown; auto usm_host_raw_ptr = engine.get_device_info().dev_type == cldnn::device_type::integrated_gpu && user_tensor_mem_type == cldnn::allocation_type::usm_host; - bool can_share = !is_convert_required(user_tensor->get_element_type(), element_type) && can_use_usm_host(engine); + bool can_share = !is_convert_required(user_tensor->get_element_type(), element_type) && can_use_usm_host(engine) && !generic_remote_tensor; if (usm_host_tensor && can_share) { return { usm_host_tensor->get_impl(), user_tensor_wrapper.owner }; @@ -703,13 +719,17 @@ std::vector SyncInferRequest::prepare_input(const std::string auto user_tensor = user_tensor_wrapper.ptr; auto element_type = user_tensor->get_element_type(); - auto remote_ptr = std::dynamic_pointer_cast(user_tensor); + auto remote_tensor_impl_ptr = std::dynamic_pointer_cast(user_tensor); + auto iremote_tensor_ptr = std::dynamic_pointer_cast(user_tensor); auto usm_host_ptr = std::dynamic_pointer_cast(user_tensor); - bool is_remote = remote_ptr != nullptr; + bool is_generic_remote = iremote_tensor_ptr != nullptr && remote_tensor_impl_ptr == nullptr; + bool is_remote_tensor_impl = remote_tensor_impl_ptr != nullptr; bool is_usm_host_tensor = usm_host_ptr != nullptr; GPU_DEBUG_TRACE_DETAIL << "Prepare input for " << internal_name - << " ( is_remote ? " << is_remote << ", is_usm_host_tensor ? " << is_usm_host_tensor << ")" << std::endl; + << " (is_remote_tensor_impl ? " << is_remote_tensor_impl + << ", is_usm_host_tensor ? " << is_usm_host_tensor + << ", is_generic_remote ? " << is_generic_remote << ")" << std::endl; GPU_DEBUG_TRACE_DETAIL << " port shape : " << pshape.to_string() << std::endl; GPU_DEBUG_TRACE_DETAIL << " user_tensor shape: " << user_tensor->get_shape().to_string() << std::endl; @@ -729,7 +749,7 @@ std::vector SyncInferRequest::prepare_input(const std::string auto device_tensor_et = convert_to_supported_device_type(element_type); bool convert_needed = is_convert_required(element_type, device_tensor_et); - if (is_remote) { + if (is_remote_tensor_impl) { if (convert_needed) { m_plugin_inputs[input_idx] = { create_device_tensor(pshape, cldnn::element_type_to_data_type(element_type), @@ -747,11 +767,11 @@ std::vector SyncInferRequest::prepare_input(const std::string } else { m_plugin_inputs[input_idx] = { usm_host_ptr->get_impl(), user_tensor_wrapper.owner }; } - is_remote = true; + is_remote_tensor_impl = true; } auto user_tensor_mem_type = cldnn::allocation_type::unknown; - if (!is_remote) { + if (!is_remote_tensor_impl && !is_generic_remote) { user_tensor_mem_type = engine.detect_usm_allocation_type(user_tensor_wrapper.ptr->data()); } @@ -766,13 +786,13 @@ std::vector SyncInferRequest::prepare_input(const std::string user_tensor_mem_type == cldnn::allocation_type::usm_host; bool update_device_tensor = (m_plugin_inputs.count(input_idx) == 0) || - (m_plugin_inputs[input_idx].owner == TensorOwner::USER && !is_remote) || + (m_plugin_inputs[input_idx].owner == TensorOwner::USER && !is_remote_tensor_impl) || (plugin_tensor_mem_type != cldnn::allocation_type::usm_host && usm_host_raw_ptr); if (update_device_tensor) { // If device input hasn't been created, then try to use user memory if it's usm_host, or allocate new device buffer m_plugin_inputs[input_idx] = create_or_share_device_tensor(user_tensor_wrapper, internal_name, pshape, device_tensor_et, convert_needed); - } else if (!is_remote) { + } else if (!is_remote_tensor_impl) { // Device memory has been created on previous iterations. Try to reuse whenever it's possible auto device_tensor_wrapper = m_plugin_inputs.at(input_idx); auto device_tensor = std::dynamic_pointer_cast(device_tensor_wrapper.ptr); @@ -819,18 +839,21 @@ std::vector SyncInferRequest::prepare_input(const std::string } cldnn::event::ptr ret_event = nullptr; - if (!is_remote && !convert_needed) { - auto src_ptr = static_cast(user_tensor->data()); - if (!same_host_mem(memory, src_ptr)) { - ret_event = memory->copy_from(stream, src_ptr, false); - } - } if (convert_needed) { - if (is_remote) { - convert_and_copy(remote_ptr->get_memory(), device_tensor->get_memory(), stream); + if (is_remote_tensor_impl) { + convert_and_copy(remote_tensor_impl_ptr->get_memory(), device_tensor->get_memory(), stream); } else { convert_and_copy(user_tensor.get(), device_tensor.get(), stream); } + } else { + if (!is_remote_tensor_impl && !is_generic_remote) { + auto src_ptr = static_cast(user_tensor->data()); + if (!same_host_mem(memory, src_ptr)) { + ret_event = memory->copy_from(stream, src_ptr, false); + } + } else if (is_generic_remote) { + user_tensor->copy_to(device_tensor); + } } GPU_DEBUG_TRACE_DETAIL << internal_name << " with index " << input_idx << " prepare input: " << memory->buffer_ptr() @@ -851,9 +874,11 @@ std::vector SyncInferRequest::prepare_output(size_t output_id auto is_dynamic = pshape.is_dynamic(); auto element_type = port.get_element_type(); auto user_tensor = user_tensor_wrapper.ptr; - auto remote_ptr = std::dynamic_pointer_cast(user_tensor); + auto iremote_tensor_ptr = std::dynamic_pointer_cast(user_tensor); + auto remote_tensor_impl_ptr = std::dynamic_pointer_cast(user_tensor); auto internal_name = m_output_names_map.at(output_idx); - bool is_remote = remote_ptr != nullptr; + bool is_remote_tensor_impl = remote_tensor_impl_ptr != nullptr; + bool is_generic_remote = iremote_tensor_ptr != nullptr && remote_tensor_impl_ptr == nullptr; GPU_DEBUG_TRACE_DETAIL << "Prepare output for " << internal_name << std::endl; GPU_DEBUG_TRACE_DETAIL << " port shape : " << pshape.to_string() << std::endl; @@ -874,7 +899,7 @@ std::vector SyncInferRequest::prepare_output(size_t output_id auto device_tensor_et = convert_to_supported_device_type(element_type); bool convert_needed = is_convert_required(device_tensor_et, element_type); - if (is_remote && !convert_needed && !is_dynamic) { + if (is_remote_tensor_impl && !convert_needed && !is_dynamic) { m_plugin_outputs[output_idx] = user_tensor_wrapper; } @@ -882,7 +907,8 @@ std::vector SyncInferRequest::prepare_output(size_t output_id auto is_cpu_impl = network->is_cpu_impl(internal_name); bool has_device_buffer = m_plugin_outputs.count(output_idx) > 0; bool update_device_tensor = !has_device_buffer || - (m_plugin_outputs[output_idx].owner == TensorOwner::USER && !is_remote); + is_generic_remote || + (m_plugin_outputs[output_idx].owner == TensorOwner::USER && !is_remote_tensor_impl); if (update_device_tensor) { m_plugin_outputs[output_idx] = create_or_share_device_tensor(user_tensor_wrapper, internal_name, pshape, device_tensor_et, is_cpu_impl || convert_needed); diff --git a/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.cpp b/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.cpp index b8c9bb45e74395..a2ddc7dd2a4dff 100644 --- a/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.cpp +++ b/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.cpp @@ -17,9 +17,25 @@ #include #endif +#define TRY_CATCH_CL_ERROR(...) \ + try { \ + __VA_ARGS__; \ + } catch (cl::Error const& err) { \ + OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); \ + } + namespace cldnn { namespace ocl { +static inline cldnn::event::ptr create_event(stream& stream, size_t bytes_count, bool need_user_event) { + if (bytes_count == 0) { + GPU_DEBUG_TRACE_DETAIL << "Skip memory operation for 0 size tensor" << std::endl; + return stream.create_user_event(true); + } + + return need_user_event ? stream.create_user_event(true) : stream.create_base_event(); +} + static int get_cl_map_type(mem_lock_type type) { switch (type) { case mem_lock_type::read: @@ -112,75 +128,66 @@ shared_mem_params gpu_buffer::get_internal_params() const { 0}; } -event::ptr gpu_buffer::copy_from(stream& stream, const memory& other, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - switch (other.get_allocation_type()) { - case allocation_type::usm_host: - case allocation_type::usm_shared: - { +event::ptr gpu_buffer::copy_from(stream& stream, const void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; + + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + auto src_ptr = reinterpret_cast(data_ptr) + src_offset; + + TRY_CATCH_CL_ERROR(cl_stream->get_cl_queue().enqueueWriteBuffer(_buffer, blocking, dst_offset, size, src_ptr, nullptr, cl_event)) + + return result_event; +} + +event::ptr gpu_buffer::copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) { + auto result_event = create_event(stream, size, false); + if (size == 0) + return result_event; + + switch (src_mem.get_allocation_type()) { + case allocation_type::usm_host: + case allocation_type::usm_shared: + case allocation_type::usm_device: { // If other is gpu_usm, down cast to gpu_buffer is not possible. // But it can read as host ptr if it's allocation type is either usm_host or usm_shared. - auto& mem_inst = downcast(other); - return copy_from(stream, mem_inst.buffer_ptr(), blocking, 0, 0); + auto usm_mem = downcast(&src_mem); + return copy_from(stream, usm_mem->buffer_ptr(), src_offset, dst_offset, size, blocking); } - case allocation_type::cl_mem: - { - auto& cl_stream = downcast(stream); - auto& mem_inst = downcast(other); - auto ev = stream.create_base_event(); - cl::Event& ev_ocl = downcast(ev.get())->get(); - try { - cl_stream.get_cl_queue().enqueueCopyBuffer(mem_inst.get_buffer(), get_buffer(), 0, 0, other.size(), nullptr, &ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } + case allocation_type::cl_mem: { + OPENVINO_ASSERT(!src_mem.get_layout().format.is_image_2d()); + + auto cl_stream = downcast(&stream); + auto cl_mem_buffer = downcast(&src_mem); + auto ev_ocl = &downcast(result_event.get())->get(); + + TRY_CATCH_CL_ERROR( + cl_stream->get_cl_queue().enqueueCopyBuffer(cl_mem_buffer->get_buffer(), get_buffer(), src_offset, dst_offset, size, nullptr, ev_ocl)); + if (blocking) - ev->wait(); + result_event->wait(); - return ev; + return result_event; } - case allocation_type::usm_device: - default: - throw std::runtime_error("Unsupported allocation_type."); + default: + OPENVINO_THROW("[GPU] Unsupported buffer type for gpu_buffer::copy_from() function"); } } -event::ptr gpu_buffer::copy_from(stream& stream, const void* host_ptr, bool blocking, size_t dst_offset, size_t data_size) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - data_size = (data_size == 0) ? size() : data_size; - try { - cl_stream.get_cl_queue().enqueueWriteBuffer(_buffer, blocking, dst_offset, data_size, host_ptr, nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } +event::ptr gpu_buffer::copy_to(stream& stream, void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; - return ev; -} + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + auto dst_ptr = reinterpret_cast(data_ptr) + dst_offset; -event::ptr gpu_buffer::copy_to(stream& stream, void* host_ptr, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - try { - cl_stream.get_cl_queue().enqueueReadBuffer(_buffer, blocking, 0, size(), host_ptr, nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } + TRY_CATCH_CL_ERROR(cl_stream->get_cl_queue().enqueueReadBuffer(_buffer, blocking, src_offset, size, dst_ptr, nullptr, cl_event)); - return ev; + return result_event; } #ifdef ENABLE_ONEDNN_FOR_GPU @@ -341,89 +348,63 @@ shared_mem_params gpu_image2d::get_internal_params() const { 0}; } -event::ptr gpu_image2d::copy_from(stream& stream, const memory& other, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto& casted = downcast(other); - auto ev = stream.create_base_event(); - cl::Event* ev_ocl = &downcast(ev.get())->get(); - try { - cl_stream.get_cl_queue().enqueueCopyImage(casted.get_buffer(), get_buffer(), - {0, 0, 0}, {0, 0, 0}, {_width, _height, 1}, - nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } +event::ptr gpu_image2d::copy_from(stream& stream, const void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; - if (blocking) - ev->wait(); + OPENVINO_ASSERT(dst_offset == 0, "[GPU] Unsupported dst_offset value for gpu_image2d::copy_from() function"); + OPENVINO_ASSERT(size == _bytes_count, "[GPU] Unsupported data_size value for gpu_image2d::copy_from() function"); - return ev; -} + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + auto src_ptr = reinterpret_cast(data_ptr) + src_offset; -event::ptr gpu_image2d::copy_from(stream& stream, const void* host_ptr, bool blocking, size_t dst_offset, size_t data_size) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - OPENVINO_ASSERT(dst_offset == 0, "[GPU] dst_offset should be zero for gpu_image2d::copy_from."); - OPENVINO_ASSERT(data_size == 0, "[GPU] data_size should be zero for gpu_image2d::copy_from."); - auto& cl_stream = downcast(stream); - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - try { - cl_stream.get_cl_queue().enqueueWriteImage(_buffer, blocking, {0, 0, 0}, {_width, _height, 1}, - _row_pitch, _slice_pitch, host_ptr, nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } + TRY_CATCH_CL_ERROR( + cl_stream->get_cl_queue().enqueueWriteImage(_buffer, blocking, {0, 0, 0}, {_width, _height, 1}, _row_pitch, _slice_pitch, src_ptr, nullptr, cl_event)); - return ev; + return result_event; } -event::ptr gpu_image2d::copy_to(stream& stream, memory& other, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto& casted = downcast(other); - auto ev = stream.create_base_event(); - cl::Event* ev_ocl = &downcast(ev.get())->get(); - try { - cl_stream.get_cl_queue().enqueueCopyImage(get_buffer(), casted.get_buffer(), - {0, 0, 0}, {0, 0, 0}, {_width, _height, 1}, - nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } +event::ptr gpu_image2d::copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) { + auto result_event = create_event(stream, size, false); + if (size == 0) + return result_event; + OPENVINO_ASSERT(src_mem.get_layout().format.is_image_2d(), "Unsupported buffer type for gpu_image2d::copy_from() function"); + OPENVINO_ASSERT(src_offset == 0, "[GPU] Unsupported dst_offset value for gpu_image2d::copy_from() function"); + OPENVINO_ASSERT(dst_offset == 0, "[GPU] Unsupported dst_offset value for gpu_image2d::copy_from() function"); + OPENVINO_ASSERT(size == _bytes_count, "[GPU] Unsupported data_size value for gpu_image2d::copy_from() function"); + + auto cl_stream = downcast(&stream); + auto cl_event = &downcast(result_event.get())->get(); + auto cl_image_mem = downcast(&src_mem); + + TRY_CATCH_CL_ERROR( + cl_stream->get_cl_queue().enqueueCopyImage(cl_image_mem->get_buffer(), get_buffer(), {0, 0, 0}, {0, 0, 0}, {_width, _height, 1}, nullptr, cl_event)); if (blocking) - ev->wait(); + cl_event->wait(); - return ev; + return result_event; } -event::ptr gpu_image2d::copy_to(stream& stream, void* host_ptr, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - try { - cl_stream.get_cl_queue().enqueueReadImage(_buffer, blocking, {0, 0, 0}, {_width, _height, 1}, - _row_pitch, _slice_pitch, host_ptr, nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } +event::ptr gpu_image2d::copy_to(stream& stream, void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; - return ev; + OPENVINO_ASSERT(src_offset == 0, "[GPU] Unsupported src_offset value for gpu_image2d::copy_from() function"); + OPENVINO_ASSERT(size == _bytes_count, "[GPU] Unsupported data_size value for gpu_image2d::copy_from() function"); + + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + auto dst_ptr = reinterpret_cast(data_ptr) + dst_offset; + + TRY_CATCH_CL_ERROR( + cl_stream->get_cl_queue().enqueueReadImage(_buffer, blocking, {0, 0, 0}, {_width, _height, 1}, _row_pitch, _slice_pitch, dst_ptr, nullptr, cl_event)); + + return result_event; } gpu_media_buffer::gpu_media_buffer(ocl_engine* engine, @@ -565,91 +546,65 @@ event::ptr gpu_usm::fill(stream& stream) { return fill(stream, 0); } -event::ptr gpu_usm::copy_from(stream& stream, const memory& other, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - if (other.get_allocation_type() == allocation_type::cl_mem) { - // Copy cl_mem to usm_memory by cl::CommandQueue::enqueueReadBuffer() - auto& mem_inst = downcast(other); - try { - cl_stream.get_cl_queue().enqueueReadBuffer(mem_inst.get_buffer(), blocking, 0, size(), this->buffer_ptr(), nullptr, ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } - } else { - auto& casted = downcast(other); - auto dst_ptr = get_buffer().get(); - auto src_ptr = casted.get_buffer().get(); - try { - cl_stream.get_usm_helper().enqueue_memcpy(cl_stream.get_cl_queue(), - dst_ptr, - src_ptr, - _bytes_count, - blocking, - nullptr, - ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } - } - return ev; +event::ptr gpu_usm::copy_from(stream& stream, const void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; + + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + auto src_ptr = reinterpret_cast(data_ptr) + src_offset; + auto dst_ptr = reinterpret_cast(buffer_ptr()) + dst_offset; + + TRY_CATCH_CL_ERROR(cl_stream->get_usm_helper().enqueue_memcpy(cl_stream->get_cl_queue(), dst_ptr, src_ptr, size, blocking, nullptr, cl_event)); + + return result_event; } -event::ptr gpu_usm::copy_from(stream& stream, const void* host_ptr, bool blocking, size_t dst_offset, size_t data_size) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto dst_ptr = get_buffer().get(); - if (dst_offset > 0) { - auto tmp_dst_ptr = reinterpret_cast(dst_ptr); - tmp_dst_ptr += dst_offset; - dst_ptr = reinterpret_cast(tmp_dst_ptr); - } - data_size = (data_size == 0) ? _bytes_count : data_size; - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - try { - cl_stream.get_usm_helper().enqueue_memcpy(cl_stream.get_cl_queue(), - dst_ptr, - host_ptr, - data_size, - blocking, - nullptr, - ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); +event::ptr gpu_usm::copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; + + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + + if (src_mem.get_allocation_type() == allocation_type::cl_mem) { + auto cl_mem_buffer = downcast(&src_mem); + auto dst_ptr = reinterpret_cast(buffer_ptr()); + + return cl_mem_buffer->copy_to(stream, dst_ptr, src_offset, dst_offset, size, blocking); + } else if (memory_capabilities::is_usm_type(src_mem.get_allocation_type())) { + auto usm_mem = downcast(&src_mem); + auto src_ptr = reinterpret_cast(usm_mem->buffer_ptr()) + src_offset; + auto dst_ptr = reinterpret_cast(buffer_ptr()) + dst_offset; + + TRY_CATCH_CL_ERROR(cl_stream->get_usm_helper().enqueue_memcpy(cl_stream->get_cl_queue(), dst_ptr, src_ptr, size, blocking, nullptr, cl_event)); + } else { + std::vector tmp_buf; + tmp_buf.resize(size); + src_mem.copy_to(stream, tmp_buf.data(), src_offset, 0, size, true); + + GPU_DEBUG_TRACE_DETAIL << "Suboptimal copy call from " << src_mem.get_allocation_type() << " to " << get_allocation_type() << "\n"; + return copy_from(stream, tmp_buf.data(), 0, 0, size, blocking); } - return ev; + + return result_event; } -event::ptr gpu_usm::copy_to(stream& stream, void* host_ptr, bool blocking) { - if (_bytes_count == 0) { - GPU_DEBUG_TRACE_DETAIL << "Skip EnqueueMemcpy for 0 size tensor" << std::endl; - return stream.create_user_event(true); - } - auto& cl_stream = downcast(stream); - auto ev = blocking ? stream.create_user_event(true) : stream.create_base_event(); - cl::Event* ev_ocl = blocking ? nullptr : &downcast(ev.get())->get(); - auto src_ptr = get_buffer().get(); - try { - cl_stream.get_usm_helper().enqueue_memcpy(cl_stream.get_cl_queue(), - host_ptr, - src_ptr, - _bytes_count, - blocking, - nullptr, - ev_ocl); - } catch (cl::Error const& err) { - OPENVINO_THROW(OCL_ERR_MSG_FMT(err)); - } - return ev; +event::ptr gpu_usm::copy_to(stream& stream, void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const { + auto result_event = create_event(stream, size, blocking); + if (size == 0) + return result_event; + + auto cl_stream = downcast(&stream); + auto cl_event = blocking ? nullptr : &downcast(result_event.get())->get(); + auto src_ptr = reinterpret_cast(buffer_ptr()) + src_offset; + auto dst_ptr = reinterpret_cast(data_ptr) + dst_offset; + + TRY_CATCH_CL_ERROR(cl_stream->get_usm_helper().enqueue_memcpy(cl_stream->get_cl_queue(), dst_ptr, src_ptr, size, blocking, nullptr, cl_event)); + + return result_event; } #ifdef ENABLE_ONEDNN_FOR_GPU diff --git a/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.hpp b/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.hpp index a4270c5f9e71d6..e2a68537cdc69e 100644 --- a/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.hpp +++ b/src/plugins/intel_gpu/src/runtime/ocl/ocl_memory.hpp @@ -40,10 +40,9 @@ struct gpu_buffer : public lockable_gpu_mem, public memory { return _buffer; } - event::ptr copy_from(stream& stream, const memory& other, bool blocking) override; - event::ptr copy_from(stream& stream, const void* host_ptr, bool blocking, size_t dst_offset, size_t data_size) override; - - event::ptr copy_to(stream& stream, void* other , bool blocking) override; + event::ptr copy_from(stream& stream, const void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) override; + event::ptr copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) override; + event::ptr copy_to(stream& stream, void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const override; #ifdef ENABLE_ONEDNN_FOR_GPU dnnl::memory get_onednn_memory(dnnl::memory::desc /* desc */, int64_t offset = 0) const override; @@ -67,11 +66,9 @@ struct gpu_image2d : public lockable_gpu_mem, public memory { return _buffer; } - event::ptr copy_from(stream& stream, const memory& other, bool blocking) override; - event::ptr copy_from(stream& stream, const void* other, bool blocking, size_t dst_offset, size_t data_size) override; - - event::ptr copy_to(stream& stream, memory& other, bool blocking) override; - event::ptr copy_to(stream& stream, void* other, bool blocking) override; + event::ptr copy_from(stream& stream, const void* data_ptr, size_t src_offset = 0, size_t dst_offset = 0, size_t size = 0, bool blocking = true) override; + event::ptr copy_from(stream& stream, const memory& src_mem, size_t src_offset = 0, size_t dst_offset = 0, size_t size = 0, bool blocking = true) override; + event::ptr copy_to(stream& stream, void* data_ptr, size_t src_offset = 0, size_t dst_offset = 0, size_t size = 0, bool blocking = true) const override; protected: cl::Image2D _buffer; @@ -119,10 +116,10 @@ struct gpu_usm : public lockable_gpu_mem, public memory { event::ptr fill(stream& stream) override; shared_mem_params get_internal_params() const override; - event::ptr copy_from(stream& stream, const memory& other, bool blocking) override; - event::ptr copy_from(stream& stream, const void* host_ptr, bool blocking, size_t dst_offset, size_t data_size) override; + event::ptr copy_from(stream& stream, const void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) override; + event::ptr copy_from(stream& stream, const memory& src_mem, size_t src_offset, size_t dst_offset, size_t size, bool blocking) override; + event::ptr copy_to(stream& stream, void* data_ptr, size_t src_offset, size_t dst_offset, size_t size, bool blocking) const override; - event::ptr copy_to(stream& stream, void* host_ptr, bool blocking) override; #ifdef ENABLE_ONEDNN_FOR_GPU dnnl::memory get_onednn_memory(dnnl::memory::desc /* desc */, int64_t offset = 0) const override; #endif diff --git a/src/plugins/intel_gpu/tests/functional/CMakeLists.txt b/src/plugins/intel_gpu/tests/functional/CMakeLists.txt index 598b2725b75178..1776a7a2f54cd3 100644 --- a/src/plugins/intel_gpu/tests/functional/CMakeLists.txt +++ b/src/plugins/intel_gpu/tests/functional/CMakeLists.txt @@ -30,6 +30,7 @@ ov_add_test_target( DEPENDENCIES openvino_intel_gpu_plugin LINK_LIBRARIES + openvino::reference funcSharedTests OpenCL::NewHeaders # should come before OpenCL::OpenCL OpenCL::OpenCL diff --git a/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp b/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp index 17168e792adf78..ee6486f432a380 100644 --- a/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp +++ b/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp @@ -14,6 +14,7 @@ #include "common_test_utils/subgraph_builders/conv_pool_relu.hpp" #include "common_test_utils/subgraph_builders/split_multi_conv_concat.hpp" #include "common_test_utils/subgraph_builders/convert_transpose.hpp" +#include "openvino/reference/utils/coordinate_transform.hpp" class OVRemoteTensor_Test : public ov::test::TestsCommon { protected: @@ -2495,3 +2496,337 @@ TEST(OVRemoteContextGPU, smoke_RemoteTensorSetShape) { OV_ASSERT_NO_THROW(remote_tensor.set_shape({1, 3, 4, 5})); OV_ASSERT_NO_THROW(remote_tensor.set_shape({3, 3, 4, 5})); } + +TEST(RemoteTensor, smoke_CopyToEmptyTensor) { +#if defined(ANDROID) + GTEST_SKIP(); +#endif + auto core = ov::Core(); + auto context = core.get_default_context(ov::test::utils::DEVICE_GPU); + + auto empty_remote_tensor = ov::RemoteTensor(); + auto remote_tensor = context.create_tensor(ov::element::f32, ov::Shape{1, 2, 3, 4}); + + OV_EXPECT_THROW_HAS_SUBSTRING(empty_remote_tensor.copy_to(remote_tensor), + ov::Exception, + "Check '_impl != nullptr' failed"); +} + +TEST(RemoteTensor, smoke_EmptyRoiTensor) { +#if defined(ANDROID) + GTEST_SKIP(); +#endif + + auto empty_remote_tensor = ov::RemoteTensor(); + + OV_EXPECT_THROW_HAS_SUBSTRING(ov::RemoteTensor(empty_remote_tensor, ov::Coordinate{}, ov::Coordinate{}), + ov::Exception, + "Cannot create RoiRemoteTensor on top of empty tensor"); +} + +struct TestParams { + ov::Shape src_shape; + ov::Shape dst_shape; + ov::Coordinate begin; + ov::Coordinate end; +}; + +struct RemoteTensor : ::testing::TestWithParam> {}; + +namespace { +template +std::vector fill_data(const ov::Tensor& tensor) { + std::vector actual; + const T* data = tensor.data(); + auto strides = tensor.get_strides(); + for (auto&& c : ov::CoordinateTransformBasic{tensor.get_shape()}) { + size_t offset = 0; + for (size_t i = 0; i < strides.size(); i++) + offset += c[i] * strides[i]; + actual.emplace_back(*(data + offset / tensor.get_element_type().size())); + } + return actual; +} + +template +void compare_data(const ov::Tensor& src, const ov::Tensor& dst) { + auto source_vec = fill_data(src); + auto dest_vec = fill_data(dst); + + ASSERT_EQ(source_vec.size(), dest_vec.size()); + + for (size_t i = 0; i < source_vec.size(); i++) { + ASSERT_EQ(source_vec[i], dest_vec[i]); + } +} + +template ::value_type> +void init_tensor(const ov::Tensor& tensor) { + const auto origPtr = tensor.data(); + ASSERT_NE(nullptr, origPtr); + for (size_t i = 0; i < tensor.get_size(); ++i) { + origPtr[i] = static_cast(i); + } +} + +void init_tensor(const ov::Tensor& tensor) { + switch (tensor.get_element_type()) { + case ov::element::f32: + init_tensor(tensor); + break; + case ov::element::u8: + init_tensor(tensor); + break; + default: + OPENVINO_THROW("Unsupported data type"); + } +} + +void compare_tensors(const ov::Tensor& src, const ov::Tensor& dst) { + ASSERT_EQ(src.get_byte_size(), dst.get_byte_size()); + ASSERT_EQ(src.get_size(), dst.get_size()); + ASSERT_EQ(src.get_element_type(), dst.get_element_type()); + switch (src.get_element_type()) { + case ov::element::f32: + compare_data::value_type>(src, dst); + break; + case ov::element::u8: + compare_data::value_type>(src, dst); + break; + default: + OPENVINO_THROW("Unsupported data type"); + } +} + +ov::RemoteTensor create_tensor(ov::intel_gpu::ocl::ClContext context, + RemoteTensorSharingType sharing_type, + const ov::element::Type& type, + const ov::Shape& shape) { + switch (sharing_type) { + case RemoteTensorSharingType::PLUGIN_CL_TENSOR: + return context.create_tensor(type, shape); + case RemoteTensorSharingType::PLUGIN_HOST_TENSOR: + return context.create_usm_host_tensor(type, shape); + case RemoteTensorSharingType::PLUGIN_USM_DEVICE_TENSOR: + return context.create_usm_device_tensor(type, shape); + default: + OPENVINO_THROW("Unsupported tensor allocation type"); + } +} +} // namespace + +TEST_P(RemoteTensor, smoke_CopyFrom) { +#if defined(ANDROID) + GTEST_SKIP(); +#endif + ov::element::Type type; + TestParams p; + RemoteTensorSharingType sharing_type; + std::tie(type, sharing_type, p) = GetParam(); + + auto core = ov::Core(); + auto remote_context = core.get_default_context(ov::test::utils::DEVICE_GPU); + auto gpu_context = remote_context.as(); + bool use_roi = p.begin != ov::Coordinate{} && p.end != ov::Coordinate{}; + + auto host_tensor_ref = ov::Tensor(type, p.src_shape); + init_tensor(host_tensor_ref); + + auto first_remote_tensor = create_tensor(gpu_context, sharing_type, type, p.src_shape); + auto second_remote_tensor = create_tensor(gpu_context, sharing_type, type, p.dst_shape); + + // Copy from remote tensor to remote tensor + second_remote_tensor.copy_from(first_remote_tensor); + + // Check updated shape after copy_from call + ASSERT_EQ(second_remote_tensor.get_shape(), first_remote_tensor.get_shape()); + + // Copy from host tensor to remote tensor + if (use_roi) { + auto roi_host_tensor_ref = ov::Tensor(host_tensor_ref, p.begin, p.end); + auto roi_second_remote_tensor = ov::RemoteTensor(second_remote_tensor, p.begin, p.end); + auto second_remote_tensor_shape = second_remote_tensor.get_shape(); + + roi_second_remote_tensor.copy_from(roi_host_tensor_ref); + + // Ensure that the shape of the underlying RemoteTensor of RoiRemoteTensor remains unchanged + ASSERT_EQ(second_remote_tensor.get_shape(), second_remote_tensor_shape); + ASSERT_EQ(roi_second_remote_tensor.get_shape(), roi_host_tensor_ref.get_shape()); + + auto result_host_tensor = ov::Tensor(type, roi_second_remote_tensor.get_shape()); + roi_second_remote_tensor.copy_to(result_host_tensor); + + compare_tensors(roi_host_tensor_ref, result_host_tensor); + } else { + second_remote_tensor.copy_from(host_tensor_ref); + + auto result_host_tensor = ov::Tensor(type, p.src_shape); + second_remote_tensor.copy_to(result_host_tensor); + + compare_tensors(host_tensor_ref, result_host_tensor); + } +} + +TEST_P(RemoteTensor, smoke_CopyTo) { +#if defined(ANDROID) + GTEST_SKIP(); +#endif + ov::element::Type type; + TestParams p; + RemoteTensorSharingType sharing_type; + std::tie(type, sharing_type, p) = GetParam(); + + auto core = ov::Core(); + auto remote_context = core.get_default_context(ov::test::utils::DEVICE_GPU); + auto gpu_context = remote_context.as(); + bool use_roi = p.begin != ov::Coordinate{} && p.end != ov::Coordinate{}; + + auto host_tensor_ref = ov::Tensor(type, p.src_shape); + init_tensor(host_tensor_ref); + + auto first_remote_tensor = create_tensor(gpu_context, sharing_type, type, p.src_shape); + auto second_remote_tensor = create_tensor(gpu_context, sharing_type, type, p.dst_shape); + + // Copy to remote tensor from remote tensor + first_remote_tensor.copy_to(second_remote_tensor); + + // Check updated shape after copy_to call + ASSERT_EQ(second_remote_tensor.get_shape(), first_remote_tensor.get_shape()); + + // Copy to remote tensor from host tensor + if (use_roi) { + auto roi_host_tensor_ref = ov::Tensor(host_tensor_ref, p.begin, p.end); + auto roi_second_remote_tensor = ov::RemoteTensor(second_remote_tensor, p.begin, p.end); + auto second_remote_tensor_shape = second_remote_tensor.get_shape(); + + roi_host_tensor_ref.copy_to(roi_second_remote_tensor); + + // Ensure that the shape of the underlying RemoteTensor of RoiRemoteTensor remains unchanged + ASSERT_EQ(second_remote_tensor.get_shape(), second_remote_tensor_shape); + ASSERT_EQ(roi_second_remote_tensor.get_shape(), roi_host_tensor_ref.get_shape()); + + auto result_host_tensor = ov::Tensor(type, roi_second_remote_tensor.get_shape()); + roi_second_remote_tensor.copy_to(result_host_tensor); + + compare_tensors(roi_host_tensor_ref, result_host_tensor); + } else { + host_tensor_ref.copy_to(second_remote_tensor); + + auto host_tensor = ov::Tensor(type, p.src_shape); + second_remote_tensor.copy_to(host_tensor); + + compare_tensors(host_tensor_ref, host_tensor); + } +} + +INSTANTIATE_TEST_SUITE_P(copy_tests, + RemoteTensor, + ::testing::Combine(::testing::Values(ov::element::u8, + ov::element::f32), + ::testing::Values(RemoteTensorSharingType::PLUGIN_CL_TENSOR, + RemoteTensorSharingType::PLUGIN_USM_DEVICE_TENSOR, + RemoteTensorSharingType::PLUGIN_HOST_TENSOR), + ::testing::Values(TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{4, 3, 2, 5}, + ov::Coordinate{}, ov::Coordinate{} + }, + TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{1, 3, 2, 5}, + ov::Coordinate{}, ov::Coordinate{} + }, + TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{4, 3, 2, 5}, + ov::Coordinate{0, 0, 0, 0}, ov::Coordinate{2, 3, 2, 5} + }, + TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{4, 3, 2, 5}, + ov::Coordinate{0, 0, 0, 4}, ov::Coordinate{2, 3, 2, 5} + }, + TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{4, 3, 2, 5}, + ov::Coordinate{2, 1, 1, 4}, ov::Coordinate{4, 3, 2, 5} + }, + TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{4, 3, 2, 5}, + ov::Coordinate{2, 0, 1, 0}, ov::Coordinate{4, 3, 2, 5} + }, + TestParams { + ov::Shape{4, 3, 2, 5}, ov::Shape{4, 3, 2, 5}, + ov::Coordinate{0, 1, 1, 0}, ov::Coordinate{4, 2, 2, 3} + }))); + +TEST(RemoteTensor, smoke_CanSetRoiRemoteTensor) { +#if defined(ANDROID) + GTEST_SKIP(); +#endif + auto core = ov::Core(); + auto model = ov::test::behavior::getDefaultNGraphFunctionForTheDevice(); + + auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_GPU); + + auto input = model->get_parameters().at(0); + auto output = model->get_results().at(0); + + auto input_shape = input->get_shape(); + auto output_shape = output->get_shape(); + + auto gpu_context = compiled_model.get_context().as(); + cl_context ctx = gpu_context; + auto ocl_instance = std::make_shared(ctx); + + auto host_tensor = ov::Tensor(input->get_element_type(), input_shape); + init_tensor(host_tensor); + + auto output_tensor_copy_0 = ov::Tensor(output->get_element_type(), output_shape); + auto output_tensor_copy_1 = ov::Tensor(output->get_element_type(), output_shape); + + auto infer_request = compiled_model.create_infer_request(); + { + auto user_input_tensor = gpu_context.create_tensor(input->get_element_type(), input_shape); + auto user_output_tensor = gpu_context.create_tensor(output->get_element_type(), output_shape); + + user_input_tensor.copy_from(host_tensor); + + infer_request.set_tensor(input, user_input_tensor); + infer_request.set_tensor(output, user_output_tensor); + + OV_ASSERT_NO_THROW(infer_request.infer()); + + auto output_tensor = infer_request.get_tensor(output); + ASSERT_EQ(output_tensor.get_shape(), output_shape); + + output_tensor.copy_to(output_tensor_copy_0); + } + { + auto larger_input_shape = input_shape; + for (size_t i = 0; i < input_shape.size(); i++) + larger_input_shape[i] += 2; + + auto larger_output_shape = input_shape; + for (size_t i = 0; i < input_shape.size(); i++) + larger_output_shape[i] += 2; + + auto roi_begin = ov::Coordinate(input_shape.size(), 2); + auto roi_end = ov::Coordinate(larger_input_shape); + + auto user_input_tensor = gpu_context.create_tensor(input->get_element_type(), larger_input_shape); + auto user_input_tensor_roi = ov::RemoteTensor(user_input_tensor, roi_begin, roi_end); + auto user_output_tensor = gpu_context.create_tensor(output->get_element_type(), larger_output_shape); + auto user_output_tensor_roi = ov::RemoteTensor(user_output_tensor, roi_begin, roi_end); + + user_input_tensor_roi.copy_from(host_tensor); + + infer_request.set_tensor(input, user_input_tensor_roi); + infer_request.set_tensor(output, user_output_tensor_roi); + + OV_ASSERT_NO_THROW(infer_request.infer()); + + auto output_tensor = infer_request.get_tensor(output); + ASSERT_EQ(output_tensor.get_shape(), output_shape); + + output_tensor.copy_to(output_tensor_copy_1); + } + + compare_tensors(output_tensor_copy_0, output_tensor_copy_1); +} diff --git a/src/plugins/intel_gpu/tests/unit/module_tests/usm_memory_test.cpp b/src/plugins/intel_gpu/tests/unit/module_tests/usm_memory_test.cpp index 145e8dc7661974..3f3cbfba69262a 100644 --- a/src/plugins/intel_gpu/tests/unit/module_tests/usm_memory_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/module_tests/usm_memory_test.cpp @@ -24,6 +24,7 @@ #include "program_wrapper.h" #include +#include using namespace cldnn; using namespace ::tests; @@ -40,6 +41,23 @@ struct usm_test_params{ allocation_type type; }; +static void init_device_and_engine(std::shared_ptr& device, + std::shared_ptr& engine, + bool& supports_usm) { + // Find device, which supports USMs. + device_query query(engine_types::ocl, runtime_types::ocl); + auto devices = query.get_available_devices(); + for (const auto& d : devices) { + if (d.second->get_mem_caps().supports_usm()) { + device = std::dynamic_pointer_cast(d.second); + supports_usm = true; + break; + } + } + + engine = std::dynamic_pointer_cast(engine::create(engine_types::ocl, runtime_types::ocl, device)); +} + class BaseUSMTest : public ::testing::TestWithParam { protected: std::shared_ptr _device = nullptr; @@ -47,20 +65,11 @@ class BaseUSMTest : public ::testing::TestWithParam { bool _supports_usm = false; public: void SetUp() override { - // Find device, which supports USMs. - device_query query(engine_types::ocl, runtime_types::ocl); - auto devices = query.get_available_devices(); - for (const auto& d : devices) { - if (d.second->get_mem_caps().supports_usm()) { - _device = std::dynamic_pointer_cast(d.second); - break; - } - } - if (!_device) { - GTEST_SUCCEED(); + init_device_and_engine(_device, _engine, _supports_usm); + + if (!_device || !_engine || !_supports_usm) { + GTEST_SKIP(); } - _engine = std::dynamic_pointer_cast(engine::create(engine_types::ocl, runtime_types::ocl, _device)); - _supports_usm = true; } bool supports_usm() const { return _supports_usm; } @@ -129,13 +138,12 @@ TEST_P(copy_and_read_buffer, basic) { break; } case allocation_type::usm_device: { - auto casted = std::dynamic_pointer_cast(cldnn_mem_src); auto host_buf = _engine->allocate_memory(linear_layout, allocation_type::usm_host); { cldnn::mem_lock lock(host_buf, stream); std::copy(src_buffer.begin(), src_buffer.end(), lock.data()); } - casted->copy_from(stream, *host_buf, true); + cldnn_mem_src->copy_from(stream, *host_buf, true); break; } default: @@ -288,17 +296,15 @@ TEST_P(copy_between_gpu_buffer_and_gpu_usm, basic) { // Fill dst memory switch (p.type) { case allocation_type::usm_host: - case allocation_type::usm_shared: + case allocation_type::usm_shared: case allocation_type::usm_device: { - auto casted = std::dynamic_pointer_cast(mem_dst); - auto ev = casted->copy_from(stream, *usm_host_src, true); + auto ev = mem_dst->copy_from(stream, *usm_host_src, true); ev->wait(); break; } case allocation_type::cl_mem: { - auto casted = std::dynamic_pointer_cast(mem_dst); - auto ev = casted->copy_from(stream, *usm_host_src, true); + auto ev = mem_dst->copy_from(stream, *usm_host_src, true); ev->wait(); break; } @@ -315,7 +321,7 @@ TEST_P(copy_between_gpu_buffer_and_gpu_usm, basic) { std::memcpy(dst_buffer.data(), lock.data(), values_bytes_count); break; } - case allocation_type::usm_device: + case allocation_type::usm_device: case allocation_type::cl_mem: { auto host_buf = _engine->allocate_memory(linear_layout, allocation_type::usm_host); host_buf->copy_from(stream, *mem_dst); @@ -342,82 +348,145 @@ INSTANTIATE_TEST_SUITE_P(cldnn_usm, copy_between_gpu_buffer_and_gpu_usm, ::testi usm_test_params{ allocation_type::usm_device }, })); -class offset_usm_copy : public BaseUSMTest {}; -TEST_P(offset_usm_copy, basic) { - auto p = GetParam(); - if (!supports_usm()) { - return; - } - try { - ocl::ocl_stream stream(*_engine, {}); +struct mem_test_params { + size_t src_offset; + size_t dst_offset; + size_t size; +}; - size_t values_count = 100; - size_t values_bytes_count = values_count * sizeof(float); - std::vector src_buffer(values_count); - std::iota(src_buffer.begin(), src_buffer.end(), 0.0f); +class offset_copy_host : public ::testing::TestWithParam> { +protected: + std::shared_ptr _device = nullptr; + std::shared_ptr _engine = nullptr; + bool _supports_usm = false; +public: + void SetUp() override { + init_device_and_engine(_device, _engine, _supports_usm); - cldnn::layout linear_layout = cldnn::layout(cldnn::data_types::f32, cldnn::format::bfyx, cldnn::tensor(1, 1, int32_t(values_count), 1)); - auto usm_host_src = _engine->allocate_memory(linear_layout, allocation_type::usm_host); + if (!_device || !_engine || !_supports_usm) { + GTEST_SKIP(); + } + } - // Fill usm_host_src memory. - cldnn::mem_lock lock(usm_host_src, stream); - std::copy(src_buffer.begin(), src_buffer.end(), lock.data()); + bool supports_usm() const { return _supports_usm; } +}; - // Create dst memory - auto mem_dst = _engine->allocate_memory(linear_layout, p.type); +class offset_copy : public ::testing::TestWithParam> { +protected: + std::shared_ptr _device = nullptr; + std::shared_ptr _engine = nullptr; + bool _supports_usm = false; +public: + void SetUp() override { + init_device_and_engine(_device, _engine, _supports_usm); - // Fill dst memory - switch (p.type) { - case allocation_type::usm_host: - case allocation_type::usm_shared: - case allocation_type::usm_device: - { - auto casted = std::dynamic_pointer_cast(mem_dst); - auto ev = casted->copy_from(stream, usm_host_src->buffer_ptr(), true, 32, 32); - ev->wait(); - break; - } - case allocation_type::cl_mem: { - auto casted = std::dynamic_pointer_cast(mem_dst); - auto ev = casted->copy_from(stream, usm_host_src->buffer_ptr(), true, 32, 32); - ev->wait(); - break; - } - default: - FAIL() << "Not supported allocation type!"; + if (!_device || !_engine || !_supports_usm) { + GTEST_SKIP(); } + } - // Read from dst mem - std::vector dst_buffer(values_count); - switch (p.type) { - case allocation_type::usm_host: - case allocation_type::usm_shared: { - cldnn::mem_lock lock(mem_dst, stream); - std::memcpy(dst_buffer.data(), lock.data(), values_bytes_count); - break; - } - case allocation_type::usm_device: - case allocation_type::cl_mem: { - auto host_buf = _engine->allocate_memory(linear_layout, allocation_type::usm_host); - host_buf->copy_from(stream, *mem_dst); - { - cldnn::mem_lock lock(host_buf, stream); - std::memcpy(dst_buffer.data(), lock.data(), values_bytes_count); - } - break; - } - default: - FAIL() << "Not supported allocation type!"; - } - bool are_equal = std::equal(src_buffer.begin(), src_buffer.begin() + 8, dst_buffer.begin() + 8); - ASSERT_EQ(true, are_equal); - } catch (const char* msg) { - FAIL() << msg; + bool supports_usm() const { return _supports_usm; } +}; + +TEST_P(offset_copy, basic) { + allocation_type src_allocation_type; + allocation_type dst_allocation_type; + mem_test_params params; + bool use_copy_to; + std::tie(src_allocation_type, dst_allocation_type, params, use_copy_to) = GetParam(); + + const auto copy_size = params.size; + const auto src_size = params.src_offset + copy_size; + const auto dst_size = params.dst_offset + copy_size; + + auto stream = ocl::ocl_stream(*_engine, {}); + const auto src_layout = cldnn::layout({static_cast(src_size)}, cldnn::data_types::u8, cldnn::format::bfyx); + const auto dst_layout = cldnn::layout({static_cast(dst_size)}, cldnn::data_types::u8, cldnn::format::bfyx); + + std::vector src_buffer(src_size); + for (size_t i = 0; i < src_size; i++) + src_buffer[i] = i % 64; + + // Allocate and fill src memory + auto src_memory = _engine->allocate_memory(src_layout, src_allocation_type); + + { + const auto src_offset = 0; + const auto dst_offset = 0; + src_memory->copy_from(stream, src_buffer.data(), src_offset, dst_offset, src_size, true); + } + + // Create dst memory and copy data + auto dst_memory = _engine->allocate_memory(dst_layout, dst_allocation_type); + + if (use_copy_to) { + src_memory->copy_to(stream, *dst_memory, params.src_offset, params.dst_offset, copy_size, true); + } else { + dst_memory->copy_from(stream, *src_memory, params.src_offset, params.dst_offset, copy_size, true); + } + + // Read from dst mem + std::vector dst_buffer(copy_size); + + { + const auto src_offset = params.dst_offset; + const auto dst_offset = 0; + dst_memory->copy_to(stream, dst_buffer.data(), src_offset, dst_offset, copy_size, true); + } + + for (size_t i = 0; i < copy_size; i++) { + ASSERT_EQ(src_buffer[i + params.src_offset], dst_buffer[i]) << i << "\n"; } } -INSTANTIATE_TEST_SUITE_P(cldnn_usm, offset_usm_copy, ::testing::ValuesIn(std::vector{ - usm_test_params{ allocation_type::cl_mem }, - usm_test_params{ allocation_type::usm_host }, - usm_test_params{ allocation_type::usm_device }, -})); +TEST_P(offset_copy_host, basic) { + allocation_type allocation_type; + mem_test_params params; + bool use_copy_to; + std::tie(allocation_type, params, use_copy_to) = GetParam(); + + const auto copy_size = params.size; + const auto src_size = params.src_offset + copy_size; + const auto mem_size = params.dst_offset + copy_size; + + auto stream = ocl::ocl_stream(*_engine, {}); + const auto mem_layout = cldnn::layout({static_cast(mem_size)}, cldnn::data_types::u8, cldnn::format::bfyx); + + std::vector src_buffer(src_size); + std::vector dst_buffer(src_size); + for (size_t i = 0; i < src_size; i++) + src_buffer[i] = i % 64; + + auto memory = _engine->allocate_memory(mem_layout, allocation_type); + memory->copy_from(stream, src_buffer.data(), params.src_offset, params.dst_offset, copy_size, true); + memory->copy_to(stream, dst_buffer.data(), params.dst_offset, params.src_offset, copy_size, true); + + for (size_t i = 0; i < copy_size; i++) { + ASSERT_EQ(src_buffer[i + params.src_offset], dst_buffer[i + params.src_offset]) << i << "\n"; + } +} + +static std::vector test_memory_types { allocation_type::cl_mem, + allocation_type::usm_host, + allocation_type::usm_device }; + +// clang-format off +INSTANTIATE_TEST_SUITE_P(mem_test, + offset_copy, + ::testing::Combine(::testing::ValuesIn(test_memory_types), + ::testing::ValuesIn(test_memory_types), + ::testing::Values(mem_test_params{0, 0, 381}, + mem_test_params{100, 0, 381}, + mem_test_params{0, 79, 381}, + mem_test_params{100, 79, 381}), + ::testing::Values(false, true))); + +// clang-format off +INSTANTIATE_TEST_SUITE_P(mem_test, + offset_copy_host, + ::testing::Combine(::testing::ValuesIn(test_memory_types), + ::testing::Values(mem_test_params{0, 0, 381}, + mem_test_params{100, 0, 381}, + mem_test_params{0, 79, 381}, + mem_test_params{100, 79, 381}), + ::testing::Values(false, true))); From e56d7d71e5731a6daf28e605bc147a0cf64f940a Mon Sep 17 00:00:00 2001 From: Jade Cho Date: Fri, 23 Aug 2024 21:47:44 +0900 Subject: [PATCH 108/117] [GPU] Enable asymmetric onednn convolution (#26173) + Use onednn convolution for asymmetric convolution when the weights zero points tensor is scalar. ### Tickets: - *142818* --- .../graph/graph_optimizer/reorder_inputs.cpp | 15 +-- .../select_preferred_formats.cpp | 18 ++- .../graph/impls/onednn/convolution_onednn.cpp | 86 +++++++------- .../intel_gpu/src/graph/layout_optimizer.cpp | 5 +- .../bcast_and_pad_zp_buffers.cpp | 53 ++++++++- .../bcast_and_pad_zp_buffers.hpp | 2 +- .../src/plugin/transformations_pipeline.cpp | 2 +- .../unit/test_cases/convolution_gpu_test.cpp | 105 ++++++++++++++++++ 8 files changed, 216 insertions(+), 70 deletions(-) diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp index 65cf9a692c91b8..aebdf0b4762036 100644 --- a/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp +++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp @@ -59,20 +59,7 @@ std::map get_preferred_formats(program& p, layout_o onednn_impls_counter++; } - // Fallback to ocl when asymmetric weights convolution is existed. - size_t total_convs = 0; - size_t num_asym_wei_convs = 0; - for (auto n : p.get_processing_order()) { - if (n->is_type()) { - total_convs++; - if (n->as().weights_zero_points_term()) - num_asym_wei_convs++; - } - } - - GPU_DEBUG_LOG << "Number of convolutions with weights zero points: " << num_asym_wei_convs << "/" << total_convs << std::endl; - - if (lo.get_optimization_attributes().use_onednn_impls && (onednn_impls_counter < 1 || num_asym_wei_convs > 0)) { + if (lo.get_optimization_attributes().use_onednn_impls && onednn_impls_counter < 1) { should_update_fmt_map = true; lo.set_optimization_attribute(layout_optimizer::optimization_attributes_type::use_onednn_impls, 0); GPU_DEBUG_LOG << "Disable oneDNN implementations globally" << std::endl; diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/select_preferred_formats.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/select_preferred_formats.cpp index 70d0b70c7fa9fa..7028cfdf424478 100644 --- a/src/plugins/intel_gpu/src/graph/graph_optimizer/select_preferred_formats.cpp +++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/select_preferred_formats.cpp @@ -32,14 +32,6 @@ void select_preferred_formats::run(program& p) { #ifdef ENABLE_ONEDNN_FOR_GPU - // Fallback to ocl when asymmetric weights convolution is existed. - if (_lo.get_optimization_attributes().use_onednn_impls) { - for (auto n : p.get_processing_order()) { - if (n->is_type() && n->as().weights_zero_points_term()) - return; - } - } - auto forcing_map = _lo.get_implementation_forcing(); engine.create_onednn_engine(p.get_config()); @@ -58,8 +50,14 @@ void select_preferred_formats::run(program& p) { // Onednn primitive descriptor creation may fail, for example, due to asymmetric weight. try { if (n->is_type()) { - if (n->as().weights_zero_points_term()) - continue; + if (n->as().weights_zero_points_term()) { + if (n->as().weights_zero_points().get_output_layout().count() != 1 || + n->as().get_groups() > 1) { + // onednn convolution doesn't support per_oc and grouped as weights zero points. + continue; + } + } + auto prim_desc = onednn::get_convolution_primitive_descriptor(*n->get_kernel_impl_params(), dnnl::primitive_attr(), dnnl::memory::format_tag::any); diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp index 4892968cda98a3..e2fe4ae228fe3c 100644 --- a/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp +++ b/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp @@ -29,6 +29,10 @@ struct convolution_onednn : typed_primitive_onednn_impl { DECLARE_OBJECT_TYPE_SERIALIZATION(cldnn::onednn::convolution_onednn) +private: + int _zero_point_mask; + dnnl::memory::data_type _wzp_data_type; + protected: std::unique_ptr clone() const override { return make_unique(*this); @@ -64,49 +68,31 @@ struct convolution_onednn : typed_primitive_onednn_impl { args.insert({DNNL_ARG_ATTR_ZERO_POINTS | DNNL_ARG_SRC, a_zp->get_onednn_memory(desc)}); GPU_DEBUG_GET_INSTANCE(debug_config); - GPU_DEBUG_IF(debug_config->verbose >= static_cast(ov::intel_gpu::LogLevel::TRACE_DETAIL)) { - auto dnnl_mem = a_zp->get_onednn_memory(desc); - void *mapped_ptr = dnnl_mem.map_data(); - if (mapped_ptr) { - GPU_DEBUG_TRACE_DETAIL << instance.id() << " activations_zero_points: "; - for (size_t i = 0; i < desc.get_size(); ++i) { - GPU_DEBUG_TRACE_DETAIL << static_cast(mapped_ptr)[i] << " "; - } - GPU_DEBUG_TRACE_DETAIL << std::endl; - dnnl_mem.unmap_data(mapped_ptr); - } - } + GPU_DEBUG_TRACE_DETAIL << instance.id() << " activations_zero_points: " + << " " << a_zp->get_layout().to_short_string() << std::endl; } if (instance.weights_zero_points_term()) { - throw std::runtime_error("Convolution oneDNN primitive doesn't support asymmetric weights quantization"); - // auto w_zp = instance.weights_zero_points_memory(); - // dnnl::memory::desc desc = onednn::layout_to_memory_desc(w_zp->get_layout(), dnnl::memory::format_tag::a, true); - // args.insert({DNNL_ARG_ATTR_ZERO_POINTS | DNNL_ARG_WEIGHTS, w_zp->get_onednn_memory(desc)}); - - // GPU_DEBUG_GET_INSTANCE(debug_config); - // GPU_DEBUG_IF(debug_config->verbose >= static_cast(ov::intel_gpu::LogLevel::TRACE_DETAIL)) { - // auto dnnl_mem = w_zp->get_onednn_memory(desc); - // void *mapped_ptr = dnnl_mem.map_data(); - // if (mapped_ptr) { - // GPU_DEBUG_TRACE_DETAIL << instance.id() << " weights_zero_points: "; - // for (size_t i = 0; i < desc.get_size(); ++i) { - // GPU_DEBUG_TRACE_DETAIL << static_cast(mapped_ptr)[i] << " "; - // } - // GPU_DEBUG_TRACE_DETAIL << std::endl; - // dnnl_mem.unmap_data(mapped_ptr); - // } - // } + auto w_zp = instance.weights_zero_points_memory(); + dnnl::memory::desc desc = onednn::layout_to_memory_desc(w_zp->get_layout(), dnnl::memory::format_tag::a, true); + args.insert({DNNL_ARG_ATTR_ZERO_POINTS | DNNL_ARG_WEIGHTS, w_zp->get_onednn_memory(desc)}); + + GPU_DEBUG_GET_INSTANCE(debug_config); + GPU_DEBUG_TRACE_DETAIL << instance.id() << " weights_zero_points: " + << " " << w_zp->get_layout().to_short_string() << std::endl; } return args; } - int _zero_point_mask; void set_zero_point_mask(int zero_point_mask) { _zero_point_mask = zero_point_mask; } + void set_weights_zero_point_data_type(dnnl::memory::data_type data_type) { + _wzp_data_type = data_type; + } + template static void set_activation_zero_points_attr(const std::shared_ptr& attrs, cldnn::data_node& node, int& zero_point_mask) { @@ -120,7 +106,8 @@ struct convolution_onednn : typed_primitive_onednn_impl { static std::shared_ptr get_primitive_attributes(const typed_program_node& arg, const kernel_impl_params& impl_params, - int& zero_point_mask) { + int& zero_point_mask, + dnnl::memory::data_type& wzp_data_type) { auto attrs = impl_params.attrs_onednn; if (arg.activations_zero_points_term()) { @@ -139,12 +126,14 @@ struct convolution_onednn : typed_primitive_onednn_impl { } if (arg.weights_zero_points_term()) { - throw std::runtime_error("Convolution oneDNN primitive doesn't support asymmetric weights quantization"); - - // Commented out since oneDNN doesn't support asymmetric weights quantization - // auto& w_zp = arg.weights_zero_points(); - // int mask = w_zp.get_output_layout().count() > 1 ? 2 : 0; - // attrs->set_zero_points(DNNL_ARG_WEIGHTS, mask, {DNNL_RUNTIME_S32_VAL}); + auto& wzp = arg.weights_zero_points(); + auto wzp_layout = wzp.get_output_layout(); + wzp_data_type = convert_data_type(wzp_layout.data_type); + if (wzp_layout.count() == 1) { + attrs->set_zero_points(DNNL_ARG_WEIGHTS, 0, dnnl::memory::dims{}, wzp_data_type); + } else { + throw std::runtime_error("Convolution oneDNN primitive doesn't support PER_OC weights zero points"); + } } return attrs; @@ -192,6 +181,13 @@ struct convolution_onednn : typed_primitive_onednn_impl { ob << typed_pd->get_padding_r(); ob << typed_pd->bias_desc().is_zero(); + const kernel_impl_params* impl_params = reinterpret_cast(ob.getKernelImplParams()); + auto prim = impl_params->typed_desc(); + bool has_wzp = !prim->weights_zero_points.empty(); + if (has_wzp) { + ob << make_data(&_wzp_data_type, sizeof(dnnl::memory::data_type)); + } + std::vector prim_cache; prim_cache = _prim.get_cache_blob(); ob << prim_cache; @@ -225,6 +221,13 @@ struct convolution_onednn : typed_primitive_onednn_impl { bool zero_bias; ib >> zero_bias; + auto prim = impl_params->typed_desc(); + bool has_wzp = !prim->weights_zero_points.empty(); + if (has_wzp) { + ib >> make_data(&_wzp_data_type, sizeof(dnnl::memory::data_type)); + _attrs->set_zero_points(DNNL_ARG_WEIGHTS, 0, dnnl::memory::dims{}, _wzp_data_type); + } + if (zero_bias) { auto prim_desc = std::make_shared( ib.get_engine().get_onednn_engine(), @@ -257,13 +260,18 @@ struct convolution_onednn : typed_primitive_onednn_impl { auto& engine = impl_params.prog->get_engine(); auto& config = impl_params.prog->get_config(); int zero_point_mask = -1; - auto attr = get_primitive_attributes(arg, impl_params, zero_point_mask); + dnnl::memory::data_type wzp_data_type = dnnl::memory::data_type::undef; + + auto attr = get_primitive_attributes(arg, impl_params, zero_point_mask, wzp_data_type); auto prim_desc = get_convolution_primitive_descriptor(impl_params, *attr); auto conv_onednn_impl = cldnn::make_unique(engine, config, attr, *prim_desc, get_weights_reorder(impl_params, *prim_desc, arg.get_transposed())); + conv_onednn_impl->set_zero_point_mask(zero_point_mask); + conv_onednn_impl->set_weights_zero_point_data_type(wzp_data_type); + return conv_onednn_impl; } }; diff --git a/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp b/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp index 8959d449b21b63..aeca449efffc60 100644 --- a/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp +++ b/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp @@ -1712,8 +1712,9 @@ impl_types layout_optimizer::get_preferred_impl_type(program_node& node, format } } - // oneDNN doesn't support asymmetric weights quantization - if (node.is_type() && node.as().weights_zero_points_term()) + // oneDNN only supports asymmetric weights quantization by scalar zero-points + if (node.is_type() && node.as().weights_zero_points_term() && + node.as().weights_zero_points().get_output_layout().count() != 1) impl_candidate = impl_types::ocl; preferred_impl = impl_candidate; diff --git a/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp b/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp index 5029162cd8cc71..c35816b7d3febc 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp @@ -68,9 +68,46 @@ std::shared_ptr pad_quantization_parameter(std::shared_ptr(new_qp); } +template +bool all_same_value(const T* qp_ptr, size_t size) { + return std::all_of(qp_ptr, qp_ptr + size, [qp_ptr](const T& val) { + return val == qp_ptr[0]; + }); +} + +std::shared_ptr scalar_parameter(std::shared_ptr qp) { + auto type = qp->get_element_type(); + size_t size = ov::shape_size(qp->get_shape()); + bool has_same_value = false; + switch (type) { + case ov::element::u8: + has_same_value = all_same_value(static_cast(qp->get_data_ptr()), size); + break; + case ov::element::i8: + has_same_value = all_same_value(static_cast(qp->get_data_ptr()), size); + break; + case ov::element::f16: + has_same_value = all_same_value(static_cast(qp->get_data_ptr()), size); + break; + case ov::element::f32: + has_same_value = all_same_value(static_cast(qp->get_data_ptr()), size); + break; + default: OPENVINO_THROW("[GPU] Can't pad quantization parameter for ", type, " element type"); + } + + if (has_same_value) { + auto new_shape = qp->get_shape(); + std::fill(new_shape.begin(), new_shape.end(), 1); + ov::Tensor new_qp(type, new_shape); + return std::make_shared(new_qp); + } + + return nullptr; +} + } // namespace -BroadcastAndPadZeroPointBuffers::BroadcastAndPadZeroPointBuffers(size_t pad_size) { +BroadcastAndPadZeroPointBuffers::BroadcastAndPadZeroPointBuffers(size_t pad_size, bool supports_immad) { auto input_m = any_input(type_matches_any({ov::element::u8, ov::element::i8})); auto weights_m = any_input(type_matches_any({ov::element::u8, ov::element::i8})); auto bias_m = any_input(); @@ -106,8 +143,18 @@ BroadcastAndPadZeroPointBuffers::BroadcastAndPadZeroPointBuffers(size_t pad_size if (auto wzp = std::dynamic_pointer_cast(pattern_map.at(wzp_m).get_node_shared_ptr())) { auto target_shape = wzp->get_shape(); - const size_t wzp_c_idx = 0; - auto aligned_wzp = pad_quantization_parameter(wzp, out_shape[channel_idx].get_length(), wzp_c_idx, pad_size); + + std::shared_ptr aligned_wzp; + if (supports_immad && !(conv->get_groups() > 1)) { + // OneDNN supports scalar wzp. If wzp data are identical, replace it with scalar value for OneDNN + aligned_wzp = scalar_parameter(wzp); + } + + if (aligned_wzp == nullptr) { + const size_t wzp_c_idx = 0; + aligned_wzp = pad_quantization_parameter(wzp, out_shape[channel_idx].get_length(), wzp_c_idx, pad_size); + } + aligned_wzp->set_friendly_name(conv->get_friendly_name() + "_wzp"); ov::copy_runtime_info(wzp, aligned_wzp); conv->input(op::Convolution::Args::WZP).replace_source_output(aligned_wzp); diff --git a/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.hpp b/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.hpp index ae8ddb712218ba..1a869b8afbddf2 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.hpp +++ b/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.hpp @@ -14,7 +14,7 @@ namespace intel_gpu { class BroadcastAndPadZeroPointBuffers : public ov::pass::MatcherPass { public: OPENVINO_RTTI("BroadcastAndPadZeroPointBuffers", "0"); - BroadcastAndPadZeroPointBuffers(size_t alignment = 1); + BroadcastAndPadZeroPointBuffers(size_t alignment = 1, bool supports_immad = false); }; } // namespace intel_gpu diff --git a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp index fc62f68af2f6a2..485c55a4ba9380 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp @@ -849,7 +849,7 @@ void TransformationsPipeline::apply(std::shared_ptr func) { manager.register_pass(); const size_t zp_pad_size = device_info.supports_immad ? 16 : 32; - manager.register_pass(zp_pad_size); + manager.register_pass(zp_pad_size, device_info.supports_immad); manager.register_pass(); pass_config->disable(); diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp index 5e7aa5735abed7..9b9ac3ed01cc94 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp @@ -9979,6 +9979,111 @@ TEST(convolution_gpu_onednn, quantized_onednn_convolution_u8s8f32_asymmetric_act } } +TEST(convolution_gpu_onednn, quantized_onednn_convolution_u8s8f32_weights_zp) { + auto& engine = get_test_engine(); + if (!engine.get_device_info().supports_immad) + return; + + auto input = engine.allocate_memory({ data_types::u8, format::bfyx, { 1, 2, 5, 4 } }); + auto weights = engine.allocate_memory({ data_types::i8, format::bfyx, { 3, 2, 3, 3 } }); + auto biases = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 3, 1, 1 } }); + auto a_zp = engine.allocate_memory({ data_types::u8, format::bfyx, { 1, 3, 1, 1 } }); + auto w_zp = engine.allocate_memory({ data_types::u8, format::bfyx, { 1, 1, 1, 1 } }); + + set_values(input, { 1, 2, 3, 4, 5, + 2, 2, 3, 4, 6, + 3, 3, 3, 5, 1, + 1, 1, 1, 1, 1, + + 1, 2, 3, 4, 5, + 2, 2, 3, 4, 6, + 3, 3, 3, 5, 1, + 1, 1, 1, 1, 1 }); + + set_values(weights, { 1, 2, -1, + -2, 1, 2, + 9, 7, -1, + + 9, 0, -4, + -1, 3, 2, + 0, 2, 5, + + 1, 2, -1, + -2, 1, 2, + 9, 7, -1, + + 9, 0, -4, + -1, 3, 2, + 0, 2, 5, + + 1, 2, -1, + -2, 1, 2, + 9, 7, -1, + + 9, 0, -4, + -1, 3, 2, + 0, 2, 5 }); + set_values(a_zp, { 2, 5, 5 }); + set_values(w_zp, { 2 }); + set_values(biases, { 1.0f, -8.0f, -8.0f }); + + VVVF output_vec = { + { + { 2.0f, -5.0f, -20.0f }, + { 12.0f, 26.0f, -10.0f } + }, + { + { -7.0f, -14.0f, -29.0f }, + { 3.0f, 17.0f, -19.0f } + }, + { + { -7.0f, -14.0f, -29.0f }, + { 3.0f, 17.0f, -19.0f } + } }; + + topology topology( + input_layout("input", input->get_layout()), + data("weights", weights), + data("biases", biases), + data("a_zp", a_zp), + data("w_zp", w_zp), + convolution("conv", input_info("input"), "weights", "biases", "w_zp", "a_zp", "", 1, + { 2, 2 }, { 1, 1 }, { 0, 0 }, { 1, 2 }, false, data_types::f32), + reorder("out", input_info("conv"), format::bfyx, data_types::f32)); + + ExecutionConfig config = get_test_default_config(engine); + ov::intel_gpu::ImplementationDesc conv_impl = { format::byxf, "", impl_types::onednn }; + config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ { "conv", conv_impl }})); + config.set_property(ov::intel_gpu::optimize_data(true)); + + network network(engine, topology, config); + network.set_input_data("input", input); + + auto outputs = network.execute(); + ASSERT_EQ(outputs.begin()->first, "out"); + + auto output_memory = outputs.at("out").get_memory(); + cldnn::mem_lock output_ptr(output_memory, get_test_stream()); + + auto output_layout = output_memory->get_layout(); + int y_size = output_layout.spatial(1); + int x_size = output_layout.spatial(0); + int f_size = output_layout.feature(); + int b_size = output_layout.batch(); + ASSERT_EQ(output_layout.format, format::bfyx); + ASSERT_EQ(y_size, 2); + ASSERT_EQ(x_size, 3); + ASSERT_EQ(f_size, 3); + ASSERT_EQ(b_size, 1); + for (int f = 0; f < f_size; f++) + for (int y = 0; y < y_size; ++y) { + for (int x = 0; x < x_size; ++x) { + ASSERT_NEAR(output_vec[f][y][x], ((float)output_ptr[f * y_size * x_size + y * x_size + x]), 1e-5f) << + " x="<< x << " y=" << y << " f=" << f; + } + } +} + TEST(convolution_gpu_onednn, has_proper_synchronization) { auto& engine = get_test_engine(); if (!engine.get_device_info().supports_immad) From d3096afb11b9f2e87ff0165efe2630bd01f49a66 Mon Sep 17 00:00:00 2001 From: Alexandra Sidorova Date: Fri, 23 Aug 2024 16:49:50 +0400 Subject: [PATCH 109/117] [RISCV64] Added parallelism support for FC (#24352) ### Details: - *Added parallelism support for FC* - *Enabled OpenMP on rv64 by default* - *PR to oneDNN: https://github.com/openvinotoolkit/oneDNN/pull/260* ### Tickets: - *N/A * ### Prerequisites: - [x] https://github.com/openvinotoolkit/openvino/pull/23901 - [x] https://github.com/openvinotoolkit/openvino/pull/23964 - [x] https://github.com/openvinotoolkit/openvino/pull/26175 --- cmake/features.cmake | 5 ++-- .../riscv64-071-thead-gnu.toolchain.cmake | 3 --- .../riscv64-100-thead-gnu.toolchain.cmake | 3 --- docs/dev/build_riscv64.md | 4 ++- .../executors/shl/shl_fullyconnected.cpp | 26 ++++++++++++++++--- .../executors/shl/shl_fullyconnected.hpp | 6 +++++ src/plugins/intel_cpu/thirdparty/onednn | 2 +- 7 files changed, 35 insertions(+), 14 deletions(-) diff --git a/cmake/features.cmake b/cmake/features.cmake index d37c113e866ab8..8709c48cc1c567 100644 --- a/cmake/features.cmake +++ b/cmake/features.cmake @@ -85,10 +85,11 @@ ov_dependent_option (ENABLE_PKGCONFIG_GEN "Enable openvino.pc pkg-config file ge # # "OneDNN library based on OMP or TBB or Sequential implementation: TBB|OMP|SEQ" -if(RISCV64 OR ANDROID) - # oneDNN does not support non-SEQ for RISC-V architecture +if(ANDROID) # on Android we experience SEGFAULT during compilation set(THREADING_DEFAULT "SEQ") +elseif(RISCV64) + set(THREADING_DEFAULT "OMP") else() set(THREADING_DEFAULT "TBB") endif() diff --git a/cmake/toolchains/riscv64-071-thead-gnu.toolchain.cmake b/cmake/toolchains/riscv64-071-thead-gnu.toolchain.cmake index 5062350a9e439a..f5e9e68aabedc6 100644 --- a/cmake/toolchains/riscv64-071-thead-gnu.toolchain.cmake +++ b/cmake/toolchains/riscv64-071-thead-gnu.toolchain.cmake @@ -33,9 +33,6 @@ set(CMAKE_CXX_COMPILER ${RISCV_TOOLCHAIN_ROOT}/bin/riscv64-unknown-linux-gnu-g++ set(CMAKE_STRIP ${RISCV_TOOLCHAIN_ROOT}/bin/riscv64-unknown-linux-gnu-strip) set(PKG_CONFIG_EXECUTABLE "NOT-FOUND" CACHE PATH "Path to RISC-V pkg-config") -# Don't run the linker on compiler check -set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) - set(CMAKE_C_FLAGS_INIT "${CMAKE_C_FLAGS_INIT} -march=rv64gcv0p7_zfh_xtheadc -mabi=lp64d") set(CMAKE_CXX_FLAGS_INIT "${CMAKE_CXX_FLAGS_INIT} -march=rv64gcv0p7_zfh_xtheadc -mabi=lp64d") diff --git a/cmake/toolchains/riscv64-100-thead-gnu.toolchain.cmake b/cmake/toolchains/riscv64-100-thead-gnu.toolchain.cmake index 02b1cacd4fce76..e00e30f975598f 100644 --- a/cmake/toolchains/riscv64-100-thead-gnu.toolchain.cmake +++ b/cmake/toolchains/riscv64-100-thead-gnu.toolchain.cmake @@ -33,9 +33,6 @@ set(CMAKE_CXX_COMPILER ${RISCV_TOOLCHAIN_ROOT}/bin/riscv64-unknown-linux-gnu-g++ set(CMAKE_STRIP ${RISCV_TOOLCHAIN_ROOT}/bin/riscv64-unknown-linux-gnu-strip) set(PKG_CONFIG_EXECUTABLE "NOT-FOUND" CACHE PATH "Path to RISC-V pkg-config") -# Don't run the linker on compiler check -set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) - set(CMAKE_C_FLAGS_INIT "${CMAKE_C_FLAGS_INIT} -march=rv64gcv1p0_zfh -mabi=lp64d") set(CMAKE_CXX_FLAGS_INIT "${CMAKE_CXX_FLAGS_INIT} -march=rv64gcv1p0_zfh -mabi=lp64d") diff --git a/docs/dev/build_riscv64.md b/docs/dev/build_riscv64.md index 75d3782004f4dc..13ab9e98d56958 100644 --- a/docs/dev/build_riscv64.md +++ b/docs/dev/build_riscv64.md @@ -69,7 +69,9 @@ The software was validated on the following devices: -DRISCV_TOOLCHAIN_ROOT=/opt/riscv ``` > **NOTE**: The `riscv-gnu-toolchain` is build as there are essential files used for cross compilation under `/opt/riscv/sysroot`. The latest stable versions of Clang or GCC both support compiling source code into RISC-V instructions, so it is acceptable to choose your preferable compilers by specifying `-DCMAKE_C_COMPILER` and `CMAKE_CXX_COMPILER`. But remember to add the key `-DCMAKE_SYSROOT=/opt/riscv/sysroot`, otherwise many fundamental headers and libs could not be found during cross compilation. - + + > **NOTE**: By default OpenVINO is built with OpenMP support on RISC-V devices. + Then run `make` to build the project: ```sh make install -j$(nproc) diff --git a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp index ede6d7511cc62e..ceb50d89830836 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp +++ b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.cpp @@ -121,19 +121,37 @@ bool ShlFCExecutor::update(const MemoryArgs& memory) { src = src.cloneWithNewShape(memory.at(ARG_SRC)->getDescPtr()->getShape().getStaticDims()); dst = dst.cloneWithNewShape(memory.at(ARG_DST)->getDescPtr()->getShape().getStaticDims()); + const auto src_shape = src.getShape(); + const auto dst_shape = dst.getShape(); + dim_M = std::accumulate(dst_shape.rbegin() + 1, dst_shape.rend(), size_t(1), std::multiplies()); + dim_In = src_shape.back(); + dim_Out = dst_shape.back(); + LDA = dim_In * memory.at(ARG_SRC)->getPrecision().size(); + LDC = dim_Out * memory.at(ARG_DST)->getPrecision().size(); + return true; } void ShlFCExecutor::execute(const MemoryArgs& memory) { - src.setData(memory.at(ARG_SRC)->getData()); wei.setData(packedWeights->getData()); - dst.setData(memory.at(ARG_DST)->getData()); if (with_bias) { bias.setData(memory.at(ARG_BIAS)->getData()); } - OPENVINO_ASSERT(csinn_fullyconnected(src.get(), dst.get(), wei.get(), bias.get(), static_cast(params.get())) == CSINN_TRUE, - "ShlFCExecutor: failed to execute"); + const auto nthreads = std::min(static_cast(dim_M), parallel_get_max_threads()); + parallel_nt(nthreads, [&](const int ithr, const int nthr) { + size_t dim_M0 = 0, dim_M1 = 0; + splitter(dim_M, nthr, ithr, dim_M0, dim_M1); + + const auto M = dim_M1 - dim_M0; + auto src_tensor = src.cloneWithNewShape(ov::Shape{ M, dim_In }); + auto dst_tensor = dst.cloneWithNewShape(ov::Shape{ M, dim_Out }); + src_tensor.setData(reinterpret_cast(memory.at(ARG_SRC)->getData()) + dim_M0 * LDA); + dst_tensor.setData(reinterpret_cast(memory.at(ARG_DST)->getData()) + dim_M0 * LDC); + + OPENVINO_ASSERT(csinn_fullyconnected(src_tensor.get(), dst_tensor.get(), wei.get(), bias.get(), static_cast(params.get())) == CSINN_TRUE, + "ShlFCExecutor: failed to execute"); + }); } } // namespace intel_cpu diff --git a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.hpp b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.hpp index 129b2e35867809..370ddb3d28c4b7 100644 --- a/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.hpp +++ b/src/plugins/intel_cpu/src/nodes/executors/shl/shl_fullyconnected.hpp @@ -38,6 +38,12 @@ class ShlFCExecutor : public Executor { const MemoryCPtr packedWeights; + size_t dim_M = 0; + size_t dim_In = 0; + size_t dim_Out = 0; + size_t LDA = 0; + size_t LDC = 0; + bool with_bias = false; }; using ShlFCExecutorPtr = std::shared_ptr; diff --git a/src/plugins/intel_cpu/thirdparty/onednn b/src/plugins/intel_cpu/thirdparty/onednn index 6237cb7cc6df35..740efd8194fbc7 160000 --- a/src/plugins/intel_cpu/thirdparty/onednn +++ b/src/plugins/intel_cpu/thirdparty/onednn @@ -1 +1 @@ -Subproject commit 6237cb7cc6df3591bf0113fdc546fab724d4d55b +Subproject commit 740efd8194fbc72ba4e495c7fe57c3cf51361048 From 5b99ebc04270aa88259f9bc18b17bde1d1f44c8b Mon Sep 17 00:00:00 2001 From: Ujjayant Kadian <118752727+ujjayant-kadian@users.noreply.github.com> Date: Fri, 23 Aug 2024 14:10:05 +0100 Subject: [PATCH 110/117] NPUW: Support asymmetric weights quantization (Opt B) (#26164) ### Details: There has a case emerged where now there are vectors of zero points instead of a single value. Adding the support for unpacking such asymmetric zeropoints. ### Tickets: - *134720* --------- Co-authored-by: Dmitry Matveev --- .../plugin/npuw/partitioning/partitioning.cpp | 3 + .../npuw/partitioning/patterns/dcoff.cpp | 146 ++++++++++++- .../npuw/partitioning/patterns/dcoff.hpp | 14 +- .../intel_npu/src/plugin/npuw/util.cpp | 191 +++++++++++++++++- 4 files changed, 343 insertions(+), 11 deletions(-) diff --git a/src/plugins/intel_npu/src/plugin/npuw/partitioning/partitioning.cpp b/src/plugins/intel_npu/src/plugin/npuw/partitioning/partitioning.cpp index bb1905b25ed1f6..1325fc1f1d1dd0 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/partitioning/partitioning.cpp +++ b/src/plugins/intel_npu/src/plugin/npuw/partitioning/partitioning.cpp @@ -1627,6 +1627,9 @@ void Partitioner::decompressionCutOff(const std::string& func_name) { // Phi-3 4SymW16A/GPTQ rewr.add_matcher(dcoff_mode, dcoff_type, std::ref(params_to)); + // Asymmetric zeropoints + rewr.add_matcher(dcoff_mode, dcoff_type, std::ref(params_to)); + rewr.run_on_model(f._model); ov::pass::Validate val; diff --git a/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.cpp b/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.cpp index 99ff93a606697a..857bcd9c93ba56 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.cpp +++ b/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.cpp @@ -56,28 +56,48 @@ ClosureRemap build_remap(const Function& fbody, const DCOFFParams& params_to) { ClosureRemap m; + using PPtr = std::shared_ptr; + std::unordered_set ban_list; + + for (const auto& scale_pair : params_to.scales) { + ban_list.insert(scale_pair.first); + } + + for (const auto& zerop_pair : params_to.zerops_asymm) { + ban_list.insert(zerop_pair.second); + } + // FIXME: use indexed() here instead for (std::size_t i = fbody._param_offset; i < body_params.size(); i++) { - LOG_DEBUG("Checking the function parameter " << body_params[i]); + const auto& param = body_params[i]; + LOG_DEBUG("Checking the function parameter " << param); LOG_BLOCK(); // First find among scale factors... - auto pscale_iter = params_to.scales.find(body_params[i]); + auto pscale_iter = params_to.scales.find(param); + auto pzerop_iter = params_to.zerops_asymm.find(param); if (pscale_iter != params_to.scales.end()) { LOG_DEBUG("This is a Scale factor parameter, will be removed"); auto& pscale_weight_param = pscale_iter->second; auto pscale_weight_pindex = fbody._model->get_parameter_index(pscale_weight_param); auto pscale_weight_cindex = pscale_weight_pindex - fbody._param_offset; m.scale_remap[pscale_weight_cindex] = i - fbody._param_offset; - m.params_to_remove.push_back(body_params[i]); - } else { + m.params_to_remove.push_back(param); + } else if (pzerop_iter != params_to.zerops_asymm.end()) { + LOG_DEBUG("There is an Asymmetric zero point corresponding to this parameter, it will be removed"); + auto zerop_pindex = fbody._model->get_parameter_index(pzerop_iter->second); + auto zerop_cindex = zerop_pindex - fbody._param_offset; + m.zerop_remap[i - fbody._param_offset] = zerop_cindex; + m.params_to_remove.push_back(pzerop_iter->second); + m.closure_remap.push_back(i - fbody._param_offset); + } else if (ban_list.find(param) == ban_list.end()) { + // If it's not in the ban list, it's an OK parameter and should be kept LOG_DEBUG("This is an OK parameter, will be kept"); - // n++ is the index of `i` here m.closure_remap.push_back(i - fbody._param_offset); } // Process zero points for parameters - auto zerop_iter = params_to.zerops.find(body_params[i]); + auto zerop_iter = params_to.zerops.find(param); if (zerop_iter != params_to.zerops.end()) { LOG_DEBUG("This parameter requires zero point: " << zerop_iter->second); m.zero_points.push_back(ov::npuw::util::tensor_from_const(zerop_iter->second)); @@ -85,7 +105,8 @@ ClosureRemap build_remap(const Function& fbody, const DCOFFParams& params_to) { m.zero_points.push_back(ov::Tensor()); } } - NPUW_ASSERT((body_params.size() - fbody._param_offset) == (m.scale_remap.size() + m.closure_remap.size())); + NPUW_ASSERT((body_params.size() - fbody._param_offset) == + (m.scale_remap.size() + m.closure_remap.size() + m.zerop_remap.size())); NPUW_ASSERT((body_params.size() - fbody._param_offset) == m.zero_points.size()); LOG_DEBUG("DONE"); @@ -105,7 +126,10 @@ void apply_remap(Subgraph& fcall, const ClosureRemap& m) { auto scale_iter = m.scale_remap.find(i); new_scales.push_back(scale_iter != m.scale_remap.end() ? fcall._closure[scale_iter->second] : ov::Tensor()); - new_zerops.push_back(m.zero_points[i]); + // Check for asymmetric zero points and add them to new_zerops + auto zerop_iter = m.zerop_remap.find(i); + const auto& zerop = zerop_iter != m.zerop_remap.end() ? fcall._closure[zerop_iter->second] : m.zero_points[i]; + new_zerops.push_back(zerop); } fcall._closure = std::move(new_closure); fcall._scales = std::move(new_scales); @@ -790,6 +814,112 @@ CWAI3::CWAI3(CWAI3::Results scales) { // Implementation TBD } // namespace SymmZP + +//------------------------------------------------------------------------------ +// Pattern: ASymmZP, weights with asymmetric quantization +// +namespace AsymmZP { +// As seen in asymmetric TinyLlama: +// Since it is ASymm, all zero points for all blocks have different +// values so they will be Parameters but not Constants. +// +// In the diagram below, pattern on the left is identified and +// is modified to pattern in the right if type is promoted to f16 +// +// "tensor" "zero point" "scale" +// Parameter:A Parameter:B Parameter:C > Parameter:A +// u4 u4 f16 > f16 +// : : : > : : +// V : : > V V +// Convert Convert : > Reshape|Convert +// f16 f16 : > +// : : : > +// V V : > +// Subtract : > +// f16 : > +// : : > +// V V > +// Multiply > +// fp16 > +// : : > +// V V > +// Reshape|Convert > +// : > +// V > +// +DCOFFPassReshape::DCOFFPassReshape(DCOffMode dcoff_mode, ov::element::Type dcoff_type, DCOFFParamRef pref) { + auto paramA = opp::wrap_type(); + auto paramB = opp::wrap_type(); + auto paramC = opp::wrap_type(); + auto cvtA = opp::wrap_type({paramA}); + auto cvtB = opp::wrap_type({paramB}); + auto subtr = opp::wrap_type({cvtA, cvtB}); + auto mulply = opp::wrap_type({subtr, paramC}); + + auto scalar = opp::wrap_type(); + auto reshpe = opp::wrap_type({mulply, scalar}); + + auto callback = [=](ov::pass::pattern::Matcher& m) { + auto& node_to_output = m.get_pattern_value_map(); + auto matched_nodeA = node_to_output.at(paramA).get_node_shared_ptr(); + auto matched_nodeB = node_to_output.at(paramB).get_node_shared_ptr(); + auto matched_nodeC = node_to_output.at(paramC).get_node_shared_ptr(); + + NPUW_ASSERT(ov::op::util::is_parameter(matched_nodeA)); + NPUW_ASSERT(ov::op::util::is_parameter(matched_nodeB)); + NPUW_ASSERT(ov::op::util::is_parameter(matched_nodeC)); + + auto matched_paramA = std::static_pointer_cast(matched_nodeA); + auto matched_paramB = std::static_pointer_cast(matched_nodeB); + auto matched_paramC = std::static_pointer_cast(matched_nodeC); + + if (ov::element::u4 == matched_paramA->get_element_type() && + ov::element::u4 == matched_paramB->get_element_type() && + ov::element::f16 == matched_paramC->get_element_type()) { + LOG_DEBUG("Matched: " << matched_paramA << ", set element type to " << dcoff_type); + matched_paramA->set_element_type(dcoff_type); + + if (dcoff_mode == DCOffMode::CAST_SCALE) { + NPUW_ASSERT(dcoff_type == ov::element::f16); + + LOG_DEBUG("Matched: " << matched_paramB << " - value to remove..."); + LOG_DEBUG("Matched: " << matched_paramC << " - parameter to remove..."); + LOG_BLOCK(); + + // Extra transformation here: + // - remove Subtract + Multiply, + // - mark paramC for removal. + // Reshape will be reconnected to ParamA directly + + // Record mapping from the Scale coeff parameter to the Real weight parameter + pref.get().zerops_asymm[matched_paramA] = matched_paramB; + pref.get().scales[matched_paramC] = matched_paramA; + + // Disconnect Multiply and Convert from their outputs + auto matched_mulply = node_to_output.at(mulply).get_node_shared_ptr(); + auto matched_convrt = node_to_output.at(cvtA).get_node_shared_ptr(); + auto drop_outputs = [](std::shared_ptr node) { + for (auto&& node_outputs : node->outputs()) { + for (auto&& node_reader_port : node_outputs.get_target_inputs()) { + node_outputs.remove_target_input(node_reader_port); + } + } + }; + LOG_DEBUG("Dropping the connections..."); + drop_outputs(matched_mulply); + drop_outputs(matched_convrt); + + LOG_DEBUG("Reconnecting the Root..."); + auto matched_reshpe = node_to_output.at(reshpe).get_node_shared_ptr(); + matched_reshpe->input(0).replace_source_output(matched_paramA); + } + LOG_DEBUG("Done"); + } + return false; // root node hasn't changed + }; + register_matcher(std::make_shared(reshpe, "TagDCOFFReshape"), std::move(callback)); +} +} // namespace AsymmZP } // namespace patterns } // namespace npuw } // namespace ov diff --git a/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.hpp b/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.hpp index 83ed575f8afd41..c0b394616c6ed5 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.hpp +++ b/src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.hpp @@ -28,8 +28,9 @@ namespace patterns { struct DCOFFParams { using PPtr = std::shared_ptr; using CPtr = std::shared_ptr; - std::unordered_map scales; // Closures: a scaling factor -> orig tensor - std::unordered_map zerops; // Closures: orig tensor -> a zero point (yes, a reverse...) + std::unordered_map scales; // Closures: a scaling factor -> orig tensor + std::unordered_map zerops; // Closures: orig tensor -> a zero point (yes, a reverse...) + std::unordered_map zerops_asymm; // Closures: orig tensor -> an asymmetric zerop parameter }; using DCOFFParamRef = std::reference_wrapper; @@ -37,6 +38,7 @@ using DCOFFParamRef = std::reference_wrapper; struct ClosureRemap { std::vector closure_remap; // [new closure index] -> orig closure idx std::map scale_remap; // orig closure idx -> orig scale idx + std::map zerop_remap; // orig closure idx -> orig asymm zero point idx ov::ParameterVector params_to_remove; std::vector zero_points; // zero points for closures, if needed @@ -160,6 +162,14 @@ class CWAI3 : public ov::pass::MatcherPass { } // namespace SymmZP +namespace AsymmZP { +class DCOFFPassReshape : public ov::pass::MatcherPass { +public: + DCOFFPassReshape(DCOffMode dcoff_mode, ov::element::Type dcoff_type, DCOFFParamRef pref); +}; + +} // namespace AsymmZP + } // namespace patterns } // namespace npuw } // namespace ov diff --git a/src/plugins/intel_npu/src/plugin/npuw/util.cpp b/src/plugins/intel_npu/src/plugin/npuw/util.cpp index 46bc874e560196..fbfbcc5d35eb19 100644 --- a/src/plugins/intel_npu/src/plugin/npuw/util.cpp +++ b/src/plugins/intel_npu/src/plugin/npuw/util.cpp @@ -860,6 +860,186 @@ void unpack_u4f16(const ov::SoPtr& from, } } +void unpack_u4f16_asymm_zp(const ov::SoPtr& from, + const ov::SoPtr& zerop, + const ov::SoPtr& scale, + const ov::SoPtr& to, + const ov::npuw::util::UnpackOptions& unpack_options) { + NPUW_ASSERT(from->is_continuous()); + NPUW_ASSERT(zerop->is_continuous()); + NPUW_ASSERT(scale->is_continuous()); + NPUW_ASSERT(to->is_continuous()); + NPUW_ASSERT(from->get_size() == to->get_size()); + + const auto& from_shape = from->get_shape(); + NPUW_ASSERT(from_shape.back() % 64 == 0); + + // 3-channel (group-wise) scale factors are + // supported. + + const auto& scale_shape = scale->get_shape(); + NPUW_ASSERT(scale_shape.size() == 3); + if (scale_shape.size() == 3) { + NPUW_ASSERT(scale_shape[0] == from_shape[0]); + NPUW_ASSERT(scale_shape[1] == from_shape[1]); + NPUW_ASSERT(scale_shape[2] == 1); + } + + const auto& zerop_shape = zerop->get_shape(); + NPUW_ASSERT(zerop_shape.size() == 3); + if (zerop_shape.size() == 3) { + NPUW_ASSERT(zerop_shape[0] == from_shape[0]); + NPUW_ASSERT(zerop_shape[1] == from_shape[1]); + NPUW_ASSERT(zerop_shape[2] == 1); + } + + const auto zerop_elem_type = zerop->get_element_type(); + const auto scale_elem_type = scale->get_element_type(); + NPUW_ASSERT(zerop_elem_type == ov::element::u4); + NPUW_ASSERT(scale_elem_type == ov::element::f16); + + // This conversion combines u4tof32 and f32tof16. Here we + // - read 256 bits (= 32 bytes, = 64 u4 elements) + // - write 1024 bits (= 128 bytes, = 64 f16 elements) + // per every iteration, what translates to (from->size() / 64) iterations + + const std::size_t total = to->get_size(); + const std::size_t stotal = scale->get_size(); + const std::size_t elementsPerScale = total / stotal; + + const uint8_t* const pSrc = static_cast(from->data()); // 2 x u4 elements + const uint8_t* const pZer = static_cast(zerop->data()); // 2 x u4 element + const int8_t* const pScl = static_cast(scale->data()); // 1 x f16 element + const int16_t* pDst = static_cast(to->data()); // 1 x f16 element + + auto unpack_body = [pSrc, pDst, pScl, pZer, elementsPerScale, scale_elem_type, zerop_elem_type, stotal]( + std::size_t sindex, + std::size_t stride) { + // number of vectorized operations per scale + size_t elementsPerScaleVectorized = elementsPerScale / 64; + + uint8_t const* pSrcLocal = pSrc + 32 * elementsPerScaleVectorized * sindex * stride; + int8_t const* pSclLocal = pScl + scale_elem_type.size() * sindex * stride; + uint8_t const* pZerLocal = pZer + zerop_elem_type.size() * sindex * stride / 2; + int16_t* pDstLocal = const_cast(pDst) + 64 * elementsPerScaleVectorized * sindex * stride; + + // if it is last iteration current stride can be smaller - lets check that + sindex *= stride; + const auto jobFinish = std::min(sindex + stride, stotal); + + for (; sindex < jobFinish; sindex++) { + __m256 svalVec = avx2_load_scale(pSclLocal, scale_elem_type); + __m256 zvalVec = _mm256_set1_ps(static_cast((sindex % 2 == 0) ? lo4(*pZerLocal) : hi4(*pZerLocal))); + + for (std::size_t index = 0; index < elementsPerScale; index += 64) { + __m128i* outv[] = { + reinterpret_cast<__m128i*>(pDstLocal), + reinterpret_cast<__m128i*>(pDstLocal + 8), + reinterpret_cast<__m128i*>(pDstLocal + 16), + reinterpret_cast<__m128i*>(pDstLocal + 24), + reinterpret_cast<__m128i*>(pDstLocal + 32), + reinterpret_cast<__m128i*>(pDstLocal + 40), + reinterpret_cast<__m128i*>(pDstLocal + 48), + reinterpret_cast<__m128i*>(pDstLocal + 56), + }; + __m256i himask = _mm256_set1_epi8(static_cast(0xF0)); + __m256i lomask = _mm256_set1_epi8(static_cast(0x0F)); + + // loading 256 bit u4 into unalligned memory , so 64 elements + // cannot use aligned version here like _mm256_load_si256 - segfault even on unit tests + __m256i xmmData = _mm256_lddqu_si256(reinterpret_cast<__m256i const*>(pSrcLocal)); + + // unpacking with interleaving + __m256i vht = _mm256_and_si256(xmmData, himask); + __m256i xmmUnpackedLo = _mm256_srli_epi16(vht, 4); // 32 x i8 + __m256i xmmUnpackedHi = _mm256_and_si256(xmmData, lomask); // 32 x i8 + + // need 4 portions of 8 x i8 elements + __m128i unpacked32LoHi = _mm256_castsi256_si128(xmmUnpackedLo); // lower 16 x i8 + __m128i unpacked32LoLo = _mm256_extractf128_si256(xmmUnpackedLo, 1); // higher 16 x i8 + + __m128i unpacked32HiHi = _mm256_castsi256_si128(xmmUnpackedHi); // lower 16 x i8 + __m128i unpacked32HiLo = _mm256_extractf128_si256(xmmUnpackedHi, 1); // higher 16 x i8 + + // converting to 32 x f16 + __m128i f16LoLo[] = {avx2_u8tof16_hi(unpacked32LoLo, zvalVec, svalVec), + avx2_u8tof16_lo(unpacked32LoLo, zvalVec, svalVec)}; + + __m128i f16LoHi[] = { + avx2_u8tof16_hi(unpacked32LoHi, zvalVec, svalVec), + avx2_u8tof16_lo(unpacked32LoHi, zvalVec, svalVec), + }; + + __m128i f16HiLo[] = {avx2_u8tof16_hi(unpacked32HiLo, zvalVec, svalVec), + avx2_u8tof16_lo(unpacked32HiLo, zvalVec, svalVec)}; + __m128i f16HiHi[] = {avx2_u8tof16_hi(unpacked32HiHi, zvalVec, svalVec), + avx2_u8tof16_lo(unpacked32HiHi, zvalVec, svalVec)}; + + // interleaving back + __m128i interleaved[] = {_mm_unpacklo_epi16(f16HiHi[0], f16LoHi[0]), + _mm_unpackhi_epi16(f16HiHi[0], f16LoHi[0]), + _mm_unpacklo_epi16(f16HiHi[1], f16LoHi[1]), + _mm_unpackhi_epi16(f16HiHi[1], f16LoHi[1]), + _mm_unpacklo_epi16(f16HiLo[0], f16LoLo[0]), + _mm_unpackhi_epi16(f16HiLo[0], f16LoLo[0]), + _mm_unpacklo_epi16(f16HiLo[1], f16LoLo[1]), + _mm_unpackhi_epi16(f16HiLo[1], f16LoLo[1])}; + + // store the results + _mm_storeu_si128(outv[0], interleaved[0]); + _mm_storeu_si128(outv[1], interleaved[1]); + _mm_storeu_si128(outv[2], interleaved[2]); + _mm_storeu_si128(outv[3], interleaved[3]); + _mm_storeu_si128(outv[4], interleaved[4]); + _mm_storeu_si128(outv[5], interleaved[5]); + _mm_storeu_si128(outv[6], interleaved[6]); + _mm_storeu_si128(outv[7], interleaved[7]); + + pSrcLocal += 32; // shift pSrc only by 32 since it is 64 x u4 + pDstLocal += 64; // note pDst is int16_t, so 64 x f16 -> 64 elements + } // for(index) + pSclLocal += scale_elem_type.size(); + if (sindex % 2 == 1) { + pZerLocal += zerop_elem_type.size(); + } + } // for(sindex) + }; + + size_t stride{1}; + + // since scaling is always 64 elements aligned operations, lets partition only in scale shape + if (unpack_options.nPartitions) { + std::size_t minPartitions; + if (!unpack_options.bStrictPartitioning) { + // some heuristics that every tbb thread workload has to have 2048 x intrinsics operations at least, + // so in terms of stride, it should be nElementsPerscale/64 * 2048 + const auto nIntrinsicsPerScale = elementsPerScale / 64u; + auto minScaleStride = 2048u / nIntrinsicsPerScale; + minScaleStride = std::max(1u, minScaleStride); + minPartitions = stotal / minScaleStride; + minPartitions = std::max(1u, minPartitions); + minPartitions = std::min(minPartitions, unpack_options.nPartitions); + } else { + minPartitions = unpack_options.nPartitions; + } + + // calculating stride in scale elements space + stride = static_cast(stotal / minPartitions); + } + + const size_t numWork = (stotal + stride - 1) / stride; + + if (unpack_options.bUseOvParallelFor) { + ov::parallel_for(numWork, [unpack_body, stride](size_t index) { + unpack_body(index, stride); + }); + } else { + for (std::size_t index = 0; index < numWork; index++) { + unpack_body(index, stride); + } + } +} + void unpack_u4f16_z(const ov::SoPtr& from, const ov::SoPtr& zerop, const ov::SoPtr& scale, @@ -1121,6 +1301,11 @@ void ov::npuw::util::unpack(const ov::SoPtr& from, // - [32, 1, 4096].*[32, 128, 4096] // - [32, 1, 11008].*[32, 128, 11008] // - [86, 1, 4096].*[86, 128, 4096] + // unpack_u4f16_asymm_zp: + // - [256, 16, 1].*[256, 16, 128] + // - [2048, 16, 1].*[2048, 16, 128] + // - [5632, 16, 1].*[5632, 16, 128] + // Zero Point Shapes: [256, 16, 1], [2048, 16, 1], [5632, 16, 1] // Unsupported Case for scale tensor: // - [s1, 1, s2, 1, s3] @@ -1132,7 +1317,11 @@ void ov::npuw::util::unpack(const ov::SoPtr& from, unpack_u4f16_z(from, zerop, scale, to, unpack_options); } else if (scale_shape.size() == 3 && scale_shape[0] == from_shape[0] && scale_shape[1] == from_shape[1] && scale_shape[2] == 1) { - unpack_u4f16(from, zerop, scale, to, unpack_options); + if (zerop->get_size() == 1) { + unpack_u4f16(from, zerop, scale, to, unpack_options); + } else { + unpack_u4f16_asymm_zp(from, zerop, scale, to, unpack_options); + } } else if (scale_shape.size() == 2 && scale_shape[0] == from_shape[0] && scale_shape[1] == 1) { unpack_u4f16(from, zerop, scale, to, unpack_options); } else { From 458a6bbc324e16c3880e5b03f58f9d00fe6f8e9c Mon Sep 17 00:00:00 2001 From: Andrei Gorbachev Date: Fri, 23 Aug 2024 17:04:10 +0100 Subject: [PATCH 111/117] [Core] remove rewrite_graph.hpp (#25853) ### Details: - *remove rewrite_graph.hpp* ### Tickets: - *CVS-118087* --- .../pyopenvino/graph/passes/graph_rewrite.cpp | 3 +- .../low_precision/base_matcher_pass.hpp | 2 +- .../convert_subtract_constant.hpp | 2 +- .../low_precision/create_attribute.hpp | 1 - .../create_precisions_dependent_attribute.hpp | 2 +- .../low_precision/layer_transformation.hpp | 2 +- .../include/low_precision/markup_bias.hpp | 2 +- .../low_precision/propagate_shared_value.hpp | 2 +- .../propagate_through_precision_preserved.hpp | 2 +- .../low_precision/propagate_to_input.hpp | 2 +- .../pull_reshape_through_dequantization.hpp | 2 +- .../pull_transpose_through_dequantization.hpp | 2 +- .../pass/broadcast_to_movebroadcast.hpp | 2 +- .../snippets/pass/collapse_subgraph.hpp | 3 +- .../snippets/pass/common_optimizations.hpp | 2 +- .../snippets/pass/convert_constants.hpp | 2 +- .../pass/convert_power_to_powerstatic.hpp | 3 +- .../pass/explicit_transpose_matmul_inputs.hpp | 2 +- .../pass/extract_reshapes_from_mha.hpp | 3 +- .../snippets/pass/fq_decomposition.hpp | 2 +- .../snippets/pass/fuse_transpose_brgemm.hpp | 3 +- .../snippets/pass/gn_decomposition.hpp | 3 +- .../snippets/pass/insert_movebroadcast.hpp | 3 +- .../snippets/pass/matmul_to_brgemm.hpp | 3 +- .../snippets/pass/mha_tokenization.hpp | 3 +- .../pass/reduce_to_snippets_reduce.hpp | 3 +- .../snippets/pass/softmax_decomposition.hpp | 3 +- .../pass/softmax_reshape_elimination.hpp | 3 +- .../include/snippets/pass/tokenization.hpp | 3 +- .../snippets/pass/transform_convert.hpp | 3 +- .../snippets/pass/transpose_decomposition.hpp | 3 +- .../include/snippets/pass/validate.hpp | 3 +- .../adaptive_pool_to_reduce.hpp | 2 +- .../add_fake_quantize_fusion.hpp | 2 +- .../align_eltwise_input_ranks.hpp | 2 +- .../augru_cell_fusion.hpp | 2 +- .../batch_to_space_fusion.hpp | 2 +- .../common_optimizations/binarize_weights.hpp | 2 +- .../broadcast_elementwise_fusion.hpp | 2 +- .../broadcast_transition.hpp | 2 +- .../common_optimizations/clamp_fusion.hpp | 2 +- .../common_optimizations.hpp | 2 +- .../common_optimizations/concat_fusion.hpp | 2 +- .../concat_to_broadcast.hpp | 2 +- .../common_optimizations/conv_mul_fusion.hpp | 2 +- .../conv_to_binary_conv.hpp | 2 +- .../convert_quantize_dequantize.hpp | 2 +- ...onvert_u4_weights_zero_point_to_scalar.hpp | 2 +- .../depth_to_space_fusion.hpp | 2 +- .../dilated_convolution_converter.hpp | 2 +- .../dimension_tracking.hpp | 2 +- ...isable_random_uniform_constant_folding.hpp | 2 +- .../disable_shapeof_constant_folding.hpp | 2 +- .../common_optimizations/divide_fusion.hpp | 2 +- .../dropout_with_random_uniform_replacer.hpp | 2 +- .../eliminate_duplicate_ti_inputs.hpp | 2 +- .../eliminate_loop_inputs_outputs.hpp | 2 +- .../eliminate_unsqueeze_gather.hpp | 3 +- .../enable_shapeof_constant_folding.hpp | 2 +- .../fold_subgraph_empty_inputs.hpp | 2 +- .../common_optimizations/fq_mul_fusion.hpp | 2 +- .../fq_reshape_fusion.hpp | 2 +- .../common_optimizations/gru_cell_fusion.hpp | 2 +- .../interpolate_sequence_fusion.hpp | 3 +- .../leaky_relu_fusion.hpp | 2 +- .../matmul_const_transposes_extraction.hpp | 2 +- .../matmul_multiply_fusion.hpp | 2 +- .../common_optimizations/mish_fusion.hpp | 3 +- .../moc_transformations.hpp | 2 +- .../common_optimizations/mul_conv_fusion.hpp | 2 +- .../mul_fake_quantize_fusion.hpp | 2 +- .../nearest_neighbor_upsampling_fusion.hpp | 2 +- .../nonzero_horizontal_fusion.hpp | 3 +- .../normalize_l2_fusion.hpp | 3 +- .../pull_transpose_through_fq.hpp | 2 +- .../random_uniform_fusion.hpp | 2 +- .../common_optimizations/reduce_merge.hpp | 2 +- .../reduce_reshape_fusion.hpp | 2 +- .../relu_fake_quantize_fusion.hpp | 2 +- .../remove_concat_zero_dim_input.hpp | 2 +- .../common_optimizations/reshape_prelu.hpp | 2 +- .../reshape_sequence_fusion.hpp | 2 +- .../common_optimizations/ric_fusion.hpp | 3 +- .../common_optimizations/rms_fusion.hpp | 2 +- .../select_with_one_value_condition.hpp | 2 +- .../common_optimizations/sequence_fusion.hpp | 2 +- .../shared_ops_optimization.hpp | 2 +- .../shuffle_channels_fusion.hpp | 2 +- .../simplify_shape_of_sub_graph.hpp | 2 +- ...ip_gather_before_transpose_and_reshape.hpp | 2 +- .../common_optimizations/softmax_fusion.hpp | 2 +- .../common_optimizations/softplus_fusion.hpp | 2 +- .../softplus_to_mish_fusion.hpp | 3 +- .../space_to_batch_fusion.hpp | 2 +- ...plit_concat_pair_to_interpolate_fusion.hpp | 3 +- .../split_squeeze_concat_fusion.hpp | 3 +- .../strides_optimization.hpp | 2 +- .../common_optimizations/subtract_fusion.hpp | 2 +- ...anspose_reshape_elimination_for_matmul.hpp | 2 +- .../transpose_sinking.hpp | 1 - .../transpose_to_reshape.hpp | 3 +- .../weights_dequantize_to_fake_quantize.hpp | 2 +- .../wrap_interpolate_into_transposes.hpp | 2 +- .../control_flow/unroll_if.hpp | 2 +- .../control_flow/unroll_tensor_iterator.hpp | 2 +- .../transformations/convert_precision.hpp | 2 +- .../flush_fp32_subnormals_to_zero.hpp | 2 +- .../align_mixed_fp32_fp16_types.hpp | 3 +- .../convert_compression_only_to_legacy.hpp | 3 +- ...decompression_convert_constant_folding.hpp | 2 +- ...k_subgraphs_to_keep_in_mixed_precision.hpp | 3 +- .../transformations/init_node_info.hpp | 2 +- .../mark_dequantization_subgraph.hpp | 2 +- .../batch_norm_decomposition.hpp | 2 +- .../convert_avgpool_downgrade.hpp | 2 +- .../op_conversions/convert_batch_to_space.hpp | 2 +- .../op_conversions/convert_broadcast3.hpp | 2 +- .../convert_broadcast_to_tiles.hpp | 2 +- .../op_conversions/convert_convertlike.hpp | 2 +- .../convert_convertpromotetypes.hpp | 2 +- .../convert_deformable_conv_v8_to_v1.hpp | 2 +- .../op_conversions/convert_depth_to_space.hpp | 2 +- .../op_conversions/convert_divide.hpp | 2 +- ...vert_embedding_bag_offsets15_downgrade.hpp | 2 +- ...nvert_embedding_bag_packed15_downgrade.hpp | 2 +- .../op_conversions/convert_gather_0d.hpp | 2 +- .../convert_gather_downgrade.hpp | 2 +- .../convert_gather_to_compressed.hpp | 2 +- .../op_conversions/convert_gather_upgrade.hpp | 2 +- .../op_conversions/convert_gelu.hpp | 2 +- .../convert_gp9_to_gp_ie_internal.hpp | 2 +- .../convert_interpolate11_downgrade.hpp | 2 +- .../convert_interpolate1_to_interpolate4.hpp | 2 +- .../convert_matrix_nms_to_matrix_nms_ie.hpp | 2 +- .../convert_maxpool_downgrade.hpp | 2 +- .../convert_maxpool_upgrade.hpp | 2 +- .../convert_minimum_to_power_and_max.hpp | 2 +- .../op_conversions/convert_mod.hpp | 2 +- ...rt_multiclass_nms_to_multiclass_nms_ie.hpp | 2 +- .../convert_multiclass_nms_upgrade.hpp | 2 +- .../op_conversions/convert_mvn1_to_mvn6.hpp | 2 +- .../op_conversions/convert_negative.hpp | 2 +- .../convert_nms9_to_nms_ie_internal.hpp | 2 +- ...convert_nms_rotated_to_nms_ie_internal.hpp | 2 +- .../convert_nms_to_nms_ie_internal.hpp | 2 +- .../convert_pad12_downgrade.hpp | 2 +- .../convert_pad_to_group_conv.hpp | 2 +- .../convert_previous_nms_to_nms_5.hpp | 2 +- .../convert_previous_nms_to_nms_9.hpp | 2 +- .../convert_prior_box_v8_to_v0.hpp | 2 +- .../convert_roi_align_v3_to_v9.hpp | 2 +- .../convert_roi_align_v9_to_v3.hpp | 2 +- .../convert_scatter_elements_to_scatter.hpp | 2 +- ...rt_scatter_elements_update12_downgrade.hpp | 2 +- .../op_conversions/convert_shapeof3.hpp | 2 +- .../convert_shuffle_channels3.hpp | 2 +- .../convert_slice_to_strided_slice.hpp | 2 +- .../convert_softmax_downgrade.hpp | 2 +- .../convert_softmax_upgrade.hpp | 2 +- .../op_conversions/convert_space_to_batch.hpp | 2 +- .../op_conversions/convert_space_to_depth.hpp | 2 +- .../op_conversions/convert_subtract.hpp | 2 +- .../convert_topk11_downgrade.hpp | 2 +- .../op_conversions/convert_topk3.hpp | 2 +- .../convert_xor_to_logical_xor.hpp | 2 +- .../detection_output_downgrade.hpp | 2 +- .../detection_output_upgrade.hpp | 2 +- .../op_conversions/einsum_decomposition.hpp | 2 +- .../op_conversions/eye_decomposition.hpp | 2 +- .../op_conversions/fq_decomposition.hpp | 2 +- .../op_conversions/gelu7_downgrade.hpp | 2 +- .../group_normalization_decomposition.hpp | 2 +- .../op_conversions/gru_cell_decomposition.hpp | 2 +- .../hard_sigmoid_decomposition.hpp | 2 +- .../op_conversions/hsigmoid_decomposition.hpp | 2 +- .../op_conversions/hswish_decomposition.hpp | 2 +- .../log_softmax_decomposition.hpp | 2 +- .../lstm_cell_decomposition.hpp | 2 +- .../op_conversions/mvn6_decomposition.hpp | 2 +- .../normalize_l2_decomposition.hpp | 3 +- .../reduce_l1_decomposition.hpp | 3 +- .../reduce_l2_decomposition.hpp | 3 +- .../op_conversions/rnn_cell_decomposition.hpp | 2 +- ...ed_dot_product_attention_decomposition.hpp | 2 +- .../simplify_ctc_greedy_decoder_seq_len.hpp | 2 +- .../op_conversions/softmax_decomposition.hpp | 2 +- .../op_conversions/softplus_decomposition.hpp | 2 +- .../op_conversions/softsign_decomposition.hpp | 2 +- .../op_conversions/unique_decomposition.hpp | 2 +- .../convert_opset2_to_opset1.hpp | 2 +- .../convert_opset3_to_opset2.hpp | 2 +- .../position_ids_replacer.hpp | 5 +- .../prev_sequence_length_pattern.hpp | 6 +- .../state_management_pattern.hpp | 2 +- .../total_sequence_length_pattern.hpp | 6 +- .../broadcast_const_range_replacement.hpp | 2 +- .../smart_reshape/lstm_states_broadcast.hpp | 2 +- .../smart_reshape/matmul_sr.hpp | 2 +- .../proposal_scales_stridedslice.hpp | 2 +- .../smart_reshape/reshape_sinking.hpp | 2 +- .../smart_reshape/reshape_to_1D.hpp | 2 +- .../smart_reshape/shape_of_const_folding.hpp | 2 +- .../smart_reshape/smart_reshape.hpp | 2 +- .../smart_reshape/strided_slice_squeeze.hpp | 2 +- .../chained_maximum.hpp | 2 +- .../dereshape_matmul.hpp | 2 +- .../nop_broadcast.hpp | 2 +- .../reshape_optimizations.hpp | 2 +- .../transpose_sinking/ts_base.hpp | 3 +- .../transpose_sinking/ts_binary.hpp | 3 +- .../transpose_sinking/ts_concat.hpp | 3 +- .../transpose_sinking/ts_cumsum.hpp | 3 +- .../transpose_sinking/ts_data_movement.hpp | 3 +- .../transpose_sinking/ts_fuse.hpp | 3 +- .../transpose_sinking/ts_gather.hpp | 3 +- .../transpose_sinking/ts_interpolate.hpp | 3 +- .../transpose_sinking/ts_reduction.hpp | 3 +- .../ts_reset_no_sinking_attribute.hpp | 3 +- .../transpose_sinking/ts_slice.hpp | 3 +- .../transpose_sinking/ts_squeeze.hpp | 3 +- .../transpose_sinking/ts_unary.hpp | 2 +- .../transpose_sinking/ts_unsqueeze.hpp | 3 +- .../common_optimizations/ric_fusion.cpp | 1 + .../openvino/pass/backward_graph_rewrite.hpp | 23 +++ .../openvino/pass/convert_fp32_to_fp16.hpp | 2 +- .../include/openvino/pass/graph_rewrite.hpp | 159 +----------------- .../include/openvino/pass/matcher_pass.hpp | 107 ++++++++++++ .../include/openvino/pass/node_registry.hpp | 56 ++++++ src/core/src/pass/graph_rewrite.cpp | 8 + src/core/src/pass/node_registry.cpp | 9 + src/core/tests/graph_rewrite.cpp | 3 +- 231 files changed, 439 insertions(+), 427 deletions(-) create mode 100644 src/core/include/openvino/pass/backward_graph_rewrite.hpp create mode 100644 src/core/include/openvino/pass/matcher_pass.hpp create mode 100644 src/core/include/openvino/pass/node_registry.hpp create mode 100644 src/core/src/pass/node_registry.cpp diff --git a/src/bindings/python/src/pyopenvino/graph/passes/graph_rewrite.cpp b/src/bindings/python/src/pyopenvino/graph/passes/graph_rewrite.cpp index be013a00a76fde..031a188b74c6d7 100644 --- a/src/bindings/python/src/pyopenvino/graph/passes/graph_rewrite.cpp +++ b/src/bindings/python/src/pyopenvino/graph/passes/graph_rewrite.cpp @@ -6,8 +6,7 @@ #include -#include -#include +#include #include "pyopenvino/core/common.hpp" diff --git a/src/common/low_precision_transformations/include/low_precision/base_matcher_pass.hpp b/src/common/low_precision_transformations/include/low_precision/base_matcher_pass.hpp index a71735090f49dd..f3a217e9d25cab 100644 --- a/src/common/low_precision_transformations/include/low_precision/base_matcher_pass.hpp +++ b/src/common/low_precision_transformations/include/low_precision/base_matcher_pass.hpp @@ -4,7 +4,7 @@ #pragma once #include "openvino/core/node.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "rt_info/attribute_parameters.hpp" namespace ov { diff --git a/src/common/low_precision_transformations/include/low_precision/convert_subtract_constant.hpp b/src/common/low_precision_transformations/include/low_precision/convert_subtract_constant.hpp index 0316f0b2b029bb..d89384a8cd169f 100644 --- a/src/common/low_precision_transformations/include/low_precision/convert_subtract_constant.hpp +++ b/src/common/low_precision_transformations/include/low_precision/convert_subtract_constant.hpp @@ -8,7 +8,7 @@ #include #include "low_precision/lpt_visibility.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace pass { diff --git a/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp b/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp index 1357b81a88af0f..cd9c21f7fe8d40 100644 --- a/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp +++ b/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp @@ -8,7 +8,6 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "low_precision/lpt_visibility.hpp" #include "low_precision/base_matcher_pass.hpp" diff --git a/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp b/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp index dc3d81eefd9d89..c57d15dde899bd 100644 --- a/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp +++ b/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp @@ -11,7 +11,7 @@ #include "openvino/pass/pattern/op/wrap_type.hpp" #include "low_precision/lpt_visibility.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/opsets/opset1.hpp" #include "rt_info/precision_preserved_attribute.hpp" #include "network_helper.hpp" diff --git a/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp b/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp index 7a272d4a6adcb1..d86dbd9470cc07 100644 --- a/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp +++ b/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp @@ -11,7 +11,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformation_context.hpp" #include "quantization_details.hpp" #include "low_precision/common/ie_lpt_exception.hpp" diff --git a/src/common/low_precision_transformations/include/low_precision/markup_bias.hpp b/src/common/low_precision_transformations/include/low_precision/markup_bias.hpp index de5487187c4d56..a7f46f74dc0645 100644 --- a/src/common/low_precision_transformations/include/low_precision/markup_bias.hpp +++ b/src/common/low_precision_transformations/include/low_precision/markup_bias.hpp @@ -6,7 +6,7 @@ #include "low_precision/lpt_visibility.hpp" #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/pass/pattern/matcher.hpp" namespace ov { diff --git a/src/common/low_precision_transformations/include/low_precision/propagate_shared_value.hpp b/src/common/low_precision_transformations/include/low_precision/propagate_shared_value.hpp index 3f69575fc200e7..16a014cda6ec04 100644 --- a/src/common/low_precision_transformations/include/low_precision/propagate_shared_value.hpp +++ b/src/common/low_precision_transformations/include/low_precision/propagate_shared_value.hpp @@ -11,7 +11,7 @@ #include "openvino/core/node.hpp" #include "low_precision/lpt_visibility.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "low_precision/network_helper.hpp" #include "lpt_itt.hpp" diff --git a/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp b/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp index ce6139e2fca817..0450091699065d 100644 --- a/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp +++ b/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp @@ -8,7 +8,7 @@ #include #include "openvino/core/node.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "low_precision/lpt_visibility.hpp" diff --git a/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp b/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp index 0e8b0026fafac7..3e550b9e950ff3 100644 --- a/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp +++ b/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp @@ -11,7 +11,7 @@ #include "openvino/pass/pattern/op/wrap_type.hpp" #include "low_precision/lpt_visibility.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "network_helper.hpp" namespace ov { diff --git a/src/common/low_precision_transformations/include/low_precision/pull_reshape_through_dequantization.hpp b/src/common/low_precision_transformations/include/low_precision/pull_reshape_through_dequantization.hpp index adf623c757b647..75d0d3f6510048 100644 --- a/src/common/low_precision_transformations/include/low_precision/pull_reshape_through_dequantization.hpp +++ b/src/common/low_precision_transformations/include/low_precision/pull_reshape_through_dequantization.hpp @@ -7,7 +7,7 @@ #include #include #include "low_precision/lpt_visibility.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace pass { diff --git a/src/common/low_precision_transformations/include/low_precision/pull_transpose_through_dequantization.hpp b/src/common/low_precision_transformations/include/low_precision/pull_transpose_through_dequantization.hpp index aca835624e7ade..92e9eeebd2be52 100644 --- a/src/common/low_precision_transformations/include/low_precision/pull_transpose_through_dequantization.hpp +++ b/src/common/low_precision_transformations/include/low_precision/pull_transpose_through_dequantization.hpp @@ -7,7 +7,7 @@ #include #include #include "low_precision/lpt_visibility.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace pass { diff --git a/src/common/snippets/include/snippets/pass/broadcast_to_movebroadcast.hpp b/src/common/snippets/include/snippets/pass/broadcast_to_movebroadcast.hpp index 3e2dc15d99ae30..242d490b2fab05 100644 --- a/src/common/snippets/include/snippets/pass/broadcast_to_movebroadcast.hpp +++ b/src/common/snippets/include/snippets/pass/broadcast_to_movebroadcast.hpp @@ -5,7 +5,7 @@ #pragma once #include "openvino/pass/pattern/matcher.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/collapse_subgraph.hpp b/src/common/snippets/include/snippets/pass/collapse_subgraph.hpp index 57f8662a65ea52..41236df12aa0ef 100644 --- a/src/common/snippets/include/snippets/pass/collapse_subgraph.hpp +++ b/src/common/snippets/include/snippets/pass/collapse_subgraph.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "snippets/pass/tokenization.hpp" namespace ov { diff --git a/src/common/snippets/include/snippets/pass/common_optimizations.hpp b/src/common/snippets/include/snippets/pass/common_optimizations.hpp index 36fb7d7ef1bca4..1ff2d6293db649 100644 --- a/src/common/snippets/include/snippets/pass/common_optimizations.hpp +++ b/src/common/snippets/include/snippets/pass/common_optimizations.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "snippets/pass/tokenization.hpp" namespace ov { diff --git a/src/common/snippets/include/snippets/pass/convert_constants.hpp b/src/common/snippets/include/snippets/pass/convert_constants.hpp index 4b62d80ba44748..629528a1700959 100644 --- a/src/common/snippets/include/snippets/pass/convert_constants.hpp +++ b/src/common/snippets/include/snippets/pass/convert_constants.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/pass/pattern/matcher.hpp" namespace ov { diff --git a/src/common/snippets/include/snippets/pass/convert_power_to_powerstatic.hpp b/src/common/snippets/include/snippets/pass/convert_power_to_powerstatic.hpp index 85ead3b5785a04..a2274837fb7c3a 100644 --- a/src/common/snippets/include/snippets/pass/convert_power_to_powerstatic.hpp +++ b/src/common/snippets/include/snippets/pass/convert_power_to_powerstatic.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/explicit_transpose_matmul_inputs.hpp b/src/common/snippets/include/snippets/pass/explicit_transpose_matmul_inputs.hpp index d4aa8ed2ed947b..5aeee244a76877 100644 --- a/src/common/snippets/include/snippets/pass/explicit_transpose_matmul_inputs.hpp +++ b/src/common/snippets/include/snippets/pass/explicit_transpose_matmul_inputs.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/extract_reshapes_from_mha.hpp b/src/common/snippets/include/snippets/pass/extract_reshapes_from_mha.hpp index 9c7e9f67b7eafb..c4c23b6e247951 100644 --- a/src/common/snippets/include/snippets/pass/extract_reshapes_from_mha.hpp +++ b/src/common/snippets/include/snippets/pass/extract_reshapes_from_mha.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/fq_decomposition.hpp b/src/common/snippets/include/snippets/pass/fq_decomposition.hpp index 9ad25c927d1ca3..982835b4f27d64 100644 --- a/src/common/snippets/include/snippets/pass/fq_decomposition.hpp +++ b/src/common/snippets/include/snippets/pass/fq_decomposition.hpp @@ -5,7 +5,7 @@ #pragma once #include "openvino/op/fake_quantize.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/fuse_transpose_brgemm.hpp b/src/common/snippets/include/snippets/pass/fuse_transpose_brgemm.hpp index d32bc179f8af9c..d913df46caa890 100644 --- a/src/common/snippets/include/snippets/pass/fuse_transpose_brgemm.hpp +++ b/src/common/snippets/include/snippets/pass/fuse_transpose_brgemm.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/op/transpose.hpp" diff --git a/src/common/snippets/include/snippets/pass/gn_decomposition.hpp b/src/common/snippets/include/snippets/pass/gn_decomposition.hpp index 8bd80f90c790ff..5c7b6478dec15f 100644 --- a/src/common/snippets/include/snippets/pass/gn_decomposition.hpp +++ b/src/common/snippets/include/snippets/pass/gn_decomposition.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/insert_movebroadcast.hpp b/src/common/snippets/include/snippets/pass/insert_movebroadcast.hpp index 2ee9de1c15ed2f..787677a22ed108 100644 --- a/src/common/snippets/include/snippets/pass/insert_movebroadcast.hpp +++ b/src/common/snippets/include/snippets/pass/insert_movebroadcast.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/matmul_to_brgemm.hpp b/src/common/snippets/include/snippets/pass/matmul_to_brgemm.hpp index 29ce586bf2b394..780b153b4f0487 100644 --- a/src/common/snippets/include/snippets/pass/matmul_to_brgemm.hpp +++ b/src/common/snippets/include/snippets/pass/matmul_to_brgemm.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "snippets/op/brgemm.hpp" diff --git a/src/common/snippets/include/snippets/pass/mha_tokenization.hpp b/src/common/snippets/include/snippets/pass/mha_tokenization.hpp index 633505a5ce5ad6..78dad6ee8e6e19 100644 --- a/src/common/snippets/include/snippets/pass/mha_tokenization.hpp +++ b/src/common/snippets/include/snippets/pass/mha_tokenization.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "snippets/pass/tokenization.hpp" namespace ov { diff --git a/src/common/snippets/include/snippets/pass/reduce_to_snippets_reduce.hpp b/src/common/snippets/include/snippets/pass/reduce_to_snippets_reduce.hpp index 1270cf1ecccf88..01d33d6e86cd9c 100644 --- a/src/common/snippets/include/snippets/pass/reduce_to_snippets_reduce.hpp +++ b/src/common/snippets/include/snippets/pass/reduce_to_snippets_reduce.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/pattern/matcher.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/softmax_decomposition.hpp b/src/common/snippets/include/snippets/pass/softmax_decomposition.hpp index 51d80520d4991f..8e24c1532a72d3 100644 --- a/src/common/snippets/include/snippets/pass/softmax_decomposition.hpp +++ b/src/common/snippets/include/snippets/pass/softmax_decomposition.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/softmax_reshape_elimination.hpp b/src/common/snippets/include/snippets/pass/softmax_reshape_elimination.hpp index f72098996a0b13..b43881c1425f84 100644 --- a/src/common/snippets/include/snippets/pass/softmax_reshape_elimination.hpp +++ b/src/common/snippets/include/snippets/pass/softmax_reshape_elimination.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/tokenization.hpp b/src/common/snippets/include/snippets/pass/tokenization.hpp index aeee72160c85fe..24efcceec71a24 100644 --- a/src/common/snippets/include/snippets/pass/tokenization.hpp +++ b/src/common/snippets/include/snippets/pass/tokenization.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "snippets/op/subgraph.hpp" diff --git a/src/common/snippets/include/snippets/pass/transform_convert.hpp b/src/common/snippets/include/snippets/pass/transform_convert.hpp index bf9c27f0d782e1..5b087d4ae559eb 100644 --- a/src/common/snippets/include/snippets/pass/transform_convert.hpp +++ b/src/common/snippets/include/snippets/pass/transform_convert.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/transpose_decomposition.hpp b/src/common/snippets/include/snippets/pass/transpose_decomposition.hpp index e9bd1506b93c60..dbef9bc7b31c93 100644 --- a/src/common/snippets/include/snippets/pass/transpose_decomposition.hpp +++ b/src/common/snippets/include/snippets/pass/transpose_decomposition.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/snippets/include/snippets/pass/validate.hpp b/src/common/snippets/include/snippets/pass/validate.hpp index be0aed0a9f1f37..1fedf8a2ce08d5 100644 --- a/src/common/snippets/include/snippets/pass/validate.hpp +++ b/src/common/snippets/include/snippets/pass/validate.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace snippets { diff --git a/src/common/transformations/include/transformations/common_optimizations/adaptive_pool_to_reduce.hpp b/src/common/transformations/include/transformations/common_optimizations/adaptive_pool_to_reduce.hpp index a8e2bda647e776..06dde1ff0bbf63 100644 --- a/src/common/transformations/include/transformations/common_optimizations/adaptive_pool_to_reduce.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/adaptive_pool_to_reduce.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/add_fake_quantize_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/add_fake_quantize_fusion.hpp index 442e8f05548e4c..f63f00a455a117 100644 --- a/src/common/transformations/include/transformations/common_optimizations/add_fake_quantize_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/add_fake_quantize_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/align_eltwise_input_ranks.hpp b/src/common/transformations/include/transformations/common_optimizations/align_eltwise_input_ranks.hpp index ba25cbf634068a..1a7578d3551903 100644 --- a/src/common/transformations/include/transformations/common_optimizations/align_eltwise_input_ranks.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/align_eltwise_input_ranks.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" /** diff --git a/src/common/transformations/include/transformations/common_optimizations/augru_cell_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/augru_cell_fusion.hpp index 88a464fb81622e..c6773de5ec894f 100644 --- a/src/common/transformations/include/transformations/common_optimizations/augru_cell_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/augru_cell_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/batch_to_space_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/batch_to_space_fusion.hpp index 4075b2d8c11426..7b05f721f52400 100644 --- a/src/common/transformations/include/transformations/common_optimizations/batch_to_space_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/batch_to_space_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/binarize_weights.hpp b/src/common/transformations/include/transformations/common_optimizations/binarize_weights.hpp index 91c3fb3a794dd2..3803281478a055 100644 --- a/src/common/transformations/include/transformations/common_optimizations/binarize_weights.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/binarize_weights.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/broadcast_elementwise_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/broadcast_elementwise_fusion.hpp index fce96aff0ff374..38ae4799e932a0 100644 --- a/src/common/transformations/include/transformations/common_optimizations/broadcast_elementwise_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/broadcast_elementwise_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/broadcast_transition.hpp b/src/common/transformations/include/transformations/common_optimizations/broadcast_transition.hpp index 8dcaca0b7c6408..089f1472b7c431 100644 --- a/src/common/transformations/include/transformations/common_optimizations/broadcast_transition.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/broadcast_transition.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/pass/pattern/matcher.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/common_optimizations/clamp_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/clamp_fusion.hpp index 1cd33cdd93711d..fe966323edbb98 100644 --- a/src/common/transformations/include/transformations/common_optimizations/clamp_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/clamp_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/common_optimizations.hpp b/src/common/transformations/include/transformations/common_optimizations/common_optimizations.hpp index ccb268ebf17a55..7540275ce74d0f 100644 --- a/src/common/transformations/include/transformations/common_optimizations/common_optimizations.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/common_optimizations.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/concat_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/concat_fusion.hpp index 0a450e3d4f1a19..31b710722bf13f 100644 --- a/src/common/transformations/include/transformations/common_optimizations/concat_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/concat_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/concat_to_broadcast.hpp b/src/common/transformations/include/transformations/common_optimizations/concat_to_broadcast.hpp index 1a26d6a95db9a6..ddb20338c0b01d 100644 --- a/src/common/transformations/include/transformations/common_optimizations/concat_to_broadcast.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/concat_to_broadcast.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/conv_mul_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/conv_mul_fusion.hpp index b96dd5346dabce..9e2ba5194367ba 100644 --- a/src/common/transformations/include/transformations/common_optimizations/conv_mul_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/conv_mul_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/conv_to_binary_conv.hpp b/src/common/transformations/include/transformations/common_optimizations/conv_to_binary_conv.hpp index d615d3d6fd79b7..a60a15d37be9e7 100644 --- a/src/common/transformations/include/transformations/common_optimizations/conv_to_binary_conv.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/conv_to_binary_conv.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/convert_quantize_dequantize.hpp b/src/common/transformations/include/transformations/common_optimizations/convert_quantize_dequantize.hpp index 823844b416a66a..7c0b6b5be95d5d 100644 --- a/src/common/transformations/include/transformations/common_optimizations/convert_quantize_dequantize.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/convert_quantize_dequantize.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.hpp b/src/common/transformations/include/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.hpp index f6463890f60b79..dfd9eef8069665 100644 --- a/src/common/transformations/include/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/depth_to_space_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/depth_to_space_fusion.hpp index 82184e8491ac90..53e6b623d67d5a 100644 --- a/src/common/transformations/include/transformations/common_optimizations/depth_to_space_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/depth_to_space_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/dilated_convolution_converter.hpp b/src/common/transformations/include/transformations/common_optimizations/dilated_convolution_converter.hpp index c4814634d91d1b..204190cafd305c 100644 --- a/src/common/transformations/include/transformations/common_optimizations/dilated_convolution_converter.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/dilated_convolution_converter.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/dimension_tracking.hpp b/src/common/transformations/include/transformations/common_optimizations/dimension_tracking.hpp index a9bd1db84d33d7..d1ec2069b3f621 100644 --- a/src/common/transformations/include/transformations/common_optimizations/dimension_tracking.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/dimension_tracking.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" using P2Btype = diff --git a/src/common/transformations/include/transformations/common_optimizations/disable_random_uniform_constant_folding.hpp b/src/common/transformations/include/transformations/common_optimizations/disable_random_uniform_constant_folding.hpp index 00735ac681f584..405e8ff7288e5d 100644 --- a/src/common/transformations/include/transformations/common_optimizations/disable_random_uniform_constant_folding.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/disable_random_uniform_constant_folding.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/disable_shapeof_constant_folding.hpp b/src/common/transformations/include/transformations/common_optimizations/disable_shapeof_constant_folding.hpp index f0e439b72c19f4..1526fea966347d 100644 --- a/src/common/transformations/include/transformations/common_optimizations/disable_shapeof_constant_folding.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/disable_shapeof_constant_folding.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/divide_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/divide_fusion.hpp index 911c5c558687b6..37a5b1f66a5551 100644 --- a/src/common/transformations/include/transformations/common_optimizations/divide_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/divide_fusion.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/dropout_with_random_uniform_replacer.hpp b/src/common/transformations/include/transformations/common_optimizations/dropout_with_random_uniform_replacer.hpp index ab5e157e5cfd21..2ad17f308d46bc 100644 --- a/src/common/transformations/include/transformations/common_optimizations/dropout_with_random_uniform_replacer.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/dropout_with_random_uniform_replacer.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/eliminate_duplicate_ti_inputs.hpp b/src/common/transformations/include/transformations/common_optimizations/eliminate_duplicate_ti_inputs.hpp index 87c4b28f3a7bbb..058daba182b8a6 100644 --- a/src/common/transformations/include/transformations/common_optimizations/eliminate_duplicate_ti_inputs.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/eliminate_duplicate_ti_inputs.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/eliminate_loop_inputs_outputs.hpp b/src/common/transformations/include/transformations/common_optimizations/eliminate_loop_inputs_outputs.hpp index 361ccd11daf016..ca58bb504fd811 100644 --- a/src/common/transformations/include/transformations/common_optimizations/eliminate_loop_inputs_outputs.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/eliminate_loop_inputs_outputs.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/eliminate_unsqueeze_gather.hpp b/src/common/transformations/include/transformations/common_optimizations/eliminate_unsqueeze_gather.hpp index 244a51e8cb7423..b0ce4581a25569 100644 --- a/src/common/transformations/include/transformations/common_optimizations/eliminate_unsqueeze_gather.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/eliminate_unsqueeze_gather.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/enable_shapeof_constant_folding.hpp b/src/common/transformations/include/transformations/common_optimizations/enable_shapeof_constant_folding.hpp index 79c7eae24cc936..ab515ce65ac83b 100644 --- a/src/common/transformations/include/transformations/common_optimizations/enable_shapeof_constant_folding.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/enable_shapeof_constant_folding.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/fold_subgraph_empty_inputs.hpp b/src/common/transformations/include/transformations/common_optimizations/fold_subgraph_empty_inputs.hpp index 698a45f4acb612..8775d93644456e 100644 --- a/src/common/transformations/include/transformations/common_optimizations/fold_subgraph_empty_inputs.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/fold_subgraph_empty_inputs.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/fq_mul_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/fq_mul_fusion.hpp index 6b3875a3a977e1..3b48e9da740269 100644 --- a/src/common/transformations/include/transformations/common_optimizations/fq_mul_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/fq_mul_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/fq_reshape_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/fq_reshape_fusion.hpp index c39e505a0faf0e..e4004d794d8ec7 100644 --- a/src/common/transformations/include/transformations/common_optimizations/fq_reshape_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/fq_reshape_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/gru_cell_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/gru_cell_fusion.hpp index 4cb8542190de5a..50bc5ac370a74c 100644 --- a/src/common/transformations/include/transformations/common_optimizations/gru_cell_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/gru_cell_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/interpolate_sequence_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/interpolate_sequence_fusion.hpp index ff2c2ae9fe920c..ff7495e5a2d405 100644 --- a/src/common/transformations/include/transformations/common_optimizations/interpolate_sequence_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/interpolate_sequence_fusion.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/leaky_relu_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/leaky_relu_fusion.hpp index 42c66251cde2ac..42abc74e0dbc2a 100644 --- a/src/common/transformations/include/transformations/common_optimizations/leaky_relu_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/leaky_relu_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/matmul_const_transposes_extraction.hpp b/src/common/transformations/include/transformations/common_optimizations/matmul_const_transposes_extraction.hpp index 4ce419c0353497..7626be5f877527 100644 --- a/src/common/transformations/include/transformations/common_optimizations/matmul_const_transposes_extraction.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/matmul_const_transposes_extraction.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" /** diff --git a/src/common/transformations/include/transformations/common_optimizations/matmul_multiply_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/matmul_multiply_fusion.hpp index 57108da5ea554f..7994a04be7972d 100644 --- a/src/common/transformations/include/transformations/common_optimizations/matmul_multiply_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/matmul_multiply_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/mish_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/mish_fusion.hpp index 6f37fdf7dae9ee..8dc6e0149c881f 100644 --- a/src/common/transformations/include/transformations/common_optimizations/mish_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/mish_fusion.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/moc_transformations.hpp b/src/common/transformations/include/transformations/common_optimizations/moc_transformations.hpp index ffe98b65a2bd06..49893dfb220de6 100644 --- a/src/common/transformations/include/transformations/common_optimizations/moc_transformations.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/moc_transformations.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/mul_conv_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/mul_conv_fusion.hpp index 1b2906a0292ccc..75d73b5f2a8d97 100644 --- a/src/common/transformations/include/transformations/common_optimizations/mul_conv_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/mul_conv_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/mul_fake_quantize_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/mul_fake_quantize_fusion.hpp index b4be1d6c7c3e6d..f66e52f82c6c0e 100644 --- a/src/common/transformations/include/transformations/common_optimizations/mul_fake_quantize_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/mul_fake_quantize_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.hpp index 40536393a08d2e..04b45ee6c67cd3 100644 --- a/src/common/transformations/include/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/nonzero_horizontal_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/nonzero_horizontal_fusion.hpp index 7e4ac4a25bf994..d579cb0c8a9ec1 100644 --- a/src/common/transformations/include/transformations/common_optimizations/nonzero_horizontal_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/nonzero_horizontal_fusion.hpp @@ -6,8 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/normalize_l2_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/normalize_l2_fusion.hpp index e117e97c3ea301..39355ec6af5ec4 100644 --- a/src/common/transformations/include/transformations/common_optimizations/normalize_l2_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/normalize_l2_fusion.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/pull_transpose_through_fq.hpp b/src/common/transformations/include/transformations/common_optimizations/pull_transpose_through_fq.hpp index 27ac2edd134f45..c4aa71724a07a3 100644 --- a/src/common/transformations/include/transformations/common_optimizations/pull_transpose_through_fq.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/pull_transpose_through_fq.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/random_uniform_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/random_uniform_fusion.hpp index 96cede7bb5a628..198666e9a02673 100644 --- a/src/common/transformations/include/transformations/common_optimizations/random_uniform_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/random_uniform_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/reduce_merge.hpp b/src/common/transformations/include/transformations/common_optimizations/reduce_merge.hpp index 87af67497b85ae..20daf9173b87c8 100644 --- a/src/common/transformations/include/transformations/common_optimizations/reduce_merge.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/reduce_merge.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/reduce_reshape_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/reduce_reshape_fusion.hpp index 2521c44ce4231a..2827be2cdb5738 100644 --- a/src/common/transformations/include/transformations/common_optimizations/reduce_reshape_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/reduce_reshape_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/relu_fake_quantize_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/relu_fake_quantize_fusion.hpp index a905438f8fd0eb..8d2895b378c774 100644 --- a/src/common/transformations/include/transformations/common_optimizations/relu_fake_quantize_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/relu_fake_quantize_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/remove_concat_zero_dim_input.hpp b/src/common/transformations/include/transformations/common_optimizations/remove_concat_zero_dim_input.hpp index c941a60c1b9c68..5c746cd4dde987 100644 --- a/src/common/transformations/include/transformations/common_optimizations/remove_concat_zero_dim_input.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/remove_concat_zero_dim_input.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/reshape_prelu.hpp b/src/common/transformations/include/transformations/common_optimizations/reshape_prelu.hpp index d2984eceec4aa5..9ced2036d9906b 100644 --- a/src/common/transformations/include/transformations/common_optimizations/reshape_prelu.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/reshape_prelu.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/reshape_sequence_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/reshape_sequence_fusion.hpp index 338655e70f879a..5fa22e7feb0fe6 100644 --- a/src/common/transformations/include/transformations/common_optimizations/reshape_sequence_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/reshape_sequence_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/ric_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/ric_fusion.hpp index d47ba645b94f84..c91c27a464cada 100644 --- a/src/common/transformations/include/transformations/common_optimizations/ric_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/ric_fusion.hpp @@ -5,8 +5,7 @@ #pragma once #include "openvino/core/model.hpp" -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/rms_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/rms_fusion.hpp index b03902440067b2..5d4d5609367ff1 100644 --- a/src/common/transformations/include/transformations/common_optimizations/rms_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/rms_fusion.hpp @@ -4,8 +4,8 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" #include "openvino/pass/manager.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/select_with_one_value_condition.hpp b/src/common/transformations/include/transformations/common_optimizations/select_with_one_value_condition.hpp index 66d4f50fbc6c75..5278e17d07ff64 100644 --- a/src/common/transformations/include/transformations/common_optimizations/select_with_one_value_condition.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/select_with_one_value_condition.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/sequence_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/sequence_fusion.hpp index cdbd57ec269e31..ecba41990e28dd 100644 --- a/src/common/transformations/include/transformations/common_optimizations/sequence_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/sequence_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/shared_ops_optimization.hpp b/src/common/transformations/include/transformations/common_optimizations/shared_ops_optimization.hpp index da582db367b010..8e2a87502ebcc9 100644 --- a/src/common/transformations/include/transformations/common_optimizations/shared_ops_optimization.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/shared_ops_optimization.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/shuffle_channels_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/shuffle_channels_fusion.hpp index 6b3aa632f34a62..2304fe637b4551 100644 --- a/src/common/transformations/include/transformations/common_optimizations/shuffle_channels_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/shuffle_channels_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/simplify_shape_of_sub_graph.hpp b/src/common/transformations/include/transformations/common_optimizations/simplify_shape_of_sub_graph.hpp index 92286f06b70b92..509047578bd489 100644 --- a/src/common/transformations/include/transformations/common_optimizations/simplify_shape_of_sub_graph.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/simplify_shape_of_sub_graph.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.hpp b/src/common/transformations/include/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.hpp index b5ab5480134e1d..a93fdb8f4f20fe 100644 --- a/src/common/transformations/include/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/softmax_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/softmax_fusion.hpp index 88ef524ef523aa..f56a8bd1b574f7 100644 --- a/src/common/transformations/include/transformations/common_optimizations/softmax_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/softmax_fusion.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/softplus_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/softplus_fusion.hpp index 094dee82f6cc19..44d34dcdcc4c90 100644 --- a/src/common/transformations/include/transformations/common_optimizations/softplus_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/softplus_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/softplus_to_mish_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/softplus_to_mish_fusion.hpp index bb0689bc639a54..6a6d247e4ea351 100644 --- a/src/common/transformations/include/transformations/common_optimizations/softplus_to_mish_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/softplus_to_mish_fusion.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/space_to_batch_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/space_to_batch_fusion.hpp index 0048e63b7e60ba..43cf4654628cf5 100644 --- a/src/common/transformations/include/transformations/common_optimizations/space_to_batch_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/space_to_batch_fusion.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/split_concat_pair_to_interpolate_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/split_concat_pair_to_interpolate_fusion.hpp index f18c0b736975fd..e9ecba4fe6e961 100644 --- a/src/common/transformations/include/transformations/common_optimizations/split_concat_pair_to_interpolate_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/split_concat_pair_to_interpolate_fusion.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/split_squeeze_concat_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/split_squeeze_concat_fusion.hpp index 6ec54032c0c6e8..24073c6a61e2dc 100644 --- a/src/common/transformations/include/transformations/common_optimizations/split_squeeze_concat_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/split_squeeze_concat_fusion.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/strides_optimization.hpp b/src/common/transformations/include/transformations/common_optimizations/strides_optimization.hpp index a0d73eb6b40676..57f5036fe5faa7 100644 --- a/src/common/transformations/include/transformations/common_optimizations/strides_optimization.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/strides_optimization.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/backward_graph_rewrite.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/subtract_fusion.hpp b/src/common/transformations/include/transformations/common_optimizations/subtract_fusion.hpp index 18f660ccf581c0..69e4095b6becd7 100644 --- a/src/common/transformations/include/transformations/common_optimizations/subtract_fusion.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/subtract_fusion.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.hpp b/src/common/transformations/include/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.hpp index 7ac286eb610f48..c1299872c4b3a5 100644 --- a/src/common/transformations/include/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/transpose_sinking.hpp b/src/common/transformations/include/transformations/common_optimizations/transpose_sinking.hpp index 3fc33c9a553060..8189535fe260ae 100644 --- a/src/common/transformations/include/transformations/common_optimizations/transpose_sinking.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/transpose_sinking.hpp @@ -8,7 +8,6 @@ #include #include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/transpose_to_reshape.hpp b/src/common/transformations/include/transformations/common_optimizations/transpose_to_reshape.hpp index 3ca43521250699..aba6154bb0b58c 100644 --- a/src/common/transformations/include/transformations/common_optimizations/transpose_to_reshape.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/transpose_to_reshape.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp b/src/common/transformations/include/transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp index 5e856384a0bebb..aa34c7859d068a 100644 --- a/src/common/transformations/include/transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/common_optimizations/wrap_interpolate_into_transposes.hpp b/src/common/transformations/include/transformations/common_optimizations/wrap_interpolate_into_transposes.hpp index 1a4122349c51e6..7b35498d5dde64 100644 --- a/src/common/transformations/include/transformations/common_optimizations/wrap_interpolate_into_transposes.hpp +++ b/src/common/transformations/include/transformations/common_optimizations/wrap_interpolate_into_transposes.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/control_flow/unroll_if.hpp b/src/common/transformations/include/transformations/control_flow/unroll_if.hpp index a41447caa2f7a8..e59b60106e2536 100644 --- a/src/common/transformations/include/transformations/control_flow/unroll_if.hpp +++ b/src/common/transformations/include/transformations/control_flow/unroll_if.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/control_flow/unroll_tensor_iterator.hpp b/src/common/transformations/include/transformations/control_flow/unroll_tensor_iterator.hpp index b2755da91bfd71..282aecab5c7f05 100644 --- a/src/common/transformations/include/transformations/control_flow/unroll_tensor_iterator.hpp +++ b/src/common/transformations/include/transformations/control_flow/unroll_tensor_iterator.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/convert_precision.hpp b/src/common/transformations/include/transformations/convert_precision.hpp index 636dae4ac4d38f..30f773da9e3be4 100644 --- a/src/common/transformations/include/transformations/convert_precision.hpp +++ b/src/common/transformations/include/transformations/convert_precision.hpp @@ -10,7 +10,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/flush_fp32_subnormals_to_zero.hpp b/src/common/transformations/include/transformations/flush_fp32_subnormals_to_zero.hpp index 26925ad35ab4f0..71c71b0614f29d 100644 --- a/src/common/transformations/include/transformations/flush_fp32_subnormals_to_zero.hpp +++ b/src/common/transformations/include/transformations/flush_fp32_subnormals_to_zero.hpp @@ -7,7 +7,7 @@ #include #include "openvino/core/model.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/pass/serialize.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/fp16_compression/align_mixed_fp32_fp16_types.hpp b/src/common/transformations/include/transformations/fp16_compression/align_mixed_fp32_fp16_types.hpp index e819795d9bec2d..4fd93d7742ab67 100644 --- a/src/common/transformations/include/transformations/fp16_compression/align_mixed_fp32_fp16_types.hpp +++ b/src/common/transformations/include/transformations/fp16_compression/align_mixed_fp32_fp16_types.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/fp16_compression/convert_compression_only_to_legacy.hpp b/src/common/transformations/include/transformations/fp16_compression/convert_compression_only_to_legacy.hpp index 9a4ab82a778fca..fbac44f637a2a2 100644 --- a/src/common/transformations/include/transformations/fp16_compression/convert_compression_only_to_legacy.hpp +++ b/src/common/transformations/include/transformations/fp16_compression/convert_compression_only_to_legacy.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp b/src/common/transformations/include/transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp index a9aa3a0855cf0a..4f003dbc09e671 100644 --- a/src/common/transformations/include/transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp +++ b/src/common/transformations/include/transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp @@ -5,7 +5,7 @@ #pragma once #include "mark_decompression_convert_constant_folding.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.hpp b/src/common/transformations/include/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.hpp index ae50cc2d943dcc..0ffce989f0d83c 100644 --- a/src/common/transformations/include/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.hpp +++ b/src/common/transformations/include/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/backward_graph_rewrite.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/init_node_info.hpp b/src/common/transformations/include/transformations/init_node_info.hpp index 13e748f2316ab6..e458bcfdcd4bd4 100644 --- a/src/common/transformations/include/transformations/init_node_info.hpp +++ b/src/common/transformations/include/transformations/init_node_info.hpp @@ -12,7 +12,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/low_precision/mark_dequantization_subgraph.hpp b/src/common/transformations/include/transformations/low_precision/mark_dequantization_subgraph.hpp index 0fe847d402e405..832c06573caff4 100644 --- a/src/common/transformations/include/transformations/low_precision/mark_dequantization_subgraph.hpp +++ b/src/common/transformations/include/transformations/low_precision/mark_dequantization_subgraph.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/batch_norm_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/batch_norm_decomposition.hpp index 75b1bc38df3fbc..9f4399804c50ff 100644 --- a/src/common/transformations/include/transformations/op_conversions/batch_norm_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/batch_norm_decomposition.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" using namespace std; diff --git a/src/common/transformations/include/transformations/op_conversions/convert_avgpool_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_avgpool_downgrade.hpp index 7a16d522c283a5..40f4e32b60af7e 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_avgpool_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_avgpool_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_batch_to_space.hpp b/src/common/transformations/include/transformations/op_conversions/convert_batch_to_space.hpp index 5e84c886f4e5d2..f2792b467a96e0 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_batch_to_space.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_batch_to_space.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_broadcast3.hpp b/src/common/transformations/include/transformations/op_conversions/convert_broadcast3.hpp index afadecfd967490..06687b9e07ba01 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_broadcast3.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_broadcast3.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_broadcast_to_tiles.hpp b/src/common/transformations/include/transformations/op_conversions/convert_broadcast_to_tiles.hpp index ba799943863ea4..5d5934b33e8216 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_broadcast_to_tiles.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_broadcast_to_tiles.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_convertlike.hpp b/src/common/transformations/include/transformations/op_conversions/convert_convertlike.hpp index 74f15d1aef6c84..dfe5e5e7424d90 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_convertlike.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_convertlike.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_convertpromotetypes.hpp b/src/common/transformations/include/transformations/op_conversions/convert_convertpromotetypes.hpp index a0c8fd3eb0fd5a..c4d95f1211bea5 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_convertpromotetypes.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_convertpromotetypes.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_deformable_conv_v8_to_v1.hpp b/src/common/transformations/include/transformations/op_conversions/convert_deformable_conv_v8_to_v1.hpp index 9208403e4eca85..7db239e18d265a 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_deformable_conv_v8_to_v1.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_deformable_conv_v8_to_v1.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_depth_to_space.hpp b/src/common/transformations/include/transformations/op_conversions/convert_depth_to_space.hpp index 72e0ecb168fd69..481006b7a05822 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_depth_to_space.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_depth_to_space.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_divide.hpp b/src/common/transformations/include/transformations/op_conversions/convert_divide.hpp index 9698f59f2b73c0..66442bbdc123da 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_divide.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_divide.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.hpp index 18b1339366ece3..6ddbff4b7991b6 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.hpp index bac6e636ac9daa..a925928a28a3d8 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_gather_0d.hpp b/src/common/transformations/include/transformations/op_conversions/convert_gather_0d.hpp index 2d97152a1b1588..75f9dd967d48c8 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_gather_0d.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_gather_0d.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_gather_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_gather_downgrade.hpp index e6b6b0a8b67fb4..dfdbed915679b2 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_gather_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_gather_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_gather_to_compressed.hpp b/src/common/transformations/include/transformations/op_conversions/convert_gather_to_compressed.hpp index 2181396adc0284..a916e9a4b91a44 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_gather_to_compressed.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_gather_to_compressed.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_gather_upgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_gather_upgrade.hpp index cfc2f41b23af06..ec8f8be61c3015 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_gather_upgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_gather_upgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_gelu.hpp b/src/common/transformations/include/transformations/op_conversions/convert_gelu.hpp index a7d172cb81a307..498872814f9cbb 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_gelu.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_gelu.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_gp9_to_gp_ie_internal.hpp b/src/common/transformations/include/transformations/op_conversions/convert_gp9_to_gp_ie_internal.hpp index 90017756954aa5..9fe62aad7fbd8c 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_gp9_to_gp_ie_internal.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_gp9_to_gp_ie_internal.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_interpolate11_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_interpolate11_downgrade.hpp index 2797da2370315d..8c136aa918f5f0 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_interpolate11_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_interpolate11_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_interpolate1_to_interpolate4.hpp b/src/common/transformations/include/transformations/op_conversions/convert_interpolate1_to_interpolate4.hpp index 6c54128dfce58b..f3b07c36962ccd 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_interpolate1_to_interpolate4.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_interpolate1_to_interpolate4.hpp @@ -8,7 +8,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.hpp b/src/common/transformations/include/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.hpp index 940db1608607fc..6d414139ad6f57 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.hpp @@ -8,7 +8,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_maxpool_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_maxpool_downgrade.hpp index f62300e95a9d26..953cbab8a801a7 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_maxpool_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_maxpool_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_maxpool_upgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_maxpool_upgrade.hpp index ade23432733f37..6e7eed21342584 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_maxpool_upgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_maxpool_upgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_minimum_to_power_and_max.hpp b/src/common/transformations/include/transformations/op_conversions/convert_minimum_to_power_and_max.hpp index 90f97eb8cdb01f..d092ffec29d8c4 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_minimum_to_power_and_max.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_minimum_to_power_and_max.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_mod.hpp b/src/common/transformations/include/transformations/op_conversions/convert_mod.hpp index d3bec6f48e764e..0fbd3bba723ecb 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_mod.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_mod.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.hpp b/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.hpp index 5a33375a833548..361d2352928b7e 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_upgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_upgrade.hpp index 653aeca61fd4f8..1f3e9e9b5caf08 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_upgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_multiclass_nms_upgrade.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_mvn1_to_mvn6.hpp b/src/common/transformations/include/transformations/op_conversions/convert_mvn1_to_mvn6.hpp index 4daba95e86a192..d958d166f7270d 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_mvn1_to_mvn6.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_mvn1_to_mvn6.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_negative.hpp b/src/common/transformations/include/transformations/op_conversions/convert_negative.hpp index e85e6092b6ee40..b985f4bfe7f639 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_negative.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_negative.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_nms9_to_nms_ie_internal.hpp b/src/common/transformations/include/transformations/op_conversions/convert_nms9_to_nms_ie_internal.hpp index d9078815070172..fee970b6b44bfc 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_nms9_to_nms_ie_internal.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_nms9_to_nms_ie_internal.hpp @@ -8,7 +8,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.hpp b/src/common/transformations/include/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.hpp index f117b406d2863e..dcee03e513b38e 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.hpp @@ -8,7 +8,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_nms_to_nms_ie_internal.hpp b/src/common/transformations/include/transformations/op_conversions/convert_nms_to_nms_ie_internal.hpp index a5ff6807870f91..ca205fe9078f7a 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_nms_to_nms_ie_internal.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_nms_to_nms_ie_internal.hpp @@ -8,7 +8,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_pad12_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_pad12_downgrade.hpp index 7cd48773e492d0..36ca9112b07829 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_pad12_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_pad12_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_pad_to_group_conv.hpp b/src/common/transformations/include/transformations/op_conversions/convert_pad_to_group_conv.hpp index 8134d27d207ca2..a89386bd7048cb 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_pad_to_group_conv.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_pad_to_group_conv.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_5.hpp b/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_5.hpp index 7077d672d0aa5f..8a4c0ee3110c1b 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_5.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_5.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_9.hpp b/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_9.hpp index 1a50dd10708eae..f77db7a03f8606 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_9.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_previous_nms_to_nms_9.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_prior_box_v8_to_v0.hpp b/src/common/transformations/include/transformations/op_conversions/convert_prior_box_v8_to_v0.hpp index 24b4520c506642..2725d789a83a70 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_prior_box_v8_to_v0.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_prior_box_v8_to_v0.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v3_to_v9.hpp b/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v3_to_v9.hpp index 66de7739d61572..71f6becff0ba26 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v3_to_v9.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v3_to_v9.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v9_to_v3.hpp b/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v9_to_v3.hpp index 6d0a830dc7f0bd..d06dc424ff436e 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v9_to_v3.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_roi_align_v9_to_v3.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_to_scatter.hpp b/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_to_scatter.hpp index 9bc3cedbf3b532..d0a738c14fab9c 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_to_scatter.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_to_scatter.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_update12_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_update12_downgrade.hpp index 37f5a86224ce62..4af4e18c706e93 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_update12_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_scatter_elements_update12_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_shapeof3.hpp b/src/common/transformations/include/transformations/op_conversions/convert_shapeof3.hpp index e684e7a699be8b..0aceb9e99614fb 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_shapeof3.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_shapeof3.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_shuffle_channels3.hpp b/src/common/transformations/include/transformations/op_conversions/convert_shuffle_channels3.hpp index 3efd57c95c11b7..05b2d2607464b8 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_shuffle_channels3.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_shuffle_channels3.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_slice_to_strided_slice.hpp b/src/common/transformations/include/transformations/op_conversions/convert_slice_to_strided_slice.hpp index c6b4bf125f1195..8d396bca6ccd1e 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_slice_to_strided_slice.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_slice_to_strided_slice.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_softmax_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_softmax_downgrade.hpp index 0bd1d11c68a491..701f2cb94e9857 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_softmax_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_softmax_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_softmax_upgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_softmax_upgrade.hpp index 31754bc9a997cb..2164eac6052384 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_softmax_upgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_softmax_upgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_space_to_batch.hpp b/src/common/transformations/include/transformations/op_conversions/convert_space_to_batch.hpp index 7d3f98cd273b6d..97bda0273c522f 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_space_to_batch.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_space_to_batch.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_space_to_depth.hpp b/src/common/transformations/include/transformations/op_conversions/convert_space_to_depth.hpp index ec97bbdc62016c..da97add26411a8 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_space_to_depth.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_space_to_depth.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_subtract.hpp b/src/common/transformations/include/transformations/op_conversions/convert_subtract.hpp index b3f41501dfd084..5b2a5d0c36abdf 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_subtract.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_subtract.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_topk11_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/convert_topk11_downgrade.hpp index 0514e0bad38003..e6e8340e45df94 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_topk11_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_topk11_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_topk3.hpp b/src/common/transformations/include/transformations/op_conversions/convert_topk3.hpp index 7b5b5dad08f096..0b61bf85bff28f 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_topk3.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_topk3.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/convert_xor_to_logical_xor.hpp b/src/common/transformations/include/transformations/op_conversions/convert_xor_to_logical_xor.hpp index 21740be21597df..ee7bf0f55615bd 100644 --- a/src/common/transformations/include/transformations/op_conversions/convert_xor_to_logical_xor.hpp +++ b/src/common/transformations/include/transformations/op_conversions/convert_xor_to_logical_xor.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/detection_output_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/detection_output_downgrade.hpp index f34c28a0f3295c..8f4e6ad237a6b0 100644 --- a/src/common/transformations/include/transformations/op_conversions/detection_output_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/detection_output_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/detection_output_upgrade.hpp b/src/common/transformations/include/transformations/op_conversions/detection_output_upgrade.hpp index cb0b108f22460a..8693fb206ed2cd 100644 --- a/src/common/transformations/include/transformations/op_conversions/detection_output_upgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/detection_output_upgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/einsum_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/einsum_decomposition.hpp index a754f954261a3e..78accf3f0b4877 100644 --- a/src/common/transformations/include/transformations/op_conversions/einsum_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/einsum_decomposition.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/eye_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/eye_decomposition.hpp index dda37e63fe93e8..15c53bc9cf6f30 100644 --- a/src/common/transformations/include/transformations/op_conversions/eye_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/eye_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/fq_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/fq_decomposition.hpp index c1ed179ba39fb6..d938a9b70687e2 100644 --- a/src/common/transformations/include/transformations/op_conversions/fq_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/fq_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/gelu7_downgrade.hpp b/src/common/transformations/include/transformations/op_conversions/gelu7_downgrade.hpp index b95d2a21472420..d08c3877de26a1 100644 --- a/src/common/transformations/include/transformations/op_conversions/gelu7_downgrade.hpp +++ b/src/common/transformations/include/transformations/op_conversions/gelu7_downgrade.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/group_normalization_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/group_normalization_decomposition.hpp index c9dbfe594c1a22..8df9c220a9de75 100644 --- a/src/common/transformations/include/transformations/op_conversions/group_normalization_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/group_normalization_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/gru_cell_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/gru_cell_decomposition.hpp index de6e414e3a9024..ce4387293f97ad 100644 --- a/src/common/transformations/include/transformations/op_conversions/gru_cell_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/gru_cell_decomposition.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/hard_sigmoid_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/hard_sigmoid_decomposition.hpp index cfdf19bdbf305d..b635a08350922b 100644 --- a/src/common/transformations/include/transformations/op_conversions/hard_sigmoid_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/hard_sigmoid_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/hsigmoid_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/hsigmoid_decomposition.hpp index 6db5d0b39553a4..5a455c37253afe 100644 --- a/src/common/transformations/include/transformations/op_conversions/hsigmoid_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/hsigmoid_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/hswish_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/hswish_decomposition.hpp index 021768ce572975..e6168109d3c89b 100644 --- a/src/common/transformations/include/transformations/op_conversions/hswish_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/hswish_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/log_softmax_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/log_softmax_decomposition.hpp index 625f375487df66..f972a0cdd8fa76 100644 --- a/src/common/transformations/include/transformations/op_conversions/log_softmax_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/log_softmax_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/lstm_cell_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/lstm_cell_decomposition.hpp index d2f16d5c1a164e..08b109533738cf 100644 --- a/src/common/transformations/include/transformations/op_conversions/lstm_cell_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/lstm_cell_decomposition.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/mvn6_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/mvn6_decomposition.hpp index 2cff2f6ea823a6..f8335f5f4546f2 100644 --- a/src/common/transformations/include/transformations/op_conversions/mvn6_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/mvn6_decomposition.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/normalize_l2_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/normalize_l2_decomposition.hpp index d93c28577c2c8b..ae058a3e8cba2f 100644 --- a/src/common/transformations/include/transformations/op_conversions/normalize_l2_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/normalize_l2_decomposition.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/reduce_l1_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/reduce_l1_decomposition.hpp index 18f3560b90cebd..506853e003e33a 100644 --- a/src/common/transformations/include/transformations/op_conversions/reduce_l1_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/reduce_l1_decomposition.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/reduce_l2_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/reduce_l2_decomposition.hpp index ab69a523ea9d56..dab02ff58f2f5c 100644 --- a/src/common/transformations/include/transformations/op_conversions/reduce_l2_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/reduce_l2_decomposition.hpp @@ -7,8 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/rnn_cell_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/rnn_cell_decomposition.hpp index df8fab51867862..ce651a47510577 100644 --- a/src/common/transformations/include/transformations/op_conversions/rnn_cell_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/rnn_cell_decomposition.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/scaled_dot_product_attention_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/scaled_dot_product_attention_decomposition.hpp index 254f64ff43c2b5..e52c6ba46838b9 100644 --- a/src/common/transformations/include/transformations/op_conversions/scaled_dot_product_attention_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/scaled_dot_product_attention_decomposition.hpp @@ -5,7 +5,7 @@ #pragma once #include "openvino/op/scaled_dot_product_attention.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.hpp b/src/common/transformations/include/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.hpp index a87bcd5265f158..70cd9bbe0162c5 100644 --- a/src/common/transformations/include/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.hpp +++ b/src/common/transformations/include/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/softmax_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/softmax_decomposition.hpp index b7fb184a74f7ef..a1ab4be69fdc62 100644 --- a/src/common/transformations/include/transformations/op_conversions/softmax_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/softmax_decomposition.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/softplus_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/softplus_decomposition.hpp index 2d79165c5aabf5..3a7cca9ff5c8b1 100644 --- a/src/common/transformations/include/transformations/op_conversions/softplus_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/softplus_decomposition.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/softsign_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/softsign_decomposition.hpp index 62f372052e81cf..bfd026f21eb111 100644 --- a/src/common/transformations/include/transformations/op_conversions/softsign_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/softsign_decomposition.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/op_conversions/unique_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/unique_decomposition.hpp index 05833b9305cd82..02f889e7d3122a 100644 --- a/src/common/transformations/include/transformations/op_conversions/unique_decomposition.hpp +++ b/src/common/transformations/include/transformations/op_conversions/unique_decomposition.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/opset_conversions/convert_opset2_to_opset1.hpp b/src/common/transformations/include/transformations/opset_conversions/convert_opset2_to_opset1.hpp index 273f7f915624f1..8b523bc663912d 100644 --- a/src/common/transformations/include/transformations/opset_conversions/convert_opset2_to_opset1.hpp +++ b/src/common/transformations/include/transformations/opset_conversions/convert_opset2_to_opset1.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/opset_conversions/convert_opset3_to_opset2.hpp b/src/common/transformations/include/transformations/opset_conversions/convert_opset3_to_opset2.hpp index d7100c6adfc1ff..8a44b0d24ad6e4 100644 --- a/src/common/transformations/include/transformations/opset_conversions/convert_opset3_to_opset2.hpp +++ b/src/common/transformations/include/transformations/opset_conversions/convert_opset3_to_opset2.hpp @@ -6,7 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/sdpa_to_paged_attention/position_ids_replacer.hpp b/src/common/transformations/include/transformations/sdpa_to_paged_attention/position_ids_replacer.hpp index bd0c29aa0474cf..5ee79ec787a9bc 100644 --- a/src/common/transformations/include/transformations/sdpa_to_paged_attention/position_ids_replacer.hpp +++ b/src/common/transformations/include/transformations/sdpa_to_paged_attention/position_ids_replacer.hpp @@ -5,7 +5,10 @@ #pragma once #include "openvino/op/add.hpp" -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/op/parameter.hpp" +#include "openvino/pass/matcher_pass.hpp" +#include "openvino/pass/pattern/op/wrap_type.hpp" +#include "transformations/utils/utils.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp b/src/common/transformations/include/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp index a811a8eeac2e2c..fd4e22c69262ae 100644 --- a/src/common/transformations/include/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp +++ b/src/common/transformations/include/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp @@ -4,7 +4,11 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/cc/pass/itt.hpp" +#include "openvino/op/shape_of.hpp" +#include "openvino/op/subtract.hpp" +#include "openvino/pass/matcher_pass.hpp" +#include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/utils/utils.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/sdpa_to_paged_attention/state_management_pattern.hpp b/src/common/transformations/include/transformations/sdpa_to_paged_attention/state_management_pattern.hpp index d3be92d829165a..feab06ccc0cd5d 100644 --- a/src/common/transformations/include/transformations/sdpa_to_paged_attention/state_management_pattern.hpp +++ b/src/common/transformations/include/transformations/sdpa_to_paged_attention/state_management_pattern.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.hpp b/src/common/transformations/include/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.hpp index 8ebb0f6ec71905..c6b319a389ecaa 100644 --- a/src/common/transformations/include/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.hpp +++ b/src/common/transformations/include/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.hpp @@ -4,7 +4,11 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/op/concat.hpp" +#include "openvino/op/parameter.hpp" +#include "openvino/pass/matcher_pass.hpp" +#include "openvino/pass/pattern/op/wrap_type.hpp" +#include "transformations/utils/utils.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/broadcast_const_range_replacement.hpp b/src/common/transformations/include/transformations/smart_reshape/broadcast_const_range_replacement.hpp index 2561a01854c038..04f7de9a336414 100644 --- a/src/common/transformations/include/transformations/smart_reshape/broadcast_const_range_replacement.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/broadcast_const_range_replacement.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/lstm_states_broadcast.hpp b/src/common/transformations/include/transformations/smart_reshape/lstm_states_broadcast.hpp index 8616fafa2b131a..55f80ace7812e3 100644 --- a/src/common/transformations/include/transformations/smart_reshape/lstm_states_broadcast.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/lstm_states_broadcast.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/matmul_sr.hpp b/src/common/transformations/include/transformations/smart_reshape/matmul_sr.hpp index 430da1d1250790..4e21e767d1bce6 100644 --- a/src/common/transformations/include/transformations/smart_reshape/matmul_sr.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/matmul_sr.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/proposal_scales_stridedslice.hpp b/src/common/transformations/include/transformations/smart_reshape/proposal_scales_stridedslice.hpp index 6c853f5820a815..d2eaf125e0dd5c 100644 --- a/src/common/transformations/include/transformations/smart_reshape/proposal_scales_stridedslice.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/proposal_scales_stridedslice.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/reshape_sinking.hpp b/src/common/transformations/include/transformations/smart_reshape/reshape_sinking.hpp index c9fa23ce7f86a3..aeaf46ccde1c2b 100644 --- a/src/common/transformations/include/transformations/smart_reshape/reshape_sinking.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/reshape_sinking.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/reshape_to_1D.hpp b/src/common/transformations/include/transformations/smart_reshape/reshape_to_1D.hpp index d08f212925182a..a973038bb30900 100644 --- a/src/common/transformations/include/transformations/smart_reshape/reshape_to_1D.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/reshape_to_1D.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/shape_of_const_folding.hpp b/src/common/transformations/include/transformations/smart_reshape/shape_of_const_folding.hpp index d7dc15d4d7454b..d2bc029cce4682 100644 --- a/src/common/transformations/include/transformations/smart_reshape/shape_of_const_folding.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/shape_of_const_folding.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/smart_reshape.hpp b/src/common/transformations/include/transformations/smart_reshape/smart_reshape.hpp index f8f6c021097301..55bdf523762d91 100644 --- a/src/common/transformations/include/transformations/smart_reshape/smart_reshape.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/smart_reshape.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/smart_reshape/strided_slice_squeeze.hpp b/src/common/transformations/include/transformations/smart_reshape/strided_slice_squeeze.hpp index a60b76f8a8473c..f34b6d25a27e49 100644 --- a/src/common/transformations/include/transformations/smart_reshape/strided_slice_squeeze.hpp +++ b/src/common/transformations/include/transformations/smart_reshape/strided_slice_squeeze.hpp @@ -7,7 +7,7 @@ #include #include -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/symbolic_transformations/chained_maximum.hpp b/src/common/transformations/include/transformations/symbolic_transformations/chained_maximum.hpp index 203259ecdcf7ce..c7cb03afd5ade4 100644 --- a/src/common/transformations/include/transformations/symbolic_transformations/chained_maximum.hpp +++ b/src/common/transformations/include/transformations/symbolic_transformations/chained_maximum.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/symbolic_transformations/dereshape_matmul.hpp b/src/common/transformations/include/transformations/symbolic_transformations/dereshape_matmul.hpp index 037a9cce421a11..fa1c844faa7129 100644 --- a/src/common/transformations/include/transformations/symbolic_transformations/dereshape_matmul.hpp +++ b/src/common/transformations/include/transformations/symbolic_transformations/dereshape_matmul.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/symbolic_transformations/nop_broadcast.hpp b/src/common/transformations/include/transformations/symbolic_transformations/nop_broadcast.hpp index 19d6e41f9627d1..5a12b5735ce428 100644 --- a/src/common/transformations/include/transformations/symbolic_transformations/nop_broadcast.hpp +++ b/src/common/transformations/include/transformations/symbolic_transformations/nop_broadcast.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/symbolic_transformations/reshape_optimizations.hpp b/src/common/transformations/include/transformations/symbolic_transformations/reshape_optimizations.hpp index 6ad409b4d96ad5..5d84d83bad2de5 100644 --- a/src/common/transformations/include/transformations/symbolic_transformations/reshape_optimizations.hpp +++ b/src/common/transformations/include/transformations/symbolic_transformations/reshape_optimizations.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_base.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_base.hpp index 34a2a7b83f5d9c..013799e854df8f 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_base.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_base.hpp @@ -6,8 +6,7 @@ #include -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/transpose_sinking/ts_utils.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_binary.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_binary.hpp index 5c913e3d778be8..9534380d51253e 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_binary.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_binary.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_concat.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_concat.hpp index c37cccaaac6516..cc0ccc2c194dbf 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_concat.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_concat.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_cumsum.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_cumsum.hpp index de82ce274cf32c..185bea0105ec4d 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_cumsum.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_cumsum.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_data_movement.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_data_movement.hpp index 768972af596a2e..9775e57d61146b 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_data_movement.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_data_movement.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_fuse.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_fuse.hpp index 206f3cd0af7559..974e7accc4d808 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_fuse.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_fuse.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_gather.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_gather.hpp index 188cbe6556940e..5bc7cea340cb72 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_gather.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_gather.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_interpolate.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_interpolate.hpp index 32100f40d878ea..dfdd062e1f7ce3 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_interpolate.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_interpolate.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_reduction.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_reduction.hpp index 44fd1fc534315e..a983519a3012d6 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_reduction.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_reduction.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_reset_no_sinking_attribute.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_reset_no_sinking_attribute.hpp index cab1f1841107bc..240c6e8342c069 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_reset_no_sinking_attribute.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_reset_no_sinking_attribute.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations_visibility.hpp" namespace ov { diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_slice.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_slice.hpp index 8b486609aa1f1c..5e10a7f0e8a930 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_slice.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_slice.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_squeeze.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_squeeze.hpp index 820dd3da37d8af..752e040ab52cab 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_squeeze.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_squeeze.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_unary.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_unary.hpp index 3d7694a32832f9..c8148e912b30c0 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_unary.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_unary.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/include/transformations/transpose_sinking/ts_unsqueeze.hpp b/src/common/transformations/include/transformations/transpose_sinking/ts_unsqueeze.hpp index a660b99506f1ea..1ee195624cb801 100644 --- a/src/common/transformations/include/transformations/transpose_sinking/ts_unsqueeze.hpp +++ b/src/common/transformations/include/transformations/transpose_sinking/ts_unsqueeze.hpp @@ -4,8 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" -#include "openvino/pass/pass.hpp" +#include "openvino/pass/matcher_pass.hpp" #include "transformations/transpose_sinking/ts_base.hpp" #include "transformations_visibility.hpp" diff --git a/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp index 6e44692b5f169c..60643d726ec275 100644 --- a/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp @@ -24,6 +24,7 @@ #include "openvino/op/transpose.hpp" #include "openvino/op/util/binary_elementwise_arithmetic.hpp" #include "openvino/op/util/pad_base.hpp" +#include "openvino/pass/backward_graph_rewrite.hpp" #include "openvino/pass/manager.hpp" #include "openvino/pass/pattern/op/or.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" diff --git a/src/core/include/openvino/pass/backward_graph_rewrite.hpp b/src/core/include/openvino/pass/backward_graph_rewrite.hpp new file mode 100644 index 00000000000000..7e7f6f118efe8d --- /dev/null +++ b/src/core/include/openvino/pass/backward_graph_rewrite.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include +#include +#include + +#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/pass.hpp" + +namespace ov { +namespace pass { +class OPENVINO_API BackwardGraphRewrite : public GraphRewrite { +public: + OPENVINO_RTTI("ov::pass::BackwardGraphRewrite"); + + BackwardGraphRewrite() = default; + + explicit BackwardGraphRewrite(const std::shared_ptr& pass) : GraphRewrite(pass) {} + + bool run_on_model(const std::shared_ptr& m) override; +}; +} // namespace pass +} // namespace ov diff --git a/src/core/include/openvino/pass/convert_fp32_to_fp16.hpp b/src/core/include/openvino/pass/convert_fp32_to_fp16.hpp index 61c76e3b2f974a..ae9bb25efb4a87 100644 --- a/src/core/include/openvino/pass/convert_fp32_to_fp16.hpp +++ b/src/core/include/openvino/pass/convert_fp32_to_fp16.hpp @@ -4,7 +4,7 @@ #pragma once -#include "openvino/pass/graph_rewrite.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { namespace pass { diff --git a/src/core/include/openvino/pass/graph_rewrite.hpp b/src/core/include/openvino/pass/graph_rewrite.hpp index 792393b33a1b5b..3fd801235c31a2 100644 --- a/src/core/include/openvino/pass/graph_rewrite.hpp +++ b/src/core/include/openvino/pass/graph_rewrite.hpp @@ -8,149 +8,10 @@ #include #include -#include "openvino/pass/pass.hpp" -#include "openvino/pass/pattern/matcher.hpp" +#include "openvino/pass/matcher_pass.hpp" namespace ov { -using matcher_pass_callback = std::function; -using graph_rewrite_callback = std::function; -using handler_callback = std::function& node)>; namespace pass { -/// \brief Register openvino node pointers into container. -/// Can create and/or add existing node pointers into register -class NodeRegistry { -public: - /// \brief Make new node and add it to register. - /// - /// \tparam T Node type. - /// \tparam Args Node ctor args types. - /// - /// \param args New node ctor arguments. - /// \return Shared pointer to node of type T. - template - std::shared_ptr make(Args&&... args) { - auto node = std::make_shared(std::forward(args)...); - return add(node); - } - - /// \brief Add node to register - /// - /// \tparam T Node type. - /// - /// \param node Node to add - /// - /// \return Shared pointer to new node added of type T. - template - std::shared_ptr add(const std::shared_ptr& node) { - m_nodes.push_back(node); - return node; - } - - /// \brief Get nodes container. - /// - /// \return Const reference to nodes container. - const std::vector>& get() const { - return m_nodes; - } - - /// \brief Clear register. - void clear() { - m_nodes.clear(); - } - -private: - std::vector> m_nodes; //!< Stores added nodes. -}; - -/// \brief MatcherPass is a basic block for pattern based transformations. It describes -/// pattern and -/// action that is applied if pattern is matched. -/// -/// MatcherPass consists of Matcher and matcher_pass_callback that needs to be implemented -/// and -/// finally registered by using \sa register_matcher. MatcherPass can be executed on node -/// within -/// \sa apply method. To run matcher pass on Function use GraphRewrite. -/// In addition MatcherPass provides a way for adding new operations into GraphRewrite -/// execution -/// queue. That means that operations that were created inside transformation callback can -/// be added -/// for matching. To register node use \sa register_new_node method. GraphRewrite -/// automatically -/// takes registered nodes and put them to execution queue. If multiple nodes were register -/// make -/// sure that they were registered in topological order. -/// Note: when implementing pattern for Matcher make sure that root node is an operation -/// from opset -/// or has ov::pass::pattern::op::WrapType. That will help GraphRewrite to execute matcher -/// passes more -/// efficient. -/// \ingroup ov_pass_cpp_api -class OPENVINO_API MatcherPass : public PassBase { -public: - OPENVINO_RTTI("ov::pass::MatcherPass"); - - MatcherPass() = default; - - MatcherPass(const MatcherPass&) = delete; - MatcherPass& operator=(const MatcherPass&) = delete; - - explicit MatcherPass(const std::string& name, - const std::shared_ptr& m, - const handler_callback& handler, - const PassPropertyMask& property = PassProperty::CHANGE_DYNAMIC_STATE) - : PassBase(), - m_handler(handler), - m_matcher(m) { - set_name(name); - set_property(property, true); - } - - MatcherPass(const std::shared_ptr& m, const matcher_pass_callback& callback) : PassBase() { - register_matcher(m, callback); - } - - bool apply(std::shared_ptr node); - - template - std::shared_ptr register_new_node(Args&&... args) { - return m_new_nodes.make(std::forward(args)...); - } - - template - std::shared_ptr register_new_node(const std::shared_ptr& node) { - return m_new_nodes.add(node); - } - - std::shared_ptr register_new_node_(const std::shared_ptr& node) { - return register_new_node(node); - } - - const std::vector>& get_new_nodes() { - return m_new_nodes.get(); - } - - void clear_new_nodes() { - m_new_nodes.clear(); - } - - std::shared_ptr get_matcher() { - return m_matcher; - } - -protected: - void register_matcher(const std::shared_ptr& m, - const matcher_pass_callback& callback, - const PassPropertyMask& property); - - void register_matcher(const std::shared_ptr& m, const matcher_pass_callback& callback); - -private: - handler_callback m_handler; - std::shared_ptr m_matcher; - NodeRegistry m_new_nodes; -}; - /// \brief GraphRewrite is a container for MatcherPasses that allows to run them on Function /// in /// efficient way @@ -249,12 +110,7 @@ class OPENVINO_API GraphRewrite : public ModelPass { } } - std::shared_ptr add_matcher(const std::shared_ptr& pass) { - auto pass_config = get_pass_config(); - pass->set_pass_config(pass_config); - m_matchers.push_back(pass); - return pass; - } + std::shared_ptr add_matcher(const std::shared_ptr& pass); bool run_on_model(const std::shared_ptr& m) override; @@ -267,16 +123,5 @@ class OPENVINO_API GraphRewrite : public ModelPass { std::vector> m_matchers; }; - -class OPENVINO_API BackwardGraphRewrite : public GraphRewrite { -public: - OPENVINO_RTTI("ov::pass::BackwardGraphRewrite"); - - BackwardGraphRewrite() = default; - - explicit BackwardGraphRewrite(const std::shared_ptr& pass) : GraphRewrite(pass) {} - - bool run_on_model(const std::shared_ptr& m) override; -}; } // namespace pass } // namespace ov diff --git a/src/core/include/openvino/pass/matcher_pass.hpp b/src/core/include/openvino/pass/matcher_pass.hpp new file mode 100644 index 00000000000000..b17237fdf08340 --- /dev/null +++ b/src/core/include/openvino/pass/matcher_pass.hpp @@ -0,0 +1,107 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include + +#include "openvino/pass/node_registry.hpp" + +namespace ov { +using matcher_pass_callback = std::function; +using graph_rewrite_callback = std::function; +using handler_callback = std::function& node)>; +namespace pass { +/// \brief MatcherPass is a basic block for pattern based transformations. It describes +/// pattern and +/// action that is applied if pattern is matched. +/// +/// MatcherPass consists of Matcher and matcher_pass_callback that needs to be implemented +/// and +/// finally registered by using \sa register_matcher. MatcherPass can be executed on node +/// within +/// \sa apply method. To run matcher pass on Function use GraphRewrite. +/// In addition MatcherPass provides a way for adding new operations into GraphRewrite +/// execution +/// queue. That means that operations that were created inside transformation callback can +/// be added +/// for matching. To register node use \sa register_new_node method. GraphRewrite +/// automatically +/// takes registered nodes and put them to execution queue. If multiple nodes were register +/// make +/// sure that they were registered in topological order. +/// Note: when implementing pattern for Matcher make sure that root node is an operation +/// from opset +/// or has ov::pass::pattern::op::WrapType. That will help GraphRewrite to execute matcher +/// passes more +/// efficient. +/// \ingroup ov_pass_cpp_api +class OPENVINO_API MatcherPass : public PassBase { +public: + OPENVINO_RTTI("ov::pass::MatcherPass"); + + MatcherPass() = default; + + MatcherPass(const MatcherPass&) = delete; + MatcherPass& operator=(const MatcherPass&) = delete; + + explicit MatcherPass(const std::string& name, + const std::shared_ptr& m, + const handler_callback& handler, + const PassPropertyMask& property = PassProperty::CHANGE_DYNAMIC_STATE) + : PassBase(), + m_handler(handler), + m_matcher(m) { + set_name(name); + set_property(property, true); + } + + MatcherPass(const std::shared_ptr& m, const matcher_pass_callback& callback) : PassBase() { + register_matcher(m, callback); + } + + bool apply(std::shared_ptr node); + + template + std::shared_ptr register_new_node(Args&&... args) { + return m_new_nodes.make(std::forward(args)...); + } + + template + std::shared_ptr register_new_node(const std::shared_ptr& node) { + return m_new_nodes.add(node); + } + + std::shared_ptr register_new_node_(const std::shared_ptr& node) { + return register_new_node(node); + } + + const std::vector>& get_new_nodes() { + return m_new_nodes.get(); + } + + void clear_new_nodes() { + m_new_nodes.clear(); + } + + std::shared_ptr get_matcher() { + return m_matcher; + } + +protected: + void register_matcher(const std::shared_ptr& m, + const matcher_pass_callback& callback, + const PassPropertyMask& property); + + void register_matcher(const std::shared_ptr& m, const matcher_pass_callback& callback); + +private: + handler_callback m_handler; + std::shared_ptr m_matcher; + NodeRegistry m_new_nodes; +}; +} // namespace pass +} // namespace ov diff --git a/src/core/include/openvino/pass/node_registry.hpp b/src/core/include/openvino/pass/node_registry.hpp new file mode 100644 index 00000000000000..f0cdb4b228c613 --- /dev/null +++ b/src/core/include/openvino/pass/node_registry.hpp @@ -0,0 +1,56 @@ +#pragma once + +#include +#include +#include + +#include "openvino/core/node.hpp" +#include "openvino/pass/pattern/matcher.hpp" + +namespace ov { +namespace pass { +/// \brief Register openvino node pointers into container. +/// Can create and/or add existing node pointers into register +class NodeRegistry { +public: + /// \brief Make new node and add it to register. + /// + /// \tparam T Node type. + /// \tparam Args Node ctor args types. + /// + /// \param args New node ctor arguments. + /// \return Shared pointer to node of type T. + template + std::shared_ptr make(Args&&... args) { + auto node = std::make_shared(std::forward(args)...); + return add(node); + } + + /// \brief Add node to register + /// + /// \tparam T Node type. + /// + /// \param node Node to add + /// + /// \return Shared pointer to new node added of type T. + template + std::shared_ptr add(const std::shared_ptr& node) { + m_nodes.push_back(node); + return node; + } + + /// \brief Get nodes container. + /// + /// \return Const reference to nodes container. + const std::vector>& get() const { + return m_nodes; + } + + /// \brief Clear register. + void clear(); + +private: + std::vector> m_nodes; //!< Stores added nodes. +}; +} // namespace pass +} // namespace ov diff --git a/src/core/src/pass/graph_rewrite.cpp b/src/core/src/pass/graph_rewrite.cpp index 24353a56bf746a..00eafa873043c3 100644 --- a/src/core/src/pass/graph_rewrite.cpp +++ b/src/core/src/pass/graph_rewrite.cpp @@ -14,6 +14,7 @@ #include "openvino/cc/pass/itt.hpp" #include "openvino/op/util/multi_subgraph_base.hpp" +#include "openvino/pass/backward_graph_rewrite.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "openvino/util/log.hpp" #include "perf_counters.hpp" @@ -64,6 +65,13 @@ PerfCounters& perf_counters_graph_rewrite() { } // namespace ov #endif // ENABLE_PROFILING_ITT +std::shared_ptr ov::pass::GraphRewrite::add_matcher( + const std::shared_ptr& pass) { + auto pass_config = get_pass_config(); + pass->set_pass_config(pass_config); + m_matchers.push_back(pass); + return pass; +} bool ov::pass::BackwardGraphRewrite::run_on_model(const std::shared_ptr& f) { RUN_ON_MODEL_SCOPE(BackwardGraphRewrite); diff --git a/src/core/src/pass/node_registry.cpp b/src/core/src/pass/node_registry.cpp new file mode 100644 index 00000000000000..67b719a3b4c5e5 --- /dev/null +++ b/src/core/src/pass/node_registry.cpp @@ -0,0 +1,9 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "openvino/pass/node_registry.hpp" + +void ov::pass::NodeRegistry::clear() { + m_nodes.clear(); +} diff --git a/src/core/tests/graph_rewrite.cpp b/src/core/tests/graph_rewrite.cpp index 02369738741dcc..3043e851aaf1d9 100644 --- a/src/core/tests/graph_rewrite.cpp +++ b/src/core/tests/graph_rewrite.cpp @@ -2,8 +2,6 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "openvino/pass/graph_rewrite.hpp" - #include #include "common_test_utils/ov_test_utils.hpp" @@ -14,6 +12,7 @@ #include "openvino/op/relu.hpp" #include "openvino/op/result.hpp" #include "openvino/op/tanh.hpp" +#include "openvino/pass/backward_graph_rewrite.hpp" #include "openvino/pass/manager.hpp" #include "openvino/pass/pattern/op/label.hpp" From 43b23c3cf757ebff35babd729632253dcab4b8bd Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Fri, 23 Aug 2024 21:11:58 +0400 Subject: [PATCH 112/117] [TF FE] Switch on SparseTensorDenseAdd test on GPU (#26207) **Details:** Switch on SparseTensorDenseAdd test on GPU. It was fixed since downgrading transformation for ScatterNDUpdate was merged https://github.com/openvinotoolkit/openvino/pull/26113 **Ticket:** TBD Signed-off-by: Kazantsev, Roman --- .../tensorflow_tests/test_tf_SparseTensorDenseAdd.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py index 704f7bd81729d8..729f79f0a1164c 100644 --- a/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py +++ b/tests/layer_tests/tensorflow_tests/test_tf_SparseTensorDenseAdd.py @@ -78,8 +78,6 @@ def test_sparse_tensor_dense_add(self, data_type, indices_type, a_shape, b_shape, nnz, ie_device, precision, ir_version, temp_dir, use_legacy_frontend): - if ie_device == 'GPU': - pytest.skip("149830: ScatterNDUpdate-15 is not supported on GPU") self._test(*self.create_sparse_tensor_dense_add_net(data_type, indices_type, a_shape, b_shape, nnz), ie_device, precision, ir_version, temp_dir=temp_dir, From 7a8ae558eb54834766cf598623f726886c7ad51b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hubert=20B=C5=82aszczyk?= <56601011+hub-bla@users.noreply.github.com> Date: Fri, 23 Aug 2024 19:28:00 +0200 Subject: [PATCH 113/117] [TF FE]: Support TensorScatterUpdate operation for TensorFlow (#26168) ### Details: - Support `TensorScatterUpdate` operation ### Tickets: - [None](https://github.com/openvinotoolkit/openvino/issues/23247) --------- Co-authored-by: Roman Kazantsev --- .../tensorflow/docs/supported_ops.md | 2 +- src/frontends/tensorflow/src/op_table.cpp | 1 + .../include/common_op_table.hpp | 1 + .../src/op/tensor_scatter_update.cpp | 29 ++++++ .../test_tf_TensorScatterUpdate.py | 89 +++++++++++++++++++ 5 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 src/frontends/tensorflow_common/src/op/tensor_scatter_update.cpp create mode 100644 tests/layer_tests/tensorflow_tests/test_tf_TensorScatterUpdate.py diff --git a/src/frontends/tensorflow/docs/supported_ops.md b/src/frontends/tensorflow/docs/supported_ops.md index 0eed3eab516c70..1affaa2640cbea 100644 --- a/src/frontends/tensorflow/docs/supported_ops.md +++ b/src/frontends/tensorflow/docs/supported_ops.md @@ -1318,7 +1318,7 @@ A "supported operation" is one that TensorFlow Frontend can convert to the OpenV | TensorScatterMax | NO | | | TensorScatterMin | NO | | | TensorScatterSub | NO | | -| TensorScatterUpdate | NO | | +| TensorScatterUpdate | YES | | | TensorSliceDataset | NO | | | TensorStridedSliceUpdate | NO | | | TensorSummary | NO | | diff --git a/src/frontends/tensorflow/src/op_table.cpp b/src/frontends/tensorflow/src/op_table.cpp index 76fc33c123915f..aa188d81808614 100644 --- a/src/frontends/tensorflow/src/op_table.cpp +++ b/src/frontends/tensorflow/src/op_table.cpp @@ -414,6 +414,7 @@ const std::map get_supported_ops() { {"TensorListReserve", CreatorFunction(translate_tensor_list_reserve_op)}, {"TensorListResize", CreatorFunction(translate_tensor_list_resize_op)}, {"TensorListConcatV2", CreatorFunction(translate_tensor_list_concat_v2_op)}, + {"TensorScatterUpdate", CreatorFunction(translate_tensor_scatter_update_op)}, {"Tile", CreatorFunction(translate_tile_op)}, {"ToBool", CreatorFunction(translate_tobool_op)}, {"TopK", CreatorFunction(translate_top_k_op)}, diff --git a/src/frontends/tensorflow_common/include/common_op_table.hpp b/src/frontends/tensorflow_common/include/common_op_table.hpp index dfc27f1c6ecc68..e01d2dcc6f789a 100644 --- a/src/frontends/tensorflow_common/include/common_op_table.hpp +++ b/src/frontends/tensorflow_common/include/common_op_table.hpp @@ -173,6 +173,7 @@ OP_CONVERTER(translate_tensor_list_set_item_op); OP_CONVERTER(translate_tensor_list_stack_op); OP_CONVERTER(translate_tensor_list_resize_op); OP_CONVERTER(translate_tensor_list_concat_v2_op); +OP_CONVERTER(translate_tensor_scatter_update_op); OP_CONVERTER(translate_tile_op); OP_CONVERTER(translate_tobool_op); OP_CONVERTER_NAMED(translate_top_k_op); diff --git a/src/frontends/tensorflow_common/src/op/tensor_scatter_update.cpp b/src/frontends/tensorflow_common/src/op/tensor_scatter_update.cpp new file mode 100644 index 00000000000000..732d944e7312f0 --- /dev/null +++ b/src/frontends/tensorflow_common/src/op/tensor_scatter_update.cpp @@ -0,0 +1,29 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "common_op_table.hpp" +#include "openvino/op/scatter_nd_update.hpp" +#include "utils.hpp" + +using namespace std; +using namespace ov::op; + +namespace ov { +namespace frontend { +namespace tensorflow { +namespace op { +OutputVector translate_tensor_scatter_update_op(const NodeContext& node) { + default_op_checks(node, 3, {"TensorScatterUpdate"}); + auto tensor = node.get_input(0); + auto indices = node.get_input(1); + auto updates = node.get_input(2); + + auto scatter_nd = make_shared(tensor, indices, updates); + set_node_name(node.get_name(), scatter_nd); + return {scatter_nd}; +} +} // namespace op +} // namespace tensorflow +} // namespace frontend +} // namespace ov diff --git a/tests/layer_tests/tensorflow_tests/test_tf_TensorScatterUpdate.py b/tests/layer_tests/tensorflow_tests/test_tf_TensorScatterUpdate.py new file mode 100644 index 00000000000000..91f8b14c31e734 --- /dev/null +++ b/tests/layer_tests/tensorflow_tests/test_tf_TensorScatterUpdate.py @@ -0,0 +1,89 @@ +# Copyright (C) 2018-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import platform +import pytest +import tensorflow as tf +from common.tf_layer_test_class import CommonTFLayerTest + +rng = np.random.default_rng(872173) + + +class TestTensorScatterUpdate(CommonTFLayerTest): + def _prepare_input(self, inputs_info): + assert 'tensor:0' in inputs_info + assert 'indices:0' in inputs_info + assert 'updates:0' in inputs_info + + tensor_shape = inputs_info['tensor:0'] + updates_shape = inputs_info['updates:0'] + indices_shape = inputs_info['indices:0'] + + inputs_data = {} + if np.issubdtype(self.data_type, np.floating): + inputs_data['tensor:0'] = rng.uniform(-5.0, 5.0, tensor_shape).astype(self.data_type) + inputs_data['updates:0'] = rng.uniform(-5.0, 5.0, updates_shape).astype(self.data_type) + elif np.issubdtype(self.data_type, np.signedinteger): + inputs_data['tensor:0'] = rng.integers(-8, 8, tensor_shape).astype(self.data_type) + inputs_data['updates:0'] = rng.integers(-8, 8, updates_shape).astype(self.data_type) + else: + inputs_data['tensor:0'] = rng.integers(0, 8, tensor_shape).astype(self.data_type) + inputs_data['updates:0'] = rng.integers(0, 8, updates_shape).astype(self.data_type) + + indices_rows, indices_col = indices_shape + + indices_of_tensor_shape = [] + for i in range(0, indices_col): + indices_of_tensor_shape.append(np.arange(tensor_shape[i])) + + mesh = np.meshgrid(*indices_of_tensor_shape) + + all_indicies = np.stack(mesh, axis=indices_col) + all_indicies = all_indicies.reshape(-1, all_indicies.shape[-1]) + + inputs_data['indices:0'] = rng.choice(all_indicies, indices_rows, replace=False).astype(self.indices_type) + + return inputs_data + + def create_tensor_scatter_update_net(self, data_type, indices_type, + tensor_shape, updates_shape, indices_shape): + self.data_type = data_type + self.indices_type = indices_type + self.tensor_shape = tensor_shape + self.updates_shape = updates_shape + self.indices_shape = indices_shape + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + indices = tf.compat.v1.placeholder(indices_type, indices_shape, 'indices') + tensor = tf.compat.v1.placeholder(data_type, tensor_shape, 'tensor') + updates = tf.compat.v1.placeholder(data_type, updates_shape, 'updates') + tf.raw_ops.TensorScatterUpdate( + tensor=tensor, + indices=indices, + updates=updates) + tf.compat.v1.global_variables_initializer() + tf_net = sess.graph_def + + ref_net = None + + return tf_net, ref_net + + @pytest.mark.parametrize('data_type', [np.float32, np.float64, np.int32]) + @pytest.mark.parametrize('indices_type', [np.int32, np.int64]) + @pytest.mark.parametrize('tensor_shape, updates_shape, indices_shape', [ + [[10, 5], [2], [2, 2]], + [[4, 4, 4], [2, 4, 4], [2, 1]], + [[2, 4, 8], [3], [3, 3]], + [[4, 3, 5], [1, 5], [1, 2]], + ]) + @pytest.mark.precommit + @pytest.mark.nightly + def test_sparse_tensor_dense_add(self, data_type, indices_type, + tensor_shape, updates_shape, indices_shape, + ie_device, precision, ir_version, temp_dir, + use_legacy_frontend): + self._test(*self.create_tensor_scatter_update_net(data_type, indices_type, + tensor_shape, updates_shape, indices_shape), + ie_device, precision, ir_version, temp_dir=temp_dir, + use_legacy_frontend=use_legacy_frontend) From 79c966b08478be453d6efd42da52cab44b8f46f1 Mon Sep 17 00:00:00 2001 From: Roman Kazantsev Date: Fri, 23 Aug 2024 23:56:42 +0400 Subject: [PATCH 114/117] [TF FE] Stabilize binary comparison ops (Equal, NonEqual, Less, etc.) tests on all platforms (#26205) **Details:** Stabilize binary comparison ops (Equal, NonEqual, Less, etc.) tests on all platforms **Ticket:** 145795 --------- Signed-off-by: Kazantsev, Roman --- .../test_tf_BinaryComparison.py | 96 +++++++++++++++++++ .../tensorflow_tests/test_tf_BinaryOps.py | 13 +-- 2 files changed, 98 insertions(+), 11 deletions(-) create mode 100644 tests/layer_tests/tensorflow_tests/test_tf_BinaryComparison.py diff --git a/tests/layer_tests/tensorflow_tests/test_tf_BinaryComparison.py b/tests/layer_tests/tensorflow_tests/test_tf_BinaryComparison.py new file mode 100644 index 00000000000000..41e0accb5e350d --- /dev/null +++ b/tests/layer_tests/tensorflow_tests/test_tf_BinaryComparison.py @@ -0,0 +1,96 @@ +# Copyright (C) 2018-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import pytest +import tensorflow as tf +from common.tf_layer_test_class import CommonTFLayerTest +from common.utils.tf_utils import mix_array_with_several_values + +rng = np.random.default_rng(23356) + + +class TestBinaryComparison(CommonTFLayerTest): + def _generate_value(self, input_shape, input_type): + if np.issubdtype(input_type, np.floating): + gen_value = rng.uniform(-5.0, 5.0, input_shape).astype(input_type) + elif np.issubdtype(input_type, np.signedinteger): + gen_value = rng.integers(-8, 8, input_shape).astype(input_type) + else: + gen_value = rng.integers(8, 16, input_shape).astype(input_type) + return gen_value + + def _prepare_input(self, inputs_info): + assert 'x:0' in inputs_info, "Test error: inputs_info must contain `x`" + x_shape = inputs_info['x:0'] + input_type = self.input_type + + inputs_data = {} + y_value = None + if self.is_const: + y_value = self.y_value + y_shape = y_value.shape + else: + assert 'y:0' in inputs_info, "Test error: inputs_info must contain `y`" + y_shape = inputs_info['y:0'] + y_value = self._generate_value(y_shape, input_type) + inputs_data['y:0'] = y_value + + # generate x value so that some elements will be equal, less, greater than y value element-wise + squeeze_dims = 0 if len(y_shape) <= len(x_shape) else len(y_shape) - len(x_shape) + zeros_list = [0] * squeeze_dims + y_value = y_value[tuple(zeros_list)] + y_value_minus_one = y_value - 1 + y_value_plus_one = y_value + 1 + + x_value = self._generate_value(x_shape, input_type) + # mix input data with preferable values + x_value = mix_array_with_several_values(x_value, [y_value, y_value_plus_one, y_value_minus_one], rng) + inputs_data['x:0'] = x_value + + return inputs_data + + def create_binary_comparison_net(self, input_shape1, input_shape2, binary_op, is_const, input_type): + compare_ops_map = { + 'Equal': tf.raw_ops.Equal, + 'NotEqual': tf.raw_ops.NotEqual, + 'Greater': tf.raw_ops.Greater, + 'GreaterEqual': tf.raw_ops.GreaterEqual, + 'Less': tf.raw_ops.Less, + 'LessEqual': tf.raw_ops.LessEqual, + } + + self.input_type = input_type + self.is_const = is_const + tf.compat.v1.reset_default_graph() + # Create the graph and model + with tf.compat.v1.Session() as sess: + x = tf.compat.v1.placeholder(input_type, input_shape1, 'x') + y = tf.compat.v1.placeholder(input_type, input_shape2, 'y') + if is_const: + self.y_value = self._generate_value(input_shape2, input_type) + y = tf.constant(self.y_value, dtype=input_type) + compare_ops_map[binary_op](x=x, y=y) + tf.compat.v1.global_variables_initializer() + + tf_net = sess.graph_def + + return tf_net, None + + @pytest.mark.parametrize('input_shape1', [[], [4], [3, 4], [2, 3, 4]]) + @pytest.mark.parametrize('input_shape2', [[4], [3, 4]]) + @pytest.mark.parametrize('binary_op', ['Equal', 'NotEqual', 'Greater', 'GreaterEqual', 'Less', 'LessEqual']) + @pytest.mark.parametrize('is_const', [False, True]) + @pytest.mark.parametrize('input_type', [np.int8, np.uint8, np.int16, + np.int32, np.int64, + np.float16, np.float32, np.float64]) + @pytest.mark.precommit + @pytest.mark.nightly + def test_binary_comparison(self, input_shape1, input_shape2, binary_op, is_const, input_type, + ie_device, precision, ir_version, temp_dir, + use_legacy_frontend): + if ie_device == 'GPU' and input_type == np.int16 and is_const: + pytest.skip('150501: Accuracy error on GPU for int16 type and constant operand') + self._test(*self.create_binary_comparison_net(input_shape1, input_shape2, binary_op, is_const, input_type), + ie_device, precision, ir_version, temp_dir=temp_dir, + use_legacy_frontend=use_legacy_frontend) diff --git a/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py b/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py index 8d15eb5ca3a49e..4de252e40442c4 100644 --- a/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py +++ b/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py @@ -53,13 +53,7 @@ def create_add_placeholder_const_net(self, x_shape, y_shape, op_type): 'Pow': tf.raw_ops.Pow, 'Maximum': tf.raw_ops.Maximum, 'Minimum': tf.raw_ops.Minimum, - 'Equal': tf.raw_ops.Equal, - 'NotEqual': tf.raw_ops.NotEqual, 'Mod': tf.raw_ops.Mod, - 'Greater': tf.raw_ops.Greater, - 'GreaterEqual': tf.raw_ops.GreaterEqual, - 'Less': tf.raw_ops.Less, - 'LessEqual': tf.raw_ops.LessEqual, 'LogicalAnd': tf.raw_ops.LogicalAnd, 'LogicalOr': tf.raw_ops.LogicalOr, 'FloorMod': tf.raw_ops.FloorMod, @@ -95,8 +89,8 @@ def create_add_placeholder_const_net(self, x_shape, y_shape, op_type): @pytest.mark.parametrize('y_shape', [[4], [2, 3, 4]]) @pytest.mark.parametrize("op_type", ['Add', 'AddV2', 'Sub', 'Mul', 'Div', 'RealDiv', 'SquaredDifference', 'Pow', - 'Maximum', 'Minimum', 'Equal', 'NotEqual', 'Mod', 'Greater', 'GreaterEqual', 'Less', - 'LessEqual', 'LogicalAnd', 'LogicalOr', 'FloorMod', 'FloorDiv', 'Xdivy']) + 'Maximum', 'Minimum', 'Mod', 'LogicalAnd', 'LogicalOr', 'FloorMod', + 'FloorDiv', 'Xdivy']) @pytest.mark.nightly @pytest.mark.precommit @pytest.mark.xfail(condition=platform.system() == 'Darwin' and platform.machine() == 'arm64', @@ -109,8 +103,5 @@ def test_binary_op(self, x_shape, y_shape, ie_device, precision, ir_version, tem pytest.skip("For Mod and Pow GPU has inference mismatch") if op_type in ['Mod', 'FloorDiv', 'FloorMod']: pytest.skip("Inference mismatch for Mod and FloorDiv") - if ie_device == 'GPU' and precision == 'FP16' and op_type in ['Equal', 'NotEqual', 'Greater', 'GreaterEqual', - 'Less', 'LessEqual']: - pytest.skip("Accuracy mismatch on GPU") self._test(*self.create_add_placeholder_const_net(x_shape=x_shape, y_shape=y_shape, op_type=op_type), ie_device, precision, ir_version, temp_dir=temp_dir, use_legacy_frontend=use_legacy_frontend) From 66a02feefaa519c7ad4015bb7427a1614b8c860f Mon Sep 17 00:00:00 2001 From: c8ef Date: Sun, 25 Aug 2024 05:36:46 +0800 Subject: [PATCH 115/117] [chore] fix some simple typos (#26097) Co-authored-by: River Li --- .github/workflows/job_onnx_models_tests.yml | 2 +- src/plugins/auto/src/compiled_model.cpp | 2 +- .../auto_batch/tests/unit/plugin_compile_model_test.cpp | 2 +- .../tests/unit/test_cases/concatenation_gpu_test.cpp | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/job_onnx_models_tests.yml b/.github/workflows/job_onnx_models_tests.yml index 19bf3b23482b89..5cf311d52e193b 100644 --- a/.github/workflows/job_onnx_models_tests.yml +++ b/.github/workflows/job_onnx_models_tests.yml @@ -95,7 +95,7 @@ jobs: - name: Install Python tests dependencies run: | # To enable pytest parallel features - python3 -m pip install pytest-xdist[psutil] pytest-forked + python3 -m pip install pytest-xdist[psutil] pytest-forked pytest-randomly - name: ONNX Models Tests run: python3 -m pytest --backend="CPU" --model_zoo_dir="${MODELS_SHARE_PATH}" ${INSTALL_TEST_DIR}/onnx/tests/tests_python/test_zoo_models.py -v -n auto --forked -k 'not _cuda' --model_zoo_xfail diff --git a/src/plugins/auto/src/compiled_model.cpp b/src/plugins/auto/src/compiled_model.cpp index d4d781e635a9a3..d0e4a47bb8f273 100644 --- a/src/plugins/auto/src/compiled_model.cpp +++ b/src/plugins/auto/src/compiled_model.cpp @@ -63,7 +63,7 @@ ov::AnyMap ov::auto_plugin::CompiledModel::get_device_supported_properties(AutoC OPENVINO_ASSERT(context.m_compiled_model); auto device_supported_properties = context.m_compiled_model->get_property(ov::supported_properties.name()); for (auto&& property_name : device_supported_properties.as>()) { - // for lto issue, explictly do the conversion here + // For LTO issue, explicitly do the conversion here std::string query_name = property_name; device_properties[property_name] = context.m_compiled_model->get_property(query_name); } diff --git a/src/plugins/auto_batch/tests/unit/plugin_compile_model_test.cpp b/src/plugins/auto_batch/tests/unit/plugin_compile_model_test.cpp index 9569a9adb19f48..639da2fddde048 100644 --- a/src/plugins/auto_batch/tests/unit/plugin_compile_model_test.cpp +++ b/src/plugins/auto_batch/tests/unit/plugin_compile_model_test.cpp @@ -130,7 +130,7 @@ TEST_P(PluginCompileModelTest, PluginCompileModelBatchedModelWithRemoteContextTe } const std::vector plugin_compile_model_param_test = { - // Case 1: explict apply batch size by config of AUTO_BATCH_DEVICE_CONFIG + // Case 1: explicitly apply batch size by config of AUTO_BATCH_DEVICE_CONFIG plugin_compile_model_param{{{ov::hint::performance_mode.name(), ov::hint::PerformanceMode::THROUGHPUT}, {ov::optimal_batch_size.name(), static_cast(16)}, {ov::hint::num_requests(12)}, diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/concatenation_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/concatenation_gpu_test.cpp index 6f2ec418adac7f..6fc3b6287f918e 100644 --- a/src/plugins/intel_gpu/tests/unit/test_cases/concatenation_gpu_test.cpp +++ b/src/plugins/intel_gpu/tests/unit/test_cases/concatenation_gpu_test.cpp @@ -1620,7 +1620,7 @@ INSTANTIATE_TEST_SUITE_P(smoke, concat_gpu::PrintToStringParamName); template -struct concat_gpu_4d_explict : public concat_gpu { +struct concat_gpu_4d_explicit : public concat_gpu { public: cldnn::memory::ptr run_concat_network(std::vector>>>> input, format::type fmt, ExecutionConfig config) { auto data_type = ov::element::from(); @@ -1757,7 +1757,7 @@ struct concat_gpu_4d_explict : public concat_gpu { }; -using concat_no_implicit_gpu_onednn_4d_f16 = concat_gpu_4d_explict; +using concat_no_implicit_gpu_onednn_4d_f16 = concat_gpu_4d_explicit; TEST_P(concat_no_implicit_gpu_onednn_4d_f16, input_order_opt_b_fs_yx_fsv16) { ASSERT_NO_FATAL_FAILURE(test(format::b_fs_yx_fsv16)); From 13650e9da66b1bb72e018a8b3b0c02ee305b36cc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 25 Aug 2024 12:28:11 +0200 Subject: [PATCH 116/117] Bump micromatch from 4.0.5 to 4.0.8 in /src/bindings/js/node (#26216) Bumps [micromatch](https://github.com/micromatch/micromatch) from 4.0.5 to 4.0.8.

Changelog

Sourced from micromatch's changelog.

[4.0.8] - 2024-08-22

  • backported CVE-2024-4067 fix (from v4.0.6) over to 4.x branch

[4.0.7] - 2024-05-22

  • this is basically v4.0.5, with some README updates
  • it is vulnerable to CVE-2024-4067
  • Updated braces to v3.0.3 to avoid CVE-2024-4068
  • does NOT break API compatibility

[4.0.6] - 2024-05-21

  • Added hasBraces to check if a pattern contains braces.
  • Fixes CVE-2024-4067
  • BREAKS API COMPATIBILITY
  • Should be labeled as a major release, but it's not.
Commits
  • 8bd704e 4.0.8
  • a0e6841 run verb to generate README documentation
  • 4ec2884 Merge branch 'v4' into hauserkristof-feature/v4.0.8
  • 03aa805 Merge pull request #266 from hauserkristof/feature/v4.0.8
  • 814f5f7 lint
  • 67fcce6 fix: CHANGELOG about braces & CVE-2024-4068, v4.0.5
  • 113f2e3 fix: CVE numbers in CHANGELOG
  • d9dbd9a feat: updated CHANGELOG
  • 2ab1315 fix: use actions/setup-node@v4
  • 1406ea3 feat: rework test to work on macos with node 10,12 and 14
  • Additional commits viewable in compare view

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=micromatch&package-manager=npm_and_yarn&previous-version=4.0.5&new-version=4.0.8)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/openvinotoolkit/openvino/network/alerts).
Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- src/bindings/js/node/package-lock.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/bindings/js/node/package-lock.json b/src/bindings/js/node/package-lock.json index ce4f932455c933..89c00b035fa5a9 100644 --- a/src/bindings/js/node/package-lock.json +++ b/src/bindings/js/node/package-lock.json @@ -1456,12 +1456,12 @@ } }, "node_modules/micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "dev": true, "dependencies": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" }, "engines": { From db44fb636307a2e2717b718dc145fb92d156ca5c Mon Sep 17 00:00:00 2001 From: Yuan Hu Date: Mon, 26 Aug 2024 10:48:28 +0800 Subject: [PATCH 117/117] [CPU]fix offset in store emitter issue (#26083) ### Details: - *offset in store emitter is offset of dst gpr register, and should parse together with reg_dst* ### Tickets: - *CVS-149693* --------- Signed-off-by: HU Yuan2 --- .../emitters/plugin/x64/jit_load_store_emitters.cpp | 4 +++- .../emitters/plugin/x64/jit_load_store_emitters.hpp | 4 ++++ .../src/emitters/snippets/x64/jit_memory_emitters.cpp | 2 +- src/plugins/intel_cpu/src/nodes/interaction.cpp | 2 +- .../intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp | 2 +- src/plugins/intel_cpu/src/nodes/mha.cpp | 6 +++--- src/plugins/intel_cpu/src/nodes/roi_align.cpp | 4 ++-- src/plugins/intel_cpu/src/nodes/roi_pooling.cpp | 11 +++++++---- src/plugins/intel_cpu/src/nodes/topk.cpp | 4 ++-- 9 files changed, 24 insertions(+), 15 deletions(-) diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp index dd764c66348d44..893c18768a9511 100644 --- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp +++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp @@ -110,6 +110,7 @@ size_t jit_load_emitter::aux_gprs_count() const { } void jit_load_emitter::emit_impl(const std::vector &in_idxs, const std::vector &out_idxs) const { + // offset in load emitter is the offset of src gpr register, should be parsed from in_idxs. const int offset = in_idxs.size() == 2 ? in_idxs[1] : 0; if (host_isa_ == cpu::x64::sse41) { emit_isa(Reg64(in_idxs[0]), static_cast(out_idxs[0]), offset); @@ -676,7 +677,8 @@ void jit_store_emitter::emit_data() const { } void jit_store_emitter::emit_impl(const std::vector &in_idxs, const std::vector &out_idxs) const { - const int offset = in_idxs.size() == 2 ? in_idxs[1] : 0; + // offset in store emitter is the offset of dst gpr register, should be parsed from out_idxs. + const int offset = out_idxs.size() == 2 ? out_idxs[1] : 0; if (host_isa_ == cpu::x64::sse41) { emit_isa(static_cast(in_idxs[0]), Reg64(out_idxs[0]), offset); } else if (host_isa_ == cpu::x64::avx2) { diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp index 6bf3cc589702a6..9570a836aa64ee 100644 --- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp +++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp @@ -66,6 +66,8 @@ class jit_load_emitter : public jit_emitter { * \|/ * dst_prc */ + + // offset in load emitter is the offset of src gpr register, should be parsed from in_idxs. void emit_impl(const std::vector &in_idxs, const std::vector &out_idxs) const override; size_t get_inputs_num() const override; @@ -123,6 +125,8 @@ class jit_store_emitter : public jit_emitter { * dst_prc * note: FP32/I32-->BF16(x*) is supported only on at least avx512-core plateform */ + + // offset in store emitter is the offset of dst gpr register, should be parsed from out_idxs. void emit_impl(const std::vector &in_idxs, const std::vector &out_idxs) const override; size_t get_inputs_num() const override; diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp index 52a77f4feced2c..9ffa574b7fe877 100644 --- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp +++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp @@ -183,7 +183,7 @@ jit_store_memory_emitter::jit_store_memory_emitter(jit_generator* h, cpu_isa_t i void jit_store_memory_emitter::emit_impl(const std::vector& in, const std::vector& out) const { OV_CPU_JIT_EMITTER_ASSERT(store_emitter, "Store CPU emitter isn't initialized!"); - store_emitter->emit_code({in[0], compiled_byte_offset}, {out[0]}, aux_vec_idxs, get_available_aux_gprs()); + store_emitter->emit_code({in[0]}, {out[0], compiled_byte_offset}, aux_vec_idxs, get_available_aux_gprs()); } void jit_store_memory_emitter::emit_data() const { diff --git a/src/plugins/intel_cpu/src/nodes/interaction.cpp b/src/plugins/intel_cpu/src/nodes/interaction.cpp index b089a0493a8b62..6f604f4a9e278a 100644 --- a/src/plugins/intel_cpu/src/nodes/interaction.cpp +++ b/src/plugins/intel_cpu/src/nodes/interaction.cpp @@ -136,7 +136,7 @@ struct jit_move_scale_kernel : public jit_uni_move_scale_kernel, public jit_gene emitters[seed].reset(new jit_store_emitter(this, isa, src_prc, dst_prc, elt_num)); } - emitters[seed]->emit_code({static_cast(vmm_src.getIdx()), 0}, {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_src.getIdx())}, {static_cast(reg_dst.getIdx())}, pool_aux_vmm_idxs, pool_aux_gpr_idxs); } diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp index 4f279af3395db6..4115dd27126089 100644 --- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp +++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp @@ -201,7 +201,7 @@ void jit_rotary_kernel::store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_s if (!emitters[seed]) { emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num)); } - emitters[seed]->emit_code({static_cast(vmm_src.getIdx()), offset}, {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_src.getIdx())}, {static_cast(reg_dst.getIdx()), offset}, pool_aux_vmm_idxs, pool_aux_gpr_idxs); } diff --git a/src/plugins/intel_cpu/src/nodes/mha.cpp b/src/plugins/intel_cpu/src/nodes/mha.cpp index 0a7fb66fc8897b..7d082e99fa4f6a 100644 --- a/src/plugins/intel_cpu/src/nodes/mha.cpp +++ b/src/plugins/intel_cpu/src/nodes/mha.cpp @@ -298,7 +298,7 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num)); } - emitters[seed]->emit_code({static_cast(vmm_src.getIdx()), 0}, {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_src.getIdx())}, {static_cast(reg_dst.getIdx())}, pool_aux_vmm_idxs, pool_aux_gpr_idxs); } @@ -480,7 +480,7 @@ struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, publi emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num)); } - emitters[seed]->emit_code({static_cast(vmm_src.getIdx()), 0}, {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_src.getIdx())}, {static_cast(reg_dst.getIdx())}, pool_aux_vmm_idxs, pool_aux_gpr_idxs); } @@ -639,7 +639,7 @@ struct jit_convert_transpose_kernel : public jit_uni_convert_transpose_kernel, p emitters[seed].reset(new jit_store_emitter(this, isa, src_prc, dst_prc, elt_num)); } - emitters[seed]->emit_code({static_cast(vmm_src.getIdx()), 0}, {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_src.getIdx())}, {static_cast(reg_dst.getIdx())}, pool_aux_vmm_idxs, pool_aux_gpr_idxs); } diff --git a/src/plugins/intel_cpu/src/nodes/roi_align.cpp b/src/plugins/intel_cpu/src/nodes/roi_align.cpp index 61bedf62811fa4..3bc988784aa563 100644 --- a/src/plugins/intel_cpu/src/nodes/roi_align.cpp +++ b/src/plugins/intel_cpu/src/nodes/roi_align.cpp @@ -197,8 +197,8 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji std::vector local_store_pool_vec_idxs = { static_cast(vmm_dst.getIdx()) }; local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(), store_pool_vec_idxs.begin(), store_pool_vec_idxs.end()); - emitters[seed]->emit_code({static_cast(vmm_dst.getIdx()), static_cast(offset)}, - {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_dst.getIdx())}, + {static_cast(reg_dst.getIdx()), static_cast(offset)}, {local_store_pool_vec_idxs}, {store_pool_gpr_idxs}); } diff --git a/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp b/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp index f1a4291f0803a3..1b05dc3673325f 100644 --- a/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp +++ b/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp @@ -213,7 +213,8 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi for (int i = 0; i < c_blocks; i++) { Vmm vmm_dst = get_acc_reg(i); - store_emitter->emit_code({static_cast(vmm_dst.getIdx()), static_cast(i * dst_c_off)}, {static_cast(reg_output.getIdx())}, + store_emitter->emit_code({static_cast(vmm_dst.getIdx())}, + {static_cast(reg_output.getIdx()), static_cast(i * dst_c_off)}, get_local_store_pool_vec_idxs(vmm_dst), store_pool_gpr_idxs); } } @@ -260,7 +261,8 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi const int dst_c_off = i * jpp_.oh * jpp_.ow * jpp_.c_block * jpp_.dst_prc.size(); - store_emitter->emit_code({static_cast(vmm_src11.getIdx()), static_cast(dst_c_off)}, {static_cast(reg_output.getIdx())}, + store_emitter->emit_code({static_cast(vmm_src11.getIdx())}, + {static_cast(reg_output.getIdx()), static_cast(dst_c_off)}, get_local_store_pool_vec_idxs(vmm_src11), store_pool_gpr_idxs); } } @@ -270,8 +272,9 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi const int dst_c_off = jpp_.oh * jpp_.ow * jpp_.c_block * jpp_.dst_prc.size(); for (int i = 0; i < c_blocks; i++) { - store_empty_roi_emitter->emit_code({static_cast(vmm_zero.getIdx()), static_cast(i * dst_c_off)}, - {static_cast(reg_output.getIdx())}, store_pool_vec_idxs, store_pool_gpr_idxs); + store_empty_roi_emitter->emit_code({static_cast(vmm_zero.getIdx())}, + {static_cast(reg_output.getIdx()), static_cast(i * dst_c_off)}, + store_pool_vec_idxs, store_pool_gpr_idxs); } } diff --git a/src/plugins/intel_cpu/src/nodes/topk.cpp b/src/plugins/intel_cpu/src/nodes/topk.cpp index be8ac05d85b3e6..fc2d13adfc0df0 100644 --- a/src/plugins/intel_cpu/src/nodes/topk.cpp +++ b/src/plugins/intel_cpu/src/nodes/topk.cpp @@ -260,8 +260,8 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato std::vector local_store_pool_vec_idxs = { static_cast(vmm_dst.getIdx()) }; local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(), store_pool_vec_idxs.begin(), store_pool_vec_idxs.end()); - emitters[seed]->emit_code({static_cast(vmm_dst.getIdx()), static_cast(offset)}, - {static_cast(reg_dst.getIdx())}, + emitters[seed]->emit_code({static_cast(vmm_dst.getIdx())}, + {static_cast(reg_dst.getIdx()), static_cast(offset)}, {local_store_pool_vec_idxs}, {store_pool_gpr_idxs}); }