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

model_compression_toolkit/core/runner.py

@@ -12,44 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-from collections import namedtuple
 
 import copy
-
-from typing import Callable, Tuple, Any, List, Dict
-
-import numpy as np
+from typing import Callable, Any, List
 
 from model_compression_toolkit.core.common import FrameworkInfo
+from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.fusion.graph_fuser import GraphFuser
-
+from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.graph.memory_graph.compute_graph_max_cut import compute_graph_max_cut, \
     SchedulerInfo
 from model_compression_toolkit.core.common.graph.memory_graph.memory_graph import MemoryGraph
 from model_compression_toolkit.core.common.hessian.hessian_info_service import HessianInfoService
+from model_compression_toolkit.core.common.mixed_precision.bit_width_setter import set_bit_widths
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_candidates_filter import \
     filter_candidates_for_mixed_precision
+from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_facade import search_bit_width
+from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
+    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.resource_utilization_data import \
     requires_mixed_precision
-from model_compression_toolkit.core.graph_prep_runner import graph_preparation_runner
-from model_compression_toolkit.core.quantization_prep_runner import quantization_preparation_runner
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
-from model_compression_toolkit.core.common.graph.base_graph import Graph
-from model_compression_toolkit.core.common.mixed_precision.bit_width_setter import set_bit_widths
-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_aggregation_methods import MpRuAggregation
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_functions_mapping import ru_functions_mapping
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_methods import MpRuMetric
-from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_facade import search_bit_width
 from model_compression_toolkit.core.common.network_editors.edit_network import edit_network_graph
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
-from model_compression_toolkit.core.common.visualization.final_config_visualizer import \
-    WeightsFinalBitwidthConfigVisualizer, \
-    ActivationFinalBitwidthConfigVisualizer
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import TensorboardWriter, \
     finalize_bitwidth_in_tb
+from model_compression_toolkit.core.graph_prep_runner import graph_preparation_runner
+from model_compression_toolkit.core.quantization_prep_runner import quantization_preparation_runner
+from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
+    FrameworkQuantizationCapabilities
 
 
 def core_runner(in_model: Any,
@@ -57,7 +50,7 @@ def core_runner(in_model: Any,
                 core_config: CoreConfig,
                 fw_info: FrameworkInfo,
                 fw_impl: FrameworkImplementation,
-                tpc: TargetPlatformCapabilities,
+                fqc: FrameworkQuantizationCapabilities,
                 target_resource_utilization: ResourceUtilization = None,
                 running_gptq: bool = False,
                 tb_w: TensorboardWriter = None):
@@ -77,7 +70,7 @@ def core_runner(in_model: Any,
         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.).
         fw_impl: FrameworkImplementation object with a specific framework methods implementation.
-        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.
         target_resource_utilization: ResourceUtilization to constraint the search of the mixed-precision configuration for the model.
         tb_w: TensorboardWriter object for logging
@@ -88,7 +81,7 @@ def core_runner(in_model: Any,
     """
 
     # Warn is representative dataset has batch-size == 1
-    batch_data = iter(representative_data_gen()).__next__()
+    batch_data = next(iter(representative_data_gen()))
     if isinstance(batch_data, list):
         batch_data = batch_data[0]
     if batch_data.shape[0] == 1:
@@ -96,7 +89,7 @@ def core_runner(in_model: Any,
                        ' consider increasing the batch size')
 
     # Checking whether to run mixed precision quantization
-    if target_resource_utilization is not None:
+    if target_resource_utilization is not None and target_resource_utilization.is_any_restricted():
         if core_config.mixed_precision_config is None:
             Logger.critical("Provided an initialized target_resource_utilization, that means that mixed precision quantization is "
                             "enabled, but the provided MixedPrecisionQuantizationConfig is None.")
@@ -105,7 +98,7 @@ def core_runner(in_model: Any,
                                     target_resource_utilization,
                                     representative_data_gen,
                                     core_config,
-                                    tpc,
+                                    fqc,
                                     fw_info,
                                     fw_impl):
             core_config.mixed_precision_config.set_mixed_precision_enable()
@@ -116,7 +109,7 @@ def core_runner(in_model: Any,
                                      core_config.quantization_config,
                                      fw_info,
                                      fw_impl,
-                                     tpc,
+                                     fqc,
                                      core_config.bit_width_config,
                                      tb_w,
                                      mixed_precision_enable=core_config.is_mixed_precision_enabled,
@@ -138,7 +131,7 @@ def core_runner(in_model: Any,
     if core_config.is_mixed_precision_enabled:
         if core_config.mixed_precision_config.configuration_overwrite is None:
 
-            filter_candidates_for_mixed_precision(graph, target_resource_utilization, fw_info, tpc)
+            filter_candidates_for_mixed_precision(graph, target_resource_utilization, fw_info, fqc)
             bit_widths_config = search_bit_width(tg,
                                                  fw_info,
                                                  fw_impl,
@@ -177,7 +170,6 @@ def core_runner(in_model: Any,
 
     _set_final_resource_utilization(graph=tg,
                                     final_bit_widths_config=bit_widths_config,
-                                    ru_functions_dict=ru_functions_mapping,
                                     fw_info=fw_info,
                                     fw_impl=fw_impl)
 
@@ -215,7 +207,6 @@ def core_runner(in_model: Any,
 
 def _set_final_resource_utilization(graph: Graph,
                                     final_bit_widths_config: List[int],
-                                    ru_functions_dict: Dict[RUTarget, Tuple[MpRuMetric, MpRuAggregation]],
                                     fw_info: FrameworkInfo,
                                     fw_impl: FrameworkImplementation):
     """
@@ -225,39 +216,21 @@ def _set_final_resource_utilization(graph: Graph,
     Args:
         graph: Graph to compute the resource utilization for.
         final_bit_widths_config: The final bit-width configuration to quantize the model accordingly.
-        ru_functions_dict: A mapping between a RUTarget and a pair of resource utilization method and resource utilization aggregation functions.
         fw_info: A FrameworkInfo object.
         fw_impl: FrameworkImplementation object with specific framework methods implementation.
 
     """
-
-    final_ru_dict = {}
-    for ru_target, ru_funcs in ru_functions_dict.items():
-        ru_method, ru_aggr = ru_funcs
-        if ru_target == RUTarget.BOPS:
-            final_ru_dict[ru_target] = \
-            ru_aggr(ru_method(final_bit_widths_config, graph, fw_info, fw_impl, False), False)[0]
-        else:
-            non_conf_ru = ru_method([], graph, fw_info, fw_impl)
-            conf_ru = ru_method(final_bit_widths_config, graph, fw_info, fw_impl)
-            if len(final_bit_widths_config) > 0 and len(non_conf_ru) > 0:
-                final_ru_dict[ru_target] = ru_aggr(np.concatenate([conf_ru, non_conf_ru]), False)[0]
-            elif len(final_bit_widths_config) > 0 and len(non_conf_ru) == 0:
-                final_ru_dict[ru_target] = ru_aggr(conf_ru, False)[0]
-            elif len(final_bit_widths_config) == 0 and len(non_conf_ru) > 0:
-                # final_bit_widths_config == 0 ==> no configurable nodes,
-                # thus, ru can be computed from non_conf_ru alone
-                final_ru_dict[ru_target] = ru_aggr(non_conf_ru, False)[0]
-            else:
-                # No relevant nodes have been quantized with affect on the given target - since we only consider
-                # in the model's final size the quantized layers size, this means that the final size for this target
-                # is zero.
-                Logger.warning(f"No relevant quantized layers for the ru target {ru_target} were found, the recorded "
-                               f"final ru for this target would be 0.")
-                final_ru_dict[ru_target] = 0
-
-    final_ru = ResourceUtilization()
-    final_ru.set_resource_utilization_by_target(final_ru_dict)
-    print(final_ru)
+    w_qcs = {n: n.final_weights_quantization_cfg for n in graph.nodes}
+    a_qcs = {n: n.final_activation_quantization_cfg for n in graph.nodes}
+    ru_calculator = ResourceUtilizationCalculator(graph, fw_impl, fw_info)
+    final_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.QCustom,
+                                                          act_qcs=a_qcs, w_qcs=w_qcs)
+
+    for ru_target, ru in final_ru.get_resource_utilization_dict().items():
+        if ru == 0:
+            Logger.warning(f"No relevant quantized layers for the resource utilization target {ru_target} were found, "
+                           f"the recorded final ru for this target would be 0.")
+
+    Logger.info(f'Resource utilization (of quantized targets):\n {str(final_ru)}.')
     graph.user_info.final_resource_utilization = final_ru
     graph.user_info.mixed_precision_cfg = final_bit_widths_config

model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py

@@ -20,7 +20,7 @@ from model_compression_toolkit.core.common.quantization.node_quantization_config
     NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
 
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget
 from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers.keras.quantizers import BaseKerasInferableQuantizer

model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py

@@ -21,7 +21,7 @@ from model_compression_toolkit.constants import THRESHOLD, SIGNED, RANGE_MIN, RA
 from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
     NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget
 from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers import \

model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -22,7 +22,9 @@ from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT, LR
     LR_BIAS_DEFAULT, GPTQ_MOMENTUM, REG_DEFAULT_SLA
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW, ACT_HESSIAN_DEFAULT_BATCH_SIZE, GPTQ_HESSIAN_NUM_SAMPLES
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2keras import \
+    AttachTpcToKeras
 from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, GPTQHessianScoresConfig, \
@@ -33,7 +35,6 @@ from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.gptq.runner import gptq_runner
 from model_compression_toolkit.core.analyzer import analyzer_model_quantization
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.metadata import create_model_metadata
 
 
@@ -48,8 +49,6 @@ if FOUND_TF:
     from model_compression_toolkit.exporter.model_wrapper import get_exportable_keras_model
     from model_compression_toolkit import get_target_platform_capabilities
     from mct_quantizers.keras.metadata import add_metadata
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
-        AttachTpcToKeras
 
     # As from TF2.9 optimizers package is changed
     if version.parse(tf.__version__) < version.parse("2.9"):
@@ -157,7 +156,7 @@ if FOUND_TF:
                                                   gptq_representative_data_gen: Callable = None,
                                                   target_resource_utilization: ResourceUtilization = None,
                                                   core_config: CoreConfig = CoreConfig(),
-                                                  target_platform_capabilities: TargetPlatformModel = DEFAULT_KERAS_TPC) -> Tuple[Model, UserInformation]:
+                                                  target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC) -> Tuple[Model, UserInformation]:
         """
         Quantize a trained Keras model using post-training quantization. The model is quantized using a
         symmetric constraint quantization thresholds (power of two).
@@ -244,7 +243,7 @@ if FOUND_TF:
 
         # Attach tpc model to framework
         attach2keras = AttachTpcToKeras()
-        target_platform_capabilities = attach2keras.attach(
+        framework_platform_capabilities = attach2keras.attach(
             target_platform_capabilities,
             custom_opset2layer=core_config.quantization_config.custom_tpc_opset_to_layer)
 
@@ -253,7 +252,7 @@ if FOUND_TF:
                                                                                    core_config=core_config,
                                                                                    fw_info=DEFAULT_KERAS_INFO,
                                                                                    fw_impl=fw_impl,
-                                                                                   tpc=target_platform_capabilities,
+                                                                                   fqc=framework_platform_capabilities,
                                                                                    target_resource_utilization=target_resource_utilization,
                                                                                    tb_w=tb_w,
                                                                                    running_gptq=True)
@@ -281,9 +280,9 @@ if FOUND_TF:
                                         DEFAULT_KERAS_INFO)
 
         exportable_model, user_info = get_exportable_keras_model(tg_gptq)
-        if target_platform_capabilities.tp_model.add_metadata:
+        if framework_platform_capabilities.tpc.add_metadata:
             exportable_model = add_metadata(exportable_model,
-                                            create_model_metadata(tpc=target_platform_capabilities,
+                                            create_model_metadata(fqc=framework_platform_capabilities,
                                                                   scheduling_info=scheduling_info))
         return exportable_model, user_info
 

model_compression_toolkit/gptq/keras/quantizer/soft_rounding/symmetric_soft_quantizer.py

@@ -18,7 +18,7 @@ import numpy as np
 
 from model_compression_toolkit.gptq import RoundingType
 from model_compression_toolkit.core.common import max_power_of_two
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget
 from model_compression_toolkit.gptq.common.gptq_constants import PTQ_THRESHOLD, SCALE_PTQ, \
     SOFT_ROUNDING_GAMMA, SOFT_ROUNDING_ZETA, AUXVAR

model_compression_toolkit/gptq/keras/quantizer/soft_rounding/uniform_soft_quantizer.py

@@ -18,7 +18,7 @@ import numpy as np
 
 from model_compression_toolkit.gptq import RoundingType
 from model_compression_toolkit.trainable_infrastructure.common.constants import FQ_MIN, FQ_MAX
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget
 from model_compression_toolkit.gptq.common.gptq_constants import \
     SOFT_ROUNDING_GAMMA, SOFT_ROUNDING_ZETA, AUXVAR

model_compression_toolkit/gptq/keras/quantizer/ste_rounding/symmetric_ste.py

@@ -19,7 +19,7 @@ import numpy as np
 import tensorflow as tf
 
 from model_compression_toolkit.gptq import RoundingType
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget
 from model_compression_toolkit.gptq.common.gptq_constants import AUXVAR, PTQ_THRESHOLD
 from model_compression_toolkit.gptq.keras.quantizer import quant_utils as qutils

model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -31,8 +31,7 @@ from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT, LR
 from model_compression_toolkit.gptq.runner import gptq_runner
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.metadata import create_model_metadata
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
 from model_compression_toolkit.verify_packages import FOUND_TORCH
 
 
@@ -48,7 +47,7 @@ if FOUND_TORCH:
     from torch.optim import Adam, Optimizer
     from model_compression_toolkit import get_target_platform_capabilities
     from mct_quantizers.pytorch.metadata import add_metadata
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+    from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2pytorch import \
         AttachTpcToPytorch
 
     DEFAULT_PYTORCH_TPC = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
@@ -146,11 +145,11 @@ if FOUND_TORCH:
                                                     core_config: CoreConfig = CoreConfig(),
                                                     gptq_config: GradientPTQConfig = None,
                                                     gptq_representative_data_gen: Callable = None,
-                                                    target_platform_capabilities: TargetPlatformModel = DEFAULT_PYTORCH_TPC):
+                                                    target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
         """
         Quantize a trained Pytorch module using post-training quantization.
         By default, the module is quantized using a symmetric constraint quantization thresholds
-        (power of two) as defined in the default TargetPlatformCapabilities.
+        (power of two) as defined in the default FrameworkQuantizationCapabilities.
         The module is first optimized using several transformations (e.g. BatchNormalization folding to
         preceding layers). Then, using a given dataset, statistics (e.g. min/max, histogram, etc.) are
         being collected for each layer's output (and input, depends on the quantization configuration).
@@ -217,7 +216,7 @@ if FOUND_TORCH:
 
         # Attach tpc model to framework
         attach2pytorch = AttachTpcToPytorch()
-        target_platform_capabilities = attach2pytorch.attach(target_platform_capabilities,
+        framework_quantization_capabilities = attach2pytorch.attach(target_platform_capabilities,
                                                              core_config.quantization_config.custom_tpc_opset_to_layer)
 
         # ---------------------- #
@@ -228,7 +227,7 @@ if FOUND_TORCH:
                                                                                       core_config=core_config,
                                                                                       fw_info=DEFAULT_PYTORCH_INFO,
                                                                                       fw_impl=fw_impl,
-                                                                                      tpc=target_platform_capabilities,
+                                                                                      fqc=framework_quantization_capabilities,
                                                                                       target_resource_utilization=target_resource_utilization,
                                                                                       tb_w=tb_w,
                                                                                       running_gptq=True)
@@ -257,9 +256,9 @@ if FOUND_TORCH:
                                         DEFAULT_PYTORCH_INFO)
 
         exportable_model, user_info = get_exportable_pytorch_model(graph_gptq)
-        if target_platform_capabilities.tp_model.add_metadata:
+        if framework_quantization_capabilities.tpc.add_metadata:
             exportable_model = add_metadata(exportable_model,
-                                            create_model_metadata(tpc=target_platform_capabilities,
+                                            create_model_metadata(fqc=framework_quantization_capabilities,
                                                                   scheduling_info=scheduling_info))
         return exportable_model, user_info
 

model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/symmetric_soft_quantizer.py

@@ -18,7 +18,7 @@ from typing import Dict
 import numpy as np
 
 from model_compression_toolkit.core.common import max_power_of_two
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget, PytorchQuantizationWrapper
 from model_compression_toolkit.gptq.common.gptq_config import RoundingType
 from model_compression_toolkit.gptq.pytorch.quantizer.base_pytorch_gptq_quantizer import \

model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/uniform_soft_quantizer.py

@@ -18,7 +18,7 @@ from typing import Dict
 import numpy as np
 
 from model_compression_toolkit.trainable_infrastructure.common.constants import FQ_MIN, FQ_MAX
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget, PytorchQuantizationWrapper
 from model_compression_toolkit.gptq.common.gptq_config import RoundingType
 from model_compression_toolkit.gptq.pytorch.quantizer.base_pytorch_gptq_quantizer import \

model_compression_toolkit/gptq/pytorch/quantizer/ste_rounding/symmetric_ste.py

@@ -18,7 +18,7 @@ from typing import Dict
 import numpy as np
 from model_compression_toolkit.defaultdict import DefaultDict
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget, PytorchQuantizationWrapper
 from model_compression_toolkit.gptq.common.gptq_config import RoundingType
 from model_compression_toolkit.gptq.pytorch.quantizer.base_pytorch_gptq_quantizer import \

model_compression_toolkit/metadata.py

@@ -18,33 +18,34 @@ from typing import Dict, Any
 from model_compression_toolkit.constants import OPERATORS_SCHEDULING, FUSED_NODES_MAPPING, CUTS, MAX_CUT, OP_ORDER, \
     OP_RECORD, SHAPE, NODE_OUTPUT_INDEX, NODE_NAME, TOTAL_SIZE, MEM_ELEMENTS
 from model_compression_toolkit.core.common.graph.memory_graph.compute_graph_max_cut import SchedulerInfo
-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 create_model_metadata(tpc: TargetPlatformCapabilities,
+def create_model_metadata(fqc: FrameworkQuantizationCapabilities,
                           scheduling_info: SchedulerInfo = None) -> Dict:
     """
     Creates and returns a metadata dictionary for the model, including version information
     and optional scheduling information.
 
     Args:
-        tpc: A TPC object to get the version.
+        fqc: A FQC object to get the version.
         scheduling_info: An object containing scheduling details and metadata. Default is None.
 
     Returns:
         Dict: A dictionary containing the model's version information and optional scheduling information.
     """
-    _metadata = get_versions_dict(tpc)
+    _metadata = get_versions_dict(fqc)
     if scheduling_info:
         scheduler_metadata = get_scheduler_metadata(scheduler_info=scheduling_info)
         _metadata['scheduling_info'] = scheduler_metadata
     return _metadata
 
 
-def get_versions_dict(tpc) -> Dict:
+def get_versions_dict(fqc) -> Dict:
     """
 
-    Returns: A dictionary with TPC, MCT and TPC-Schema versions.
+    Returns: A dictionary with FQC, MCT and FQC-Schema versions.
 
     """
     # imported inside to avoid circular import error
@@ -53,10 +54,10 @@ def get_versions_dict(tpc) -> Dict:
     @dataclass
     class TPCVersions:
         mct_version: str
-        tpc_minor_version: str = f'{tpc.tp_model.tpc_minor_version}'
-        tpc_patch_version: str = f'{tpc.tp_model.tpc_patch_version}'
-        tpc_platform_type: str = f'{tpc.tp_model.tpc_platform_type}'
-        tpc_schema: str = f'{tpc.tp_model.SCHEMA_VERSION}'
+        tpc_minor_version: str = f'{fqc.tpc.tpc_minor_version}'
+        tpc_patch_version: str = f'{fqc.tpc.tpc_patch_version}'
+        tpc_platform_type: str = f'{fqc.tpc.tpc_platform_type}'
+        tpc_schema: str = f'{fqc.tpc.SCHEMA_VERSION}'
 
     return asdict(TPCVersions(mct_version))
 

model_compression_toolkit/pruning/keras/pruning_facade.py

@@ -17,7 +17,7 @@ from typing import Callable, Tuple
 
 from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import TENSORFLOW
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
 from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.pruning.pruner import Pruner
@@ -26,17 +26,16 @@ from model_compression_toolkit.core.common.pruning.pruning_info import PruningIn
 from model_compression_toolkit.core.common.quantization.set_node_quantization_config import set_quantization_configuration_to_graph
 from model_compression_toolkit.core.graph_prep_runner import read_model_to_graph
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.core.common.quantization.quantization_config import DEFAULTCONFIG
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
 
 if FOUND_TF:
+    from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2keras import \
+        AttachTpcToKeras
     from model_compression_toolkit.core.keras.back2framework.float_model_builder import FloatKerasModelBuilder
     from model_compression_toolkit.core.keras.pruning.pruning_keras_implementation import PruningKerasImplementation
     from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
     from tensorflow.keras.models import Model
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
-        AttachTpcToKeras
 
     DEFAULT_KERAS_TPC = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
 
@@ -44,7 +43,7 @@ if FOUND_TF:
                                    target_resource_utilization: ResourceUtilization,
                                    representative_data_gen: Callable,
                                    pruning_config: PruningConfig = PruningConfig(),
-                                   target_platform_capabilities: TargetPlatformModel = DEFAULT_KERAS_TPC) -> Tuple[Model, PruningInfo]:
+                                   target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC) -> Tuple[Model, PruningInfo]:
         """
         Perform structured pruning on a Keras model to meet a specified target resource utilization.
         This function prunes the provided model according to the target resource utilization by grouping and pruning
@@ -62,7 +61,7 @@ if FOUND_TF:
             target_resource_utilization (ResourceUtilization): The target Key Performance Indicators to be achieved through pruning.
             representative_data_gen (Callable): A function to generate representative data for pruning analysis.
             pruning_config (PruningConfig): Configuration settings for the pruning process. Defaults to standard config.
-            target_platform_capabilities (TargetPlatformCapabilities): Platform-specific constraints and capabilities. Defaults to DEFAULT_KERAS_TPC.
+            target_platform_capabilities (FrameworkQuantizationCapabilities): Platform-specific constraints and capabilities. Defaults to DEFAULT_KERAS_TPC.
 
         Returns:
             Tuple[Model, PruningInfo]: A tuple containing the pruned Keras model and associated pruning information.

model_compression_toolkit/pruning/pytorch/pruning_facade.py

@@ -16,7 +16,7 @@
 from typing import Callable, Tuple
 from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import PYTORCH
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
 from model_compression_toolkit.verify_packages import FOUND_TORCH
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.pruning.pruner import Pruner
@@ -25,7 +25,6 @@ from model_compression_toolkit.core.common.pruning.pruning_info import PruningIn
 from model_compression_toolkit.core.common.quantization.set_node_quantization_config import set_quantization_configuration_to_graph
 from model_compression_toolkit.core.graph_prep_runner import read_model_to_graph
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.core.common.quantization.quantization_config import DEFAULTCONFIG
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
 
@@ -38,7 +37,7 @@ if FOUND_TORCH:
         PruningPytorchImplementation
     from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
     from torch.nn import Module
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+    from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2pytorch import \
         AttachTpcToPytorch
 
     # Set the default Target Platform Capabilities (TPC) for PyTorch.
@@ -48,7 +47,7 @@ if FOUND_TORCH:
                                      target_resource_utilization: ResourceUtilization,
                                      representative_data_gen: Callable,
                                      pruning_config: PruningConfig = PruningConfig(),
-                                     target_platform_capabilities: TargetPlatformModel = DEFAULT_PYOTRCH_TPC) -> \
+                                     target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYOTRCH_TPC) -> \
             Tuple[Module, PruningInfo]:
         """
         Perform structured pruning on a Pytorch model to meet a specified target resource utilization.
@@ -121,12 +120,12 @@ if FOUND_TORCH:
 
         # Attach TPC to framework
         attach2pytorch = AttachTpcToPytorch()
-        target_platform_capabilities = attach2pytorch.attach(target_platform_capabilities)
+        framework_platform_capabilities = attach2pytorch.attach(target_platform_capabilities)
 
         # Convert the original Pytorch model to an internal graph representation.
         float_graph = read_model_to_graph(model,
                                           representative_data_gen,
-                                          target_platform_capabilities,
+                                          framework_platform_capabilities,
                                           DEFAULT_PYTORCH_INFO,
                                           fw_impl)
 
@@ -143,7 +142,7 @@ if FOUND_TORCH:
                         target_resource_utilization,
                         representative_data_gen,
                         pruning_config,
-                        target_platform_capabilities)
+                        framework_platform_capabilities)
 
         # Apply the pruning process.
         pruned_graph = pruner.prune_graph()

model_compression_toolkit/ptq/keras/quantization_facade.py

@@ -22,17 +22,18 @@ from model_compression_toolkit.core.common.quantization.quantize_graph_weights i
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
 from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.ptq.runner import ptq_runner
 from model_compression_toolkit.metadata import create_model_metadata
 
 if FOUND_TF:
+    from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2keras import \
+        AttachTpcToKeras
     from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
     from model_compression_toolkit.core.keras.keras_implementation import KerasImplementation
     from model_compression_toolkit.core.keras.keras_model_validation import KerasModelValidation
@@ -42,8 +43,6 @@ if FOUND_TF:
 
     from model_compression_toolkit import get_target_platform_capabilities
     from mct_quantizers.keras.metadata import add_metadata
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
-        AttachTpcToKeras
 
     DEFAULT_KERAS_TPC = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
 
@@ -52,7 +51,7 @@ if FOUND_TF:
                                          representative_data_gen: Callable,
                                          target_resource_utilization: ResourceUtilization = None,
                                          core_config: CoreConfig = CoreConfig(),
-                                         target_platform_capabilities: TargetPlatformModel = DEFAULT_KERAS_TPC):
+                                         target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
         """
          Quantize a trained Keras model using post-training quantization. The model is quantized using a
          symmetric constraint quantization thresholds (power of two).
@@ -139,7 +138,7 @@ if FOUND_TF:
         fw_impl = KerasImplementation()
 
         attach2keras = AttachTpcToKeras()
-        target_platform_capabilities = attach2keras.attach(
+        framework_platform_capabilities = attach2keras.attach(
             target_platform_capabilities,
             custom_opset2layer=core_config.quantization_config.custom_tpc_opset_to_layer)
 
@@ -149,7 +148,7 @@ if FOUND_TF:
                                                                 core_config=core_config,
                                                                 fw_info=fw_info,
                                                                 fw_impl=fw_impl,
-                                                                tpc=target_platform_capabilities,
+                                                                fqc=framework_platform_capabilities,
                                                                 target_resource_utilization=target_resource_utilization,
                                                                 tb_w=tb_w)
 
@@ -177,9 +176,9 @@ if FOUND_TF:
                                         fw_info)
 
         exportable_model, user_info = get_exportable_keras_model(graph_with_stats_correction)
-        if target_platform_capabilities.tp_model.add_metadata:
+        if framework_platform_capabilities.tpc.add_metadata:
             exportable_model = add_metadata(exportable_model,
-                                            create_model_metadata(tpc=target_platform_capabilities,
+                                            create_model_metadata(fqc=framework_platform_capabilities,
                                                                   scheduling_info=scheduling_info))
         return exportable_model, user_info