mct-nightly 2.1.0.20240708.453__tar.gz → 2.1.0.20240709.429__tar.gz

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.1.0.20240708.453
+Version: 2.1.0.20240709.429
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.1.0.20240708.453
+Version: 2.1.0.20240709.429
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/mct_nightly.egg-info/SOURCES.txt

@@ -56,8 +56,8 @@ model_compression_toolkit/core/common/graph/memory_graph/memory_graph.py
 model_compression_toolkit/core/common/hessian/__init__.py
 model_compression_toolkit/core/common/hessian/hessian_info_service.py
 model_compression_toolkit/core/common/hessian/hessian_info_utils.py
-model_compression_toolkit/core/common/hessian/trace_hessian_calculator.py
-model_compression_toolkit/core/common/hessian/trace_hessian_request.py
+model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py
+model_compression_toolkit/core/common/hessian/hessian_scores_request.py
 model_compression_toolkit/core/common/matchers/__init__.py
 model_compression_toolkit/core/common/matchers/base_graph_filter.py
 model_compression_toolkit/core/common/matchers/base_matcher.py
@@ -193,9 +193,9 @@ model_compression_toolkit/core/keras/graph_substitutions/substitutions/softmax_s
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/virtual_activation_weights_composition.py
 model_compression_toolkit/core/keras/graph_substitutions/substitutions/weights_activation_split.py
 model_compression_toolkit/core/keras/hessian/__init__.py
-model_compression_toolkit/core/keras/hessian/activation_trace_hessian_calculator_keras.py
-model_compression_toolkit/core/keras/hessian/trace_hessian_calculator_keras.py
-model_compression_toolkit/core/keras/hessian/weights_trace_hessian_calculator_keras.py
+model_compression_toolkit/core/keras/hessian/activation_hessian_scores_calculator_keras.py
+model_compression_toolkit/core/keras/hessian/hessian_scores_calculator_keras.py
+model_compression_toolkit/core/keras/hessian/weights_hessian_scores_calculator_keras.py
 model_compression_toolkit/core/keras/mixed_precision/__init__.py
 model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py
 model_compression_toolkit/core/keras/mixed_precision/configurable_weights_quantizer.py
@@ -258,9 +258,9 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/transfo
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/virtual_activation_weights_composition.py
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/weights_activation_split.py
 model_compression_toolkit/core/pytorch/hessian/__init__.py
-model_compression_toolkit/core/pytorch/hessian/activation_trace_hessian_calculator_pytorch.py
-model_compression_toolkit/core/pytorch/hessian/trace_hessian_calculator_pytorch.py
-model_compression_toolkit/core/pytorch/hessian/weights_trace_hessian_calculator_pytorch.py
+model_compression_toolkit/core/pytorch/hessian/activation_hessian_scores_calculator_pytorch.py
+model_compression_toolkit/core/pytorch/hessian/hessian_scores_calculator_pytorch.py
+model_compression_toolkit/core/pytorch/hessian/weights_hessian_scores_calculator_pytorch.py
 model_compression_toolkit/core/pytorch/mixed_precision/__init__.py
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quantizer.py

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/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__ = "2.1.0.20240708.000453"
+__version__ = "2.1.0.20240709.000429"

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/model_compression_toolkit/core/common/framework_implementation.py

@@ -24,7 +24,7 @@ from model_compression_toolkit.core.common import BaseNode
 from model_compression_toolkit.core.common.collectors.statistics_collector import BaseStatsCollector
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.graph.base_graph import Graph
-from model_compression_toolkit.core.common.hessian import TraceHessianRequest, HessianInfoService
+from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianInfoService
 from model_compression_toolkit.core.common.mixed_precision.sensitivity_evaluation import SensitivityEvaluation
 from model_compression_toolkit.core.common.model_builder_mode import ModelBuilderMode
 from model_compression_toolkit.core.common.node_prior_info import NodePriorInfo
@@ -49,23 +49,23 @@ class FrameworkImplementation(ABC):
         raise NotImplemented(f'{self.__class__.__name__} did not supply a constants module.')  # pragma: no cover
 
     @abstractmethod
-    def get_trace_hessian_calculator(self,
-                                     graph: Graph,
-                                     input_images: List[Any],
-                                     trace_hessian_request: TraceHessianRequest,
-                                     num_iterations_for_approximation: int = HESSIAN_NUM_ITERATIONS):
+    def get_hessian_scores_calculator(self,
+                                      graph: Graph,
+                                      input_images: List[Any],
+                                      hessian_scores_request: HessianScoresRequest,
+                                      num_iterations_for_approximation: int = HESSIAN_NUM_ITERATIONS):
         """
-        Get framework trace hessian approximations calculator based on the trace hessian request.
+        Get framework hessian-approximation scores calculator based on the hessian scores request.
         Args:
             input_images: Images to use for computation.
             graph: Float graph to compute the approximation of its different nodes.
-            trace_hessian_request: TraceHessianRequest to search for the desired calculator.
-            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian trace.
+            hessian_scores_request: HessianScoresRequest to search for the desired calculator.
+            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian-approximation scores.
 
-        Returns: TraceHessianCalculator to use for the trace hessian approximation computation for this request.
+        Returns: HessianScoresCalculator to use for the hessian approximation scores computation for this request.
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
-                             f'framework\'s get_trace_hessian_calculator method.')  # pragma: no cover
+                             f'framework\'s get_hessian_scores_calculator method.')  # pragma: no cover
 
     @abstractmethod
     def to_numpy(self, tensor: Any) -> np.ndarray:
@@ -310,7 +310,7 @@ class FrameworkImplementation(ABC):
             representative_data_gen: Dataset to use for retrieving images for the models inputs.
             fw_info: FrameworkInfo object with information about the specific framework's model.
             disable_activation_for_metric: Whether to disable activation quantization when computing the MP metric.
-            hessian_info_service: HessianInfoService to fetch Hessian traces approximations.
+            hessian_info_service: HessianInfoService to fetch information based on Hessian-approximation.
 
         Returns:
             A function that computes the metric.

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/model_compression_toolkit/core/common/hessian/__init__.py

@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-from model_compression_toolkit.core.common.hessian.trace_hessian_request import TraceHessianRequest, HessianMode, HessianInfoGranularity
+from model_compression_toolkit.core.common.hessian.hessian_scores_request import HessianScoresRequest, HessianMode, HessianScoresGranularity
 from model_compression_toolkit.core.common.hessian.hessian_info_service import HessianInfoService
 import model_compression_toolkit.core.common.hessian.hessian_info_utils as hessian_utils

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/model_compression_toolkit/core/common/hessian/hessian_info_service.py

@@ -19,24 +19,24 @@ from tqdm import tqdm
 from typing import Callable, List, Dict, Any, Tuple
 
 from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
-from model_compression_toolkit.core.common.hessian.trace_hessian_request import TraceHessianRequest, \
-    HessianInfoGranularity, HessianMode
+from model_compression_toolkit.core.common.hessian.hessian_scores_request import HessianScoresRequest, \
+    HessianScoresGranularity, HessianMode
 from model_compression_toolkit.logger import Logger
 
 
 class HessianInfoService:
     """
-    A service to manage, store, and compute approximation of the Hessian-based information.
+    A service to manage, store, and compute information based on the Hessian matrix approximation.
 
-    This class provides functionalities to compute approximation based on the Hessian matrix based
-    on the different parameters (such as number of iterations for approximating the info)
+    This class provides functionalities to compute information based on the Hessian matrix approximation
+    based on the different parameters (such as number of iterations for approximating the scores)
     and input images (using representative_dataset_gen).
     It also offers cache management capabilities for efficient computation and retrieval.
 
     Note:
     - The Hessian provides valuable information about the curvature of the loss function.
     - Computation can be computationally heavy and time-consuming.
-    - The computed trace is an approximation.
+    - The computed information is based on Hessian approximation (and not the precise Hessian matrix).
     """
 
     def __init__(self,
@@ -49,7 +49,7 @@ class HessianInfoService:
         Args:
             graph: Float graph.
             representative_dataset_gen: A callable that provides a dataset for sampling.
-            fw_impl: Framework-specific implementation for trace Hessian approximation computation.
+            fw_impl: Framework-specific implementation for Hessian approximation scores computation.
         """
         self.graph = graph
 
@@ -58,7 +58,7 @@ class HessianInfoService:
         self.fw_impl = fw_impl
         self.num_iterations_for_approximation = num_iterations_for_approximation
 
-        self.trace_hessian_request_to_score_list = {}
+        self.hessian_scores_request_to_scores_list = {}
 
     def _sample_batch_representative_dataset(self,
                                              representative_dataset: Any,
@@ -142,11 +142,11 @@ class HessianInfoService:
 
     def _clear_saved_hessian_info(self):
         """Clears the saved info approximations."""
-        self.trace_hessian_request_to_score_list={}
+        self.hessian_scores_request_to_scores_list={}
 
-    def count_saved_info_of_request(self, hessian_request: TraceHessianRequest) -> Dict:
+    def count_saved_scores_of_request(self, hessian_request: HessianScoresRequest) -> Dict:
         """
-        Counts the saved approximations of Hessian info (traces, for now) for a specific request.
+        Counts the saved approximations of Hessian scores for a specific request.
         If some approximations were computed for this request before, the amount of approximations (per image)
         will be returned. If not, zero is returned.
 
@@ -166,55 +166,58 @@ class HessianInfoService:
                 Logger.critical(f"Expecting the Hessian request to include only non-reused nodes at this point, "
                                 f"but found node {n.name} with 'reuse' status.")
             # Check if the request for this node is in the saved info and store its count, otherwise store 0
-            per_node_counter[n] = len(self.trace_hessian_request_to_score_list.get(hessian_request, []))
+            per_node_counter[n] = len(self.hessian_scores_request_to_scores_list.get(hessian_request, []))
 
         return per_node_counter
 
-    def compute(self, trace_hessian_request: TraceHessianRequest, representative_dataset_gen, num_hessian_samples: int,
+    def compute(self,
+                hessian_scores_request: HessianScoresRequest,
+                representative_dataset_gen,
+                num_hessian_samples: int,
                 last_iter_remain_samples: List[List[np.ndarray]] = None):
         """
-        Computes an approximation of the trace of the Hessian based on the
+        Computes scores based on the Hessian matrix approximation according to the
         provided request configuration and stores it in the cache.
 
         Args:
-            trace_hessian_request: Configuration for which to compute the approximation.
+            hessian_scores_request: Configuration for which to compute the approximation.
             representative_dataset_gen: A callable that provides a dataset for sampling.
             num_hessian_samples: Number of requested samples to compute batch Hessian approximation scores.
             last_iter_remain_samples: A list of input samples (for each input layer) with remaining samples from
             previous iterations.
         """
-        Logger.debug(f"Computing Hessian-trace approximation for nodes {trace_hessian_request.target_nodes}.")
+        Logger.debug(f"Computing Hessian-scores approximations for nodes {hessian_scores_request.target_nodes}.")
 
         images, next_iter_remain_samples = representative_dataset_gen(num_hessian_samples=num_hessian_samples,
                                                                       last_iter_remain_samples=last_iter_remain_samples)
 
         # Compute and store the computed approximation in the saved info
         topo_sorted_nodes_names = [x.name for x in self.graph.get_topo_sorted_nodes()]
-        trace_hessian_request.target_nodes.sort(key=lambda x: topo_sorted_nodes_names.index(x.name))
+        hessian_scores_request.target_nodes.sort(key=lambda x: topo_sorted_nodes_names.index(x.name))
 
-        # Get the framework-specific calculator for trace Hessian approximation
-        fw_hessian_calculator = self.fw_impl.get_trace_hessian_calculator(graph=self.graph,
-                                                                          input_images=images,
-                                                                          trace_hessian_request=trace_hessian_request,
-                                                                          num_iterations_for_approximation=self.num_iterations_for_approximation)
+        # Get the framework-specific calculator Hessian-approximation scores
+        fw_hessian_calculator = self.fw_impl.get_hessian_scores_calculator(graph=self.graph,
+                                                                           input_images=images,
+                                                                           hessian_scores_request=hessian_scores_request,
+                                                                           num_iterations_for_approximation=self.num_iterations_for_approximation)
 
-        trace_hessian = fw_hessian_calculator.compute()
+        hessian_scores = fw_hessian_calculator.compute()
 
-        for node, hessian in zip(trace_hessian_request.target_nodes, trace_hessian):
-            single_node_request = self._construct_single_node_request(trace_hessian_request.mode,
-                                                                      trace_hessian_request.granularity,
+        for node, hessian in zip(hessian_scores_request.target_nodes, hessian_scores):
+            single_node_request = self._construct_single_node_request(hessian_scores_request.mode,
+                                                                      hessian_scores_request.granularity,
                                                                       node)
 
             # The hessian for each node is expected to be a tensor where the first axis represents the number of
             # images in the batch on which the approximation was computed.
             # We collect the results as a list of a result for images, which is combined across batches.
-            # After conversion, trace_hessian_request_to_score_list for a request of a single node should be a list of
+            # After conversion, hessian_scores_request_to_scores_list for a request of a single node should be a list of
             # results of all images, where each result is a tensor of the shape depending on the granularity.
-            if single_node_request in self.trace_hessian_request_to_score_list:
-                self.trace_hessian_request_to_score_list[single_node_request] += (
+            if single_node_request in self.hessian_scores_request_to_scores_list:
+                self.hessian_scores_request_to_scores_list[single_node_request] += (
                     self._convert_tensor_to_list_of_appx_results(hessian))
             else:
-                self.trace_hessian_request_to_score_list[single_node_request] = (
+                self.hessian_scores_request_to_scores_list[single_node_request] = (
                     self._convert_tensor_to_list_of_appx_results(hessian))
 
         # In case that we are required to return a number of scores that is larger that the computation batch size
@@ -226,15 +229,15 @@ class HessianInfoService:
         and len(next_iter_remain_samples[0]) > 0 else None
 
     def fetch_hessian(self,
-                      trace_hessian_request: TraceHessianRequest,
+                      hessian_scores_request: HessianScoresRequest,
                       required_size: int,
                       batch_size: int = 1) -> List[List[np.ndarray]]:
         """
-        Fetches the computed approximations of the trace of the Hessian for the given 
+        Fetches the computed approximations of the Hessian-based scores for the given
         request and required size.
 
         Args:
-            trace_hessian_request: Configuration for which to fetch the approximation.
+            hessian_scores_request: Configuration for which to fetch the approximation.
             required_size: Number of approximations required.
             batch_size: The Hessian computation batch size.
 
@@ -245,28 +248,28 @@ class HessianInfoService:
             OC for per-output-channel when the requested node has OC output-channels, etc.)
         """
 
-        if len(trace_hessian_request.target_nodes) == 0:
+        if len(hessian_scores_request.target_nodes) == 0:
             return []
 
         if required_size == 0:
-            return [[] for _ in trace_hessian_request.target_nodes]
+            return [[] for _ in hessian_scores_request.target_nodes]
 
-        Logger.info(f"\nEnsuring {required_size} Hessian-trace approximation for nodes "
-                    f"{trace_hessian_request.target_nodes}.")
+        Logger.info(f"\nEnsuring {required_size} Hessian-approximation scores for nodes "
+                    f"{hessian_scores_request.target_nodes}.")
 
         # Replace node in reused target nodes with a representing node from the 'reuse group'.
-        for n in trace_hessian_request.target_nodes:
+        for n in hessian_scores_request.target_nodes:
             if n.reuse_group:
                 rep_node = self._get_representing_of_reuse_group(n)
-                trace_hessian_request.target_nodes.remove(n)
-                if rep_node not in trace_hessian_request.target_nodes:
-                    trace_hessian_request.target_nodes.append(rep_node)
+                hessian_scores_request.target_nodes.remove(n)
+                if rep_node not in hessian_scores_request.target_nodes:
+                    hessian_scores_request.target_nodes.append(rep_node)
 
         # Ensure the saved info has the required number of approximations
-        self._populate_saved_info_to_size(trace_hessian_request, required_size, batch_size)
+        self._populate_saved_info_to_size(hessian_scores_request, required_size, batch_size)
 
         # Return the saved approximations for the given request
-        return self._collect_saved_hessians_for_request(trace_hessian_request, required_size)
+        return self._collect_saved_hessians_for_request(hessian_scores_request, required_size)
 
     def _get_representing_of_reuse_group(self, node) -> Any:
         """
@@ -286,20 +289,20 @@ class HessianInfoService:
         return father_nodes[0]
 
     def _populate_saved_info_to_size(self,
-                                     trace_hessian_request: TraceHessianRequest,
+                                     hessian_scores_request: HessianScoresRequest,
                                      required_size: int,
                                      batch_size: int = 1):
         """
-        Ensures that the saved info has the required size of trace Hessian approximations for the given request.
+        Ensures that the saved info has the required size of Hessian approximation scores for the given request.
 
         Args:
-            trace_hessian_request: Configuration for which to ensure the saved info size.
-            required_size: Required number of trace Hessian approximations.
+            hessian_scores_request: Configuration of the request to ensure the saved info size.
+            required_size: Required number of Hessian-approximation scores.
             batch_size: The Hessian computation batch size.
         """
 
         # Get the current number of saved approximations for each node in the request
-        current_existing_hessians = self.count_saved_info_of_request(trace_hessian_request)
+        current_existing_hessians = self.count_saved_scores_of_request(hessian_scores_request)
 
         # Compute the required number of approximations to meet the required size.
         # Since we allow batch and multi-nodes computation, we take the node with the maximal number of missing
@@ -308,9 +311,9 @@ class HessianInfoService:
         max_remaining_hessians = required_size - min_exist_hessians
 
         Logger.info(
-            f"Running Hessian approximation computation for {len(trace_hessian_request.target_nodes)} nodes.\n "
-            f"The node with minimal existing Hessian-trace approximations has {min_exist_hessians} "
-            f"approximations computed.\n"
+            f"Running Hessian approximation computation for {len(hessian_scores_request.target_nodes)} nodes.\n "
+            f"The node with minimal existing Hessian-approximation scores has {min_exist_hessians} "
+            f"approximated scores computed.\n"
             f"{max_remaining_hessians} approximations left to compute...")
 
         hessian_representative_dataset = partial(self._sample_batch_representative_dataset,
@@ -325,30 +328,31 @@ class HessianInfoService:
             pbar.update(1)
             size_to_compute = min(max_remaining_hessians, batch_size)
             next_iter_remaining_samples = (
-                self.compute(trace_hessian_request, hessian_representative_dataset, size_to_compute,
+                self.compute(hessian_scores_request, hessian_representative_dataset, size_to_compute,
                              last_iter_remain_samples=next_iter_remaining_samples))
             max_remaining_hessians -= size_to_compute
 
-    def _collect_saved_hessians_for_request(self, trace_hessian_request: TraceHessianRequest, required_size: int
-                                            ) -> List[List[np.ndarray]]:
+    def _collect_saved_hessians_for_request(self,
+                                            hessian_scores_request: HessianScoresRequest,
+                                            required_size: int) -> List[List[np.ndarray]]:
         """
         Collects Hessian approximation for the nodes in the given request.
 
         Args:
-            trace_hessian_request: Configuration for which to fetch the approximation.
-            required_size: Required number of trace Hessian approximations.
+            hessian_scores_request: Configuration for which to fetch the approximation.
+            required_size: Required number of Hessian-approximation scores.
 
         Returns: A list with List of computed Hessian approximation (a tensor for each score) for each node
         in the request.
 
         """
         collected_results = []
-        for node in trace_hessian_request.target_nodes:
-            single_node_request = self._construct_single_node_request(trace_hessian_request.mode,
-                                                                      trace_hessian_request.granularity,
+        for node in hessian_scores_request.target_nodes:
+            single_node_request = self._construct_single_node_request(hessian_scores_request.mode,
+                                                                      hessian_scores_request.granularity,
                                                                       node)
 
-            res_for_node = self.trace_hessian_request_to_score_list.get(single_node_request)
+            res_for_node = self.hessian_scores_request_to_scores_list.get(single_node_request)
             if res_for_node is None:  # pragma: no cover
                 Logger.critical(f"Couldn't find saved Hessian approximations for node {node.name}.")
             if len(res_for_node) < required_size:  # pragma: no cover
@@ -362,22 +366,23 @@ class HessianInfoService:
         return collected_results
 
     @staticmethod
-    def _construct_single_node_request(mode: HessianMode, granularity: HessianInfoGranularity, target_nodes: List
-                                       ) -> TraceHessianRequest:
+    def _construct_single_node_request(mode: HessianMode,
+                                       granularity: HessianScoresGranularity,
+                                       target_nodes: List) -> HessianScoresRequest:
         """
         Constructs a Hessian request with for a single node. Used for retrieving and maintaining cached results.
 
         Args:
-            mode (HessianMode): Mode of Hessian's trace approximation (w.r.t weights or activations).
-            granularity (HessianInfoGranularity): Granularity level for the approximation.
-            target_nodes (List[BaseNode]): The node in the float graph for which the Hessian's trace approximation is targeted.
+            mode (HessianMode): Mode of Hessian's approximation (w.r.t weights or activations).
+            granularity (HessianScoresGranularity): Granularity level for the approximation.
+            target_nodes (List[BaseNode]): The node in the float graph for which the Hessian's approximation scores is targeted.
 
-        Returns: A TraceHessianRequest with the given details for the requested node.
+        Returns: A HessianScoresRequest with the given details for the requested node.
 
         """
-        return TraceHessianRequest(mode,
-                                   granularity,
-                                   target_nodes=[target_nodes])
+        return HessianScoresRequest(mode,
+                                    granularity,
+                                    target_nodes=[target_nodes])
 
     @staticmethod
     def _convert_tensor_to_list_of_appx_results(t: Any) -> List:

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/model_compression_toolkit/core/common/hessian/hessian_info_utils.py

@@ -19,7 +19,7 @@ from model_compression_toolkit.constants import EPS
 
 def normalize_scores(hessian_approximations: List) -> List[np.ndarray]:
     """
-    Normalize Hessian information approximations by dividing the trace Hessian approximations value by the sum of all
+    Normalize Hessian scores approximations by dividing their value by the sum of all
     other values.
 
     Args:

mct-nightly-2.1.0.20240708.453/model_compression_toolkit/core/common/hessian/trace_hessian_calculator.py → mct-nightly-2.1.0.20240709.429/model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py

@@ -18,16 +18,16 @@ from typing import List, Any
 
 from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.core.common.hessian import TraceHessianRequest
+from model_compression_toolkit.core.common.hessian import HessianScoresRequest
 from model_compression_toolkit.logger import Logger
 
 
-class TraceHessianCalculator(ABC):
+class HessianScoresCalculator(ABC):
     """
-    Abstract base class for computing an approximation of the trace of the Hessian.
+    Abstract base class for computing scores based on the Hessian matrix approximation.
 
     This class provides a structure for implementing different methods to compute
-    the trace of the Hessian approximation based on the provided configuration,
+    scores based on Hessian-approximation according to the provided configuration,
     input images, and other parameters.
     """
 
@@ -35,15 +35,15 @@ class TraceHessianCalculator(ABC):
                  graph: Graph,
                  input_images: List[Any],
                  fw_impl,
-                 trace_hessian_request: TraceHessianRequest,
+                 hessian_scores_request: HessianScoresRequest,
                  num_iterations_for_approximation: int = HESSIAN_NUM_ITERATIONS):
         """
         Args:
             graph: Computational graph for the float model.
             input_images: List of input images for the computation.
-            fw_impl: Framework-specific implementation for trace Hessian computation.
-            trace_hessian_request: Configuration request for which to compute the trace Hessian approximation.
-            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian trace.
+            fw_impl: Framework-specific implementation for Hessian-approximation scores computation.
+            hessian_scores_request: Configuration request for which to compute the Hessian-based approximation.
+            num_iterations_for_approximation: Number of iterations to use when approximating the Hessian-approximation scores.
 
         """
         self.graph = graph
@@ -60,15 +60,15 @@ class TraceHessianCalculator(ABC):
             Logger.critical(f"The graph requires {len(graph.get_inputs())} inputs, but the provided representative dataset contains {len(self.input_images)} inputs.")
 
         self.fw_impl = fw_impl
-        self.hessian_request = trace_hessian_request
+        self.hessian_request = hessian_scores_request
 
     @abstractmethod
     def compute(self) -> List[float]:
         """
-        Abstract method to compute the approximation of the trace of the Hessian.
+        Abstract method to compute the scores based on the Hessian-approximation matrix.
 
         This method should be implemented by subclasses to provide the specific
-        computation method for the trace Hessian approximation.
+        computation method for the Hessian-approximation scores.
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement compute method.')  # pragma: no cover
 

mct-nightly-2.1.0.20240708.453/model_compression_toolkit/core/common/hessian/trace_hessian_request.py → mct-nightly-2.1.0.20240709.429/model_compression_toolkit/core/common/hessian/hessian_scores_request.py

@@ -28,11 +28,11 @@ class HessianMode(Enum):
     ACTIVATION = 1     # Hessian approximation based on activations
 
 
-class HessianInfoGranularity(Enum):
+class HessianScoresGranularity(Enum):
     """
-    Enum representing the granularity level for Hessian information computation.
+    Enum representing the granularity level for Hessian scores computation.
 
-    This determines the number the Hessian approximations is computed for some node.
+    This determines the number the Hessian scores is computed for some node.
     Note: This is not the actual Hessian but an approximation.
     """
     PER_ELEMENT = 0
@@ -40,25 +40,25 @@ class HessianInfoGranularity(Enum):
     PER_TENSOR = 2
 
 
-class TraceHessianRequest:
+class HessianScoresRequest:
     """
-    Request configuration for the trace of the Hessian approximation.
+    Request configuration for the Hessian-approximation scores.
 
-    This class defines the parameters for the approximation of the trace of the Hessian matrix.
+    This class defines the parameters for the scores based on the Hessian matrix approximation.
     It specifies the mode (weights/activations), granularity (element/channel/tensor), and the target node.
-    Note: This does not compute the actual Hessian's trace but approximates it.
+
+    Note: This does not compute scores using the actual Hessian matrix but an approximation.
     """
 
     def __init__(self,
                  mode: HessianMode,
-                 granularity: HessianInfoGranularity,
-                 target_nodes: List,
-                 ):
+                 granularity: HessianScoresGranularity,
+                 target_nodes: List):
         """
         Attributes:
-            mode (HessianMode): Mode of Hessian's trace approximation (w.r.t weights or activations).
-            granularity (HessianInfoGranularity): Granularity level for the approximation.
-            target_nodes (List[BaseNode]): The node in the float graph for which the Hessian's trace approximation is targeted.
+            mode (HessianMode): Mode of Hessian-approximation score (w.r.t weights or activations).
+            granularity (HessianScoresGranularity): Granularity level for the approximation.
+            target_nodes (List[BaseNode]): The node in the float graph for which the Hessian's approximation scores is targeted.
         """
 
         self.mode = mode  # w.r.t activations or weights
@@ -66,9 +66,9 @@ class TraceHessianRequest:
         self.target_nodes = target_nodes
 
     def __eq__(self, other):
-        # Checks if the other object is an instance of TraceHessianRequest
+        # Checks if the other object is an instance of HessianScoresRequest
         # and then checks if all attributes are equal.
-        return isinstance(other, TraceHessianRequest) and \
+        return isinstance(other, HessianScoresRequest) and \
                self.mode == other.mode and \
                self.granularity == other.granularity and \
                self.target_nodes == other.target_nodes

{mct-nightly-2.1.0.20240708.453 → mct-nightly-2.1.0.20240709.429}/model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py

@@ -51,7 +51,7 @@ def search_bit_width(graph_to_search_cfg: Graph,
                      mp_config: MixedPrecisionQuantizationConfig,
                      representative_data_gen: Callable,
                      search_method: BitWidthSearchMethod = BitWidthSearchMethod.INTEGER_PROGRAMMING,
-                     hessian_info_service: HessianInfoService=None) -> List[int]:
+                     hessian_info_service: HessianInfoService = None) -> List[int]:
     """
     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
@@ -68,7 +68,7 @@ def search_bit_width(graph_to_search_cfg: Graph,
         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.
-        hessian_info_service: HessianInfoService to fetch Hessian traces approximations.
+        hessian_info_service: HessianInfoService to fetch Hessian-approximation information.
 
     Returns:
         A MP configuration for the graph (list of integers, where the index in the list, is the node's