[CPU] Revert "Fix Alibaba-NLP accuracy issue (#32507)" (#32653)

### Details: - *mlp fusion pattern changes will result in perf regression for some models, so we need re-consider the pattern limitation settings to both fix the acc issue and keep current models no perf regression* ### Tickets: - *CVS-176051 CVS-176019*

Author: liubo-intel

src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.cpp

@@ -122,34 +122,6 @@ ov::intel_cpu::MLPFusionPass::MLPFusionPass() {
  matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
  const auto& pattern_map = m.get_pattern_value_map();
  auto root = m.get_match_root();
- // Check that the first input of Multiply is the gate (activation) branch and the second input is the up branch;
- // otherwise, do not fuse. Input order is critical for correctness: mismatched input order can silently cause
- // accuracy issues.
- auto mlp_gated_up_node = pattern_map.at(mlp_gated_up).get_node_shared_ptr();
- auto input0 = mlp_gated_up_node->input_value(0);
- auto input1 = mlp_gated_up_node->input_value(1);
-
- bool input0_is_gate = false;
- bool input1_is_up = false;
-
- if (pattern_map.count(mlp_silu_gate) && input0.get_node() == pattern_map.at(mlp_silu_gate).get_node()) {
- input0_is_gate = true;
- }
- if (pattern_map.count(mlp_gelu_gate) && input0.get_node() == pattern_map.at(mlp_gelu_gate).get_node()) {
- input0_is_gate = true;
- }
-
- if (pattern_map.count(mlp_up_proj) && input1.get_node() == pattern_map.at(mlp_up_proj).get_node()) {
- input1_is_up = true;
- }
- if (pattern_map.count(gate_up_proj_split) &&
- input1.get_node() == pattern_map.at(gate_up_proj_split).get_node() && input1.get_index() == 1) {
- input1_is_up = true;
- }
-
- if (!input0_is_gate || !input1_is_up) {
- return false;
- }
  auto src = pattern_map.at(input);
  if (!src.get_element_type().is_real()) {
  // FakeQuantize, should skip fusion

src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/x64/mlp_fusion.cpp

@@ -6,13 +6,13 @@
 #include <vector>
 
 #include "common_test_utils/ov_tensor_utils.hpp"
+#include "openvino/runtime/exec_model_info.hpp"
+#include "shared_test_classes/base/ov_subgraph.hpp"
 #include "openvino/op/convert.hpp"
 #include "openvino/op/gelu.hpp"
 #include "openvino/op/matmul.hpp"
 #include "openvino/op/multiply.hpp"
 #include "openvino/op/swish.hpp"
-#include "openvino/runtime/exec_model_info.hpp"
-#include "shared_test_classes/base/ov_subgraph.hpp"
 
 namespace ov {
 namespace test {
@@ -23,7 +23,6 @@ struct LLMMLPFusionParams {
  size_t up_size;
  std::string act_type;
  bool use_dynamic_quant;
- bool swap_inputs; // true = swap inputs to prevent fusion, false = normal order for fusion
 };
 
 class LLMMLPFusionTest : public testing::WithParamInterface<LLMMLPFusionParams>, public ov::test::SubgraphBaseTest {
@@ -40,7 +39,6 @@ class LLMMLPFusionTest : public testing::WithParamInterface<LLMMLPFusionParams>,
  result << "up_size=" << obj.param.up_size << "_";
  result << "act_type=" << obj.param.act_type << "_";
  result << "use_dynamic_quant=" << obj.param.use_dynamic_quant << "_";
- result << "swap_inputs=" << obj.param.swap_inputs << "_";
  result << obj.index;
  return result.str();
  }
@@ -72,8 +70,7 @@ class LLMMLPFusionTest : public testing::WithParamInterface<LLMMLPFusionParams>,
  in_data.start_from = 0;
  in_data.range = 1;
  in_data.resolution = 128;
- auto tensor_scale_per_oc =
- ov::test::utils::create_and_fill_tensor(ov::element::f32, ov::Shape{OC, 1}, in_data);
+ auto tensor_scale_per_oc = ov::test::utils::create_and_fill_tensor(ov::element::f32, ov::Shape{OC, 1}, in_data);
  auto scale_per_oc = std::make_shared<ov::op::v0::Constant>(tensor_scale_per_oc);
 
  auto weight_deq = std::make_shared<ov::op::v1::Multiply>(weight_const_f32, scale_per_oc);
@@ -88,8 +85,7 @@ class LLMMLPFusionTest : public testing::WithParamInterface<LLMMLPFusionParams>,
  return std::make_shared<ov::op::v0::Constant>(tensor);
  };
  if (param.use_dynamic_quant)
- configuration.insert(
- {ov::hint::dynamic_quantization_group_size.name(), std::numeric_limits<uint64_t>::max()});
+ configuration.insert({ov::hint::dynamic_quantization_group_size.name(), std::numeric_limits<uint64_t>::max()});
 
  auto gate_weight = create_const(param.up_size, param.down_size, 100);
  auto up_weight = create_const(param.up_size, param.down_size, 100);
@@ -105,22 +101,13 @@ class LLMMLPFusionTest : public testing::WithParamInterface<LLMMLPFusionParams>,
  if (param.act_type == "Gelu")
  gate_act = std::make_shared<ov::op::v7::Gelu>(gate_proj);
 
- // Control input order based on swap_inputs parameter
- std::shared_ptr<ov::op::v1::Multiply> gate_up;
- if (param.swap_inputs) {
- // Swapped order should prevent fusion
- gate_up = std::make_shared<ov::op::v1::Multiply>(up_proj, gate_act);
- } else {
- // Normal order should allow fusion
- gate_up = std::make_shared<ov::op::v1::Multiply>(gate_act, up_proj);
- }
-
+ auto gate_up = std::make_shared<ov::op::v1::Multiply>(gate_act, up_proj);
  auto output = std::make_shared<ov::op::v0::MatMul>(gate_up, down_weight, false, true);
 
  function = std::make_shared<ov::Model>(ov::OutputVector{output}, ov::ParameterVector{src});
  }
 
- void check_fusion_result() {
+ void check_results() {
  auto exec_model = compiledModel.get_runtime_model();
 
  int fused_node_found = 0;
@@ -129,40 +116,26 @@ class LLMMLPFusionTest : public testing::WithParamInterface<LLMMLPFusionParams>,
  if (layer_type == "LLMMLP")
  fused_node_found++;
  }
-
- auto& param = this->GetParam();
- if (param.swap_inputs) {
- // When inputs are swapped, fusion should NOT happen
- ASSERT_EQ(fused_node_found, 0) << "Fusion should not occur with swapped inputs";
- } else {
- // Normal case, fusion should happen
- ASSERT_EQ(fused_node_found, 1) << "Fusion should occur with correct input order";
- }
+ ASSERT_EQ(fused_node_found, 1);
  }
 };
 
 TEST_P(LLMMLPFusionTest, CompareWithRefs) {
  if (!ov::with_cpu_x86_avx512_core_amx_bf16())
  GTEST_SKIP();
  run();
- check_fusion_result();
+ check_results();
 }
 
 namespace {
 
-static ov::test::InputShape ishape{ov::PartialShape{-1, -1, 4096 / 4},
- {ov::Shape{1, 8, 4096 / 4}, ov::Shape{5, 37, 4096 / 4}}};
+static ov::test::InputShape ishape{ov::PartialShape{-1, -1, 4096 / 4}, {ov::Shape{1, 8, 4096 / 4}, ov::Shape{5, 37, 4096 / 4}}};
 
-// Test parameters combining both normal fusion and no-fusion cases
 const std::vector<LLMMLPFusionParams> mlp_params = {
- // Normal cases - should fuse (swap_inputs = false)
- {ishape, 4096 / 4, 11008 / 4, "Gelu", false, false},
- {ishape, 4096 / 4, 11008 / 4, "Gelu", true, false},
- {ishape, 4096 / 4, 11008 / 4, "Swish", false, false},
- {ishape, 4096 / 4, 11008 / 4, "Swish", true, false},
-
- // Port order issue cases - should NOT fuse (swap_inputs = true)
- {ishape, 4096 / 4, 11008 / 4, "Gelu", false, true},
+ {ishape, 4096 / 4, 11008 / 4, "Gelu", false},
+ {ishape, 4096 / 4, 11008 / 4, "Gelu", true},
+ {ishape, 4096 / 4, 11008 / 4, "Swish", false},
+ {ishape, 4096 / 4, 11008 / 4, "Swish", true},
 };
 
 INSTANTIATE_TEST_SUITE_P(smoke_LLMMLPFusion,