mct-nightly 1.11.0.20240321.357__py3-none-any.whl → 1.11.0.20240323.408__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/target_platform/fusing.py

@@ -14,37 +14,72 @@
 # ==============================================================================
 
 
-from typing import Any
+from typing import Any, List, Union
 
-from model_compression_toolkit.target_platform_capabilities.target_platform.operators import OperatorSetConcat
+from model_compression_toolkit.target_platform_capabilities.target_platform.operators import OperatorSetConcat, \
+    OperatorsSet
 from model_compression_toolkit.target_platform_capabilities.target_platform.target_platform_model_component import TargetPlatformModelComponent
 
 
 class Fusing(TargetPlatformModelComponent):
+    """
+     Fusing defines a list of operators that should be combined and treated as a single operator,
+     hence no quantization is applied between them.
+    """
 
-    def __init__(self, operator_groups_list, name=None):
+    def __init__(self,
+                 operator_groups_list: List[Union[OperatorsSet, OperatorSetConcat]],
+                 name: str = None):
+        """
+        Args:
+            operator_groups_list (List[Union[OperatorsSet, OperatorSetConcat]]): A list of operator groups, each being either an OperatorSetConcat or an OperatorsSet.
+            name (str): The name for the Fusing instance. If not provided, it's generated from the operator groups' names.
+        """
         assert isinstance(operator_groups_list,
                           list), f'List of operator groups should be of type list but is {type(operator_groups_list)}'
         assert len(operator_groups_list) >= 2, f'Fusing can not be created for a single operators group'
+
+        # Generate a name from the operator groups if no name is provided
         if name is None:
             name = '_'.join([x.name for x in operator_groups_list])
+
         super().__init__(name)
         self.operator_groups_list = operator_groups_list
 
-    def contains(self, other: Any):
+    def contains(self, other: Any) -> bool:
+        """
+        Determines if the current Fusing instance contains another Fusing instance.
+
+        Args:
+            other: The other Fusing instance to check against.
+
+        Returns:
+            A boolean indicating whether the other instance is contained within this one.
+        """
         if not isinstance(other, Fusing):
             return False
+
+        # Check for containment by comparing operator groups
         for i in range(len(self.operator_groups_list) - len(other.operator_groups_list) + 1):
             for j in range(len(other.operator_groups_list)):
-                if self.operator_groups_list[i + j] != other.operator_groups_list[j] and not (isinstance(self.operator_groups_list[i + j], OperatorSetConcat) and (other.operator_groups_list[j] in self.operator_groups_list[i + j].op_set_list)):
+                if self.operator_groups_list[i + j] != other.operator_groups_list[j] and not (
+                        isinstance(self.operator_groups_list[i + j], OperatorSetConcat) and (
+                        other.operator_groups_list[j] in self.operator_groups_list[i + j].op_set_list)):
                     break
             else:
+                # If all checks pass, the other Fusing instance is contained
                 return True
+        # Other Fusing instance is not contained
         return False
 
-
     def get_info(self):
+        """
+        Retrieves information about the Fusing instance, including its name and the sequence of operator groups.
+
+        Returns:
+            A dictionary with the Fusing instance's name as the key and the sequence of operator groups as the value,
+            or just the sequence of operator groups if no name is set.
+        """
         if self.name is not None:
             return {self.name: ' -> '.join([x.name for x in self.operator_groups_list])}
-        return ' -> '.join([x.name for x in self.operator_groups_list])
-
+        return ' -> '.join([x.name for x in self.operator_groups_list])

model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py

@@ -124,7 +124,7 @@ class OpQuantizationConfig:
 
         Args:
             default_weight_attr_config (AttributeQuantizationConfig): A default attribute quantization configuration for the operation.
-            attr_weights_configs_mapping (dict): A mapping between an op attribute name and its quantization configuration.
+            attr_weights_configs_mapping (Dict[str, AttributeQuantizationConfig]): A mapping between an op attribute name and its quantization configuration.
             activation_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for activation quantization.
             activation_n_bits (int): Number of bits to quantize the activations.
             enable_activation_quantization (bool): Whether to quantize the model activations or not.
@@ -215,24 +215,19 @@ class QuantizationConfigOptions(object):
         """
 
         assert isinstance(quantization_config_list,
-                          list), f'QuantizationConfigOptions options list should be of type list, but is: ' \
-                                 f'{type(quantization_config_list)}'
-        assert len(quantization_config_list) > 0, f'Options list can not be empty'
+                          list), f'\'QuantizationConfigOptions\' options list must be a list, but received: {type(quantization_config_list)}.'
+        assert len(quantization_config_list) > 0, f'Options list can not be empty.'
         for cfg in quantization_config_list:
-            assert isinstance(cfg, OpQuantizationConfig), f'Options should be a list of QuantizationConfig objects, ' \
-                                                        f'but found an object type: {type(cfg)}'
+            assert isinstance(cfg, OpQuantizationConfig), f'Each option must be an instance of \'OpQuantizationConfig\', but found an object of type: {type(cfg)}.'
         self.quantization_config_list = quantization_config_list
         if len(quantization_config_list) > 1:
-            assert base_config is not None, f'When quantization config options contains more than one configuration, ' \
-                                            f'a base_config must be passed for non-mixed-precision optimization process'
-            assert base_config in quantization_config_list, f"base_config must be in the given quantization config " \
-                                                            f"list of options"
+            assert base_config is not None, f'For multiple configurations, a \'base_config\' is required for non-mixed-precision optimization.'
+            assert base_config in quantization_config_list, f"\'base_config\' must be included in the quantization config options list."
             self.base_config = base_config
         elif len(quantization_config_list) == 1:
             self.base_config = quantization_config_list[0]
         else:
-            raise Exception("QuantizationConfigOptions must have at least one OpQuantizationConfig "
-                            "defined in its options list, but list is empty")
+            Logger.critical("\'QuantizationConfigOptions\' requires at least one \'OpQuantizationConfig\'; the provided list is empty.")
 
     def __eq__(self, other):
         """
@@ -280,13 +275,13 @@ class QuantizationConfigOptions(object):
                 attrs_to_update = list(qc.attr_weights_configs_mapping.keys())
             else:
                 if not isinstance(attrs, List):
-                    Logger.error(f"Expecting a list of attribute but got {type(attrs)}.")
+                    Logger.critical(f"Expected a list of attributes but received {type(attrs)}.")
                 attrs_to_update = attrs
 
             for attr in attrs_to_update:
                 if qc.attr_weights_configs_mapping.get(attr) is None:
-                    Logger.error(f'Edit attributes is possible only for existing attributes '
-                                 f'in the configuration weights config mapping, but {attr} is not an attribute of {qc}.')
+                    Logger.critical(f'Editing attributes is only possible for existing attributes in the configuration\'s '
+                                    f'weights config mapping; {attr} does not exist in {qc}.')
                 self.__edit_quantization_configuration(qc.attr_weights_configs_mapping[attr], kwargs)
         return qc_options
 
@@ -312,7 +307,7 @@ class QuantizationConfigOptions(object):
                 for attr in list(qc.attr_weights_configs_mapping.keys()):
                     new_key = layer_attrs_mapping.get(attr)
                     if new_key is None:
-                        Logger.error(f"Attribute {attr} does not exist in the given attribute mapping.")
+                        Logger.critical(f"Attribute \'{attr}\' does not exist in the provided attribute mapping.")
 
                     new_attr_mapping[new_key] = qc.attr_weights_configs_mapping.pop(attr)
 
@@ -323,8 +318,8 @@ class QuantizationConfigOptions(object):
     def __edit_quantization_configuration(self, qc, kwargs):
         for k, v in kwargs.items():
             assert hasattr(qc,
-                           k), f'Edit attributes is possible only for existing attributes in configuration, ' \
-                               f'but {k} is not an attribute of {qc}'
+                           k), (f'Editing is only possible for existing attributes in the configuration; '
+                                f'{k} is not an attribute of {qc}.')
             setattr(qc, k, v)
 
     def get_info(self):

model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py

@@ -156,7 +156,7 @@ class TargetPlatformModel(ImmutableClass):
         elif isinstance(tp_model_component, OperatorsSetBase):
             self.operator_set.append(tp_model_component)
         else:
-            raise Exception(f'Trying to append an unfamiliar TargetPlatformModelComponent of type: {type(tp_model_component)}')
+            Logger.critical(f'Attempted to append an unrecognized TargetPlatformModelComponent of type: {type(tp_model_component)}.')
 
     def __enter__(self):
         """
@@ -192,7 +192,7 @@ class TargetPlatformModel(ImmutableClass):
         """
         opsets_names = [op.name for op in self.operator_set]
         if (len(set(opsets_names)) != len(opsets_names)):
-            Logger.error(f'OperatorsSet must have unique names')
+            Logger.critical(f'Operator Sets must have unique names.')
 
     def get_default_config(self) -> OpQuantizationConfig:
         """

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attribute_filter.py

@@ -87,7 +87,7 @@ class AttributeFilter(Filter):
         """
 
         if not isinstance(other, AttributeFilter):
-            Logger.error("Not an attribute filter. Can not run an OR operation.")  # pragma: no cover
+            Logger.critical("Not an attribute filter. Cannot perform an 'OR' operation.")  # pragma: no cover
         return OrAttributeFilter(self, other)
 
     def __and__(self, other: Any):
@@ -101,7 +101,7 @@ class AttributeFilter(Filter):
             AndAttributeFilter that filters with AND between the current AttributeFilter and the passed AttributeFilter.
         """
         if not isinstance(other, AttributeFilter):
-            Logger.error("Not an attribute filter. Can not run an AND operation.")  # pragma: no cover
+            Logger.critical("Not an attribute filter. Can not perform an 'AND' operation.")  # pragma: no cover
         return AndAttributeFilter(self, other)
 
     def match(self,

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/current_tpc.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from model_compression_toolkit.logger import Logger
 
 
 def get_current_tpc():
@@ -38,7 +39,7 @@ class _CurrentTPC(object):
 
         """
         if self.tpc is None:
-            raise Exception('TargetPlatformCapabilities is not initialized.')
+            Logger.critical("'TargetPlatformCapabilities' (TPC) instance is not initialized.")
         return self.tpc
 
     def reset(self):

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/operations_to_layers.py

@@ -20,6 +20,7 @@ from model_compression_toolkit.target_platform_capabilities.target_platform.targ
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.target_platform_capabilities_component import TargetPlatformCapabilitiesComponent
 from model_compression_toolkit.target_platform_capabilities.target_platform.operators import OperatorSetConcat, \
     OperatorsSetBase
+from model_compression_toolkit import DefaultDict
 
 
 class OperationsSetToLayers(TargetPlatformCapabilitiesComponent):
@@ -29,15 +30,14 @@ class OperationsSetToLayers(TargetPlatformCapabilitiesComponent):
     def __init__(self,
                  op_set_name: str,
                  layers: List[Any],
-                 attr_mapping: Dict[str, Any] = None):
+                 attr_mapping: Dict[str, DefaultDict] = None):
         """
 
         Args:
             op_set_name (str): Name of OperatorsSet to associate with layers.
             layers (List[Any]): List of layers/FilterLayerParams to associate with OperatorsSet.
-            attr_mapping (dict): A mapping between a general attribute name to a DefaultDict that maps a layer type
-            to the layer's framework name of this attribute (the dictionary type is not specified to handle circular
-            dependency).
+            attr_mapping (Dict[str, DefaultDict]): A mapping between a general attribute name to a DefaultDict that maps a layer type to the layer's framework name of this attribute.
+
         """
         self.layers = layers
         self.attr_mapping = attr_mapping
@@ -147,7 +147,7 @@ class OperationsToLayers:
             for layer in ops2layers.layers:
                 qco_by_opset_name = _current_tpc.get().tp_model.get_config_options_by_operators_set(ops2layers.name)
                 if layer in existing_layers:
-                    Logger.error(f'Found layer {layer.__name__} in more than one '
+                    Logger.critical(f'Found layer {layer.__name__} in more than one '
                                  f'OperatorsSet')  # pragma: no cover
                 else:
                     existing_layers.update({layer: qco_by_opset_name})

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/target_platform_capabilities.py

@@ -139,8 +139,7 @@ class TargetPlatformCapabilities(ImmutableClass):
         if isinstance(tpc_component, OperationsSetToLayers):
             self.op_sets_to_layers += tpc_component
         else:
-            Logger.error(f'Trying to append an unfamiliar TargetPlatformCapabilitiesComponent of type: '
-                         f'{type(tpc_component)}')  # pragma: no cover
+            Logger.critical(f"Attempt to append an unrecognized 'TargetPlatformCapabilitiesComponent' of type: '{type(tpc_component)}'. Ensure the component is compatible.")  # pragma: no cover
 
     def __enter__(self):
         """

model_compression_toolkit/trainable_infrastructure/common/base_trainable_quantizer.py

@@ -55,9 +55,9 @@ class BaseTrainableQuantizer(BaseInferableQuantizer):
         for i, (k, v) in enumerate(self.get_sig().parameters.items()):
             if i == 0:
                 if v.annotation not in [TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]:
-                    Logger.error(f"First parameter must be either TrainableQuantizerWeightsConfig or TrainableQuantizerActivationConfig")  # pragma: no cover
+                    Logger.critical(f"The first parameter must be either 'TrainableQuantizerWeightsConfig' or 'TrainableQuantizerActivationConfig'.")  # pragma: no cover
             elif v.default is v.empty:
-                Logger.error(f"Parameter {k} doesn't have a default value")  # pragma: no cover
+                Logger.critical(f"Parameter '{k}' lacks a default value.")  # pragma: no cover
 
         super(BaseTrainableQuantizer, self).__init__()
         self.quantization_config = quantization_config
@@ -67,22 +67,22 @@ class BaseTrainableQuantizer(BaseInferableQuantizer):
         static_quantization_target = getattr(self, QUANTIZATION_TARGET, None)
 
         if static_quantization_method is None or static_quantization_target is None:
-            Logger.error("A quantizer class that inherit from BaseTrainableQuantizer is not defined appropriately."
-                         "Either it misses the @mark_quantizer decorator or the decorator is not used correctly.")
+            Logger.critical("Quantizer class inheriting from 'BaseTrainableQuantizer' is improperly defined. "
+                            "Ensure it includes the '@mark_quantizer' decorator and is correctly applied.")
 
         if static_quantization_target == QuantizationTarget.Weights:
             self.validate_weights()
             if self.quantization_config.weights_quantization_method not in static_quantization_method:
-                Logger.error(
-                    f'Quantization method mismatch expected: {static_quantization_method} and got  {self.quantization_config.weights_quantization_method}')
+                Logger.critical(
+                    f"Quantization method mismatch. Expected methods: {static_quantization_method}, received: {self.quantization_config.weights_quantization_method}.")
         elif static_quantization_target == QuantizationTarget.Activation:
             self.validate_activation()
             if self.quantization_config.activation_quantization_method not in static_quantization_method:
-                Logger.error(
-                    f'Quantization method mismatch expected: {static_quantization_method} and got  {self.quantization_config.activation_quantization_method}')
+                Logger.critical(
+                    f"Quantization method mismatch. Expected methods: {static_quantization_method}, received: {self.quantization_config.activation_quantization_method}.")
         else:
-            Logger.error(
-                f'Unknown Quantization Part:{static_quantization_target}')  # pragma: no cover
+            Logger.critical(
+                f"Unrecognized 'QuantizationTarget': {static_quantization_target}.")  # pragma: no cover
 
         self.quantizer_parameters = {}
 
@@ -145,7 +145,7 @@ class BaseTrainableQuantizer(BaseInferableQuantizer):
 
         """
         if self.activation_quantization() or not self.weights_quantization():
-            Logger.error(f'Expect weight quantization got activation')
+            Logger.critical(f'Expected weight quantization configuration; received activation quantization instead.')
 
     def validate_activation(self) -> None:
         """
@@ -153,7 +153,7 @@ class BaseTrainableQuantizer(BaseInferableQuantizer):
 
         """
         if not self.activation_quantization() or self.weights_quantization():
-            Logger.error(f'Expect activation quantization got weight')
+            Logger.critical(f'Expected activation quantization configuration; received weight quantization instead.')
 
     def convert2inferable(self) -> BaseInferableQuantizer:
         """
@@ -183,7 +183,7 @@ class BaseTrainableQuantizer(BaseInferableQuantizer):
         if name in self.quantizer_parameters:
             return self.quantizer_parameters[name][VAR]
         else:
-            Logger.error(f'Variable {name} is not exist in quantizers parameters!') # pragma: no cover
+            Logger.critical(f"Variable '{name}' does not exist in quantizer parameters.") # pragma: no cover
 
 
     @abstractmethod

model_compression_toolkit/trainable_infrastructure/common/get_quantizer_config.py

@@ -36,7 +36,9 @@ def get_trainable_quantizer_weights_config(
          TrainableQuantizerWeightsConfig: an object that contains the quantizer configuration
     """
     if n.final_weights_quantization_cfg is None:
-        Logger.error(f'Node must have final_weights_quantization_cfg in order to build quantizer configuration')  # pragma: no cover
+        Logger.critical(
+            "The node requires a 'final_weights_quantization_cfg' configuration to build a "
+            "quantizer. Please ensure this configuration is set for the node.")# pragma: no cover
 
     final_node_cfg = n.final_weights_quantization_cfg
     final_attr_cfg = final_node_cfg.get_attr_config(attr_name)
@@ -65,7 +67,9 @@ def get_trainable_quantizer_activation_config(
          TrainableQuantizerActivationConfig - an object that contains the quantizer configuration
     """
     if n.final_activation_quantization_cfg is None:
-        Logger.error(f'Node must have final_activation_quantization_cfg in order to build quantizer configuration')  # pragma: no cover
+        Logger.critical(
+            "The node requires a 'final_activation_quantization_cfg' configuration to build a "
+            "quantizer. Please ensure this configuration is set for the node.")# pragma: no cover
 
     final_cfg = n.final_activation_quantization_cfg
     return TrainableQuantizerActivationConfig(final_cfg.activation_quantization_method,
@@ -93,17 +97,20 @@ def get_trainable_quantizer_quantization_candidates(n: BaseNode, attr: str = Non
     if attr is not None:
         # all candidates must have the same weights quantization method
         weights_quantization_methods = set([cfg.weights_quantization_cfg.get_attr_config(attr).weights_quantization_method
-                                            for cfg in n.candidates_quantization_cfg])
+             for cfg in n.candidates_quantization_cfg])
         if len(weights_quantization_methods) > 1:
-            Logger.error(f'Unsupported candidates_quantization_cfg with different weights quantization methods: '
-                         f'{weights_quantization_methods}')  # pragma: no cover
+            Logger.critical(f"Invalid 'candidates_quantization_cfg': Inconsistent weights "
+                            f"quantization methods detected: {weights_quantization_methods}. "
+                            f"Trainable quantizer requires all candidates to have the same weights "
+                            f"quantization method.")  # pragma: no cover
 
     # all candidates must have the same activation quantization method
     activation_quantization_methods = set([cfg.activation_quantization_cfg.activation_quantization_method
                                            for cfg in n.candidates_quantization_cfg])
     if len(activation_quantization_methods) > 1:
-        Logger.error(f'Unsupported candidates_quantization_cfg with different activation quantization methods: '
-                     f'{activation_quantization_methods}')  # pragma: no cover
+        Logger.critical(f"Invalid 'candidates_quantization_cfg': Inconsistent activation quantization "
+                        f"methods detected: {activation_quantization_methods}. "
+                        f"Trainable quantizer requires all candidates to have the same activation quantization method.")# pragma: no cover
 
     # get unique lists of candidates
     unique_weights_candidates = n.get_unique_weights_candidates(attr)

model_compression_toolkit/trainable_infrastructure/common/get_quantizers.py

@@ -44,7 +44,7 @@ def get_trainable_quantizer_class(quant_target: QuantizationTarget,
     """
     qat_quantizer_classes = get_all_subclasses(quantizer_base_class)
     if len(qat_quantizer_classes) == 0:
-        Logger.error(f"No quantizers were found that inherit from {quantizer_base_class}.")  # pragma: no cover
+        Logger.critical(f"No quantizer classes inherited from {quantizer_base_class} were detected.")  # pragma: no cover
 
     filtered_quantizers = list(filter(lambda q_class: getattr(q_class, QUANTIZATION_TARGET, None) is not None and
                                                       getattr(q_class, QUANTIZATION_TARGET) == quant_target and
@@ -54,9 +54,9 @@ def get_trainable_quantizer_class(quant_target: QuantizationTarget,
                                       qat_quantizer_classes))
 
     if len(filtered_quantizers) != 1:
-        Logger.error(f"Found {len(filtered_quantizers)} quantizer for target {quant_target.value} "  # pragma: no cover
-                     f"that matches the requested quantization method {quant_method.name} and "
-                     f"quantizer type {quantizer_id.value} but there should be exactly one."
-                     f"The possible quantizers that were found are {filtered_quantizers}.")
+        Logger.critical(f"Found {len(filtered_quantizers)} quantizers for target {quant_target.value}, "
+                        f"matching the requested quantization method {quant_method.name} and "
+                        f"quantizer type {quantizer_id.value}, but exactly one is required. "
+                        f"Identified quantizers: {filtered_quantizers}.")
 
     return filtered_quantizers[0]

model_compression_toolkit/trainable_infrastructure/keras/base_keras_quantizer.py

@@ -86,6 +86,5 @@ else:
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):
 
             super().__init__(quantization_config)
-            Logger.critical('Installing tensorflow is mandatory '
-                            'when using BaseKerasQuantizer. '
-                            'Could not find Tensorflow package.')  # pragma: no cover
+            Logger.critical("Tensorflow must be installed to use BaseKerasTrainableQuantizer. "
+                            "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/trainable_infrastructure/keras/load_model.py

@@ -48,8 +48,8 @@ if FOUND_TF:
             KerasTrainableQuantizationWrapper.__name__: KerasTrainableQuantizationWrapper})
         all_trainable_names = list(qi_trainable_custom_objects.keys())
         if len(set(all_trainable_names)) < len(all_trainable_names):
-            Logger.error(f"Found multiple quantizers with the same name that inherit from BaseKerasTrainableQuantizer"
-                         f"while trying to load a model.")
+            Logger.critical("Found multiple quantizers with identical names inheriting from "
+                            "'BaseKerasTrainableQuantizer' while trying to load a model.")
 
         qi_custom_objects = {**qi_trainable_custom_objects}
 
@@ -72,6 +72,5 @@ else:
         Returns: A keras Model
 
         """
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_load_quantized_model. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_load_quantized_model. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/trainable_infrastructure/keras/quantize_wrapper.py

@@ -91,7 +91,7 @@ if FOUND_TF:
                     layer_weights_list[weight_keys.index(_weight_name(w.name))] = w
             # Verify all the weights in the list are ready. The "set_weights" method expects all the layer's weights
             if not all(w is not None for w in layer_weights_list):
-                Logger.error(f'Not all weights are set for layer {self.layer.name}')
+                Logger.critical(f"Not all weights are set for layer '{self.layer.name}'")
             assert all(w is not None for w in layer_weights_list)
             inferable_quantizers_wrapper.set_weights(layer_weights_list)
 
@@ -110,6 +110,5 @@ else:
                 layer: A keras layer.
                 weights_quantizers: A dictionary between a weight's name to its quantizer.
             """
-            Logger.critical('Installing tensorflow is mandatory '
-                            'when using KerasTrainableQuantizationWrapper. '
-                            'Could not find Tensorflow package.')  # pragma: no cover
+            Logger.critical("Tensorflow must be installed to use KerasTrainableQuantizationWrapper. "
+                            "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/trainable_infrastructure/pytorch/base_pytorch_quantizer.py

@@ -60,6 +60,6 @@ else:
         def __init__(self,
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):
             super().__init__(quantization_config)
-            Logger.critical('Installing Pytorch is mandatory '
-                            'when using BasePytorchTrainableQuantizer. '
-                            'Could not find torch package.')  # pragma: no cover
+            Logger.critical("PyTorch must be installed to use 'BasePytorchTrainableQuantizer'. "
+                            "The 'torch' package is missing.")  # pragma: no cover
+

model_compression_toolkit/core/common/mixed_precision/kpi_tools/kpi.py

@@ -1,112 +0,0 @@
-# Copyright 2021 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-from enum import Enum
-from typing import Dict, Any
-
-import numpy as np
-
-
-class KPITarget(Enum):
-    """
-    Targets for which we define KPIs metrics for mixed-precision search.
-    For each target that we care to consider in a mixed-precision search, there should be defined a set of
-    kpi computation function, kpi aggregation function, and kpi target (within a KPI object).
-
-    Whenever adding a kpi metric to KPI class we should add a matching target to this enum.
-
-    WEIGHTS - Weights memory KPI metric.
-
-    ACTIVATION - Activation memory KPI metric.
-
-    TOTAL - Total memory KPI metric.
-
-    BOPS - Total Bit-Operations KPI Metric.
-
-    """
-
-    WEIGHTS = 'weights'
-    ACTIVATION = 'activation'
-    TOTAL = 'total'
-    BOPS = 'bops'
-
-
-class KPI:
-    """
-    Class to represent measurements of performance.
-    """
-
-    def __init__(self,
-                 weights_memory: float = np.inf,
-                 activation_memory: float = np.inf,
-                 total_memory: float = np.inf,
-                 bops: float = np.inf):
-        """
-
-        Args:
-            weights_memory: Memory of a model's weights in bytes. Note that this includes only coefficients that should be quantized (for example, the kernel of Conv2D in Keras will be affected by this value, while the bias will not).
-            activation_memory: Memory of a model's activation in bytes, according to the given activation kpi metric.
-            total_memory: The sum of model's activation and weights memory in bytes, according to the given total kpi metric.
-            bops: The total bit-operations in the model.
-        """
-        self.weights_memory = weights_memory
-        self.activation_memory = activation_memory
-        self.total_memory = total_memory
-        self.bops = bops
-
-    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_kpi_dict(self) -> Dict[KPITarget, float]:
-        """
-        Returns: a dictionary with the KPI object's values for each KPI target.
-        """
-        return {KPITarget.WEIGHTS: self.weights_memory,
-                KPITarget.ACTIVATION: self.activation_memory,
-                KPITarget.TOTAL: self.total_memory,
-                KPITarget.BOPS: self.bops}
-
-    def set_kpi_by_target(self, kpis_mapping: Dict[KPITarget, float]):
-        """
-        Setting a KPI object values for each KPI target in the given dictionary.
-
-        Args:
-            kpis_mapping: A mapping from a KPITarget to a matching KPI value.
-
-        """
-        self.weights_memory = kpis_mapping.get(KPITarget.WEIGHTS, np.inf)
-        self.activation_memory = kpis_mapping.get(KPITarget.ACTIVATION, np.inf)
-        self.total_memory = kpis_mapping.get(KPITarget.TOTAL, np.inf)
-        self.bops = kpis_mapping.get(KPITarget.BOPS, np.inf)
-
-    def holds_constraints(self, kpi: Any) -> bool:
-        """
-        Checks whether the given KPI holds a set of KPI constraints defined by the currect KPI object.
-
-        Args:
-            kpi: A KPI object to check if it holds the constraints.
-
-        Returns: True if all the given KPI values are not greater than the referenced KPI values.
-
-        """
-        if not isinstance(kpi, KPI):
-            return False
-
-        return kpi.weights_memory <= self.weights_memory and \
-               kpi.activation_memory <= self.activation_memory and \
-               kpi.total_memory <= self.total_memory and \
-               kpi.bops <= self.bops