[Solver] Move most of quantizer_config into the QuantizerConfig itself (#3559)

### Changes

Most QuantizerConfig logic is moved to the QuantizerConfig class

### Reason for changes

To separate logic of QuantizerConfig from the Solver to make it easier
to process new QuantizerConfigs in future

Author: daniil-lyakhov

nncf/common/quantization/quantizer_propagation/graph.py

@@ -43,7 +43,6 @@
 from nncf.common.quantization.quantizer_setup import QuantizationInsertionPointBase
 from nncf.common.quantization.quantizer_setup import QuantizationPointId
 from nncf.common.quantization.quantizer_setup import WeightQuantizationInsertionPoint
-from nncf.common.quantization.structs import QuantizationScheme as QuantizationMode
 from nncf.common.quantization.structs import QuantizerConfig
 from nncf.common.quantization.structs import UnifiedScaleType
 from nncf.common.scopes import should_consider_scope
@@ -1155,25 +1154,7 @@ def is_downstream_quantizer_redundant(
             assert len(us_configs) == 1
             ds_config = ds_configs[0]
             us_config = us_configs[0]
-            is_redundant = True
-            is_redundant = is_redundant and (ds_config.num_bits == us_config.num_bits)
-
-            # Avoid asymmetric quantization if a symmetrically quantized tensor arrived
-            is_redundant = is_redundant and (
-                (ds_config.mode == us_config.mode)
-                or (ds_config.mode == QuantizationMode.ASYMMETRIC and us_config.mode == QuantizationMode.SYMMETRIC)
-            )
-
-            # Avoid per-channel quantization if a per-tensor-quantized tensor arrived
-            is_redundant = is_redundant and (
-                (ds_config.per_channel == us_config.per_channel)
-                or (ds_config.per_channel is True and us_config.per_channel is False)
-            )
-
-            # Strictly prohibit merging of config with different narrow_range params
-            is_redundant = is_redundant and (ds_config.narrow_range == us_config.narrow_range)
-
-            return is_redundant
+            return us_config.is_redundant_with_downstream_qconfig(ds_config)
 
         def merge_traverse_fn(
             curr_node_key: str, affecting_pq_and_prev_node_key: tuple[Optional[PropagatingQuantizer], str]

nncf/common/quantization/quantizer_propagation/solver.py

@@ -155,23 +155,9 @@ def finalize(
             else:
                 final_qconfig = final_quantizer_setup.quantization_points[qp_id].qconfig
                 if strict:
-
-                    def is_final_qconfig_compatible_to_initial(initial_qconfig: QuantizerConfig) -> bool:
-                        return (
-                            final_qconfig.per_channel == initial_qconfig.per_channel
-                            and final_qconfig.mode == initial_qconfig.mode
-                            and final_qconfig.num_bits == initial_qconfig.num_bits
-                            and final_qconfig.narrow_range == initial_qconfig.narrow_range
-                            and (
-                                final_qconfig.signedness_to_force == initial_qconfig.signedness_to_force
-                                or initial_qconfig.signedness_to_force is None
-                                or final_qconfig.signedness_to_force is None
-                            )
-                        )
-
                     compatible_initial_qconfs = list(
                         filter(
-                            is_final_qconfig_compatible_to_initial,
+                            final_qconfig.is_compatible_with,
                             self.quantizer_setup.quantization_points[qp_id].possible_qconfigs,
                         )
                     )
@@ -1511,33 +1497,6 @@ def __disambiguate_config_list(
         list. Quantization configs could not contain different narrow range parameters, so it does
         not participate in __lt__ method of the QConfigComparator.
         """
-
-        class QConfigComparator:
-            def __init__(self, qconfig: QuantizerConfig):
-                self.qconfig = qconfig
-
-            def __lt__(self, other: "QConfigComparator") -> bool:
-                # Prefer higher bitwidths, per-tensor, symmetrical
-                if self.qconfig.num_bits > other.qconfig.num_bits:
-                    return True
-                if self.qconfig.num_bits < other.qconfig.num_bits:
-                    return False
-                if self.qconfig.per_channel is False and other.qconfig.per_channel is True:
-                    return True
-                if self.qconfig.per_channel is True and other.qconfig.per_channel is False:
-                    return False
-                if (
-                    self.qconfig.mode is QuantizationMode.SYMMETRIC
-                    and other.qconfig.mode is QuantizationMode.ASYMMETRIC
-                ):
-                    return True
-                if (
-                    self.qconfig.mode is QuantizationMode.ASYMMETRIC
-                    and other.qconfig.mode is QuantizationMode.SYMMETRIC
-                ):
-                    return False
-                return False
-
         slices_to_sort = []
 
         if len(qconfig_list_with_priority) > 1:
@@ -1554,12 +1513,11 @@ def __lt__(self, other: "QConfigComparator") -> bool:
             if last_idx - curr_priority_start_idx > 0:
                 slices_to_sort.append(slice(curr_priority_start_idx, last_idx + 1))
 
-        list_to_sort = [QConfigComparator(x[0]) for x in qconfig_list_with_priority]
+        list_to_sort = [x[0] for x in qconfig_list_with_priority]
         for slice_obj in slices_to_sort:
             list_to_sort[slice_obj] = sorted(list_to_sort[slice_obj])
 
-        retval = [x.qconfig for x in list_to_sort]
-        return retval
+        return list_to_sort
 
     def get_finished_propagating_quantizers(self) -> list[PropagatingQuantizer]:
         """

nncf/common/quantization/structs.py

@@ -98,6 +98,71 @@ def __str__(self) -> str:
     def __hash__(self) -> int:
         return hash(str(self))
 
+    def __lt__(self, other: "QuantizerConfig") -> bool:
+        # Prefer higher bitwidths, per-tensor, symmetrical
+        if self.num_bits > other.num_bits:
+            return True
+        if self.num_bits < other.num_bits:
+            return False
+        if self.per_channel is False and other.per_channel is True:
+            return True
+        if self.per_channel is True and other.per_channel is False:
+            return False
+        if self.mode is QuantizationScheme.SYMMETRIC and other.mode is QuantizationScheme.ASYMMETRIC:
+            return True
+        if self.mode is QuantizationScheme.ASYMMETRIC and other.mode is QuantizationScheme.SYMMETRIC:
+            return False
+        return False
+
+    def is_redundant_with_downstream_qconfig(self, downstream_qconfig: "QuantizerConfig") -> bool:
+        """
+        Returns True if the two quantizers placed immediately one after another are redundant and could be
+        replaced with a single quantizer.
+
+        :param downstream_qconfig: QuantizerConfig of a quantizer placed immediately after the quantizer
+            with the current QuantizerConfig.
+        :return: True if the two quantizers placed immediately one after another are redundant and could be
+            replaced with a single quantizer.
+        """
+        is_redundant = downstream_qconfig.num_bits == self.num_bits
+
+        # Avoid asymmetric quantization if a symmetrically quantized tensor arrived
+        is_redundant = is_redundant and (
+            (downstream_qconfig.mode == self.mode)
+            or (downstream_qconfig.mode == QuantizationScheme.ASYMMETRIC and self.mode == QuantizationScheme.SYMMETRIC)
+        )
+
+        # Avoid per-channel quantization if a per-tensor-quantized tensor arrived
+        is_redundant = is_redundant and (
+            (downstream_qconfig.per_channel == self.per_channel)
+            or (downstream_qconfig.per_channel is True and self.per_channel is False)
+        )
+
+        # Strictly prohibit merging of config with different narrow_range params
+        is_redundant = is_redundant and (downstream_qconfig.narrow_range == self.narrow_range)
+        return is_redundant
+
+    def is_compatible_with(self, other: "QuantizerConfig") -> bool:
+        """
+        Return True if the current QuantizerConfig and the other QuantizerConfig
+        do not contradict each other.
+
+        :param other: The QuantizerConfig to compare with.
+        :return: True if the current QuantizerConfig and the other QuantizerConfig
+            do not contradict each other.
+        """
+        return (
+            self.per_channel == other.per_channel
+            and self.mode == other.mode
+            and self.num_bits == other.num_bits
+            and self.narrow_range == other.narrow_range
+            and (
+                self.signedness_to_force == other.signedness_to_force
+                or other.signedness_to_force is None
+                or self.signedness_to_force is None
+            )
+        )
+
     def is_valid_requantization_for(self, other: "QuantizerConfig") -> bool:
         """
         Quantizer config A is a valid requantization for quantizer config B if A is more strict -