mct-nightly 2.3.0.20250323.559__py3-none-any.whl → 2.3.0.20250325.524__py3-none-any.whl

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py

@@ -12,11 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+import copy
+from collections import defaultdict
 
-from typing import Callable, Dict, List
+from tqdm import tqdm
+
+from typing import Dict, List, Tuple
 
 import numpy as np
 
+from model_compression_toolkit.constants import EPS
 from model_compression_toolkit.core.common import BaseNode
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
@@ -29,7 +34,10 @@ from model_compression_toolkit.core.common.mixed_precision.resource_utilization_
     TargetInclusionCriterion, BitwidthMode
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_ru_helper import \
     MixedPrecisionRUHelper
+from model_compression_toolkit.core.common.mixed_precision.search_methods.linear_programming import \
+    MixedPrecisionIntegerLPSolver
 from model_compression_toolkit.core.common.mixed_precision.sensitivity_evaluation import SensitivityEvaluation
+from model_compression_toolkit.core.common.substitutions.apply_substitutions import substitute
 from model_compression_toolkit.logger import Logger
 
 
@@ -43,8 +51,7 @@ class MixedPrecisionSearchManager:
                  fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation,
                  sensitivity_evaluator: SensitivityEvaluation,
-                 target_resource_utilization: ResourceUtilization,
-                 original_graph: Graph = None):
+                 target_resource_utilization: ResourceUtilization):
         """
 
         Args:
@@ -54,96 +61,208 @@ class MixedPrecisionSearchManager:
             sensitivity_evaluator: A SensitivityEvaluation which provides a function that evaluates the sensitivity of
                 a bit-width configuration for the MP model.
             target_resource_utilization: Target Resource Utilization to bound our feasible solution space s.t the configuration does not violate it.
-            original_graph: In case we have a search over a virtual graph (if we have BOPS utilization target), then this argument
-                will contain the original graph (for config reconstruction purposes).
         """
 
-        self.graph = graph
-        self.original_graph = graph if original_graph is None else original_graph
         self.fw_info = fw_info
         self.fw_impl = fw_impl
+
+        self.original_graph = graph
+        # graph for mp search
+        self.mp_graph, self.using_virtual_graph = self._get_mp_graph(graph, target_resource_utilization)
+        del graph  # so that it's not used by mistake
+
         self.sensitivity_evaluator = sensitivity_evaluator
+        self.target_resource_utilization = target_resource_utilization
+
+        self.mp_topo_configurable_nodes = self.mp_graph.get_configurable_sorted_nodes(fw_info)
         self.layer_to_bitwidth_mapping = self.get_search_space()
-        self.compute_metric_fn = self.get_sensitivity_metric()
-        self._cuts = None
 
-        # To define RU Total constraints we need to compute weights and activations even if they have no constraints
-        # TODO currently this logic is duplicated in linear_programming.py
-        targets = target_resource_utilization.get_restricted_targets()
-        if RUTarget.TOTAL in targets:
-            targets = targets.union({RUTarget.ACTIVATION, RUTarget.WEIGHTS}) - {RUTarget.TOTAL}
-        self.ru_targets_to_compute = targets
+        self.ru_targets = target_resource_utilization.get_restricted_targets()
+        self.ru_helper = MixedPrecisionRUHelper(self.mp_graph, fw_info, fw_impl)
 
-        self.ru_helper = MixedPrecisionRUHelper(graph, fw_info, fw_impl)
-        self.target_resource_utilization = target_resource_utilization
-        self.min_ru_config = self.graph.get_min_candidates_config(fw_info)
-        self.max_ru_config = self.graph.get_max_candidates_config(fw_info)
-        self.min_ru = self.ru_helper.compute_utilization(self.ru_targets_to_compute, self.min_ru_config)
-        self.non_conf_ru_dict = self.ru_helper.compute_utilization(self.ru_targets_to_compute, None)
+        self.min_ru_config = self.mp_graph.get_min_candidates_config(fw_info)
+        self.max_ru_config = self.mp_graph.get_max_candidates_config(fw_info)
+        self.min_ru = self.ru_helper.compute_utilization(self.ru_targets, self.min_ru_config)
 
-        self.config_reconstruction_helper = ConfigReconstructionHelper(virtual_graph=self.graph,
+        self.config_reconstruction_helper = ConfigReconstructionHelper(virtual_graph=self.mp_graph,
                                                                        original_graph=self.original_graph)
 
-    def get_search_space(self) -> Dict[int, List[int]]:
+    def search(self) -> List[int]:
         """
-        The search space is a mapping from a node's index to a list of integers (possible bitwidths candidates indeces
-        for the node).
+        Run mixed precision search.
 
         Returns:
-            The entire search space of the graph.
+            Indices of the selected bit-widths candidates.
         """
+        candidates_sensitivity = self._build_sensitivity_mapping()
+        candidates_ru = self._compute_relative_ru_matrices()
+        rel_target_ru = self._get_relative_ru_constraint_per_mem_element()
+        solver = MixedPrecisionIntegerLPSolver(candidates_sensitivity, candidates_ru, rel_target_ru)
+        config = solver.run()
 
-        indices_mapping = {}
-        nodes_to_configure = self.graph.get_configurable_sorted_nodes(self.fw_info)
-        for idx, n in enumerate(nodes_to_configure):
-            # For each node, get all possible bitwidth indices for it
-            # (which is a list from 0 to the length of the candidates mp_config list of the node).
-            indices_mapping[idx] = list(range(len(n.candidates_quantization_cfg)))  # all search_methods space
-        return indices_mapping
+        if self.using_virtual_graph:
+            config = self.config_reconstruction_helper.reconstruct_config_from_virtual_graph(config)
+        return config
 
-    def get_sensitivity_metric(self) -> Callable:
+    def _get_relative_ru_constraint_per_mem_element(self) -> Dict[RUTarget, np.ndarray]:
         """
+        Computes resource utilization constraint with respect to the minimal bit configuration, i.e. corresponding
+        constraint for each memory element is the relative utilization between the target utilization and
+        element's utilization for min-bit configuration.
+
+        Returns:
+            A dictionary of relative resource utilization constraints per ru target.
+
+        Raises:
+            ValueError: if target resource utilization cannot be satisfied (utilization for the minimal bit
+              configuration exceeds the requested target utilization for any target).
+        """
+        target_ru = self.target_resource_utilization.get_resource_utilization_dict(restricted_only=True)
+        rel_target_ru = {
+            ru_target: ru - self.min_ru[ru_target] for ru_target, ru in target_ru.items()
+        }
+        unsatisfiable_targets = {
+            ru_target.value: target_ru[ru_target] for ru_target, ru in rel_target_ru.items() if any(ru < 0)
+        }
+        if unsatisfiable_targets:
+            raise ValueError(f"The model cannot be quantized to meet the specified resource utilization for the "
+                             f"following targets: {unsatisfiable_targets}")
+        return rel_target_ru
+
+    def _build_sensitivity_mapping(self, 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.
+        It builds a mapping from a node's index, to its bitwidht's effect on the model sensitivity.
+        For each node and some possible node's bitwidth (according to the given search space), we use
+        the framework function compute_metric_fn in order to infer
+        a batch of images, and compute (using the inference results) the sensitivity metric of
+        the configured mixed-precision model.
+
+        Args:
+            eps: Epsilon value to manually increase metric value (if necessary) for numerical stability
 
-        Returns: Return a function (from the framework implementation) to compute a metric that
-        indicates the similarity of the mixed-precision model (to the float model) for a given
-        mixed-precision configuration.
+        Returns:
+            Mapping from each node's index in a graph, to a dictionary from the bitwidth index (of this node) to
+            the sensitivity of the model.
 
         """
-        # Get from the framework an evaluation function on how a MP configuration,
-        # affects the expected loss.
 
-        return self.sensitivity_evaluator.compute_metric
+        Logger.info('Starting to evaluate metrics')
+        layer_to_metrics_mapping = {}
+
+        compute_metric = self.sensitivity_evaluator.compute_metric
+        if self.using_virtual_graph:
+            origin_max_config = self.config_reconstruction_helper.reconstruct_config_from_virtual_graph(
+                self.max_ru_config)
+            max_config_value = compute_metric(origin_max_config)
+        else:
+            max_config_value = compute_metric(self.max_ru_config)
+
+        for node_idx, layer_possible_bitwidths_indices in tqdm(self.layer_to_bitwidth_mapping.items(),
+                                                               total=len(self.layer_to_bitwidth_mapping)):
+            layer_to_metrics_mapping[node_idx] = {}
+
+            for bitwidth_idx in layer_possible_bitwidths_indices:
+                if self.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 = self.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 self.using_virtual_graph:
+                    # Reconstructing original graph's configuration from virtual graph's configuration
+                    origin_mp_model_configuration = \
+                        self.config_reconstruction_helper.reconstruct_config_from_virtual_graph(
+                            mp_model_configuration,
+                            changed_virtual_nodes_idx=[node_idx],
+                            original_base_config=origin_max_config)
+                    origin_changed_nodes_indices = [i for i, c in enumerate(origin_max_config) if
+                                                    c != origin_mp_model_configuration[i]]
+                    metric_value = compute_metric(
+                        origin_mp_model_configuration,
+                        origin_changed_nodes_indices,
+                        origin_max_config)
+                else:
+                    metric_value = compute_metric(
+                        mp_model_configuration,
+                        [node_idx],
+                        self.max_ru_config)
+
+                layer_to_metrics_mapping[node_idx][bitwidth_idx] = max(metric_value, max_config_value + eps)
 
-    def compute_resource_utilization_matrix(self, target: RUTarget) -> np.ndarray:
+        # Finalize distance metric mapping
+        self.finalize_distance_metric(layer_to_metrics_mapping)
+
+        return layer_to_metrics_mapping
+
+    def _get_mp_graph(self, graph: Graph, target_resource_utilization: ResourceUtilization) -> Tuple[Graph, bool]:
         """
-        Computes and builds a resource utilization matrix, to be used for the mixed-precision search problem formalization.
-        Utilization is computed relative to the minimal configuration, i.e. utilization for it will be 0.
+        Get graph for mixed precision search. Virtual graph is built if bops is restricted and both activation and
+        weights are configurable.
 
         Args:
-            target: The resource target for which the resource utilization is calculated (a RUTarget value).
+            graph: input graph.
+            target_resource_utilization: target resource utilization.
+
+        Returns:
+            Graph for mixed precision search (virtual or original), and a boolean flag whether a virtual graph has been
+            constructed.
+        """
+        if (target_resource_utilization.bops_restricted() and
+                graph.has_any_configurable_activation() and
+                graph.has_any_configurable_weights()):
+            mp_graph = substitute(copy.deepcopy(graph),
+                                  self.fw_impl.get_substitutions_virtual_weights_activation_coupling())
+            return mp_graph, True
+
+        return graph, False
+
+    def get_search_space(self) -> Dict[int, List[int]]:
+        """
+        The search space is a mapping from a node's index to a list of integers (possible bitwidths candidates indeces
+        for the node).
 
         Returns:
-            A resource utilization matrix of shape (num configurations, num memory elements). Num memory elements
-            depends on the target, e.g. num nodes or num cuts, for which utilization is computed.
+            The entire search space of the graph.
         """
-        assert isinstance(target, RUTarget), f"{target} is not a valid resource target"
 
-        configurable_sorted_nodes = self.graph.get_configurable_sorted_nodes(self.fw_info)
+        indices_mapping = {}
+        for idx, n in enumerate(self.mp_topo_configurable_nodes):
+            # For each node, get all possible bitwidth indices for it
+            # (which is a list from 0 to the length of the candidates mp_config list of the node).
+            indices_mapping[idx] = list(range(len(n.candidates_quantization_cfg)))  # all search_methods space
+        return indices_mapping
+
+    def _compute_relative_ru_matrices(self) -> Dict[RUTarget, np.ndarray]:
+        """
+        Computes and builds a resource utilization matrix for all restricted targets, to be used for the
+        mixed-precision search problem formalization.
+        Utilization is computed relative to the minimal configuration, i.e. utilization for it will be 0.
 
-        ru_matrix = []
-        for c, c_n in enumerate(configurable_sorted_nodes):
+        Returns:
+            A dictionary containing resource utilization matrix of shape (num configurations, num memory elements)
+            per ru target. Num memory elements depends on the target, e.g. num cuts or 1 for cumulative metrics.
+        """
+        rus_per_candidate = defaultdict(list)
+        for c, c_n in enumerate(self.mp_topo_configurable_nodes):
             for candidate_idx in range(len(c_n.candidates_quantization_cfg)):
                 if candidate_idx == self.min_ru_config[c]:
-                    candidate_rus = self.min_ru[target]
+                    candidate_rus = self.min_ru
                 else:
-                    candidate_rus = self.compute_node_ru_for_candidate(c, candidate_idx, target)
+                    candidate_rus = self.compute_ru_for_candidate(c, candidate_idx)
 
-                ru_matrix.append(np.asarray(candidate_rus))
+                for target, ru in candidate_rus.items():
+                    rus_per_candidate[target].append(ru)
 
-        np_ru_matrix = np.array(ru_matrix) - self.min_ru[target]    # num configurations X num elements
-        return np_ru_matrix
+        # Each target contains a matrix of num configurations X num elements
+        relative_rus = {target: np.array(ru) - self.min_ru[target] for target, ru in rus_per_candidate.items()}
+        return relative_rus
 
-    def compute_node_ru_for_candidate(self, conf_node_idx: int, candidate_idx: int, target: RUTarget) -> np.ndarray:
+    def compute_ru_for_candidate(self, conf_node_idx: int, candidate_idx: int) -> Dict[RUTarget, np.ndarray]:
         """
         Computes a resource utilization vector after replacing the given node's configuration candidate in the minimal
         target configuration with the given candidate index.
@@ -151,13 +270,13 @@ class MixedPrecisionSearchManager:
         Args:
             conf_node_idx: The index of a node in a sorted configurable nodes list.
             candidate_idx: Quantization config candidate to be used for the node's resource utilization computation.
-            target: The target for which the resource utilization is calculated (a RUTarget value).
 
-        Returns: Node's resource utilization vector.
+        Returns:
+            Node's resource utilization vector.
 
         """
         cfg = self.replace_config_in_index(self.min_ru_config, conf_node_idx, candidate_idx)
-        return self.ru_helper.compute_utilization({target}, cfg)[target]
+        return self.ru_helper.compute_utilization(self.ru_targets, cfg)
 
     @staticmethod
     def replace_config_in_index(mp_cfg: List[int], idx: int, value: int) -> List[int]:
@@ -191,7 +310,7 @@ class MixedPrecisionSearchManager:
         act_qcs, w_qcs = self.ru_helper.get_quantization_candidates(config)
         ru = self.ru_helper.ru_calculator.compute_resource_utilization(
             target_criterion=TargetInclusionCriterion.AnyQuantized, bitwidth_mode=BitwidthMode.QCustom, act_qcs=act_qcs,
-            w_qcs=w_qcs, ru_targets=self.ru_targets_to_compute, allow_unused_qcs=True)
+            w_qcs=w_qcs, ru_targets=self.ru_targets, allow_unused_qcs=True)
         return ru
 
     def finalize_distance_metric(self, layer_to_metrics_mapping: Dict[int, Dict[int, float]]):

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py

@@ -51,25 +51,34 @@ class ResourceUtilization:
     bops: float = np.inf
 
     def weight_restricted(self):
-        return self.weights_memory < np.inf
+        return self._is_restricted(self.weights_memory)
 
     def activation_restricted(self):
-        return self.activation_memory < np.inf
+        return self._is_restricted(self.activation_memory)
 
     def total_mem_restricted(self):
-        return self.total_memory < np.inf
+        return self._is_restricted(self.total_memory)
 
     def bops_restricted(self):
-        return self.bops < np.inf
+        return self._is_restricted(self.bops)
 
-    def get_resource_utilization_dict(self) -> Dict[RUTarget, float]:
+    def get_resource_utilization_dict(self, restricted_only: bool = False) -> Dict[RUTarget, float]:
         """
-        Returns: a dictionary with the ResourceUtilization object's values for each resource utilization target.
+        Get resource utilization as a dictionary.
+
+        Args:
+            restricted_only: whether to include only targets with restricted utilization.
+
+        Returns:
+            A dictionary containing the resource utilization with targets as keys.
         """
-        return {RUTarget.WEIGHTS: self.weights_memory,
-                RUTarget.ACTIVATION: self.activation_memory,
-                RUTarget.TOTAL: self.total_memory,
-                RUTarget.BOPS: self.bops}
+        ru_dict = {RUTarget.WEIGHTS: self.weights_memory,
+                   RUTarget.ACTIVATION: self.activation_memory,
+                   RUTarget.TOTAL: self.total_memory,
+                   RUTarget.BOPS: self.bops}
+        if restricted_only:
+            ru_dict = {k: v for k, v in ru_dict.items() if self._is_restricted(v)}
+        return ru_dict
 
     def is_satisfied_by(self, ru: 'ResourceUtilization') -> bool:
         """
@@ -114,3 +123,6 @@ class ResourceUtilization:
         if RUTarget.BOPS in targets:
             summary.append(f"BOPS: {self.bops}")
         return ', '.join(summary)
+
+    def _is_restricted(self, v):
+        return v < np.inf

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -431,8 +431,7 @@ class ResourceUtilizationCalculator:
         Returns:
             Node's activation utilization.
         """
-        if qc and bitwidth_mode != BitwidthMode.QCustom:
-            raise ValueError(self.unexpected_qc_error)
+        self._validate_custom_qcs(qc, bitwidth_mode)
 
         if target_criterion:
             # only check whether the node meets the criterion
@@ -470,9 +469,6 @@ class ResourceUtilizationCalculator:
             - Total BOPS count of the network.
             - Detailed BOPS count per node.
         """
-        self._validate_custom_qcs(act_qcs, bitwidth_mode)
-        self._validate_custom_qcs(w_qcs, bitwidth_mode)
-
         nodes_bops = {}
         for n in self.graph.get_topo_sorted_nodes():
             w_qc = w_qcs.get(n.name) if w_qcs else None

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py

@@ -16,10 +16,7 @@ import copy
 from typing import Callable, Any
 
 from model_compression_toolkit.core import FrameworkInfo, ResourceUtilization, CoreConfig, QuantizationErrorMethod
-from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
-    RUTarget
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_calculator import \
     ResourceUtilizationCalculator, BitwidthMode, TargetInclusionCriterion
 from model_compression_toolkit.core.graph_prep_runner import graph_preparation_runner
@@ -31,13 +28,10 @@ def compute_resource_utilization_data(in_model: Any,
                                       core_config: CoreConfig,
                                       fqc: FrameworkQuantizationCapabilities,
                                       fw_info: FrameworkInfo,
-                                      fw_impl: FrameworkImplementation,
-                                      transformed_graph: Graph = None,
-                                      mixed_precision_enable: bool = True) -> ResourceUtilization:
+                                      fw_impl: FrameworkImplementation) -> ResourceUtilization:
     """
-    Compute Resource Utilization information that can be relevant for defining target ResourceUtilization for mixed precision search.
-    Calculates maximal activation tensor size, the sum of the model's weight parameters and the total memory combining both weights
-    and maximal activation tensor size.
+    Compute Resource Utilization of a model with the default single precision quantization.
+    This can serve as a basis for defining target Resource Utilization for mixed precision search.
 
     Args:
         in_model:  Model to build graph from (the model that intended to be quantized).
@@ -47,100 +41,26 @@ def compute_resource_utilization_data(in_model: Any,
                                               the attached framework operator's information.
         fw_info: Information needed for quantization about the specific framework.
         fw_impl: FrameworkImplementation object with a specific framework methods implementation.
-        transformed_graph: An internal graph representation of the input model. Defaults to None.
-                            If no graph is provided, a graph will be constructed using the specified model.
-        mixed_precision_enable: Indicates if mixed precision is enabled, defaults to True.
-                                If disabled, computes resource utilization using base quantization
-                                configurations across all layers.
 
     Returns:
         ResourceUtilization: An object encapsulating the calculated resource utilization computations.
 
     """
-    core_config = _create_core_config_for_ru(core_config)
-    # We assume that the resource_utilization_data API is used to compute the model resource utilization for
-    # mixed precision scenario, so we run graph preparation under the assumption of enabled mixed precision.
-    if transformed_graph is None:
-        transformed_graph = graph_preparation_runner(in_model,
-                                                     representative_data_gen,
-                                                     core_config.quantization_config,
-                                                     fw_info,
-                                                     fw_impl,
-                                                     fqc,
-                                                     bit_width_config=core_config.bit_width_config,
-                                                     mixed_precision_enable=mixed_precision_enable,
-                                                     running_gptq=False)
-
-    ru_calculator = ResourceUtilizationCalculator(transformed_graph, fw_impl, fw_info)
-    ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.Q8Bit,
-                                                    ru_targets=set(RUTarget) - {RUTarget.BOPS})
-    ru.bops, _ = ru_calculator.compute_bops(TargetInclusionCriterion.AnyQuantized, BitwidthMode.Float)
-    return ru
-
-
-def requires_mixed_precision(in_model: Any,
-                             target_resource_utilization: ResourceUtilization,
-                             representative_data_gen: Callable,
-                             core_config: CoreConfig,
-                             fqc: FrameworkQuantizationCapabilities,
-                             fw_info: FrameworkInfo,
-                             fw_impl: FrameworkImplementation) -> bool:
-    """
-    The function checks whether the model requires mixed precision to meet the requested target resource utilization.
-    This is determined by whether the target memory usage of the weights is less than the available memory,
-    the target maximum size of an activation tensor is less than the available memory,
-    and the target number of BOPs is less than the available BOPs.
-    If any of these conditions are met, the function returns True. Otherwise, it returns False.
-
-    Args:
-        in_model: The model to be evaluated.
-        target_resource_utilization: The resource utilization of the target device.
-        representative_data_gen: A function that generates representative data for the model.
-        core_config: CoreConfig containing parameters of how the model should be quantized.
-        fqc: FrameworkQuantizationCapabilities object that models the inference target platform and
-                                              the attached framework operator's information.
-        fw_info: Information needed for quantization about the specific framework.
-        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
-
-    Returns: A boolean indicating if mixed precision is needed.
-    """
-    # Any target resource utilization other than weights will always require MP calculation.
-    if target_resource_utilization.activation_restricted() or \
-            target_resource_utilization.total_mem_restricted() or \
-            target_resource_utilization.bops_restricted():
-        return True
-
-    core_config = _create_core_config_for_ru(core_config)
+    core_config = copy.deepcopy(core_config)
+    # For resource utilization graph_preparation_runner runs with gptq=False (the default value). HMSE is not supported
+    # without GPTQ and will raise an error later so we replace it with MSE.
+    if core_config.quantization_config.weights_error_method == QuantizationErrorMethod.HMSE:
+        core_config.quantization_config.weights_error_method = QuantizationErrorMethod.MSE
 
     transformed_graph = graph_preparation_runner(in_model,
-                                                 representative_data_gen,
-                                                 core_config.quantization_config,
-                                                 fw_info,
-                                                 fw_impl,
-                                                 fqc,
+                                                 representative_data_gen=representative_data_gen,
+                                                 quantization_config=core_config.quantization_config,
+                                                 fw_info=fw_info,
+                                                 fw_impl=fw_impl,
+                                                 fqc=fqc,
                                                  bit_width_config=core_config.bit_width_config,
                                                  mixed_precision_enable=False,
                                                  running_gptq=False)
 
     ru_calculator = ResourceUtilizationCalculator(transformed_graph, fw_impl, fw_info)
-    max_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.QMaxBit,
-                                                        ru_targets=target_resource_utilization.get_restricted_targets())
-    return not target_resource_utilization.is_satisfied_by(max_ru)
-
-
-def _create_core_config_for_ru(core_config: CoreConfig) -> CoreConfig:
-    """
-    Create a core config to use for resource utilization computation.
-
-    Args:
-        core_config: input core config
-
-    Returns:
-        Core config for resource utilization.
-    """
-    core_config = copy.deepcopy(core_config)
-    # For resource utilization graph_preparation_runner runs with gptq=False (the default value). HMSE is not supported
-    # without GPTQ and will raise an error later so we replace it with MSE.
-    if core_config.quantization_config.weights_error_method == QuantizationErrorMethod.HMSE:
-        core_config.quantization_config.weights_error_method = QuantizationErrorMethod.MSE
-    return core_config
+    return ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.QDefaultSP)