[Common, PT, TF FE] Introduce common translators to support complex tensors in PyTorch (#29150)

**Details:** It introduces new component with common translators for
PyTorch and TensorFlow. This common translators allow to support complex
tensors for operations: add, mul, sub, atan2, angle, complex, real and
imag.
It helps to support RoPE implementation based on complex tensor
computation, Kokoru model.

**Ticket:** 162659

---------

Signed-off-by: Kazantsev, Roman <roman.kazantsev@intel.com>

Author: rkazants

cmake/developer_package/frontends/frontends.cmake

@@ -228,7 +228,8 @@ macro(ov_add_frontend)
     ov_add_vs_version_file(NAME ${TARGET_NAME}
                            FILEDESCRIPTION ${OV_FRONTEND_FILEDESCRIPTION})
 
-    target_link_libraries(${TARGET_NAME} PRIVATE ${OV_FRONTEND_LINK_LIBRARIES} PUBLIC openvino::runtime)
+    target_link_libraries(${TARGET_NAME} PRIVATE ${OV_FRONTEND_LINK_LIBRARIES} openvino::frontend::common_translators
+                          PUBLIC openvino::runtime)
     ov_add_library_version(${TARGET_NAME})
 
     if(OV_FRONTEND_PROTOBUF_REQUIRED)

src/frontends/CMakeLists.txt

@@ -4,6 +4,8 @@
 
 add_subdirectory(common)
 
+add_subdirectory(common_translators)
+
 if(ENABLE_TESTS)
     add_subdirectory(tests)
 endif()

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

@@ -5,6 +5,8 @@
 #pragma once
 
 #include "openvino/core/type/element_type.hpp"
+#include "openvino/frontend/exception.hpp"
+#include "openvino/frontend/node_context.hpp"
 #include "openvino/frontend/visibility.hpp"
 #include "openvino/op/util/framework_node.hpp"
 
@@ -22,11 +24,12 @@ class FRONTEND_API ComplexTypeMark : public ov::op::util::FrameworkNode {
 public:
     OPENVINO_OP("ComplexTypeMark", "util", ov::op::util::FrameworkNode);
 
-    ComplexTypeMark(const ov::Output<ov::Node>& input, const ov::element::Type& complex_part_type)
-        : ov::op::util::FrameworkNode(ov::OutputVector{input}, 1),
-          m_complex_part_type(complex_part_type) {
-        validate_and_infer_types();
-    }
+    ComplexTypeMark(const ov::Output<ov::Node>& input,
+                    const ov::element::Type& complex_part_type = ov::element::dynamic);
+
+    ComplexTypeMark(const ov::Output<ov::Node>& real,
+                    const ov::Output<ov::Node>& imag,
+                    const ov::element::Type& complex_part_type = ov::element::dynamic);
 
     ~ComplexTypeMark() override;
 
@@ -44,8 +47,68 @@ class FRONTEND_API ComplexTypeMark : public ov::op::util::FrameworkNode {
         return m_complex_part_type;
     }
 
+    // Get a real part of the complex tensor
+    ov::Output<ov::Node> get_real(bool squeezed = true);
+
+    // Get an imaginary part of the complex tensor
+    ov::Output<ov::Node> get_imag(bool squeezed = true);
+
+    // Get floating-point representation of the complex tensor
+    ov::Output<ov::Node> get_data();
+
+    // Compute summation of two operands that can be of complex type
+    // if operand is of complex type, complex type will be indicated by bool flag
+    // complex tensor is represented as a real tensor with auxiliary dimension 2 in the tail
+    // types of both operands must be aligned prior to the call
+    static ov::Output<ov::Node> add(const NodeContext& context,
+                                    const ov::Output<ov::Node>& lhs,
+                                    const ov::Output<ov::Node>& rhs);
+
+    // Compute subtraction of two operands that can be of complex type
+    // if operand is of complex type, complex type will be indicated by bool flag
+    // complex tensor is represented as a real tensor with auxiliary dimension 2 in the tail
+    // types of both operands must be aligned prior to the call
+    static ov::Output<ov::Node> sub(const NodeContext& context,
+                                    const ov::Output<ov::Node>& lhs,
+                                    const ov::Output<ov::Node>& rhs);
+
+    // Compute multiplication of two operands that can be of complex type
+    // if operand is of complex type, complex type will be indicated by bool flag
+    // complex tensor is represented as a real tensor with auxiliary dimension 2 in the tail
+    // types of both operands must be aligned prior to the call
+    static ov::Output<ov::Node> mul(const NodeContext& context,
+                                    const ov::Output<ov::Node>& lhs,
+                                    const ov::Output<ov::Node>& rhs);
+
+    // Compute inverse of operand that can be of complex type
+    // if operand is of complex type, complex type will be indicated by bool flag
+    // complex tensor is represented as a real tensor with auxiliary dimension 2 in the tail
+    static ov::Output<ov::Node> inv(const NodeContext& context, const ov::Output<ov::Node>& data);
+
+    // Compute division of two operands that can be of complex type
+    // if operand is of complex type, complex type will be indicated by bool flag
+    // complex tensor is represented as a real tensor with auxiliary dimension 2 in the tail
+    // types of both operands must be aligned prior to the call
+    static ov::Output<ov::Node> div(const NodeContext& context,
+                                    const ov::Output<ov::Node>& lhs,
+                                    const ov::Output<ov::Node>& rhs);
+
+    // Convert type of real and imaginary parts of input to like type
+    static ov::Output<ov::Node> convert_like(const NodeContext& context,
+                                             const ov::Output<ov::Node>& input,
+                                             const ov::Output<ov::Node>& like);
+
 private:
     ov::element::Type m_complex_part_type;
+
+    // floating-point tensor that represents complex tensor
+    ov::Output<ov::Node> m_data;
+
+    // real part of the complex tensor in squeezed form (no auxiliary dimension)
+    ov::Output<ov::Node> m_real;
+
+    // imaginary part of the complex tensor in squeezed form (no auxiliary dimension)
+    ov::Output<ov::Node> m_imag;
 };
 
 }  // namespace frontend

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

@@ -120,6 +120,21 @@ class FRONTEND_API NodeContext {
         FRONT_END_NOT_IMPLEMENTED(get_subgraph);
     }
 
+    /// \brief Returns Node object that can be with updated attributes
+    /// such node name, runtime info, etc.
+    /// By default, it returns the same node without update
+    virtual std::shared_ptr<Node> mark_node(std::shared_ptr<Node> ov_node) const {
+        return ov_node;
+    }
+
+    /// \brief PyTorch may have None inputs coming to operations
+    /// Other frontends do not have it per our observation
+    virtual bool input_is_none(size_t index) const {
+        auto num_inputs = get_input_size();
+        FRONT_END_GENERAL_CHECK(index < num_inputs, "Input index is out of allowed indices range");
+        return false;
+    }
+
 private:
     virtual ov::Any apply_additional_conversion_rules(const ov::Any& data, const std::type_info& type_info) const {
         return data;