Finalize first QDQ Stripping implementation

Author: v-Golubev

src/common/low_precision_transformations/include/low_precision/qdq_stripping.hpp

@@ -23,7 +23,7 @@ namespace low_precision {
 class LP_TRANSFORMATIONS_API FQStrippingTransformation : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("FQStrippingTransformation", "0", MatcherPass);
-    FQStrippingTransformation(const std::set<size_t>& levels_to_strip);
+    FQStrippingTransformation(const std::set<size_t>& levels_to_strip, bool replace_with_clamp);
 };
 
 } // namespace low_precision

src/common/low_precision_transformations/src/qdq_stripping.cpp

@@ -14,15 +14,17 @@
 #include "openvino/core/type.hpp"
 #include "openvino/op/clamp.hpp"
 #include "openvino/op/constant.hpp"
+#include "openvino/op/equal.hpp"
 #include "openvino/op/fake_quantize.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/util/log.hpp"
+#include "transformations/utils/utils.hpp"
 
 namespace ov {
 namespace pass {
 namespace low_precision {
 
-FQStrippingTransformation::FQStrippingTransformation(const std::set<size_t>& levels_to_strip) {
+FQStrippingTransformation::FQStrippingTransformation(const std::set<size_t>& levels_to_strip, bool replace_with_clamp) {
     MATCHER_SCOPE(FQStrippingTransformation);
     auto is_scalar = [](const Output<Node>& output) -> bool {
         return ov::shape_size(output.get_shape()) == 1;
@@ -43,29 +45,38 @@ FQStrippingTransformation::FQStrippingTransformation(const std::set<size_t>& lev
 
         const size_t levels = node->get_levels();
         if (!levels_to_strip.count(levels)) {
-            std::cout << "[QDQStripping] Levels " << levels << " not in strip set, skipping" << std::endl;
             return false;
         }
 
-        std::cout << "[QDQStripping] Levels " << levels << " found in strip set, proceeding with transformation"
-                  << std::endl;
-
         auto input = node->get_input_node_shared_ptr(0);
+        auto input_low = ov::as_type_ptr<ov::op::v0::Constant>(pattern_map.at(input_low_m).get_node_shared_ptr());
+        auto input_high = ov::as_type_ptr<ov::op::v0::Constant>(pattern_map.at(input_high_m).get_node_shared_ptr());
         auto output_low = ov::as_type_ptr<ov::op::v0::Constant>(pattern_map.at(output_low_m).get_node_shared_ptr());
         auto output_high = ov::as_type_ptr<ov::op::v0::Constant>(pattern_map.at(output_high_m).get_node_shared_ptr());
 
         // TODO: need to check that input and output intervals are equal
-        if (!output_low || !output_high) {
-            std::cout << "[QDQStripping] Failed to get constant output_low or output_high nodes" << std::endl;
+        if (!input_low || !input_high || !output_low || !output_high) {
+            return false;
+        }
+        auto constants_are_equal = [](const std::shared_ptr<ov::op::v0::Constant>& lhs,
+                                      const std::shared_ptr<ov::op::v0::Constant>& rhs) {
+            auto equal = ov::as_type_ptr<ov::op::v0::Constant>(ov::op::util::make_try_fold<ov::op::v1::Equal>(lhs, rhs));
+            OPENVINO_ASSERT(equal && ov::shape_size(equal->get_shape()) == 1,
+                            "constants_are_equal expects scalar constant as a comparison result");
+            return equal->get_vector<bool>()[0] == true;
+        };
+        if (!constants_are_equal(input_low, output_low) || !constants_are_equal(input_high, output_high)) {
             return false;
         }
 
-        auto clamp = std::make_shared<ov::op::v0::Clamp>(input->output(0),
-                                                         output_low->cast_vector<double>()[0],
-                                                         output_high->cast_vector<double>()[0]);
-        std::cout << "[ INFO ] clamp low = " << clamp->get_min() << ", high = " << clamp->get_max() << std::endl;
-
-        return replace_node_update_name(node, clamp);
+        if (replace_with_clamp) {
+            auto clamp = std::make_shared<ov::op::v0::Clamp>(input->output(0),
+                                                             output_low->cast_vector<double>()[0],
+                                                             output_high->cast_vector<double>()[0]);
+            return replace_node_update_name(node, clamp);
+        } else {
+            return replace_output_update_name(node->output(0), node->input_value(0));
+        }
     };
 
     auto m = std::make_shared<ov::pass::pattern::Matcher>(fq_m, matcher_name);

src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp

@@ -166,7 +166,6 @@ ov::pass::ConvertQuantizeDequantize::ConvertQuantizeDequantize(
 
         copy_runtime_info({fq, convert1.get_node_shared_ptr(), convert2.get_node_shared_ptr()}, new_fq);
         replace_node(mul, new_fq);
-        std::cout << "[ INFO ] ConvertQuantizeDequantize is finished for node " << new_fq->get_friendly_name() << std::endl;
 
         return true;
     };

src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp

@@ -24,6 +24,7 @@
 #include "low_precision/fold_convert.hpp"
 #include "low_precision/fuse_convert.hpp"
 #include "low_precision/group_convolution.hpp"
+#include "low_precision/qdq_stripping.hpp"
 #include "low_precision/low_precision.hpp"
 #include "low_precision/mat_mul.hpp"
 #include "low_precision/multiply_to_group_convolution.hpp"
@@ -390,6 +391,17 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
 
         auto is_model_quantized = ov::pass::low_precision::LowPrecision::isFunctionQuantized(func);
         enableInt8 = config.get_enable_lp_transformations() && is_model_quantized;
+        {
+            using namespace ov::pass::low_precision;
+            // QDQ stripping pipeline
+            // 1. Transform DQ part to canonicalized form: Multiply->Add => Subtract->Multiply
+            manager.register_pass<AddTransformation>();
+            // 2. Fuse FQ->Convert->DQ to a single FQ
+            manager.register_pass<ov::pass::ConvertQuantizeDequantize>(ov::element::TypeVector{ov::element::i16, ov::element::u16});
+            // 3. Strip FQ layers with unsupported levels
+            bool replace_with_clamp = false;
+            manager.register_pass<FQStrippingTransformation>(std::set<size_t>{levels::int16}, replace_with_clamp);
+        }
 
         manager.register_pass<ov::pass::MarkDequantization>(
             std::vector<ov::element::Type>{ ov::element::i8, ov::element::u8, ov::element::i4, ov::element::u4 },