Add GeluFusion to PreProcessing transformations pipeline (#29421)

### Details:
In specific cases of Gelu pattern, Mul(input, const(0.5)) might be fused
to Conv weights, the pattern can't be detected after that.
We have to add Gelu to the preprocessing transformation pipeline.

### Tickets:
 - *CVS-163672*

Author: itikhono

src/core/src/preprocess/pre_post_process.cpp

@@ -16,6 +16,7 @@
 #include "transformations/common_optimizations/convolution_to_group_convolution_fusion.hpp"
 #include "transformations/common_optimizations/disable_random_uniform_constant_folding.hpp"
 #include "transformations/common_optimizations/disable_shapeof_constant_folding.hpp"
+#include "transformations/common_optimizations/gelu_fusion.hpp"
 #include "transformations/common_optimizations/mul_conv_fusion.hpp"
 #include "transformations/common_optimizations/ric_fusion.hpp"
 #include "transformations/common_optimizations/shared_ops_optimization.hpp"
@@ -89,12 +90,14 @@ void transformation_pipeline(std::shared_ptr<ov::Model>& model) {
 
     // 2. Fusion transformations:
     REGISTER_PASS(manager, ConvertDivideWithConstant)
-    auto multiply_fusions = manager.register_pass<GraphRewrite>();
-    ADD_MATCHER(multiply_fusions, MultiplyConvolutionFusion)
-    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionFusion)
-    ADD_MATCHER(multiply_fusions, MultiplyConvolutionBackpropDataFusion)
-    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionBackpropDataFusion)
-    multiply_fusions->set_name("ov::pass::MultiplyFusions");
+    auto fusions = manager.register_pass<GraphRewrite>();
+    // Gelu fusion have to be executed before MulConv fusion because Mul(X, 0.5) might be fused to Conv weights
+    ADD_MATCHER(fusions, GeluFusion)
+    ADD_MATCHER(fusions, MultiplyConvolutionFusion)
+    ADD_MATCHER(fusions, MultiplyGroupConvolutionFusion)
+    ADD_MATCHER(fusions, MultiplyConvolutionBackpropDataFusion)
+    ADD_MATCHER(fusions, MultiplyGroupConvolutionBackpropDataFusion)
+    fusions->set_name("ov::pass::MultiplyFusions");
     REGISTER_PASS(manager, ReverseInputChannelsFusion)
 
     // 3. CF call due to detected perf degradations

src/core/tests/preprocess.cpp

@@ -2,6 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#define _USE_MATH_DEFINES
+
+#include <math.h>
+
 #include "common_test_utils/ov_test_utils.hpp"
 #include "common_test_utils/test_assertions.hpp"
 #include "common_test_utils/test_tools.hpp"
@@ -2504,3 +2508,50 @@ TEST_F(TransformationTestsF, preprocessing_conv_decompression) {
         model_ref = std::make_shared<ov::Model>(ResultVector{res}, ParameterVector{input});
     }
 }
+
+TEST_F(TransformationTestsF, preprocessing_gelu_fusion) {
+    auto in_shape = Shape{1, 3, 32, 32};
+    auto in_type = element::f32;
+    auto weight_type = element::f32;
+    {
+        auto data = std::make_shared<ov::op::v0::Parameter>(in_type, in_shape);
+
+        auto mul_const_sqrt_1_2 = ov::op::v0::Constant::create(in_type, Shape{1}, {M_SQRT1_2});
+        auto mul_to_erf = std::make_shared<ov::op::v1::Multiply>(data, mul_const_sqrt_1_2);
+        auto erf = std::make_shared<ov::op::v0::Erf>(mul_to_erf);
+
+        auto add_const = ov::op::v0::Constant::create(in_type, Shape{1}, {1.0});
+        auto add = std::make_shared<ov::op::v1::Add>(erf, add_const);
+        auto mul_first = std::make_shared<ov::op::v1::Multiply>(data, add);
+
+        auto mul_const = ov::op::v0::Constant::create(in_type, Shape{1}, {0.5});
+        auto mul = std::make_shared<ov::op::v1::Multiply>(mul_first, mul_const);
+
+        std::shared_ptr<Node> weights = std::make_shared<op::v0::Constant>(weight_type, ov::Shape{1, 3, 3, 3}, 1);
+        auto conv = std::make_shared<op::v1::Convolution>(mul,
+                                                          weights,
+                                                          Strides{},
+                                                          CoordinateDiff{},
+                                                          CoordinateDiff{},
+                                                          Strides{});
+        auto res = std::make_shared<op::v0::Result>(conv);
+        auto f = std::make_shared<ov::Model>(ov::ResultVector{res}, ov::ParameterVector{data});
+        auto p = PrePostProcessor(f);
+        model = p.build();
+    }
+
+    {
+        auto input = std::make_shared<op::v0::Parameter>(in_type, in_shape);
+
+        auto gelu = std::make_shared<op::v7::Gelu>(input);
+        auto weights = op::v0::Constant::create(weight_type, ov::Shape({1, 3, 3, 3}), {1.f});
+        auto conv = std::make_shared<op::v1::Convolution>(gelu,
+                                                          weights,
+                                                          Strides{},
+                                                          CoordinateDiff{},
+                                                          CoordinateDiff{},
+                                                          Strides{});
+        auto res = std::make_shared<op::v0::Result>(conv);
+        model_ref = std::make_shared<ov::Model>(ResultVector{res}, ParameterVector{input});
+    }
+}