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

model_compression_toolkit/core/keras/hessian/weights_trace_hessian_calculator_keras.py

@@ -68,8 +68,8 @@ class WeightsTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
         """
         # Check if the target node's layer type is supported
         if not DEFAULT_KERAS_INFO.is_kernel_op(self.hessian_request.target_node.type):
-            Logger.error(
-                f"{self.hessian_request.target_node.type} is not supported for Hessian info w.r.t weights.")
+            Logger.critical(
+                f"{self.hessian_request.target_node.type} is not supported for Hessian-based scoring with respect to weights.")
 
         # Construct the Keras float model for inference
         model, _ = FloatKerasModelBuilder(graph=self.graph).build_model()
@@ -79,7 +79,7 @@ class WeightsTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
 
         # Get the weight tensor for the target node
         if len(weight_attributes) != 1:
-            Logger.error(f"Hessian scores w.r.t weights is supported, for now, for a single-weight node. Found {len(weight_attributes)}")
+            Logger.critical(f"Hessian-based scoring with respect to weights is currently supported only for nodes with a single weight attribute. Found {len(weight_attributes)} attributes.")
 
         weight_tensor = getattr(model.get_layer(self.hessian_request.target_node.name), weight_attributes[0])
 
@@ -139,8 +139,7 @@ class WeightsTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
 
         if self.hessian_request.granularity == HessianInfoGranularity.PER_TENSOR:
             if final_approx.shape != (1,):
-                Logger.error(f"In HessianInfoGranularity.PER_TENSOR the score shape is expected"
-                             f"to be (1,) but is {final_approx.shape} ")
+                Logger.critical(f"For HessianInfoGranularity.PER_TENSOR, the expected score shape is (1,), but found {final_approx.shape}.")
         elif self.hessian_request.granularity == HessianInfoGranularity.PER_ELEMENT:
             # Reshaping the scores to the original weight shape
             final_approx = tf.reshape(final_approx, weight_tensor.shape)
@@ -195,4 +194,4 @@ class WeightsTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
         elif self.hessian_request.granularity == HessianInfoGranularity.PER_ELEMENT:
             return tf.size(weight_tensor).numpy()
         else:
-            Logger.error(f"Encountered an unexpected granularity {self.hessian_request.granularity} ")
+            Logger.critical(f"Unexpected granularity encountered: {self.hessian_request.granularity}.")

model_compression_toolkit/core/keras/keras_implementation.py

@@ -493,7 +493,7 @@ class KerasImplementation(FrameworkImplementation):
                                                       fw_impl=self,
                                                       num_iterations_for_approximation=num_iterations_for_approximation)
         else:
-            Logger.error(f"Keras does not support hessian mode of {trace_hessian_request.mode}")
+            Logger.critical(f"Unsupported Hessian mode for Keras: {trace_hessian_request.mode}.")
 
     def is_output_node_compatible_for_hessian_score_computation(self,
                                                                 node: BaseNode) -> Any:

model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py

@@ -66,7 +66,7 @@ class ConfigurableActivationQuantizer(BaseKerasInferableQuantizer):
         for qc in node_q_cfg:
             if qc.activation_quantization_cfg.enable_activation_quantization != \
                     node_q_cfg[0].activation_quantization_cfg.enable_activation_quantization:
-                Logger.error("Candidates with different activation enabled properties is currently not supported.")  # pragma: no cover
+                Logger.critical("Unsupported configuration: Mixing candidates with differing activation quantization states (enabled/disabled).")  # pragma: no cover
 
         self.activation_quantizers = init_activation_quantizers(self.node_q_cfg)
         self.active_quantization_config_index = max_candidate_idx  # initialize with first config as default

model_compression_toolkit/core/keras/mixed_precision/configurable_weights_quantizer.py

@@ -77,8 +77,7 @@ class ConfigurableWeightsQuantizer(BaseKerasInferableQuantizer):
         for qc in self.node_q_cfg:
             if qc.weights_quantization_cfg.get_attr_config(self.kernel_attr).enable_weights_quantization != \
                     self.node_q_cfg[0].weights_quantization_cfg.get_attr_config(self.kernel_attr).enable_weights_quantization:
-                Logger.error("Candidates with different kernel attribute quantization enabled "
-                             "properties is currently not supported.")
+                Logger.critical("Mixing candidates with varying weights quantization states (enabled/disabled) is not supported.")
 
         # Initialize quantized weights for each weight that should be quantized.
         self.quantized_weights = init_quantized_weights(node_q_cfg=self.node_q_cfg,
@@ -101,8 +100,7 @@ class ConfigurableWeightsQuantizer(BaseKerasInferableQuantizer):
         """
 
         if index >= len(self.node_q_cfg):
-            Logger.error(f'Quantizer has {len(self.node_q_cfg)} '  # pragma: no cover
-                         f'possible nbits. Can not set index {index}')
+            Logger.critical(f'Quantizer supports only {len(self.node_q_cfg)} bit width configurations; index {index} is out of range.')# pragma: no cover
         self.active_quantization_config_index = index
 
     def __call__(self,

model_compression_toolkit/core/keras/pruning/pruning_keras_implementation.py

@@ -172,7 +172,7 @@ class PruningKerasImplementation(KerasImplementation, PruningFrameworkImplementa
         if fw_info.is_kernel_op(node.type):
             kernel_attributes = fw_info.get_kernel_op_attributes(node.type)
             if kernel_attributes is None or len(kernel_attributes)==0:
-                Logger.error(f"Expected to find attributes but found {kernel_attributes}")
+                Logger.critical(f"Expected kernel attributes for operation for node type {node.type}, found None or empty.")
 
             for attr in kernel_attributes:
                 attributes_with_axis[attr] = fw_info.kernel_channels_mapping.get(node.type)

model_compression_toolkit/core/keras/quantizer/fake_quant_builder.py

@@ -69,11 +69,11 @@ def power_of_two_quantization(activation_n_bits: int,
     activation_is_signed = quantization_params.get(SIGNED)
 
     if activation_threshold is None:
-        Logger.error("Activation threshold is None")  # pragma: no cover
+        Logger.critical("Activation threshold must be specified.")  # pragma: no cover
     if activation_is_signed is None:
-        Logger.error("activation_is_signed is None")  # pragma: no cover
+        Logger.critical("Parameter 'activation_is_signed' must be specified.")  # pragma: no cover
     if not threshold_is_power_of_two(activation_threshold, per_channel=False):
-        Logger.error("Activation threshold is not power of two")  # pragma: no cover
+        Logger.critical("Activation threshold must be a power of two.")  # pragma: no cover
 
     min_value, max_value = quantizer_min_max_calculator(activation_threshold,
                                                         activation_n_bits,
@@ -99,9 +99,9 @@ def symmetric_quantization(activation_n_bits: int,
     activation_is_signed = quantization_params.get(SIGNED)
 
     if activation_threshold is None:
-        Logger.error("Activation threshold is None")  # pragma: no cover
+        Logger.critical("Activation threshold must be specified.")  # pragma: no cover
     if activation_is_signed is None:
-        Logger.error("activation_is_signed is None")  # pragma: no cover
+        Logger.critical("Parameter 'activation_is_signed' must be specified.")  # pragma: no cover
 
     min_value, max_value = quantizer_min_max_calculator(activation_threshold,
                                                         activation_n_bits,
@@ -126,9 +126,9 @@ def uniform_quantization(activation_n_bits: int,
     min_value, max_value = quantization_params.get(RANGE_MIN), quantization_params.get(RANGE_MAX)
 
     if min_value is None:
-        Logger.error("Min value is None")  # pragma: no cover
+        Logger.critical("Minimum value must be specified.")  # pragma: no cover
     if max_value is None:
-        Logger.error("Max value is None")  # pragma: no cover
+        Logger.critical("Maximum value must be specified.")  # pragma: no cover
 
     return lambda x: q(x, min_value, max_value, activation_n_bits)
 

model_compression_toolkit/core/keras/reader/common.py

@@ -47,7 +47,7 @@ def is_node_an_input_layer(node: BaseNode) -> bool:
     elif isinstance(node, KerasNode):
         return isinstance(node.layer, InputLayer)
     else:
-        Logger.error('Node to check has to be either a graph node or a keras node')  # pragma: no cover
+        Logger.critical('Node must be a graph node or a Keras node for input layer check.')  # pragma: no cover
 
 
 def is_node_a_model(node: BaseNode) -> bool:
@@ -64,5 +64,5 @@ def is_node_a_model(node: BaseNode) -> bool:
     elif isinstance(node, KerasNode):
         return isinstance(node.layer, Functional) or isinstance(node.layer, Sequential)
     else:
-        Logger.error('Node to check has to be either a graph node or a keras node')  # pragma: no cover
+        Logger.critical('Node must be a graph node or a Keras node.')  # pragma: no cover
 

model_compression_toolkit/core/keras/reader/node_builder.py

@@ -132,7 +132,7 @@ def build_node(node: KerasNode,
         # All KerasTensor and positional weights are removed from the call_args\kwargs. They are restored
         # in the model builder.
         if len(weights) > 0:
-            Logger.error('Functional nodes are not expected to have weights in framework')
+            Logger.critical('Functional nodes are not expected to have weights in this framework.')
 
         # read weights from call args
         tf_function_symbols = get_tf_function_symbols()

model_compression_toolkit/core/keras/{kpi_data_facade.py → resource_utilization_data_facade.py}

@@ -15,12 +15,11 @@
 
 from typing import Callable
 from model_compression_toolkit.core import MixedPrecisionQuantizationConfig, CoreConfig
-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.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW
 from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi_data import compute_kpi_data
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_data import compute_resource_utilization_data
 from model_compression_toolkit.constants import FOUND_TF
 
 if FOUND_TF:
@@ -33,13 +32,16 @@ if FOUND_TF:
 
     KERAS_DEFAULT_TPC = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
 
-    def keras_kpi_data(in_model: Model,
-                       representative_data_gen: Callable,
-                       core_config: CoreConfig = CoreConfig(mixed_precision_config=MixedPrecisionQuantizationConfig()),
-                       target_platform_capabilities: TargetPlatformCapabilities = KERAS_DEFAULT_TPC) -> KPI:
+    def keras_resource_utilization_data(in_model: Model,
+                                        representative_data_gen: Callable,
+                                        core_config: CoreConfig = CoreConfig(
+                                            mixed_precision_config=MixedPrecisionQuantizationConfig()),
+                                        target_platform_capabilities: TargetPlatformCapabilities = KERAS_DEFAULT_TPC) -> ResourceUtilization:
         """
-        Computes KPI data that can be used to calculate the desired target KPI for mixed-precision quantization.
-        Builds the computation graph from the given model and hw modeling, and uses it to compute the KPI data.
+        Computes resource utilization data that can be used to calculate the desired target resource utilization
+        for mixed-precision quantization.
+        Builds the computation graph from the given model and hw modeling, and uses it to compute the
+        resource utilization data.
 
         Args:
             in_model (Model): Keras model to quantize.
@@ -49,7 +51,7 @@ if FOUND_TF:
 
         Returns:
 
-            A KPI object with total weights parameters sum and max activation tensor.
+            A ResourceUtilization object with total weights parameters sum and max activation tensor.
 
         Examples:
 
@@ -63,30 +65,29 @@ if FOUND_TF:
             >>> import numpy as np
             >>> def repr_datagen(): yield [np.random.random((1, 224, 224, 3))]
 
-            Import MCT and call for KPI data calculation:
+            Import MCT and call for resource utilization data calculation:
 
             >>> import model_compression_toolkit as mct
-            >>> kpi_data = mct.core.keras_kpi_data(model, repr_datagen)
+            >>> ru_data = mct.core.keras_resource_utilization_data(model, repr_datagen)
 
         """
 
         if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
-            Logger.error("KPI data computation can't be executed without MixedPrecisionQuantizationConfig object."
-                         "Given quant_config is not of type MixedPrecisionQuantizationConfig.")
+            Logger.critical("Resource utilization data computation requires a MixedPrecisionQuantizationConfig object; "
+                            "provided config is of an incorrect type.")
 
         fw_impl = KerasImplementation()
 
-        return compute_kpi_data(in_model,
-                                representative_data_gen,
-                                core_config,
-                                target_platform_capabilities,
-                                DEFAULT_KERAS_INFO,
-                                fw_impl)
+        return compute_resource_utilization_data(in_model,
+                                                 representative_data_gen,
+                                                 core_config,
+                                                 target_platform_capabilities,
+                                                 DEFAULT_KERAS_INFO,
+                                                 fw_impl)
 
 else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use this function.
-    def keras_kpi_data(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_kpi_data. '
-                        'Could not find Tensorflow package.')  # pragma: no cover
+    def keras_resource_utilization_data(*args, **kwargs):
+        Logger.critical("Tensorflow must be installed to use keras_resource_utilization_data. "
+                        "The 'tensorflow' package is missing.")  # pragma: no cover

model_compression_toolkit/core/keras/tf_tensor_numpy.py

@@ -16,6 +16,8 @@ from typing import Union, List, Tuple
 import tensorflow as tf
 import numpy as np
 
+from model_compression_toolkit.logger import Logger
+
 
 def to_tf_tensor(tensor):
     """
@@ -35,7 +37,7 @@ def to_tf_tensor(tensor):
     elif isinstance(tensor, np.ndarray):
         return tf.convert_to_tensor(tensor.astype(np.float32))
     else:
-        raise Exception(f'Conversion of type {type(tensor)} to {type(tf.Tensor)} is not supported')
+        Logger.critical(f'Unsupported type for conversion to TF tensor: {type(tensor)}.')
 
 
 def tf_tensor_to_numpy(tensor: Union[List, Tuple, np.ndarray, tf.Tensor],
@@ -65,4 +67,4 @@ def tf_tensor_to_numpy(tensor: Union[List, Tuple, np.ndarray, tf.Tensor],
     elif isinstance(tensor, tf.Tensor):
         return tensor.numpy()
     else:
-        raise Exception(f'Conversion of type {type(tensor)} to {type(np.ndarray)} is not supported')
+        Logger.critical(f'Unsupported type for conversion to Numpy array: {type(tensor)}.')

model_compression_toolkit/core/pytorch/back2framework/factory_model_builder.py

@@ -38,9 +38,9 @@ def get_pytorch_model_builder(mode: ModelBuilderMode) -> type:
     """
 
     if not isinstance(mode, ModelBuilderMode):
-        Logger.error(f'get_pytorch_model_builder expects a mode of type ModelBuilderMode, but {type(mode)} was passed.')
+        Logger.critical(f"Expected a ModelBuilderMode type for 'mode' parameter; received {type(mode)} instead.")
     if mode is None:
-        Logger.error(f'get_pytorch_model_builder received a mode which is None')
+        Logger.critical(f"Received 'mode' parameter is None.")
     if mode not in pytorch_model_builders.keys():
-        Logger.error(f'mode {mode} is not in pytorch model builders factory')
+        Logger.critical(f"'mode' parameter {mode} is not supported by the PyTorch model builders factory.")
     return pytorch_model_builders.get(mode)

model_compression_toolkit/core/pytorch/back2framework/mixed_precision_model_builder.py

@@ -101,8 +101,7 @@ class MixedPrecisionPyTorchModelBuilder(PyTorchModelBuilder):
                 #  or single precision).
                 node_weights_qc = n.get_unique_weights_candidates(kernel_attr)
                 if not len(node_weights_qc) == 1:
-                    Logger.error(f"Expecting node {n.name} to have a unique weights configuration "  # pragma: no cover
-                                 f"but {len(node_weights_qc)} different configurations exist.")
+                    Logger.critical(f"Expected a single weights quantization configuration for node '{n.name}', but found ({len(node_weights_qc)}) configurations.")# pragma: no cover
 
                 quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Weights,
                                                                   node_weights_qc[0].weights_quantization_cfg
@@ -139,8 +138,7 @@ class MixedPrecisionPyTorchModelBuilder(PyTorchModelBuilder):
 
         max_cfg_candidates = n.find_max_candidates_indices()
         if not len(max_cfg_candidates) == 1:
-            Logger.error(f"A maximal config candidate must be defined, "  # pragma: no cover
-                         f"but some node have multiple potential maximal candidates")
+            Logger.critical(f"A maximal configuration candidate must be uniquely defined; however, multiple potential maximal candidates were found.") # pragma: no cover
 
         max_candidate_idx = max_cfg_candidates[0]
 
@@ -179,7 +177,7 @@ class MixedPrecisionPyTorchModelBuilder(PyTorchModelBuilder):
 
                 max_cfg_candidates = n.find_max_candidates_indices()
                 assert len(max_cfg_candidates) == 1, \
-                    f"A maximal config candidate must be defined, but some node have multiple potential maximal candidates"
+                    f"A maximal configuration candidate must be uniquely defined; however, multiple potential maximal candidates were found."
                 max_candidate_idx = max_cfg_candidates[0]
 
                 kernel_attr = self.fw_info.get_kernel_op_attributes(n.type)[0]
@@ -189,8 +187,7 @@ class MixedPrecisionPyTorchModelBuilder(PyTorchModelBuilder):
                                         * num_of_outputs
             else:
                 node_act_qc = n.get_unique_activation_candidates()
-                assert len(node_act_qc) == 1, f"Expecting node {n.name} to have a unique activation configuration, " \
-                                              f"but {len(node_act_qc)} different configurations exist."
+                assert len(node_act_qc) == 1, f"Expected a single activation configuration for node '{n.name}', but found multiple ({len(node_act_qc)}) configurations."
                 quantizer_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
                                                                    node_act_qc[0].activation_quantization_cfg.activation_quantization_method,
                                                                    BasePyTorchInferableQuantizer)
@@ -204,8 +201,7 @@ class MixedPrecisionPyTorchModelBuilder(PyTorchModelBuilder):
         if len(activation_quantizers) == 1:
             return PytorchActivationQuantizationHolder(activation_quantizers[0])
 
-        Logger.error(f'PytorchActivationQuantizationHolder supports a single quantizer but '  # pragma: no cover
-                     f'{len(activation_quantizers)} quantizers were found for node {n}')
+        Logger.critical(f"PytorchActivationQuantizationHolder expects a single quantizer, but ({len(activation_quantizers)}) quantizers were found for node {n}.")# pragma: no cover
 
     def build_model(self) -> Tuple[torch.nn.Module, UserInformation,
                                    Dict[str, Union[PytorchQuantizationWrapper, PytorchActivationQuantizationHolder]]]:
@@ -283,5 +279,4 @@ class MixedPrecisionPyTorchModelBuilder(PyTorchModelBuilder):
         elif weights_quant and act_quant:
             return self._get_weights_quant_layers(n, named_layers) + self._get_activation_quant_layers(n, named_layers)
         else:  # pragma: no cover
-            Logger.error(f"Expects node {n.name} to have at either weights or activation quantization configured,"
-                         f"but both are disabled.")
+            Logger.critical(f"Expected node {n.name} to have either weights or activation quantization enabled, but both are disabled.")

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/const_holder_conv.py

@@ -53,13 +53,13 @@ class FunctionalConvSubstitution(common.BaseSubstitution):
         elif func_node.type == conv_transpose2d:
             new_layer = ConvTranspose2d
         else:
-            Logger.error('mismatch in substitution filter')  # pragma: no cover
+            Logger.critical(f'Substitution filter mismatch. Layer {func_node.type}. Must be {type(Conv2d)} or {type(ConvTranspose2d)}.')  # pragma: no cover
 
         out_channel_index, in_channel_index = self.fw_info.kernel_channels_mapping.get(new_layer)
 
         # Create new node of layer convolution
         if 1 not in func_node.weights:
-            Logger.error('missing weight input')  # pragma: no cover
+            Logger.critical(f'Weight input missing for node {func_node.name}.')  # pragma: no cover
         weight = func_node.weights[1]
         bias = func_node.weights.get(2)
         framework_attr = func_node.framework_attr

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/functional_batch_norm.py

@@ -47,7 +47,7 @@ class FunctionalBatchNorm(common.BaseSubstitution):
             Weights dictionary for BatchNorm2d.
         """
         if 1 not in node.weights and 2 not in node.weights:
-            Logger.error(f'Missing {MOVING_MEAN} and {MOVING_VARIANCE} in functional batch_norm inputs')
+            Logger.critical(f'Missing {MOVING_MEAN} and {MOVING_VARIANCE} in functional batch_norm inputs.')
         weights_dict = {MOVING_MEAN: node.weights[1],
                         MOVING_VARIANCE: node.weights[2],
                         GAMMA: np.ones(node.weights[1].shape),

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/linear_collapsing.py

@@ -101,7 +101,7 @@ def conv2d_collapsing_fn(first_node: BaseNode,
 
         return kernel_collapsed, bias_collapsed
     else:
-        Logger.error("No supported layer collapsing of {} and {}".format(first_node.type, second_node.type))
+        Logger.critical(f"Layer collapsing is not supported for the combination of {first_node.type} and {second_node.type}.")
 
 
 def pytorch_linear_collapsing() -> Conv2DCollapsing:

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/multi_head_attention_decomposition.py

@@ -47,19 +47,19 @@ class MHAParams:
         # Only batch first network is supported
         if BATCH_FIRST in mha_node.framework_attr.keys():
             if mha_node.framework_attr[BATCH_FIRST] is not True:
-                Logger.error('Only batch first network is supported')  # pragma: no cover
+                Logger.critical('Only networks with batch first cofiguration are supported.')  # pragma: no cover
         else:
-            Logger.error('Only batch first network is supported')  # pragma: no cover
+            Logger.critical('Only networks with batch first cofiguration are supported.')  # pragma: no cover
 
         # Add Zero Attn feature is Not Implemented
         if ADD_ZERO_ATTN in mha_node.framework_attr.keys():
             if mha_node.framework_attr[ADD_ZERO_ATTN] is not False:
-                Logger.error('Add Zero Attn feature is Not Implemented')  # pragma: no cover
+                Logger.critical('Add Zero Attention (Add Zero Attn) feature is not implemented.')  # pragma: no cover
 
         # Check if Add Bias KV feature is Active
         if BIAS_K and BIAS_V in mha_node.weights.keys():
             if mha_node.weights[BIAS_K] is not None and mha_node.weights[BIAS_V] is not None:
-                Logger.error('Add BIAS_KV feature is Not Implemented')  # pragma: no cover
+                Logger.critical('Add Bias to Key/Value (BIAS_KV) feature is not implemented.')  # pragma: no cover
 
         self.embed_dim = mha_node.framework_attr[EMBED_DIM]
         self.num_heads = mha_node.framework_attr[NUM_HEADS]
@@ -702,7 +702,7 @@ class MultiHeadAttentionDecomposition(common.BaseSubstitution):
         """
 
         if mha_node.reuse:
-            raise Exception("MCT doesn't support reuse of MultiHeadAttention layer")  # pragma: no cover
+            Logger.critical("Reuse of MultiHeadAttention layers is currently not supported.")  # pragma: no cover
         params = MHAParams(mha_node)
 
         # project

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/relu_bound_to_power_of_2.py

@@ -103,7 +103,7 @@ class ReLUBoundToPowerOfTwo(common.BaseSubstitution):
             else:
                 return graph
         else:
-            Logger.error(f"In substitution with wrong matched pattern")
+            Logger.critical(f"Encountered an unexpected non-linearity type not supported for this substitution: {non_linear_node.type}.")
         Logger.debug(
             f"Node named:{non_linear_node.name} changed "
             f"to:{non_linear_node.type}")

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/reshape_with_static_shapes.py

@@ -58,7 +58,7 @@ class ReshapeWithStaticShapes(common.BaseSubstitution):
         if len(node.output_shape) == 1:
             node.output_shape[0][0] = BATCH_DIM_VALUE
         else:
-            Logger.error('Reshape or view nodes should have a single output shape')  # pragma: no cover
+            Logger.critical("This substitution handles 'reshape' or 'view' nodes with a single output shape.")  # pragma: no cover
 
         # configure the new static output shape attribute
         node.op_call_args = node.output_shape

model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/residual_collapsing.py

@@ -58,7 +58,7 @@ def residual_collapsing_fn(first_node: BaseNode,
             kernel[i, i, idxH, idxW] += 1
         return kernel
     else:
-        Logger.error("No supported add residual collapsing for {}".format(first_node.type))
+        Logger.critical(f"Residual collapsing not supported for node type: {first_node.type}")
 
 
 def pytorch_residual_collapsing() -> ResidualCollapsing:

model_compression_toolkit/core/pytorch/hessian/activation_trace_hessian_calculator_pytorch.py

@@ -65,10 +65,7 @@ class ActivationTraceHessianCalculatorPytorch(TraceHessianCalculatorPytorch):
             model_output_nodes = [ot.node for ot in self.graph.get_outputs()]
 
             if self.hessian_request.target_node in model_output_nodes:
-                Logger.exception("Trying to compute activation Hessian approximation with respect to the model output. "
-                                 "This operation is not supported. "
-                                 "Remove the output node from the set of node targets in the Hessian request.")
-
+                Logger.critical("Activation Hessian approximation cannot be computed for model outputs. Exclude output nodes from Hessian request targets.")
             grad_model_outputs = [self.hessian_request.target_node] + model_output_nodes
             model, _ = FloatPyTorchModelBuilder(graph=self.graph, append2output=grad_model_outputs).build_model()
             model.eval()
@@ -82,8 +79,7 @@ class ActivationTraceHessianCalculatorPytorch(TraceHessianCalculatorPytorch):
             outputs = model(*self.input_images)
 
             if len(outputs) != len(grad_model_outputs):
-                Logger.error(f"Model for computing activation Hessian approximation expects {len(grad_model_outputs)} "
-                             f"outputs, but got {len(outputs)} output tensors.")
+                Logger.critical(f"Mismatch in expected and actual model outputs for activation Hessian approximation. Expected {len(grad_model_outputs)} outputs, received {len(outputs)}.")
 
             # Extracting the intermediate activation tensors and the model real output
             # TODO: we are assuming that the hessian request is for a single node.
@@ -146,5 +142,5 @@ class ActivationTraceHessianCalculatorPytorch(TraceHessianCalculatorPytorch):
             return ipts_hessian_trace_approx.tolist()
 
         else:
-            Logger.error(f"{self.hessian_request.granularity} is not supported for Pytorch activation hessian's trace approx calculator")
+            Logger.critical(f"PyTorch activation Hessian's trace approximation does not support {self.hessian_request.granularity} granularity.")
 

model_compression_toolkit/core/pytorch/hessian/trace_hessian_calculator_pytorch.py

@@ -65,7 +65,6 @@ class TraceHessianCalculatorPytorch(TraceHessianCalculator):
         concat_axis_dim = [o.shape[0] for o in _r_tensors]
         if not all(d == concat_axis_dim[0] for d in concat_axis_dim):
             Logger.critical(
-                "Can't concat model's outputs for gradients calculation since the shape of the first axis "  # pragma: no cover
-                "is not equal in all outputs.")
+                "Unable to concatenate tensors for gradient calculation due to mismatched shapes along the first axis.")
 
         return torch.concat(_r_tensors, dim=1)

model_compression_toolkit/core/pytorch/hessian/weights_trace_hessian_calculator_pytorch.py

@@ -70,7 +70,7 @@ class WeightsTraceHessianCalculatorPytorch(TraceHessianCalculatorPytorch):
 
         # Check if the target node's layer type is supported
         if not DEFAULT_PYTORCH_INFO.is_kernel_op(self.hessian_request.target_node.type):
-            Logger.error(f"{self.hessian_request.target_node.type} is not supported for Hessian info w.r.t weights.")  # pragma: no cover
+            Logger.critical(f"Hessian information with respect to weights is not supported for {self.hessian_request.target_node.type} layers.")  # pragma: no cover
 
         # Float model
         model, _ = FloatPyTorchModelBuilder(graph=self.graph).build_model()
@@ -80,7 +80,7 @@ class WeightsTraceHessianCalculatorPytorch(TraceHessianCalculatorPytorch):
 
         # Get the weight tensor for the target node
         if len(weights_attributes) != 1:
-            Logger.error(f"Hessian scores w.r.t weights is supported, for now, for a single-weight node. Found {len(weights_attributes)}")
+            Logger.critical(f"Currently, Hessian scores with respect to weights are supported only for nodes with a single weight attribute. {len(weights_attributes)} attributes found.")
 
         weights_tensor = getattr(getattr(model,self.hessian_request.target_node.name),weights_attributes[0])
 

model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py

@@ -65,7 +65,7 @@ class ConfigurableActivationQuantizer(BasePyTorchInferableQuantizer):
         for qc in self.node_q_cfg:
             if qc.activation_quantization_cfg.enable_activation_quantization != \
                    self.node_q_cfg[0].activation_quantization_cfg.enable_activation_quantization:
-                Logger.error("Candidates with different activation enabled properties is currently not supported.")  # pragma: no cover
+                Logger.critical("Unsupported configuration: Mixing candidates with differing activation quantization states (enabled/disabled).")  # pragma: no cover
 
         # Setting layer's activation
         self.activation_quantizers = init_activation_quantizers(self.node_q_cfg)

model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quantizer.py

@@ -77,8 +77,7 @@ class ConfigurableWeightsQuantizer(BasePyTorchInferableQuantizer):
         for qc in self.node_q_cfg:
             if qc.weights_quantization_cfg.get_attr_config(self.kernel_attr).enable_weights_quantization != \
                    self.node_q_cfg[0].weights_quantization_cfg.get_attr_config(self.kernel_attr).enable_weights_quantization:
-                Logger.error("Candidates with different kernel attribute quantization enabled "
-                             "properties is currently not supported.")
+                Logger.critical("Unsupported configuration: Mixing candidates with differing weights quantization states (enabled/disabled).")  # pragma: no cover
 
         # Initialize quantized weights for each weight that should be quantized.
         self.quantized_weights = init_quantized_weights(node_q_cfg=self.node_q_cfg,

model_compression_toolkit/core/pytorch/pruning/pruning_pytorch_implementation.py

@@ -184,7 +184,7 @@ class PruningPytorchImplementation(PytorchImplementation, PruningFrameworkImplem
         if fw_info.is_kernel_op(node.type):
             kernel_attributes = fw_info.get_kernel_op_attributes(node.type)
             if kernel_attributes is None or len(kernel_attributes) == 0:
-                Logger.error(f"Expected to find attributes but found {kernel_attributes}")
+                Logger.critical(f"Expected to find kernel attributes but none were identified for node '{node.name}' of type {node.type}.")
 
             for attr in kernel_attributes:
                 attributes_with_axis[attr] = fw_info.kernel_channels_mapping.get(node.type)
@@ -273,7 +273,7 @@ def _prune_pytorch_edge_node(node: BaseNode,
         elif node.type == torch.nn.Linear:
             node.framework_attr[OUT_FEATURES] = int(np.sum(mask))
         else:
-            Logger.exception(f"{node.type} is currently not supported"
+            Logger.critical(f"{node.type} is currently not supported"
                              f"as an edge node in a pruning section")
 
     if is_exit_node:
@@ -282,7 +282,7 @@ def _prune_pytorch_edge_node(node: BaseNode,
         elif node.type == torch.nn.Linear:
             node.framework_attr[IN_FEATURES] = int(np.sum(mask))
         else:
-            Logger.exception(f"{node.type} is currently not supported"
+            Logger.critical(f"{node.type} is currently not supported"
                              f"as an edge node in a pruning section")
         # Adjust the input shape for the last node in the section.
         _edit_node_input_shape(node, mask_bool, fw_info)

model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -301,7 +301,7 @@ class PytorchImplementation(FrameworkImplementation):
         if quant_config.softmax_shift:
             substitutions_list.append(pytorch_softmax_shift())
         if quant_config.input_scaling:
-            raise Exception('Input scaling is currently not supported for Pytorch.')
+            Logger.critical('Input scaling is currently not supported for Pytorch.')
         return substitutions_list
 
     def get_substitutions_pre_build(self) -> List[common.BaseSubstitution]:

model_compression_toolkit/core/pytorch/reader/graph_builders.py

@@ -46,9 +46,7 @@ def extract_holder_weights(constant_name, node_target, model, weights, to_numpy)
     named_buffer_weights = {constant_name: to_numpy(parameter) for name, parameter in
                             model.named_buffers() if node_target == name}
     if len(named_parameters_weights) + len(named_buffer_weights) > 1:
-        raise Exception(
-            f'Constant parameter can only have one tensor. Here we have '
-            f'{len(named_parameters_weights)+ len(named_buffer_weights)}')
+        Logger.critical("A single constant parameter must correspond to exactly one tensor. Found {len(named_parameters_weights) + len(named_buffer_weights)} parameters.")
 
     weights.update(named_parameters_weights)
     weights.update(named_buffer_weights)
@@ -108,13 +106,13 @@ def nodes_builder(model: GraphModule,
             elif hasattr(torch.Tensor, node.target):
                 node_type = getattr(torch.Tensor, node.target)
             else:
-                raise Exception(f'Call method of type \'{node.target}\' is currently not supported.')
+                Logger.critical(f"The call method '{node.target}' is not supported.")
         elif node.op == GET_ATTR:
             Logger.warning(
                 'Pytorch model has a parameter or constant Tensor value. This can cause unexpected behaviour when '
                 'converting the model.')
         else:
-            raise Exception(f'Unknown node type: {node.name}')
+            Logger.critical(f'Encountered an unsupported node type in node: {node.name}.')
 
         # extract layer weights and named buffers
         weights = {}
@@ -129,7 +127,7 @@ def nodes_builder(model: GraphModule,
         if node.op == GET_ATTR:
             new_const = extract_holder_weights(node, node.target, model, weights, to_numpy)
             if list(new_const.keys())[0] in consts_dict:
-                Logger.error('Constant weight recorded twice')
+                Logger.critical('A constant weight appears to have been recorded multiple times.')
             consts_dict.update(new_const)
             continue
 
@@ -219,7 +217,7 @@ def nodes_builder(model: GraphModule,
     # make sure all extracted constants were used in the graph
     not_connected_consts = [c for c in consts_dict if c not in used_consts]
     if not_connected_consts:
-        Logger.error(f'error reading graph - constants not connected in graph: {not_connected_consts}')
+        Logger.critical(f'Error reading graph: These constants are not connected in the graph: {not_connected_consts}.')
 
     # generate graph outputs list
     for node in output_nodes: