PyPI - mct-nightly - Versions diffs - 2.2.0.20250114.164007__tar.gz → 2.2.0.20250115.511__tar.gz - Mend

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

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

@@ -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.20250114.164007"
+__version__ = "2.2.0.20250115.000511"

@@ -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_targets()
+        targets = target_resource_utilization.get_restricted_metrics()
         if RUTarget.TOTAL in targets:
             targets = targets.union({RUTarget.ACTIVATION, RUTarget.WEIGHTS}) - {RUTarget.TOTAL}
         self.ru_targets_to_compute = targets

@@ -86,31 +86,15 @@ class ResourceUtilization:
                     ru.total_memory <= self.total_memory and \
                     ru.bops <= self.bops)
-    def get_restricted_targets(self) -> Set[RUTarget]:
+    def get_restricted_metrics(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_targets())
+        return bool(self.get_restricted_metrics())
-    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)
+    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}"

@@ -15,7 +15,8 @@
 from collections import defaultdict
 from copy import deepcopy
 from enum import Enum, auto
-from typing import Dict, NamedTuple, Optional, Tuple, List, Iterable, Union, Literal, Sequence, Set
+from functools import lru_cache
+from typing import Dict, NamedTuple, Optional, Tuple, List, Iterable, Union, Literal, Sequence
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.core import FrameworkInfo
@@ -159,17 +160,16 @@ 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_targets() == set(ru_targets), 'Mismatch between the number of requested and computed metrics'
+        assert ru.get_restricted_metrics() == set(ru_targets), 'Mismatch between the number of requested and computed metrics'
         return ru
     def compute_weights_utilization(self,
@@ -464,14 +464,6 @@ 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.

@@ -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_targets())
+                                                        ru_targets=target_resource_utilization.get_restricted_metrics())
     return not target_resource_utilization.is_satisfied_by(max_ru)

@@ -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_targets()
+    constraints_targets = target_resource_utilization.get_restricted_metrics()
     # to add constraints for Total target we need to compute weight and activation
     targets_to_compute = constraints_targets
     if RUTarget.TOTAL in constraints_targets:

@@ -14,7 +14,7 @@
 # ==============================================================================
 import copy
-from typing import Callable, Any, List, Optional
+from typing import Callable, Any, List
 from model_compression_toolkit.core.common import FrameworkInfo
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
@@ -170,7 +170,6 @@ 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)
@@ -208,7 +207,6 @@ 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):
     """
@@ -218,24 +216,21 @@ 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.
     """
-    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}.')
+    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)}.')
     graph.user_info.final_resource_utilization = final_ru
     graph.user_info.mixed_precision_cfg = final_bit_widths_config

mct-nightly 2.2.0.20250114.164007__tar.gz → 2.2.0.20250115.511__tar.gz

mct-nightly 2.2.0.20250114.164007tar.gz → 2.2.0.20250115.511tar.gz