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

model_compression_toolkit/core/common/pruning/memory_calculator.py

@@ -207,13 +207,13 @@ class MemoryCalculator:
         kernel_attr = self.fw_info.get_kernel_op_attributes(node.type)
         # Ensure only one kernel attribute exists for the given node.
         if len(kernel_attr) != 1:
-            Logger.error(f"Expected to found a single attribute but found {len(kernel_attr)} for node {node}")
+            Logger.critical(f"Expected a single attribute, but found {len(kernel_attr)} attributes for node '{node}'. Ensure the node configuration is correct.")
         kernel_attr = kernel_attr[0]
 
         # Retrieve and validate the axis index for the output channels.
         _, ic_axis = self.fw_info.kernel_channels_mapping.get(node.type)
         if ic_axis is None or int(ic_axis) != ic_axis:
-            Logger.error(f"Expected input channel axis to be an integer but is {ic_axis} for node {node}")
+            Logger.critical(f"Invalid input channel axis type for node '{node}': expected integer but got '{ic_axis}'.")
 
         # Get the number of output channels based on the kernel attribute and axis.
         num_ic = node.get_weights_by_keys(kernel_attr).shape[ic_axis]
@@ -295,7 +295,7 @@ class MemoryCalculator:
         for w_attr, w in node.weights.items():
             io_axis = [io_axis for attr, io_axis in attributes_and_oc_axis.items() if attr in w_attr]
             if len(io_axis) != 1:
-                Logger.error(f"Each weight should have exactly one corresponding IO axis, but is {io_axis} ")
+                Logger.critical(f"Each weight must correspond to exactly one IO (Input/Output) axis; however, the current configuration has '{io_axis}' axes.")
             out_axis, in_axis = io_axis[0]
 
             # Apply input and output masks to the weight tensor.
@@ -313,7 +313,7 @@ class MemoryCalculator:
             # Get the node channel axis from framework info
             channel_axis = self.fw_info.out_channel_axis_mapping.get(node.type)
             if channel_axis is None:
-                Logger.error("Channel axis is not defined")
+                Logger.critical(f"The channel axis is undefined. Please ensure the channel axis is explicitly defined for node {node.type} in the framework info.")
 
             # Check if node.output_shape is a list of lists.
             # In this case make sure all the out channels are the same value
@@ -322,7 +322,7 @@ class MemoryCalculator:
                 if all(len(sublist) > channel_axis and sublist[channel_axis] == compare_value for sublist in node.output_shape):
                     num_oc = compare_value
                 else:
-                    Logger.error("Number of out channels are not the same for all outputs of the node")
+                    Logger.critical("The number of output channels must be the same across all outputs of the node.")
             else:
                 num_oc = node.output_shape[channel_axis]
 
@@ -348,7 +348,7 @@ class MemoryCalculator:
         """
         mask = np.ones(w.shape[axis], dtype=bool) if mask is None else mask.astype(bool)
         if w.shape[axis] != len(mask):
-            Logger.error(f"Expected mask length {len(mask)}, found {w.shape[axis]}.")
+            Logger.critical(f"Expected a mask length of {len(mask)}, but got {w.shape[axis]}. Ensure the mask aligns with the tensor shape.")
         pruned_w = np.take(w, np.where(mask)[0], axis=axis)
         return pruned_w
 
@@ -370,7 +370,7 @@ class MemoryCalculator:
             The adjusted number of parameters considering padded channels.
         """
         if not (num_oc >= 1 and int(num_oc) == num_oc):
-            Logger.error(f"Expected number of output channels to be a non-negative integer but is {num_oc}")
+            Logger.critical(f"Expected the number of output channels to be a non-negative integer, but received '{num_oc}'.")
 
         nparams_per_oc = node_nparams / num_oc
         if int(nparams_per_oc) != nparams_per_oc:

model_compression_toolkit/core/common/pruning/prune_graph.py

@@ -50,8 +50,7 @@ def build_pruned_graph(graph: Graph,
 
     # Check that each entry node corresponds to a pruning section has an output-channel mask.
     if len(pruning_sections) != len(masks):
-        Logger.error(f"Expected to find same number of masks as number of pruning sections,"
-                     f"but {len(masks)} masks were given and found {len(pruning_sections)} pruning sections.")
+        Logger.critical(f"Expected to find the same number of masks as the number of pruning sections, but {len(masks)} masks were given for {len(pruning_sections)} pruning sections.") # progmra: no cover
 
     # Apply the pruning masks to each pruning section.
     for pruning_section in pruning_sections:
@@ -59,7 +58,7 @@ def build_pruned_graph(graph: Graph,
         # Retrieve the corresponding mask using the node's name (since we use a graph's copy).
         mask = [v for k, v in masks.items() if k.name == pruning_section.entry_node.name]
         if len(mask) != 1:
-            Logger.error(f"Expected to find a single node with name {pruning_section.entry_node.name} in masks dictionary but found {len(mask)}")
+            Logger.critical(f"Expected to find a single node with name {pruning_section.entry_node.name} in masks dictionary, but found {len(mask)}.")
         mask = mask[0]
 
         # If the mask indicates that some channels are to be pruned, apply it.

model_compression_toolkit/core/common/pruning/pruner.py

@@ -18,7 +18,7 @@ from typing import Callable, List, Dict, Tuple
 
 from model_compression_toolkit.core.common import Graph, BaseNode
 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.pruning.greedy_mask_calculator import GreedyMaskCalculator
 from model_compression_toolkit.core.common.pruning.importance_metrics.importance_metric_factory import \
     get_importance_metric
@@ -33,14 +33,14 @@ from model_compression_toolkit.target_platform_capabilities.target_platform impo
 
 class Pruner:
     """
-    Pruner class responsible for applying pruning to a computational graph to meet a target KPI.
+    Pruner class responsible for applying pruning to a computational graph to meet a target resource utilization.
     It identifies and prunes less significant channels based on importance scores, considering SIMD constraints.
     """
     def __init__(self,
                  float_graph: Graph,
                  fw_info: FrameworkInfo,
                  fw_impl: PruningFrameworkImplementation,
-                 target_kpi: KPI,
+                 target_resource_utilization: ResourceUtilization,
                  representative_data_gen: Callable,
                  pruning_config: PruningConfig,
                  target_platform_capabilities: TargetPlatformCapabilities):
@@ -49,7 +49,7 @@ class Pruner:
             float_graph (Graph): The floating-point representation of the model's computation graph.
             fw_info (FrameworkInfo): Contains metadata and helper functions for the framework.
             fw_impl (PruningFrameworkImplementation): Implementation of specific framework methods required for pruning.
-            target_kpi (KPI): The target KPIs to be achieved after pruning.
+            target_resource_utilization (ResourceUtilization): The target resource utilization to be achieved after pruning.
             representative_data_gen (Callable): Generator function for representative dataset used in pruning analysis.
             pruning_config (PruningConfig): Configuration object specifying how pruning should be performed.
             target_platform_capabilities (TargetPlatformCapabilities): Object encapsulating the capabilities of the target hardware platform.
@@ -57,7 +57,7 @@ class Pruner:
         self.float_graph = float_graph
         self.fw_info = fw_info
         self.fw_impl = fw_impl
-        self.target_kpi = target_kpi
+        self.target_resource_utilization = target_resource_utilization
         self.representative_data_gen = representative_data_gen
         self.pruning_config = pruning_config
         self.target_platform_capabilities = target_platform_capabilities
@@ -84,7 +84,7 @@ class Pruner:
             mask_calculator = GreedyMaskCalculator(entry_nodes,
                                                    self.fw_info,
                                                    self.simd_scores,
-                                                   self.target_kpi,
+                                                   self.target_resource_utilization,
                                                    self.float_graph,
                                                    self.fw_impl,
                                                    self.target_platform_capabilities,
@@ -92,7 +92,7 @@ class Pruner:
             mask_calculator.compute_mask()
             self.per_oc_mask = mask_calculator.get_mask()
         else:
-            Logger.error("Only GREEDY ChannelsFilteringStrategy is currently supported.")
+            Logger.critical("Only GREEDY ChannelsFilteringStrategy is currently supported.")
 
         Logger.info("Start pruning graph...")
         _pruned_graph = build_pruned_graph(self.float_graph,

model_compression_toolkit/core/common/pruning/pruning_config.py

@@ -32,7 +32,7 @@ class ChannelsFilteringStrategy(Enum):
     """
     Enum for specifying the strategy used for filtering (pruning) channels:
 
-    GREEDY - Prune the least important channel groups up to allowed resources in the KPI (for now, only weights_memory is considered).
+    GREEDY - Prune the least important channel groups up to the allowed resources utilization limit (for now, only weights_memory is considered).
 
     """
     GREEDY = 0  # Greedy strategy for pruning channels based on importance metrics.

model_compression_toolkit/core/common/pruning/pruning_info.py

@@ -75,8 +75,8 @@ def unroll_simd_scores_to_per_channel_scores(simd_scores: Dict[BaseNode, np.ndar
         Dict[BaseNode, np.ndarray]: Expanded scores for each individual channel.
     """
     if simd_scores is None or simd_groups_indices is None:
-        Logger.error(f"Found to find scores and indices to create an unrolled scores for pruning info,"
-                     f"but scores is {simd_scores} and groups indices are {simd_groups_indices}")
+        Logger.critical(f"Failed to find scores and indices to create unrolled scores for pruning information."
+                        f" Scores: {simd_scores}, Group indices: {simd_groups_indices}.")
     _scores = {}
     for node, groups_indices in simd_groups_indices.items():
         node_scores = simd_scores[node]

model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py

@@ -59,8 +59,10 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
             self.activation_quantization_cfg = activation_quantization_cfg
         else:
             if any(v is None for v in (qc, op_cfg, activation_quantization_fn, activation_quantization_params_fn)):
-                Logger.error("Missing some required arguments to initialize "
-                             "a node activation quantization configuration.")
+                Logger.critical(
+                    "Missing required arguments to initialize a node activation quantization configuration. "
+                    "Ensure QuantizationConfig, OpQuantizationConfig, activation quantization function, "
+                    "and parameters function are provided.")
             self.activation_quantization_cfg = (
                 NodeActivationQuantizationConfig(qc=qc,
                                                  op_cfg=op_cfg,
@@ -71,8 +73,9 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
             self.weights_quantization_cfg = weights_quantization_cfg
         else:
             if any(v is None for v in (qc, op_cfg, node_attrs_list)):
-                Logger.error("Missing some required arguments to initialize "
-                             "a node weights quantization configuration.")
+                Logger.critical("Missing required arguments to initialize a node weights quantization configuration. "
+                                "Ensure QuantizationConfig, OpQuantizationConfig, weights quantization function, "
+                                "parameters function, and weights attribute quantization config are provided.")
             self.weights_quantization_cfg = NodeWeightsQuantizationConfig(qc=qc, op_cfg=op_cfg,
                                                                           weights_channels_axis=weights_channels_axis,
                                                                           node_attrs_list=node_attrs_list)

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -122,7 +122,9 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
                                                      self.activation_quantization_params)
 
         if fake_quant is None:
-            Logger.error('Layer is meant to be quantized but fake_quant function is None')  # pragma: no cover
+            Logger.critical(
+                "Layer is intended to be quantized, but the fake_quant function is None.")  # pragma: no cover
+
         return fake_quant(tensors)
 
     @property

model_compression_toolkit/core/common/quantization/quantization_fn_selection.py

@@ -16,6 +16,7 @@
 from collections.abc import Callable
 from functools import partial
 
+from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.core.common.quantization.quantizers.lut_kmeans_quantizer import lut_kmeans_quantizer
 from model_compression_toolkit.core.common.quantization.quantizers.uniform_quantizers import power_of_two_quantizer, \
@@ -42,6 +43,7 @@ def get_weights_quantization_fn(weights_quantization_method: QuantizationMethod)
     elif weights_quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER, QuantizationMethod.LUT_SYM_QUANTIZER]:
         quantizer_fn = lut_kmeans_quantizer
     else:
-        raise Exception(
-            f'No quantizer function for the configuration of quantization method {weights_quantization_method}')
+        Logger.critical(
+            f"No quantizer function found for the specified quantization method: {weights_quantization_method}")
+
     return quantizer_fn

model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py

@@ -47,9 +47,8 @@ def get_activation_quantization_params_fn(activation_quantization_method: Quanti
     elif activation_quantization_method == QuantizationMethod.LUT_POT_QUANTIZER:
         params_fn = lut_kmeans_histogram
     else:
-        Logger.error(
-            f'No params function for the configuration of '
-            f'quantization method {activation_quantization_method}')  # pragma: no cover
+        Logger.critical(
+            f"No parameter function found for the specified quantization method: {activation_quantization_method}")  # pragma: no cover
     return params_fn
 
 
@@ -74,7 +73,6 @@ def get_weights_quantization_params_fn(weights_quantization_method: Quantization
     elif weights_quantization_method == QuantizationMethod.LUT_SYM_QUANTIZER:
         params_fn = partial(lut_kmeans_tensor, is_symmetric=True)
     else:
-        Logger.error(
-            f'No params function for the configuration of '
-            f'quantization method {weights_quantization_method}')  # pragma: no cover
+        Logger.critical(
+            f"No parameter function found for the specified quantization method: {weights_quantization_method}")  # pragma: no cover
     return params_fn

model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py

@@ -60,8 +60,7 @@ def lut_kmeans_tensor(tensor_data: np.ndarray,
         the thresholds per channel and the multiplier num bits.
     """
     if n_bits >= LUT_VALUES_BITWIDTH:
-        Logger.critical(f'Look-Up-Table bit configuration has {n_bits} bits, but must be less than '
-                        f'{LUT_VALUES_BITWIDTH}')  # pragma: no cover
+        Logger.critical(f'Look-Up-Table (LUT) bit configuration exceeds maximum: {n_bits} bits provided, must be less than {LUT_VALUES_BITWIDTH} bits.')  # pragma: no cover
     # TODO: need to set this externally
     if len(np.unique(tensor_data.flatten())) < 2 ** n_bits:
         n_clusters = len(np.unique(tensor_data.flatten()))
@@ -121,8 +120,7 @@ def lut_kmeans_histogram(bins: np.ndarray,
     """
 
     if n_bits >= LUT_VALUES_BITWIDTH:
-        Logger.critical(f'Look-Up-Table bit configuration has {n_bits} bits. It must be less then '
-                        f'{LUT_VALUES_BITWIDTH}')  # pragma: no cover
+        Logger.critical(f'Look-Up-Table (LUT) bit configuration exceeds maximum: {n_bits} bits provided, must be less than {LUT_VALUES_BITWIDTH} bits.')  # pragma: no cover
 
     bins_with_values = np.abs(bins)[1:][counts > 0]
     if len(np.unique(bins_with_values.flatten())) < 2 ** n_bits:

model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py

@@ -238,7 +238,7 @@ def get_tensor_max(tensor_data: np.ndarray,
 
     """
     if n_bits < 1:
-        Logger.error("n_bits must be positive")
+        Logger.critical(f"Parameter n_bits must be positive; however 'n_bits'={n_bits} was provided.")
     if is_uniform_quantization:
         expansion_factor = 1.0
     elif n_bits == 1:

model_compression_toolkit/core/common/quantization/quantizers/uniform_quantizers.py

@@ -52,11 +52,13 @@ def power_of_two_quantizer(tensor_data: np.ndarray,
     """
     threshold = quantization_params.get(THRESHOLD)
     if threshold is None:
-        Logger.error(f"{THRESHOLD} parameter must be defined in 'quantization_params'")  # pragma: no cover
+        Logger.critical(f"'{THRESHOLD}' parameter must be defined in 'quantization_params'")  # pragma: no cover
+
     if not threshold_is_power_of_two(threshold, per_channel):
-        Logger.error(f"Expects {THRESHOLD} parameter to be a power of two, but got {threshold}")  # pragma: no cover
+        Logger.critical(f"Expected '{THRESHOLD}' parameter to be a power of two, but received {threshold}.")# pragma: no cover
+
     if (per_channel and (threshold <= 0).any()) or ((not per_channel) and threshold <= 0):
-        Logger.error(f"{THRESHOLD} parameter must positive")  # pragma: no cover
+        Logger.critical(f"'{THRESHOLD}' parameter must positive")  # pragma: no cover
 
 
     return quantize_tensor(tensor_data,
@@ -88,10 +90,10 @@ def symmetric_quantizer(tensor_data: np.ndarray,
     """
     threshold = quantization_params.get(THRESHOLD)
     if threshold is None:
-        Logger.error(f"{THRESHOLD} parameter must be defined in 'quantization_params'")  # pragma: no cover
+        Logger.critical(f"'{THRESHOLD}' parameter must be defined in 'quantization_params'")  # pragma: no cover
 
     if (per_channel and np.any(threshold <= 0)) or (not per_channel and threshold <= 0):
-        Logger.error(f"{THRESHOLD} parameter must positive")  # pragma: no cover
+        Logger.critical(f"'{THRESHOLD}' parameter must positive")  # pragma: no cover
 
     return quantize_tensor(tensor_data,
                            threshold,
@@ -122,6 +124,6 @@ def uniform_quantizer(tensor_data: np.ndarray,
     range_min = quantization_params.get(RANGE_MIN)
     range_max = quantization_params.get(RANGE_MAX)
     if range_min is None or range_max is None:
-        Logger.error("'quantization range' parameters must be defined in 'quantization_params'")  # pragma: no cover
+        Logger.critical("'quantization range' parameters must be defined in 'quantization_params'")  # pragma: no cover
 
     return uniform_quantize_tensor(tensor_data, range_min, range_max, n_bits)

model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -112,7 +112,7 @@ def create_node_activation_qc(qc: QuantizationConfig,
 
     activation_quantization_fn = fw_info.activation_quantizer_mapping.get(op_cfg.activation_quantization_method)
     if activation_quantization_fn is None:
-        Logger.critical('Unknown quantization method for activations')  # pragma: no cover
+        Logger.critical('Unknown activation quantization method specified.')  # pragma: no cover
 
     activation_quantization_params_fn = get_activation_quantization_params_fn(op_cfg.activation_quantization_method)
 
@@ -149,7 +149,7 @@ def _create_node_single_candidate_qc(qc: QuantizationConfig,
     # get parameters for activation quantization
     activation_quantization_fn = fw_info.activation_quantizer_mapping.get(op_cfg.activation_quantization_method)
     if activation_quantization_fn is None:
-        Logger.critical('Unknown quantization method for activations')  # pragma: no cover
+        Logger.critical('Unknown activation quantization method specified.')  # pragma: no cover
 
     activation_quantization_params_fn = get_activation_quantization_params_fn(op_cfg.activation_quantization_method)
 

model_compression_toolkit/core/common/statistics_correction/compute_bias_correction_of_graph.py

@@ -190,13 +190,11 @@ def _get_bias_correction_term_of_node(input_channels_axis: int,
     """
 
     if output_channels_axis is None:
-        Logger.error(
-            f'Unknown output channel axis for node named: {n.name},'
-            f' please update channel mapping function')
+        Logger.critical(
+            f'Unknown output channel axis for node: {n.name}. Please update the channel mapping function.')
     if input_channels_axis is None:
-        Logger.error(
-            f'Unknown input channel axis for node named: {n.name},'
-            f' please update channel mapping function')
+        Logger.critical(
+            f'Unknown input channel axis for node: {n.name}. Please update the channel mapping function')
     # Compute the bias correction term.
     correction = _compute_bias_correction(n.get_weights_by_keys(fw_impl.constants.KERNEL),
                                           quantized_kernel,

model_compression_toolkit/core/common/substitutions/batchnorm_refusing.py

@@ -103,15 +103,13 @@ class BatchNormalizationRefusing(common.BaseSubstitution):
         # If the linear operator is part of a reused group (it is the "base" node, or a reused node),
         # we should skip the substitution.
         if source_node.is_reused():
-            Logger.exception("If the linear operator is part of a reused group we should skip the the BN folding "
-                             "substitution and SMC feature")  # pragma: no cover
+            Logger.critical("BN folding substitution cannot proceed if the linear operator is part of a reused group.")  # pragma: no cover
 
         bn_node = edge_nodes[1]
 
         if len(graph.get_next_nodes(source_node)) > 1 or len(graph.get_prev_nodes(bn_node)) > 1:
-            Logger.exception(
-                "If the linear operator has multiple outputs or the bn layer has multiple inputs we should "
-                "skip the the BN folding substitution and SMC feature")  # pragma: no cover
+            Logger.critical(
+                "BN folding substitution cannot proceed if the linear operator has multiple outputs or the BN layer has multiple inputs.")  # pragma: no cover
 
         kernel = source_node.get_weights_by_keys(self.kernel_str)
         bias = source_node.get_weights_by_keys(self.bias_str)
@@ -199,5 +197,4 @@ class BatchNormalizationRefusing(common.BaseSubstitution):
             conv_bn_kernel_cfg.set_weights_quantization_param(corr_dict)
 
         else:
-            Logger.exception("Second moment statistics correction feature disabled for models with weights "
-                             "quantization method of Power of 2")  # pragma: no cover
+            Logger.critical("Second moment statistics correction feature is not supported for weights quantization methods other than 'SYMMETRIC' and 'UNIFORM'.")  # pragma: no cover

model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -134,7 +134,7 @@ def insert_node_after_node(graph: Graph,
 
     last_nodes = graph.get_next_nodes(first_node)
     if len(last_nodes) != 1:
-        Logger.error('Can only insert if there is only one input')  # pragma: no cover
+        Logger.critical(f'Insertion requires exactly one successor node; {len(last_nodes)} successors found.')  # pragma: no cover
     last_node = last_nodes[0]
     insert_node_between_two_nodes(graph, node_to_insert, first_node, last_node)
 
@@ -156,7 +156,7 @@ def insert_node_before_node(graph: Graph,
     """
     first_nodes = graph.get_prev_nodes(last_node)
     if len(first_nodes) != 1:
-        Logger.error('Can only insert if there is only one input')  # pragma: no cover
+        Logger.critical('Insertion requires exactly one predecessor node; multiple or no predecessors found.')  # pragma: no cover
     first_node = first_nodes[0]
     insert_node_between_two_nodes(graph, node_to_insert, first_node, last_node)
 
@@ -235,7 +235,7 @@ def shift_negative_function(graph: Graph,
     min_to_correct, max_value2compare = graph.get_out_stats_collector(non_linear_node).get_min_max_values()
 
     if not non_linear_node.is_all_activation_candidates_equal():
-        Logger.error("Shift negative correction is not supported for more than one activation quantization "
+        Logger.critical("Shift negative correction is not supported for more than one activation quantization "
                      "configuration candidate")  # pragma: no cover
 
     # all candidates have same activation config, so taking the first candidate for calculations

model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py

@@ -48,7 +48,7 @@ class BaseVirtualActivationWeightsComposition(BaseSubstitution):
 
         if len(graph.out_edges(act_node)) > 1:
             Logger.warning(f"Node {act_node.name} has multiple outgoing edges, which is not supported with "
-                           f"mixed-precision bit-operations KPI, thus, edge {act_node.name} --> {weights_node.name} "
+                           f"mixed-precision bit-operations utilization, thus, edge {act_node.name} --> {weights_node.name} "
                            f"would not be counted in the bit-operations calculations.")
             return graph
 

model_compression_toolkit/core/common/substitutions/weights_activation_split.py

@@ -65,9 +65,9 @@ class BaseWeightsActivationSplit(BaseSubstitution):
                                    for c in node.candidates_quantization_cfg]
             if not set(expected_candidates).issubset(all_candidates_bits):
                 # Node is not composite, therefore, can't be split
-                Logger.critical(f"The graph contains a node {node.name} with non composite candidates."
-                                f"In order to run mixed-precision search with BOPS target KPI, "
-                                f"all model layers should be composite.")  # pragma: no cover
+                Logger.critical(f"The node {node.name} cannot be split as it has non-composite candidates. "
+                                f"For mixed-precision search with BOPS target resource utilization, "
+                                f"all model layers must be composite.")  # pragma: no cover
 
         weights_node = VirtualSplitWeightsNode(node, kernel_attr)
         activation_node = VirtualSplitActivationNode(node, self.activation_layer_type, self.fw_attr)

model_compression_toolkit/core/common/user_info.py

@@ -29,7 +29,7 @@ class UserInformation:
         self.input_scale = 1
         self.gptq_info_dict = dict()
         self.mixed_precision_cfg = None
-        self.final_kpi = None
+        self.final_resource_utilization = None
 
     def set_input_scale(self, scale_value: float):
         """

model_compression_toolkit/core/keras/back2framework/factory_model_builder.py

@@ -38,9 +38,9 @@ def get_keras_model_builder(mode: ModelBuilderMode) -> type:
     """
 
     if not isinstance(mode, ModelBuilderMode):
-        Logger.error(f'get_keras_model_builder expects a mode of type ModelBuilderMode, but {type(mode)} was passed.')
+        Logger.critical(f"Expected a ModelBuilderMode type for 'mode', but received {type(mode)} instead.")
     if mode is None:
-        Logger.error(f'get_keras_model_builder received a mode which is None')
+        Logger.critical(f"get_keras_model_builder received 'mode' is None")
     if mode not in keras_model_builders.keys():
-        Logger.error(f'mode {mode} is not in keras model builders factory')
+        Logger.critical(f"'mode' {mode} is not recognized in the Keras model builders factory.")
     return keras_model_builders.get(mode)

model_compression_toolkit/core/keras/back2framework/instance_builder.py

@@ -88,8 +88,8 @@ def node_builder(n: common.BaseNode) -> Layer:
     try:
         node_instance = _layer_class.from_config(framework_attr)  # Build layer from node's configuration.
     except Exception as e:
-        print(e) # pragma: no cover
-        Logger.error(
+        Logger.info(e) # pragma: no cover
+        Logger.critical(
             f"Keras can not de-serialize layer {_layer_class} in order to build a static graph representation. This is probably because "
             f"your model contains custom layers which MCT doesn't support. Please provide a model without custom layers.") # pragma: no cover
     with tf.name_scope(n.name):

model_compression_toolkit/core/keras/back2framework/mixed_precision_model_builder.py

@@ -104,8 +104,7 @@ class MixedPrecisionKerasModelBuilder(KerasModelBuilder):
                 #  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 unique weights 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
@@ -143,8 +142,7 @@ class MixedPrecisionKerasModelBuilder(KerasModelBuilder):
 
         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 defined; found multiple potential maximal candidates.")# pragma: no cover
 
         max_candidate_idx = max_cfg_candidates[0]
 
@@ -211,8 +209,7 @@ class MixedPrecisionKerasModelBuilder(KerasModelBuilder):
         if len(activation_quantizers) == 1:
             return KerasActivationQuantizationHolder(activation_quantizers[0])
 
-        Logger.error(f'KerasActivationQuantizationHolder supports a single quantizer but '  # pragma: no cover
-                     f'{len(activation_quantizers)} quantizers were found for node {n}')
+        Logger.critical(f"'KerasActivationQuantizationHolder' supports only one quantizer, but found {len(activation_quantizers)} for node {n}")# pragma: no cover
 
     def build_model(self) -> Tuple[Model, UserInformation,
                                    Dict[str, Union[KerasQuantizationWrapper, KerasActivationQuantizationHolder]]]:
@@ -292,6 +289,5 @@ class MixedPrecisionKerasModelBuilder(KerasModelBuilder):
         elif weights_quant and act_quant:
             return self._get_weights_quant_layers(n, layers_list) + self._get_activation_quant_layers(n, layers_list)
         else:
-            Logger.error(f"Expects node {n.name} to have at either weights or activation quantization configured,"  # pragma: no cover
-                         f"but both are disabled.")
+            Logger.critical(f"Expected node {n.name} to have either weights or activation quantization configured, but both are disabled.")# pragma: no cover
 

model_compression_toolkit/core/keras/graph_substitutions/substitutions/input_scaling.py

@@ -25,6 +25,7 @@ from model_compression_toolkit.core.common.graph.base_node import BaseNode
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
 from model_compression_toolkit.constants import THRESHOLD
 from model_compression_toolkit.core.keras.constants import KERNEL
+from model_compression_toolkit.logger import Logger
 
 input_node = NodeOperationMatcher(InputLayer)
 zeropad_node = NodeOperationMatcher(ZeroPadding2D)
@@ -80,8 +81,8 @@ class BaseInputScaling(common.BaseSubstitution):
         linear_layer = nodes_list[-1]
 
         if not input_layer.is_all_activation_candidates_equal():
-            raise Exception("Input scaling is not supported for more than one activation quantization configuration "
-                            "candidate")
+            Logger.critical("Input scaling is not supported for nodes with more than one activation quantization configuration "
+                            "candidate.")
 
         # all candidates have same activation config, so taking the first candidate for calculations
         threshold = input_layer.candidates_quantization_cfg[0].activation_quantization_cfg.activation_quantization_params.get(THRESHOLD)

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

@@ -104,7 +104,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 unsupported for combination: {first_node.type} and {second_node.type}.")
 
 
 def keras_linear_collapsing() -> Conv2DCollapsing:
@@ -161,7 +161,7 @@ def op2d_add_const_collapsing_fn(op2d_node: BaseNode,
     # read constant from add node (either 1st or 2nd positional weight)
     const = add_node.weights.get(0, add_node.weights.get(1))
     if const is None:
-        Logger.error(f'Unable to read constant from add node: {add_node.name}')  # pragma: no cover
+        Logger.critical(f'Failed to read constant from add node: {add_node.name}.')  # pragma: no cover
 
     # return new bias
     if bias is None:

model_compression_toolkit/core/keras/graph_substitutions/substitutions/matmul_substitution.py

@@ -66,7 +66,7 @@ class MatmulToDenseSubstitution(common.BaseSubstitution):
         # read const from matmul inputs
         w = matmul_node.weights.get(1)
         if w is None:
-            Logger.error(f"Matmul substitution: can't locate weight for node {matmul_node.name}")  # pragma: no cover
+            Logger.critical(f"Matmul substitution failed: Unable to locate weight for node {matmul_node.name}.")  # pragma: no cover
 
         if len(w.shape) != 2:
             # weight tensor should be of shape (Cin, Cout)

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

@@ -448,7 +448,7 @@ class MultiHeadAttentionDecomposition(common.BaseSubstitution):
         """
 
         if mha_node.reuse:
-            Logger.error("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)
 
         mha_in_edges = graph.in_edges(mha_node)

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

@@ -62,7 +62,7 @@ def residual_collapsing_fn(first_node: BaseNode,
 
         return kernel
     else:
-        Logger.error("No supported add residual collapsing for {}".format(first_node.type))
+        Logger.critical(f"Residual collapsing is unsupported for {first_node.type} node types.")
 
 
 def keras_residual_collapsing() -> ResidualCollapsing:

model_compression_toolkit/core/keras/hessian/activation_trace_hessian_calculator_keras.py

@@ -64,7 +64,7 @@ class ActivationTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
             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. "
+                Logger.critical("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.")
 
@@ -83,7 +83,7 @@ class ActivationTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
                     outputs = model(*self.input_images)
 
                 if len(outputs) != len(grad_model_outputs):
-                    Logger.error(
+                    Logger.critical(
                         f"Model for computing activation Hessian approximation expects {len(grad_model_outputs)} "
                         f"outputs, but got {len(outputs)} output tensors.")
 
@@ -166,4 +166,4 @@ class ActivationTraceHessianCalculatorKeras(TraceHessianCalculatorKeras):
             return trace_approx_by_node.numpy().tolist()
 
         else:
-            Logger.error(f"{self.hessian_request.granularity} is not supported for Keras activation hessian's trace approx calculator")
+            Logger.critical(f"{self.hessian_request.granularity} is not supported for Keras activation hessian\'s trace approximation calculator.")

model_compression_toolkit/core/keras/hessian/trace_hessian_calculator_keras.py

@@ -74,7 +74,6 @@ class TraceHessianCalculatorKeras(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.")# pragma: no cover
 
         return tf.concat(_r_tensors, axis=1)