Simplify code

Signed-off-by: Maxim Vafin <maxim.vafin@intel.com>

Author: mvafin

src/frontends/common/include/openvino/frontend/unconverted_ops_report.hpp

@@ -13,6 +13,13 @@
 #include <vector>
 
 #include "openvino/frontend/visibility.hpp"
+namespace ov {
+namespace op {
+namespace util {
+class FrameworkNodeAttrs;
+}  // namespace util
+}  // namespace op
+}  // namespace ov
 
 namespace ov {
 class Model;
@@ -36,6 +43,12 @@ FRONTEND_API std::string format_unconverted_ops_report(const UnconvertedOpMap& u
                                                        const std::string& additional_error = std::string{},
                                                        const std::string& header = "Model wasn't fully converted.");
 
+FRONTEND_API FrameworkNodeErrorInfo
+build_framework_node_error_info(const ov::op::util::FrameworkNodeAttrs& attrs,
+                                const std::string& op_type_attr_key = std::string{},
+                                const std::string& failure_attr_key = std::string{},
+                                const std::string& version_attr_key = std::string{});
+
 template <class TNode, class Callback>
 UnconvertedOpExtractor make_unconverted_op_extractor(Callback&& callback) {
     return [cb = std::forward<Callback>(callback)](

src/frontends/common/src/unconverted_ops_report.cpp

@@ -6,7 +6,6 @@
 
 #include <sstream>
 
-#include "openvino/core/graph_util.hpp"
 #include "openvino/core/model.hpp"
 #include "openvino/core/node.hpp"
 #include "openvino/op/util/framework_node.hpp"
@@ -16,17 +15,11 @@ namespace ov {
 namespace frontend {
 namespace {
 
-struct CollectorContext {
-    const std::vector<UnconvertedOpExtractor>& extractors;
-    UnconvertedOpMap& report;
-};
-
 std::optional<FrameworkNodeErrorInfo> extract_from_framework_node(
     const std::shared_ptr<ov::op::util::FrameworkNode>& fw_node) {
     if (!fw_node) {
         return std::nullopt;
     }
-
     FrameworkNodeErrorInfo info;
     const auto& attrs = fw_node->get_attrs();
     info.op_type = attrs.get_type_name();
@@ -36,16 +29,7 @@ std::optional<FrameworkNodeErrorInfo> extract_from_framework_node(
     if (info.op_type.empty()) {
         info.op_type = fw_node->get_friendly_name();
     }
-
-    std::stringstream consumer;
-    if (fw_node->get_output_size() > 0) {
-        auto inputs = fw_node->output(0).get_target_inputs();
-        if (!inputs.empty()) {
-            consumer << " Consumer: " << *(inputs.begin()->get_node());
-        }
-    }
-    info.failure_message = "This is OpenVINO internal type." + consumer.str();
-
+    info.failure_message = "This is OpenVINO internal type.";
     return info;
 }
 
@@ -54,51 +38,81 @@ std::optional<FrameworkNodeErrorInfo> extract_node_info(const std::shared_ptr<ov
     if (!node) {
         return std::nullopt;
     }
-
     for (const auto& extractor : extractors) {
-        if (!extractor) {
-            continue;
-        }
-        if (auto info = extractor(node)) {
-            return info;
+        if (extractor) {
+            if (auto info = extractor(node)) {
+                return info;
+            }
         }
     }
-
     if (const auto& fw_node = ov::as_type_ptr<ov::op::util::FrameworkNode>(node)) {
         return extract_from_framework_node(fw_node);
     }
-
     return std::nullopt;
 }
 
-void collect_from_model(const std::shared_ptr<ov::Model>& model, const CollectorContext& ctx) {
+void collect_from_model(const std::shared_ptr<ov::Model>& model,
+                        const std::vector<UnconvertedOpExtractor>& extractors,
+                        UnconvertedOpMap& report) {
     if (!model) {
         return;
     }
-
     for (const auto& node : model->get_ordered_ops()) {
-        if (auto info = extract_node_info(node, ctx.extractors)) {
-            if (!info->op_type.empty() && ctx.report.count(info->op_type) == 0) {
-                ctx.report.emplace(info->op_type, info->failure_message);
+        if (auto info = extract_node_info(node, extractors)) {
+            if (!info->op_type.empty() && report.count(info->op_type) == 0) {
+                report.emplace(info->op_type, info->failure_message);
             }
         }
-
         if (const auto& multigraph = ov::as_type_ptr<ov::op::util::MultiSubGraphOp>(node)) {
             const size_t subgraphs = multigraph->get_internal_subgraphs_size();
             for (size_t idx = 0; idx < subgraphs; ++idx) {
-                collect_from_model(multigraph->get_function(idx), ctx);
+                collect_from_model(multigraph->get_function(idx), extractors, report);
             }
         }
     }
 }
 
 }  // namespace
 
+FrameworkNodeErrorInfo build_framework_node_error_info(const ov::op::util::FrameworkNodeAttrs& attrs,
+                                                       const std::string& op_type_attr_key,
+                                                       const std::string& failure_attr_key,
+                                                       const std::string& version_attr_key) {
+    FrameworkNodeErrorInfo info;
+    auto find_attr = [&](const std::string& key) -> std::string {
+        const auto it = attrs.find(key);
+        return it == attrs.end() ? std::string{} : it->second;
+    };
+
+    info.op_type = op_type_attr_key.empty() ? std::string{} : find_attr(op_type_attr_key);
+    if (info.op_type.empty()) {
+        info.op_type = attrs.get_type_name();
+    }
+    if (info.op_type.empty()) {
+        info.op_type = "<unknown>";
+    }
+
+    const auto version = version_attr_key.empty() ? std::string{} : find_attr(version_attr_key);
+    if (!version.empty()) {
+        info.op_type += "-" + version;
+    }
+
+    const auto& opset_name = attrs.get_opset_name();
+    if (!opset_name.empty()) {
+        info.op_type = opset_name + "." + info.op_type;
+    }
+
+    if (!failure_attr_key.empty()) {
+        info.failure_message = find_attr(failure_attr_key);
+    }
+
+    return info;
+}
+
 UnconvertedOpMap collect_unconverted_ops(const std::shared_ptr<ov::Model>& model,
                                          const std::vector<UnconvertedOpExtractor>& custom_extractors) {
     UnconvertedOpMap report;
-    CollectorContext ctx{custom_extractors, report};
-    collect_from_model(model, ctx);
+    collect_from_model(model, custom_extractors, report);
     return report;
 }
 
@@ -108,41 +122,41 @@ std::string format_unconverted_ops_report(const UnconvertedOpMap& unconverted_op
     std::stringstream error_msg;
     error_msg << (header.empty() ? "Model wasn't fully converted." : header);
 
-    std::stringstream unconverted_ops_msg;
-    std::stringstream failed_ops_msg;
-    std::stringstream failed_ops_short;
-    unconverted_ops_msg << "-- No conversion rule found for operations: ";
-    failed_ops_msg << " Failed operations detailed log:";
-    failed_ops_short << "-- Conversion is failed for: ";
+    std::stringstream unsupported_msg;
+    std::stringstream failures_msg;
+    std::stringstream failed_short;
+    unsupported_msg << "-- No conversion rule found for operations: ";
+    failures_msg << " Failed operations detailed log:";
+    failed_short << "-- Conversion is failed for: ";
 
     bool has_unsupported = false;
     bool has_failures = false;
     for (const auto& op : unconverted_ops) {
         if (op.second.empty()) {
             if (has_unsupported) {
-                unconverted_ops_msg << ", ";
+                unsupported_msg << ", ";
             }
-            unconverted_ops_msg << op.first;
+            unsupported_msg << op.first;
             has_unsupported = true;
         } else {
             if (has_failures) {
-                failed_ops_short << ", ";
+                failed_short << ", ";
             }
-            failed_ops_short << op.first;
-            failed_ops_msg << "\n-- " << op.first << " with a message:\n" << op.second;
+            failed_short << op.first;
+            failures_msg << "\n-- " << op.first << " with a message:\n" << op.second;
             has_failures = true;
         }
     }
 
     if (has_failures) {
-        error_msg << failed_ops_msg.str();
+        error_msg << failures_msg.str();
     }
     error_msg << "\nSummary:" << additional_error;
     if (has_unsupported) {
-        error_msg << '\n' << unconverted_ops_msg.str();
+        error_msg << '\n' << unsupported_msg.str();
     }
     if (has_failures) {
-        error_msg << '\n' << failed_ops_short.str();
+        error_msg << '\n' << failed_short.str();
     }
 
     return error_msg.str();

src/frontends/jax/src/frontend.cpp

@@ -29,15 +29,12 @@ const std::vector<UnconvertedOpExtractor>& get_unconverted_extractors() {
         ov::frontend::make_unconverted_op_extractor<JaxFrameworkNode>(
             [](const std::shared_ptr<JaxFrameworkNode>& node) -> std::optional<FrameworkNodeErrorInfo> {
                 const auto& attrs = node->get_attrs();
-                auto type_it = attrs.find(JaxFrameworkNode::op_type_key);
-                FRONT_END_GENERAL_CHECK(type_it != attrs.end(),
+                auto info = ov::frontend::build_framework_node_error_info(attrs,
+                                                                          JaxFrameworkNode::op_type_key,
+                                                                          JaxFrameworkNode::failed_conversion_key,
+                                                                          std::string{});
+                FRONT_END_GENERAL_CHECK(!info.op_type.empty(),
                                         "FrameworkNode attributes do not contain operation type.");
-                FrameworkNodeErrorInfo info;
-                info.op_type = type_it->second;
-                auto failure_it = attrs.find(JaxFrameworkNode::failed_conversion_key);
-                if (failure_it != attrs.end()) {
-                    info.failure_message = failure_it->second;
-                }
                 return info;
             })};
     return extractors;
@@ -59,9 +56,6 @@ std::shared_ptr<Model> FrontEnd::convert(const ov::frontend::InputModel::Ptr& mo
     if (m_telemetry) {
         for (const auto& entry : unconverted_ops) {
             m_telemetry->send_event("error_cause", "jax_" + entry.first);
-            if (!entry.second.empty()) {
-                m_telemetry->send_event("error_info", entry.second);
-            }
         }
     }
     FRONT_END_OP_CONVERSION_CHECK(

src/frontends/onnx/frontend/src/frontend.cpp

@@ -122,29 +122,20 @@ const std::vector<UnconvertedOpExtractor>& get_onnx_extractors() {
         ov::frontend::make_unconverted_op_extractor<ov::frontend::onnx::ONNXFrameworkNode>(
             [](const std::shared_ptr<ov::frontend::onnx::ONNXFrameworkNode>& node)
                 -> std::optional<FrameworkNodeErrorInfo> {
-                FrameworkNodeErrorInfo info;
                 const auto& attrs = node->get_attrs();
-                info.op_type = attrs.get_type_name();
-                if (!attrs.get_opset_name().empty()) {
-                    info.op_type = attrs.get_opset_name() + "." + info.op_type;
-                }
-                if (const auto it = attrs.find(ONNX_OPSET_VERSION_ATTR); it != attrs.end()) {
-                    info.op_type += "-" + it->second;
-                }
-                return info;
+                return ov::frontend::build_framework_node_error_info(attrs,
+                                                                     std::string{},
+                                                                     std::string{},
+                                                                     ONNX_OPSET_VERSION_ATTR);
             }),
         ov::frontend::make_unconverted_op_extractor<ov::frontend::onnx::NotSupportedONNXNode>(
             [](const std::shared_ptr<ov::frontend::onnx::NotSupportedONNXNode>& node)
                 -> std::optional<FrameworkNodeErrorInfo> {
-                FrameworkNodeErrorInfo info;
                 const auto& attrs = node->get_attrs();
-                info.op_type = attrs.get_type_name();
-                if (!attrs.get_opset_name().empty()) {
-                    info.op_type = attrs.get_opset_name() + "." + info.op_type;
-                }
-                if (const auto it = attrs.find(ONNX_OPSET_VERSION_ATTR); it != attrs.end()) {
-                    info.op_type += "-" + it->second;
-                }
+                FrameworkNodeErrorInfo info = ov::frontend::build_framework_node_error_info(attrs,
+                                                                                            std::string{},
+                                                                                            std::string{},
+                                                                                            ONNX_OPSET_VERSION_ATTR);
                 info.failure_message = node->additional_error_message();
                 return info;
             })};

src/frontends/paddle/src/frontend.cpp

@@ -150,9 +150,8 @@ const std::vector<UnconvertedOpExtractor>& get_unconverted_extractors() {
     static const std::vector<UnconvertedOpExtractor> extractors{
         ov::frontend::make_unconverted_op_extractor<FrameworkNode>(
             [](const std::shared_ptr<FrameworkNode>& node) -> std::optional<FrameworkNodeErrorInfo> {
-                FrameworkNodeErrorInfo info;
-                info.op_type = node->get_op_type();
-                return info;
+                const auto& attrs = node->get_attrs();
+                return ov::frontend::build_framework_node_error_info(attrs);
             })};
     return extractors;
 }
@@ -520,9 +519,6 @@ std::shared_ptr<ov::Model> FrontEnd::convert(const InputModel::Ptr& model) const
         if (m_telemetry) {
             for (const auto& entry : unconverted_ops) {
                 m_telemetry->send_event("error_cause", "paddle_" + entry.first);
-                if (!entry.second.empty()) {
-                    m_telemetry->send_event("error_info", entry.second);
-                }
             }
         }
         FRONT_END_OP_CONVERSION_CHECK(
@@ -553,9 +549,6 @@ void FrontEnd::convert(const std::shared_ptr<ov::Model>& partiallyConverted) con
         if (m_telemetry) {
             for (const auto& entry : unconverted_ops) {
                 m_telemetry->send_event("error_cause", "paddle_" + entry.first);
-                if (!entry.second.empty()) {
-                    m_telemetry->send_event("error_info", entry.second);
-                }
             }
         }
         FRONT_END_OP_CONVERSION_CHECK(

src/frontends/pytorch/src/frontend.cpp

@@ -61,15 +61,12 @@ const std::vector<UnconvertedOpExtractor>& get_unconverted_extractors() {
         ov::frontend::make_unconverted_op_extractor<PtFrameworkNode>(
             [](const std::shared_ptr<PtFrameworkNode>& node) -> std::optional<FrameworkNodeErrorInfo> {
                 const auto& attrs = node->get_attrs();
-                auto op_type_it = attrs.find(PtFrameworkNode::op_type_key);
-                FRONT_END_GENERAL_CHECK(op_type_it != attrs.end(),
+                auto info = ov::frontend::build_framework_node_error_info(attrs,
+                                                                          PtFrameworkNode::op_type_key,
+                                                                          PtFrameworkNode::failed_conversion_key,
+                                                                          std::string{});
+                FRONT_END_GENERAL_CHECK(!info.op_type.empty(),
                                         "FrameworkNode attributes do not contain operation type.");
-                FrameworkNodeErrorInfo info;
-                info.op_type = op_type_it->second;
-                auto exception_it = attrs.find(PtFrameworkNode::failed_conversion_key);
-                if (exception_it != attrs.end()) {
-                    info.failure_message = exception_it->second;
-                }
                 return info;
             })};
     return extractors;