mct-nightly 2.2.0.20250115.511__py3-none-any.whl → 2.2.0.20250115.124229__py3-none-any.whl

{mct_nightly-2.2.0.20250115.511.dist-info → mct_nightly-2.2.0.20250115.124229.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=2u1DrGdQe9j4PDWnUfeyWGWTSmI4I_pIdm0vdAPRJ9k,1557
+model_compression_toolkit/__init__.py,sha256=XzPQtEswf99NjIZ6WKNDM9aZ5p6w7n23Q3CF0XIUpOE,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=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
@@ -8,7 +8,7 @@ model_compression_toolkit/core/__init__.py,sha256=8a0wUNBKwTdJGDk_Ho6WQAXjGuCqQZ
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=CVTjBaci8F6EP3IKDnRMfxkP-Sv8qY8GpkGt6FyII2U,11376
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=OtL6g2rTC5mfdKrkzm47EPPW-voGGVYMYxpy2_sfu1U,6547
-model_compression_toolkit/core/runner.py,sha256=YuL6LFarg3rl65rm3ccdXI9aNVd-yUhGRqhYqztby0M,13114
+model_compression_toolkit/core/runner.py,sha256=iFpcF1EFbMfEHIkL2XV7NXey3HnQT6kizB7_S0xwVwI,13624
 model_compression_toolkit/core/common/__init__.py,sha256=Wh127PbXcETZX_d1PQqZ71ETK3J9XO5A-HpadGUbj6o,1447
 model_compression_toolkit/core/common/base_substitutions.py,sha256=xDFSmVVs_iFSZfajytI0cuQaNRNcwHX3uqOoHgVUvxQ,1666
 model_compression_toolkit/core/common/framework_implementation.py,sha256=IkMydCj6voau7dwkYLYA_Ka_EFUKP3GKQdpYN6b1fgc,22163
@@ -67,16 +67,16 @@ model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates
 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=7ROKH1bTQEoyl5yLj10NbOWLFJgJicHBBJmUT_s1xnw,32463
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=fe8R1ZdllwL_YQoHgvzTBjoI3GJo4bEVk89I3zEVr14,32463
 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=UWgxzhKWFOoESLq0TFVz0M1PhkU9d9n6wccSA3RgUxk,7903
 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=89gXow5VMOsQX0SxLLoVvVDDxQd1z9b6crEWZgeWSaY,3453
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=jvPhYhzGMKKgoqkEBMeDcOiM8wHdHxn_hM1RVFgvERw,34262
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=5sbFXgDA6mpkXXAmk6HmR5UvBnuAmkoqTHu3ah6npsY,8529
+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=qkYrYORLL5wmdmCkEY3tDSgabsGYt3OaTDVsgHWYBfE,34885
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=tfcbMppa5KP_brfkFWRiOX9LQVHGXJtlgxyAt9oDGuw,8529
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
-model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=0NUmtGiAOLl3GObr6V5L6GU19fXmp89GKDlKAKZkxwU,17176
+model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=ZvLxFIfMUPAyKKzPhJcuZyjjngLD9_1wWFU8e14vEbA,17176
 model_compression_toolkit/core/common/network_editors/__init__.py,sha256=vZmu55bYqiaOQs3AjfwWDXHmuKZcLHt-wm7uR5fPEqg,1307
 model_compression_toolkit/core/common/network_editors/actions.py,sha256=nid0_j-Cn10xvmztT8yCKW_6uA7JEnom9SW9syx7wc0,19594
 model_compression_toolkit/core/common/network_editors/edit_network.py,sha256=dfgawi-nB0ocAJ0xcGn9E-Zv203oUnQLuMiXpX8vTgA,1748
@@ -523,8 +523,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.2.0.20250115.511.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.2.0.20250115.511.dist-info/METADATA,sha256=MWsnlz94L6FWAYZo3f4Iz6HwpXl-qth128ESSNECXYU,26601
-mct_nightly-2.2.0.20250115.511.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mct_nightly-2.2.0.20250115.511.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.2.0.20250115.511.dist-info/RECORD,,
+mct_nightly-2.2.0.20250115.124229.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.2.0.20250115.124229.dist-info/METADATA,sha256=dzpp7TMHexI-0ubm_-SRvqQoFeEbOzarWf1MWBRvGA8,26604
+mct_nightly-2.2.0.20250115.124229.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mct_nightly-2.2.0.20250115.124229.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.2.0.20250115.124229.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.2.0.20250115.000511"
+__version__ = "2.2.0.20250115.124229"

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py

@@ -69,7 +69,7 @@ class MixedPrecisionSearchManager:
 
         # To define RU Total constraints we need to compute weights and activations even if they have no constraints
         # TODO currently this logic is duplicated in linear_programming.py
-        targets = target_resource_utilization.get_restricted_metrics()
+        targets = target_resource_utilization.get_restricted_targets()
         if RUTarget.TOTAL in targets:
             targets = targets.union({RUTarget.ACTIVATION, RUTarget.WEIGHTS}) - {RUTarget.TOTAL}
         self.ru_targets_to_compute = targets

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py

@@ -86,15 +86,31 @@ class ResourceUtilization:
                     ru.total_memory <= self.total_memory and \
                     ru.bops <= self.bops)
 
-    def get_restricted_metrics(self) -> Set[RUTarget]:
+    def get_restricted_targets(self) -> Set[RUTarget]:
         d = self.get_resource_utilization_dict()
         return {k for k, v in d.items() if v < np.inf}
 
     def is_any_restricted(self) -> bool:
-        return bool(self.get_restricted_metrics())
+        return bool(self.get_restricted_targets())
 
-    def __repr__(self):
-        return f"Weights_memory: {self.weights_memory}, " \
-               f"Activation_memory: {self.activation_memory}, " \
-               f"Total_memory: {self.total_memory}, " \
-               f"BOPS: {self.bops}"
+    def get_summary_str(self, restricted: bool):
+        """
+        Generate summary string.
+
+        Args:
+            restricted: whether to include non-restricted targets.
+
+        Returns:
+            Summary string.
+        """
+        targets = self.get_restricted_targets() if restricted else list(RUTarget)
+        summary = []
+        if RUTarget.WEIGHTS in targets:
+            summary.append(f"Weights memory: {self.weights_memory}")
+        if RUTarget.ACTIVATION in targets:
+            summary.append(f"Activation memory: {self.activation_memory}")
+        if RUTarget.TOTAL in targets:
+            summary.append(f"Total memory: {self.total_memory}")
+        if RUTarget.BOPS in targets:
+            summary.append(f"BOPS: {self.bops}")
+        return ', '.join(summary)

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -15,8 +15,7 @@
 from collections import defaultdict
 from copy import deepcopy
 from enum import Enum, auto
-from functools import lru_cache
-from typing import Dict, NamedTuple, Optional, Tuple, List, Iterable, Union, Literal, Sequence
+from typing import Dict, NamedTuple, Optional, Tuple, List, Iterable, Union, Literal, Sequence, Set
 
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.core import FrameworkInfo
@@ -160,16 +159,17 @@ class ResourceUtilizationCalculator:
         """
         ru_targets = set(ru_targets) if ru_targets else set(RUTarget)
 
+        if w_qcs is not None and not self.is_custom_weights_config_applicable(ru_targets):
+            raise ValueError('Weight configuration passed but no relevant metric requested.')
+        if act_qcs is not None and not self.is_custom_activation_config_applicable(ru_targets):
+            raise ValueError('Activation configuration passed but no relevant metric requested.')
+
         w_total, a_total = None, None
         if {RUTarget.WEIGHTS, RUTarget.TOTAL}.intersection(ru_targets):
             w_total, *_ = self.compute_weights_utilization(target_criterion, bitwidth_mode, w_qcs)
-        elif w_qcs is not None:    # pragma: no cover
-            raise ValueError('Weight configuration passed but no relevant metric requested.')
 
         if {RUTarget.ACTIVATION, RUTarget.TOTAL}.intersection(ru_targets):
             a_total = self.compute_activations_utilization(target_criterion, bitwidth_mode, act_qcs)
-        elif act_qcs is not None:    # pragma: no cover
-            raise ValueError('Activation configuration passed but no relevant metric requested.')
 
         ru = ResourceUtilization()
         if RUTarget.WEIGHTS in ru_targets:
@@ -182,7 +182,7 @@ class ResourceUtilizationCalculator:
             ru.bops, _ = self.compute_bops(target_criterion=target_criterion,
                                            bitwidth_mode=bitwidth_mode, act_qcs=act_qcs, w_qcs=w_qcs)
 
-        assert ru.get_restricted_metrics() == set(ru_targets), 'Mismatch between the number of requested and computed metrics'
+        assert ru.get_restricted_targets() == set(ru_targets), 'Mismatch between the number of requested and computed metrics'
         return ru
 
     def compute_weights_utilization(self,
@@ -464,6 +464,14 @@ class ResourceUtilizationCalculator:
         node_bops = a_nbits * w_nbits * node_mac
         return node_bops
 
+    def is_custom_weights_config_applicable(self, ru_targets: Set[RUTarget]) -> bool:
+        """ Whether custom configuration for weights is compatible with the requested targets."""
+        return bool({RUTarget.WEIGHTS, RUTarget.TOTAL, RUTarget.BOPS}.intersection(ru_targets))
+
+    def is_custom_activation_config_applicable(self, ru_targets: Set[RUTarget]) -> bool:
+        """ Whether custom configuration for activations is compatible with the requested targets."""
+        return bool({RUTarget.ACTIVATION, RUTarget.TOTAL, RUTarget.BOPS}.intersection(ru_targets))
+
     def _get_cut_target_nodes(self, cut: Cut, target_criterion: TargetInclusionCriterion) -> List[BaseNode]:
         """
         Retrieve target nodes from a cut filtered by a criterion.

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py

@@ -118,7 +118,7 @@ def requires_mixed_precision(in_model: Any,
 
     ru_calculator = ResourceUtilizationCalculator(transformed_graph, fw_impl, fw_info)
     max_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.QMaxBit,
-                                                        ru_targets=target_resource_utilization.get_restricted_metrics())
+                                                        ru_targets=target_resource_utilization.get_restricted_targets())
     return not target_resource_utilization.is_satisfied_by(max_ru)
 
 

model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py

@@ -196,7 +196,7 @@ def _add_ru_constraints(search_manager: MixedPrecisionSearchManager,
     """
     ru_indicated_vectors = {}
     # targets to add constraints for
-    constraints_targets = target_resource_utilization.get_restricted_metrics()
+    constraints_targets = target_resource_utilization.get_restricted_targets()
     # to add constraints for Total target we need to compute weight and activation
     targets_to_compute = constraints_targets
     if RUTarget.TOTAL in constraints_targets:

model_compression_toolkit/core/runner.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 
 import copy
-from typing import Callable, Any, List
+from typing import Callable, Any, List, Optional
 
 from model_compression_toolkit.core.common import FrameworkInfo
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
@@ -170,6 +170,7 @@ def core_runner(in_model: Any,
 
     _set_final_resource_utilization(graph=tg,
                                     final_bit_widths_config=bit_widths_config,
+                                    target_resource_utilization=target_resource_utilization,
                                     fw_info=fw_info,
                                     fw_impl=fw_impl)
 
@@ -207,6 +208,7 @@ def core_runner(in_model: Any,
 
 def _set_final_resource_utilization(graph: Graph,
                                     final_bit_widths_config: List[int],
+                                    target_resource_utilization: Optional[ResourceUtilization],
                                     fw_info: FrameworkInfo,
                                     fw_impl: FrameworkImplementation):
     """
@@ -216,21 +218,24 @@ def _set_final_resource_utilization(graph: Graph,
     Args:
         graph: Graph to compute the resource utilization for.
         final_bit_widths_config: The final bit-width configuration to quantize the model accordingly.
+        target_resource_utilization: Requested target resource utilization if relevant.
         fw_info: A FrameworkInfo object.
         fw_impl: FrameworkImplementation object with specific framework methods implementation.
 
     """
-    w_qcs = {n: n.final_weights_quantization_cfg for n in graph.nodes}
-    a_qcs = {n: n.final_activation_quantization_cfg for n in graph.nodes}
-    ru_calculator = ResourceUtilizationCalculator(graph, fw_impl, fw_info)
-    final_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.QCustom,
-                                                          act_qcs=a_qcs, w_qcs=w_qcs)
-
-    for ru_target, ru in final_ru.get_resource_utilization_dict().items():
-        if ru == 0:
-            Logger.warning(f"No relevant quantized layers for the resource utilization target {ru_target} were found, "
-                           f"the recorded final ru for this target would be 0.")
-
-    Logger.info(f'Resource utilization (of quantized targets):\n {str(final_ru)}.')
+    ru_targets = target_resource_utilization.get_restricted_targets() if target_resource_utilization else None
+    final_ru = None
+    if ru_targets:
+        ru_calculator = ResourceUtilizationCalculator(graph, fw_impl, fw_info)
+        w_qcs, a_qcs = None, None
+        if ru_calculator.is_custom_weights_config_applicable(ru_targets):
+            w_qcs = {n: n.final_weights_quantization_cfg for n in graph.nodes}
+        if ru_calculator.is_custom_activation_config_applicable(ru_targets):
+            a_qcs = {n: n.final_activation_quantization_cfg for n in graph.nodes}
+        final_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized,
+                                                              BitwidthMode.QCustom,
+                                                              act_qcs=a_qcs, w_qcs=w_qcs, ru_targets=ru_targets)
+        summary = final_ru.get_summary_str(restricted=True)
+        Logger.info(f'Resource utilization for quantized mixed-precision targets:\n {summary}.')
     graph.user_info.final_resource_utilization = final_ru
     graph.user_info.mixed_precision_cfg = final_bit_widths_config