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

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "1.11.0.20240320.000400"
+__version__ = "1.11.0.20240322.000404"

model_compression_toolkit/constants.py

@@ -93,7 +93,7 @@ UPPER_FACTOR = 1.2
 DEC_RANGE_BOTTOM = 0.97
 DEC_RANGE_UPPER = 1.03
 
-# KPI computation parameters
+# Resource utilization computation parameters
 BITS_TO_BYTES = 8.0
 
 # Default threshold for Softmax layer

model_compression_toolkit/core/__init__.py

@@ -21,9 +21,9 @@ from model_compression_toolkit.core.common.quantization import quantization_conf
 from model_compression_toolkit.core.common.mixed_precision import mixed_precision_quantization_config
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig, QuantizationErrorMethod, DEFAULTCONFIG
 from model_compression_toolkit.core.common.quantization.core_config import 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.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig
-from model_compression_toolkit.core.keras.kpi_data_facade import keras_kpi_data
-from model_compression_toolkit.core.pytorch.kpi_data_facade import pytorch_kpi_data
+from model_compression_toolkit.core.keras.resource_utilization_data_facade import keras_resource_utilization_data
+from model_compression_toolkit.core.pytorch.resource_utilization_data_facade import pytorch_resource_utilization_data
 from model_compression_toolkit.core.common.mixed_precision.distance_weighting import MpDistanceWeighting
 

model_compression_toolkit/core/common/collectors/base_collector.py

@@ -66,5 +66,5 @@ class BaseCollector(object):
         """
 
         if not self.is_legal:
-            Logger.exception(f'{self.__class__.__name__} was manipulated per-channel,'
-                             'but collected per-tensor. Data is invalid.')  # pragma: no cover
+            Logger.critical('The data is invalid.'
+                            f'{self.__class__.__name__} was collected per-tensor but received data manipulated per-channel.')  # pragma: no cover

model_compression_toolkit/core/common/data_loader.py

@@ -66,7 +66,7 @@ class FolderImageLoader(object):
 
         self.folder = folder
         self.image_list = []
-        print(f"Starting Scanning Disk: {self.folder}")
+        Logger.info(f"Starting Scanning Disk: {self.folder}")
         for root, dirs, files in os.walk(self.folder):
             for file in files:
                 file_type = file.split('.')[-1].lower()
@@ -74,8 +74,8 @@ class FolderImageLoader(object):
                     self.image_list.append(os.path.join(root, file))
         self.n_files = len(self.image_list)
         if self.n_files == 0:
-            Logger.error(f"No files of type: {FILETYPES} are found!") # pragma: no cover
-        print(f"Finished Disk Scanning: Found {self.n_files} files")
+            Logger.critical(f"Expected files of type {FILETYPES}. No files of type {FILETYPES} were found.") # pragma: no cover
+        Logger.info(f"Finished Disk Scanning: Found {self.n_files} files")
         self.preprocessing = preprocessing
         self.batch_size = batch_size
 

model_compression_toolkit/core/common/graph/base_graph.py

@@ -102,10 +102,10 @@ class Graph(nx.MultiDiGraph, GraphSearches):
                                                           for filtered_layer in tpc_filtered_layers])
             if n.is_custom:
                 if not is_node_in_tpc:
-                    Logger.error(f'MCT does not support optimizing Keras custom layers, but found layer of type {n.type}. '
-                                 f'Please add the custom layer to TPC or file a feature request or an issue if you believe this is an issue.')
+                    Logger.critical(f'MCT does not support optimizing Keras custom layers. Found a layer of type {n.type}. '
+                                 f' Please add the custom layer to Target Platform Capabilities (TPC), or file a feature request or an issue if you believe this should be supported.')
                 if any([qc.default_weight_attr_config.enable_weights_quantization for qc in n.get_qco(tpc).quantization_config_list]):
-                    Logger.error(f'MCT does not support optimizing Keras custom layers with weights quantization. Layer: {n.type}')
+                    Logger.critical(f'Layer identified: {n.type}. MCT does not support weight quantization for Keras custom layers.')
 
         self.tpc = tpc
 
@@ -231,7 +231,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         sc = self.node_to_in_stats_collector.get(n)
         if sc is None:
-            Logger.error(f'Input statistics collector of node {n.name} is None')  # pragma: no cover
+            Logger.critical(f'No input statistics collector found for node {n.name}.')  # pragma: no cover
         return sc
 
     def scale_stats_collector(self,
@@ -370,8 +370,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             input_nodes_output_index = [0] * len(input_nodes)
 
         if len(input_nodes_output_index) != len(input_nodes):
-            Logger.error('Graph.add_node_with_in_edges: input_nodes & input_nodes_output_index must be the same '
-                         'length')  # pragma: no cover
+            Logger.critical('The number of input nodes and their corresponding output indices must be equal. Found mismatched lengths.')  # pragma: no cover
 
         self.add_node(new_node)
         for sink_index, (in_node, source_index) in enumerate(zip(input_nodes, input_nodes_output_index)):
@@ -414,7 +413,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         """
         if new_node is None:
-            Logger.error("Graph received a None value as a new input node.")
+            Logger.critical("Cannot replace input node with a None value; new input node is required.")
 
         graph_inputs = self.get_inputs()
         new_graph_inputs = copy(graph_inputs)
@@ -442,13 +441,13 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         if node_to_remove in output_nodes:  # If node is in the graph's outputs, the outputs should be updated
             if new_graph_outputs is None:
                 Logger.critical(
-                    f'{node_to_remove.name} is in graph outputs, but new outputs were not given.')  # pragma: no cover
+                    f"{node_to_remove.name} is among the graph outputs; however, it cannot be removed without providing a new output.")  # pragma: no cover
             self.set_outputs(new_graph_outputs)
 
         if node_to_remove in self.get_inputs():  # If node is in the graph's inputs, the inputs should be updated
             if new_graph_inputs is None:
                 Logger.critical(
-                    f'{node_to_remove.name} is in graph inputs, but new inputs were not given.')  # pragma: no cover
+                    f'{node_to_remove.name} s among the graph inputs; however, it cannot be removed without providing a new input.')  # pragma: no cover
             self.set_inputs(new_graph_inputs)
 
         # Make sure there are no connected edges left to the node before removing it.
@@ -828,14 +827,12 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         """
         if not fw_impl.is_node_entry_node(entry_node):
-            Logger.error(f"Expected to find an entry node to create its pruning section,"
-                         f"but node {entry_node} is not an entry node.")
+            Logger.critical(f"Node {entry_node} is not a valid entry node for creating a pruning section")
 
         intermediate_nodes, exit_node = self._find_intermediate_and_exit_nodes(entry_node, fw_impl)
 
         if not fw_impl.is_node_exit_node(exit_node, entry_node, self.fw_info):
-            Logger.error(f"Expected to find exit node when creating a pruning section,"
-                         f"but node {exit_node} is not an exit node.")
+            Logger.critical(f"Node {exit_node} is not a valid exit node for the pruning section starting with {entry_node}.")
 
         return PruningSection(entry_node=entry_node,
                               intermediate_nodes=intermediate_nodes,

model_compression_toolkit/core/common/graph/base_node.py

@@ -547,7 +547,7 @@ class BaseNode:
         """
 
         if tpc is None:
-            Logger.error(f'Can not retrieve QC options for None TPC')  # pragma: no cover
+            Logger.critical(f'Can not retrieve QC options for None TPC')  # pragma: no cover
 
         for fl, qco in tpc.filterlayer2qco.items():
             if self.is_match_filter_params(fl):
@@ -617,10 +617,10 @@ class BaseNode:
             Logger.warning(f"More than one pruning SIMD option is available."
                            f" Min SIMD is used: {min(simd_list)}")
         if len(simd_list) == 0:
-            Logger.error(f"No SIMD option is available for {self}")
+            Logger.critical(f"No SIMD option is available for {self}")
         _simd = min(simd_list)
         if _simd <= 0 or int(_simd) != _simd:
-            Logger.error(f"SIMD is expected to be a non-positive integer but found: {_simd}")
+            Logger.critical(f"SIMD is expected to be a non-positive integer but found: {_simd}")
         return _simd
 
     def sort_node_candidates(self, fw_info):

model_compression_toolkit/core/common/graph/edge.py

@@ -17,6 +17,7 @@
 from typing import Any, Dict
 
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
+from model_compression_toolkit.logger import Logger
 
 # Edge attributes:
 EDGE_SOURCE_INDEX = 'source_index'
@@ -108,4 +109,4 @@ def convert_to_edge(edge: Any) -> Edge:
     elif isinstance(edge, Edge):  # it's already an Edge and no change need to be done
         return edge
 
-    raise Exception('Edges list contains an object that is not a known edge format.')
+    Logger.critical('Edge conversion failed: unrecognized edge format encountered.')

model_compression_toolkit/core/common/graph/memory_graph/bipartite_graph.py

@@ -75,10 +75,8 @@ class DirectedBipartiteGraph(nx.DiGraph):
             edges_list: A list of edges to verify their correction.
         """
         for n1, n2 in edges_list:
-            if n1 in self.a_nodes and n2 in self.a_nodes:
-                Logger.critical(f"Can't add an edge {(n1, n2)} between two nodes in size A of a bipartite graph.")
-            if n1 in self.b_nodes and n2 in self.b_nodes:
-                Logger.critical(f"Can't add an edge {(n1, n2)} between two nodes in size B of a bipartite graph.")
+            if (n1 in self.a_nodes and n2 in self.a_nodes) or (n1 in self.b_nodes and n2 in self.b_nodes):
+                Logger.critical(f"Attempted to add edge {(n1, n2)} between nodes of the same partition in a bipartite graph, violating bipartite properties.")
 
     def add_nodes_to_a(self, new_nodes: List[Any]):
         """

model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py

@@ -113,14 +113,14 @@ class VirtualSplitActivationNode(VirtualSplitNode):
 class VirtualActivationWeightsNode(BaseNode):
     """
     A node that represents a composition of pair of sequential activation node and weights (kernel) node.
-    This structure is used for mixed-precision search with bit-operation KPI.
+    This structure is used for mixed-precision search with bit-operation constraint.
     The node's candidates are the cartesian product of both nodes' candidates.
 
     Important: note that not like regular BaseNode or FunctionalNode, in VirtualActivationWeightsNode the activation
     candidates config refer to the quantization config of the activation that precedes the linear operation! instead of
     the output of the linear operation.
     It is ok, since this node is not meant to be used in a graph for creating an actual model, but only a virtual
-    representation of the model's graph only for allowing to compute the bit-operations KPI in mixed-precision.
+    representation of the model's graph only for allowing to compute the bit-operations constraint in mixed-precision.
     """
 
     def __init__(self,

model_compression_toolkit/core/common/hessian/hessian_info_service.py

@@ -72,7 +72,7 @@ class HessianInfoService:
         """
         images = next(representative_dataset())
         if not isinstance(images, list):
-            Logger.error(f'Images expected to be a list but is of type {type(images)}')
+            Logger.critical(f'Expected images to be a list; found type: {type(images)}.')
 
         # Ensure each image is a single sample, if not, take the first sample
         return [image[0:1, ...] if image.shape[0] != 1 else image for image in images]
@@ -176,8 +176,7 @@ class HessianInfoService:
         """
         father_nodes = [n for n in self.graph.nodes if not n.reuse and n.reuse_group==trace_hessian_request.target_node.reuse_group]
         if len(father_nodes)!=1:
-            Logger.error(f"Each reused group has a single node in it which is not marked as"
-                         f" reused but found {len(father_nodes)}")
+            Logger.critical(f"Expected a single non-reused node in the reused group, but found {len(father_nodes)}.")
         reused_group_request = TraceHessianRequest(target_node=father_nodes[0],
                                                    granularity=trace_hessian_request.granularity,
                                                    mode=trace_hessian_request.mode)

model_compression_toolkit/core/common/hessian/trace_hessian_calculator.py

@@ -50,21 +50,19 @@ class TraceHessianCalculator(ABC):
 
         for output_node in graph.get_outputs():
             if not fw_impl.is_output_node_compatible_for_hessian_score_computation(output_node.node):
-                Logger.error(f"All graph outputs should support Hessian computation, but node {output_node.node} "
-                             f"was found with layer type {output_node.node.type}. "
-                             f"Try to run MCT without Hessian info computation.")
+                Logger.critical(f"All graph outputs must support Hessian score computation. Incompatible node: {output_node.node}, layer type: {output_node.node.type}. Consider disabling Hessian info computation.")
 
         self.input_images = fw_impl.to_tensor(input_images)
         self.num_iterations_for_approximation = num_iterations_for_approximation
 
         # Validate representative dataset has same inputs as graph
         if len(self.input_images)!=len(graph.get_inputs()):
-            Logger.error(f"Graph has {len(graph.get_inputs())} inputs, but provided representative dataset returns {len(self.input_images)} inputs")
+            Logger.critical(f"The graph requires {len(graph.get_inputs())} inputs, but the provided representative dataset contains {len(self.input_images)} inputs.")
 
         # Assert all inputs have a batch size of 1
         for image in self.input_images:
             if image.shape[0]!=1:
-                Logger.error(f"Hessian is calculated only for a single image (per input) but input shape is {image.shape}")
+                Logger.critical(f"Hessian calculations are restricted to a single-image per input. Found input with shape: {image.shape}.")
 
         self.fw_impl = fw_impl
         self.hessian_request = trace_hessian_request

model_compression_toolkit/core/common/mixed_precision/bit_width_setter.py

@@ -116,8 +116,7 @@ def _get_node_qc_by_bit_widths(node: BaseNode,
 
             return qc
 
-    Logger.critical(f'Node {node.name} quantization configuration from configuration file'  # pragma: no cover
-                    f' was not found in candidates configurations.')
+    Logger.critical(f"Quantization configuration for node '{node.name}' not found in candidate configurations.")  # pragma: no cover
 
 
 def _set_node_final_qc(bit_width_cfg: List[int],

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py

@@ -21,8 +21,8 @@ from typing import List, Callable, Dict
 from model_compression_toolkit.core import MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.hessian import HessianInfoService
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI, KPITarget
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi_functions_mapping import kpi_functions_mapping
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_functions_mapping import ru_functions_mapping
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import MixedPrecisionSearchManager
 from model_compression_toolkit.core.common.mixed_precision.search_methods.linear_programming import \
@@ -47,7 +47,7 @@ search_methods = {
 def search_bit_width(graph_to_search_cfg: Graph,
                      fw_info: FrameworkInfo,
                      fw_impl: FrameworkImplementation,
-                     target_kpi: KPI,
+                     target_resource_utilization: ResourceUtilization,
                      mp_config: MixedPrecisionQuantizationConfig,
                      representative_data_gen: Callable,
                      search_method: BitWidthSearchMethod = BitWidthSearchMethod.INTEGER_PROGRAMMING,
@@ -56,15 +56,15 @@ def search_bit_width(graph_to_search_cfg: Graph,
     Search for an MP configuration for a given graph. Given a search_method method (by default, it's linear
     programming), we use the sensitivity_evaluator object that provides a function to compute an
     evaluation for the expected sensitivity for a bit-width configuration.
-    Then, and after computing the KPI for each node in the graph for each bit-width in the search space,
-    we search for the optimal solution, given some target_kpi, the solution should fit.
-    target_kpi have to be passed. If it was not passed, the facade is not supposed to get here by now.
+    Then, and after computing the resource utilization for each node in the graph for each bit-width in the search space,
+    we search for the optimal solution, given some target_resource_utilization, the solution should fit.
+    target_resource_utilization have to be passed. If it was not passed, the facade is not supposed to get here by now.
 
     Args:
         graph_to_search_cfg: Graph to search a MP configuration for.
         fw_info: FrameworkInfo object about the specific framework (e.g., attributes of different layers' weights to quantize).
         fw_impl: FrameworkImplementation object with specific framework methods implementation.
-        target_kpi: Target KPI to bound our feasible solution space s.t the configuration does not violate it.
+        target_resource_utilization: Target Resource Utilization to bound our feasible solution space s.t the configuration does not violate it.
         mp_config: Mixed-precision quantization configuration.
         representative_data_gen: Dataset to use for retrieving images for the models inputs.
         search_method: BitWidthSearchMethod to define which searching method to use.
@@ -77,25 +77,25 @@ def search_bit_width(graph_to_search_cfg: Graph,
 
     """
 
-    # target_kpi have to be passed. If it was not passed, the facade is not supposed to get here by now.
-    if target_kpi is None:
-        Logger.critical('Target KPI have to be passed for search_methods bit-width configuration')  # pragma: no cover
+    # target_resource_utilization have to be passed. If it was not passed, the facade is not supposed to get here by now.
+    if target_resource_utilization is None:
+        Logger.critical("Target ResourceUtilization is required for the bit-width search method's configuration.")  # pragma: no cover
 
     # Set graph for MP search
     graph = copy.deepcopy(graph_to_search_cfg)  # Copy graph before searching
-    if target_kpi.bops < np.inf:
-        # Since Bit-operations count target KPI is set, we need to reconstruct the graph for the MP search
+    if target_resource_utilization.bops < np.inf:
+        # Since Bit-operations count target resource utilization is set, we need to reconstruct the graph for the MP search
         graph = substitute(graph, fw_impl.get_substitutions_virtual_weights_activation_coupling())
 
     # If we only run weights compression with MP than no need to consider activation quantization when computing the
     # MP metric (it adds noise to the computation)
-    disable_activation_for_metric = (target_kpi.weights_memory < np.inf and
-                                    (target_kpi.activation_memory == np.inf and
-                                     target_kpi.total_memory == np.inf and
-                                     target_kpi.bops == np.inf)) or graph_to_search_cfg.is_single_activation_cfg()
+    disable_activation_for_metric = (target_resource_utilization.weights_memory < np.inf and
+                                    (target_resource_utilization.activation_memory == np.inf and
+                                     target_resource_utilization.total_memory == np.inf and
+                                     target_resource_utilization.bops == np.inf)) or graph_to_search_cfg.is_single_activation_cfg()
 
     # Set Sensitivity Evaluator for MP search. It should always work with the original MP graph,
-    # even if a virtual graph was created (and is used only for BOPS KPI computation purposes)
+    # even if a virtual graph was created (and is used only for BOPS utilization computation purposes)
     se = fw_impl.get_sensitivity_evaluator(
         graph_to_search_cfg,
         mp_config,
@@ -104,16 +104,17 @@ def search_bit_width(graph_to_search_cfg: Graph,
         disable_activation_for_metric=disable_activation_for_metric,
         hessian_info_service=hessian_info_service)
 
-    # Each pair of (KPI method, KPI aggregation) should match to a specific provided kpi target
-    kpi_functions = kpi_functions_mapping
+    # Each pair of (resource utilization method, resource utilization aggregation) should match to a specific
+    # provided target resource utilization
+    ru_functions = ru_functions_mapping
 
     # Instantiate a manager object
     search_manager = MixedPrecisionSearchManager(graph,
                                                  fw_info,
                                                  fw_impl,
                                                  se,
-                                                 kpi_functions,
-                                                 target_kpi,
+                                                 ru_functions,
+                                                 target_resource_utilization,
                                                  original_graph=graph_to_search_cfg)
 
     if search_method in search_methods:  # Get a specific search function
@@ -123,9 +124,9 @@ def search_bit_width(graph_to_search_cfg: Graph,
 
     # Search for the desired mixed-precision configuration
     result_bit_cfg = search_method_fn(search_manager,
-                                      target_kpi)
+                                      target_resource_utilization)
 
     if mp_config.refine_mp_solution:
-        result_bit_cfg = greedy_solution_refinement_procedure(result_bit_cfg, search_manager, target_kpi)
+        result_bit_cfg = greedy_solution_refinement_procedure(result_bit_cfg, search_manager, target_resource_utilization)
 
     return result_bit_cfg