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

model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py

@@ -19,27 +19,28 @@ from tqdm import tqdm
 from typing import Dict, List, Tuple, Callable
 
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI, KPITarget
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import MixedPrecisionSearchManager
 
 # Limit ILP solver runtime in seconds
 SOLVER_TIME_LIMIT = 60
 
+
 def mp_integer_programming_search(search_manager: MixedPrecisionSearchManager,
-                                  target_kpi: KPI = None) -> List[int]:
+                                  target_resource_utilization: ResourceUtilization = None) -> List[int]:
     """
     Searching and returning a mixed-precision configuration using an ILP optimization solution.
     It first builds a mapping from each layer's index (in the model) to a dictionary that maps the
     bitwidth index to the observed sensitivity of the model when using that bitwidth for that layer.
     Then, it creates a mapping from each node's index (in the graph) to a dictionary
     that maps the bitwidth index to the contribution of configuring this node with this
-    bitwidth to the minimal possible KPI of the model.
+    bitwidth to the minimal possible resource utilization of the model.
     Then, and using these mappings, it builds an LP problem and finds an optimal solution.
     If a solution could not be found, exception is thrown.
 
     Args:
         search_manager: MixedPrecisionSearchManager object to be used for problem formalization.
-        target_kpi: KPI to constrain our LP problem with some resources limitations (like model' weights memory
+        target_resource_utilization: Target resource utilization to constrain our LP problem with some resources limitations (like model' weights memory
         consumption).
 
     Returns:
@@ -50,11 +51,11 @@ def mp_integer_programming_search(search_manager: MixedPrecisionSearchManager,
     # Build a mapping from each layer's index (in the model) to a dictionary that maps the
     # bitwidth index to the observed sensitivity of the model when using that bitwidth for that layer.
 
-    if target_kpi is None or search_manager is None:
-        Logger.critical("Can't run mixed precision search with given target_kpi=None or search_manager=None."
-                        "Please provide a valid target_kpi and check the mixed precision parameters values.")
+    if target_resource_utilization is None or search_manager is None:
+        Logger.critical("Invalid parameters: 'target_resource_utilization' and 'search_manager' must not be 'None' "
+                        "for mixed-precision search. Ensure valid inputs are provided.")
 
-    layer_to_metrics_mapping = _build_layer_to_metrics_mapping(search_manager, target_kpi)
+    layer_to_metrics_mapping = _build_layer_to_metrics_mapping(search_manager, target_resource_utilization)
 
     # Init variables to find their values when solving the lp problem.
     layer_to_indicator_vars_mapping, layer_to_objective_vars_mapping = _init_problem_vars(layer_to_metrics_mapping)
@@ -63,7 +64,7 @@ def mp_integer_programming_search(search_manager: MixedPrecisionSearchManager,
     lp_problem = _formalize_problem(layer_to_indicator_vars_mapping,
                                     layer_to_metrics_mapping,
                                     layer_to_objective_vars_mapping,
-                                    target_kpi,
+                                    target_resource_utilization,
                                     search_manager)
 
     # Use default PULP solver. Limit runtime in seconds
@@ -81,7 +82,7 @@ def mp_integer_programming_search(search_manager: MixedPrecisionSearchManager,
          in layer_to_indicator_vars_mapping.values()]
     ).flatten()
 
-    if target_kpi.bops < np.inf:
+    if target_resource_utilization.bops < np.inf:
         return search_manager.config_reconstruction_helper.reconstruct_config_from_virtual_graph(config)
     else:
         return config
@@ -122,7 +123,7 @@ def _init_problem_vars(layer_to_metrics_mapping: Dict[int, Dict[int, float]]) ->
 def _formalize_problem(layer_to_indicator_vars_mapping: Dict[int, Dict[int, LpVariable]],
                        layer_to_metrics_mapping: Dict[int, Dict[int, float]],
                        layer_to_objective_vars_mapping: Dict[int, LpVariable],
-                       target_kpi: KPI,
+                       target_resource_utilization: ResourceUtilization,
                        search_manager: MixedPrecisionSearchManager) -> LpProblem:
     """
     Formalize the LP problem by defining all inequalities that define the solution space.
@@ -134,8 +135,8 @@ def _formalize_problem(layer_to_indicator_vars_mapping: Dict[int, Dict[int, LpVa
         evaluation.
         layer_to_objective_vars_mapping: Dictionary that maps each node's index to a bitwidth variable we find its
         value.
-        target_kpi: KPI to reduce our feasible solution space.
-        search_manager: MixedPrecisionSearchManager object to be used for kpi constraints formalization.
+        target_resource_utilization: Target resource utilization to reduce our feasible solution space.
+        search_manager: MixedPrecisionSearchManager object to be used for resource utilization constraints formalization.
 
     Returns:
         The formalized LP problem.
@@ -155,9 +156,9 @@ def _formalize_problem(layer_to_indicator_vars_mapping: Dict[int, Dict[int, LpVa
         lp_problem += lpSum(
             [v for v in layer_to_indicator_vars_mapping[layer].values()]) == 1
 
-    # Bound the feasible solution space with the desired KPI.
-    # Creates separate constraints for weights KPI and activation KPI.
-    if target_kpi is not None:
+    # Bound the feasible solution space with the desired resource utilization values.
+    # Creates separate constraints for weights utilization and activation utilization.
+    if target_resource_utilization is not None:
         indicators = []
         for layer in layer_to_metrics_mapping.keys():
             for _, indicator in layer_to_indicator_vars_mapping[layer].items():
@@ -166,73 +167,76 @@ def _formalize_problem(layer_to_indicator_vars_mapping: Dict[int, Dict[int, LpVa
         indicators_arr = np.array(indicators)
         indicators_matrix = np.diag(indicators_arr)
 
-        for target, kpi_value in target_kpi.get_kpi_dict().items():
-            if not np.isinf(kpi_value):
-                non_conf_kpi_vector = None if search_manager.non_conf_kpi_dict is None \
-                    else search_manager.non_conf_kpi_dict.get(target)
-                _add_set_of_kpi_constraints(search_manager=search_manager,
-                                            target=target,
-                                            target_kpi_value=kpi_value,
-                                            indicators_matrix=indicators_matrix,
-                                            lp_problem=lp_problem,
-                                            non_conf_kpi_vector=non_conf_kpi_vector)
+        for target, ru_value in target_resource_utilization.get_resource_utilization_dict().items():
+            if not np.isinf(ru_value):
+                non_conf_ru_vector = None if search_manager.non_conf_ru_dict is None \
+                    else search_manager.non_conf_ru_dict.get(target)
+                _add_set_of_ru_constraints(search_manager=search_manager,
+                                           target=target,
+                                           target_resource_utilization_value=ru_value,
+                                           indicators_matrix=indicators_matrix,
+                                           lp_problem=lp_problem,
+                                           non_conf_ru_vector=non_conf_ru_vector)
     else:  # pragma: no cover
-        raise Logger.critical("Can't run mixed-precision search with given target_kpi=None."
-                              "Please provide a valid target_kpi.")
+        Logger.critical("Unable to execute mixed-precision search: 'target_resource_utilization' is None. "
+                        "A valid 'target_resource_utilization' is required.")
     return lp_problem
 
 
-def _add_set_of_kpi_constraints(search_manager: MixedPrecisionSearchManager,
-                                target: KPITarget,
-                                target_kpi_value: float,
-                                indicators_matrix: np.ndarray,
-                                lp_problem: LpProblem,
-                                non_conf_kpi_vector: np.ndarray):
+def _add_set_of_ru_constraints(search_manager: MixedPrecisionSearchManager,
+                               target: RUTarget,
+                               target_resource_utilization_value: float,
+                               indicators_matrix: np.ndarray,
+                               lp_problem: LpProblem,
+                               non_conf_ru_vector: np.ndarray):
     """
-    Adding a constraint for the Lp problem for the given KPI target.
+    Adding a constraint for the Lp problem for the given target resource utilization.
     The update to the Lp problem object is done inplace.
 
     Args:
-        search_manager:  MixedPrecisionSearchManager object to be used for kpi constraints formalization.
-        target: A KPITarget.
-        target_kpi_value: Target KPI value of the given KPI target for which the constraint is added.
+        search_manager:  MixedPrecisionSearchManager object to be used for resource utilization constraints formalization.
+        target: A RUTarget.
+        target_resource_utilization_value: Target resource utilization value of the given target resource utilization
+        for which the constraint is added.
         indicators_matrix: A diagonal matrix of the Lp problem's indicators.
         lp_problem: An Lp problem object to add constraint to.
-        non_conf_kpi_vector: A non-configurable nodes' KPI vector.
+        non_conf_ru_vector: A non-configurable nodes' resource utilization vector.
 
     """
 
-    kpi_matrix = search_manager.compute_kpi_matrix(target)
-    indicated_kpi_matrix = np.matmul(kpi_matrix, indicators_matrix)
+    ru_matrix = search_manager.compute_resource_utilization_matrix(target)
+    indicated_ru_matrix = np.matmul(ru_matrix, indicators_matrix)
     # Need to re-organize the tensor such that the configurations' axis will be second,
     # and all metric values' axis will come afterword
-    indicated_kpi_matrix = np.moveaxis(indicated_kpi_matrix, source=len(indicated_kpi_matrix.shape) - 1, destination=1)
-
-    # In order to get the result KPI according to a chosen set of indicators, we sum each row in the result matrix.
-    # Each row represents the KPI values for a specific KPI metric, such that only elements corresponding
-    # to a configuration which implied by the set of indicators will have some positive value different than 0
-    # (and will contribute to the total KPI).
-    kpi_sum_vector = np.array([
-        np.sum(indicated_kpi_matrix[i], axis=0) +  # sum of metric values over all configurations in a row
-        search_manager.min_kpi[target][i] for i in range(indicated_kpi_matrix.shape[0])])
-
-    # search_manager.compute_kpi_functions contains a pair of kpi_metric and kpi_aggregation for each kpi target
-    # get aggregated KPI, considering both configurable and non-configurable nodes
-    if non_conf_kpi_vector is None or len(non_conf_kpi_vector) == 0:
-        aggr_kpi = search_manager.compute_kpi_functions[target][1](kpi_sum_vector)
+    indicated_ru_matrix = np.moveaxis(indicated_ru_matrix, source=len(indicated_ru_matrix.shape) - 1, destination=1)
+
+    # In order to get the result resource utilization according to a chosen set of indicators, we sum each row in
+    # the result matrix. Each row represents the resource utilization values for a specific resource utilization metric,
+    # such that only elements corresponding to a configuration which implied by the set of indicators will have some
+    # positive value different than 0 (and will contribute to the total resource utilization).
+    ru_sum_vector = np.array([
+        np.sum(indicated_ru_matrix[i], axis=0) +  # sum of metric values over all configurations in a row
+        search_manager.min_ru[target][i] for i in range(indicated_ru_matrix.shape[0])])
+
+    # search_manager.compute_ru_functions contains a pair of ru_metric and ru_aggregation for each ru target
+    # get aggregated ru, considering both configurable and non-configurable nodes
+    if non_conf_ru_vector is None or len(non_conf_ru_vector) == 0:
+        aggr_ru = search_manager.compute_ru_functions[target][1](ru_sum_vector)
     else:
-        aggr_kpi = search_manager.compute_kpi_functions[target][1](np.concatenate([kpi_sum_vector, non_conf_kpi_vector]))
+        aggr_ru = search_manager.compute_ru_functions[target][1](np.concatenate([ru_sum_vector, non_conf_ru_vector]))
 
-    for v in aggr_kpi:
+    for v in aggr_ru:
         if isinstance(v, float):
-            if v > target_kpi_value:
-                Logger.critical(f"The model can't be quantized to satisfy target KPI {target.value} with value {target_kpi_value}")  # pragma: no cover
+            if v > target_resource_utilization_value:
+                Logger.critical(
+                    f"The model cannot be quantized to meet the specified target resource utilization {target.value} "
+                    f"with the value {target_resource_utilization_value}.")  # pragma: no cover
         else:
-            lp_problem += v <= target_kpi_value
+            lp_problem += v <= target_resource_utilization_value
 
 
 def _build_layer_to_metrics_mapping(search_manager: MixedPrecisionSearchManager,
-                                    target_kpi: KPI,
+                                    target_resource_utilization: ResourceUtilization,
                                     eps: float = EPS) -> Dict[int, Dict[int, float]]:
     """
     This function measures the sensitivity of a change in a bitwidth of a layer on the entire model.
@@ -244,8 +248,8 @@ def _build_layer_to_metrics_mapping(search_manager: MixedPrecisionSearchManager,
 
     Args:
         search_manager: MixedPrecisionSearchManager object to be used for problem formalization.
-        target_kpi: KPI to constrain our LP problem with some resources limitations (like model' weights memory
-        consumption).
+        target_resource_utilization: ResourceUtilization to constrain our LP problem with some resources limitations
+        (like model' weights memory consumption).
         eps: Epsilon value to manually increase metric value (if necessary) for numerical stability
 
     Returns:
@@ -257,30 +261,30 @@ def _build_layer_to_metrics_mapping(search_manager: MixedPrecisionSearchManager,
     Logger.info('Starting to evaluate metrics')
     layer_to_metrics_mapping = {}
 
-    is_bops_target_kpi = target_kpi.bops < np.inf
+    is_bops_target_resource_utilization = target_resource_utilization.bops < np.inf
 
-    if is_bops_target_kpi:
-        origin_max_config = search_manager.config_reconstruction_helper.reconstruct_config_from_virtual_graph(search_manager.max_kpi_config)
+    if is_bops_target_resource_utilization:
+        origin_max_config = search_manager.config_reconstruction_helper.reconstruct_config_from_virtual_graph(search_manager.max_ru_config)
         max_config_value = search_manager.compute_metric_fn(origin_max_config)
     else:
-        max_config_value = search_manager.compute_metric_fn(search_manager.max_kpi_config)
+        max_config_value = search_manager.compute_metric_fn(search_manager.max_ru_config)
 
     for node_idx, layer_possible_bitwidths_indices in tqdm(search_manager.layer_to_bitwidth_mapping.items(),
                                                            total=len(search_manager.layer_to_bitwidth_mapping)):
         layer_to_metrics_mapping[node_idx] = {}
 
         for bitwidth_idx in layer_possible_bitwidths_indices:
-            if search_manager.max_kpi_config[node_idx] == bitwidth_idx:
+            if search_manager.max_ru_config[node_idx] == bitwidth_idx:
                 # This is a computation of the metric for the max configuration, assign pre-calculated value
                 layer_to_metrics_mapping[node_idx][bitwidth_idx] = max_config_value
                 continue
 
             # Create a configuration that differs at one layer only from the baseline model
-            mp_model_configuration = search_manager.max_kpi_config.copy()
+            mp_model_configuration = search_manager.max_ru_config.copy()
             mp_model_configuration[node_idx] = bitwidth_idx
 
             # Build a distance matrix using the function we got from the framework implementation.
-            if is_bops_target_kpi:
+            if is_bops_target_resource_utilization:
                 # Reconstructing original graph's configuration from virtual graph's configuration
                 origin_mp_model_configuration = \
                     search_manager.config_reconstruction_helper.reconstruct_config_from_virtual_graph(
@@ -297,7 +301,7 @@ def _build_layer_to_metrics_mapping(search_manager: MixedPrecisionSearchManager,
                 metric_value = search_manager.compute_metric_fn(
                     mp_model_configuration,
                     [node_idx],
-                    search_manager.max_kpi_config)
+                    search_manager.max_ru_config)
 
             layer_to_metrics_mapping[node_idx][bitwidth_idx] = max(metric_value, max_config_value + eps)
 

model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py

@@ -78,8 +78,7 @@ class SensitivityEvaluation:
         self.disable_activation_for_metric = disable_activation_for_metric
         if self.quant_config.use_hessian_based_scores:
             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, a valid HessianInfoService object is required; found {type(hessian_info_service)}.")
             self.hessian_info_service = hessian_info_service
 
         self.sorted_configurable_nodes_names = graph.get_configurable_sorted_nodes_names(self.fw_info)
@@ -320,8 +319,7 @@ class SensitivityEvaluation:
         node_name = sorted_configurable_nodes_names[node_idx_to_configure]
         layers_to_config = self.conf_node2layers.get(node_name, None)
         if layers_to_config is None:
-            Logger.error(
-                f"Couldn't find matching layers in the MP model for node {node_name}.")  # pragma: no cover
+            Logger.critical(f"Matching layers for node {node_name} not found in the mixed precision model configuration.")  # pragma: no cover
 
         for current_layer in layers_to_config:
             self.set_layer_to_bitwidth(current_layer, mp_model_configuration[node_idx_to_configure])

model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py

@@ -15,7 +15,7 @@
 
 from typing import List
 
-from model_compression_toolkit.core import KPI
+from model_compression_toolkit.core import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import \
     MixedPrecisionSearchManager
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
@@ -26,29 +26,29 @@ import numpy as np
 
 def greedy_solution_refinement_procedure(mp_solution: List[int],
                                          search_manager: MixedPrecisionSearchManager,
-                                         target_kpi: KPI) -> List[int]:
+                                         target_resource_utilization: ResourceUtilization) -> List[int]:
     """
     A greedy procedure to try and improve a mixed-precision solution that was found by a mixed-precision optimization
     algorithm.
     This procedure tries to increase the bit-width precision of configurable nodes that did not get the maximal
     candidate
     in the found solution.
-    It iteratively goes over all such nodes, computes the KPI values on a modified configuration (with the node's next
-    best candidate), filters out all configs that hold the KPI constraints and chooses one of them as an improvement
+    It iteratively goes over all such nodes, computes the resource utilization values on a modified configuration (with the node's next
+    best candidate), filters out all configs that hold the resource utilization constraints and chooses one of them as an improvement
     step
-    The choice is done in a greedy approach where we take the configuration that modifies the KPI the least.
+    The choice is done in a greedy approach where we take the configuration that modifies the resource utilization the least.
 
     Args:
         mp_solution: A mixed-precision configuration that was found by a mixed-precision optimization algorithm.
         search_manager: A MixedPrecisionSearchManager object.
-        target_kpi: The target KPIs for the mixed-precision search.
+        target_resource_utilization: The target resource utilization for the mixed-precision search.
 
     Returns: A new, possibly updated, mixed-precision bit-width configuration.
 
     """
-    # Refinement is not supported for BOPs KPI for now...
-    if target_kpi.bops < np.inf:
-        Logger.info(f'Target KPI constraint BOPs - Skipping MP greedy solution refinement')
+    # Refinement is not supported for BOPs utilization for now...
+    if target_resource_utilization.bops < np.inf:
+        Logger.info(f'Target resource utilization constraint BOPs - Skipping MP greedy solution refinement')
         return mp_solution
 
     new_solution = mp_solution.copy()
@@ -56,7 +56,7 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
 
     while changed:
         changed = False
-        nodes_kpis = {}
+        nodes_ru = {}
         nodes_next_candidate = {}
 
         for node_idx in range(len(mp_solution)):
@@ -72,32 +72,32 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
             kernel_attr = None if kernel_attr is None else kernel_attr[0]
             valid_candidates = _get_valid_candidates_indices(node_candidates, new_solution[node_idx], kernel_attr)
 
-            # Create a list of KPIs for the valid candidates.
-            updated_kpis = []
+            # Create a list of ru for the valid candidates.
+            updated_ru = []
             for valid_idx in valid_candidates:
-                node_updated_kpis = search_manager.compute_kpi_for_config(
+                node_updated_ru = search_manager.compute_resource_utilization_for_config(
                     config=search_manager.replace_config_in_index(new_solution, node_idx, valid_idx))
-                updated_kpis.append(node_updated_kpis)
-
-            # filter out new configs that don't hold the KPI restrictions
-            node_filtered_kpis = [(node_idx, kpis) for node_idx, kpis in zip(valid_candidates, updated_kpis) if
-                                  target_kpi.holds_constraints(kpis)]
-
-            if len(node_filtered_kpis) > 0:
-                sorted_by_kpi = sorted(node_filtered_kpis, key=lambda node_kpis: (node_kpis[1].total_memory,
-                                                                                  node_kpis[1].weights_memory,
-                                                                                  node_kpis[1].activation_memory))
-                nodes_kpis[node_idx] = sorted_by_kpi[0][1]
-                nodes_next_candidate[node_idx] = sorted_by_kpi[0][0]
-
-        if len(nodes_kpis) > 0:
-            # filter out new configs that don't hold the KPI restrictions
-            node_filtered_kpis = [(node_idx, kpis) for node_idx, kpis in nodes_kpis.items()]
-            sorted_by_kpi = sorted(node_filtered_kpis, key=lambda node_kpis: (node_kpis[1].total_memory,
-                                                                              node_kpis[1].weights_memory,
-                                                                              node_kpis[1].activation_memory))
-
-            node_idx_to_upgrade = sorted_by_kpi[0][0]
+                updated_ru.append(node_updated_ru)
+
+            # filter out new configs that don't hold the resource utilization restrictions
+            node_filtered_ru = [(node_idx, ru) for node_idx, ru in zip(valid_candidates, updated_ru) if
+                                target_resource_utilization.holds_constraints(ru)]
+
+            if len(node_filtered_ru) > 0:
+                sorted_by_ru = sorted(node_filtered_ru, key=lambda node_ru: (node_ru[1].total_memory,
+                                                                             node_ru[1].weights_memory,
+                                                                             node_ru[1].activation_memory))
+                nodes_ru[node_idx] = sorted_by_ru[0][1]
+                nodes_next_candidate[node_idx] = sorted_by_ru[0][0]
+
+        if len(nodes_ru) > 0:
+            # filter out new configs that don't hold the ru restrictions
+            node_filtered_ru = [(node_idx, ru) for node_idx, ru in nodes_ru.items()]
+            sorted_by_ru = sorted(node_filtered_ru, key=lambda node_ru: (node_ru[1].total_memory,
+                                                                         node_ru[1].weights_memory,
+                                                                         node_ru[1].activation_memory))
+
+            node_idx_to_upgrade = sorted_by_ru[0][0]
             new_solution[node_idx_to_upgrade] = nodes_next_candidate[node_idx_to_upgrade]
             changed = True
 

model_compression_toolkit/core/common/model_collector.py

@@ -158,9 +158,9 @@ class ModelCollector:
         for td, sc in zip(tensor_data, self.stats_containers_list):
             if isinstance(sc, (list, tuple)):
                 if not isinstance(td, (list, tuple)):
-                    Logger.exception('"tensor_data" must be a list or a tuple if the model tensor_list is a list or a tuple') # pragma: no cover
+                    Logger.critical('\'tensor_data\' must be a list or a tuple if \'stats_containers_list\' contains lists or tuples.') # pragma: no cover
                 if len(sc) != len(td):
-                    Logger.exception('"tensor_data" and the model tensor_list must be of the same length') # pragma: no cover
+                    Logger.critical('\'tensor_data\' and \'stats_containers_list\' must have matching lengths') # pragma: no cover
                 for tdi, sci in zip(td, sc):
                     sci.update_statistics(self.fw_impl.to_numpy(tdi))
             else:

model_compression_toolkit/core/common/network_editors/actions.py

@@ -305,7 +305,7 @@ class ChangeCandidatesActivationQuantizationMethod(BaseAction):
                     self.activation_quantization_method)
 
                 if activation_quantization_fn is None:
-                    raise Exception('Unknown quantization method for activations')  # pragma: no cover
+                    Logger.critical('Unknown activation quantization method specified.')  # pragma: no cover
 
                 qc.activation_quantization_cfg.set_activation_quantization_fn(activation_quantization_fn)
                 qc.activation_quantization_cfg.activation_quantization_method = self.activation_quantization_method
@@ -352,7 +352,7 @@ class ChangeFinalWeightsQuantizationMethod(BaseAction):
             weights_quantization_fn = get_weights_quantization_fn(self.weights_quantization_method)
 
             if weights_quantization_fn is None:
-                raise Exception('Unknown quantization method for weights')  # pragma: no cover
+                Logger.critical('Unknown weights quantization method specified.')  # pragma: no cover
 
             (node.final_weights_quantization_cfg.get_attr_config(self.attr_name)
              .set_weights_quantization_fn(weights_quantization_fn))
@@ -401,7 +401,7 @@ class ChangeCandidatesWeightsQuantizationMethod(BaseAction):
                 weights_quantization_fn = get_weights_quantization_fn(self.weights_quantization_method)
 
                 if weights_quantization_fn is None:
-                    raise Exception('Unknown quantization method for weights')  # pragma: no cover
+                    Logger.critical('Unknown weights quantization method specified.')  # pragma: no cover
 
                 attr_qc.set_weights_quantization_fn(weights_quantization_fn)
                 attr_qc.weights_quantization_method = self.weights_quantization_method

model_compression_toolkit/core/common/pruning/greedy_mask_calculator.py

@@ -18,7 +18,7 @@ from typing import List, Dict, Tuple
 
 from model_compression_toolkit.core.common import BaseNode, Graph
 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.mask.per_channel_mask import MaskIndicator
 from model_compression_toolkit.core.common.pruning.memory_calculator import MemoryCalculator
 from model_compression_toolkit.core.common.pruning.pruning_framework_implementation import PruningFrameworkImplementation
@@ -30,16 +30,16 @@ from model_compression_toolkit.target_platform_capabilities.target_platform impo
 class GreedyMaskCalculator:
     """
     GreedyMaskCalculator calculates pruning masks for prunable nodes to meet a
-    specified target KPI. It employs a greedy approach to selectively unprune channel
+    specified target resource utilization. It employs a greedy approach to selectively unprune channel
     groups (SIMD groups) based on their importance scores. Initially, all channels are
     pruned (mask set to zero), and the calculator iteratively adds back the most significant
-    channel groups until the memory footprint meets the target KPI or all channels are unpruned.
+    channel groups until the memory footprint meets the target resource utilization or all channels are unpruned.
     """
     def __init__(self,
                  prunable_nodes: List[BaseNode],
                  fw_info: FrameworkInfo,
                  simd_groups_scores: Dict[BaseNode, np.ndarray],
-                 target_kpi: KPI,
+                 target_resource_utilization: ResourceUtilization,
                  graph: Graph,
                  fw_impl: PruningFrameworkImplementation,
                  tpc: TargetPlatformCapabilities,
@@ -49,7 +49,7 @@ class GreedyMaskCalculator:
             prunable_nodes (List[BaseNode]): Nodes that are eligible for pruning.
             fw_info (FrameworkInfo): Framework-specific information and utilities.
             simd_groups_scores (Dict[BaseNode, np.ndarray]): Importance scores for each SIMG group in a prunable node.
-            target_kpi (KPI): The target KPI to achieve.
+            target_resource_utilization (ResourceUtilization): The target resource utilization to achieve.
             graph (Graph): The computational graph of the model.
             fw_impl (PruningFrameworkImplementation): Framework-specific implementation details.
             tpc (TargetPlatformCapabilities): Platform-specific constraints and capabilities.
@@ -57,7 +57,7 @@ class GreedyMaskCalculator:
         """
         self.prunable_nodes = prunable_nodes
         self.fw_info = fw_info
-        self.target_kpi = target_kpi
+        self.target_resource_utilization = target_resource_utilization
         self.graph = graph
         self.fw_impl = fw_impl
         self.tpc = tpc
@@ -86,18 +86,18 @@ class GreedyMaskCalculator:
     def compute_mask(self):
         """
         Computes the pruning mask by iteratively adding SIMD groups to unpruned state
-        based on their importance and the target KPI.
+        based on their importance and the target resource utilization.
         """
         # Iteratively unprune the graph while monitoring the memory footprint.
         current_memory = self.memory_calculator.get_pruned_graph_memory(masks=self.oc_pruning_mask.get_mask(),
                                                                         include_padded_channels=self.tpc.is_simd_padding)
-        if current_memory > self.target_kpi.weights_memory:
-            Logger.error(f"Minimal required memory is {current_memory}, "
-                         f"but target KPI is {self.target_kpi.weights_memory}")
+        if current_memory > self.target_resource_utilization.weights_memory:
+            Logger.critical(f"Insufficient memory for the target resource utilization: current memory {current_memory}, "
+                            f"target memory {self.target_resource_utilization.weights_memory}.")
 
         # Greedily unprune groups (by setting their mask to 1) until the memory target is met
         # or all channels unpruned.
-        while current_memory < self.target_kpi.weights_memory and self.oc_pruning_mask.has_pruned_channel():
+        while current_memory < self.target_resource_utilization.weights_memory and self.oc_pruning_mask.has_pruned_channel():
             # Select the best SIMD group (best means highest score which means most sensitive group)
             # to add based on the scores.
             node_to_remain, group_to_remain_idx = self._get_most_sensitive_simd_group_candidate()
@@ -108,7 +108,7 @@ class GreedyMaskCalculator:
                                                                             include_padded_channels=self.tpc.is_simd_padding)
 
         # If the target memory is exceeded, revert the last addition.
-        if current_memory > self.target_kpi.weights_memory:
+        if current_memory > self.target_resource_utilization.weights_memory:
             self.oc_pruning_mask.set_mask_value_for_simd_group(node=node_to_remain,
                                                                group_index=group_to_remain_idx,
                                                                mask_indicator=MaskIndicator.PRUNED)

model_compression_toolkit/core/common/pruning/importance_metrics/lfh_importance_metric.py

@@ -250,13 +250,13 @@ class LFHImportanceMetric(BaseImportanceMetric):
         kernel_attr = self.fw_info.get_kernel_op_attributes(entry_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 {entry_node}")
+            Logger.critical(f"Expected a single attribute but found multiple attributes ({len(kernel_attr)}) for node {entry_node}.")
         kernel_attr = kernel_attr[0]
 
         # Retrieve and validate the axis index for the output channels.
         oc_axis, _ = self.fw_info.kernel_channels_mapping.get(entry_node.type)
         if oc_axis is None or int(oc_axis) != oc_axis:
-            Logger.error(f"Expected output channel axis to be an integer but is {oc_axis} for node {entry_node}")
+            Logger.critical(f"Invalid output channel axis type for node {entry_node}: expected integer but got {oc_axis}.")
 
         # Get the number of output channels based on the kernel attribute and axis.
         num_oc = entry_node.get_weights_by_keys(kernel_attr[0]).shape[oc_axis]

model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py

@@ -19,7 +19,7 @@ from typing import List, Dict, Tuple
 
 from model_compression_toolkit.core.common import BaseNode, Graph
 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.memory_calculator import MemoryCalculator
 from model_compression_toolkit.core.common.pruning.pruning_framework_implementation import PruningFrameworkImplementation
 from model_compression_toolkit.logger import Logger
@@ -73,7 +73,7 @@ class PerChannelMask:
             mask_indicator: The new value to set in the mask (either PRUNED or REMAINED).
         """
         if mask_indicator not in [MaskIndicator.PRUNED, MaskIndicator.REMAINED]:
-            Logger.error("Mask value must be either MaskIndicator.PRUNED or MaskIndicator.REMAINED")
+            Logger.critical("Mask value must be either 'MaskIndicator.PRUNED' or 'MaskIndicator.REMAINED'")
         self._mask[node][channel_idx] = mask_indicator.value
 
     def has_pruned_channel(self) -> bool:

model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py

@@ -18,7 +18,7 @@ from typing import List, Dict, Tuple
 
 from model_compression_toolkit.core.common import BaseNode, Graph
 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.mask.per_channel_mask import PerChannelMask, MaskIndicator
 from model_compression_toolkit.core.common.pruning.memory_calculator import MemoryCalculator
 from model_compression_toolkit.core.common.pruning.pruning_framework_implementation import PruningFrameworkImplementation
@@ -79,7 +79,7 @@ class PerSIMDGroupMask:
             mask_indicator: The new value to set in the mask (either PRUNED or REMAINED).
         """
         if mask_indicator not in [MaskIndicator.PRUNED, MaskIndicator.REMAINED]:
-            Logger.error("Mask value must be either MaskIndicator.PRUNED or MaskIndicator.REMAINED")
+            Logger.critical("Mask value must be either 'MaskIndicator.PRUNED' or 'MaskIndicator.REMAINED'")
 
         # Update the SIMD group mask and corresponding per-channel mask
         self._mask_simd[node][group_index] = mask_indicator.value