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

model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py

@@ -46,29 +46,29 @@ if FOUND_TF:
 
         valid_layer = isinstance(layer, Layer)
         if not valid_layer:
-            Logger.error(
+            Logger.critical(
                 f'Exportable layer must be a Keras layer, but layer {layer.name} is of type '
                 f'{type(layer)}') # pragma: no cover
 
         if isinstance(layer, KerasQuantizationWrapper):
             valid_weights_quantizers = isinstance(layer.weights_quantizers, dict)
             if not valid_weights_quantizers:
-                Logger.error(
+                Logger.critical(
                     f'KerasQuantizationWrapper must have a weights_quantizers but has a '
                     f'{type(layer.weights_quantizers)} object') # pragma: no cover
 
             if len(layer.weights_quantizers) == 0:
-                Logger.error(f'KerasQuantizationWrapper must have at least one weight quantizer, but found {len(layer.weights_quantizers)} quantizers. If layer is not quantized it should be a Keras layer.')
+                Logger.critical(f'KerasQuantizationWrapper must have at least one weight quantizer, but found {len(layer.weights_quantizers)} quantizers. If layer is not quantized it should be a Keras layer.')
 
             for _, weights_quantizer in layer.weights_quantizers.items():
                 if not isinstance(weights_quantizer, BaseInferableQuantizer):
-                    Logger.error(
+                    Logger.critical(
                         f'weights_quantizer must be a BaseInferableQuantizer object but has a '
                         f'{type(weights_quantizer)} object')  # pragma: no cover
 
         if isinstance(layer, KerasActivationQuantizationHolder):
             if not isinstance(layer.activation_holder_quantizer, BaseInferableQuantizer):
-                Logger.error(
+                Logger.critical(
                     f'activation quantizer in KerasActivationQuantizationHolder'
                     f' must be a BaseInferableQuantizer object but has a '
                     f'{type(layer.activation_holder_quantizer)} object')  # pragma: no cover
@@ -76,6 +76,5 @@ if FOUND_TF:
         return True
 else:
     def is_keras_layer_exportable(*args, **kwargs):  # pragma: no cover
-        Logger.error('Installing tensorflow is mandatory '
-                     'when using is_keras_layer_exportable. '
-                     'Could not find Tensorflow package.')
+        Logger.critical("Tensorflow must be installed to use is_keras_layer_exportable. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py

@@ -60,7 +60,7 @@ if FOUND_TORCH:
         # quantization, which in this case has an empty list).
         if len(activation_quantizers) == 1:
             return PytorchActivationQuantizationHolder(activation_quantizers[0])
-        Logger.error(
+        Logger.critical(
             f'PytorchActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers '
             f'were found for node {node}')
 
@@ -74,16 +74,23 @@ if FOUND_TORCH:
         Returns:
             Fully quantized PyTorch model.
         """
-        return PyTorchModelBuilder(graph=graph,
-                                   wrapper=lambda n, m:
-                                   fully_quantized_wrapper(n, m,
-                                                           fw_impl=C.pytorch.pytorch_implementation.PytorchImplementation()),
-                                   get_activation_quantizer_holder_fn=lambda n:
-                                   get_activation_quantizer_holder(n,
-                                                                   fw_impl=C.pytorch.pytorch_implementation.PytorchImplementation())).build_model()
+        exportable_model, user_info = PyTorchModelBuilder(graph=graph,
+                                                          wrapper=lambda n, m:
+                                                          fully_quantized_wrapper(n, m,
+                                                                                  fw_impl=C.pytorch.pytorch_implementation.PytorchImplementation()),
+                                                          get_activation_quantizer_holder_fn=lambda n:
+                                                          get_activation_quantizer_holder(n,
+                                                                                          fw_impl=C.pytorch.pytorch_implementation.PytorchImplementation())).build_model()
+
+        Logger.info("Please run your accuracy evaluation on the exported quantized model to verify it's accuracy.\n"
+                    "Checkout the FAQ and Troubleshooting pages for resolving common issues and improving the quantized model accuracy:\n"
+                    "FAQ: https://github.com/sony/model_optimization/tree/main/FAQ.md"
+                    "Quantization Troubleshooting: https://github.com/sony/model_optimization/tree/main/quantization_troubleshooting.md")
+
+        return exportable_model, user_info
+
 
 else:
-    def get_exportable_pytorch_model(*args, **kwargs):  # pragma: no cover
-        Logger.error('Installing torch is mandatory '
-                     'when using get_exportable_pytorch_model. '
-                     'Could not find PyTorch package.')
+    def get_exportable_pytorch_model(*args, **kwargs):
+        Logger.critical("PyTorch must be installed to use 'get_exportable_pytorch_model'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py

@@ -44,7 +44,7 @@ def get_weights_inferable_quantizer_kwargs(node_qc: NodeWeightsQuantizationConfi
     """
 
     if not isinstance(node_qc, NodeWeightsQuantizationConfig):
-        Logger.error(
+        Logger.critical(
             f"Non-compatible node quantization config was given for quantization target Weights.")  # pragma: no cover
 
     if attr_name is None:
@@ -97,7 +97,7 @@ def get_activation_inferable_quantizer_kwargs(node_qc: NodeActivationQuantizatio
     """
 
     if not isinstance(node_qc, NodeActivationQuantizationConfig):
-        Logger.error(
+        Logger.critical(
             f"Non-compatible node quantization config was given for quantization target Activation.")  # pragma: no cover
 
     quantization_method = node_qc.activation_quantization_method

model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py

@@ -35,36 +35,35 @@ if FOUND_TORCH:
             Check whether a PyTorch layer is a valid exportable layer or not.
         """
         if not isinstance(layer, nn.Module):
-            Logger.error(f'Exportable layer must be a nn.Module layer, but layer {layer.name} is of type {type(layer)}') # pragma: no cover
+            Logger.critical(f'Exportable layer must be a nn.Module layer, but layer {layer.name} is of type {type(layer)}.') # pragma: no cover
 
         if isinstance(layer, PytorchQuantizationWrapper):
             valid_weights_quantizers = isinstance(layer.weights_quantizers, dict)
             if not valid_weights_quantizers:
-                Logger.error(
+                Logger.critical(
                     f'PytorchQuantizationWrapper must have a weights_quantizers but has a '
-                    f'{type(layer.weights_quantizers)} object') # pragma: no cover
+                    f'{type(layer.weights_quantizers)} object.') # pragma: no cover
 
             if len(layer.weights_quantizers) == 0:
-                Logger.error(f'PytorchQuantizationWrapper must have at least one weight quantizer, but found {len(layer.weights_quantizers)} quantizers.'
+                Logger.critical(f'PytorchQuantizationWrapper must have at least one weight quantizer, but found {len(layer.weights_quantizers)} quantizers.'
                              f'If layer is not quantized it should be a Keras layer.')
 
             for _, weights_quantizer in layer.weights_quantizers.items():
                 if not isinstance(weights_quantizer, BasePyTorchInferableQuantizer):
-                    Logger.error(
+                    Logger.critical(
                         f'weights_quantizer must be a BasePyTorchInferableQuantizer object but has a '
-                        f'{type(weights_quantizer)} object')  # pragma: no cover
+                        f'{type(weights_quantizer)} object.')  # pragma: no cover
 
         elif isinstance(layer, PytorchActivationQuantizationHolder):
             if not isinstance(layer.activation_holder_quantizer, BasePyTorchInferableQuantizer):
-                Logger.error(
+                Logger.critical(
                     f'activation quantizer in PytorchActivationQuantizationHolder'
                     f' must be a BasePyTorchInferableQuantizer object but has a '
-                    f'{type(layer.activation_holder_quantizer)} object')  # pragma: no cover
+                    f'{type(layer.activation_holder_quantizer)} object.')  # pragma: no cover
 
         return True
 
 else:
     def is_pytorch_layer_exportable(*args, **kwargs):  # pragma: no cover
-        Logger.error('Installing torch is mandatory '
-                     'when using is_pytorch_layer_exportable. '
-                     'Could not find PyTorch package.')
+        Logger.critical("PyTorch must be installed to use 'is_pytorch_layer_exportable'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/gptq/common/gptq_graph.py

@@ -62,7 +62,7 @@ def get_kernel_attribute_name_for_gptq(layer_type: type, fw_info: FrameworkInfo)
     """
     kernel_attribute = fw_info.get_kernel_op_attributes(layer_type)
     if len(kernel_attribute) != 1:
-        Logger.error(  # pragma: no cover
-            f"In GPTQ training only the kernel weights attribute should be trained, but number of kernel "
-            f"attributes is {len(kernel_attribute)}.")
+        Logger.critical(  # pragma: no cover
+            f"In GPTQ training, only the kernel weights attribute should be trained. "
+            f"However, the number of kernel attributes is {len(kernel_attribute)}.")
     return kernel_attribute[0]

model_compression_toolkit/gptq/common/gptq_training.py

@@ -75,8 +75,8 @@ class GPTQTrainer(ABC):
         self.fxp_model, self.gptq_user_info = self.build_gptq_model()
         if self.gptq_config.use_hessian_based_weights:
             if not isinstance(hessian_info_service, HessianInfoService):
-                Logger.error(f"When using hessian based approximations for sensitivity evaluation, "
-                             f" an HessianInfoService object must be provided but is {hessian_info_service}")
+                Logger.critical(f"When using Hessian-based approximations for sensitivity evaluation, "
+                                f"an 'HessianInfoService' object must be provided, but received: {hessian_info_service}.")
             self.hessian_service = hessian_info_service
 
     def get_optimizer_with_param(self,
@@ -106,8 +106,8 @@ class GPTQTrainer(ABC):
                 else:
                     w2train_res.extend(flattened_bias_weights)
                     if self.gptq_config.optimizer_rest is None:
-                        Logger.error(  # pragma: no cover
-                            "To enable bias micro training an additional optimizer is required, please define the optimizer_rest")
+                        Logger.critical("To enable bias micro-training, an additional optimizer is required. "
+                                        "Please define the 'optimizer_rest' parameter.")# pragma: no cover
             if quant_params_learning:
                 if self.gptq_config.optimizer_quantization_parameter is not None:  # Ability to override optimizer
                     optimizer_with_param.append((self.gptq_config.optimizer_quantization_parameter,
@@ -115,14 +115,16 @@ class GPTQTrainer(ABC):
                 else:
                     w2train_res.extend(trainable_quantization_parameters)
                 if self.gptq_config.optimizer_rest is None:
-                    Logger.error(  # pragma: no cover
-                        "To enable quantization parameters micro training an additional optimizer is required, please define the optimizer_rest")
+                    Logger.critical(
+                        "To enable quantization parameters micro-training, an additional optimizer is required. "
+                        "Please define the 'optimizer_rest' parameter.")  # pragma: no cover
             if len(w2train_res) > 0:
                 # Either bias or quantization parameters are trainable but did not provide a specific optimizer,
                 # so we should use optimizer_rest to train them
                 if self.gptq_config.optimizer_rest is None:
-                    Logger.error(  # pragma: no cover
-                        "To enable bias or quantization parameters micro training an additional optimizer is required, please define the optimizer_rest")
+                    Logger.critical(
+                        "To enable bais or quantization parameters micro-training, an additional optimizer is required. "
+                        "Please define the 'optimizer_rest' parameter.")  # pragma: no cover
                 optimizer_with_param.append((self.gptq_config.optimizer_rest, w2train_res))
 
         return optimizer_with_param
@@ -236,11 +238,11 @@ class GPTQTrainer(ABC):
             trace_approx: Trace approximation to validate.
         """
         if not isinstance(trace_approx, list):
-            Logger.error(f"Trace approx was expected to be a list but has a type of {type(trace_approx)}")
+            Logger.critical(f"Trace approximation was expected to be a list but is of type: {type(trace_approx)}.")
         if len(trace_approx) != 1:
-            Logger.error(
-                f"Trace approx was expected to be of length 1 (when computing approximations with "
-                f"granularity=HessianInfoGranularity.PER_TENSOR) but has a length of {len(trace_approx)}"
+            Logger.critical(f"Trace approximation was expected to have a length of 1 "
+                            f"(for computations with granularity set to 'HessianInfoGranularity.PER_TENSOR') "
+                            f"but has a length of {len(trace_approx)}."
             )
 
     @staticmethod

model_compression_toolkit/gptq/keras/gptq_training.py

@@ -96,9 +96,9 @@ class KerasGPTQTrainer(GPTQTrainer):
 
         if not (len(self.compare_points) == len(trainable_weights) == len(self.flp_weights_list) == len(
                 self.fxp_weights_list)):
-            raise Exception(
-                "GPTQ: Mismatch between number of compare points, number of layers with trainable weights " +
-                "and number of float and quantized weights for loss")
+            Logger.critical("Mismatch in the number of comparison points, layers with trainable weights, "
+                            "and the number of float and quantized weights for loss calculation. "
+                            "Ensure all these elements align to proceed with GPTQ training.")
 
         flattened_trainable_weights = [w for layer_weights in trainable_weights for w in layer_weights]
         flattened_bias_weights = [w for layer_weights in bias_weights for w in layer_weights]
@@ -110,7 +110,8 @@ class KerasGPTQTrainer(GPTQTrainer):
             [len(optimizer_params_tuple[1]) for optimizer_params_tuple in self.optimizer_with_param]) > 0
 
         if self.float_user_info.input_scale != self.gptq_user_info.input_scale:
-            Logger.error("Input scale mismatch between float and GPTQ networks")  # pragma: no cover
+            Logger.critical("Input scale mismatch detected between the float model and the GPTQ model. "
+                            "Confirm that the input scales for both models are correctly configured and aligned.")  # pragma: no cover
         else:
             self.input_scale = self.gptq_user_info.input_scale
 
@@ -177,9 +178,9 @@ class KerasGPTQTrainer(GPTQTrainer):
         if len(activation_quantizers) == 1:
             return KerasActivationQuantizationHolder(activation_quantizers[0])
 
-        Logger.error(
-            f'KerasActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers '
-            f'were found for node {n}')
+        Logger.critical(f"'KerasActivationQuantizationHolder' is designed to support a single quantizer, "
+                        f"but {len(activation_quantizers)} quantizers were found for node '{n}'. "
+                        f"Ensure only one quantizer is configured for each node's activation.")
 
 
     def build_gptq_model(self) -> Tuple[Model, UserInformation]:
@@ -331,7 +332,8 @@ class KerasGPTQTrainer(GPTQTrainer):
                 if len(node) == 0 and isinstance(layer.layer, TensorFlowOpLayer):
                     node = graph.find_node_by_name('_'.join(layer.layer.name.split('_')[3:]))
                 if len(node) != 1:
-                    Logger.error(f"Can't update GPTQ graph due to missing layer named: {layer.layer.name}")
+                    Logger.critical(f"Unable to update the GPTQ graph because the layer named '{layer.layer.name}' could not be found. "
+                                    f"Verify that the layer names in the GPTQ model match those in the graph.")
                 node = node[0]
                 kernel_attribute = get_kernel_attribute_name_for_gptq(layer_type=node.type,
                                                                       fw_info=self.fw_info)

model_compression_toolkit/gptq/keras/graph_info.py

@@ -52,7 +52,7 @@ def get_gptq_trainable_parameters(fxp_model: Model,
 
             # collect trainable weights per quantizer
             if kernel_attribute not in layer.weights_quantizers:
-                Logger.error(f'{kernel_attribute} was not found in weight quantizers of layer {layer.layer}')
+                Logger.critical(f"'{kernel_attribute}' was not found in the weight quantizers of layer '{layer.layer}'.")
 
             quantizer_trainable_weights = layer.weights_quantizers[kernel_attribute].get_trainable_variables(VariableGroup.WEIGHTS)
             quantizer_trainable_threshold = layer.weights_quantizers[kernel_attribute].get_trainable_variables(VariableGroup.QPARAMS)

model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -22,7 +22,7 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW, FOUND_TF
 from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
-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.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core import CoreConfig
@@ -116,7 +116,7 @@ if FOUND_TF:
     def keras_gradient_post_training_quantization(in_model: Model, representative_data_gen: Callable,
                                                   gptq_config: GradientPTQConfig,
                                                   gptq_representative_data_gen: Callable = None,
-                                                  target_kpi: KPI = None,
+                                                  target_resource_utilization: ResourceUtilization = None,
                                                   core_config: CoreConfig = CoreConfig(),
                                                   target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC) -> Tuple[Model, UserInformation]:
         """
@@ -129,7 +129,7 @@ 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 resource utilization need to be passed after weights_memory
         is set (in bytes).
         Then, the quantized weights are optimized using gradient based post
         training quantization by comparing points between the float and quantized models, and minimizing the observed
@@ -140,7 +140,7 @@ if FOUND_TF:
             representative_data_gen (Callable): Dataset used for calibration.
             gptq_config (GradientPTQConfig): Configuration for using gptq (e.g. optimizer).
             gptq_representative_data_gen (Callable): Dataset used for GPTQ training. If None defaults to representative_data_gen
-            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.
 
@@ -174,12 +174,12 @@ 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 resource utilization object:
+            Create a resource utilization 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.
 
             Create GPTQ config:
 
@@ -187,7 +187,7 @@ if FOUND_TF:
 
             Pass the model with the representative dataset generator to get a quantized model:
 
-            >>> quantized_model, quantization_info = mct.gptq.keras_gradient_post_training_quantization(model, repr_datagen, gptq_config, target_kpi=kpi, core_config=config)
+            >>> quantized_model, quantization_info = mct.gptq.keras_gradient_post_training_quantization(model, repr_datagen, gptq_config, target_resource_utilization=ru, core_config=config)
 
         """
         KerasModelValidation(model=in_model,
@@ -195,9 +195,9 @@ 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 "
-                             "MixedPrecisionQuantizationConfig. Please use keras_post_training_quantization "
-                             "API, or pass a valid mixed precision configuration.")  # pragma: no cover
+                Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "
+                                "Ensure usage of the correct API for keras_post_training_quantization "
+                                "or provide a valid mixed-precision configuration.")  # pragma: no cover
 
         tb_w = init_tensorboard_writer(DEFAULT_KERAS_INFO)
 
@@ -232,12 +232,10 @@ else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use these functions.
     def get_keras_gptq_config(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using get_keras_gptq_config. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use get_keras_gptq_config. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover
 
 
     def keras_gradient_post_training_quantization(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_gradient_post_training_quantization. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+        Logger.critical("Tensorflow must be installed to use keras_gradient_post_training_quantization. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/gptq/keras/quantizer/base_keras_gptq_quantizer.py

@@ -61,8 +61,8 @@ if FOUND_TF:
             weights = {}
             for weight, quantizer_vars, quantizer in layer.get_weights_vars():
                 if not isinstance(quantizer, BaseTrainableQuantizer):
-                    Logger.error(f"Expecting a GPTQ trainable quantizer, "  # pragma: no cover
-                                 f"but got {type(quantizer)} which is not callable.")
+                    Logger.critical(f"Expecting a GPTQ trainable quantizer for layer '{layer.name}', but received {type(quantizer)}. "
+                                    f"Ensure a trainable quantizer is used.") # pragma: no cover
                 weights.update({weight: quantizer(training=False, inputs=quantizer_vars)})
 
             quant_config = {WEIGHTS_QUANTIZATION_PARAMS: self.get_quant_config()}
@@ -105,6 +105,5 @@ if FOUND_TF:
 else:
     class BaseKerasGPTQTrainableQuantizer:  # pragma: no cover
         def __init__(self, *args, **kwargs):
-            Logger.critical('Installing tensorflow is mandatory '
-                            'when using BaseKerasGPTQTrainableQuantizer. '
-                            'Could not find Tensorflow package.')  # pragma: no cover
+            Logger.critical("Tensorflow must be installed to use BaseKerasGPTQTrainableQuantizer. "
+                            "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/gptq/keras/quantizer/quantization_builder.py

@@ -66,8 +66,7 @@ def quantization_builder(n: common.BaseNode,
     activation_quantizers = []
     if n.is_activation_quantization_enabled():
         if n.final_activation_quantization_cfg is None:
-            Logger.critical(f'Can not set quantizer for a node with no final activation quantization configuration')  #
-            # pragma: no cover
+            Logger.critical(f"Cannot set quantizer for a node without a final activation quantization configuration.")  # pragma: no cover
 
         quant_method = n.final_activation_quantization_cfg.activation_quantization_method
 

model_compression_toolkit/gptq/pytorch/gptq_training.py

@@ -76,7 +76,8 @@ class PytorchGPTQTrainer(GPTQTrainer):
         self.loss_list = []
         self.input_scale = 1
         if self.float_user_info.input_scale != self.gptq_user_info.input_scale:
-            Logger.error("Input scale mismatch between float and GPTQ networks")  # pragma: no cover
+            Logger.critical("Input scale mismatch between float and GPTQ networks. "
+                            "Ensure both networks have matching input scales.")  # pragma: no cover
         else:
             self.input_scale = self.gptq_user_info.input_scale
 
@@ -87,9 +88,9 @@ class PytorchGPTQTrainer(GPTQTrainer):
         self.flp_weights_list, self.fxp_weights_list = get_weights_for_loss(self.fxp_model)
         if not (len(self.compare_points) == len(trainable_weights) == len(self.flp_weights_list) == len(
                 self.fxp_weights_list)):
-            Logger.error(
-                "GPTQ: Mismatch between number of compare points, number of layers with trainable weights " +
-                "and number of float and quantized weights for loss")
+            Logger.critical("GPTQ: Number of comparison points, layers with trainable weights, "
+                            "and float vs. quantized weights for loss calculation do not match. "
+                            "Verify consistency across these parameters for successful GPTQ training.")
 
         self.optimizer_with_param = self.get_optimizer_with_param(trainable_weights,
                                                                   trainable_bias,
@@ -156,9 +157,9 @@ class PytorchGPTQTrainer(GPTQTrainer):
         # quantization, which in this case has an empty list).
         if len(activation_quantizers) == 1:
             return PytorchActivationQuantizationHolder(activation_quantizers[0])
-        Logger.error(
-            f'PytorchActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers '
-            f'were found for node {n}')
+        Logger.critical(f"'PytorchActivationQuantizationHolder' requires exactly one quantizer, "
+                        f"but {len(activation_quantizers)} were found for node {n.name}. "
+                        f"Ensure the node is configured with a single activation quantizer.")
 
     def build_gptq_model(self):
         """
@@ -278,7 +279,8 @@ class PytorchGPTQTrainer(GPTQTrainer):
             if isinstance(layer, PytorchQuantizationWrapper):
                 node = self.graph_quant.find_node_by_name(name)
                 if len(node) != 1:
-                    Logger.error(f"Can't update GPTQ graph due to missing layer named: {name}")
+                    Logger.critical(f"Cannot update GPTQ graph: Layer with name '{name}' is missing or not unique. "
+                                    f"Ensure each layer has a unique name and exists within the graph for updates.")
                 node = node[0]
                 kernel_attribute = get_kernel_attribute_name_for_gptq(layer_type=node.type,
                                                                       fw_info=self.fw_info)

model_compression_toolkit/gptq/pytorch/graph_info.py

@@ -48,7 +48,7 @@ def get_gptq_trainable_parameters(fxp_model: nn.Module,
 
             # collect trainable weights per quantizer
             if kernel_attribute not in layer.weights_quantizers:
-                Logger.error(f'{kernel_attribute} was not found in weight quantizers of layer {layer.layer}')
+                Logger.critical(f"'{kernel_attribute}' was not found in the weight quantizers of layer '{layer.layer}'.")
             quantizer_trainable_weights = layer.weights_quantizers[kernel_attribute].get_trainable_variables(VariableGroup.WEIGHTS)
             quantizer_trainable_threshold = layer.weights_quantizers[kernel_attribute].get_trainable_variables(VariableGroup.QPARAMS)
             trainable_aux_weights.extend(quantizer_trainable_weights)

model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -21,7 +21,7 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import PYTORCH
 from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
 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.runner import core_runner
 from model_compression_toolkit.gptq.keras.quantization_facade import GPTQ_MOMENTUM
 from model_compression_toolkit.gptq.runner import gptq_runner
@@ -94,7 +94,7 @@ if FOUND_TORCH:
 
     def pytorch_gradient_post_training_quantization(model: Module,
                                                     representative_data_gen: Callable,
-                                                    target_kpi: KPI = None,
+                                                    target_resource_utilization: ResourceUtilization = None,
                                                     core_config: CoreConfig = CoreConfig(),
                                                     gptq_config: GradientPTQConfig = None,
                                                     gptq_representative_data_gen: Callable = None,
@@ -118,7 +118,7 @@ if FOUND_TORCH:
         Args:
             model (Module): Pytorch 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.
             gptq_config (GradientPTQConfig): Configuration for using gptq (e.g. optimizer).
             gptq_representative_data_gen (Callable): Dataset used for GPTQ training. If None defaults to representative_data_gen
@@ -159,9 +159,9 @@ 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 "
-                             "MixedPrecisionQuantizationConfig. Please use keras_post_training_quantization "
-                             "API, or pass a valid mixed precision configuration.")  # pragma: no cover
+                Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "
+                                "Ensure usage of the correct API for 'keras_post_training_quantization' "
+                                "or provide a valid mixed-precision configuration.")  # pragma: no cover
 
         tb_w = init_tensorboard_writer(DEFAULT_PYTORCH_INFO)
 
@@ -176,7 +176,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)
 
         # ---------------------- #
@@ -202,12 +202,10 @@ else:
     # If torch is not installed,
     # we raise an exception when trying to use these functions.
     def get_pytorch_gptq_config(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using get_pytorch_gptq_config. '
-                        'Could not find torch package.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'get_pytorch_gptq_config'. "
+                        "The 'torch' package is missing.")  # pragma: no cover
 
 
     def pytorch_gradient_post_training_quantization(*args, **kwargs):
-        Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_gradient_post_training_quantization. '
-                        'Could not find the torch package.')  # pragma: no cover
+        Logger.critical("PyTorch must be installed to use 'pytorch_gradient_post_training_quantization'. "
+                        "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/gptq/pytorch/quantizer/base_pytorch_gptq_quantizer.py

@@ -63,7 +63,7 @@ if FOUND_TORCH:
             weights = {}
             for weight, quantizer_vars, quantizer in layer.get_weights_vars():
                 if not isinstance(quantizer, BaseTrainableQuantizer):
-                    Logger.error(f"Expecting a GPTQ trainable quantizer, "  # pragma: no cover
+                    Logger.critical(f"Expecting a GPTQ trainable quantizer, "  # pragma: no cover
                                  f"but got {type(quantizer)} which is not callable.")
                 weights.update({weight: quantizer(training=False, inputs=quantizer_vars)})
 
@@ -87,6 +87,5 @@ if FOUND_TORCH:
 else:
     class BasePytorchGPTQTrainableQuantizer:  # pragma: no cover
         def __init__(self, *args, **kwargs):
-            Logger.critical('Installing Pytorch is mandatory '
-                            'when using BasePytorchGPTQTrainableQuantizer. '
-                            'Could not find torch package.')  # pragma: no cover
+            Logger.critical("PyTorch must be installed to use 'BasePytorchGPTQTrainableQuantizer'. "
+                            "The 'torch' package is missing.")  # pragma: no cover

model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py

@@ -65,8 +65,7 @@ def quantization_builder(n: common.BaseNode,
     activation_quantizers = []
     if n.is_activation_quantization_enabled():
         if n.final_activation_quantization_cfg is None:
-            Logger.critical(f'Can not set quantizer for a node with no final activation quantization configuration')  #
-            # pragma: no cover
+            Logger.critical(f"Cannot set quantizer for a node without a final activation quantization configuration.")  # pragma: no cover
 
         quant_method = n.final_activation_quantization_cfg.activation_quantization_method
 

model_compression_toolkit/logger.py

@@ -19,7 +19,7 @@ import os
 from datetime import datetime
 from pathlib import Path
 
-LOGGER_NAME = 'Constrained Model Optimization'
+LOGGER_NAME = 'Model Compression Toolkit'
 
 
 class Logger:
@@ -116,17 +116,6 @@ class Logger:
         Logger.get_logger().critical(msg)
         raise Exception(msg)
 
-    @staticmethod
-    def exception(msg: str):
-        """
-        Log a message at 'exception' severity and raise an exception.
-        Args:
-            msg: Message to log.
-
-        """
-        Logger.get_logger().exception(msg)
-        raise Exception(msg)
-
     @staticmethod
     def debug(msg: str):
         """
@@ -172,7 +161,6 @@ class Logger:
 
         """
         Logger.get_logger().error(msg)
-        raise Exception(msg)
 
 
 def set_log_folder(folder: str, level: int = logging.INFO):