Extend Gelu pattern to support Mul (#29321)

### Details:
Extend Gelu patterns to support Mul
Simplify the gelu fusion transformations logic
Update unit tests

### Tickets:
 - *CVS-163672*

Author: itikhono

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

@@ -26,60 +26,63 @@
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "transformations/utils/utils.hpp"
 
+using namespace ov;
+using namespace ov::op::util;
+using namespace ov::pass::pattern::op;
+
+constexpr auto SQRT2 = static_cast<float>(M_SQRT2);
+constexpr auto SQRT1_2 = static_cast<float>(M_SQRT1_2);
+
+namespace {
+
+Predicate check_value(float ref, float eps = std::numeric_limits<float>::epsilon()) {
+    return Predicate(
+        [=](const Output<Node>& output) -> bool {
+            return ov::op::util::has_constant_value<float>(output.get_node_shared_ptr(), ref, eps);
+        },
+        "has_constant_value(" + std::to_string(ref) + ")");
+}
+
+bool gelu_replacer(ov::pass::pattern::Matcher& m, const std::shared_ptr<ov::Node>& pattern_input_to_relu) {
+    ov::pass::NodeRegistry rg;
+    auto pattern_to_output = m.get_pattern_map();
+    auto x_output = pattern_to_output.at(pattern_input_to_relu);
+
+    auto gelu = rg.make<ov::op::v7::Gelu>(x_output);
+
+    gelu->set_friendly_name(m.get_match_root()->get_friendly_name());
+    copy_runtime_info(m.get_matched_nodes(), rg.get());
+    replace_node(m.get_match_root(), gelu);
+    return true;
+}
+
+}  // namespace
+
 ov::pass::GeluFusionWithErfOne::GeluFusionWithErfOne() {
     MATCHER_SCOPE(GeluFusionWithErfOne);
     // Replaces a sub-graph with a Gelu op
     // Shared by every pattern: (1 + erf(x / sqrt(2)))
     auto input = pass::pattern::any_input();
-    auto div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+    auto div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(SQRT2, 0.001f));
     auto div = ov::pass::pattern::wrap_type<ov::op::v1::Divide>({input, div_constant});
-    auto erf = ov::pass::pattern::wrap_type<ov::op::v0::Erf>({div});
-    auto add_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+
+    // In case of ConvertDivideWithConstant is applied and Div is converted to Mul
+    auto mul_as_div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(SQRT1_2, 0.001f));
+    auto mul_as_div = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({input, mul_as_div_constant});
+    auto erf_input = std::make_shared<Or>(ov::OutputVector{div, mul_as_div});
+
+    auto erf = ov::pass::pattern::wrap_type<ov::op::v0::Erf>({erf_input});
+
+    auto add_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(1.0f));
     auto add = ov::pass::pattern::wrap_type<ov::op::v1::Add>({add_constant, erf});
-    auto mul_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+    auto mul_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(0.5f));
 
     // (0.5 * x) * (1 + erf(x / sqrt(2))
     auto mul_first = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({input, mul_constant});
     auto mul = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({mul_first, add});
 
     ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
-        auto& pattern_to_output = m.get_pattern_value_map();
-        auto x_output = pattern_to_output.at(input);
-
-        auto div_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(div_constant).get_node_shared_ptr());
-        auto add_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(add_constant).get_node_shared_ptr());
-        auto mul_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(mul_constant).get_node_shared_ptr());
-
-        if (!div_const_value || !add_const_value || !mul_const_value) {
-            return false;
-        }
-
-        bool valid_constant_values =
-            op::util::has_constant_value<float>(div_const_value, static_cast<float>(M_SQRT2), 0.001f) &&
-            op::util::has_constant_value<float>(add_const_value, 1.0f) &&
-            op::util::has_constant_value<float>(mul_const_value, 0.5f);
-
-        if (!valid_constant_values) {
-            return false;
-        }
-
-        auto gelu = std::make_shared<ov::op::v7::Gelu>(x_output);
-
-        gelu->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info(
-            {
-                pattern_to_output.at(div).get_node_shared_ptr(),
-                pattern_to_output.at(erf).get_node_shared_ptr(),
-                pattern_to_output.at(add).get_node_shared_ptr(),
-                pattern_to_output.at(mul_first).get_node_shared_ptr(),
-                pattern_to_output.at(mul).get_node_shared_ptr(),
-            },
-            gelu);
-        ov::replace_node(m.get_match_root(), gelu);
-        return true;
+        return gelu_replacer(m, input);
     };
 
     auto m = std::make_shared<ov::pass::pattern::Matcher>(mul, matcher_name);
@@ -91,55 +94,25 @@ ov::pass::GeluFusionWithErfTwo::GeluFusionWithErfTwo() {
     // Replaces a sub-graph with a Gelu op
     // Shared by every pattern: (1 + erf(x / sqrt(2)))
     auto input = pass::pattern::any_input();
-    auto div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+    auto div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(SQRT2, 0.001f));
     auto div = ov::pass::pattern::wrap_type<ov::op::v1::Divide>({input, div_constant});
-    auto erf = ov::pass::pattern::wrap_type<ov::op::v0::Erf>({div});
-    auto add_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+
+    // In case of ConvertDivideWithConstant is applied and Div is converted to Mul
+    auto mul_as_div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(SQRT1_2, 0.001f));
+    auto mul_as_div = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({input, mul_as_div_constant});
+    auto erf_input = std::make_shared<Or>(ov::OutputVector{div, mul_as_div});
+
+    auto erf = ov::pass::pattern::wrap_type<ov::op::v0::Erf>({erf_input});
+    auto add_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(1.0f));
     auto add = ov::pass::pattern::wrap_type<ov::op::v1::Add>({add_constant, erf});
-    auto mul_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+    auto mul_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(0.5f));
 
     // 0.5 * (x * (1 + erf(x / sqrt(2)))
     auto mul_first = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({input, add});
     auto mul = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({mul_constant, mul_first});
 
     ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
-        auto& pattern_to_output = m.get_pattern_value_map();
-        auto x_output = pattern_to_output.at(input);
-
-        auto div_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(div_constant).get_node_shared_ptr());
-        auto add_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(add_constant).get_node_shared_ptr());
-        auto mul_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(mul_constant).get_node_shared_ptr());
-
-        if (!div_const_value || !add_const_value || !mul_const_value) {
-            return false;
-        }
-
-        bool valid_constant_values =
-            op::util::has_constant_value<float>(div_const_value, static_cast<float>(M_SQRT2), 0.001f) &&
-            op::util::has_constant_value<float>(add_const_value, 1.0f) &&
-            op::util::has_constant_value<float>(mul_const_value, 0.5f);
-
-        if (!valid_constant_values) {
-            return false;
-        }
-
-        auto gelu = std::make_shared<ov::op::v7::Gelu>(x_output);
-
-        gelu->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info(
-            {
-                pattern_to_output.at(div).get_node_shared_ptr(),
-                pattern_to_output.at(erf).get_node_shared_ptr(),
-                pattern_to_output.at(add).get_node_shared_ptr(),
-                pattern_to_output.at(mul_first).get_node_shared_ptr(),
-                pattern_to_output.at(mul).get_node_shared_ptr(),
-            },
-            gelu);
-        ov::replace_node(m.get_match_root(), gelu);
-        return true;
+        return gelu_replacer(m, input);
     };
 
     auto m = std::make_shared<ov::pass::pattern::Matcher>(mul, matcher_name);
@@ -151,55 +124,25 @@ ov::pass::GeluFusionWithErfThree::GeluFusionWithErfThree() {
     // Replaces a sub-graph with a Gelu op
     // Shared by every pattern: (1 + erf(x / sqrt(2)))
     auto input = pass::pattern::any_input();
-    auto div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+    auto div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(SQRT2, 0.001f));
     auto div = ov::pass::pattern::wrap_type<ov::op::v1::Divide>({input, div_constant});
-    auto erf = ov::pass::pattern::wrap_type<ov::op::v0::Erf>({div});
-    auto add_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+
+    // In case of ConvertDivideWithConstant is applied and Div is converted to Mul
+    auto mul_as_div_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(SQRT1_2, 0.001f));
+    auto mul_as_div = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({input, mul_as_div_constant});
+    auto erf_input = std::make_shared<Or>(ov::OutputVector{div, mul_as_div});
+
+    auto erf = ov::pass::pattern::wrap_type<ov::op::v0::Erf>({erf_input});
+    auto add_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(1.0f));
     auto add = ov::pass::pattern::wrap_type<ov::op::v1::Add>({add_constant, erf});
-    auto mul_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
+    auto mul_constant = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(check_value(0.5f));
 
     // x * (0.5 * (1 + erf(x / sqrt(2)))
     auto mul_first = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({add, mul_constant});
     auto mul = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({input, mul_first});
 
     ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
-        auto& pattern_to_output = m.get_pattern_value_map();
-        auto x_output = pattern_to_output.at(input);
-
-        auto div_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(div_constant).get_node_shared_ptr());
-        auto add_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(add_constant).get_node_shared_ptr());
-        auto mul_const_value =
-            ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(mul_constant).get_node_shared_ptr());
-
-        if (!div_const_value || !add_const_value || !mul_const_value) {
-            return false;
-        }
-
-        bool valid_constant_values =
-            op::util::has_constant_value<float>(div_const_value, static_cast<float>(M_SQRT2), 0.001f) &&
-            op::util::has_constant_value<float>(add_const_value, 1.0f) &&
-            op::util::has_constant_value<float>(mul_const_value, 0.5f);
-
-        if (!valid_constant_values) {
-            return false;
-        }
-
-        auto gelu = std::make_shared<ov::op::v7::Gelu>(x_output);
-
-        gelu->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info(
-            {
-                pattern_to_output.at(div).get_node_shared_ptr(),
-                pattern_to_output.at(erf).get_node_shared_ptr(),
-                pattern_to_output.at(add).get_node_shared_ptr(),
-                pattern_to_output.at(mul_first).get_node_shared_ptr(),
-                pattern_to_output.at(mul).get_node_shared_ptr(),
-            },
-            gelu);
-        ov::replace_node(m.get_match_root(), gelu);
-        return true;
+        return gelu_replacer(m, input);
     };
 
     auto m = std::make_shared<ov::pass::pattern::Matcher>(mul, matcher_name);
@@ -212,45 +155,19 @@ ov::pass::GeluFusionWithErfFour::GeluFusionWithErfFour() {
     using namespace ov::pass::pattern;
 
     auto input = any_input();
-    auto mul1_constant = wrap_type<ov::op::v0::Constant>();
+    auto mul1_constant = wrap_type<ov::op::v0::Constant>(check_value(SQRT1_2, 0.001f));
     auto mul1 = wrap_type<ov::op::v1::Multiply>({input, mul1_constant});
     auto erf = wrap_type<ov::op::v0::Erf>({mul1});
-    auto mul2_constant = wrap_type<ov::op::v0::Constant>();
+    auto mul2_constant = wrap_type<ov::op::v0::Constant>(check_value(0.5f));
     auto mul2 = wrap_type<ov::op::v1::Multiply>({erf, mul2_constant});
-    auto add_constant = wrap_type<ov::op::v0::Constant>();
+    auto add_constant = wrap_type<ov::op::v0::Constant>(check_value(0.5f));
     auto add = wrap_type<ov::op::v1::Add>({add_constant, mul2});
 
     // x * (0.5 + 0.5 * erf(x * (1 / sqrt(2))))
     auto mul3 = wrap_type<ov::op::v1::Multiply>({input, add});
 
     matcher_pass_callback callback = [=](Matcher& m) {
-        NodeRegistry rg;
-        auto pattern_to_output = m.get_pattern_map();
-        auto x_output = pattern_to_output.at(input);
-
-        auto mul1_const_value = ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(mul1_constant));
-        auto add_const_value = ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(add_constant));
-        auto mul2_const_value = ov::as_type_ptr<ov::op::v0::Constant>(pattern_to_output.at(mul2_constant));
-
-        if (!mul1_const_value || !add_const_value || !mul2_const_value) {
-            return false;
-        }
-
-        constexpr auto sqrt2 = static_cast<float>(M_SQRT2);
-        bool valid_constant_values = ov::op::util::has_constant_value<float>(mul1_const_value, 1.0f / sqrt2, 0.001f) &&
-                                     ov::op::util::has_constant_value<float>(add_const_value, 0.5f) &&
-                                     ov::op::util::has_constant_value<float>(mul2_const_value, 0.5f);
-
-        if (!valid_constant_values) {
-            return false;
-        }
-
-        auto gelu = rg.make<ov::op::v7::Gelu>(x_output);
-
-        gelu->set_friendly_name(m.get_match_root()->get_friendly_name());
-        copy_runtime_info(m.get_matched_nodes(), rg.get());
-        replace_node(m.get_match_root(), gelu);
-        return true;
+        return gelu_replacer(m, input);
     };
 
     auto m = std::make_shared<Matcher>(mul3, matcher_name);