Fix MarkDequantization transformation (#29151)

### Details:
Move the precision check to the predicate
It will fix the multiply commutativity to match both cases :
mul(lp_weights, scale) and mul(scale, lp_weights)

### Tickets:
 - *CVS-160006*
CVS-161724

Author: itikhono

src/common/low_precision_transformations/tests/mark_dequantization_subgraph_transformation.cpp

@@ -176,6 +176,37 @@ TEST_F(TransformationTestsF, KeepConstPrecision2BranchesSameShapes) {
     comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
 }
 
+TEST_F(TransformationTestsF, MarkDequantizationScaleOnTheLeftBranch) {
+    {
+        auto lp_const = std::make_shared<opset10::Constant>(element::u4, Shape{27}, 1);
+        auto scale = opset10::Constant::create(element::i64, Shape{}, {2});
+
+        auto convert_lp = std::make_shared<opset10::Convert>(lp_const, element::f32);
+        auto convert_scale = std::make_shared<opset10::Convert>(scale, element::f32);
+        auto multiply = std::make_shared<opset10::Multiply>(convert_scale, convert_lp);
+        auto stub_op = std::make_shared<opset10::Relu>(multiply);
+        model = std::make_shared<Model>(stub_op, ParameterVector{});
+    }
+
+    manager.register_pass<pass::MarkDequantization>(element::TypeVector{element::u4});
+    manager.register_pass<pass::ConstantFolding>();
+
+    {
+        auto lp_const = std::make_shared<opset10::Constant>(element::u4, Shape{27}, 1);
+        auto scale = opset10::Constant::create(element::f32, Shape{}, {2});
+
+        auto convert_lp = std::make_shared<opset10::Convert>(lp_const, element::f32);
+        auto multiply = std::make_shared<opset10::Multiply>(scale, convert_lp);
+        auto stub_op = std::make_shared<opset10::Relu>(multiply);
+        model_ref = std::make_shared<Model>(stub_op, ParameterVector{});
+
+        mark_as_dequantization_node(multiply);
+        ov::pass::disable_constant_folding(convert_lp);
+    }
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+    comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
+}
+
 TEST_F(TransformationTestsF, KeepConstPrecision) {
     {
         auto lp_const = std::make_shared<opset10::Constant>(element::u4, Shape{27}, 1);

src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp

@@ -11,6 +11,7 @@
 #include "openvino/op/unsqueeze.hpp"
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/pattern/op/optional.hpp"
+#include "openvino/pass/pattern/op/pattern.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "transformations/rt_info/dequantization_node.hpp"
 #include "transformations/rt_info/disable_constant_folding.hpp"
@@ -23,9 +24,13 @@ using namespace ov::pass::pattern;
 
 namespace {
 
-bool check_precision(const ov::element::Type_t type_to_check, const ov::element::TypeVector& precisions) {
-    return std::find(precisions.begin(), precisions.end(), type_to_check) != precisions.end();
-};
+ov::pass::pattern::op::Predicate check_precision(const ov::element::TypeVector& precisions) {
+    return ov::pass::pattern::op::Predicate(
+        [=](const Output<Node>& output) -> bool {
+            return std::find(precisions.begin(), precisions.end(), output.get_element_type()) != precisions.end();
+        },
+        "check_precision");
+}
 
 using RTInfoSetter = std::function<void(const std::shared_ptr<ov::Node>& node)>;
 void set_rt_info(const PatternValueMap& pt_map,
@@ -35,10 +40,9 @@ void set_rt_info(const PatternValueMap& pt_map,
     for (const auto& pattern_node : pattern_nodes) {
         if (pt_map.count(pattern_node)) {
             auto node = pt_map.at(pattern_node).get_node_shared_ptr();
-
             // we don't need to mark Converts with disable_cf attribute if the `from` type (input type)
             // is not in the `precisions` list.
-            if (ov::as_type_ptr<v0::Convert>(node) && !check_precision(node->get_input_element_type(0), precisions)) {
+            if (ov::as_type_ptr<v0::Convert>(node) && !check_precision(precisions)(node->input_value(0))) {
                 continue;
             }
 
@@ -196,7 +200,7 @@ ov::pass::MarkDequantization::MarkDequantization(const element::TypeVector& prec
     MATCHER_SCOPE(MarkDequantization);
 
     // data input:
-    auto input_pattern = any_input();
+    auto input_pattern = any_input(check_precision(precisions));
     auto convert_pattern = wrap_type<v0::Convert>({input_pattern}, consumers_count(1));
 
     // zero points:
@@ -217,7 +221,7 @@ ov::pass::MarkDequantization::MarkDequantization(const element::TypeVector& prec
         auto input = pt_map.at(input_pattern);
         const auto multiply = m.get_match_root();
 
-        if (!check_precision(input.get_element_type(), precisions) || transformation_callback(multiply)) {
+        if (transformation_callback(multiply)) {
             return false;
         }
 
@@ -290,8 +294,7 @@ ov::pass::KeepConstPrecision::KeepConstPrecision(const element::TypeVector& prec
         for (const auto& pattern_node : keep_const_precisions) {
             if (pt_map.count(pattern_node.first)) {
                 auto node = pt_map.at(pattern_node.first).get_node_shared_ptr();
-                const auto& precision = node->get_output_element_type(0);
-                if (ov::as_type_ptr<v0::Constant>(node) && check_precision(precision, precisions)) {
+                if (ov::as_type_ptr<v0::Constant>(node) && check_precision(precisions)(node->output(0))) {
                     if (pattern_node.second) {
                         ov::disable_keep_const_precision(node);
                     } else {

src/core/src/preprocess/pre_post_process.cpp

@@ -18,6 +18,7 @@
 #include "transformations/common_optimizations/disable_shapeof_constant_folding.hpp"
 #include "transformations/common_optimizations/mul_conv_fusion.hpp"
 #include "transformations/common_optimizations/ric_fusion.hpp"
+#include "transformations/common_optimizations/shared_ops_optimization.hpp"
 #include "transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp"
 #include "transformations/low_precision/mark_dequantization_subgraph.hpp"
 #include "transformations/op_conversions/convert_divide.hpp"
@@ -74,6 +75,9 @@ void transformation_pipeline(std::shared_ptr<ov::Model>& model) {
     Manager manager("pre_post_processing");
     manager.set_per_pass_validation(false);
 
+    // prerequisite: the model structure optimization before applying of the markup
+    REGISTER_PASS(manager, SharedOpOptimization)
+
     // 1. Set "disable_const_folding" attribute
     REGISTER_PASS(manager, MarkDequantization, TypeVector{i8, u8, i4, u4, nf4, f4e2m1, f8e4m3, f8e5m2, f8e8m0});
     REGISTER_PASS(manager, DisableShapeOfConstantFolding, false);