mct-nightly 1.11.0.20240320.400__py3-none-any.whl → 1.11.0.20240322.404__py3-none-any.whl

model_compression_toolkit/pruning/keras/pruning_facade.py

@@ -17,7 +17,7 @@ from typing import Callable, Tuple
 
 from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import TENSORFLOW, FOUND_TF
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.pruning.pruner import Pruner
 from model_compression_toolkit.core.common.pruning.pruning_config import PruningConfig
 from model_compression_toolkit.core.common.pruning.pruning_info import PruningInfo
@@ -37,13 +37,13 @@ if FOUND_TF:
     DEFAULT_KERAS_TPC = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
 
     def keras_pruning_experimental(model: Model,
-                                   target_kpi: KPI,
+                                   target_resource_utilization: ResourceUtilization,
                                    representative_data_gen: Callable,
                                    pruning_config: PruningConfig = PruningConfig(),
                                    target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC) -> Tuple[Model, PruningInfo]:
         """
-        Perform structured pruning on a Keras model to meet a specified target KPI.
-        This function prunes the provided model according to the target KPI by grouping and pruning
+        Perform structured pruning on a Keras model to meet a specified target resource utilization.
+        This function prunes the provided model according to the target resource utilization by grouping and pruning
         channels based on each layer's SIMD configuration in the Target Platform Capabilities (TPC).
         By default, the importance of each channel group is determined using the Label-Free Hessian
         (LFH) method, assessing each channel's sensitivity to the Hessian of the loss function.
@@ -55,7 +55,7 @@ if FOUND_TF:
 
         Args:
             model (Model): The original Keras model to be pruned.
-            target_kpi (KPI): The target Key Performance Indicators to be achieved through pruning.
+            target_resource_utilization (ResourceUtilization): The target Key Performance Indicators to be achieved through pruning.
             representative_data_gen (Callable): A function to generate representative data for pruning analysis.
             pruning_config (PruningConfig): Configuration settings for the pruning process. Defaults to standard config.
             target_platform_capabilities (TargetPlatformCapabilities): Platform-specific constraints and capabilities. Defaults to DEFAULT_KERAS_TPC.
@@ -82,12 +82,12 @@ if FOUND_TF:
             >>> import numpy as np
             >>> def repr_datagen(): yield [np.random.random((1, 224, 224, 3))]
 
-            Define a target KPI for pruning.
+            Define a target resource utilization for pruning.
             Here, we aim to reduce the memory footprint of weights by 50%, assuming the model weights
             are represented in float32 data type (thus, each parameter is represented using 4 bytes):
 
             >>> dense_nparams = sum([l.count_params() for l in model.layers])
-            >>> target_kpi = mct.core.KPI(weights_memory=dense_nparams * 4 * 0.5)
+            >>> target_resource_utilization = mct.core.ResourceUtilization(weights_memory=dense_nparams * 4 * 0.5)
 
             Optionally, define a pruning configuration. num_score_approximations can be passed
             to configure the number of importance scores that will be calculated for each channel.
@@ -98,7 +98,7 @@ if FOUND_TF:
 
             Perform pruning:
 
-            >>> pruned_model, pruning_info = mct.pruning.keras_pruning_experimental(model=model, target_kpi=target_kpi, representative_data_gen=repr_datagen, pruning_config=pruning_config)
+            >>> pruned_model, pruning_info = mct.pruning.keras_pruning_experimental(model=model, target_resource_utilization=target_resource_utilization, representative_data_gen=repr_datagen, pruning_config=pruning_config)
 
         """
 
@@ -126,7 +126,7 @@ if FOUND_TF:
         pruner = Pruner(float_graph_with_compression_config,
                         DEFAULT_KERAS_INFO,
                         fw_impl,
-                        target_kpi,
+                        target_resource_utilization,
                         representative_data_gen,
                         pruning_config,
                         target_platform_capabilities)
@@ -148,6 +148,5 @@ else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use these functions.
     def keras_pruning_experimental(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_pruning_experimental. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_pruning_experimental. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/pruning/pytorch/pruning_facade.py

@@ -16,7 +16,7 @@
 from typing import Callable, Tuple
 from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import FOUND_TORCH, PYTORCH
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.pruning.pruner import Pruner
 from model_compression_toolkit.core.common.pruning.pruning_config import PruningConfig
 from model_compression_toolkit.core.common.pruning.pruning_info import PruningInfo
@@ -41,14 +41,14 @@ if FOUND_TORCH:
     DEFAULT_PYOTRCH_TPC = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
 
     def pytorch_pruning_experimental(model: Module,
-                                     target_kpi: KPI,
+                                     target_resource_utilization: ResourceUtilization,
                                      representative_data_gen: Callable,
                                      pruning_config: PruningConfig = PruningConfig(),
                                      target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYOTRCH_TPC) -> \
             Tuple[Module, PruningInfo]:
         """
-        Perform structured pruning on a Pytorch model to meet a specified target KPI.
-        This function prunes the provided model according to the target KPI by grouping and pruning
+        Perform structured pruning on a Pytorch model to meet a specified target resource utilization.
+        This function prunes the provided model according to the target resource utilization by grouping and pruning
         channels based on each layer's SIMD configuration in the Target Platform Capabilities (TPC).
         By default, the importance of each channel group is determined using the Label-Free Hessian
         (LFH) method, assessing each channel's sensitivity to the Hessian of the loss function.
@@ -60,7 +60,7 @@ if FOUND_TORCH:
 
         Args:
             model (Module): The PyTorch model to be pruned.
-            target_kpi (KPI): Key Performance Indicators specifying the pruning targets.
+            target_resource_utilization (ResourceUtilization): Key Performance Indicators specifying the pruning targets.
             representative_data_gen (Callable): A function to generate representative data for pruning analysis.
             pruning_config (PruningConfig): Configuration settings for the pruning process. Defaults to standard config.
             target_platform_capabilities (TargetPlatformCapabilities): Platform-specific constraints and capabilities.
@@ -88,12 +88,12 @@ if FOUND_TORCH:
             >>> import numpy as np
             >>> def repr_datagen(): yield [np.random.random((1, 3, 224, 224))]
 
-            Define a target KPI for pruning.
+            Define a target resource utilization for pruning.
             Here, we aim to reduce the memory footprint of weights by 50%, assuming the model weights
             are represented in float32 data type (thus, each parameter is represented using 4 bytes):
 
             >>> dense_nparams = sum(p.numel() for p in model.state_dict().values())
-            >>> target_kpi = mct.core.KPI(weights_memory=dense_nparams * 4 * 0.5)
+            >>> target_resource_utilization = mct.core.ResourceUtilization(weights_memory=dense_nparams * 4 * 0.5)
 
             Optionally, define a pruning configuration. num_score_approximations can be passed
             to configure the number of importance scores that will be calculated for each channel.
@@ -104,7 +104,7 @@ if FOUND_TORCH:
 
             Perform pruning:
 
-            >>> pruned_model, pruning_info = mct.pruning.pytorch_pruning_experimental(model=model, target_kpi=target_kpi, representative_data_gen=repr_datagen, pruning_config=pruning_config)
+            >>> pruned_model, pruning_info = mct.pruning.pytorch_pruning_experimental(model=model, target_resource_utilization=target_resource_utilization, representative_data_gen=repr_datagen, pruning_config=pruning_config)
 
         """
 
@@ -132,7 +132,7 @@ if FOUND_TORCH:
         pruner = Pruner(float_graph_with_compression_config,
                         DEFAULT_PYTORCH_INFO,
                         fw_impl,
-                        target_kpi,
+                        target_resource_utilization,
                         representative_data_gen,
                         pruning_config,
                         target_platform_capabilities)
@@ -165,6 +165,5 @@ else:
         Raises:
             CriticalError: Indicates that PyTorch must be installed to use this function.
         """
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_pruning_experimental. '
-                        'Could not find the torch package.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'pytorch_pruning_experimental'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/ptq/keras/quantization_facade.py

@@ -20,7 +20,7 @@ from model_compression_toolkit.core.analyzer import analyzer_model_quantization
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW, FOUND_TF
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
@@ -42,7 +42,7 @@ if FOUND_TF:
 
     def keras_post_training_quantization(in_model: Model,
                                          representative_data_gen: Callable,
-                                         target_kpi: KPI = None,
+                                         target_resource_utilization: ResourceUtilization = None,
                                          core_config: CoreConfig = CoreConfig(),
                                          target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
         """
@@ -55,13 +55,13 @@ if FOUND_TF:
          statistics. Then, if given a mixed precision config in the core_config, using an ILP solver we find
          a mixed-precision configuration, and set a bit-width for each layer. The model is then quantized
          (both coefficients and activations by default).
-         In order to limit the maximal model's size, a target KPI need to be passed after weights_memory
+         In order to limit the maximal model's size, a target ResourceUtilization need to be passed after weights_memory
          is set (in bytes).
 
          Args:
              in_model (Model): Keras model to quantize.
              representative_data_gen (Callable): Dataset used for calibration.
-             target_kpi (KPI): KPI object to limit the search of the mixed-precision configuration as desired.
+             target_resource_utilization (ResourceUtilization): ResourceUtilization object to limit the search of the mixed-precision configuration as desired.
              core_config (CoreConfig): Configuration object containing parameters of how the model should be quantized, including mixed precision parameters.
              target_platform_capabilities (TargetPlatformCapabilities): TargetPlatformCapabilities to optimize the Keras model according to.
 
@@ -99,17 +99,17 @@ if FOUND_TF:
 
             >>> config = mct.core.CoreConfig(mixed_precision_config=mct.core.MixedPrecisionQuantizationConfig(num_of_images=1))
 
-            For mixed-precision set a target KPI object:
-            Create a KPI object to limit our returned model's size. Note that this value affects only coefficients
+            For mixed-precision set a target ResourceUtilization object:
+            Create a ResourceUtilization object to limit our returned model's size. Note that this value affects 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):
 
-            >>> kpi = mct.core.KPI(model.count_params() * 0.75)  # About 0.75 of the model size when quantized with 8 bits.
+            >>> ru = mct.core.ResourceUtilization(model.count_params() * 0.75)  # About 0.75 of the model size when quantized with 8 bits.
 
-            Pass the model, the representative dataset generator, the configuration and the target KPI to get a
+            Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a
             quantized model:
 
-            >>> quantized_model, quantization_info = mct.ptq.keras_post_training_quantization(model, repr_datagen, kpi, core_config=config)
+            >>> quantized_model, quantization_info = mct.ptq.keras_post_training_quantization(model, repr_datagen, ru, core_config=config)
 
             For more configuration options, please take a look at our `API documentation <https://sony.github.io/model_optimization/api/api_docs/modules/mixed_precision_quantization_config.html>`_.
 
@@ -122,7 +122,7 @@ if FOUND_TF:
 
         if core_config.mixed_precision_enable:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
-                Logger.error("Given quantization config to mixed-precision facade is not of type "
+                Logger.critical("Given quantization config to mixed-precision facade is not of type "
                                     "MixedPrecisionQuantizationConfig. Please use keras_post_training_quantization "
                                     "API, or pass a valid mixed precision configuration.")  # pragma: no cover
 
@@ -137,7 +137,7 @@ if FOUND_TF:
                                                fw_info=fw_info,
                                                fw_impl=fw_impl,
                                                tpc=target_platform_capabilities,
-                                               target_kpi=target_kpi,
+                                               target_resource_utilization=target_resource_utilization,
                                                tb_w=tb_w)
 
         tg = ptq_runner(tg, representative_data_gen, core_config, fw_info, fw_impl, tb_w)
@@ -156,6 +156,5 @@ else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use these functions.
     def keras_post_training_quantization(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_post_training_quantization. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_post_training_quantization. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/ptq/pytorch/quantization_facade.py

@@ -19,7 +19,7 @@ from model_compression_toolkit.core.common.visualization.tensorboard_writer impo
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import PYTORCH, FOUND_TORCH
 from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
@@ -41,7 +41,7 @@ if FOUND_TORCH:
 
     def pytorch_post_training_quantization(in_module: Module,
                                            representative_data_gen: Callable,
-                                           target_kpi: KPI = None,
+                                           target_resource_utilization: ResourceUtilization = None,
                                            core_config: CoreConfig = CoreConfig(),
                                            target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
         """
@@ -60,7 +60,7 @@ if FOUND_TORCH:
         Args:
             in_module (Module): Pytorch module to quantize.
             representative_data_gen (Callable): Dataset used for calibration.
-            target_kpi (KPI): KPI object to limit the search of the mixed-precision configuration as desired.
+            target_resource_utilization (ResourceUtilization): ResourceUtilization object to limit the search of the mixed-precision configuration as desired.
             core_config (CoreConfig): Configuration object containing parameters of how the model should be quantized, including mixed precision parameters.
             target_platform_capabilities (TargetPlatformCapabilities): TargetPlatformCapabilities to optimize the PyTorch model according to.
 
@@ -93,7 +93,7 @@ if FOUND_TORCH:
 
         if core_config.mixed_precision_enable:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
-                Logger.error("Given quantization config to mixed-precision facade is not of type "
+                Logger.critical("Given quantization config to mixed-precision facade is not of type "
                              "MixedPrecisionQuantizationConfig. Please use "
                              "pytorch_post_training_quantization API, or pass a valid mixed precision "
                              "configuration.")  # pragma: no cover
@@ -109,7 +109,7 @@ if FOUND_TORCH:
                                                fw_info=DEFAULT_PYTORCH_INFO,
                                                fw_impl=fw_impl,
                                                tpc=target_platform_capabilities,
-                                               target_kpi=target_kpi,
+                                               target_resource_utilization=target_resource_utilization,
                                                tb_w=tb_w)
 
         tg = ptq_runner(tg, representative_data_gen, core_config, DEFAULT_PYTORCH_INFO, fw_impl, tb_w)
@@ -128,6 +128,5 @@ else:
     # If torch is not installed,
     # we raise an exception when trying to use these functions.
     def pytorch_post_training_quantization(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_post_training_quantization. '
-                        'Could not find the torch package.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'pytorch_post_training_quantization_experimental'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/qat/keras/quantization_facade.py

@@ -20,7 +20,7 @@ from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import FOUND_TF
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
 from mct_quantizers import KerasActivationQuantizationHolder
@@ -87,7 +87,7 @@ if FOUND_TF:
 
     def keras_quantization_aware_training_init_experimental(in_model: Model,
                                                             representative_data_gen: Callable,
-                                                            target_kpi: KPI = None,
+                                                            target_resource_utilization: ResourceUtilization = None,
                                                             core_config: CoreConfig = CoreConfig(),
                                                             qat_config: QATConfig = QATConfig(),
                                                             target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
@@ -103,13 +103,13 @@ if FOUND_TF:
          a mixed-precision configuration, and set a bit-width for each layer. The model is built with fake_quant
          nodes for quantizing activation. Weights are kept as float and are quantized online while training by the
          quantization wrapper's weight quantizer.
-         In order to limit the maximal model's size, a target KPI need to be passed after weights_memory
+         In order to limit the maximal model's size, a target resource utilization need to be passed after weights_memory
          is set (in bytes).
 
          Args:
              in_model (Model): Keras model to quantize.
              representative_data_gen (Callable): Dataset used for initial calibration.
-             target_kpi (KPI): KPI object to limit the search of the mixed-precision configuration as desired.
+             target_resource_utilization (ResourceUtilization): ResourceUtilization object to limit the search of the mixed-precision configuration as desired.
              core_config (CoreConfig): Configuration object containing parameters of how the model should be quantized, including mixed precision parameters.
              qat_config (QATConfig): QAT configuration
              target_platform_capabilities (TargetPlatformCapabilities): TargetPlatformCapabilities to optimize the Keras model according to.
@@ -149,17 +149,17 @@ if FOUND_TF:
 
              >>> config = mct.core.CoreConfig(mixed_precision_config=MixedPrecisionQuantizationConfig())
 
-             For mixed-precision set a target KPI object:
-             Create a KPI object to limit our returned model's size. Note that this value affects only coefficients
+             For mixed-precision set a target ResourceUtilization object:
+             Create a ResourceUtilization object to limit our returned model's size. Note that this value affects 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):
 
-             >>> kpi = mct.core.KPI(model.count_params() * 0.75)  # About 0.75 of the model size when quantized with 8 bits.
+             >>> ru = mct.core.ResourceUtilization(model.count_params() * 0.75)  # About 0.75 of the model size when quantized with 8 bits.
 
-             Pass the model, the representative dataset generator, the configuration and the target KPI to get a
+             Pass the model, the representative dataset generator, the configuration and the target Resource Utilization to get a
              quantized model:
 
-             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init_experimental(model, repr_datagen, kpi, core_config=config)
+             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init_experimental(model, repr_datagen, ru, core_config=config)
 
              Use the quantized model for fine-tuning. For loading the model from file, use the custom_objects dictionary:
 
@@ -178,7 +178,7 @@ if FOUND_TF:
 
         if core_config.mixed_precision_enable:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
-                Logger.error("Given quantization config to mixed-precision facade is not of type "
+                Logger.critical("Given quantization config to mixed-precision facade is not of type "
                              "MixedPrecisionQuantizationConfig. Please use keras_post_training_quantization API,"
                              "or pass a valid mixed precision configuration.")
 
@@ -193,7 +193,7 @@ if FOUND_TF:
                                                fw_info=DEFAULT_KERAS_INFO,
                                                fw_impl=fw_impl,
                                                tpc=target_platform_capabilities,
-                                               target_kpi=target_kpi,
+                                               target_resource_utilization=target_resource_utilization,
                                                tb_w=tb_w)
 
         tg = ptq_runner(tg, representative_data_gen, core_config, DEFAULT_KERAS_INFO, fw_impl, tb_w)
@@ -245,17 +245,17 @@ if FOUND_TF:
 
              >>> config = mct.core.CoreConfig(mixed_precision_config=MixedPrecisionQuantizationConfig())
 
-             For mixed-precision set a target KPI object:
-             Create a KPI object to limit our returned model's size. Note that this value affects only coefficients
+             For mixed-precision set a target ResourceUtilization object:
+             Create a ResourceUtilization object to limit our returned model's size. Note that this value affects 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):
 
-             >>> kpi = mct.core.KPI(model.count_params() * 0.75)  # About 0.75 of the model size when quantized with 8 bits.
+             >>> ru = mct.core.ResourceUtilization(model.count_params() * 0.75)  # About 0.75 of the model size when quantized with 8 bits.
 
-             Pass the model, the representative dataset generator, the configuration and the target KPI to get a
+             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a
              quantized model:
 
-             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init_experimental(model, repr_datagen, kpi, core_config=config)
+             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init_experimental(model, repr_datagen, ru, core_config=config)
 
              Use the quantized model for fine-tuning. For loading the model from file, use the custom_objects dictionary:
 
@@ -291,12 +291,10 @@ else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use these functions.
     def keras_quantization_aware_training_init_experimental(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_quantization_aware_training_init_experimental. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_quantization_aware_training_init_experimental. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover
 
 
     def keras_quantization_aware_training_finalize_experimental(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_quantization_aware_training_finalize_experimental. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_quantization_aware_training_finalize_experimental. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/qat/keras/quantizer/base_keras_qat_quantizer.py

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

model_compression_toolkit/qat/keras/quantizer/quantization_builder.py

@@ -49,7 +49,7 @@ def get_activation_quantizer_holder(n: common.BaseNode,
     # quantization, which in this case has an empty list).
     if len(activation_quantizers) == 1:
         return KerasActivationQuantizationHolder(activation_quantizers[0])
-    Logger.error(f'KerasActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers were found for node {n}')
+    Logger.critical(f'KerasActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers were found for node {n}.')
 
 
 def quantization_builder(n: common.BaseNode,

model_compression_toolkit/qat/pytorch/quantization_facade.py

@@ -23,7 +23,7 @@ from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import \
@@ -75,7 +75,7 @@ if FOUND_TORCH:
 
     def pytorch_quantization_aware_training_init_experimental(in_model: Module,
                                                               representative_data_gen: Callable,
-                                                              target_kpi: KPI = None,
+                                                              target_resource_utilization: ResourceUtilization = None,
                                                               core_config: CoreConfig = CoreConfig(),
                                                               qat_config: QATConfig = QATConfig(),
                                                               target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
@@ -91,13 +91,13 @@ if FOUND_TORCH:
          a mixed-precision configuration, and set a bit-width for each layer. The model is built with fake_quant
          nodes for quantizing activation. Weights are kept as float and are quantized online while training by the
          quantization wrapper's weight quantizer.
-         In order to limit the maximal model's size, a target KPI need to be passed after weights_memory
+         In order to limit the maximal model's size, a target resource utilization need to be passed after weights_memory
          is set (in bytes).
 
          Args:
              in_model (Model): Pytorch model to quantize.
              representative_data_gen (Callable): Dataset used for initial calibration.
-             target_kpi (KPI): KPI object to limit the search of the mixed-precision configuration as desired.
+             target_resource_utilization (ResourceUtilization): ResourceUtilization object to limit the search of the mixed-precision configuration as desired.
              core_config (CoreConfig): Configuration object containing parameters of how the model should be quantized, including mixed precision parameters.
              qat_config (QATConfig): QAT configuration
              target_platform_capabilities (TargetPlatformCapabilities): TargetPlatformCapabilities to optimize the Pytorch model according to.
@@ -131,7 +131,7 @@ if FOUND_TORCH:
 
              >>> config = mct.core.CoreConfig()
 
-             Pass the model, the representative dataset generator, the configuration and the target KPI to get a
+             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a
              quantized model. Now the model contains quantizer wrappers for fine tunning the weights:
 
              >>> quantized_model, quantization_info = mct.qat.pytorch_quantization_aware_training_init_experimental(model, repr_datagen, core_config=config)
@@ -146,7 +146,7 @@ if FOUND_TORCH:
 
         if core_config.mixed_precision_enable:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
-                Logger.error("Given quantization config to mixed-precision facade is not of type "
+                Logger.critical("Given quantization config to mixed-precision facade is not of type "
                              "MixedPrecisionQuantizationConfig. Please use pytorch_post_training_quantization API,"
                              "or pass a valid mixed precision configuration.")
 
@@ -160,7 +160,7 @@ if FOUND_TORCH:
                                                fw_info=DEFAULT_PYTORCH_INFO,
                                                fw_impl=fw_impl,
                                                tpc=target_platform_capabilities,
-                                               target_kpi=target_kpi,
+                                               target_resource_utilization=target_resource_utilization,
                                                tb_w=tb_w)
 
         tg = ptq_runner(tg, representative_data_gen, core_config, DEFAULT_PYTORCH_INFO, fw_impl, tb_w)
@@ -213,7 +213,7 @@ if FOUND_TORCH:
 
              >>> config = mct.core.CoreConfig()
 
-             Pass the model, the representative dataset generator, the configuration and the target KPI to get a
+             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a
              quantized model:
 
              >>> quantized_model, quantization_info = mct.qat.pytorch_quantization_aware_training_init_experimental(model, repr_datagen, core_config=config)
@@ -239,12 +239,10 @@ else:
     # If torch is not installed,
     # we raise an exception when trying to use these functions.
     def pytorch_quantization_aware_training_init_experimental(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_quantization_aware_training_init_experimental. '
-                        'Could not find the torch package.')  # pragma: no cover
+        Logger.critical('PyTorch must be installed to use pytorch_quantization_aware_training_init_experimental. '
+                        "The 'torch' package is missing.")  # pragma: no cover
 
 
     def pytorch_quantization_aware_training_finalize_experimental(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_quantization_aware_training_finalize_experimental. '
-                        'Could not find the torch package.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'pytorch_quantization_aware_training_finalize_experimental'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/qat/pytorch/quantizer/base_pytorch_qat_quantizer.py

@@ -44,6 +44,5 @@ else:
         def __init__(self,
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):
             super().__init__(quantization_config)
-            Logger.critical('Installing Pytorch is mandatory '
-                            'when using BasePytorchQATTrainableQuantizer. '
-                            'Could not find torch package.')  # pragma: no cover
+            Logger.critical("Installation of PyTorch is required to use BasePytorchQATTrainableQuantizer. "
+                            "The 'torch' package was not found.")  # pragma: no cover

model_compression_toolkit/qat/pytorch/quantizer/quantization_builder.py

@@ -49,7 +49,7 @@ def get_activation_quantizer_holder(n: common.BaseNode,
     # quantization, which in this case has an empty list).
     if len(activation_quantizers) == 1:
         return PytorchActivationQuantizationHolder(activation_quantizers[0])
-    Logger.error(f'ActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers were found for node {n}')
+    Logger.critical(f'ActivationQuantizationHolder supports only a single quantizer, but ({len(activation_quantizers)}) quantizers were found for node {n}.')
 
 
 def quantization_builder(n: common.BaseNode,

model_compression_toolkit/target_platform_capabilities/immutable.py

@@ -14,6 +14,8 @@
 # ==============================================================================
 from typing import Any
 
+from model_compression_toolkit.logger import Logger
+
 
 class ImmutableClass(object):
     """
@@ -36,7 +38,7 @@ class ImmutableClass(object):
 
         """
         if self._initialized:
-            raise Exception('Immutable class. Can\'t edit attributes')
+            Logger.critical("Immutable class. Can't edit attributes.")
         else:
             object.__setattr__(self,
                                *args,
@@ -49,5 +51,5 @@ class ImmutableClass(object):
 
         """
         if self._initialized:
-            raise Exception('reinitialized')  # Can not get finalized again.
+            Logger.critical('Object reinitialization error: object cannot be finalized again.')  # Can not get finalized again.
         self._initialized = True  # Finalize object.

model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py

@@ -14,14 +14,10 @@
 # ==============================================================================
 
 from model_compression_toolkit.target_platform_capabilities.target_platform.fusing import Fusing
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import \
-    TargetPlatformCapabilities, OperationsSetToLayers, Smaller, SmallerEq, NotEq, Eq, GreaterEq, Greater, LayerFilterParams, OperationsToLayers, get_current_tpc
-
-from model_compression_toolkit.target_platform_capabilities.target_platform.target_platform_model import \
-    get_default_quantization_config_options, TargetPlatformModel
-
-from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import OpQuantizationConfig, \
-    QuantizationConfigOptions, AttributeQuantizationConfig
+from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attribute_filter import AttributeFilter
+from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities, OperationsSetToLayers, Smaller, SmallerEq, NotEq, Eq, GreaterEq, Greater, LayerFilterParams, OperationsToLayers, get_current_tpc
+from model_compression_toolkit.target_platform_capabilities.target_platform.target_platform_model import get_default_quantization_config_options, TargetPlatformModel
+from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import OpQuantizationConfig, QuantizationConfigOptions, AttributeQuantizationConfig
 from model_compression_toolkit.target_platform_capabilities.target_platform.operators import OperatorsSet, OperatorSetConcat
 
 from mct_quantizers import QuantizationMethod

model_compression_toolkit/target_platform_capabilities/target_platform/current_tp_model.py

@@ -40,7 +40,7 @@ class CurrentTPModel:
 
         """
         if self.tp_model is None:
-            Logger.error('Target platform model is not initialized.')  # pragma: no cover
+            Logger.critical('Target platform model is not initialized.')  # pragma: no cover
         return self.tp_model
 
     def reset(self):