[CPU][ACL] LPT transformations are enabled + FQ decomposition (#28981)

### Details:
- It depends on #28870
so this PR should be merged after
 - LPT is enabled on ARM
- ARM LPT transformation pipeline is separated from common LPT
transformation pipeline
 - FQ is decomposed to avoid reference code

### Tickets:
 - CVS-162444

Author: alvoron

src/plugins/intel_cpu/src/config.h

@@ -89,7 +89,7 @@ struct Config {
     bool enableNodeSplit = false;
     bool enableHyperThreading = true;
     bool changedHyperThreading = false;
-#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
+#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) || defined(OPENVINO_ARCH_ARM64)
     LPTransformsMode lpTransformsMode = LPTransformsMode::On;
 #else
     // Currently INT8 mode is not optimized on ARM / RISCV or other non-x86 platforms, fallback to FP32 mode.

src/plugins/intel_cpu/src/graph_optimizer.cpp

@@ -82,8 +82,8 @@ void GraphOptimizer::ApplyCommonGraphOptimizations(Graph& graph) {
     FuseMultiplyAndAdd(graph);
     graph.RemoveDroppedNodes();
 
-    OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, "MergeConvertAndScaleShift");
-    MergeConvertAndScaleShift(graph);
+    OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, "MergeConvertAndEltwise");
+    MergeConvertAndEltwise(graph);
     graph.RemoveDroppedNodes();
 
     OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, "FuseFCAndConvertOnWeights");
@@ -166,6 +166,10 @@ void GraphOptimizer::ApplyCommonGraphOptimizations(Graph& graph) {
     FuseEltwiseAndSimple(graph);
     graph.RemoveDroppedNodes();
 
+    OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, "MergeEltwiseAndConvert");
+    MergeEltwiseAndConvert(graph);
+    graph.RemoveDroppedNodes();
+
     OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, "reshapeRnnSeq");
     reshapeRnnSeq(graph);
     graph.RemoveDroppedNodes();
@@ -680,12 +684,61 @@ void GraphOptimizer::FuseMultiplyAndAdd(Graph& graph) {
     }
 }
 
-void GraphOptimizer::MergeConvertAndScaleShift(Graph& graph) {
+void GraphOptimizer::MergeEltwiseAndConvert(Graph& graph) {
+// The pass is enabled on arm platforms only, however it might be usefull for other platforms as well
+// It requires additional perf validation. Ticket: 163388
+#if !defined(OPENVINO_ARCH_ARM64)
+    return;
+#endif
+    auto& graphNodes = graph.GetNodes();
+
+    auto parent = graphNodes.begin();
+    while (parent != graphNodes.end()) {
+        CPU_GRAPH_OPTIMIZER_SCOPE(MergeEltwiseAndConvert);
+        auto parentNode = *parent;
+        if (parentNode->getType() != Type::Eltwise) {
+            parent++;
+            continue;
+        }
+
+        const auto& childEdges = parentNode->getChildEdges();
+        if (childEdges.size() != 1) {
+            parent++;
+            continue;
+        }
+
+        const auto edge = childEdges[0].lock();
+        auto childNode = edge->getChild();
+        if (childNode->getType() != Type::Convert) {
+            parent++;
+            continue;
+        }
+
+        const auto eltwise = dynamic_cast<ov::intel_cpu::node::Eltwise*>(parentNode.get());
+        if (!eltwise->canFuseConvert(childNode)) {
+            parent++;
+            continue;
+        }
+
+        // WA: Eltwise node uses precision of last fused node as output precision
+        auto fusedOps = parentNode->getFusedWith();
+        if (!fusedOps.empty()) {
+            fusedOps[fusedOps.size() - 1]->setOriginalOutputPrecisionAtPort(
+                0,
+                childNode->getOriginalOutputPrecisionAtPort(0));
+        }
+        parentNode->setOriginalOutputPrecisionAtPort(0, childNode->getOriginalOutputPrecisionAtPort(0));
+        parentNode->addOriginalLayer(childNode->getOriginalLayers());
+        graph.DropNode(childNode);
+    }
+}
+
+void GraphOptimizer::MergeConvertAndEltwise(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto parent = graphNodes.begin();
     while (parent != graphNodes.end()) {
-        CPU_GRAPH_OPTIMIZER_SCOPE(MergeConvertAndScaleShift);
+        CPU_GRAPH_OPTIMIZER_SCOPE(MergeConvertAndEltwise);
         auto parentNode = *parent;
         if (parentNode->getType() != Type::Convert) {
             parent++;

src/plugins/intel_cpu/src/graph_optimizer.h

@@ -23,7 +23,8 @@ class GraphOptimizer {
     void FuseConvolutionMatMulDeconvAndBias(Graph& graph);
     void FuseDeconvolutionAndSimpleOperation(Graph& graph);
     void FuseMultiplyAndAdd(Graph& graph);
-    void MergeConvertAndScaleShift(Graph& graph);
+    void MergeEltwiseAndConvert(Graph& graph);
+    void MergeConvertAndEltwise(Graph& graph);
     void FuseFCAndConvertOnWeights(Graph& graph);
     void FuseFCAndTransposeOnWeights(Graph& graph);
     void FuseFullyConnectedAndSimpleOperation(Graph& graph);

src/plugins/intel_cpu/src/nodes/eltwise.cpp

@@ -2277,6 +2277,23 @@ bool Eltwise::canFuseParent(const NodePtr& parentNode) const {
     return true;
 }
 
+bool Eltwise::canFuseConvert(const NodePtr& convertNode) const {
+    if (!one_of(convertNode->getOriginalOutputPrecisionAtPort(0),
+                ov::element::i8,
+                ov::element::u8,
+                ov::element::f16,
+                ov::element::bf16,
+                ov::element::f32)) {
+        return false;
+    }
+// Convert can be fused into Eltwise only if jit implementation is supported
+#if defined(OPENVINO_ARCH_ARM64)
+    return jitIsSupported(this, getAlpha(), getBeta(), getGamma());
+#else
+    return false;
+#endif
+}
+
 bool Eltwise::canFuse(const NodePtr& node) const {
     auto isIntegerComputeSupported = [](const Node* node) {
         if (!one_of(node->getAlgorithm(),

src/plugins/intel_cpu/src/nodes/eltwise.h

@@ -43,6 +43,7 @@ class Eltwise : public Node {
     void execute(const dnnl::stream& strm) override;
     bool created() const override;
     bool canBeInPlace() const override;
+    bool canFuseConvert(const NodePtr& convertNode) const;
     bool canFuseParent(const NodePtr& parentNode) const;
     bool canFuse(const NodePtr& node) const override;
     void appendPostOps(dnnl::post_ops& ops,

src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp

@@ -115,15 +115,24 @@
 
 // LPT transformations
 #include "low_precision/add.hpp"
+#include "low_precision/avg_pool.hpp"
 #include "low_precision/convert_subtract_constant.hpp"
 #include "low_precision/convolution_backprop_data.hpp"
 #include "low_precision/fold_convert.hpp"
 #include "low_precision/fuse_convert.hpp"
 #include "low_precision/group_convolution.hpp"
+#include "low_precision/interpolate.hpp"
 #include "low_precision/mat_mul.hpp"
+#include "low_precision/max_pool.hpp"
 #include "low_precision/multiply_to_group_convolution.hpp"
+#include "low_precision/mvn.hpp"
 #include "low_precision/network_helper.hpp"
+#include "low_precision/normalize_l2.hpp"
 #include "low_precision/recurrent_cell.hpp"
+#include "low_precision/reduce_max.hpp"
+#include "low_precision/reduce_mean.hpp"
+#include "low_precision/reduce_min.hpp"
+#include "low_precision/reduce_sum.hpp"
 #include "low_precision/rt_info/bias_attribute.hpp"
 #include "transformations/low_precision/mark_dequantization_subgraph.hpp"
 
@@ -159,6 +168,7 @@
 #include "snippets/pass/explicit_transpose_matmul_inputs.hpp"
 #include "snippets/pass/extract_reshapes_from_mha.hpp"
 #include "snippets/pass/fc_tokenization.hpp"
+#include "snippets/pass/fq_decomposition.hpp"
 #include "snippets/pass/mha_tokenization.hpp"
 #include "snippets/pass/split_dimension_m.hpp"
 #include "snippets/pass/tokenization.hpp"
@@ -422,7 +432,7 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
     if (config.inferencePrecision == ov::element::f16) {
         precisions_map fp_convert_precision_map = {{ov::element::f32, ov::element::f16}};
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
-        type_to_fuse_map fuse_map = {{ov::opset1::FakeQuantize::get_type_info_static(), fuse_type_to_fq}};
+        type_to_fuse_map fuse_map = {};
 #else
         type_to_fuse_map fuse_map = {{ov::op::PagedAttentionExtension::get_type_info_static(), fuse_type_to_pa}};
 #endif
@@ -764,12 +774,58 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
     manager.run_passes(model);
 }
 
-void Transformations::Lpt(const std::vector<ov::element::Type>& defaultPrecisions) {
-    CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(this, Lpt);
-
+void Transformations::runLptPasses(const std::vector<ov::element::Type>& defaultPrecisions) {
     using namespace ov::pass::low_precision;
-    CPU_LPT_SCOPE(LowPrecisionTransformations_Part4);
-    OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "LowPrecisionTransformations");
+    ov::pass::Manager lptManager("CPU:LPT");
+#if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
+    auto supportedPrecisions = std::vector<PrecisionsRestriction>({
+        PrecisionsRestriction::create<ov::opset1::MatMul>({{{0, 1}, {ov::element::i8}}}),
+    });
+
+    auto quantizationRestrictions = std::vector<QuantizationGranularityRestriction>();
+
+    CPU_REGISTER_PASS_COMMON(lptManager,
+                             LowPrecision,
+                             supportedPrecisions,
+                             quantizationRestrictions,
+                             LayerTransformation::Params(true, ov::element::f32, defaultPrecisions));
+    CPU_DISABLE_PASS_COMMON(lptManager, AvgPoolTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, ConvolutionTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, ConvolutionBackpropDataTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, InterpolateTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, GroupConvolutionTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, MaxPoolTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, MVNTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, NormalizeL2Transformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, RecurrentCellTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, ReduceMaxTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, ReduceMeanTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, ReduceMinTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, ReduceSumTransformation);
+    CPU_DISABLE_PASS_COMMON(lptManager, MultiplyToGroupConvolutionTransformation);
+
+    CPU_SET_CALLBACK_COMMON(
+        lptManager,
+        [](const_node_ptr& node) -> bool {
+            return ov::marked_as_bias(node);
+        },
+        AddTransformation);
+
+    // Enable MatMulTransformation against FC nodes only
+    // int8 MatMul is disabled because acl_lowp_matmul_t supports 2D case only
+    // most models have 3D/4D cases, so fallback to jit_gemm_i8 gives worse perf than gemm_acl_f16
+    // oneDNN ticket #2696
+    CPU_SET_CALLBACK_COMMON(
+        lptManager,
+        [&](const_node_ptr& node) -> bool {
+            if (NetworkHelper::isConstantPath(node->get_input_node_shared_ptr(1)) &&
+                one_of(node->input_value(1).get_partial_shape().rank().get_length(), 2, 3)) {
+                return false;
+            }
+            return true;
+        },
+        MatMulTransformation);
+#else
     // Only enable conv/group conv signed input on AMX and avx2_vnni_2 platform.
     std::vector<ov::element::Type> input0LowPrecisionList;
     if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx) ||
@@ -807,7 +863,6 @@ void Transformations::Lpt(const std::vector<ov::element::Type>& defaultPrecision
         {QuantizationGranularityRestriction::create<ov::opset1::Convolution>({0}),
          QuantizationGranularityRestriction::create<ov::opset1::ConvolutionBackpropData>({0})});
 
-    ov::pass::Manager lptManager("CPU:LPT");
     CPU_REGISTER_PASS_COMMON(lptManager,
                              LowPrecision,
                              supportedPrecisions,
@@ -857,27 +912,20 @@ void Transformations::Lpt(const std::vector<ov::element::Type>& defaultPrecision
         },
         FuseConvertTransformation);
 
-    // Enable MatMulTransformation against FC nodes only
-    // int8 MatMul is disabled because acl_lowp_matmul_t supports 2D case only
-    // most models have 3D/4D cases, so fallback to jit_gemm_i8 gives worse perf than gemm_acl_f16
-    // oneDNN ticket #2696
-    CPU_SET_CALLBACK_ARM(
-        lptManager,
-        [&](const_node_ptr& node) -> bool {
-            if (NetworkHelper::isConstantPath(node->get_input_node_shared_ptr(1)) &&
-                one_of(node->input_value(1).get_partial_shape().rank().get_length(), 2, 3)) {
-                return false;
-            }
-            return true;
-        },
-        MatMulTransformation);
-
-    CPU_DISABLE_PASS_ARM(lptManager, RecurrentCellTransformation);
     CPU_DISABLE_PASS_COMMON(lptManager, MultiplyToGroupConvolutionTransformation);
-
+#endif
     lptManager.run_passes(model);
 }
 
+void Transformations::Lpt(const std::vector<ov::element::Type>& defaultPrecisions) {
+    CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(this, Lpt);
+
+    CPU_LPT_SCOPE(LowPrecisionTransformations_Part4);
+    OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "LowPrecisionTransformations");
+
+    runLptPasses(defaultPrecisions);
+}
+
 void Transformations::PostLpt() {
     CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(this, PostLpt);
 
@@ -997,6 +1045,19 @@ void Transformations::PostLpt() {
 }
 
 void Transformations::MainSnippets(void) {
+// Disable MainSnippets for int8 models on arm platforms due to performance issues
+// Ticket: 163408
+#if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
+    using namespace ov::pass::low_precision;
+    static const std::set<levels>& supported_fq_levels = {levels::int4,
+                                                          levels::int4_narrow_range,
+                                                          levels::int8,
+                                                          levels::int8_narrow_range};
+    if (LowPrecision::isFunctionQuantized(model, supported_fq_levels)) {
+        return;
+    }
+#endif
+
     auto is_supported_isa = []() {
 #if defined(OPENVINO_ARCH_X86_64)
         return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2);
@@ -1342,7 +1403,7 @@ void Transformations::PostSnippets(void) {
     ov::pass::Manager postSnippetsManager("CPU:PostSnippets");
     postSnippetsManager.set_per_pass_validation(false);
     CPU_REGISTER_PASS_COMMON(postSnippetsManager, ov::pass::FakeQuantizeDecomposition);
-    CPU_SET_CALLBACK_COMMON(
+    CPU_SET_CALLBACK_X64(
         postSnippetsManager,
         [](const_node_ptr& node) -> bool {
             std::string errMsg;

src/plugins/intel_cpu/src/transformations/transformation_pipeline.h

@@ -38,6 +38,7 @@ class Transformations {
     void PreLpt(const std::vector<ov::element::Type>& defaultPrecisions);
 
     void Lpt(const std::vector<ov::element::Type>& defaultPrecisions);
+    void runLptPasses(const std::vector<ov::element::Type>& defaultPrecisions);
 
     void MainSnippets(void);
 

src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/stateful_init_graph.cpp

@@ -217,7 +217,6 @@ class InitGraphStatefulDiffPrimitiveModel : public InitGraphStatefulModelBase {
 
         configuration.insert({"SNIPPETS_MODE", "DISABLE"});
 
-        bool directPair;
         std::tie(inputShapes, directPair) = this->GetParam();
 
         init_input_shapes(inputShapes);
@@ -250,12 +249,24 @@ class InitGraphStatefulDiffPrimitiveModel : public InitGraphStatefulModelBase {
     }
 
     void check_init_graph_node() override {
+#if defined(OPENVINO_ARCH_ARM64)
+        // Convert node is fused into Eltwise on arm platforms
+        if (directPair) {
+            CheckNumberOfNodesWithType(compiledModel, "Convert", 0);
+        } else {
+            CheckNumberOfNodesWithType(compiledModel, "Convert", 1);
+        }
+#else
         CheckNumberOfNodesWithType(compiledModel, "Convert", 1);
+#endif
     }
 
     ov::Shape get_state_shape(size_t i) override {
         return inputShapes[0].second[i];
     }
+
+private:
+    bool directPair;
 };
 
 TEST_P(InitGraphStatefulDiffPrimitiveModel, CompareWithRefs) {