mct-nightly 2.3.0.20250325.524__py3-none-any.whl → 2.3.0.20250327.514__py3-none-any.whl

{mct_nightly-2.3.0.20250325.524.dist-info → mct_nightly-2.3.0.20250327.514.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250325.524
+Version: 2.3.0.20250327.514
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

{mct_nightly-2.3.0.20250325.524.dist-info → mct_nightly-2.3.0.20250327.514.dist-info}/RECORD

@@ -1,6 +1,6 @@
-mct_nightly-2.3.0.20250325.524.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=QA19v194uXWUuLFh_Bg-8ll7InFUcGC8RGNV-Gi7qcc,1557
-model_compression_toolkit/constants.py,sha256=i_R6uXBfO1ph_X6DNJych2x59SUojfJbn7dNjs_mZnc,3846
+mct_nightly-2.3.0.20250327.514.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=kFad6b1992lrDWgleUg7OrJ6tqRaPUdWmvgibttVDTE,1557
+model_compression_toolkit/constants.py,sha256=2ltuH-gdaLZoZV4CPUgKjC3S9ojz2z4OTVdenyVEypU,3912
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
 model_compression_toolkit/metadata.py,sha256=x_Bk4VpzILdsFax6--CZ3X18qUTP28sbF_AhoQW8dNc,4003
@@ -40,7 +40,7 @@ model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=GH5wStmw8SoAj5IdT_-ItN1Meo_P5NUTt_5bgJC4fak,3935
 model_compression_toolkit/core/common/graph/graph_matchers.py,sha256=CrDoHYq4iPaflgJWmoJ1K4ziLrRogJvFTVWg8P0UcDU,4744
 model_compression_toolkit/core/common/graph/graph_searches.py,sha256=2oKuW6L8hP-oL0lFO9PhQFt9fEFgVJwpc1u4fHExAtE,5128
-model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py,sha256=gPlGMyC5jdUTQy8jYU_Rz7cPXSH6JhV4Dnwt3-1FAKM,9849
+model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py,sha256=JH33qnHTaqFXcYSzTVMpDc9N93503y2pY3hiVJELuZI,10704
 model_compression_toolkit/core/common/graph/memory_graph/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/core/common/graph/memory_graph/bipartite_graph.py,sha256=X6FK3C3y8ixFRPjC_wm3ClloCX8_06SOdA1TRi7o_LA,3800
 model_compression_toolkit/core/common/graph/memory_graph/compute_graph_max_cut.py,sha256=oyz260JXDbvL8aI-DVtUvLHtLRWC2Yu4SBYlGL68c2Y,3498
@@ -101,7 +101,7 @@ model_compression_toolkit/core/common/pruning/mask/__init__.py,sha256=huHoBUcKNB
 model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py,sha256=77DB1vqq_gHwbUjeCHRaq1Q-V4wEtdVdwkGezcZgToA,5021
 model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py,sha256=_LcDAxLeC5I0KdMHS8jib5XxIKO2ZLavXYuSMIPIQBo,5868
 model_compression_toolkit/core/common/quantization/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
-model_compression_toolkit/core/common/quantization/bit_width_config.py,sha256=YfZKUUeqRp5K5W6wmTOcFZR-MhxdbmtpC8k7IVXU_j4,4666
+model_compression_toolkit/core/common/quantization/bit_width_config.py,sha256=0HA3CIZW-ZrA55ra-yJXRvAYnoR8i1SjpbnMDKcWYNQ,12819
 model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py,sha256=u7uueixA5wi3eYPrZKtLVxogkmgcgFL1w2pzMfd_ToU,4950
 model_compression_toolkit/core/common/quantization/core_config.py,sha256=yxCzWqldcHoe8GGxrH0tp99bhrc5jDT7SgZftnMUUBE,2374
 model_compression_toolkit/core/common/quantization/debug_config.py,sha256=zJP2W9apUPX9RstpPWWK71wr9xJsg7j-s7lGV4_bQdc,1510
@@ -112,7 +112,7 @@ model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,
 model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py,sha256=7eG7dl1TcbdnHwgmvyjarxLs0o6Lw_9VAjXAm4rsiBk,3791
 model_compression_toolkit/core/common/quantization/quantize_graph_weights.py,sha256=N005MSvx8UypVpa7XrxNrB2G732n2wHj3RmLyjTgd3I,2728
 model_compression_toolkit/core/common/quantization/quantize_node.py,sha256=cdzGNWfT4MRogIU8ehs0tr3lVjnzAI-jeoS9b4TwVBo,2854
-model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=mR6kNfjz6s6EnJJd0ZeUzcjP1qq8w16YRtenTq9OtyQ,21330
+model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=u0pVJawyUTgatn2L8qMNBac2Cut3HSPZSytBGDuBB0k,21341
 model_compression_toolkit/core/common/quantization/quantization_params_generation/__init__.py,sha256=eCDGwsWYLU6z7qbEVb4TozMW_nd5VEP_iCJ6PcvyEPw,1486
 model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py,sha256=_m-XkEMJMHf0gYwVIXAoHVjdRa2NXt_gYdwBlw76ZR8,24031
 model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=RL-PklAjGyC-26anSt8fU07a6pB_LBQFQy9o4e9giN0,8739
@@ -526,7 +526,7 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=UVN_S9ULHBEldBpShCOt8-soT8YTQ5oE362y96qF_FA,3950
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.3.0.20250325.524.dist-info/METADATA,sha256=AhiPNPdqyMvdK9V7IcGS0EUifEcnl9RhI_IsME0A5-U,27098
-mct_nightly-2.3.0.20250325.524.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
-mct_nightly-2.3.0.20250325.524.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250325.524.dist-info/RECORD,,
+mct_nightly-2.3.0.20250327.514.dist-info/METADATA,sha256=K55wi2oh756TtflrXc2PsNWrzPqiTzTRWMoylK-kILk,27098
+mct_nightly-2.3.0.20250327.514.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mct_nightly-2.3.0.20250327.514.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250327.514.dist-info/RECORD,,

{mct_nightly-2.3.0.20250325.524.dist-info → mct_nightly-2.3.0.20250327.514.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.0.2)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.3.0.20250325.000524"
+__version__ = "2.3.0.20250327.000514"

model_compression_toolkit/constants.py

@@ -57,6 +57,8 @@ FLOAT_BITWIDTH = 32
 # In Mixed-Precision, a node can have multiple candidates for weights and activations quantization configuration.
 # In order to display a single view of a node (for example, for logging in TensorBoard) we need to track the attributes
 # that are shared among different candidates:
+WEIGHTS_ATTRIBUTE = 'weights'
+ACTIVATION_ATTRIBUTE = 'activation'
 WEIGHTS_NBITS_ATTRIBUTE = 'weights_n_bits'
 CORRECTED_BIAS_ATTRIBUTE = 'corrected_bias'
 ACTIVATION_N_BITS_ATTRIBUTE = 'activation_n_bits'

model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+import uuid
 
 from typing import Dict, Any, Tuple
 
@@ -139,23 +140,34 @@ class VirtualActivationWeightsNode(BaseNode):
         """
         # Validate weights node
         kernel_attrs = fw_info.get_kernel_op_attributes(weights_node.type)
-        assert len(kernel_attrs) == 1 and kernel_attrs[0] is not None, 'Expected exactly one kernel attr.'
+        assert len(kernel_attrs) == 1 and kernel_attrs[0] is not None, f'Expected exactly one kernel attr, {kernel_attrs}'
         kernel_attr = kernel_attrs[0]
         conf_weights = [attr for attr in weights_node.weights if weights_node.is_configurable_weight(attr)]
         if len(conf_weights) > 1 or len(conf_weights) == 1 and not weights_node.is_configurable_weight(kernel_attr):
-            raise NotImplementedError('Only kernel weight can be configurable.')    # pragma: no cover
+            raise NotImplementedError(f'Only kernel weight can be configurable. Got configurable {conf_weights}.')
 
-        weights = weights_node.weights
+        weights = weights_node.weights.copy()
+        act_node_w_rename = {}
         if act_node.weights:
-            assert fw_info.get_kernel_op_attributes(act_node)[0] is None, \
-                f'Node {act_node} with kernel cannot be used as activation for VirtualActivationWeightsNode.'
-            if set(weights_node.weights.keys()).intersection(set(act_node.weights.keys())):
-                raise ValueError('Activation and weight nodes are not expected to have the same weight attribute')    # pragma: no cover
+            if not fw_info.get_kernel_op_attributes(act_node)[0] is None:
+                raise NotImplementedError(f'Node {act_node} with kernel cannot be used as activation for '
+                                          f'VirtualActivationWeightsNode.')
             if act_node.has_any_configurable_weight():
-                raise NotImplementedError('Node with a configurable weight cannot be used as activation for '
-                                          'VirtualActivationWeightsNode.')    # pragma: no cover
+                raise NotImplementedError(f'Node {act_node} with a configurable weight cannot be used as activation for '
+                                          'VirtualActivationWeightsNode.')
             # combine weights from activation and weights
-            weights.update(act_node.weights)
+            for w_id, w in act_node.weights.items():
+                if w_id not in weights and not (isinstance(w_id, str) and kernel_attr in w_id):
+                    weights[w_id] = w
+                    continue
+                # if same identifier is used as in weight nodes (or contains the kernel substring), generate a new
+                # unique id. If positional, generate a new (and clearly made up) index.
+                # This only serves for resource utilization computation so in theory this shouldn't matter, as long as
+                # quantization config dict keys are updated accordingly.
+                uniq_id = uuid.uuid4().hex[:8] if isinstance(w_id, str) else (100 + w_id)
+                assert uniq_id not in weights
+                act_node_w_rename[w_id] = uniq_id
+                weights[uniq_id] = w
 
         name = f"{VIRTUAL_ACTIVATION_WEIGHTS_NODE_PREFIX}_{act_node.name}_{weights_node.name}"
         super().__init__(name,
@@ -181,10 +193,12 @@ class VirtualActivationWeightsNode(BaseNode):
                 if act_node.weights:
                     # add non-kernel weights cfg from activation node to the composed node's weights cfg
                     composed_candidate.weights_quantization_cfg.attributes_config_mapping.update(
-                        c_a.weights_quantization_cfg.attributes_config_mapping
+                        {act_node_w_rename.get(k, k): v
+                         for k, v in c_a.weights_quantization_cfg.attributes_config_mapping.items()}
                     )
                     composed_candidate.weights_quantization_cfg.pos_attributes_config_mapping.update(
-                        c_a.weights_quantization_cfg.pos_attributes_config_mapping
+                        {act_node_w_rename.get(k, k): v
+                         for k, v in c_a.weights_quantization_cfg.pos_attributes_config_mapping.items()}
                     )
                 v_candidates.append(composed_candidate)
 

model_compression_toolkit/core/common/quantization/bit_width_config.py

@@ -19,19 +19,31 @@ 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
 
 @dataclass
 class ManualBitWidthSelection:
     """
-   Class to encapsulate the manual bit width selection configuration for a specific filter.
+    Class to encapsulate the manual bit width selection configuration for a specific filter.
 
-   Attributes:
+    Attributes:
        filter (BaseNodeMatcher): The filter used to select nodes for bit width manipulation.
        bit_width (int): The bit width to be applied to the selected nodes.
-   """
+    """
     filter: BaseNodeMatcher
     bit_width: int
 
+@dataclass
+class ManualWeightsBitWidthSelection(ManualBitWidthSelection):
+    """
+    Class to encapsulate the manual weights bit width selection configuration for a specific filter.
+
+    Attributes:
+       filter (BaseNodeMatcher): The filter used to select nodes for bit width manipulation.
+       bit_width (int): The bit width to be applied to the selected nodes.
+       attr (str): The filtered node's attributes to apply bit-width manipulation to.
+    """
+    attr: WeightAttrT
 
 @dataclass
 class BitWidthConfig:
@@ -39,35 +51,64 @@ class BitWidthConfig:
     Class to manage manual bit-width configurations.
 
     Attributes:
-        manual_activation_bit_width_selection_list (List[ManualBitWidthSelection]): A list of ManualBitWidthSelection objects defining manual bit-width configurations.
+        manual_activation_bit_width_selection_list (List[ManualBitWidthSelection]): A list of ManualBitWidthSelection objects for activation defining manual bit-width configurations.
+        manual_weights_bit_width_selection_list (List[ManualWeightsBitWidthSelection]): A list of ManualWeightsBitWidthSelection for weights objects defining manual bit-width configurations.
     """
     manual_activation_bit_width_selection_list: List[ManualBitWidthSelection] = field(default_factory=list)
+    manual_weights_bit_width_selection_list: List[ManualWeightsBitWidthSelection] = field(default_factory=list)
 
     def set_manual_activation_bit_width(self,
-                                        filters: Union[List[BaseNodeMatcher], BaseNodeMatcher],
-                                        bit_widths: Union[List[int], int]):
+                                            filters: Union[List[BaseNodeMatcher], BaseNodeMatcher],
+                                            bit_widths: Union[List[int], int]):
         """
-        Add a manual bit-width selection to the configuration.
+        Add a manual bit-width selection for activation to the configuration.
 
         Args:
-            filter (Union[List[BaseNodeMatcher], BaseNodeMatcher]): The filters used to select nodes for bit-width manipulation.
-            bit_width (Union[List[int], int]): The bit widths to be applied to the selected nodes.
+            filters (Union[List[BaseNodeMatcher], BaseNodeMatcher]): The filters used to select nodes for bit-width manipulation.
+            bit_widths (Union[List[int], int]): The bit widths to be applied to the selected nodes.
             If a single value is given it will be applied to all the filters
         """
-        filters = [filters] if not isinstance(filters, list) else filters
-        bit_widths = [bit_widths] if not isinstance(bit_widths, list) else bit_widths
-        if len(bit_widths) > 1 and len(bit_widths) != len(filters):
-            Logger.critical(f"Configuration Error: The number of provided bit_width values {len(bit_widths)} "
-                            f"must match the number of filters {len(filters)}, or a single bit_width value "
-                            f"should be provided for all filters.")
-        elif len(bit_widths) == 1 and len(filters) > 1:
-            bit_widths = [bit_widths[0] for f in filters]
+        if filters is None:
+            Logger.critical(f"The filters cannot be None.")
+        _, bit_widths, filters = self._expand_to_list(filters, bit_widths)
         for bit_width, filter in zip (bit_widths, filters):
             self.manual_activation_bit_width_selection_list += [ManualBitWidthSelection(filter, bit_width)]
 
-    def get_nodes_to_manipulate_bit_widths(self, graph: Graph) -> Dict:
+    def set_manual_weights_bit_width(self,
+                                        filters: Union[List[BaseNodeMatcher], BaseNodeMatcher],
+                                        bit_widths: Union[List[int], int],
+                                        attrs: Union[List[WeightAttrT], WeightAttrT]):
+        """
+        Add a manual bit-width selection for weights to the configuration.
+
+        Args:
+            filters (Union[List[BaseNodeMatcher], BaseNodeMatcher]): The filters used to select nodes for bit-width manipulation.
+            bit_widths (Union[List[int], int]): The bit widths for specified by attrs to be applied to the selected nodes.
+            attrs (Union[List[WeightAttrT], WeightAttrT]): The filtered node's attributes to apply bit-width manipulation to.
+            If a single value is given it will be applied to all the filters
+        """
+        if filters is None:
+            Logger.critical(f"The filters cannot be None.")
+        attrs, bit_widths, filters = self._expand_to_list(filters, bit_widths, attrs)
+        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_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.
+
+        Args:
+            graph (Graph): The graph containing the nodes to be filtered and manipulated.
+
+        Returns:
+            Dict: A dictionary mapping nodes to their new bit-widths.
+        """
+        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_to_manipulate_weights_bit_widths(self, graph: Graph) -> Dict:
         """
-        Retrieve nodes from the graph that need their bit-widths changed according to the manual bit-width selections.
+        Retrieve nodes from the graph that need their bit-widths for weights changed according to the manual bit-width selections.
 
         Args:
             graph (Graph): The graph containing the nodes to be filtered and manipulated.
@@ -75,16 +116,127 @@ class BitWidthConfig:
         Returns:
             Dict: A dictionary mapping nodes to their new bit-widths.
         """
-        nodes_to_change_bit_width = {}
+        weights_nodes_to_change_bit_width = self._construct_node_to_new_weights_bit_mapping(graph)
+        return weights_nodes_to_change_bit_width
+
+    @staticmethod
+    def _expand_to_list_core(
+            filters: Union[List[BaseNodeMatcher], BaseNodeMatcher],
+            vals: Union[List[Union[WeightAttrT, int]], Union[WeightAttrT, int]]) -> list:
+        """
+        Extend the length of vals to match the length of filters.
+
+        Args:
+            filters (Union[List[BaseNodeMatcher], BaseNodeMatcher]): The filters used to select nodes for bit-width manipulation.
+            vals Union[List[Union[WeightAttrT, int], Union[WeightAttrT, int]]]): The bit widths or The filtered node's attributes.
+
+        Returns:
+            list: Extended vals to match the length of filters.
+        """
+        vals = [vals] if not isinstance(vals, list) else vals
+        if len(vals) > 1 and len(vals) != len(filters):
+            Logger.critical(f"Configuration Error: The number of provided bit_width values {len(vals)} "
+                            f"must match the number of filters {len(filters)}, or a single bit_width value "
+                            f"should be provided for all filters.")
+        elif len(vals) == 1 and len(filters) > 1:
+            vals = [vals[0] for f in filters]
+        return vals
+
+    @staticmethod
+    def _expand_to_list(
+            filters: Union[List[BaseNodeMatcher]],
+            bit_widths: Union[List[int], int],
+            attrs: Union[List[WeightAttrT], WeightAttrT] = None) -> [List]:
+        """
+        Extend the length of filters, bit-widths and The filtered node's attributes to match the length of filters.
+
+        Args:
+            filters (Union[List[BaseNodeMatcher], BaseNodeMatcher]): The filters used to select nodes for bit-width manipulation.
+            bit_widths (Union[List[int], int]): The bit widths for specified by attrs to be applied to the selected nodes.
+            attrs (Union[List[WeightAttrT], WeightAttrT]): The filtered node's attributes to apply bit-width manipulation to.
+
+        Returns:
+            [List]: A List of extended input arguments.
+        """
+        filters = [filters] if not isinstance(filters, list) else filters
+        bit_widths = BitWidthConfig._expand_to_list_core(filters, bit_widths)
+        if attrs is not None:
+            attrs = BitWidthConfig._expand_to_list_core(filters, attrs)
+        return attrs, bit_widths, filters
+
+    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.
+
+        Args:
+            graph (Graph): The graph containing the nodes to be filtered and manipulated.
+
+        Returns:
+            Dict: A dictionary retrieved nodes from the graph.
+        """
+        unit_nodes_to_change_bit_width = {}
         for manual_bit_width_selection in self.manual_activation_bit_width_selection_list:
             filtered_nodes = graph.filter(manual_bit_width_selection.filter)
             if len(filtered_nodes) == 0:
-                Logger.critical(f"Node Filtering Error: No nodes found in the graph for filter {manual_bit_width_selection.filter.__dict__} "
-                                f"to change their bit width to {manual_bit_width_selection.bit_width}.")
+                Logger.critical(
+                    f"Node Filtering Error: No nodes found in the graph for filter {manual_bit_width_selection.filter.__dict__} "
+                    f"to change their bit width to {manual_bit_width_selection.bit_width}.")
             for n in filtered_nodes:
                 # check if a manual configuration exists for this node
-                if n in nodes_to_change_bit_width:
+                if n in unit_nodes_to_change_bit_width:
                     Logger.info(
-                        f"Node {n} has an existing manual bit width configuration of {nodes_to_change_bit_width.get(n)}. A new manual configuration request of {manual_bit_width_selection.bit_width} has been received, and the previous value is being overridden.")
-                nodes_to_change_bit_width.update({n: manual_bit_width_selection.bit_width})
-        return nodes_to_change_bit_width
+                        f"Node {n} has an existing manual bit width configuration of {unit_nodes_to_change_bit_width.get(n)}." 
+                        f"A new manual configuration request of {manual_bit_width_selection.bit_width} has been received, and the previous value is being overridden.")
+                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:
+        """
+        Retrieve nodes from the graph that need their weights bit-widths changed according to the manual bit-width selections.
+
+        Args:
+            graph (Graph): The graph containing the nodes to be filtered and manipulated.
+
+        Returns:
+            Dict: A dictionary retrieved nodes from the graph.
+        """
+        unit_nodes_to_change_bit_width = {}
+
+        for manual_bit_width_selection in self.manual_weights_bit_width_selection_list:
+            filtered_nodes = graph.filter(manual_bit_width_selection.filter)
+            if len(filtered_nodes) == 0:
+                Logger.critical(
+                    f"Node Filtering Error: No nodes found in the graph for filter {manual_bit_width_selection.filter.__dict__} "
+                    f"to change their bit width to {manual_bit_width_selection.bit_width}.")
+
+            for n in filtered_nodes:
+                attr_to_change_bit_width = []
+                
+                attrs_str = n.get_node_weights_attributes()
+                if len(attrs_str) == 0:
+                    Logger.critical(f'The requested attribute {manual_bit_width_selection.attr} to change the bit width for {n} does not exist.')
+
+                attr = []
+                for attr_str in attrs_str:
+                    if isinstance(attr_str, str) and isinstance(manual_bit_width_selection.attr, str):
+                        if attr_str.find(manual_bit_width_selection.attr) != -1:
+                            attr.append(attr_str)
+                    elif isinstance(attr_str, int) and isinstance(manual_bit_width_selection.attr, int):
+                        if attr_str == manual_bit_width_selection.attr:
+                            attr.append(attr_str)
+                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.')
+
+                if n in unit_nodes_to_change_bit_width:
+                    attr_to_change_bit_width = unit_nodes_to_change_bit_width[n]
+                    for i, attr_to_bitwidth in enumerate(attr_to_change_bit_width):
+                        if attr_to_bitwidth[1] == manual_bit_width_selection.attr:
+                            del attr_to_change_bit_width[i]
+                            Logger.info(
+                                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.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/set_node_quantization_config.py

@@ -65,7 +65,7 @@ def set_quantization_configuration_to_graph(graph: Graph,
         Logger.warning("Using the HMSE error method for weights quantization parameters search. "
                        "Note: This method may significantly increase runtime during the parameter search process.")
 
-    nodes_to_manipulate_bit_widths = {} if bit_width_config is None else bit_width_config.get_nodes_to_manipulate_bit_widths(graph)
+    nodes_to_manipulate_bit_widths = {} if bit_width_config is None else bit_width_config.get_nodes_to_manipulate_activation_bit_widths(graph)
 
     for n in graph.nodes:
         set_quantization_configs_to_node(node=n,