mct-nightly 2.2.0.20250113.134913__py3-none-any.whl → 2.2.0.20250114.134534__py3-none-any.whl

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

@@ -13,27 +13,23 @@
 # limitations under the License.
 # ==============================================================================
 import copy
-from collections import defaultdict
+from typing import Callable, Any
 
-import numpy as np
-from typing import Callable, Any, Dict, Tuple
-
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.constants import FLOAT_BITWIDTH, BITS_TO_BYTES
 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.graph.edge import EDGE_SINK_INDEX
+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
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import QuantizationConfigOptions
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_methods import calc_graph_cuts
+from model_compression_toolkit.target_platform_capabilities import FrameworkQuantizationCapabilities
 
 
 def compute_resource_utilization_data(in_model: Any,
                                       representative_data_gen: Callable,
                                       core_config: CoreConfig,
-                                      tpc: TargetPlatformCapabilities,
+                                      fqc: FrameworkQuantizationCapabilities,
                                       fw_info: FrameworkInfo,
                                       fw_impl: FrameworkImplementation,
                                       transformed_graph: Graph = None,
@@ -47,7 +43,7 @@ def compute_resource_utilization_data(in_model: Any,
         in_model:  Model to build graph from (the model that intended to be quantized).
         representative_data_gen: Dataset used for calibration.
         core_config: CoreConfig containing parameters of how the model should be quantized.
-        tpc: TargetPlatformCapabilities object that models the inference target platform and
+        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.
@@ -70,183 +66,23 @@ def compute_resource_utilization_data(in_model: Any,
                                                      core_config.quantization_config,
                                                      fw_info,
                                                      fw_impl,
-                                                     tpc,
+                                                     fqc,
                                                      bit_width_config=core_config.bit_width_config,
-                                                     mixed_precision_enable=mixed_precision_enable)
-
-    # Compute parameters sum
-    weights_memory_bytes, weights_params = compute_nodes_weights_params(graph=transformed_graph, fw_info=fw_info)
-    total_weights_params = 0 if len(weights_params) == 0 else sum(weights_params)
-
-    # Compute max activation tensor
-    activation_output_sizes_bytes, activation_output_sizes = compute_activation_output_maxcut_sizes(graph=transformed_graph)
-    max_activation_tensor_size = 0 if len(activation_output_sizes) == 0 else max(activation_output_sizes)
-
-    # Compute total memory utilization - parameters sum + max activation tensor
-    total_size = total_weights_params + max_activation_tensor_size
-
-    # Compute BOPS utilization - total count of bit-operations for all configurable layers with kernel
-    bops_count = compute_total_bops(graph=transformed_graph, fw_info=fw_info, fw_impl=fw_impl)
-    bops_count = np.inf if len(bops_count) == 0 else sum(bops_count)
-
-    return ResourceUtilization(weights_memory=total_weights_params,
-                               activation_memory=max_activation_tensor_size,
-                               total_memory=total_size,
-                               bops=bops_count)
-
-
-def compute_nodes_weights_params(graph: Graph, fw_info: FrameworkInfo) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Calculates the memory usage in bytes and the number of weight parameters for each node within a graph.
-    Memory calculations are based on the maximum bit-width used for quantization per node.
-
-    Args:
-        graph: A finalized Graph object, representing the model structure.
-        fw_info: FrameworkInfo object containing details about the specific framework's
-                 quantization attributes for different layers' weights.
-
-    Returns:
-        A tuple containing two arrays:
-            - The first array represents the memory in bytes for each node's weights when quantized at the maximal bit-width.
-            - The second array represents the total number of weight parameters for each node.
-    """
-    weights_params = []
-    weights_memory_bytes = []
-    for n in graph.nodes:
-        # TODO: when enabling multiple attribute quantization by default (currently,
-        #  only kernel quantization is enabled) we should include other attributes memory in the sum of all
-        #  weights memory.
-        #  When implementing this, we should just go over all attributes in the node instead of counting only kernels.
-        kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
-        if kernel_attr is not None and not n.reuse:
-            kernel_candidates = n.get_all_weights_attr_candidates(kernel_attr)
-
-            if len(kernel_candidates) > 0 and any([c.enable_weights_quantization for c in kernel_candidates]):
-                max_weight_bits = max([kc.weights_n_bits for kc in kernel_candidates])
-                node_num_weights_params = 0
-                for attr in fw_info.get_kernel_op_attributes(n.type):
-                    if attr is not None:
-                        node_num_weights_params += n.get_weights_by_keys(attr).flatten().shape[0]
-
-                weights_params.append(node_num_weights_params)
-
-                # multiply num params by num bits and divide by BITS_TO_BYTES to convert from bits to bytes
-                weights_memory_bytes.append(node_num_weights_params * max_weight_bits / BITS_TO_BYTES)
-
-    return np.array(weights_memory_bytes), np.array(weights_params)
-
-
-def compute_activation_output_maxcut_sizes(graph: Graph) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Computes an array of the respective output tensor maxcut size and an array of the output tensor
-    cut size in bytes for each cut.
-
-    Args:
-        graph: A finalized Graph object, representing the model structure.
-
-    Returns:
-    A tuple containing two arrays:
-        - The first is an array of the size of each activation max-cut size in bytes, calculated
-          using the maximal bit-width for quantization.
-        - The second array an array of the size of each activation max-cut activation size in number of parameters.
-
-    """
-    cuts = calc_graph_cuts(graph)
-
-    # map nodes to cuts.
-    node_to_cat_mapping = defaultdict(list)
-    for i, cut in enumerate(cuts):
-        mem_element_names = [m.node_name for m in cut.mem_elements.elements]
-        for m_name in mem_element_names:
-            if len(graph.find_node_by_name(m_name)) > 0:
-                node_to_cat_mapping[m_name].append(i)
-            else:
-                Logger.critical(f"Missing node: {m_name}")  # pragma: no cover
+                                                     mixed_precision_enable=mixed_precision_enable,
+                                                     running_gptq=False)
 
-    activation_outputs = np.zeros(len(cuts))
-    activation_outputs_bytes = np.zeros(len(cuts))
-    for n in graph.nodes:
-        # Go over all nodes that have activation quantization enabled.
-        if n.has_activation_quantization_enabled_candidate():
-            # Fetch maximum bits required for activations quantization.
-            max_activation_bits = max([qc.activation_quantization_cfg.activation_n_bits for qc in n.candidates_quantization_cfg])
-            node_output_size = n.get_total_output_params()
-            for cut_index in node_to_cat_mapping[n.name]:
-                activation_outputs[cut_index] += node_output_size
-                # Calculate activation size in bytes and append to list
-                activation_outputs_bytes[cut_index] += node_output_size * max_activation_bits / BITS_TO_BYTES
-
-    return activation_outputs_bytes, activation_outputs
-
-
-# TODO maxcut: add test for this function and remove no cover
-def compute_activation_output_sizes(graph: Graph) -> Tuple[np.ndarray, np.ndarray]:  # pragma: no cover
-    """
-    Computes an array of the respective output tensor size and an array of the output tensor size in bytes for
-    each node.
-
-    Args:
-        graph: A finalized Graph object, representing the model structure.
-
-    Returns:
-    A tuple containing two arrays:
-        - The first array represents the size of each node's activation output tensor size in bytes,
-          calculated using the maximal bit-width for quantization.
-        - The second array represents the size of each node's activation output tensor size.
-
-    """
-    activation_outputs = []
-    activation_outputs_bytes = []
-    for n in graph.nodes:
-        # Go over all nodes that have configurable activation.
-        if n.has_activation_quantization_enabled_candidate():
-            # Fetch maximum bits required for quantizing activations
-            max_activation_bits = max([qc.activation_quantization_cfg.activation_n_bits for qc in n.candidates_quantization_cfg])
-            node_output_size = n.get_total_output_params()
-            activation_outputs.append(node_output_size)
-            # Calculate activation size in bytes and append to list
-            activation_outputs_bytes.append(node_output_size * max_activation_bits / BITS_TO_BYTES)
-
-    return np.array(activation_outputs_bytes), np.array(activation_outputs)
-
-
-def compute_total_bops(graph: Graph, fw_info: FrameworkInfo, fw_impl: FrameworkImplementation) -> np.ndarray:
-    """
-    Computes a vector with the respective Bit-operations count for each configurable node that includes MAC operations.
-    The computation assumes that the graph is a representation of a float model, thus, BOPs computation uses 32-bit.
-
-    Args:
-        graph: Finalized Graph object.
-        fw_info: FrameworkInfo object about the specific framework
-            (e.g., attributes of different layers' weights to quantize).
-        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
-
-    Returns: A vector of nodes' Bit-operations count.
-
-    """
-
-    bops = []
-
-    # Go over all configurable nodes that have kernels.
-    for n in graph.get_topo_sorted_nodes():
-        if n.has_kernel_weight_to_quantize(fw_info):
-            # If node doesn't have weights then its MAC count is 0, and we shouldn't consider it in the BOPS count.
-            incoming_edges = graph.incoming_edges(n, sort_by_attr=EDGE_SINK_INDEX)
-            assert len(incoming_edges) == 1, f"Can't compute BOPS metric for node {n.name} with multiple inputs."
-
-            node_mac = fw_impl.get_node_mac_operations(n, fw_info)
-
-            node_bops = (FLOAT_BITWIDTH ** 2) * node_mac
-            bops.append(node_bops)
-
-    return np.array(bops)
+    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,
-                             tpc: TargetPlatformCapabilities,
+                             fqc: FrameworkQuantizationCapabilities,
                              fw_info: FrameworkInfo,
                              fw_impl: FrameworkImplementation) -> bool:
     """
@@ -261,14 +97,13 @@ def requires_mixed_precision(in_model: Any,
         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.
-        tpc: TargetPlatformCapabilities object that models the inference target platform and
+        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.
     """
-    is_mixed_precision = False
     core_config = _create_core_config_for_ru(core_config)
 
     transformed_graph = graph_preparation_runner(in_model,
@@ -276,27 +111,15 @@ def requires_mixed_precision(in_model: Any,
                                                  core_config.quantization_config,
                                                  fw_info,
                                                  fw_impl,
-                                                 tpc,
+                                                 fqc,
                                                  bit_width_config=core_config.bit_width_config,
-                                                 mixed_precision_enable=False)
-    # Compute max weights memory in bytes
-    weights_memory_by_layer_bytes, _ = compute_nodes_weights_params(transformed_graph, fw_info)
-    total_weights_memory_bytes = 0 if len(weights_memory_by_layer_bytes) == 0 else sum(weights_memory_by_layer_bytes)
-
-    # Compute max activation tensor in bytes
-    activation_memory_estimation_bytes, _ = compute_activation_output_maxcut_sizes(transformed_graph)
-    max_activation_memory_estimation_bytes = 0 if len(activation_memory_estimation_bytes) == 0 \
-        else max(activation_memory_estimation_bytes)
-
-    # Compute BOPS utilization - total count of bit-operations for all configurable layers with kernel
-    bops_count = compute_total_bops(graph=transformed_graph, fw_info=fw_info, fw_impl=fw_impl)
-    bops_count = np.inf if len(bops_count) == 0 else sum(bops_count)
+                                                 mixed_precision_enable=False,
+                                                 running_gptq=False)
 
-    is_mixed_precision |= target_resource_utilization.weights_memory < total_weights_memory_bytes
-    is_mixed_precision |= target_resource_utilization.activation_memory < max_activation_memory_estimation_bytes
-    is_mixed_precision |= target_resource_utilization.total_memory < total_weights_memory_bytes + max_activation_memory_estimation_bytes
-    is_mixed_precision |= target_resource_utilization.bops < bops_count
-    return is_mixed_precision
+    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_metrics())
+    return not target_resource_utilization.is_satisfied_by(max_ru)
 
 
 def _create_core_config_for_ru(core_config: CoreConfig) -> CoreConfig:

model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py

@@ -16,7 +16,7 @@
 import numpy as np
 from pulp import *
 from tqdm import tqdm
-from typing import Dict, List, Tuple, Callable
+from typing import Dict, Tuple, Set, Any
 
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
@@ -167,72 +167,95 @@ def _formalize_problem(layer_to_indicator_vars_mapping: Dict[int, Dict[int, LpVa
         indicators_arr = np.array(indicators)
         indicators_matrix = np.diag(indicators_arr)
 
-        for target, ru_value in target_resource_utilization.get_resource_utilization_dict().items():
-            if not np.isinf(ru_value):
-                non_conf_ru_vector = None if search_manager.non_conf_ru_dict is None \
-                    else search_manager.non_conf_ru_dict.get(target)
-                _add_set_of_ru_constraints(search_manager=search_manager,
-                                           target=target,
-                                           target_resource_utilization_value=ru_value,
-                                           indicators_matrix=indicators_matrix,
-                                           lp_problem=lp_problem,
-                                           non_conf_ru_vector=non_conf_ru_vector)
+        _add_ru_constraints(search_manager=search_manager,
+                            target_resource_utilization=target_resource_utilization,
+                            indicators_matrix=indicators_matrix,
+                            lp_problem=lp_problem,
+                            non_conf_ru_dict=search_manager.non_conf_ru_dict)
     else:  # pragma: no cover
         Logger.critical("Unable to execute mixed-precision search: 'target_resource_utilization' is None. "
                         "A valid 'target_resource_utilization' is required.")
     return lp_problem
 
 
-def _add_set_of_ru_constraints(search_manager: MixedPrecisionSearchManager,
-                               target: RUTarget,
-                               target_resource_utilization_value: float,
-                               indicators_matrix: np.ndarray,
-                               lp_problem: LpProblem,
-                               non_conf_ru_vector: np.ndarray):
+def _add_ru_constraints(search_manager: MixedPrecisionSearchManager,
+                        target_resource_utilization: ResourceUtilization,
+                        indicators_matrix: np.ndarray,
+                        lp_problem: LpProblem,
+                        non_conf_ru_dict: Optional[Dict[RUTarget, np.ndarray]]):
     """
-    Adding a constraint for the Lp problem for the given target resource utilization.
+    Adding targets constraints for the Lp problem for the given target resource utilization.
     The update to the Lp problem object is done inplace.
 
     Args:
         search_manager:  MixedPrecisionSearchManager object to be used for resource utilization constraints formalization.
-        target: A RUTarget.
-        target_resource_utilization_value: Target resource utilization value of the given target resource utilization
-        for which the constraint is added.
+        target_resource_utilization: Target resource utilization.
         indicators_matrix: A diagonal matrix of the Lp problem's indicators.
         lp_problem: An Lp problem object to add constraint to.
-        non_conf_ru_vector: A non-configurable nodes' resource utilization vector.
+        non_conf_ru_dict: A non-configurable nodes' resource utilization vectors for the constrained targets.
+    """
+    ru_indicated_vectors = {}
+    # targets to add constraints for
+    constraints_targets = target_resource_utilization.get_restricted_metrics()
+    # to add constraints for Total target we need to compute weight and activation
+    targets_to_compute = constraints_targets
+    if RUTarget.TOTAL in constraints_targets:
+        targets_to_compute = targets_to_compute.union({RUTarget.ACTIVATION, RUTarget.WEIGHTS}) - {RUTarget.TOTAL}
+
+    for target in targets_to_compute:
+        ru_matrix = search_manager.compute_resource_utilization_matrix(target)    # num elements X num configurations
+        indicated_ru_matrix = np.matmul(ru_matrix.T, indicators_matrix)    # num elements X num configurations
+
+        # Sum the indicated values over all configurations, and add the value for minimal configuration once.
+        # Indicated utilization values are relative to the minimal configuration, i.e. they represent the extra memory
+        # that would be required if that configuration is selected).
+        # Each element in a vector is an lp object representing the configurations sum term for a memory element.
+        ru_vec = indicated_ru_matrix.sum(axis=1) + search_manager.min_ru[target]
+
+        non_conf_ru_vec = non_conf_ru_dict[target]
+        if non_conf_ru_vec is not None and non_conf_ru_vec.size:
+            # add non-conf value as additional mem elements so that they get aggregated
+            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.
+    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)
+        for v in aggr_ru:
+            if isinstance(v, float):
+                if v > target_resource_utilization_value:
+                    Logger.critical(
+                        f"The model cannot be quantized to meet the specified target resource utilization {target.value} "
+                        f"with the value {target_resource_utilization_value}.")  # pragma: no cover
+            else:
+                lp_problem += v <= target_resource_utilization_value
+
 
+def _aggregate_for_lp(targets_ru_vec: Dict[RUTarget, Any], target: RUTarget) -> list:
     """
+    Aggregate resource utilization values for the LP.
 
-    ru_matrix = search_manager.compute_resource_utilization_matrix(target)
-    indicated_ru_matrix = np.matmul(ru_matrix, indicators_matrix)
-    # Need to re-organize the tensor such that the configurations' axis will be second,
-    # and all metric values' axis will come afterword
-    indicated_ru_matrix = np.moveaxis(indicated_ru_matrix, source=len(indicated_ru_matrix.shape) - 1, destination=1)
-
-    # In order to get the result resource utilization according to a chosen set of indicators, we sum each row in
-    # the result matrix. Each row represents the resource utilization values for a specific resource utilization metric,
-    # such that only elements corresponding to a configuration which implied by the set of indicators will have some
-    # positive value different than 0 (and will contribute to the total resource utilization).
-    ru_sum_vector = np.array([
-        np.sum(indicated_ru_matrix[i], axis=0) +  # sum of metric values over all configurations in a row
-        search_manager.min_ru[target][i] for i in range(indicated_ru_matrix.shape[0])])
-
-    # search_manager.compute_ru_functions contains a pair of ru_metric and ru_aggregation for each ru target
-    # get aggregated ru, considering both configurable and non-configurable nodes
-    if non_conf_ru_vector is None or len(non_conf_ru_vector) == 0:
-        aggr_ru = search_manager.compute_ru_functions[target].aggregate_fn(ru_sum_vector)
-    else:
-        aggr_ru = search_manager.compute_ru_functions[target].aggregate_fn(np.concatenate([ru_sum_vector, non_conf_ru_vector]))
-
-    for v in aggr_ru:
-        if isinstance(v, float):
-            if v > target_resource_utilization_value:
-                Logger.critical(
-                    f"The model cannot be quantized to meet the specified target resource utilization {target.value} "
-                    f"with the value {target_resource_utilization_value}.")  # pragma: no cover
-        else:
-            lp_problem += v <= target_resource_utilization_value
+    Args:
+        targets_ru_vec: resource utilization vectors for all precomputed targets.
+        target: resource utilization target.
+
+    Returns:
+        Aggregated resource utilization.
+    """
+    if target == RUTarget.TOTAL:
+        w = lpSum(targets_ru_vec[RUTarget.WEIGHTS])
+        act_ru_vec = targets_ru_vec[RUTarget.ACTIVATION]
+        return [w + v for v in act_ru_vec]
+
+    if target in [RUTarget.WEIGHTS, RUTarget.BOPS]:
+        return [lpSum(targets_ru_vec[target])]
+
+    if target == RUTarget.ACTIVATION:
+        # for max aggregation, each value constitutes a separate constraint
+        return list(targets_ru_vec[target])
+
+    raise ValueError(f'Unexpected target {target}.')    # pragma: no cover
 
 
 def _build_layer_to_metrics_mapping(search_manager: MixedPrecisionSearchManager,

model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py

@@ -113,11 +113,9 @@ class SensitivityEvaluation:
         # in the new built MP model.
         self.baseline_model, self.model_mp, self.conf_node2layers = self._build_models()
 
-        # Build images batches for inference comparison
-        self.images_batches = self._get_images_batches(quant_config.num_of_images)
-
-        # Casting images tensors to the framework tensor type.
-        self.images_batches = [self.fw_impl.to_tensor(img) for img in self.images_batches]
+        # Build images batches for inference comparison and cat to framework type
+        images_batches = self._get_images_batches(quant_config.num_of_images)
+        self.images_batches = [self.fw_impl.to_tensor(img) for img in images_batches]
 
         # Initiating baseline_tensors_list since it is not initiated in SensitivityEvaluationManager init.
         self.baseline_tensors_list = self._init_baseline_tensors_list()

model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py

@@ -80,8 +80,8 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
                 updated_ru.append(node_updated_ru)
 
             # filter out new configs that don't hold the resource utilization restrictions
-            node_filtered_ru = [(node_idx, ru) for node_idx, ru in zip(valid_candidates, updated_ru) if
-                                target_resource_utilization.holds_constraints(ru)]
+            node_filtered_ru = [(node_idx, ru) for node_idx, ru in zip(valid_candidates, updated_ru)
+                                if target_resource_utilization.is_satisfied_by(ru)]
 
             if len(node_filtered_ru) > 0:
                 sorted_by_ru = sorted(node_filtered_ru, key=lambda node_ru: (node_ru[1].total_memory,

model_compression_toolkit/core/common/pruning/greedy_mask_calculator.py

@@ -24,7 +24,8 @@ from model_compression_toolkit.core.common.pruning.memory_calculator import Memo
 from model_compression_toolkit.core.common.pruning.pruning_framework_implementation import PruningFrameworkImplementation
 from model_compression_toolkit.core.common.pruning.mask.per_simd_group_mask import PerSIMDGroupMask
 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
 
 
 class GreedyMaskCalculator:
@@ -42,7 +43,7 @@ class GreedyMaskCalculator:
                  target_resource_utilization: ResourceUtilization,
                  graph: Graph,
                  fw_impl: PruningFrameworkImplementation,
-                 tpc: TargetPlatformCapabilities,
+                 fqc: FrameworkQuantizationCapabilities,
                  simd_groups_indices: Dict[BaseNode, List[List[int]]]):
         """
         Args:
@@ -52,7 +53,7 @@ class GreedyMaskCalculator:
             target_resource_utilization (ResourceUtilization): The target resource utilization to achieve.
             graph (Graph): The computational graph of the model.
             fw_impl (PruningFrameworkImplementation): Framework-specific implementation details.
-            tpc (TargetPlatformCapabilities): Platform-specific constraints and capabilities.
+            fqc (FrameworkQuantizationCapabilities): Platform-specific constraints and capabilities.
             simd_groups_indices (Dict[BaseNode, List[List[int]]]): Indices of SIMD groups in each node.
         """
         self.prunable_nodes = prunable_nodes
@@ -60,7 +61,7 @@ class GreedyMaskCalculator:
         self.target_resource_utilization = target_resource_utilization
         self.graph = graph
         self.fw_impl = fw_impl
-        self.tpc = tpc
+        self.fqc = fqc
 
         self.simd_groups_indices = simd_groups_indices
         self.simd_groups_scores = simd_groups_scores
@@ -90,7 +91,7 @@ class GreedyMaskCalculator:
         """
         # Iteratively unprune the graph while monitoring the memory footprint.
         current_memory = self.memory_calculator.get_pruned_graph_memory(masks=self.oc_pruning_mask.get_mask(),
-                                                                        include_padded_channels=self.tpc.is_simd_padding)
+                                                                        include_padded_channels=self.fqc.is_simd_padding)
         if current_memory > self.target_resource_utilization.weights_memory:
             Logger.critical(f"Insufficient memory for the target resource utilization: current memory {current_memory}, "
                             f"target memory {self.target_resource_utilization.weights_memory}.")
@@ -105,7 +106,7 @@ class GreedyMaskCalculator:
                                                                group_index=group_to_remain_idx,
                                                                mask_indicator=MaskIndicator.REMAINED)
             current_memory = self.memory_calculator.get_pruned_graph_memory(masks=self.oc_pruning_mask.get_mask(),
-                                                                            include_padded_channels=self.tpc.is_simd_padding)
+                                                                            include_padded_channels=self.fqc.is_simd_padding)
 
         # If the target memory is exceeded, revert the last addition.
         if current_memory > self.target_resource_utilization.weights_memory:

model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py

@@ -23,7 +23,6 @@ from model_compression_toolkit.core.common.mixed_precision.resource_utilization_
 from model_compression_toolkit.core.common.pruning.memory_calculator import MemoryCalculator
 from model_compression_toolkit.core.common.pruning.pruning_framework_implementation import PruningFrameworkImplementation
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
 
 class MaskIndicator(Enum):
     """

model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py

@@ -23,7 +23,6 @@ from model_compression_toolkit.core.common.pruning.mask.per_channel_mask import
 from model_compression_toolkit.core.common.pruning.memory_calculator import MemoryCalculator
 from model_compression_toolkit.core.common.pruning.pruning_framework_implementation import PruningFrameworkImplementation
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
 
 class PerSIMDGroupMask:
     def __init__(self,

model_compression_toolkit/core/common/pruning/pruner.py

@@ -29,7 +29,9 @@ from model_compression_toolkit.core.common.pruning.pruning_framework_implementat
 from model_compression_toolkit.core.common.pruning.pruning_info import PruningInfo, \
     unroll_simd_scores_to_per_channel_scores
 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 import \
+    FrameworkQuantizationCapabilities
+
 
 class Pruner:
     """
@@ -43,7 +45,7 @@ class Pruner:
                  target_resource_utilization: ResourceUtilization,
                  representative_data_gen: Callable,
                  pruning_config: PruningConfig,
-                 target_platform_capabilities: TargetPlatformCapabilities):
+                 target_platform_capabilities: FrameworkQuantizationCapabilities):
         """
         Args:
             float_graph (Graph): The floating-point representation of the model's computation graph.
@@ -52,7 +54,7 @@ class Pruner:
             target_resource_utilization (ResourceUtilization): The target resource utilization to be achieved after pruning.
             representative_data_gen (Callable): Generator function for representative dataset used in pruning analysis.
             pruning_config (PruningConfig): Configuration object specifying how pruning should be performed.
-            target_platform_capabilities (TargetPlatformCapabilities): Object encapsulating the capabilities of the target hardware platform.
+            target_platform_capabilities (FrameworkQuantizationCapabilities): Object encapsulating the capabilities of the target hardware platform.
         """
         self.float_graph = float_graph
         self.fw_info = fw_info

model_compression_toolkit/core/common/quantization/bit_width_config.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from dataclasses import dataclass, field
 from typing import List, Union, Dict
 
 from model_compression_toolkit.core.common import Graph
@@ -19,6 +20,7 @@ from model_compression_toolkit.core.common.matchers.node_matcher import BaseNode
 from model_compression_toolkit.logger import Logger
 
 
+@dataclass
 class ManualBitWidthSelection:
     """
    Class to encapsulate the manual bit width selection configuration for a specific filter.
@@ -27,13 +29,11 @@ class ManualBitWidthSelection:
        filter (BaseNodeMatcher): The filter used to select nodes for bit width manipulation.
        bit_width (int): The bit width to be applied to the selected nodes.
    """
-    def __init__(self,
-                 filter: BaseNodeMatcher,
-                 bit_width: int):
-        self.filter = filter
-        self.bit_width = bit_width
+    filter: BaseNodeMatcher
+    bit_width: int
 
 
+@dataclass
 class BitWidthConfig:
     """
     Class to manage manual bit-width configurations.
@@ -41,13 +41,7 @@ class BitWidthConfig:
     Attributes:
         manual_activation_bit_width_selection_list (List[ManualBitWidthSelection]): A list of ManualBitWidthSelection objects defining manual bit-width configurations.
     """
-    def __init__(self,
-                 manual_activation_bit_width_selection_list: List[ManualBitWidthSelection] = None):
-        self.manual_activation_bit_width_selection_list = [] if manual_activation_bit_width_selection_list is None else manual_activation_bit_width_selection_list
-
-    def __repr__(self):
-        # Used for debugging, thus no cover.
-        return str(self.__dict__)  # pragma: no cover
+    manual_activation_bit_width_selection_list: List[ManualBitWidthSelection] = field(default_factory=list)
 
     def set_manual_activation_bit_width(self,
                                         filters: Union[List[BaseNodeMatcher], BaseNodeMatcher],

model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py

@@ -15,8 +15,7 @@
 import copy
 from typing import List
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.core.common import Graph, BaseNode
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -401,9 +401,9 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 # therefore, we need to look for the attribute in the op_cfg that is contained in the node attribute's name.
                 attrs_included_in_name = {k: v for k, v in op_cfg.attr_weights_configs_mapping.items() if k in attr}
                 if len(attrs_included_in_name) > 1:  # pragma: no cover
-                    Logger.critical(f"Found multiple attribute in TPC OpConfig that are contained "
+                    Logger.critical(f"Found multiple attribute in FQC OpConfig that are contained "
                                     f"in the attribute name '{attr}'."
-                                    f"Please fix the TPC attribute names mapping such that each operator's attribute would "
+                                    f"Please fix the FQC attribute names mapping such that each operator's attribute would "
                                     f"have a unique matching name.")
                 if len(attrs_included_in_name) == 0:
                     attr_cfg = op_cfg.default_weight_attr_config