mct-nightly 2.2.0.20250113.527__py3-none-any.whl → 2.2.0.20250114.84821__py3-none-any.whl

model_compression_toolkit/core/common/graph/base_graph.py

@@ -32,8 +32,9 @@ from model_compression_toolkit.core.common.collectors.statistics_collector impor
 from model_compression_toolkit.core.common.pruning.pruning_section import PruningSection
 from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import \
-    TargetPlatformCapabilities, LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 OutTensor = namedtuple('OutTensor', 'node node_out_index')
 
@@ -86,29 +87,29 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         self.fw_info = fw_info
 
-    def set_tpc(self,
-                tpc: TargetPlatformCapabilities):
+    def set_fqc(self,
+                fqc: FrameworkQuantizationCapabilities):
         """
-        Set the graph's TPC.
+        Set the graph's FQC.
         Args:
-            tpc: TargetPlatformCapabilities object.
+            fqc: FrameworkQuantizationCapabilities object.
         """
-        # validate graph nodes are either from the framework or a custom layer defined in the TPC
-        # Validate graph nodes are either built-in layers from the framework or custom layers defined in the TPC
-        tpc_layers = tpc.op_sets_to_layers.get_layers()
-        tpc_filtered_layers = [layer for layer in tpc_layers if isinstance(layer, LayerFilterParams)]
+        # validate graph nodes are either from the framework or a custom layer defined in the FQC
+        # Validate graph nodes are either built-in layers from the framework or custom layers defined in the FQC
+        fqc_layers = fqc.op_sets_to_layers.get_layers()
+        fqc_filtered_layers = [layer for layer in fqc_layers if isinstance(layer, LayerFilterParams)]
         for n in self.nodes:
-            is_node_in_tpc = any([n.is_match_type(_type) for _type in tpc_layers]) or \
-                             any([n.is_match_filter_params(filtered_layer) for filtered_layer in tpc_filtered_layers])
+            is_node_in_fqc = any([n.is_match_type(_type) for _type in fqc_layers]) or \
+                             any([n.is_match_filter_params(filtered_layer) for filtered_layer in fqc_filtered_layers])
             if n.is_custom:
-                if not is_node_in_tpc:
+                if not is_node_in_fqc:
                     Logger.critical(f'MCT does not support optimizing Keras custom layers. Found a layer of type {n.type}. '
-                                    ' Please add the custom layer to Target Platform Capabilities (TPC), or file a feature '
+                                    ' Please add the custom layer to Framework Quantization Capabilities (FQC), or file a feature '
                                     'request or an issue if you believe this should be supported.')  # pragma: no cover
-                if any([qc.default_weight_attr_config.enable_weights_quantization for qc in n.get_qco(tpc).quantization_configurations]):
+                if any([qc.default_weight_attr_config.enable_weights_quantization for qc in n.get_qco(fqc).quantization_configurations]):
                     Logger.critical(f'Layer identified: {n.type}. MCT does not support weight quantization for Keras custom layers.')  # pragma: no cover
 
-        self.tpc = tpc
+        self.fqc = fqc
 
     def get_topo_sorted_nodes(self):
         """
@@ -544,10 +545,8 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         potential_conf_nodes = [n for n in list(self) if fw_info.is_kernel_op(n.type)]
 
         def is_configurable(n):
-            kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
-            return (n.is_weights_quantization_enabled(kernel_attr) and
-                    not n.is_all_weights_candidates_equal(kernel_attr) and
-                    (not n.reuse or include_reused_nodes))
+            kernel_attrs = fw_info.get_kernel_op_attributes(n.type)
+            return any(n.is_configurable_weight(attr) for attr in kernel_attrs) and (not n.reuse or include_reused_nodes)
 
         return [n for n in potential_conf_nodes if is_configurable(n)]
 
@@ -576,7 +575,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         Returns:
             A list of nodes that their activation can be configured (namely, has one or more activation qc candidate).
         """
-        return [n for n in list(self) if n.is_activation_quantization_enabled() and not n.is_all_activation_candidates_equal()]
+        return [n for n in list(self) if n.has_configurable_activation()]
 
     def get_sorted_activation_configurable_nodes(self) -> List[BaseNode]:
         """

model_compression_toolkit/core/common/graph/base_node.py

@@ -25,7 +25,9 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import QuantizationConfigOptions, \
     OpQuantizationConfig
 from model_compression_toolkit.target_platform_capabilities.schema.schema_functions import max_input_activation_n_bits
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities, LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 class BaseNode:
@@ -150,6 +152,27 @@ class BaseNode:
 
         return False
 
+    def is_configurable_weight(self, attr_name: str) -> bool:
+        """
+        Checks whether the specific weight attribute has a configurable quantization.
+
+        Args:
+            attr_name: weight attribute name.
+
+        Returns:
+            Whether the weight attribute is configurable.
+        """
+        return self.is_weights_quantization_enabled(attr_name) and not self.is_all_weights_candidates_equal(attr_name)
+
+    def has_configurable_activation(self) -> bool:
+        """
+        Checks whether the activation has a configurable quantization.
+
+        Returns:
+            Whether the activation has a configurable quantization.
+        """
+        return self.is_activation_quantization_enabled() and not self.is_all_activation_candidates_equal()
+
     def __repr__(self):
         """
 
@@ -420,11 +443,15 @@ class BaseNode:
 
         Returns: Output size.
         """
-        output_shapes = self.output_shape if isinstance(self.output_shape, List) else [self.output_shape]
+        # 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
+        else:
+            output_shapes = [self.output_shape]
 
         # remove batch size (first element) from output shape
         output_shapes = [s[1:] for s in output_shapes]
-
+        # for scalar shape (None,) prod returns 1
         return sum([np.prod([x for x in output_shape if x is not None]) for output_shape in output_shapes])
 
     def find_min_candidates_indices(self) -> List[int]:
@@ -536,34 +563,34 @@ class BaseNode:
         # the inner method would log an exception.
         return [c.weights_quantization_cfg.get_attr_config(attr) for c in self.candidates_quantization_cfg]
 
-    def get_qco(self, tpc: TargetPlatformCapabilities) -> QuantizationConfigOptions:
+    def get_qco(self, fqc: FrameworkQuantizationCapabilities) -> QuantizationConfigOptions:
         """
         Get the QuantizationConfigOptions of the node according
-        to the mappings from layers/LayerFilterParams to the OperatorsSet in the TargetPlatformModel.
+        to the mappings from layers/LayerFilterParams to the OperatorsSet in the TargetPlatformCapabilities.
 
         Args:
-            tpc: TPC to extract the QuantizationConfigOptions for the node.
+            fqc: FQC to extract the QuantizationConfigOptions for the node.
 
         Returns:
             QuantizationConfigOptions of the node.
         """
 
-        if tpc is None:
-            Logger.critical(f'Can not retrieve QC options for None TPC')  # pragma: no cover
+        if fqc is None:
+            Logger.critical(f'Can not retrieve QC options for None FQC')  # pragma: no cover
 
-        for fl, qco in tpc.filterlayer2qco.items():
+        for fl, qco in fqc.filterlayer2qco.items():
             if self.is_match_filter_params(fl):
                 return qco
         # Extract qco with is_match_type to overcome mismatch of function types in TF 2.15
-        matching_qcos = [_qco for _type, _qco in tpc.layer2qco.items() if self.is_match_type(_type)]
+        matching_qcos = [_qco for _type, _qco in fqc.layer2qco.items() if self.is_match_type(_type)]
         if matching_qcos:
             if all([_qco == matching_qcos[0] for _qco in matching_qcos]):
                 return matching_qcos[0]
             else:
                 Logger.critical(f"Found duplicate qco types for node '{self.name}' of type '{self.type}'!")  # pragma: no cover
-        return tpc.tp_model.default_qco
+        return fqc.tpc.default_qco
 
-    def filter_node_qco_by_graph(self, tpc: TargetPlatformCapabilities,
+    def filter_node_qco_by_graph(self, fqc: FrameworkQuantizationCapabilities,
                                  next_nodes: List, node_qc_options: QuantizationConfigOptions
                                  ) -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig]]:
         """
@@ -573,7 +600,7 @@ class BaseNode:
         filters out quantization config that don't comply to these attributes.
 
         Args:
-            tpc: TPC to extract the QuantizationConfigOptions for the next nodes.
+            fqc: FQC to extract the QuantizationConfigOptions for the next nodes.
             next_nodes: Output nodes of current node.
             node_qc_options: Node's QuantizationConfigOptions.
 
@@ -584,7 +611,7 @@ class BaseNode:
         _base_config = node_qc_options.base_config
         _node_qc_options = node_qc_options.quantization_configurations
         if len(next_nodes):
-            next_nodes_qc_options = [_node.get_qco(tpc) for _node in next_nodes]
+            next_nodes_qc_options = [_node.get_qco(fqc) for _node in next_nodes]
             next_nodes_supported_input_bitwidth = min([max_input_activation_n_bits(op_cfg)
                                                        for qc_opts in next_nodes_qc_options
                                                        for op_cfg in qc_opts.quantization_configurations])
@@ -593,7 +620,7 @@ class BaseNode:
             _node_qc_options = [_option for _option in _node_qc_options
                                 if _option.activation_n_bits <= next_nodes_supported_input_bitwidth]
             if len(_node_qc_options) == 0:
-                Logger.critical(f"Graph doesn't match TPC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
+                Logger.critical(f"Graph doesn't match FQC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
 
             # Verify base config match
             if any([node_qc_options.base_config.activation_n_bits > max_input_activation_n_bits(qc_opt.base_config)
@@ -603,9 +630,9 @@ class BaseNode:
                 if len(_node_qc_options) > 0:
                     output_act_bitwidth = {qco.activation_n_bits: i for i, qco in enumerate(_node_qc_options)}
                     _base_config = _node_qc_options[output_act_bitwidth[max(output_act_bitwidth)]]
-                    Logger.warning(f"Node {self} base quantization config changed to match Graph and TPC configuration.\nCause: {self} -> {next_nodes}.")
+                    Logger.warning(f"Node {self} base quantization config changed to match Graph and FQC configuration.\nCause: {self} -> {next_nodes}.")
                 else:
-                    Logger.critical(f"Graph doesn't match TPC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
+                    Logger.critical(f"Graph doesn't match FQC bit configurations: {self} -> {next_nodes}.")  # pragma: no cover
 
         return _base_config, _node_qc_options
 

model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py

@@ -17,18 +17,19 @@ import numpy as np
 from model_compression_toolkit.core import ResourceUtilization, FrameworkInfo
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 def filter_candidates_for_mixed_precision(graph: Graph,
                                           target_resource_utilization: ResourceUtilization,
                                           fw_info: FrameworkInfo,
-                                          tpc: TargetPlatformCapabilities):
+                                          fqc: FrameworkQuantizationCapabilities):
     """
     Filters out candidates in case of mixed precision search for only weights or activation compression.
     For instance, if running only weights compression - filters out candidates of activation configurable nodes
     such that only a single candidate would remain, with the bitwidth equal to the one defined in the matching layer's
-    base config in the TPC.
+    base config in the FQC.
 
     Note: This function modifies the graph inplace!
 
@@ -36,7 +37,7 @@ def filter_candidates_for_mixed_precision(graph: Graph,
         graph: A graph representation of the model to be quantized.
         target_resource_utilization: The resource utilization of the target device.
         fw_info: fw_info: Information needed for quantization about the specific framework.
-        tpc: TargetPlatformCapabilities object that describes the desired inference target platform.
+        fqc: FrameworkQuantizationCapabilities object that describes the desired inference target platform.
 
     """
 
@@ -50,7 +51,7 @@ def filter_candidates_for_mixed_precision(graph: Graph,
         weights_conf = graph.get_weights_configurable_nodes(fw_info)
         activation_configurable_nodes = [n for n in graph.get_activation_configurable_nodes() if n not in weights_conf]
         for n in activation_configurable_nodes:
-            base_cfg_nbits = n.get_qco(tpc).base_config.activation_n_bits
+            base_cfg_nbits = n.get_qco(fqc).base_config.activation_n_bits
             filtered_conf = [c for c in n.candidates_quantization_cfg if
                              c.activation_quantization_cfg.enable_activation_quantization and
                              c.activation_quantization_cfg.activation_n_bits == base_cfg_nbits]
@@ -67,7 +68,7 @@ def filter_candidates_for_mixed_precision(graph: Graph,
         weight_configurable_nodes = [n for n in graph.get_weights_configurable_nodes(fw_info) if n not in activation_conf]
         for n in weight_configurable_nodes:
             kernel_attr = graph.fw_info.get_kernel_op_attributes(n.type)[0]
-            base_cfg_nbits = n.get_qco(tpc).base_config.attr_weights_configs_mapping[kernel_attr].weights_n_bits
+            base_cfg_nbits = n.get_qco(fqc).base_config.attr_weights_configs_mapping[kernel_attr].weights_n_bits
             filtered_conf = [c for c in n.candidates_quantization_cfg if
                              c.weights_quantization_cfg.get_attr_config(kernel_attr).enable_weights_quantization and
                              c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits == base_cfg_nbits]

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py

@@ -22,7 +22,6 @@ from model_compression_toolkit.core import MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_functions_mapping import ru_functions_mapping
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import MixedPrecisionSearchManager
 from model_compression_toolkit.core.common.mixed_precision.search_methods.linear_programming import \
@@ -105,16 +104,11 @@ def search_bit_width(graph_to_search_cfg: Graph,
         disable_activation_for_metric=disable_activation_for_metric,
         hessian_info_service=hessian_info_service)
 
-    # Each pair of (resource utilization method, resource utilization aggregation) should match to a specific
-    # provided target resource utilization
-    ru_functions = ru_functions_mapping
-
     # Instantiate a manager object
     search_manager = MixedPrecisionSearchManager(graph,
                                                  fw_info,
                                                  fw_impl,
                                                  se,
-                                                 ru_functions,
                                                  target_resource_utilization,
                                                  original_graph=graph_to_search_cfg)
 

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py

@@ -13,23 +13,24 @@
 # limitations under the License.
 # ==============================================================================
 
-from typing import Callable, Tuple
-from typing import Dict, List
+from typing import Callable, Dict, List
+
 import numpy as np
 
 from model_compression_toolkit.core.common import BaseNode
-from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+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.graph.virtual_activation_weights_node import VirtualActivationWeightsNode, \
     VirtualSplitWeightsNode, VirtualSplitActivationNode
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import RUTarget, ResourceUtilization
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_functions_mapping import RuFunctions
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_aggregation_methods import MpRuAggregation
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_methods import MpRuMetric, calc_graph_cuts
-from model_compression_toolkit.core.common.graph.memory_graph.compute_graph_max_cut import Cut
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
+    RUTarget, ResourceUtilization
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_calculator import \
+    ResourceUtilizationCalculator, TargetInclusionCriterion, BitwidthMode
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_methods import \
+    MixedPrecisionRUHelper
 from model_compression_toolkit.core.common.mixed_precision.sensitivity_evaluation import SensitivityEvaluation
+from model_compression_toolkit.logger import Logger
 
 
 class MixedPrecisionSearchManager:
@@ -42,7 +43,6 @@ class MixedPrecisionSearchManager:
                  fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation,
                  sensitivity_evaluator: SensitivityEvaluation,
-                 ru_functions: Dict[RUTarget, RuFunctions],
                  target_resource_utilization: ResourceUtilization,
                  original_graph: Graph = None):
         """
@@ -53,8 +53,6 @@ class MixedPrecisionSearchManager:
             fw_impl: FrameworkImplementation object with specific framework methods implementation.
             sensitivity_evaluator: A SensitivityEvaluation which provides a function that evaluates the sensitivity of
                 a bit-width configuration for the MP model.
-            ru_functions: A dictionary with pairs of (MpRuMethod, MpRuAggregationMethod) mapping a RUTarget to
-                a couple of resource utilization metric function and resource utilization aggregation function.
             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).
@@ -69,29 +67,17 @@ class MixedPrecisionSearchManager:
         self.compute_metric_fn = self.get_sensitivity_metric()
         self._cuts = None
 
-        ru_types = [ru_target for ru_target, ru_value in
-                    target_resource_utilization.get_resource_utilization_dict().items() if ru_value < np.inf]
-        self.compute_ru_functions = {ru_target: ru_fn for ru_target, ru_fn in ru_functions.items() if ru_target in ru_types}
+        self.ru_metrics = target_resource_utilization.get_restricted_metrics()
+        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.compute_min_ru()
+        self.min_ru = self.ru_helper.compute_utilization(self.ru_metrics, self.min_ru_config)
         self.non_conf_ru_dict = self._non_configurable_nodes_ru()
 
         self.config_reconstruction_helper = ConfigReconstructionHelper(virtual_graph=self.graph,
                                                                        original_graph=self.original_graph)
 
-    @property
-    def cuts(self) -> List[Cut]:
-        """
-        Calculates graph cuts. Written as property, so it will only be calculated once and
-        only if cuts are needed.
-
-        """
-        if self._cuts is None:
-            self._cuts = calc_graph_cuts(self.original_graph)
-        return self._cuts
-
     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
@@ -122,40 +108,6 @@ class MixedPrecisionSearchManager:
 
         return self.sensitivity_evaluator.compute_metric
 
-    def _calc_ru_fn(self, ru_target, ru_fn, mp_cfg) -> np.ndarray:
-        """
-        Computes a resource utilization for a certain mixed precision configuration.
-        The method computes a resource utilization vector for specific target resource utilization.
-
-        Returns: resource utilization value.
-
-        """
-        # ru_fn is a pair of resource utilization computation method and
-        # resource utilization aggregation method (in this method we only need the first one)
-        if ru_target is RUTarget.ACTIVATION:
-            return ru_fn.metric_fn(mp_cfg, self.graph, self.fw_info, self.fw_impl, self.cuts)
-        else:
-            return ru_fn.metric_fn(mp_cfg, self.graph, self.fw_info, self.fw_impl)
-
-    def compute_min_ru(self) -> Dict[RUTarget, np.ndarray]:
-        """
-        Computes a resource utilization vector with the values matching to the minimal mp configuration
-        (i.e., each node is configured with the quantization candidate that would give the minimal size of the
-        node's resource utilization).
-        The method computes the minimal resource utilization vector for each target resource utilization.
-
-        Returns: A dictionary mapping each target resource utilization to its respective minimal 
-        resource utilization values.
-
-        """
-        min_ru = {}
-        for ru_target, ru_fn in self.compute_ru_functions.items():
-            # ru_fns is a pair of resource utilization computation method and
-            # resource utilization aggregation method (in this method we only need the first one)
-            min_ru[ru_target] = self._calc_ru_fn(ru_target, ru_fn, self.min_ru_config)
-
-        return min_ru
-
     def compute_resource_utilization_matrix(self, target: RUTarget) -> np.ndarray:
         """
         Computes and builds a resource utilization matrix, to be used for the mixed-precision search problem formalization.
@@ -184,7 +136,8 @@ class MixedPrecisionSearchManager:
                     # always be 0 for all entries in the results vector.
                     candidate_rus = np.zeros(shape=self.min_ru[target].shape)
                 else:
-                    candidate_rus = self.compute_candidate_relative_ru(c, candidate_idx, target)
+                    candidate_rus = self.compute_node_ru_for_candidate(c, candidate_idx, target) - self.min_ru[target]
+
                 ru_matrix.append(np.asarray(candidate_rus))
 
         # We need to transpose the calculated ru matrix to allow later multiplication with
@@ -195,40 +148,6 @@ class MixedPrecisionSearchManager:
         np_ru_matrix = np.array(ru_matrix)
         return np.moveaxis(np_ru_matrix, source=0, destination=len(np_ru_matrix.shape) - 1)
 
-    def compute_candidate_relative_ru(self,
-                                      conf_node_idx: int,
-                                      candidate_idx: int,
-                                      target: RUTarget) -> np.ndarray:
-        """
-        Computes a resource utilization vector for a given candidates of a given configurable node, 
-        i.e., the matching resource utilization vector which is obtained by computing the given target's 
-        resource utilization function on a minimal configuration in which the given
-        layer's candidates is changed to the new given one.
-        The result is normalized by subtracting the target's minimal resource utilization vector.
-
-        Args:
-            conf_node_idx: The index of a node in a sorted configurable nodes list.
-            candidate_idx: The index of a node's quantization configuration candidate.
-            target: The target for which the resource utilization is calculated (a RUTarget value).
-
-        Returns: Normalized node's resource utilization vector
-
-        """
-        return self.compute_node_ru_for_candidate(conf_node_idx, candidate_idx, target) - \
-               self.get_min_target_resource_utilization(target)
-
-    def get_min_target_resource_utilization(self, target: RUTarget) -> np.ndarray:
-        """
-        Returns the minimal resource utilization vector (pre-calculated on initialization) of a specific target.
-
-        Args:
-            target: The target for which the resource utilization is calculated (a RUTarget value).
-
-        Returns: Minimal resource utilization vector.
-
-        """
-        return self.min_ru[target]
-
     def compute_node_ru_for_candidate(self, conf_node_idx: int, candidate_idx: int, target: RUTarget) -> np.ndarray:
         """
         Computes a resource utilization vector after replacing the given node's configuration candidate in the minimal
@@ -243,7 +162,8 @@ class MixedPrecisionSearchManager:
 
         """
         cfg = self.replace_config_in_index(self.min_ru_config, conf_node_idx, candidate_idx)
-        return self._calc_ru_fn(target, self.compute_ru_functions[target], cfg)
+        # TODO compute for all targets at once. Currently the way up to add_set_of_ru_constraints is per target.
+        return self.ru_helper.compute_utilization({target}, cfg)[target]
 
     @staticmethod
     def replace_config_in_index(mp_cfg: List[int], idx: int, value: int) -> List[int]:
@@ -270,21 +190,10 @@ class MixedPrecisionSearchManager:
 
         Returns: A mapping between a RUTarget and its non-configurable nodes' resource utilization vector.
         """
-
-        non_conf_ru_dict = {}
-        for target, ru_fns in self.compute_ru_functions.items():
-            # Call for the ru method of the given target - empty quantization configuration list is passed since we
-            # compute for non-configurable nodes
-            if target == RUTarget.BOPS:
-                ru_vector = None
-            elif target == RUTarget.ACTIVATION:
-                ru_vector = ru_fns.metric_fn([], self.graph, self.fw_info, self.fw_impl, self.cuts)
-            else:
-                ru_vector = ru_fns.metric_fn([], self.graph, self.fw_info, self.fw_impl)
-
-            non_conf_ru_dict[target] = ru_vector
-
-        return non_conf_ru_dict
+        ru_metrics = self.ru_metrics - {RUTarget.BOPS}
+        ru = self.ru_helper.compute_utilization(ru_targets=ru_metrics, mp_cfg=None)
+        ru[RUTarget.BOPS] = None
+        return ru
 
     def compute_resource_utilization_for_config(self, config: List[int]) -> ResourceUtilization:
         """
@@ -297,29 +206,11 @@ class MixedPrecisionSearchManager:
         with the given config.
 
         """
-
-        ru_dict = {}
-        for ru_target, ru_fns in self.compute_ru_functions.items():
-            # Passing False to ru methods and aggregations to indicates that the computations
-            # are not for constraints setting
-            if ru_target == RUTarget.BOPS:
-                configurable_nodes_ru_vector = ru_fns.metric_fn(config, self.original_graph, self.fw_info, self.fw_impl, False)
-            elif ru_target == RUTarget.ACTIVATION:
-                configurable_nodes_ru_vector = ru_fns.metric_fn(config, self.graph, self.fw_info, self.fw_impl, self.cuts)
-            else:
-                configurable_nodes_ru_vector = ru_fns.metric_fn(config, self.original_graph, self.fw_info, self.fw_impl)
-            non_configurable_nodes_ru_vector = self.non_conf_ru_dict.get(ru_target)
-            if non_configurable_nodes_ru_vector is None or len(non_configurable_nodes_ru_vector) == 0:
-                ru_ru = self.compute_ru_functions[ru_target].aggregate_fn(configurable_nodes_ru_vector, False)
-            else:
-                ru_ru = self.compute_ru_functions[ru_target].aggregate_fn(
-                    np.concatenate([configurable_nodes_ru_vector, non_configurable_nodes_ru_vector]), False)
-
-            ru_dict[ru_target] = ru_ru[0]
-
-        config_ru = ResourceUtilization()
-        config_ru.set_resource_utilization_by_target(ru_dict)
-        return config_ru
+        act_qcs, w_qcs = self.ru_helper.get_configurable_qcs(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)
+        return ru
 
     def finalize_distance_metric(self, layer_to_metrics_mapping: Dict[int, Dict[int, float]]):
         """