mct-nightly 2.3.0.20250303.547__py3-none-any.whl → 2.3.0.20250305.525__py3-none-any.whl

{mct_nightly-2.3.0.20250303.547.dist-info → mct_nightly-2.3.0.20250305.525.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.3.0.20250303.547
+Version: 2.3.0.20250305.525
 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.20250303.547.dist-info → mct_nightly-2.3.0.20250305.525.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=XUmnCPJRShQlD16RUhAF8kEhlRn3s-VGaR8A6to87o4,1557
+model_compression_toolkit/__init__.py,sha256=12OGQaehHq34jgmvxWZvkMkK13PqhCx-3FZjElMI7zo,1557
 model_compression_toolkit/constants.py,sha256=i_R6uXBfO1ph_X6DNJych2x59SUojfJbn7dNjs_mZnc,3846
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
@@ -64,14 +64,14 @@ model_compression_toolkit/core/common/mixed_precision/bit_width_setter.py,sha256
 model_compression_toolkit/core/common/mixed_precision/configurable_quant_id.py,sha256=LLDguK7afsbN742ucLpmJr5TUfTyFpK1vbf2bpVr1v0,882
 model_compression_toolkit/core/common/mixed_precision/configurable_quantizer_utils.py,sha256=7dKMi5S0zQZ16m8NWn1XIuoXsKuZUg64G4-uK8-j1PQ,5177
 model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha256=-x8edUyudu1EAEM66AuXPtgayLpzbxoLNubfEbFM5kU,2867
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py,sha256=AkKBP5Dm7iwz7qs5WKDB7Bm8Os-jXaMVnlkyrlw4iRY,4603
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py,sha256=6pLUEEIqRTVIlCYQC4JIvY55KAvuBHEX8uTOQ-1Ac4Q,3859
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py,sha256=r1t025_QHshyoop-PZvL7x6UuXaeplCCU3h4VNBhJHo,4309
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=7iJ2YprFvm2Dk9EkXYrwO7-Sf89f537D-KrQP7XhvPs,8889
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=aAuGIzSDKIDiq07nheeWRXLEatzr6Fvoa5ZHv-2BtCI,7130
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=uDX1mEaq7qqWk2FQCfVXUYVlpGWS0OBP0C1CsGCkZYY,32791
 model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=gsigifJ-ykWNafF4t7UMEC_-nd6YPERAk1_z0kT-Y88,27172
 model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,sha256=P8QtKgFXtt5b2RoubzI5OGlCfbEfZsAirjyrkFzK26A,2846
-model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=8oAFJc_KC3z5ClI-zo4KC40kKGscyixUc5oYP4j4cMo,8019
+model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=MQZnBcpBDMd5y6rOunUtH3t41GQH0aBmxVB4muoxNfk,9477
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py,sha256=T5yVr7lay-6QLuTDBZNI1Ufj02EMBWuY_yHjC8eHx5I,3998
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=DyiE84ECgwtaCATWcisv-7ndmBUbj_TaddZ7GeIjlrU,35307
@@ -439,7 +439,7 @@ model_compression_toolkit/target_platform_capabilities/schema/v1.py,sha256=4CGpW
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/__init__.py,sha256=XjNws3zoiJkeH4ixKqrLA5xBvpv5rq31qX7wYQjNpZM,1447
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2fw.py,sha256=HJ8uc3PFfyxg-WpVXPBg4mGaox8Z9bRqtQNbRfIyAk4,3745
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=mxc3DBbUi-HDFgSx8Nmnyxr8SIdbx8lmtcRMsQl1BLE,7578
-model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=swbfYmAbvQ7yDfyPhDWZxeN2P18WohI8uzz8zR1z0cg,6301
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=WPCqs_aFGE28XJf7KKB-SlrYoUNOcD9epgoaqQMCJMw,6320
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attribute_filter.py,sha256=jfhszvuD2Fyy6W2KjlLzXBQKFzTqGAaDZeFVr4-ONQw,8776
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/current_tpc.py,sha256=_kFG0USYa6yzvLsi82_Vusv_KR8Hi7J1u680pPXECuo,2192
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py,sha256=UKzckLYLdBcFAptyKnVMwpPpfRkmF0SK1Kl0g0eGjQA,9710
@@ -459,7 +459,7 @@ model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/latest/__init__.py,sha256=NGnmaFTeLINIdAZ1svx-_OiF6vIs8upH-tz3q9jWBQ4,1554
 model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/__init__.py,sha256=t4JKsPcor-7KSCKzIwuaBv0NLNwfhuewAQGlDl6iBeo,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tpc.py,sha256=2UXcjIBKL0sVdJ2zN_L6JyX9P37ErD95dDN0TUzbFz0,12781
+model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tpc.py,sha256=sd1oN7mYH6fHqJwU2QZf6WU2NJ8EKzQ9-o4-JGU6Plc,12958
 model_compression_toolkit/trainable_infrastructure/__init__.py,sha256=uewpvlPkH9mBFt8IxoAgIfz6iEcvWbOImm_fb6_BxD8,1543
 model_compression_toolkit/trainable_infrastructure/common/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
 model_compression_toolkit/trainable_infrastructure/common/annealing_schedulers.py,sha256=qm2_wa61nga08Jdcl3RkgTsJ0zyHNjZ_A6I2--oVOig,2455
@@ -524,8 +524,8 @@ 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.20250303.547.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.3.0.20250303.547.dist-info/METADATA,sha256=-St847XvmURdE0vGMxsGeW34Al2Hi1Zh8HzcPKn_5vo,27079
-mct_nightly-2.3.0.20250303.547.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mct_nightly-2.3.0.20250303.547.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250303.547.dist-info/RECORD,,
+mct_nightly-2.3.0.20250305.525.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.3.0.20250305.525.dist-info/METADATA,sha256=j5IdMOj7semfwR2QSpcpSMLkgaHDz_eFO3RDO1vXohk,27079
+mct_nightly-2.3.0.20250305.525.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mct_nightly-2.3.0.20250305.525.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250305.525.dist-info/RECORD,,

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.20250303.000547"
+__version__ = "2.3.0.20250305.000525"

model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py

@@ -16,7 +16,6 @@ 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.targetplatform2framework.framework_quantization_capabilities import \
     FrameworkQuantizationCapabilities
 
@@ -48,31 +47,23 @@ def filter_candidates_for_mixed_precision(graph: Graph,
     if tru.weight_restricted() and not tru.activation_restricted():
         # Running mixed precision for weights compression only -
         # filter out candidates activation only configurable node
-        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]
+        activation_configurable_nodes = [n for n in graph.get_activation_configurable_nodes()]
         for n in activation_configurable_nodes:
             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]
 
-            if len(filtered_conf) != 1:
-                Logger.critical(f"Running weights only mixed precision failed on layer {n.name} with multiple "
-                                f"activation quantization configurations.")  # pragma: no cover
             n.candidates_quantization_cfg = filtered_conf
 
     elif tru.activation_restricted() and not tru.weight_restricted():
         # Running mixed precision for activation compression only -
         # filter out candidates weights only configurable node
-        activation_conf = graph.get_activation_configurable_nodes()
-        weight_configurable_nodes = [n for n in graph.get_weights_configurable_nodes(fw_info) if n not in activation_conf]
+        weight_configurable_nodes = [n for n in graph.get_weights_configurable_nodes(fw_info)]
         for n in weight_configurable_nodes:
-            kernel_attr = graph.fw_info.get_kernel_op_attributes(n.type)[0]
+            kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
             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]
-            if len(filtered_conf) != 1:
-                Logger.critical(f"Running activation only mixed precision failed on layer {n.name} with multiple "
-                                f"weights quantization configurations.")  # pragma: no cover
             n.candidates_quantization_cfg = filtered_conf

model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 
-from typing import List
+from typing import List, Tuple, Dict
 
 from model_compression_toolkit.core import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import \
@@ -21,7 +21,6 @@ from model_compression_toolkit.core.common.mixed_precision.mixed_precision_searc
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
     CandidateNodeQuantizationConfig
 from model_compression_toolkit.logger import Logger
-import numpy as np
 
 
 def greedy_solution_refinement_procedure(mp_solution: List[int],
@@ -68,9 +67,11 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
             node_candidates = current_node.candidates_quantization_cfg
 
             # only weights kernel attribute is quantized with weights mixed precision
-            kernel_attr = search_manager.fw_info.get_kernel_op_attributes(current_node.type)
-            kernel_attr = None if kernel_attr is None else kernel_attr[0]
-            valid_candidates = _get_valid_candidates_indices(node_candidates, new_solution[node_idx], kernel_attr)
+            valid_candidates = _get_valid_candidates_indices(node_candidates,
+                                                             new_solution[node_idx],
+                                                             target_resource_utilization.activation_restricted(),
+                                                             target_resource_utilization.weight_restricted()
+                                                             )
 
             # Create a list of ru for the valid candidates.
             updated_ru = []
@@ -108,40 +109,81 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
     return new_solution
 
 
-def _get_valid_candidates_indices(node_candidates: List[CandidateNodeQuantizationConfig],
-                                  current_chosen_index: int,
-                                  kernel_attr: str = None) -> List[int]:
+def _get_valid_candidates_indices(
+        node_candidates: List[CandidateNodeQuantizationConfig],
+        current_chosen_index: int,
+        is_activation_restricted: bool,
+        is_weight_restricted: bool
+) -> List[int]:
     """
-    Find node's valid candidates to try and improve the node's MP chosen candidate.
-    Valid indices are indices of candidates that have higher number of bits for both weights and activations
-    (if they are quantized in this node).
+    Find node's valid candidates to improve the node's MP chosen candidate.
+
+    Valid indices are indices of candidates that have a higher number of bits for both
+    weights and activations. In cases where weights or activations are not restricted (thus,
+    we do not search for an MP solution for them), a candidate is considered to be
+    valid only if the bit-width of the part that is not eligible for MP has equal bit-width
+    to the current candidate.
 
     Args:
-        node_candidates: Candidates of the node.
-        current_chosen_index: Current index in MP configuration of the node.
-        kernel_attr: The name of the kernel attribute on the node, otherwise None.
+        node_candidates (List[CandidateNodeQuantizationConfig]): List of candidate configurations for the node.
+        current_chosen_index (int): Index of the currently chosen candidate in the list.
+        is_activation_restricted (bool): Indicates whether activation resources are restricted.
+        is_weight_restricted (bool): Indicates whether weight resources are restricted.
+
 
     Returns:
-        List of indices of valid candidates.
+        List[int]: List of indices of valid candidates.
     """
+
+    def get_candidate_bits(candidate: CandidateNodeQuantizationConfig) -> Tuple[Dict[str, int], int]:
+        """
+        Extract weight and activation bits from a candidate.
+
+        Args:
+            candidate (CandidateNodeQuantizationConfig): A candidate node configuration.
+
+        Returns:
+            Tuple[Dict[str, int], int]:
+                - A dictionary mapping weight attributes to their bit-widths.
+                - The activation bit-width.
+        """
+        weight_attrs = candidate.weights_quantization_cfg.all_weight_attrs
+        weight_attrs_to_nbits: Dict[str, int] = {
+            w_attr: candidate.weights_quantization_cfg.get_attr_config(w_attr).weights_n_bits
+            for w_attr in weight_attrs
+        }
+        activation_n_bits: int = candidate.activation_quantization_cfg.activation_n_bits
+        return weight_attrs_to_nbits, activation_n_bits
+
+    def is_valid_candidate(candidate: CandidateNodeQuantizationConfig) -> bool:
+        """
+        Check if a candidate satisfies the weight and activation bit-width constraints to be
+        considered as a valid candidate.
+
+        Args:
+            candidate (CandidateNodeQuantizationConfig): A candidate node configuration.
+
+        Returns:
+            bool: True if the candidate is valid, False otherwise.
+        """
+        candidate_weight_bits, candidate_activation_bits = get_candidate_bits(candidate)
+
+        # Current candidate - no need to check
+        if candidate_activation_bits == current_activation_bits and all(candidate_weight_bits[attr] == current_weight_bits[attr] for attr in current_weight_bits.keys()):
+            return False
+
+        valid_weight = all(
+            candidate_weight_bits[attr] >= current_weight_bits[attr] if is_weight_restricted else
+            candidate_weight_bits[attr] == current_weight_bits[attr]
+            for attr in current_weight_bits.keys()
+        )
+        valid_activation = (
+            candidate_activation_bits >= current_activation_bits if is_activation_restricted else
+            candidate_activation_bits == current_activation_bits
+        )
+        return valid_weight and valid_activation
+
     current_candidate = node_candidates[current_chosen_index]
+    current_weight_bits, current_activation_bits = get_candidate_bits(current_candidate)
 
-    if kernel_attr is None:
-        # In this node we only quantize activation, so no need to check weights number of bits
-        activation_num_bits = current_candidate.activation_quantization_cfg.activation_n_bits
-
-        # Filter candidates that have higher bit-width for activations
-        return [i for i, c in enumerate(node_candidates) if
-                c.activation_quantization_cfg.activation_n_bits >= activation_num_bits
-                and not (c.activation_quantization_cfg.activation_n_bits == activation_num_bits)]
-    else:
-        weights_num_bits = current_candidate.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits
-        activation_num_bits = current_candidate.activation_quantization_cfg.activation_n_bits
-
-        # Filter candidates that have higher bit-width for both weights and activations (except for the current index).
-        # TODO: activation bits comparison: should be >= if ACTIVATION or TOTAL ru is used. else should be ==.
-        return [i for i, c in enumerate(node_candidates) if
-                c.activation_quantization_cfg.activation_n_bits == activation_num_bits
-                and c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits >= weights_num_bits
-                and not (c.activation_quantization_cfg.activation_n_bits == activation_num_bits
-                         and c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits == weights_num_bits)]
+    return [idx for idx, candidate in enumerate(node_candidates) if is_valid_candidate(candidate)]

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py

@@ -70,7 +70,7 @@ class AttachTpcToPytorch(AttachTpcToFramework):
             OperatorSetNames.HARDSWISH: [Hardswish, hardswish],
             OperatorSetNames.FLATTEN: [Flatten, flatten],
             OperatorSetNames.GET_ITEM: [operator.getitem],
-            OperatorSetNames.RESHAPE: [reshape],
+            OperatorSetNames.RESHAPE: [reshape, torch.Tensor.view],
             OperatorSetNames.UNSQUEEZE: [unsqueeze],
             OperatorSetNames.SQUEEZE: [squeeze],
             OperatorSetNames.PERMUTE: [permute],

model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/tpc.py

@@ -137,6 +137,7 @@ def generate_tpc(default_config: OpQuantizationConfig,
     # If the QuantizationConfigOptions contains only one configuration,
     # this configuration will be used for the operation quantization:
     default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([default_config]))
+    base_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([base_config]), base_config=base_config)
 
     # In TFLite, the quantized operator specifications constraint operators quantization
     # differently. For more details:
@@ -179,13 +180,13 @@ def generate_tpc(default_config: OpQuantizationConfig,
                                qc_options=default_configuration_options.clone_and_edit(
                                    fixed_zero_point=-128, fixed_scale=1 / 256))
     fc = schema.OperatorsSet(name=schema.OperatorSetNames.FULLY_CONNECTED,
-                             qc_options=default_configuration_options.clone_and_edit_weight_attribute(
+                             qc_options=base_configuration_options.clone_and_edit_weight_attribute(
                                  weights_per_channel_threshold=False))
     squeeze = schema.OperatorsSet(name=schema.OperatorSetNames.SQUEEZE,
                                   qc_options=default_configuration_options.clone_and_edit(
                                       quantization_preserving=True))
 
-    conv2d = schema.OperatorsSet(name=schema.OperatorSetNames.CONV)
+    conv2d = schema.OperatorsSet(name=schema.OperatorSetNames.CONV, qc_options=base_configuration_options)
     relu = schema.OperatorsSet(name=schema.OperatorSetNames.RELU)
     relu6 = schema.OperatorsSet(name=schema.OperatorSetNames.RELU6)
     elu = schema.OperatorsSet(name=schema.OperatorSetNames.ELU)