[LPT] BroadcastTransformation: broadcast with 2 inputs support (#31258)

### Tickets:
 - *CVS-170294*

Author: v-Golubev

src/common/low_precision_transformations/src/broadcast.cpp

@@ -5,40 +5,30 @@
 #include "low_precision/broadcast.hpp"
 
 #include <memory>
-#include "openvino/opsets/opset1_decl.hpp"
-#include "openvino/opsets/opset3_decl.hpp"
-#include "openvino/pass/pattern/op/or.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "low_precision/network_helper.hpp"
 
 #include "itt.hpp"
+#include "low_precision/network_helper.hpp"
 #include "openvino/op/broadcast.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 
 using namespace ov::pass::low_precision;
 
 BroadcastTransformation::BroadcastTransformation(const Params& params) : TransparentBaseTransformation(params) {
     MATCHER_SCOPE(BroadcastTransformation);
-    auto broadcast1 = pattern::wrap_type<ov::opset1::Broadcast>({
-        pattern::wrap_type<ov::opset1::Multiply>(),
-        ov::pass::pattern::any_input(),
-        ov::pass::pattern::any_input() });
-
-    auto broadcast3 = pattern::wrap_type<ov::opset3::Broadcast>({
-        pattern::wrap_type<ov::opset1::Multiply>(),
-        ov::pass::pattern::any_input(),
-        ov::pass::pattern::any_input() });
-
-    const auto matcher = std::make_shared<ov::pass::pattern::op::Or>(ov::OutputVector{ broadcast1, broadcast3 });
+    using namespace ov::pass::pattern;
+    auto mul = wrap_type<ov::op::v1::Multiply>();
+    auto matcher = wrap_type<ov::op::v3::Broadcast, ov::op::v1::Broadcast>({mul, any_input(), any_input()}) |
+                   wrap_type<ov::op::v3::Broadcast>({mul, any_input()});
 
-    ov::graph_rewrite_callback callback = [this](pattern::Matcher& m) {
+    ov::graph_rewrite_callback callback = [this](Matcher& m) {
         auto op = m.get_match_root();
         if (transformation_callback(op)) {
             return false;
         }
         return transform(m);
     };
 
-    auto m = std::make_shared<ov::pass::pattern::Matcher>(matcher, matcher_name);
+    auto m = std::make_shared<Matcher>(matcher, matcher_name);
     this->register_matcher(m, callback);
 }
 
@@ -61,17 +51,26 @@ bool BroadcastTransformation::canBeTransformed(const std::shared_ptr<ov::Node>&
         return false;
     }
 
-    const auto targetShapeConstant = ov::as_type_ptr<ov::opset1::Constant>(layer->get_input_node_shared_ptr(1));
-    const auto& targetShape = targetShapeConstant->cast_vector<int64_t>();
-    if (targetShape[dequantization.channelDimIndex] != inputShape[dequantization.channelDimIndex].get_length()) {
+    const auto& outputShape = layer->get_output_partial_shape(0);
+    if (outputShape[dequantization.channelDimIndex] != inputShape[dequantization.channelDimIndex]) {
         return false;
     }
 
-    const auto axesMappingConstant = ov::as_type_ptr<ov::opset1::Constant>(layer->get_input_node_shared_ptr(2));
-    const auto& axesMapping = axesMappingConstant->cast_vector<int64_t>();
-    if (static_cast<size_t>(axesMapping[dequantization.channelDimIndex]) != dequantization.channelDimIndex) {
+    const auto bcast = ov::as_type_ptr<ov::op::util::BroadcastBase>(layer);
+    if (bcast == nullptr) {
         return false;
     }
+    // axisMapping input affects the result only in case of explicit broadcast.
+    if (bcast->get_broadcast_spec().m_type == ov::op::BroadcastType::EXPLICIT && bcast->get_input_size() == 3) {
+        const auto axesMappingConstant = ov::as_type_ptr<ov::op::v0::Constant>(bcast->get_input_node_shared_ptr(2));
+        if (!axesMappingConstant) {
+            return false;
+        }
+        const auto& axesMapping = axesMappingConstant->cast_vector<size_t>();
+        if (axesMapping[dequantization.channelDimIndex] != dequantization.channelDimIndex) {
+            return false;
+        }
+    }
 
     return true;
 }

src/common/low_precision_transformations/tests/broadcast_transformation.cpp

@@ -44,20 +44,13 @@ typedef std::tuple<
 class BroadcastTransformation : public LayerTransformation, public testing::WithParamInterface<BroadcastTransformationParams> {
 public:
     void SetUp() override {
-        const ov::PartialShape inputShape = std::get<0>(GetParam());
-        const bool v1 = std::get<1>(GetParam());
-        const BroadcastTransformationTestValues testValues = std::get<2>(GetParam());
-
-        // batch update support
-        auto tagetShape = testValues.tagetShape;
-        tagetShape[0] = inputShape[0].get_length();
-
+        const auto [inputShape, v1, testValues] = GetParam();
         actualFunction = BroadcastFunction::get(
             v1,
             inputShape,
             testValues.actual.precisionBeforeDequantization,
             testValues.actual.dequantizationBefore,
-            tagetShape,
+            testValues.tagetShape,
             testValues.axesMapping,
             testValues.actual.dequantizationAfter);
 
@@ -70,16 +63,13 @@ class BroadcastTransformation : public LayerTransformation, public testing::With
             inputShape,
             testValues.expected.precisionBeforeDequantization,
             testValues.expected.dequantizationBefore,
-            tagetShape,
+            testValues.tagetShape,
             testValues.axesMapping,
             testValues.expected.dequantizationAfter);
     }
 
     static std::string getTestCaseName(testing::TestParamInfo<BroadcastTransformationParams> obj) {
-        const ov::PartialShape inputShape = std::get<0>(obj.param);
-        const bool v1 = std::get<1>(obj.param);
-        const BroadcastTransformationTestValues testValues = std::get<2>(obj.param);
-
+        const auto [inputShape, v1, testValues] = obj.param;
         std::ostringstream result;
         result <<
             v1 << "_" <<
@@ -108,7 +98,6 @@ TEST_P(BroadcastTransformation, CompareFunctions) {
 namespace hw_broadcast {
 const std::vector<ov::PartialShape> inputShapes = {
     { 1, 3, 1, 1 },
-    { 4, 3, 1, 1 },
 };
 
 const std::vector<BroadcastTransformationTestValues> testValues = {
@@ -181,6 +170,22 @@ const std::vector<BroadcastTransformationTestValues> testValues = {
             {{}, {}, {}},
             {{ov::element::f32}, {0.1f}, {0.2f}}
         }
+    },
+    {
+        LayerTransformation::createParamsU8I8(),
+        { 1, 9, 9, 9},
+        // empty axis mapping => bcast with 2 inputs is created
+        {},
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {0.1f}, {0.2f}},
+            {{}, {}, {}},
+        },
+        {
+            ov::element::u8,
+            {{}, {}, {}},
+            {{ov::element::f32}, {0.1f}, {0.2f}}
+        }
     }
 };
 

src/tests/ov_helpers/ov_lpt_models/src/broadcast.cpp

@@ -17,11 +17,18 @@ namespace subgraph {
 
 namespace {
 template <typename T>
-std::shared_ptr<ov::Node> make_broadcast(const std::shared_ptr<ov::Node>& parent, const Shape& tagetShape, const Shape& axesMapping) {
+std::shared_ptr<ov::Node> make_broadcast(const std::shared_ptr<ov::Node>& parent,
+                                         const Shape& tagetShape,
+                                         const Shape& axesMapping) {
+    if (axesMapping.empty()) {
+        return std::make_shared<T>(
+            parent,
+            std::make_shared<ov::opset1::Constant>(ov::element::i32, Shape{tagetShape.size()}, tagetShape));
+    }
     return std::make_shared<T>(
         parent,
-        std::make_shared<ov::opset1::Constant>(ov::element::i32, Shape{ tagetShape.size() }, tagetShape),
-        std::make_shared<ov::opset1::Constant>(ov::element::i32, Shape{ axesMapping.size() }, axesMapping));
+        std::make_shared<ov::opset1::Constant>(ov::element::i32, Shape{tagetShape.size()}, tagetShape),
+        std::make_shared<ov::opset1::Constant>(ov::element::i32, Shape{axesMapping.size()}, axesMapping));
 }
 } // namespace