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/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
 
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization, RUTarget
@@ -218,13 +218,11 @@ def _add_set_of_ru_constraints(search_manager: MixedPrecisionSearchManager,
         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]))
+    ru_vec = ru_sum_vector
+    if non_conf_ru_vector is not None and non_conf_ru_vector.size:
+        ru_vec = np.concatenate([ru_vec, non_conf_ru_vector])
 
+    aggr_ru = _aggregate_for_lp(ru_vec, target)
     for v in aggr_ru:
         if isinstance(v, float):
             if v > target_resource_utilization_value:
@@ -235,6 +233,31 @@ def _add_set_of_ru_constraints(search_manager: MixedPrecisionSearchManager,
             lp_problem += v <= target_resource_utilization_value
 
 
+def _aggregate_for_lp(ru_vec, target: RUTarget) -> list:
+    """
+    Aggregate resource utilization values for the LP.
+
+    Args:
+        ru_vec: a vector of resource utilization values.
+        target: resource utilization target.
+
+    Returns:
+        Aggregated resource utilization.
+    """
+    if target == RUTarget.TOTAL:
+        w = lpSum(v[0] for v in ru_vec)
+        return [w + v[1] for v in ru_vec]
+
+    if target in [RUTarget.WEIGHTS, RUTarget.BOPS]:
+        return [lpSum(ru_vec)]
+
+    if target == RUTarget.ACTIVATION:
+        # for max aggregation, each value constitutes a separate constraint
+        return list(ru_vec)
+
+    raise ValueError(f'Unexpected target {target}.')
+
+
 def _build_layer_to_metrics_mapping(search_manager: MixedPrecisionSearchManager,
                                     target_resource_utilization: ResourceUtilization,
                                     eps: float = EPS) -> Dict[int, Dict[int, float]]:

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

model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -25,7 +25,7 @@ from model_compression_toolkit.constants import MIN_THRESHOLD
 class CustomOpsetLayers(NamedTuple):
     """
     This struct defines a set of operators from a specific framework, which will be used to configure a custom operator
-    set in the TPC.
+    set in the FQC.
 
     Args:
         operators: a list of framework operators to map to a certain custom opset name.

model_compression_toolkit/core/common/quantization/quantization_fn_selection.py

@@ -16,8 +16,8 @@
 from collections.abc import Callable
 from functools import partial
 
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.core.common.quantization.quantizers.lut_kmeans_quantizer import lut_kmeans_quantizer
 from model_compression_toolkit.core.common.quantization.quantizers.uniform_quantizers import power_of_two_quantizer, \
     symmetric_quantizer, uniform_quantizer

model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py

@@ -16,8 +16,8 @@
 from collections.abc import Callable
 from functools import partial
 
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.lut_kmeans_params import \
     lut_kmeans_tensor, lut_kmeans_histogram
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.symmetric_selection import \

model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py

@@ -16,11 +16,11 @@ from copy import deepcopy
 from typing import Tuple, Callable, List, Iterable, Optional
 import numpy as np
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianMode, HessianScoresGranularity, \
     HessianInfoService
 from model_compression_toolkit.core.common.similarity_analyzer import compute_mse, compute_mae, compute_lp_norm
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_32, NUM_QPARAM_HESSIAN_SAMPLES
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import uniform_quantize_tensor, \
     reshape_tensor_for_per_channel_search

model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py

@@ -16,6 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.qparams_search import \
@@ -23,7 +24,6 @@ from model_compression_toolkit.core.common.quantization.quantization_params_gene
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import max_power_of_two, get_tensor_max
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.error_functions import \
     get_threshold_selection_tensor_error_function, get_threshold_selection_histogram_error_function
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.core.common.similarity_analyzer import compute_mse
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import quantize_tensor
 

model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py

@@ -15,7 +15,7 @@
 import numpy as np
 from typing import Dict, Union
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import Signedness
 from model_compression_toolkit.core.common.collectors.statistics_collector import BaseStatsCollector
 from model_compression_toolkit.core.common.quantization import quantization_params_generation

model_compression_toolkit/core/common/quantization/quantization_params_generation/symmetric_selection.py

@@ -25,7 +25,7 @@ from model_compression_toolkit.core.common.quantization.quantization_params_gene
     qparams_symmetric_selection_histogram_search, kl_qparams_symmetric_selection_histogram_search
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import \
     get_tensor_max
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.core.common.similarity_analyzer import compute_mse
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import quantize_tensor
 

model_compression_toolkit/core/common/quantization/quantization_params_generation/uniform_selection.py

@@ -24,7 +24,7 @@ from model_compression_toolkit.core.common.quantization.quantization_params_gene
     get_threshold_selection_tensor_error_function, get_threshold_selection_histogram_error_function
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import get_tensor_max, \
     get_tensor_min
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.core.common.similarity_analyzer import compute_mse
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import uniform_quantize_tensor
 

model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -33,9 +33,10 @@ from model_compression_toolkit.core.common.quantization.quantization_params_fn_s
 from model_compression_toolkit.core.common.quantization.quantization_fn_selection import \
     get_weights_quantization_fn
 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.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OpQuantizationConfig, \
     QuantizationConfigOptions
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 def set_quantization_configuration_to_graph(graph: Graph,
@@ -71,14 +72,14 @@ def set_quantization_configuration_to_graph(graph: Graph,
                                          graph=graph,
                                          quant_config=quant_config,
                                          fw_info=graph.fw_info,
-                                         tpc=graph.tpc,
+                                         fqc=graph.fqc,
                                          mixed_precision_enable=mixed_precision_enable,
                                          manual_bit_width_override=nodes_to_manipulate_bit_widths.get(n))
     return graph
 
 
 def filter_node_qco_by_graph(node: BaseNode,
-                             tpc: TargetPlatformCapabilities,
+                             fqc: FrameworkQuantizationCapabilities,
                              graph: Graph,
                              node_qc_options: QuantizationConfigOptions
                              ) -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig]]:
@@ -90,7 +91,7 @@ def filter_node_qco_by_graph(node: BaseNode,
 
     Args:
         node: Node for filtering.
-        tpc: TPC to extract the QuantizationConfigOptions for the next nodes.
+        fqc: FQC to extract the QuantizationConfigOptions for the next nodes.
         graph: Graph object.
         node_qc_options: Node's QuantizationConfigOptions.
 
@@ -108,7 +109,7 @@ def filter_node_qco_by_graph(node: BaseNode,
     next_nodes = []
     while len(_next_nodes):
         n = _next_nodes.pop(0)
-        qco = n.get_qco(tpc)
+        qco = n.get_qco(fqc)
         qp = [qc.quantization_preserving for qc in qco.quantization_configurations]
         if not all(qp) and any(qp):
             Logger.error(f'Attribute "quantization_preserving" should be the same for all QuantizaionConfigOptions in {n}.')
@@ -117,7 +118,7 @@ def filter_node_qco_by_graph(node: BaseNode,
         next_nodes.append(n)
 
     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])
@@ -126,7 +127,7 @@ def filter_node_qco_by_graph(node: 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: {node} -> {next_nodes}.")
+            Logger.critical(f"Graph doesn't match FQC bit configurations: {node} -> {next_nodes}.")
 
         # Verify base config match
         if any([node_qc_options.base_config.activation_n_bits > max_input_activation_n_bits(qc_opt.base_config)
@@ -136,9 +137,9 @@ def filter_node_qco_by_graph(node: 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 {node} base quantization config changed to match Graph and TPC configuration.\nCause: {node} -> {next_nodes}.")
+                Logger.warning(f"Node {node} base quantization config changed to match Graph and FQC configuration.\nCause: {node} -> {next_nodes}.")
             else:
-                Logger.critical(f"Graph doesn't match TPC bit configurations: {node} -> {next_nodes}.")  # pragma: no cover
+                Logger.critical(f"Graph doesn't match FQC bit configurations: {node} -> {next_nodes}.")  # pragma: no cover
 
     return _base_config, _node_qc_options
 
@@ -147,7 +148,7 @@ def set_quantization_configs_to_node(node: BaseNode,
                                      graph: Graph,
                                      quant_config: QuantizationConfig,
                                      fw_info: FrameworkInfo,
-                                     tpc: TargetPlatformCapabilities,
+                                     fqc: FrameworkQuantizationCapabilities,
                                      mixed_precision_enable: bool = False,
                                      manual_bit_width_override: Optional[int] = None):
     """
@@ -158,12 +159,12 @@ def set_quantization_configs_to_node(node: BaseNode,
         graph (Graph): Model's internal representation graph.
         quant_config (QuantizationConfig): Quantization configuration to generate the node's configurations from.
         fw_info (FrameworkInfo): Information needed for quantization about the specific framework.
-        tpc (TargetPlatformCapabilities): TargetPlatformCapabilities to get default OpQuantizationConfig.
+        fqc (FrameworkQuantizationCapabilities): FrameworkQuantizationCapabilities to get default OpQuantizationConfig.
         mixed_precision_enable (bool): Whether mixed precision is enabled. Defaults to False.
         manual_bit_width_override (Optional[int]): Specifies a custom bit-width to override the node's activation bit-width. Defaults to None.
     """
-    node_qc_options = node.get_qco(tpc)
-    base_config, node_qc_options_list = filter_node_qco_by_graph(node, tpc, graph, node_qc_options)
+    node_qc_options = node.get_qco(fqc)
+    base_config, node_qc_options_list = filter_node_qco_by_graph(node, fqc, graph, node_qc_options)
 
     # If a manual_bit_width_override is given, filter node_qc_options_list to retain only the options with activation bits equal to manual_bit_width_override,
     # and update base_config accordingly.
@@ -257,7 +258,7 @@ def _create_node_single_candidate_qc(qc: QuantizationConfig,
     attrs_with_enabled_quantization = [attr for attr, cfg in op_cfg.attr_weights_configs_mapping.items()
                                        if cfg.enable_weights_quantization]
     if len(attrs_with_enabled_quantization) > 1:
-        Logger.warning(f"Multiple weights attributes quantization is enabled via the provided TPC."
+        Logger.warning(f"Multiple weights attributes quantization is enabled via the provided FQC."
                        f"Quantizing any attribute other than the kernel is experimental "
                        f"and may be subject to unstable behavior."
                        f"Attributes with enabled weights quantization: {attrs_with_enabled_quantization}.")

model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py

@@ -26,7 +26,7 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import AttributeQuantizationConfig
 
 

model_compression_toolkit/core/common/substitutions/batchnorm_refusing.py

@@ -22,7 +22,7 @@ from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.graph.graph_matchers import EdgeMatcher, NodeOperationMatcher
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import THRESHOLD, RANGE_MIN, RANGE_MAX
 from model_compression_toolkit.logger import Logger
 

model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -22,7 +22,7 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common import FrameworkInfo, Graph, BaseNode
 from model_compression_toolkit.constants import THRESHOLD, SIGNED, SHIFT_NEGATIVE_NON_LINEAR_NUM_BITS
 from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import AttributeQuantizationConfig
 from model_compression_toolkit.core.common.quantization.set_node_quantization_config import create_node_activation_qc, \
     set_quantization_configs_to_node
@@ -359,7 +359,7 @@ def shift_negative_function(graph: Graph,
                                          node=pad_node,
                                          graph=graph,
                                          quant_config=core_config.quantization_config,
-                                         tpc=graph.tpc,
+                                         fqc=graph.fqc,
                                          mixed_precision_enable=core_config.is_mixed_precision_enabled)
 
         for candidate_qc in pad_node.candidates_quantization_cfg:
@@ -376,7 +376,7 @@ def shift_negative_function(graph: Graph,
                                      node=add_node,
                                      graph=graph,
                                      quant_config=core_config.quantization_config,
-                                     tpc=graph.tpc,
+                                     fqc=graph.fqc,
                                      mixed_precision_enable=core_config.is_mixed_precision_enabled)
 
     original_non_linear_activation_nbits = non_linear_node_cfg_candidate.activation_n_bits
@@ -392,7 +392,7 @@ def shift_negative_function(graph: Graph,
                     bypass_candidate_qc.activation_quantization_cfg.activation_quantization_params[SIGNED] = False
                     graph.shift_stats_collector(bypass_node, np.array(shift_value))
 
-    add_node_qco = add_node.get_qco(graph.tpc).quantization_configurations
+    add_node_qco = add_node.get_qco(graph.fqc).quantization_configurations
     for op_qc_idx, candidate_qc in enumerate(add_node.candidates_quantization_cfg):
         for attr in add_node.get_node_weights_attributes():
             candidate_qc.weights_quantization_cfg.get_attr_config(attr).enable_weights_quantization = False
@@ -533,7 +533,7 @@ def apply_shift_negative_correction(graph: Graph,
     nodes = list(graph.nodes())
     for n in nodes:
         # Skip substitution if QuantizationMethod is uniform.
-        node_qco = n.get_qco(graph.tpc)
+        node_qco = n.get_qco(graph.fqc)
         if any([op_qc.activation_quantization_method is QuantizationMethod.UNIFORM
                 for op_qc in node_qco.quantization_configurations]):
             continue

model_compression_toolkit/core/graph_prep_runner.py

@@ -29,8 +29,9 @@ from model_compression_toolkit.core.common.quantization.set_node_quantization_co
 from model_compression_toolkit.core.common.substitutions.apply_substitutions import substitute
 from model_compression_toolkit.core.common.substitutions.linear_collapsing_substitution import \
     linear_collapsing_substitute
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import TensorboardWriter
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 def graph_preparation_runner(in_model: Any,
@@ -38,7 +39,7 @@ def graph_preparation_runner(in_model: Any,
                              quantization_config: QuantizationConfig,
                              fw_info: FrameworkInfo,
                              fw_impl: FrameworkImplementation,
-                             tpc: TargetPlatformCapabilities,
+                             fqc: FrameworkQuantizationCapabilities,
                              bit_width_config: BitWidthConfig = None,
                              tb_w: TensorboardWriter = None,
                              mixed_precision_enable: bool = False,
@@ -58,7 +59,7 @@ def graph_preparation_runner(in_model: Any,
         fw_info (FrameworkInfo): Information needed for quantization about the specific framework (e.g., kernel channels indices,
             groups of layers by how they should be quantized, etc.).
         fw_impl (FrameworkImplementation): FrameworkImplementation object with a specific framework methods implementation.
-        tpc (TargetPlatformCapabilities): TargetPlatformCapabilities object that models the inference target platform and
+        fqc (FrameworkQuantizationCapabilities): FrameworkQuantizationCapabilities object that models the inference target platform and
             the attached framework operator's information.
         bit_width_config (BitWidthConfig): Config for bit-width selection. Defaults to None.
         tb_w (TensorboardWriter): TensorboardWriter object for logging.
@@ -71,7 +72,7 @@ def graph_preparation_runner(in_model: Any,
 
     graph = read_model_to_graph(in_model,
                                 representative_data_gen,
-                                tpc,
+                                fqc,
                                 fw_info,
                                 fw_impl)
 
@@ -79,7 +80,7 @@ def graph_preparation_runner(in_model: Any,
         tb_w.add_graph(graph, 'initial_graph')
 
     transformed_graph = get_finalized_graph(graph,
-                                            tpc,
+                                            fqc,
                                             quantization_config,
                                             bit_width_config,
                                             fw_info,
@@ -92,7 +93,7 @@ def graph_preparation_runner(in_model: Any,
 
 
 def get_finalized_graph(initial_graph: Graph,
-                        tpc: TargetPlatformCapabilities,
+                        fqc: FrameworkQuantizationCapabilities,
                         quant_config: QuantizationConfig = DEFAULTCONFIG,
                         bit_width_config: BitWidthConfig = None,
                         fw_info: FrameworkInfo = None,
@@ -106,7 +107,7 @@ def get_finalized_graph(initial_graph: Graph,
 
     Args:
         initial_graph (Graph): Graph to apply the changes to.
-        tpc (TargetPlatformCapabilities): TargetPlatformCapabilities object that describes the desired inference target platform (includes fusing patterns MCT should handle).
+        fqc (FrameworkQuantizationCapabilities): FrameworkQuantizationCapabilities object that describes the desired inference target platform (includes fusing patterns MCT should handle).
         quant_config (QuantizationConfig): QuantizationConfig containing parameters of how the model should be
             quantized.
         bit_width_config (BitWidthConfig): Config for bit-width selection. Defaults to None.
@@ -160,7 +161,7 @@ def get_finalized_graph(initial_graph: Graph,
     ######################################
     # Layer fusing
     ######################################
-    transformed_graph = fusion(transformed_graph, tpc)
+    transformed_graph = fusion(transformed_graph, fqc)
 
     ######################################
     # Channel equalization
@@ -185,7 +186,7 @@ def get_finalized_graph(initial_graph: Graph,
 
 def read_model_to_graph(in_model: Any,
                         representative_data_gen: Callable,
-                        tpc: TargetPlatformCapabilities,
+                        fqc: FrameworkQuantizationCapabilities,
                         fw_info: FrameworkInfo = None,
                         fw_impl: FrameworkImplementation = None) -> Graph:
 
@@ -195,7 +196,7 @@ def read_model_to_graph(in_model: Any,
     Args:
         in_model: Model to optimize and prepare for quantization.
         representative_data_gen: Dataset used for calibration.
-        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 (e.g.,
                 kernel channels indices, groups of layers by how they should be quantized, etc.)
@@ -207,5 +208,5 @@ def read_model_to_graph(in_model: Any,
     graph = fw_impl.model_reader(in_model,
                                  representative_data_gen)
     graph.set_fw_info(fw_info)
-    graph.set_tpc(tpc)
+    graph.set_fqc(fqc)
     return graph