Added a new pattern in pattern matcher

Author: Kadian

src/plugins/intel_npu/src/plugin/npuw/partitioning/partitioning.cpp

@@ -1622,6 +1622,8 @@ void Partitioner::decompressionCutOff(const std::string& func_name) {
         // LLaMaGPTQ
         rewr.add_matcher<ov::npuw::patterns::SymmZP::DCOFFPassReshape2>(dcoff_mode, dcoff_type, std::ref(params_to));
 
+        rewr.add_matcher<ov::npuw::patterns::SymmZP::DCOFFPassCWAI3>(dcoff_mode, dcoff_type, std::ref(params_to));
+
         rewr.run_on_model(f._model);
 
         ov::pass::Validate val;

src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.cpp

@@ -512,6 +512,88 @@ DCOFFPassReshape2::DCOFFPassReshape2(DCOffMode dcoff_mode, ov::element::Type dco
     register_matcher(std::make_shared<opp::Matcher>(reshpe, "TagDCOFFReshape2"), std::move(callback));
 }
 
+// Pattern: Phi-3 4SymW16A/GPTQ for CWAI
+//
+// FIXME: Think how it can be unified with the above
+//
+//   "tensor"       "scale"           >            "tensor"
+//    Param:A       Param:C           >             Param:A
+//      i4          f16|f32           >              f16
+//       :           :                >               :
+//       V          :                 >               V
+//     Convert     :                  >              Convert     
+//     f16|f32    :                   >                f32
+//        :      :                    >
+//        V      V                    >
+//        Multiply                    >
+//         f16|f32                    >
+//            :                       >
+//            :                       >
+//            V                       >
+//         Convert
+
+DCOFFPassCWAI3::DCOFFPassCWAI3(DCOffMode dcoff_mode, ov::element::Type dcoff_type, DCOFFParamRef pref) {
+    auto paramA = opp::wrap_type<ov::op::v0::Parameter>();
+    auto paramC = opp::wrap_type<ov::op::v0::Parameter>();
+    auto cvtA   = opp::wrap_type<ov::op::v0::Convert>({paramA});
+    auto mulply = opp::wrap_type<ov::op::v1::Multiply>({cvtA, paramC});
+    auto cvt    = opp::wrap_type<ov::op::v0::Convert>({mulply});
+    
+    auto callback = [=](ov::pass::pattern::Matcher& m) {
+        auto& node_to_output = m.get_pattern_value_map();
+        auto matched_nodeA = node_to_output.at(paramA).get_node_shared_ptr();
+        auto matched_nodeC = node_to_output.at(paramC).get_node_shared_ptr();
+
+        NPUW_ASSERT(ov::op::util::is_parameter(matched_nodeA));
+        NPUW_ASSERT(ov::op::util::is_parameter(matched_nodeC));
+
+        auto matched_paramA = std::static_pointer_cast<ov::op::v0::Parameter>(matched_nodeA);
+        auto matched_paramC = std::static_pointer_cast<ov::op::v0::Parameter>(matched_nodeC);
+
+        if (ov::element::i4 == matched_paramA->get_element_type() &&
+            (ov::element::f16 == matched_paramC->get_element_type() ||
+             ov::element::f32 == matched_paramC->get_element_type())) {
+            LOG_DEBUG("Matched: " << matched_paramA << ", set element type to " << dcoff_type);
+            matched_paramA->set_element_type(dcoff_type);
+
+            if (dcoff_mode == DCOffMode::CAST_SCALE) {
+                NPUW_ASSERT(dcoff_type == ov::element::f16);
+
+                LOG_DEBUG("Matched: " << matched_paramC << " - parameter to remove...");
+                LOG_BLOCK();
+
+                // Extra transformation here:
+                // - remove Multiply + Intermediate Convert
+                // - mark paramC for removal.
+                // Convert will be reconnected to paramA directly.
+
+                pref.get().scales[matched_paramC] = std::move(matched_paramA);
+                // Disconnect Multiply and Convert from their outputs
+                auto matched_mulply = node_to_output.at(mulply).get_node_shared_ptr();
+                auto matched_convrt = node_to_output.at(cvtA).get_node_shared_ptr();
+                auto drop_outputs = [](std::shared_ptr<ov::Node> node) {
+                    for (auto&& node_outputs : node->outputs()) {
+                        for (auto&& node_reader_port : node_outputs.get_target_inputs()) {
+                            node_outputs.remove_target_input(node_reader_port);
+                        }
+                    }
+                };
+                LOG_DEBUG("Dropping the connections...");
+                drop_outputs(std::move(matched_mulply));
+                drop_outputs(std::move(matched_convrt));
+
+                LOG_DEBUG("Reconnecting the Root...");
+                auto matched_cvt = node_to_output.at(cvt).get_node_shared_ptr();
+                matched_cvt->input(0).replace_source_output(matched_paramA);
+            }
+            LOG_DEBUG("Done");
+        }
+        return false; // root node hasn't changed
+    };
+
+    register_matcher(std::make_shared<opp::Matcher>(cvt, "TagDCOFFPassCWAI3"), std::move(callback));
+}
+
 //------------------------------------------------------------------------------
 // Pattern: 4SymW16A for CWAI
 //

src/plugins/intel_npu/src/plugin/npuw/partitioning/patterns/dcoff.hpp

@@ -129,6 +129,11 @@ class DCOFFPassReshape2 : public ov::pass::MatcherPass {
     DCOFFPassReshape2(DCOffMode dcoff_mode, ov::element::Type dcoff_type, DCOFFParamRef pref);
 };
 
+class DCOFFPassCWAI3 : public ov::pass::MatcherPass {
+public:
+    DCOFFPassCWAI3(DCOffMode dcoff_mode, ov::element::Type dcoff_type, DCOFFParamRef pref);
+};
+
 class CWAI1 : public ov::pass::MatcherPass {
 public:
     using CPtr = std::shared_ptr<ov::op::v0::Constant>;