mct-nightly 2.3.0.20250223.538__tar.gz → 2.3.0.20250225.512__tar.gz

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.3.0.20250223.538
+Version: 2.3.0.20250225.512
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
@@ -234,4 +234,4 @@ MCT is licensed under Apache License Version 2.0. By contributing to the project
 
 [4] Gordon, O., Cohen, E., Habi, H. V., & Netzer, A., 2024. [EPTQ: Enhanced Post-Training Quantization via Hessian-guided Network-wise Optimization, European Conference on Computer Vision Workshop 2024, Computational Aspects of Deep Learning (CADL)](https://arxiv.org/abs/2309.11531)
 
-[5] Dikstein, L., Lapid, A., Netzer, A., & Habi, H. V., 2024. [Data Generation for Hardware-Friendly Post-Training Quantization, Accepted to IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025](https://arxiv.org/abs/2410.22110)
+[5] Dikstein, L., Lapid, A., Netzer, A., & Habi, H. V., 2024. [Data Generation for Hardware-Friendly Post-Training Quantization, Accepted to IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025](https://openaccess.thecvf.com/content/WACV2025/papers/Dikstein_Data_Generation_for_Hardware-Friendly_Post-Training_Quantization_WACV_2025_paper.pdf)

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/README.md

@@ -203,4 +203,4 @@ MCT is licensed under Apache License Version 2.0. By contributing to the project
 
 [4] Gordon, O., Cohen, E., Habi, H. V., & Netzer, A., 2024. [EPTQ: Enhanced Post-Training Quantization via Hessian-guided Network-wise Optimization, European Conference on Computer Vision Workshop 2024, Computational Aspects of Deep Learning (CADL)](https://arxiv.org/abs/2309.11531)
 
-[5] Dikstein, L., Lapid, A., Netzer, A., & Habi, H. V., 2024. [Data Generation for Hardware-Friendly Post-Training Quantization, Accepted to IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025](https://arxiv.org/abs/2410.22110)
+[5] Dikstein, L., Lapid, A., Netzer, A., & Habi, H. V., 2024. [Data Generation for Hardware-Friendly Post-Training Quantization, Accepted to IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025](https://openaccess.thecvf.com/content/WACV2025/papers/Dikstein_Data_Generation_for_Hardware-Friendly_Post-Training_Quantization_WACV_2025_paper.pdf)

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.3.0.20250223.538
+Version: 2.3.0.20250225.512
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
@@ -234,4 +234,4 @@ MCT is licensed under Apache License Version 2.0. By contributing to the project
 
 [4] Gordon, O., Cohen, E., Habi, H. V., & Netzer, A., 2024. [EPTQ: Enhanced Post-Training Quantization via Hessian-guided Network-wise Optimization, European Conference on Computer Vision Workshop 2024, Computational Aspects of Deep Learning (CADL)](https://arxiv.org/abs/2309.11531)
 
-[5] Dikstein, L., Lapid, A., Netzer, A., & Habi, H. V., 2024. [Data Generation for Hardware-Friendly Post-Training Quantization, Accepted to IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025](https://arxiv.org/abs/2410.22110)
+[5] Dikstein, L., Lapid, A., Netzer, A., & Habi, H. V., 2024. [Data Generation for Hardware-Friendly Post-Training Quantization, Accepted to IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025](https://openaccess.thecvf.com/content/WACV2025/papers/Dikstein_Data_Generation_for_Hardware-Friendly_Post-Training_Quantization_WACV_2025_paper.pdf)

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/mct_nightly.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ model_compression_toolkit/core/common/collectors/histogram_collector.py
 model_compression_toolkit/core/common/collectors/mean_collector.py
 model_compression_toolkit/core/common/collectors/min_max_per_channel_collector.py
 model_compression_toolkit/core/common/collectors/statistics_collector.py
+model_compression_toolkit/core/common/collectors/weighted_histogram_collector.py
 model_compression_toolkit/core/common/fusion/__init__.py
 model_compression_toolkit/core/common/fusion/graph_fuser.py
 model_compression_toolkit/core/common/fusion/layer_fusing.py

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/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.3.0.20250223.000538"
+__version__ = "2.3.0.20250225.000512"

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/collectors/histogram_collector.py

@@ -53,38 +53,37 @@ class HistogramCollector(BaseCollector):
         """
 
         super().__init__()
-        self.__n_bins = n_bins
-        self.__bins = None
-        self.__counts = None
-        self.__histogram_per_iteration = []
+        self._n_bins = n_bins
+        self._bins = None
+        self._counts = None
+        self._histogram_per_iteration = []
 
-    def __merge_histograms(self):
+    def _merge_histograms(self):
         """
         After collecting histogram per iteration, we merge these histograms to a single histogram
         containing all samples from all iterations.
         The merge is done in a lazy manner (is computed only when actually needed).
         """
-        if len(self.__histogram_per_iteration) > 0:
+        if len(self._histogram_per_iteration) > 0:
             # Stack all bins that were gathered during inference
-            bins_stack = np.vstack([hist[1] for hist in self.__histogram_per_iteration])
+            bins_stack = np.vstack([hist[1] for hist in self._histogram_per_iteration])
 
             # The combined histogram will be computed between new min/max (which is the min/max of all histograms).
             # The bin width of the merged histogram is the minimal bin width among all histograms (to lose as less
             # information as possible during the merge).
             merged_histogram_min = np.min(bins_stack)
             merged_histogram_max = np.max(bins_stack)
-            merged_bin_width = (merged_histogram_max - merged_histogram_min) / self.__n_bins
-            merged_histogram_bins = np.arange(merged_histogram_min, merged_histogram_max+merged_bin_width, merged_bin_width)
+            merged_histogram_bins = np.linspace(merged_histogram_min, merged_histogram_max, self._n_bins + 1)
 
             merged_histogram_counts = None
-            for histogram in self.__histogram_per_iteration:  # Iterate all collected histograms and merge them
+            for histogram in self._histogram_per_iteration:  # Iterate all collected histograms and merge them
                 if merged_histogram_counts is None:  # First histogram to consider
-                    merged_histogram_counts = interpolate_histogram(merged_histogram_bins, histogram[1], histogram[0])
+                    merged_histogram_counts = histogram[0].astype(np.float64)  # Convert to float64
                 else:  # Merge rest of histograms into existing final histogram
                     merged_histogram_counts += interpolate_histogram(merged_histogram_bins, histogram[1], histogram[0])
 
-            self.__counts = merged_histogram_counts
-            self.__bins = merged_histogram_bins
+            self._counts = merged_histogram_counts
+            self._bins = merged_histogram_bins
 
     def scale(self, scale_factor: np.ndarray):
         """
@@ -102,7 +101,7 @@ class HistogramCollector(BaseCollector):
             self.update_legal_status(is_illegal=True)
         else:
             bins, _ = self.get_histogram()
-            self.__bins = bins * scale_factor
+            self._bins = bins * scale_factor
 
     def shift(self, shift_value: np.ndarray):
         """
@@ -120,7 +119,7 @@ class HistogramCollector(BaseCollector):
             self.update_legal_status(is_illegal=True)
         else:
             bins, _ = self.get_histogram()
-            self.__bins = bins + shift_value
+            self._bins = bins + shift_value
 
     def get_histogram(self) -> Tuple[np.ndarray, np.ndarray]:
         """
@@ -130,9 +129,9 @@ class HistogramCollector(BaseCollector):
         self.validate_data_correctness()
         # If collected histograms (one per inference iteration) were not merged before, merge them and return the
         # merged histogram.
-        if self.__bins is None or self.__counts is None:
-            self.__merge_histograms()
-        return self.__bins, self.__counts
+        if self._bins is None or self._counts is None:
+            self._merge_histograms()
+        return self._bins, self._counts
 
     def max(self):
         """
@@ -156,5 +155,5 @@ class HistogramCollector(BaseCollector):
         Args:
             x: Tensor going through the collector to update the histogram according to.
         """
-        count, bins = np.histogram(x, bins=self.__n_bins)
-        self.__histogram_per_iteration.append((count, bins))
+        count, bins = np.histogram(x, bins=self._n_bins)
+        self._histogram_per_iteration.append((count, bins))

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/collectors/statistics_collector.py

@@ -17,13 +17,12 @@
 import math
 from copy import deepcopy
 from typing import Any, Tuple
-
 import numpy as np
 
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo, ChannelAxis
 from model_compression_toolkit.core.common.collectors.histogram_collector import HistogramCollector
 from model_compression_toolkit.core.common.collectors.mean_collector import MeanCollector
 from model_compression_toolkit.core.common.collectors.min_max_per_channel_collector import MinMaxPerChannelCollector
+from model_compression_toolkit.core.common.collectors.weighted_histogram_collector import WeightedHistogramCollector
 
 
 class BaseStatsCollector(object):
@@ -71,21 +70,24 @@ class StatsCollector(BaseStatsCollector):
 
         super().__init__()
         self.hc = HistogramCollector()
+        self.weighted_hc = WeightedHistogramCollector()
         self.mc = MeanCollector(axis=out_channel_axis)
         self.mpcc = MinMaxPerChannelCollector(init_min_value=init_min_value,
                                               init_max_value=init_max_value,
                                               axis=out_channel_axis)
 
-    def update_statistics(self, x: Any):
+    def update_statistics(self, x: Any, weights: Any=None):
         """
         Update statistics in all collectors with a new tensor to consider.
 
         Args:
             x: Tensor to consider when updating statistics.
+            weights: Weights tensor to consider when updating statistics.
         """
 
         x = standardize_tensor(x)
         self.hc.update(x)
+        self.weighted_hc.update(x, weights)
         self.mc.update(x)
         self.mpcc.update(x)
 
@@ -228,6 +230,7 @@ def shift_statistics(collector: BaseStatsCollector,
         shifted_collector.mc.shift(shift_value)
         if shifted_collector.require_collection():
             shifted_collector.hc.shift(shift_value)
+            shifted_collector.weighted_hc.shift(shift_value)
 
     return shifted_collector
 
@@ -253,5 +256,6 @@ def scale_statistics(collector: BaseStatsCollector,
         scaled_collector.mc.scale(scale_value)
         if scaled_collector.require_collection():
             scaled_collector.hc.scale(scale_value)
+            scaled_collector.weighted_hc.scale(scale_value)
 
     return scaled_collector

mct_nightly-2.3.0.20250225.512/model_compression_toolkit/core/common/collectors/weighted_histogram_collector.py

@@ -0,0 +1,114 @@
+# Copyright 2025 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import numpy as np
+from model_compression_toolkit.core.common.collectors.histogram_collector import HistogramCollector
+from model_compression_toolkit.logger import Logger
+
+
+def check_broadcastable(x: np.ndarray, weights: np.ndarray) -> None:
+    """
+    Checks if tensor 'weights' can be broadcasted to the shape of tensor 'x'.
+
+    Args:
+        x (np.ndarray): The target tensor.
+        weights (np.ndarray): The tensor to check broadcasting compatibility.
+
+    Raises:
+        Logger.critical: If 'weights' cannot be broadcasted to 'x'.
+    """
+    # Get shapes
+    shape_x = x.shape
+    shape_w = weights.shape
+
+    # Ensure weights has less or equal dimensions than x
+    if len(shape_w) > len(shape_x):
+        Logger.critical(f"Tensor weights with shape {shape_w} has more dimensions than tensor a with shape {shape_x}.")
+
+    # Align shapes by padding weights' shape with leading ones
+    shape_w = (1,) * (len(shape_x) - len(shape_w)) + shape_w
+
+    # Check if each dimension is either equal or 1
+    for i, (sx, sw) in enumerate(zip(shape_x, shape_w)):
+        if not (sx == sw or sw == 1):
+            Logger.critical(f"Tensor weights with shape {shape_w} cannot be broadcasted to tensor a with shape {shape_x}. "
+                             f"Dimension mismatch at index {i}: {sw} cannot be broadcasted to {sx}.")
+
+
+class WeightedHistogramCollector(HistogramCollector):
+    """
+    Collector for holding weighted histograms of tensors going through it.
+    Extends the functionality of the base HistogramCollector by incorporating weights
+    into the histogram calculation, allowing for weighted distributions.
+    """
+    def __init__(self, n_bins: int = 2048):
+        """
+        Args:
+            n_bins: Number of bins in the histogram.
+        """
+
+        super().__init__(n_bins)
+
+    def update(self, x: np.ndarray, weights: np.ndarray = None):
+        """
+        Update the current state of the histogram bins and counts based on a new
+        tensor that passes through the collector, taking weights into account.
+
+        Args:
+            x: Tensor that passes through the collector to update the histogram.
+            weights: Array of weights corresponding to the elements of the tensor `x`.
+                     If not provided, uniform weights of 1 will be applied to all elements.
+
+        Details:
+            - The `weights` parameter allows each element of `x` to contribute a
+              weighted amount to the histogram bins, rather than contributing a simple count.
+            - This is particularly useful when the data being processed has an associated
+              importance, frequency, or probability value that should influence the histogram.
+              For example:
+                - Hessian values can serve as weights for each activation in `x`.
+                - Normalization of the histogram to reflect relative contributions.
+            - The method ensures that `x` and `weights` have matching shapes and logs
+              an error if this condition is not met.
+        """
+        if weights is None or np.all(weights == 0):
+            weights = np.ones_like(x) # Assign uniform weights if none are provided.
+
+        # Checks if tensor 'weights' can be broadcasted to the shape of tensor 'x'.
+        check_broadcastable(x, weights)
+
+        # Get x's shape
+        x_shape = x.shape
+
+        # Get weight's shape
+        weights_shape = weights.shape
+
+        # Determine the correct shape for weights
+        weights_new_shape = list(weights_shape)  # Convert to list for modification
+
+        # Ensure weights has the same number of dimensions as x
+        while len(weights_new_shape) < len(x_shape):
+            weights_new_shape.append(1)  # Add singleton dimensions
+
+        # Reshape weights to the correct shape
+        weights = weights.reshape(weights_new_shape)
+
+        # Broadcast weights to match x's shape
+        weights = np.broadcast_to(weights, x_shape)
+
+        # Compute the weighted histogram.
+        count, bins = np.histogram(x, bins=self._n_bins, weights=weights)
+
+        # Store the weighted histogram (counts and bins) for this iteration.
+        self._histogram_per_iteration.append((count, bins))

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/framework_implementation.py

@@ -137,13 +137,18 @@ class FrameworkImplementation(ABC):
     @abstractmethod
     def run_model_inference(self,
                             model: Any,
-                            input_list: List[Any]) -> Tuple[Any]:
+                            input_list: List[Any],
+                            requires_grad: bool = False) -> Tuple[Any]:
         """
-        Run the model logic on the given the inputs.
+        Executes the given model on the provided input data.
+
+        This method must be implemented by subclasses to provide framework-specific logic
+        for running inference (e.g., PyTorch, TensorFlow/Keras).
 
         Args:
-            model: Framework's model.
-            input_list: List of inputs for the model.
+            model: The framework-specific model instance.
+            input_list: A list of inputs for the model.
+            requires_grad: Whether to enable gradient computation. Defaults to `False`.
 
         Returns:
             The frameworks model's output.

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/graph/base_node.py

@@ -440,18 +440,28 @@ class BaseNode:
 
         return any([self.is_weights_quantization_enabled(attr) for attr in self.get_node_weights_attributes()])
 
-    def get_total_output_params(self) -> float:
+    # TODO it makes more sense to standardize the input/output shapes at node creation.
+    def get_output_shapes_list(self) -> List[tuple]:
         """
-        Calculates the output size of the node.
+        Return output shape in a standardized form as a list of tuples.
 
-        Returns: Output size.
+        Returns:
+            A list of output shape tuples.
         """
         # shape can be tuple or list, and multiple shapes can be packed in list or tuple
         if self.output_shape and isinstance(self.output_shape[0], (tuple, list)):
-            output_shapes = self.output_shape
+            output_shapes = [tuple(s) for s in self.output_shape]
         else:
-            output_shapes = [self.output_shape]
+            output_shapes = [tuple(self.output_shape)]
+        return output_shapes
+
+    def get_total_output_params(self) -> float:
+        """
+        Calculates the output size of the node.
 
+        Returns: Output size.
+        """
+        output_shapes = self.get_output_shapes_list()
         # remove batch size (first element) from output shape
         output_shapes = [s[1:] for s in output_shapes]
         # for scalar shape (None,) prod returns 1
@@ -550,7 +560,7 @@ class BaseNode:
         """
 
         return len(self.candidates_quantization_cfg) > 0 and \
-               any([c.activation_quantization_cfg.enable_activation_quantization for c in self.candidates_quantization_cfg])
+            any([c.activation_quantization_cfg.enable_activation_quantization for c in self.candidates_quantization_cfg])
 
     def get_all_weights_attr_candidates(self, attr: str) -> List[WeightsAttrQuantizationConfig]:
         """

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/hessian/hessian_info_service.py

@@ -13,13 +13,14 @@
 # limitations under the License.
 # ==============================================================================
 from dataclasses import dataclass
-from typing import List, Dict, Tuple, TYPE_CHECKING
+from typing import List, Dict, Tuple, TYPE_CHECKING, Any, Optional
 
 import numpy as np
 
 from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
 from model_compression_toolkit.core.common.hessian.hessian_scores_request import HessianScoresRequest, HessianMode, \
     HessianScoresGranularity
+from model_compression_toolkit.logger import Logger
 
 if TYPE_CHECKING:    # pragma: no cover
     from model_compression_toolkit.core.common import BaseNode
@@ -139,24 +140,31 @@ class HessianInfoService:
         self.cache = HessianCache()
 
     def fetch_hessian(self, request: HessianScoresRequest,
-                      force_compute: bool = False) -> Dict[LayerName, Tensor]:
+                      activation_tensors: Optional[Tuple[Any]] = None,
+                      force_compute: bool = False,
+                      ) -> Dict[LayerName, Tensor]:
         """
-        Fetch hessians per request.
-        If 'force_compute' is False, will first try to retrieve previously cached hessians. If no or not enough
-        hessians are found in the cache, will compute the remaining number of hessians to fulfill the request.
-        If 'force_compute' is True, will compute the hessians (use when you need hessians for specific inputs).
+        Fetches Hessian approximations based on the given request.
+
+        This method retrieves Hessians from the cache when available, unless `force_compute` is set to `True`,
+        in which case the Hessians are recomputed (use when you need hessians for specific inputs).
+        If `compute_from_tensors` in the request is `True`, the Hessians are computed directly from
+        the provided activation tensors.
 
         Args:
             request: request per which to fetch the hessians.
+            activation_tensors (Optional[Tuple[Any]): List of activation tensors used for Hessian computation
+            when `compute_from_tensors` in the request is `True`. Defaults to None.
             force_compute: if True, will compute the hessians.
                            If False, will look for cached hessians first.
 
+
         Returns:
             A dictionary of layers' hessian tensors of shape (samples, ...). The exact shape depends on the
             requested granularity.
         """
-        if request.n_samples is None and not force_compute:
-            raise ValueError('Number of samples can be None only when force_compute is True.')
+        if request.n_samples is None and not (force_compute or request.compute_from_tensors):
+            Logger.critical('Number of samples can be None only when force_compute is True.')
 
         orig_request = request
         # replace reused nodes with primary nodes
@@ -165,13 +173,21 @@ class HessianInfoService:
         target_nodes = [self._get_primary_node(n) for n in request.target_nodes]
         request = request.clone(target_nodes=target_nodes)
 
-        if force_compute:
-            res = self._compute_hessians(request, self.num_iterations_for_approximation, count_by_cache=False)
+        if request.compute_from_tensors:
+            if activation_tensors is None:
+                Logger.critical(f"The 'compute_from_tensors' option is enabled, but no 'activation_tensors' were provided.")
+            # This mode is primarily used for Hessian-weighted histograms in statistical collection.
+            # To ensure efficiency, we approximate the Hessian using a single iteration.
+            # This provides a sufficiently accurate approximation for this feature.
+            res = self._compute_hessian_for_batch(request, activation_tensors, n_iterations=1)
         else:
-            res = self._fetch_hessians_with_compute(request, self.num_iterations_for_approximation)
+            if force_compute:
+                res = self._compute_hessians(request, self.num_iterations_for_approximation, count_by_cache=False)
+            else:
+                res = self._fetch_hessians_with_compute(request, self.num_iterations_for_approximation)
 
-        # restore nodes from the original request
-        res = {n_orig.name: res[n.name] for n_orig, n in zip(orig_request.target_nodes, request.target_nodes)}
+            # restore nodes from the original request
+            res = {n_orig.name: res[n.name] for n_orig, n in zip(orig_request.target_nodes, request.target_nodes)}
         return res
 
     def clear_cache(self):
@@ -194,7 +210,7 @@ class HessianInfoService:
             return res
 
         if request.data_loader is None:
-            raise ValueError(f'Not enough hessians are cached to fulfill the request, but data loader was not passed '
+            Logger.critical(f'Not enough hessians are cached to fulfill the request, but data loader was not passed '
                              f'for additional computation. Requested {request.n_samples}, '
                              f'available {min(missing.values())}.')
 
@@ -249,7 +265,7 @@ class HessianInfoService:
 
         if request.n_samples:
             if n_samples < request.n_samples:
-                raise ValueError(f'Could not compute the requested number of Hessians ({request.n_samples}), '
+                Logger.critical(f'Could not compute the requested number of Hessians ({request.n_samples}), '
                                  f'not enough samples in the provided representative dataset.')
 
             if n_samples > request.n_samples:

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py

@@ -56,7 +56,7 @@ class HessianScoresCalculator(ABC):
         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()):  # pragma: no cover
+        if not hessian_scores_request.compute_from_tensors and len(self.input_images) != len(graph.get_inputs()):  # pragma: no cover
             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

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/hessian/hessian_scores_request.py

@@ -17,6 +17,8 @@ import dataclasses
 
 from enum import Enum
 
+from model_compression_toolkit.logger import Logger
+
 if TYPE_CHECKING:    # pragma: no cover
     from model_compression_toolkit.core.common import BaseNode
 
@@ -60,16 +62,19 @@ class HessianScoresRequest:
             the computation. Can be None if all hessians for the request are expected to be pre-computed previously.
         n_samples: The number of samples to fetch hessian estimations for. If None, fetch hessians for a full pass
             of the data loader.
+        compute_from_tensors: If `True`, Hessians are computed directly from given tensors instead of using the data loader.
+
     """
     mode: HessianMode
     granularity: HessianScoresGranularity
     target_nodes: Sequence['BaseNode']
     data_loader: Optional[Iterable]
     n_samples: Optional[int]
+    compute_from_tensors: bool = False
 
     def __post_init__(self):
-        if self.data_loader is None and self.n_samples is None:
-            raise ValueError('Data loader and the number of samples cannot both be None.')
+        if self.data_loader is None and self.n_samples is None and not self.compute_from_tensors:
+            Logger.critical('Data loader and the number of samples cannot both be None.')
 
     def clone(self, **kwargs):
         """ Create a clone with optional overrides """

{mct_nightly-2.3.0.20250223.538 → mct_nightly-2.3.0.20250225.512}/model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py

@@ -218,7 +218,12 @@ def _add_ru_constraints(search_manager: MixedPrecisionSearchManager,
             ru_vec = np.concatenate([ru_vec, non_conf_ru_vec])
         ru_indicated_vectors[target] = ru_vec
 
-    # add constraints only for the restricted targets in target resource utilization.
+    # Add constraints only for the restricted targets in target resource utilization.
+    # Adding activation constraints modifies the lp term in ru_indicated_vectors, so if both activation and total
+    # are restricted we first add the constraints for total.
+    if RUTarget.TOTAL in constraints_targets and RUTarget.ACTIVATION in constraints_targets:
+        constraints_targets.remove(RUTarget.ACTIVATION)
+        constraints_targets = list(constraints_targets) + [RUTarget.ACTIVATION]
     for target in constraints_targets:
         target_resource_utilization_value = target_resource_utilization.get_resource_utilization_dict()[target]
         aggr_ru = _aggregate_for_lp(ru_indicated_vectors, target)