mct-nightly 2.2.0.20250113.527__tar.gz → 2.2.0.20250114.84821__tar.gz

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/PKG-INFO

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

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/mct_nightly.egg-info/PKG-INFO

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

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/mct_nightly.egg-info/SOURCES.txt

@@ -81,9 +81,8 @@ model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_aggregation_methods.py
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_functions_mapping.py
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/ru_methods.py
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py
 model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py
@@ -445,31 +444,30 @@ model_compression_toolkit/target_platform_capabilities/schema/__init__.py
 model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py
 model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py
 model_compression_toolkit/target_platform_capabilities/schema/v1.py
-model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/__init__.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attach2fw.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attach2keras.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attach2pytorch.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attribute_filter.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/current_tpc.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/layer_filter_params.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/operations_to_layers.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/target_platform_capabilities.py
-model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/target_platform_capabilities_component.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/__init__.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2fw.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attribute_filter.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/current_tpc.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities_component.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/layer_filter_params.py
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/operations_to_layers.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/get_target_platform_capabilities.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/latest/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/__init__.py
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tp_model.py
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tpc.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/latest/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/__init__.py
-model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tp_model.py
+model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tpc.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/latest/__init__.py
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/__init__.py
-model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tp_model.py
+model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tpc.py
 model_compression_toolkit/trainable_infrastructure/__init__.py
 model_compression_toolkit/trainable_infrastructure/common/__init__.py
 model_compression_toolkit/trainable_infrastructure/common/annealing_schedulers.py

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/__init__.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 
 from model_compression_toolkit.defaultdict import DefaultDict
-from model_compression_toolkit.target_platform_capabilities import target_platform
+from model_compression_toolkit import target_platform_capabilities
 from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import get_target_platform_capabilities
 from model_compression_toolkit import core
 from model_compression_toolkit.logger import set_log_folder
@@ -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.2.0.20250113.000527"
+__version__ = "2.2.0.20250114.084821"

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/core/common/framework_info.py

@@ -18,10 +18,8 @@ from collections.abc import Callable
 from enum import Enum
 from typing import Dict, Any, List
 
-
-
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.defaultdict import DefaultDict
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 
 
 class ChannelAxis(Enum):

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/core/common/fusion/layer_fusing.py

@@ -16,8 +16,9 @@ import copy
 from typing import Any, List
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.layer_filter_params import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.layer_filter_params import LayerFilterParams
 
 
 def filter_fusing_patterns(fusing_patterns: List[List[Any]], node: BaseNode, idx: int = 0) -> List[List[Any]]:
@@ -77,18 +78,18 @@ def disable_nodes_activation_quantization(nodes: List[BaseNode]):
             qc.activation_quantization_cfg.enable_activation_quantization = False
 
 
-def fusion(graph: Graph, tpc: TargetPlatformCapabilities) -> Graph:
+def fusion(graph: Graph, fqc: FrameworkQuantizationCapabilities) -> Graph:
     """
     Fusing defines a list of operators that should be combined and treated as a single operator,
     hence no quantization is applied between them when they appear in the graph.
     This function search and disable quantization for such patterns.
     Args:
         graph: Graph we apply the fusion on.
-        tpc: TargetPlatformCapabilities object that describes the desired inference target platform (includes fusing patterns MCT should handle).
+        fqc: FrameworkQuantizationCapabilities object that describes the desired inference target platform (includes fusing patterns MCT should handle).
     Returns:
         Graph after applying fusion activation marking.
     """
-    fusing_patterns = tpc.get_fusing_patterns()
+    fusing_patterns = fqc.get_fusing_patterns()
     if len(fusing_patterns) == 0:
         return graph
 

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/core/common/graph/base_graph.py

@@ -32,8 +32,9 @@ from model_compression_toolkit.core.common.collectors.statistics_collector impor
 from model_compression_toolkit.core.common.pruning.pruning_section import PruningSection
 from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import \
-    TargetPlatformCapabilities, LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 OutTensor = namedtuple('OutTensor', 'node node_out_index')
 
@@ -86,29 +87,29 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         self.fw_info = fw_info
 
-    def set_tpc(self,
-                tpc: TargetPlatformCapabilities):
+    def set_fqc(self,
+                fqc: FrameworkQuantizationCapabilities):
         """
-        Set the graph's TPC.
+        Set the graph's FQC.
         Args:
-            tpc: TargetPlatformCapabilities object.
+            fqc: FrameworkQuantizationCapabilities object.
         """
-        # validate graph nodes are either from the framework or a custom layer defined in the TPC
-        # Validate graph nodes are either built-in layers from the framework or custom layers defined in the TPC
-        tpc_layers = tpc.op_sets_to_layers.get_layers()
-        tpc_filtered_layers = [layer for layer in tpc_layers if isinstance(layer, LayerFilterParams)]
+        # validate graph nodes are either from the framework or a custom layer defined in the FQC
+        # Validate graph nodes are either built-in layers from the framework or custom layers defined in the FQC
+        fqc_layers = fqc.op_sets_to_layers.get_layers()
+        fqc_filtered_layers = [layer for layer in fqc_layers if isinstance(layer, LayerFilterParams)]
         for n in self.nodes:
-            is_node_in_tpc = any([n.is_match_type(_type) for _type in tpc_layers]) or \
-                             any([n.is_match_filter_params(filtered_layer) for filtered_layer in tpc_filtered_layers])
+            is_node_in_fqc = any([n.is_match_type(_type) for _type in fqc_layers]) or \
+                             any([n.is_match_filter_params(filtered_layer) for filtered_layer in fqc_filtered_layers])
             if n.is_custom:
-                if not is_node_in_tpc:
+                if not is_node_in_fqc:
                     Logger.critical(f'MCT does not support optimizing Keras custom layers. Found a layer of type {n.type}. '
-                                    ' Please add the custom layer to Target Platform Capabilities (TPC), or file a feature '
+                                    ' Please add the custom layer to Framework Quantization Capabilities (FQC), or file a feature '
                                     'request or an issue if you believe this should be supported.')  # pragma: no cover
-                if any([qc.default_weight_attr_config.enable_weights_quantization for qc in n.get_qco(tpc).quantization_configurations]):
+                if any([qc.default_weight_attr_config.enable_weights_quantization for qc in n.get_qco(fqc).quantization_configurations]):
                     Logger.critical(f'Layer identified: {n.type}. MCT does not support weight quantization for Keras custom layers.')  # pragma: no cover
 
-        self.tpc = tpc
+        self.fqc = fqc
 
     def get_topo_sorted_nodes(self):
         """
@@ -544,10 +545,8 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         potential_conf_nodes = [n for n in list(self) if fw_info.is_kernel_op(n.type)]
 
         def is_configurable(n):
-            kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
-            return (n.is_weights_quantization_enabled(kernel_attr) and
-                    not n.is_all_weights_candidates_equal(kernel_attr) and
-                    (not n.reuse or include_reused_nodes))
+            kernel_attrs = fw_info.get_kernel_op_attributes(n.type)
+            return any(n.is_configurable_weight(attr) for attr in kernel_attrs) and (not n.reuse or include_reused_nodes)
 
         return [n for n in potential_conf_nodes if is_configurable(n)]
 
@@ -576,7 +575,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         Returns:
             A list of nodes that their activation can be configured (namely, has one or more activation qc candidate).
         """
-        return [n for n in list(self) if n.is_activation_quantization_enabled() and not n.is_all_activation_candidates_equal()]
+        return [n for n in list(self) if n.has_configurable_activation()]
 
     def get_sorted_activation_configurable_nodes(self) -> List[BaseNode]:
         """

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/core/common/graph/base_node.py

@@ -25,7 +25,9 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import QuantizationConfigOptions, \
     OpQuantizationConfig
 from model_compression_toolkit.target_platform_capabilities.schema.schema_functions import max_input_activation_n_bits
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities, LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 class BaseNode:
@@ -150,6 +152,27 @@ class BaseNode:
 
         return False
 
+    def is_configurable_weight(self, attr_name: str) -> bool:
+        """
+        Checks whether the specific weight attribute has a configurable quantization.
+
+        Args:
+            attr_name: weight attribute name.
+
+        Returns:
+            Whether the weight attribute is configurable.
+        """
+        return self.is_weights_quantization_enabled(attr_name) and not self.is_all_weights_candidates_equal(attr_name)
+
+    def has_configurable_activation(self) -> bool:
+        """
+        Checks whether the activation has a configurable quantization.
+
+        Returns:
+            Whether the activation has a configurable quantization.
+        """
+        return self.is_activation_quantization_enabled() and not self.is_all_activation_candidates_equal()
+
     def __repr__(self):
         """
 
@@ -420,11 +443,15 @@ class BaseNode:
 
         Returns: Output size.
         """
-        output_shapes = self.output_shape if isinstance(self.output_shape, List) else [self.output_shape]
+        # shape can be tuple or list, and multiple shapes can be packed in list or tuple
+        if self.output_shape and isinstance(self.output_shape[0], (tuple, list)):
+            output_shapes = self.output_shape
+        else:
+            output_shapes = [self.output_shape]
 
         # remove batch size (first element) from output shape
         output_shapes = [s[1:] for s in output_shapes]
-
+        # for scalar shape (None,) prod returns 1
         return sum([np.prod([x for x in output_shape if x is not None]) for output_shape in output_shapes])
 
     def find_min_candidates_indices(self) -> List[int]:
@@ -536,34 +563,34 @@ class BaseNode:
         # the inner method would log an exception.
         return [c.weights_quantization_cfg.get_attr_config(attr) for c in self.candidates_quantization_cfg]
 
-    def get_qco(self, tpc: TargetPlatformCapabilities) -> QuantizationConfigOptions:
+    def get_qco(self, fqc: FrameworkQuantizationCapabilities) -> QuantizationConfigOptions:
         """
         Get the QuantizationConfigOptions of the node according
-        to the mappings from layers/LayerFilterParams to the OperatorsSet in the TargetPlatformModel.
+        to the mappings from layers/LayerFilterParams to the OperatorsSet in the TargetPlatformCapabilities.
 
         Args:
-            tpc: TPC to extract the QuantizationConfigOptions for the node.
+            fqc: FQC to extract the QuantizationConfigOptions for the node.
 
         Returns:
             QuantizationConfigOptions of the node.
         """
 
-        if tpc is None:
-            Logger.critical(f'Can not retrieve QC options for None TPC')  # pragma: no cover
+        if fqc is None:
+            Logger.critical(f'Can not retrieve QC options for None FQC')  # pragma: no cover
 
-        for fl, qco in tpc.filterlayer2qco.items():
+        for fl, qco in fqc.filterlayer2qco.items():
             if self.is_match_filter_params(fl):
                 return qco
         # Extract qco with is_match_type to overcome mismatch of function types in TF 2.15
-        matching_qcos = [_qco for _type, _qco in tpc.layer2qco.items() if self.is_match_type(_type)]
+        matching_qcos = [_qco for _type, _qco in fqc.layer2qco.items() if self.is_match_type(_type)]
         if matching_qcos:
             if all([_qco == matching_qcos[0] for _qco in matching_qcos]):
                 return matching_qcos[0]
             else:
                 Logger.critical(f"Found duplicate qco types for node '{self.name}' of type '{self.type}'!")  # pragma: no cover
-        return tpc.tp_model.default_qco
+        return fqc.tpc.default_qco
 
-    def filter_node_qco_by_graph(self, tpc: TargetPlatformCapabilities,
+    def filter_node_qco_by_graph(self, fqc: FrameworkQuantizationCapabilities,
                                  next_nodes: List, node_qc_options: QuantizationConfigOptions
                                  ) -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig]]:
         """
@@ -573,7 +600,7 @@ class BaseNode:
         filters out quantization config that don't comply to these attributes.
 
         Args:
-            tpc: TPC to extract the QuantizationConfigOptions for the next nodes.
+            fqc: FQC to extract the QuantizationConfigOptions for the next nodes.
             next_nodes: Output nodes of current node.
             node_qc_options: Node's QuantizationConfigOptions.
 
@@ -584,7 +611,7 @@ class BaseNode:
         _base_config = node_qc_options.base_config
         _node_qc_options = node_qc_options.quantization_configurations
         if len(next_nodes):
-            next_nodes_qc_options = [_node.get_qco(tpc) for _node in next_nodes]
+            next_nodes_qc_options = [_node.get_qco(fqc) for _node in next_nodes]
             next_nodes_supported_input_bitwidth = min([max_input_activation_n_bits(op_cfg)
                                                        for qc_opts in next_nodes_qc_options
                                                        for op_cfg in qc_opts.quantization_configurations])
@@ -593,7 +620,7 @@ class BaseNode:
             _node_qc_options = [_option for _option in _node_qc_options
                                 if _option.activation_n_bits <= next_nodes_supported_input_bitwidth]
             if len(_node_qc_options) == 0:
-                Logger.critical(f"Graph doesn't match TPC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
+                Logger.critical(f"Graph doesn't match FQC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
 
             # Verify base config match
             if any([node_qc_options.base_config.activation_n_bits > max_input_activation_n_bits(qc_opt.base_config)
@@ -603,9 +630,9 @@ class BaseNode:
                 if len(_node_qc_options) > 0:
                     output_act_bitwidth = {qco.activation_n_bits: i for i, qco in enumerate(_node_qc_options)}
                     _base_config = _node_qc_options[output_act_bitwidth[max(output_act_bitwidth)]]
-                    Logger.warning(f"Node {self} base quantization config changed to match Graph and TPC configuration.\nCause: {self} -> {next_nodes}.")
+                    Logger.warning(f"Node {self} base quantization config changed to match Graph and FQC configuration.\nCause: {self} -> {next_nodes}.")
                 else:
-                    Logger.critical(f"Graph doesn't match TPC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
+                    Logger.critical(f"Graph doesn't match FQC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
 
         return _base_config, _node_qc_options
 

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py

@@ -17,18 +17,19 @@ import numpy as np
 from model_compression_toolkit.core import ResourceUtilization, FrameworkInfo
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 def filter_candidates_for_mixed_precision(graph: Graph,
                                           target_resource_utilization: ResourceUtilization,
                                           fw_info: FrameworkInfo,
-                                          tpc: TargetPlatformCapabilities):
+                                          fqc: FrameworkQuantizationCapabilities):
     """
     Filters out candidates in case of mixed precision search for only weights or activation compression.
     For instance, if running only weights compression - filters out candidates of activation configurable nodes
     such that only a single candidate would remain, with the bitwidth equal to the one defined in the matching layer's
-    base config in the TPC.
+    base config in the FQC.
 
     Note: This function modifies the graph inplace!
 
@@ -36,7 +37,7 @@ def filter_candidates_for_mixed_precision(graph: Graph,
         graph: A graph representation of the model to be quantized.
         target_resource_utilization: The resource utilization of the target device.
         fw_info: fw_info: Information needed for quantization about the specific framework.
-        tpc: TargetPlatformCapabilities object that describes the desired inference target platform.
+        fqc: FrameworkQuantizationCapabilities object that describes the desired inference target platform.
 
     """
 
@@ -50,7 +51,7 @@ def filter_candidates_for_mixed_precision(graph: Graph,
         weights_conf = graph.get_weights_configurable_nodes(fw_info)
         activation_configurable_nodes = [n for n in graph.get_activation_configurable_nodes() if n not in weights_conf]
         for n in activation_configurable_nodes:
-            base_cfg_nbits = n.get_qco(tpc).base_config.activation_n_bits
+            base_cfg_nbits = n.get_qco(fqc).base_config.activation_n_bits
             filtered_conf = [c for c in n.candidates_quantization_cfg if
                              c.activation_quantization_cfg.enable_activation_quantization and
                              c.activation_quantization_cfg.activation_n_bits == base_cfg_nbits]
@@ -67,7 +68,7 @@ def filter_candidates_for_mixed_precision(graph: Graph,
         weight_configurable_nodes = [n for n in graph.get_weights_configurable_nodes(fw_info) if n not in activation_conf]
         for n in weight_configurable_nodes:
             kernel_attr = graph.fw_info.get_kernel_op_attributes(n.type)[0]
-            base_cfg_nbits = n.get_qco(tpc).base_config.attr_weights_configs_mapping[kernel_attr].weights_n_bits
+            base_cfg_nbits = n.get_qco(fqc).base_config.attr_weights_configs_mapping[kernel_attr].weights_n_bits
             filtered_conf = [c for c in n.candidates_quantization_cfg if
                              c.weights_quantization_cfg.get_attr_config(kernel_attr).enable_weights_quantization and
                              c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits == base_cfg_nbits]

{mct_nightly-2.2.0.20250113.527 → mct_nightly-2.2.0.20250114.84821}/model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py

@@ -22,7 +22,6 @@ from model_compression_toolkit.core import MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_functions_mapping import ru_functions_mapping
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import MixedPrecisionSearchManager
 from model_compression_toolkit.core.common.mixed_precision.search_methods.linear_programming import \
@@ -105,16 +104,11 @@ def search_bit_width(graph_to_search_cfg: Graph,
         disable_activation_for_metric=disable_activation_for_metric,
         hessian_info_service=hessian_info_service)
 
-    # Each pair of (resource utilization method, resource utilization aggregation) should match to a specific
-    # provided target resource utilization
-    ru_functions = ru_functions_mapping
-
     # Instantiate a manager object
     search_manager = MixedPrecisionSearchManager(graph,
                                                  fw_info,
                                                  fw_impl,
                                                  se,
-                                                 ru_functions,
                                                  target_resource_utilization,
                                                  original_graph=graph_to_search_cfg)