change constant_path logic to avoid Matmul nodes zeros value output issue on CPU

Author: liubo-intel

src/common/transformations/include/transformations/utils/utils.hpp

@@ -280,7 +280,8 @@ TRANSFORMATIONS_API bool can_eliminate_eltwise_node(const std::shared_ptr<Node>&
 
 TRANSFORMATIONS_API bool is_constant_and_all_values_equal_int(const Output<Node>& output, const int64_t& v);
 
-TRANSFORMATIONS_API bool is_on_constant_path(const ov::Output<ov::Node>& output);
+TRANSFORMATIONS_API bool is_on_constant_path(const ov::Output<ov::Node>& output,
+                                             const std::unordered_set<std::type_index>& break_node_types = {});
 
 TRANSFORMATIONS_API bool process_subgraph(ov::pass::ModelPass& model_pass, const std::shared_ptr<Node>& node);
 

src/common/transformations/src/transformations/utils/utils.cpp

@@ -489,14 +489,23 @@ bool is_constant_and_all_values_equal_int(const Output<Node>& output, const int6
     return false;
 }
 
-bool is_on_constant_path(const ov::Output<ov::Node>& output) {
+bool is_on_constant_path(const ov::Output<ov::Node>& output,
+                         const std::unordered_set<std::type_index>& break_node_types) {
     auto status = true;
     std::deque<ov::Node*> nodes_to_calculate = {output.get_node()};
 
     while (status && !nodes_to_calculate.empty()) {
         auto current_node = nodes_to_calculate.front();
         nodes_to_calculate.pop_front();
 
+        // Check if the current node matches any type in break_node_types
+        if (!break_node_types.empty()) {
+            std::type_index current_type(typeid(*current_node));
+            if (break_node_types.find(current_type) != break_node_types.end()) {
+                return false;
+            }
+        }
+
         if (current_node->get_input_size() == 0 && !ov::is_type<ov::op::v0::Constant>(current_node)) {
             status = false;
         } else {

src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp

@@ -10,6 +10,7 @@
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/op/convert.hpp"
 #include "openvino/op/matmul.hpp"
+#include "openvino/op/random_uniform.hpp"
 #include "openvino/op/transpose.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "ov_ops/fully_connected.hpp"
@@ -19,7 +20,7 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
     MATCHER_SCOPE(ConvertMatMulToFC);
     auto activations_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank());
     auto weights_path = [](const ov::Output<ov::Node>& output) {
-        return ov::op::util::is_on_constant_path(output);
+        return ov::op::util::is_on_constant_path(output, {typeid(ov::op::v8::RandomUniform)});
     };
     auto weights_m = ov::pass::pattern::any_input(weights_path);
     auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({activations_m, weights_m},

src/plugins/intel_cpu/tests/unit/transformations/convert_matmul_test.cpp

@@ -537,3 +537,38 @@ TEST_F(TransformationTestsF, ConvertMatMulToFCTest_compressed_u8_weights) {
         model_ref = std::make_shared<ov::Model>(ov::OutputVector{matmul}, ov::ParameterVector{data});
     }
 }
+
+TEST_F(TransformationTestsF, ConvertMatMulToFCTest_WithRandomUniform) {
+    {
+        auto input1 = std::make_shared<ov::opset1::Parameter>(ov::element::f32, ov::PartialShape{-1, -1, -1});
+
+        auto random_uniform_shape = ov::opset1::Constant::create(ov::element::i32, ov::Shape{2}, {2, 2});
+        auto random_uniform_min = ov::opset1::Constant::create(ov::element::f32, ov::Shape{1}, {0.0});
+        auto random_uniform_max = ov::opset1::Constant::create(ov::element::f32, ov::Shape{1}, {1.0});
+        auto random_uniform = std::make_shared<ov::op::v8::RandomUniform>(random_uniform_shape,
+                                                                          random_uniform_min,
+                                                                          random_uniform_max,
+                                                                          ov::element::f32);
+
+        auto matmul = std::make_shared<ov::opset1::MatMul>(input1, random_uniform, false, false);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{matmul}, ov::ParameterVector{input1});
+
+        manager.register_pass<ConvertMatMulToFC>();
+    }
+    {
+        auto input1 = std::make_shared<ov::opset1::Parameter>(ov::element::f32, ov::PartialShape{-1, -1, -1});
+
+        auto random_uniform_shape = ov::opset1::Constant::create(ov::element::i32, ov::Shape{2}, {2, 2});
+        auto random_uniform_min = ov::opset1::Constant::create(ov::element::f32, ov::Shape{1}, {0.0});
+        auto random_uniform_max = ov::opset1::Constant::create(ov::element::f32, ov::Shape{1}, {1.0});
+        auto random_uniform = std::make_shared<ov::op::v8::RandomUniform>(random_uniform_shape,
+                                                                          random_uniform_min,
+                                                                          random_uniform_max,
+                                                                          ov::element::f32);
+
+        auto matmul = std::make_shared<ov::opset1::MatMul>(input1, random_uniform, false, false);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{matmul}, ov::ParameterVector{input1});
+    }
+}