mct-nightly 2.4.0.20250924.535__py3-none-any.whl → 2.4.2.20250926.532__py3-none-any.whl

model_compression_toolkit/core/common/pruning/pruning_framework_implementation.py

@@ -28,13 +28,15 @@ class PruningFrameworkImplementation(FrameworkImplementation):
     @abstractmethod
     def prune_entry_node(self,
                          node: BaseNode,
-                         output_mask: np.ndarray):
+                         output_mask: np.ndarray,
+                         fw_info: FrameworkInfo):
         """
         Abstract method to prune an entry node in the model.
 
         Args:
             node: The node to be pruned.
             output_mask: A numpy array representing the mask to be applied to the output channels.
+            fw_info: Framework-specific information.
 
         Raises:
             NotImplemented: If the method is not implemented in the subclass.
@@ -46,7 +48,8 @@ class PruningFrameworkImplementation(FrameworkImplementation):
     def prune_intermediate_node(self,
                                 node: BaseNode,
                                 input_mask: np.ndarray,
-                                output_mask: np.ndarray):
+                                output_mask: np.ndarray,
+                                fw_info: FrameworkInfo):
         """
         Abstract method to prune an intermediate node in the model.
 
@@ -54,6 +57,7 @@ class PruningFrameworkImplementation(FrameworkImplementation):
             node: The node to be pruned.
             input_mask: Mask to be applied to the input channels.
             output_mask: Mask to be applied to the output channels.
+            fw_info: Framework-specific information.
 
         Raises:
             NotImplemented: If the method is not implemented in the subclass.
@@ -64,13 +68,15 @@ class PruningFrameworkImplementation(FrameworkImplementation):
     @abstractmethod
     def prune_exit_node(self,
                         node: BaseNode,
-                        input_mask: np.ndarray):
+                        input_mask: np.ndarray,
+                        fw_info: FrameworkInfo):
         """
         Abstract method to prune an exit node in the model.
 
         Args:
             node: The node to be pruned.
             input_mask: Mask to be applied to the input channels.
+            fw_info: Framework-specific information.
 
         Raises:
             NotImplemented: If the method is not implemented in the subclass.
@@ -99,7 +105,8 @@ class PruningFrameworkImplementation(FrameworkImplementation):
     @abstractmethod
     def is_node_exit_node(self,
                           node: BaseNode,
-                          corresponding_entry_node: BaseNode) -> bool:
+                          corresponding_entry_node: BaseNode,
+                          fw_info: FrameworkInfo) -> bool:
 
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
                              f'framework\'s is_node_exit_node method.')  # pragma: no cover
@@ -122,7 +129,7 @@ class PruningFrameworkImplementation(FrameworkImplementation):
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
                              f'framework\'s is_node_intermediate_pruning_section method.')  # pragma: no cover
 
-    def attrs_oi_channels_info_for_pruning(self, node: BaseNode) -> Dict[str, Tuple[int, int]]:
+    def attrs_oi_channels_info_for_pruning(self, node: BaseNode, fw_info: FrameworkInfo) -> Dict[str, Tuple[int, int]]:
         """
         Retrieves the attributes of a given node along with the output/input (OI) channel axis
         for each attribute used to prune these attributes.
@@ -139,6 +146,7 @@ class PruningFrameworkImplementation(FrameworkImplementation):
 
         Args:
             node (BaseNode): The node from the computational graph.
+            fw_info (FrameworkInfo): Contains framework-specific information and utilities.
 
         Returns:
             Dict[str, Tuple[int, int]]: A dictionary where each key is an attribute name (like 'kernel' or 'bias')

model_compression_toolkit/core/common/pruning/pruning_section.py

@@ -76,28 +76,34 @@ class PruningSection:
 
     def apply_inner_section_mask(self,
                                  pruning_section_mask: PruningSectionMask,
-                                 fw_impl: Any):
+                                 fw_impl: Any,
+                                 fw_info: FrameworkInfo):
         """
         Apply the provided pruning section mask to all nodes within the pruning section.
 
         Args:
             pruning_section_mask (PruningSectionMask): The mask to be applied to the pruning section.
             fw_impl (PruningFrameworkImplementation): Framework-specific implementation for applying the mask.
+            fw_info (FrameworkInfo): Framework-specific information needed to apply the mask.
         """
         fw_impl.prune_entry_node(node=self.entry_node,
-                                 output_mask=pruning_section_mask.entry_node_oc_mask)
+                                 output_mask=pruning_section_mask.entry_node_oc_mask,
+                                 fw_info=fw_info)
 
         for inter_node in self.intermediate_nodes:
             fw_impl.prune_intermediate_node(node=inter_node,
                                             input_mask=pruning_section_mask.entry_node_oc_mask,
-                                            output_mask=pruning_section_mask.entry_node_oc_mask)
+                                            output_mask=pruning_section_mask.entry_node_oc_mask,
+                                            fw_info=fw_info)
 
         fw_impl.prune_exit_node(self.exit_node,
-                                input_mask=pruning_section_mask.exit_node_ic_mask)
+                                input_mask=pruning_section_mask.exit_node_ic_mask,
+                                fw_info=fw_info)
 
     @staticmethod
     def has_matching_channel_count(exit_node: BaseNode,
-                                   corresponding_entry_node: BaseNode) -> bool:
+                                   corresponding_entry_node: BaseNode,
+                                   fw_info: FrameworkInfo) -> bool:
         """
         Checks if the number of input channels of the exit node matches the number of output channels
         of its corresponding entry node.
@@ -109,10 +115,13 @@ class PruningSection:
         Returns:
             bool: True if the channel counts match, False otherwise.
         """
-        exit_input_channel_axis = exit_node.channel_axis.input
-        entry_output_channel_axis = corresponding_entry_node.channel_axis.output
+        _, exit_input_channel_axis = fw_info.kernel_channels_mapping.get(exit_node.type)
+        entry_output_channel_axis, _ = fw_info.kernel_channels_mapping.get(corresponding_entry_node.type)
 
-        exit_input_channels = exit_node.get_weights_by_keys(exit_node.kernel_attr).shape[exit_input_channel_axis]
-        entry_output_channels = corresponding_entry_node.get_weights_by_keys(corresponding_entry_node.kernel_attr).shape[entry_output_channel_axis]
+        exit_node_attr = fw_info.get_kernel_op_attributes(exit_node.type)[0]
+        entry_node_attr = fw_info.get_kernel_op_attributes(corresponding_entry_node.type)[0]
+
+        exit_input_channels = exit_node.get_weights_by_keys(exit_node_attr).shape[exit_input_channel_axis]
+        entry_output_channels = corresponding_entry_node.get_weights_by_keys(entry_node_attr).shape[entry_output_channel_axis]
 
         return exit_input_channels == entry_output_channels

model_compression_toolkit/core/common/quantization/bit_width_config.py

@@ -19,8 +19,8 @@ from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.matchers.node_matcher import BaseNodeMatcher
 from model_compression_toolkit.logger import Logger
 
-from model_compression_toolkit.core.common.graph.base_node import WeightAttrT, BaseNode
-from model_compression_toolkit.target_platform_capabilities.constants import POSITIONAL_ATTR
+from model_compression_toolkit.core.common.graph.base_node import WeightAttrT
+from model_compression_toolkit.target_platform_capabilities.constants import POS_ATTR
 
 
 @dataclass
@@ -95,7 +95,7 @@ class BitWidthConfig:
         for attr, bit_width, filter in zip (attrs, bit_widths, filters):
             self.manual_weights_bit_width_selection_list += [ManualWeightsBitWidthSelection(filter, bit_width, attr)]
 
-    def get_nodes_activation_bit_widths(self, graph: Graph) -> Dict[BaseNode, int]:
+    def get_nodes_to_manipulate_activation_bit_widths(self, graph: Graph) -> Dict:
         """
         Retrieve nodes from the graph that need their bit-widths for activation changed according to the manual bit-width selections.
 
@@ -108,7 +108,7 @@ class BitWidthConfig:
         activation_nodes_to_change_bit_width = self._construct_node_to_new_activation_bit_mapping(graph)
         return activation_nodes_to_change_bit_width
 
-    def get_nodes_weights_bit_widths(self, graph: Graph) -> Dict[BaseNode, Dict[str, int]]:
+    def get_nodes_to_manipulate_weights_bit_widths(self, graph: Graph) -> Dict:
         """
         Retrieve nodes from the graph that need their bit-widths for weights changed according to the manual bit-width selections.
 
@@ -166,7 +166,7 @@ class BitWidthConfig:
             attrs = BitWidthConfig._expand_to_list_core(filters, attrs)
         return attrs, bit_widths, filters
 
-    def _construct_node_to_new_activation_bit_mapping(self, graph) -> Dict[BaseNode, int]:
+    def _construct_node_to_new_activation_bit_mapping(self, graph) -> Dict:
         """
         Retrieve nodes from the graph that need their activation bit-widths changed according to the manual bit-width selections.
 
@@ -192,7 +192,7 @@ class BitWidthConfig:
                 unit_nodes_to_change_bit_width.update({n: manual_bit_width_selection.bit_width})
         return unit_nodes_to_change_bit_width
 
-    def _construct_node_to_new_weights_bit_mapping(self, graph) -> Dict[BaseNode, Dict[str, int]]:
+    def _construct_node_to_new_weights_bit_mapping(self, graph) -> Dict:
         """
         Retrieve nodes from the graph that need their weights bit-widths changed according to the manual bit-width selections.
 
@@ -212,7 +212,7 @@ class BitWidthConfig:
                     f"to change their bit width to {manual_bit_width_selection.bit_width}.")
 
             for n in filtered_nodes:
-                attr_to_change_bit_width = {}
+                attr_to_change_bit_width = []
                 
                 attrs_str = n.get_node_weights_attributes()
                 if len(attrs_str) == 0:
@@ -225,8 +225,8 @@ class BitWidthConfig:
                             attr.append(attr_str)
                     # this is a positional attribute, so it needs to be handled separately.
                     # Search manual_bit_width_selection's attribute that contain the POS_ATTR string.
-                    elif isinstance(attr_str, int) and POSITIONAL_ATTR in manual_bit_width_selection.attr:
-                        attr.append(POSITIONAL_ATTR)
+                    elif isinstance(attr_str, int) and POS_ATTR in manual_bit_width_selection.attr:
+                        attr.append(POS_ATTR)
                 if len(attr) == 0:
                     Logger.critical(f'The requested attribute {manual_bit_width_selection.attr} to change the bit width for {n} does not exist.')
 
@@ -239,7 +239,7 @@ class BitWidthConfig:
                                 f"Node {n} has an existing manual bit width configuration of {manual_bit_width_selection.attr}." 
                                 f"A new manual configuration request of {manual_bit_width_selection.bit_width} has been received, and the previous value is being overridden.")
 
-                attr_to_change_bit_width[manual_bit_width_selection.attr] = manual_bit_width_selection.bit_width
+                attr_to_change_bit_width.append([manual_bit_width_selection.bit_width, manual_bit_width_selection.attr])
                 unit_nodes_to_change_bit_width.update({n: attr_to_change_bit_width})
 
         return unit_nodes_to_change_bit_width

model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py

@@ -12,133 +12,72 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-import copy
-from dataclasses import dataclass, InitVar
-from typing import Callable, List, Optional
+from typing import Callable, List, Tuple
 
+from model_compression_toolkit.core import QuantizationConfig
 from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
-    NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig, ActivationQuantizationMode
+    NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import AttributeQuantizationConfig, \
+    OpQuantizationConfig
+from model_compression_toolkit.logger import Logger
 
 
-@dataclass(eq=True)
+##########################################
+# Every node holds a quantization configuration
+# for its weights quantization, and a different quantization
+# configuration for its activation quantization configuration.
+##########################################
+
 class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
     """
-    Candidate quantization configuration for a node.
+    Class for representing candidate node configuration, which includes weights and activation configuration combined.
     """
-    activation_quantization_cfg: NodeActivationQuantizationConfig
-    # TODO irena: None is passed in several places, need to check if it's handled properly or it's only passed in cases
-    #  that do not affect anything (my guess is it's the second).
-    #  I think in general it makes more sense to set it to None when there are no weights, and maybe when all weights
-    #  are unquantized, and handle it properly everywhere.
-    weights_quantization_cfg: Optional[NodeWeightsQuantizationConfig]
-
-
-# TODO irena: currently all code still looks at candidates_quantization_cfg as previously, so this is just an initial
-#  implementation. For now base config is completely separated from candidates (base config must be equal to one of the
-#  candidates, but we create a separate copy), and updating in place is allowed. Also we require quantization mode to
-#  be identical between all configs.
-@dataclass
-class NodeQuantizationConfig:
-    # quantization config for single precision
-    base_quantization_cfg: CandidateNodeQuantizationConfig
-    # quantization candidate configs for mixed precision
-    candidates_quantization_cfg: List[CandidateNodeQuantizationConfig]
-
-    validate: InitVar[bool] = True
-
-    def update_all(self, update_fn: Callable[[CandidateNodeQuantizationConfig], None], remove_duplicates: bool = True):
-        """
-        Apply update function on the base config and all candidates configs.
-
-        Args:
-            update_fn: function to apply.
-            remove_duplicates: remove duplicate candidates.
-        """
-        if self.base_quantization_cfg:
-            update_fn(self.base_quantization_cfg)
-        for cfg in self.candidates_quantization_cfg:
-            update_fn(cfg)
-        if remove_duplicates:
-            self.remove_duplicates()
 
-    def update_activation_quantization_mode(self, mode: ActivationQuantizationMode):
+    def __init__(self,
+                 qc: QuantizationConfig = None,
+                 op_cfg: OpQuantizationConfig = None,
+                 activation_quantization_cfg: NodeActivationQuantizationConfig = None,
+                 activation_quantization_fn: Callable = None,
+                 activation_quantization_params_fn: Callable = None,
+                 weights_quantization_cfg: NodeWeightsQuantizationConfig = None,
+                 weights_channels_axis: Tuple[int, int] = None,
+                 node_attrs_list: List[str] = None):
         """
-        Update activation quantization mode for the base config and all candidates configs.
 
         Args:
-            mode: quantization mode.
-        """
-        def fn(c):
-            c.activation_quantization_cfg.quant_mode = mode
-
-        self.update_all(fn)
-
-    def disable_weights_quantization(self):
-        """
-        Disable all weights quantization for the base config and all candidates configs.
-        """
-        self.update_all(lambda c: c.weights_quantization_cfg.disable_all_weights_quantization())
-
-    def get_activation_quant_mode(self) -> ActivationQuantizationMode:
-        """
-        Retrieve activation quantization mode.
-
-        Returns:
-            Activation quantization mode.
-
-        Raises:
-            ValueError if not all candidates contain the same mode.
-        """
-        self._validate_consistent_activation_quant_mode()
-        return self.base_quantization_cfg.activation_quantization_cfg.quant_mode
-
-    def remove_duplicates(self):
-        """
-        Remove duplicate candidates. First candidate among duplicates is kept, and the order is preserved.
+            qc: QuantizationConfig to create the node's config from.
+            op_cfg: OpQuantizationConfig of the node with quantizers types to use when creating node quantization configuration.
+            activation_quantization_cfg: An option to pass a NodeActivationQuantizationConfig to create a new config from.
+            activation_quantization_fn: Function to use when quantizing the node's activations.
+            activation_quantization_params_fn: Function to use when computing the threshold for quantizing a node's activations.
+            weights_quantization_cfg: An option to pass a NodeWeightsQuantizationConfig to create a new config from.
+            weights_channels_axis: Axis to quantize a node's weights attribute when quantizing per-channel.
+            node_attrs_list: A list of the node's weights attributes names.
         """
-        uniq_qcs = []
-        for qc in self.candidates_quantization_cfg:
-            if qc not in uniq_qcs:
-                uniq_qcs.append(qc)
-        self.candidates_quantization_cfg = uniq_qcs
 
-    def __post_init__(self, validate=True):
-        if validate:
-            if not any(self.base_quantization_cfg == qc for qc in self.candidates_quantization_cfg):
-                raise ValueError('Candidates should contain the base config.')
-            self._validate_consistent_activation_quant_mode()
-            self._validate_consistent_weights_quant_mode()
-        # TODO irena
-        # for now make sure they are separate objects so that one doesnt inadvertently modify the other
-        if any(self.base_quantization_cfg is qc for qc in self.candidates_quantization_cfg):
-            self.base_quantization_cfg = copy.deepcopy(self.base_quantization_cfg)
+        if activation_quantization_cfg is not None:
+            self.activation_quantization_cfg = activation_quantization_cfg
+        else:
+            if any(v is None for v in (qc, op_cfg, activation_quantization_fn, activation_quantization_params_fn)):  # pragma: no cover
+                Logger.critical(
+                    "Missing required arguments to initialize a node activation quantization configuration. "
+                    "Ensure QuantizationConfig, OpQuantizationConfig, activation quantization function, "
+                    "and parameters function are provided.")
+            self.activation_quantization_cfg = (
+                NodeActivationQuantizationConfig(qc=qc,
+                                                 op_cfg=op_cfg,
+                                                 activation_quantization_fn=activation_quantization_fn,
+                                                 activation_quantization_params_fn=activation_quantization_params_fn))
+
+        if weights_quantization_cfg is not None:
+            self.weights_quantization_cfg = weights_quantization_cfg
+        elif all(v is not None for v in (qc, op_cfg, node_attrs_list)):
+            self.weights_quantization_cfg = NodeWeightsQuantizationConfig(qc=qc,
+                                                                          op_cfg=op_cfg,
+                                                                          weights_channels_axis=weights_channels_axis,
+                                                                          node_attrs_list=node_attrs_list)
+        else:
+            self.weights_quantization_cfg = None
+            Logger.debug("Setting weights quantization config as None during CandidateNodeQuantizationConfig creation."
+                         "Notice, this should happen only for FLN nodes.")
 
-    def _validate_consistent_activation_quant_mode(self):
-        """
-        Validate that base config and all candidates configs contain identical activation quantization mode.
-
-        Raises:
-            ValueError if activation quantization mode is not consistent.
-        """
-        activation_quant_mode = self.base_quantization_cfg.activation_quantization_cfg.quant_mode
-        if any(qc.activation_quantization_cfg.quant_mode != activation_quant_mode
-               for qc in self.candidates_quantization_cfg):
-            raise ValueError('Quantization candidates with different quantization modes are not currently supported.')
-
-    def _validate_consistent_weights_quant_mode(self):
-        """
-        Validate that base config and all candidates configs contain identical weights quantization mode per attribute,
-        i.e. quantization for each attribute should either be enabled in all configs, or disabled in all configs.
-
-        Raises:
-            ValueError if weights quantization is not consistent.
-        """
-        def get_weights_mode(qc):
-            # in graph fuser weights_quantization_cfg is set to None
-            if qc.weights_quantization_cfg is None:
-                return None
-            return {attr: attr_cfg.enable_weights_quantization for attr, attr_cfg
-                    in qc.weights_quantization_cfg.get_all_weight_attrs_configs().items()}
-        if any(get_weights_mode(self.base_quantization_cfg) != get_weights_mode(qc)
-               for qc in self.candidates_quantization_cfg):
-            raise ValueError('Quantization candidates with different quantization modes are not currently supported.')

model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py

@@ -21,6 +21,7 @@ from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
     CandidateNodeQuantizationConfig
 
+
 def filter_nodes_candidates(graph: Graph):
     """
     Filters the graph's nodes candidates configuration list.
@@ -33,7 +34,7 @@ def filter_nodes_candidates(graph: Graph):
     """
     nodes = list(graph.nodes)
     for n in nodes:
-        n.quantization_cfg.candidates_quantization_cfg = filter_node_candidates(node=n)
+        n.candidates_quantization_cfg = filter_node_candidates(node=n, fw_info=graph.fw_info)
 
     return graph
 
@@ -70,7 +71,7 @@ def _filter_bit_method_dups(candidates: List[CandidateNodeQuantizationConfig],
     return final_candidates
 
 
-def filter_node_candidates(node: BaseNode) -> List[CandidateNodeQuantizationConfig]:
+def filter_node_candidates(node: BaseNode, fw_info) -> List[CandidateNodeQuantizationConfig]:
     """
     Updates a node's candidates configuration list.
     If the node's weights quantization is disabled (or it only has activations to quantize), then the updated list
@@ -80,13 +81,15 @@ def filter_node_candidates(node: BaseNode) -> List[CandidateNodeQuantizationConf
 
     Args:
         node: Node to set its quantization configurations.
+        fw_info: FrameworkInfo object with information about the specific framework's model.
 
     """
 
     filtered_candidates = copy.deepcopy(node.candidates_quantization_cfg)
     final_candidates = copy.deepcopy(node.candidates_quantization_cfg)
+    kernel_attr = fw_info.get_kernel_op_attributes(node.type)[0]
 
-    if (node.kernel_attr is None or not node.is_weights_quantization_enabled(node.kernel_attr)) and node.is_no_quantization():
+    if (kernel_attr is None or not node.is_weights_quantization_enabled(kernel_attr)) and not node.is_activation_quantization_enabled():
         # If activation quantization is disabled and the node doesn't have a kernel or doesn't quantize the kernel,
         # but for some reason the node has multiple candidates then replace it with a single dummy candidate with
         # default bit-width values.
@@ -94,17 +97,16 @@ def filter_node_candidates(node: BaseNode) -> List[CandidateNodeQuantizationConf
         single_dummy_candidate.activation_quantization_cfg.activation_n_bits = FLOAT_BITWIDTH
         single_dummy_candidate.activation_quantization_cfg.activation_quantization_method = QuantizationMethod.POWER_OF_TWO
 
-        if node.kernel_attr is not None:
-            kernel_config = single_dummy_candidate.weights_quantization_cfg.get_attr_config(node.kernel_attr)
+        if kernel_attr is not None:
+            kernel_config = single_dummy_candidate.weights_quantization_cfg.get_attr_config(kernel_attr)
             kernel_config.weights_n_bits = FLOAT_BITWIDTH
             kernel_config.weights_quantization_method = QuantizationMethod.POWER_OF_TWO
 
         final_candidates = [single_dummy_candidate]
 
-    elif node.is_no_quantization():
+    elif not node.is_activation_quantization_enabled():
         # Remove candidates that have duplicated weights candidates for node with disabled activation quantization.
         # Replacing the activation n_bits in the remained configurations with default value to prevent confusion.
-        # Set the config of the non-quantized FLN node to POWER_OF_TWO.
         seen_candidates = set()
         filtered_candidates = [candidate for candidate in filtered_candidates if
                                candidate.weights_quantization_cfg not in seen_candidates
@@ -114,17 +116,9 @@ def filter_node_candidates(node: BaseNode) -> List[CandidateNodeQuantizationConf
             c.activation_quantization_cfg.activation_n_bits = FLOAT_BITWIDTH
             c.activation_quantization_cfg.activation_quantization_method = QuantizationMethod.POWER_OF_TWO
 
-        final_candidates = _filter_bit_method_dups(filtered_candidates, node.kernel_attr)
-
-    elif node.is_fln_no_quantization() or node.is_fln_quantization():
-        # Remove candidates that have duplicated weights candidates for node with disabled activation quantization.
-        seen_candidates = set()
-        filtered_candidates = [candidate for candidate in filtered_candidates if
-                               candidate.weights_quantization_cfg not in seen_candidates
-                               and not seen_candidates.add(candidate.weights_quantization_cfg)]
-        final_candidates = _filter_bit_method_dups(filtered_candidates, node.kernel_attr)
+        final_candidates = _filter_bit_method_dups(filtered_candidates, kernel_attr)
 
-    elif node.kernel_attr is None or not node.is_weights_quantization_enabled(node.kernel_attr):
+    elif kernel_attr is None or not node.is_weights_quantization_enabled(kernel_attr):
         # TODO:
         #  To allow MP on positional weights we need to modify this to consider all weights not only kernel.
         # Remove candidates that have duplicated activation candidates for node with disabled weights quantization.
@@ -135,11 +129,11 @@ def filter_node_candidates(node: BaseNode) -> List[CandidateNodeQuantizationConf
                                and not seen_candidates.add(candidate.activation_quantization_cfg)]
 
         for c in filtered_candidates:
-            if node.kernel_attr is not None:
-                kernel_config = c.weights_quantization_cfg.get_attr_config(node.kernel_attr)
+            if kernel_attr is not None:
+                kernel_config = c.weights_quantization_cfg.get_attr_config(kernel_attr)
                 kernel_config.weights_n_bits = FLOAT_BITWIDTH
                 kernel_config.weights_quantization_method = QuantizationMethod.POWER_OF_TWO
 
-        final_candidates = _filter_bit_method_dups(filtered_candidates, node.kernel_attr)
+        final_candidates = _filter_bit_method_dups(filtered_candidates, kernel_attr)
 
     return final_candidates