[Opset14][CORE] ConvertPromoteTypes op core implementation

src/common/transformations/include/transformations/op_conversions/convert_convertaligntypes.hpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/pass/graph_rewrite.hpp"
+#include "transformations_visibility.hpp"
+
+namespace ov {
+namespace pass {
+
+class TRANSFORMATIONS_API ConvertConvertAlignTypes;
+
+}  // namespace pass
+}  // namespace ov
+
+class ov::pass::ConvertConvertAlignTypes : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("ConvertConvertAlignTypes", "0");
+    ConvertConvertAlignTypes();
+};

src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp

@@ -68,6 +68,7 @@
 #include "transformations/op_conversions/bidirectional_sequences_decomposition.hpp"
 #include "transformations/op_conversions/convert_bitwise_to_logical_bool.hpp"
 #include "transformations/op_conversions/convert_broadcast_to_tiles.hpp"
+#include "transformations/op_conversions/convert_convertaligntypes.hpp"
 #include "transformations/op_conversions/convert_convertlike.hpp"
 #include "transformations/op_conversions/convert_deformable_conv_v8_to_v1.hpp"
 #include "transformations/op_conversions/convert_depth_to_space.hpp"
@@ -164,6 +165,7 @@ bool ov::pass::CommonOptimizations::run_on_model(const std::shared_ptr<ov::Model
     ADD_MATCHER(decomp, ConvertDivide)
     ADD_MATCHER(decomp, ConvertDepthToSpace)
     ADD_MATCHER(decomp, ConvertSpaceToDepth)
+    ADD_MATCHER(decomp, ConvertConvertAlignTypes)
     ADD_MATCHER(decomp, ConvertConvertLike)
     ADD_MATCHER(decomp, BatchNormDecomposition)
     ADD_MATCHER(decomp, GroupNormalizationDecomposition)

src/common/transformations/src/transformations/op_conversions/convert_convertaligntypes.cpp

@@ -0,0 +1,40 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "transformations/op_conversions/convert_convertaligntypes.hpp"
+
+#include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/op/convert.hpp"
+#include "openvino/op/convert_align_types.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+
+using namespace ov;
+
+ov::pass::ConvertConvertAlignTypes::ConvertConvertAlignTypes() {
+    MATCHER_SCOPE(ConvertConvertAlignTypes);
+
+    auto convert_align_types = pattern::wrap_type<ov::op::v14::ConvertAlignTypes>();
+
+    matcher_pass_callback callback = [](pattern::Matcher& m) {
+        auto convert = std::dynamic_pointer_cast<ov::op::v14::ConvertAlignTypes>(m.get_match_root());
+        if (!convert) {
+            return false;
+        }
+        const element::Type& dest_type = convert->get_output_element_type(0);
+        if (dest_type == element::dynamic || dest_type == element::undefined) {
+            return false;
+        }
+        auto out0 = std::make_shared<ov::op::v0::Convert>(convert->input_value(0), dest_type);
+        auto out1 = std::make_shared<ov::op::v0::Convert>(convert->input_value(1), dest_type);
+        out0->set_friendly_name(convert->get_friendly_name() + ".0");
+        out1->set_friendly_name(convert->get_friendly_name() + ".1");
+        copy_runtime_info(convert, {out0, out1});
+        replace_node(convert, {out0, out1});
+        return true;
+    };
+
+    auto m = std::make_shared<pattern::Matcher>(convert_align_types, matcher_name);
+    this->register_matcher(m, callback);
+}

src/common/transformations/tests/op_conversions/convert_convertaligntypes_test.cpp

@@ -0,0 +1,86 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "transformations/op_conversions/convert_convertaligntypes.hpp"
+
+#include "common_test_utils/ov_test_utils.hpp"
+#include "openvino/op/convert.hpp"
+#include "openvino/op/convert_align_types.hpp"
+#include "openvino/op/parameter.hpp"
+#include "openvino/pass/manager.hpp"
+
+using namespace ov;
+using namespace ov::op;
+
+namespace {
+
+struct ConvertAlignTypesTestParams {
+    PartialShape lhs_shape;
+    element::Type lhs_type;
+    PartialShape rhs_shape;
+    element::Type rhs_type;
+    element::Type expected_type;
+};
+
+class ConvertConvertAlignTypesTest : public TransformationTestsF,
+                                     public testing::WithParamInterface<ConvertAlignTypesTestParams> {
+public:
+    void SetUp() override {
+        TransformationTestsF::SetUp();
+        const auto& parameters = GetParam();
+        const auto& lhsType = parameters.lhs_type;
+        const auto& lhsShape = parameters.lhs_shape;
+        const auto& rhsType = parameters.rhs_type;
+        const auto& rhsShape = parameters.rhs_shape;
+        const auto& alignType = parameters.expected_type;
+        model = transform(lhsShape, lhsType, rhsShape, rhsType);
+        model_ref = reference(lhsShape, lhsType, rhsShape, rhsType, alignType);
+        manager.register_pass<pass::ConvertConvertAlignTypes>();
+    }
+
+protected:
+    static std::shared_ptr<Model> transform(const PartialShape& lhsShape,
+                                            const element::Type& lhsType,
+                                            const PartialShape& rhsShape,
+                                            const element::Type& rhsType) {
+        const auto lhs = std::make_shared<v0::Parameter>(lhsType, lhsShape);
+        const auto rhs = std::make_shared<v0::Parameter>(rhsType, rhsShape);
+        const auto convert_align_types = std::make_shared<v14::ConvertAlignTypes>(lhs, rhs, true);
+        return std::make_shared<Model>(convert_align_types->outputs(), ParameterVector{lhs, rhs}, "Actual");
+    }
+
+    static std::shared_ptr<Model> reference(const PartialShape& lhsShape,
+                                            const element::Type& lhsType,
+                                            const PartialShape& rhsShape,
+                                            const element::Type& rhsType,
+                                            const element::Type& alignType) {
+        const auto lhs = std::make_shared<v0::Parameter>(lhsType, lhsShape);
+        const auto rhs = std::make_shared<v0::Parameter>(rhsType, rhsShape);
+        const auto lhs_converted = std::make_shared<v0::Convert>(lhs, alignType);
+        const auto rhs_converted = std::make_shared<v0::Convert>(rhs, alignType);
+        return std::make_shared<Model>(NodeVector{lhs_converted, rhs_converted},
+                                       ParameterVector{lhs, rhs},
+                                       "Reference");
+    }
+};
+INSTANTIATE_TEST_SUITE_P(
+    ConvertAlignTypesDecomposition,
+    ConvertConvertAlignTypesTest,
+    testing::Values(
+        ConvertAlignTypesTestParams{PartialShape::dynamic(),
+                                    element::f32,
+                                    PartialShape::dynamic(),
+                                    element::f32,
+                                    element::f32},
+        ConvertAlignTypesTestParams{PartialShape::dynamic(), element::u16, {5, 6, 7}, element::i16, element::i32},
+        ConvertAlignTypesTestParams{{1, 2, 3, 4}, element::u16, PartialShape::dynamic(), element::f32, element::f32},
+        ConvertAlignTypesTestParams{{1, {3, 7}, -1, 4}, element::f8e4m3, {0, 6, 7}, element::f8e5m2, element::f16},
+        ConvertAlignTypesTestParams{{}, element::bf16, {5, 6, 7}, element::f16, element::f32},
+        ConvertAlignTypesTestParams{{1, 2, 3, 4}, element::u16, {}, element::boolean, element::u16},
+        ConvertAlignTypesTestParams{{}, element::u16, {}, element::u1, element::u16},
+        ConvertAlignTypesTestParams{{-1}, element::u64, {1}, element::i16, element::f32},
+        ConvertAlignTypesTestParams{{1, 2, 3, 4}, element::boolean, {5, 6, 7}, element::boolean, element::boolean},
+        ConvertAlignTypesTestParams{{1, 2, 3, 4}, element::i64, {5, 6, 7}, element::f16, element::f16}));
+TEST_P(ConvertConvertAlignTypesTest, CompareFunctions) {}
+}  // namespace

src/core/include/openvino/op/convert_align_types.hpp

@@ -0,0 +1,69 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/op/op.hpp"
+
+namespace ov {
+namespace op {
+namespace v14 {
+/// \brief Elementwise type alignment conversion operation.
+/// \ingroup ov_ops_cpp_api
+class OPENVINO_API ConvertAlignTypes : public Op {
+public:
+    OPENVINO_OP("ConvertAlignTypes", "opset14", op::Op);
+
+    /// \brief Constructs a type alignment and conversion operation.
+    ConvertAlignTypes() = default;
+    /// \brief Constructs a type alignment and conversion operation.
+    /// \param lhs  Node with datatype to be aligned.
+    /// \param rhs  Node with datatype to be aligned.
+    /// \param promote_unsafe  Bool attribute wether to allow for promotions that might result in bit-widening,
+    /// precision loss and undefined behaviors.
+    /// \param pytorch_scalar_align  Bool attribute wether to align scalars using  PyTorch-like rules.
+    /// \param u64_integer_promotion_target  Element type attribute to select alignment target for u64 and signed
+    /// integers.
+    ConvertAlignTypes(const Output<Node>& lhs,
+                      const Output<Node>& rhs,
+                      const bool promote_unsafe = false,
+                      const bool pytorch_scalar_align = false,
+                      const element::Type& u64_integer_promotion_target = element::f32);
+    void validate_and_infer_types() override;
+    bool visit_attributes(AttributeVisitor& visitor) override;
+
+    std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
+
+    bool get_pytorch_scalar_align() const {
+        return m_pytorch_scalar_align;
+    }
+
+    void set_pytorch_scalar_align(bool pytorch_scalar_align) {
+        m_pytorch_scalar_align = pytorch_scalar_align;
+    }
+
+    bool get_promote_unsafe() const {
+        return m_promote_unsafe;
+    }
+
+    void set_promote_unsafe(bool promote_unsafe) {
+        m_promote_unsafe = promote_unsafe;
+    }
+
+    element::Type get_u64_integer_promotion_target() const {
+        return m_u64_integer_promotion_target;
+    }
+
+    void set_u64_integer_promotion_target(element::Type u64_integer_promotion_target) {
+        m_u64_integer_promotion_target = u64_integer_promotion_target;
+    }
+
+private:
+    bool m_promote_unsafe = false;
+    bool m_pytorch_scalar_align = false;
+    element::Type m_u64_integer_promotion_target = element::f32;
+};
+}  // namespace v14
+}  // namespace op
+}  // namespace ov

src/core/include/openvino/op/ops.hpp

@@ -32,6 +32,7 @@
 #include "openvino/op/concat.hpp"
 #include "openvino/op/constant.hpp"
 #include "openvino/op/convert.hpp"
+#include "openvino/op/convert_align_types.hpp"
 #include "openvino/op/convert_like.hpp"
 #include "openvino/op/convolution.hpp"
 #include "openvino/op/cos.hpp"

src/core/include/openvino/opsets/opset14_tbl.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2023 Intel Corporation
+// Copyright (C) 2018-2024 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -219,3 +219,4 @@ _OPENVINO_OP_REG(ScaledDotProductAttention, ov::op::v13)
 _OPENVINO_OP_REG(FakeConvert, ov::op::v13)
 
 // New operations added in opset14
+_OPENVINO_OP_REG(ConvertAlignTypes, ov::op::v14)