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

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/{tp_model.py → tpc.py}

@@ -16,36 +16,36 @@ from typing import List, Tuple
 
 import model_compression_toolkit as mct
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, QNNPACK_TP_MODEL
-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, \
     Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
-tp = mct.target_platform
 
 
-def get_tp_model() -> TargetPlatformModel:
+def get_tpc() -> TargetPlatformCapabilities:
     """
     A method that generates a default target platform model, with base 8-bit quantization configuration and 8, 4, 2
     bits configuration list for mixed-precision quantization.
     NOTE: in order to generate a target platform model with different configurations but with the same Operators Sets
     (for tests, experiments, etc.), use this method implementation as a test-case, i.e., override the
-    'get_op_quantization_configs' method and use its output to call 'generate_tp_model' with your configurations.
+    'get_op_quantization_configs' method and use its output to call 'generate_tpc' with your configurations.
 
-    Returns: A TargetPlatformModel object.
+    Returns: A TargetPlatformCapabilities object.
 
     """
     base_config, mixed_precision_cfg_list, default_config = get_op_quantization_configs()
-    return generate_tp_model(default_config=default_config,
-                             base_config=base_config,
-                             mixed_precision_cfg_list=mixed_precision_cfg_list,
-                             name='qnnpack_tp_model')
+    return generate_tpc(default_config=default_config,
+                        base_config=base_config,
+                        mixed_precision_cfg_list=mixed_precision_cfg_list,
+                        name='qnnpack_tpc')
 
 
 def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig], OpQuantizationConfig]:
     """
-    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformModel.
+    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformCapabilities.
     In addition, creates a default configuration objects list (with 8, 4 and 2 bit quantization) to be used as
     default configuration for mixed-precision quantization.
 
@@ -55,7 +55,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a default quantization config for all non-specified weights attributes.
     default_weight_attr_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=8,
         weights_per_channel_threshold=False,
         enable_weights_quantization=False,
@@ -63,7 +63,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a quantization config to quantize the kernel (for layers where there is a kernel attribute).
     kernel_base_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=8,
         weights_per_channel_threshold=False,
         enable_weights_quantization=True,
@@ -71,7 +71,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a quantization config to quantize the bias (for layers where there is a bias attribute).
     bias_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=FLOAT_BITWIDTH,
         weights_per_channel_threshold=False,
         enable_weights_quantization=False,
@@ -88,7 +88,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     eight_bits_default = schema.OpQuantizationConfig(
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={},
-        activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
+        activation_quantization_method=QuantizationMethod.POWER_OF_TWO,
         activation_n_bits=8,
         supported_input_activation_n_bits=8,
         enable_activation_quantization=True,
@@ -100,7 +100,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
     linear_eight_bits = schema.OpQuantizationConfig(
-        activation_quantization_method=tp.QuantizationMethod.UNIFORM,
+        activation_quantization_method=QuantizationMethod.UNIFORM,
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
         activation_n_bits=8,
@@ -117,22 +117,22 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     return linear_eight_bits, mixed_precision_cfg_list, eight_bits_default
 
 
-def generate_tp_model(default_config: OpQuantizationConfig,
-                      base_config: OpQuantizationConfig,
-                      mixed_precision_cfg_list: List[OpQuantizationConfig],
-                      name: str) -> TargetPlatformModel:
+def generate_tpc(default_config: OpQuantizationConfig,
+                 base_config: OpQuantizationConfig,
+                 mixed_precision_cfg_list: List[OpQuantizationConfig],
+                 name: str) -> TargetPlatformCapabilities:
     """
-    Generates TargetPlatformModel with default defined Operators Sets, based on the given base configuration and
+    Generates TargetPlatformCapabilities with default defined Operators Sets, based on the given base configuration and
     mixed-precision configurations options list.
 
     Args
         default_config: A default OpQuantizationConfig to set as the TP model default configuration.
-        base_config: An OpQuantizationConfig to set as the TargetPlatformModel base configuration for mixed-precision purposes only.
+        base_config: An OpQuantizationConfig to set as the TargetPlatformCapabilities base configuration for mixed-precision purposes only.
         mixed_precision_cfg_list: A list of OpQuantizationConfig to be used as the TP model mixed-precision
             quantization configuration options.
-        name: The name of the TargetPlatformModel.
+        name: The name of the TargetPlatformCapabilities.
 
-    Returns: A TargetPlatformModel object.
+    Returns: A TargetPlatformCapabilities object.
 
     """
     # Create a QuantizationConfigOptions, which defines a set
@@ -160,8 +160,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
 
     operator_set.extend([conv, conv_depthwise, conv_transpose, batchnorm, relu, relu6, hard_tanh, linear])
 
-    conv_opset_concat = schema.OperatorSetConcat(operators_set=[conv, conv_transpose])
-    relu_opset_concat = schema.OperatorSetConcat(operators_set=[relu, relu6, hard_tanh])
+    conv_opset_concat = schema.OperatorSetGroup(operators_set=[conv, conv_transpose])
+    relu_opset_concat = schema.OperatorSetGroup(operators_set=[relu, relu6, hard_tanh])
 
     # ------------------- #
     # Fusions
@@ -171,10 +171,10 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     fusing_patterns.append(schema.Fusing(operator_groups=(conv_opset_concat, relu_opset_concat)))
     fusing_patterns.append(schema.Fusing(operator_groups=(linear, relu_opset_concat)))
 
-    # Create a TargetPlatformModel and set its default quantization config.
+    # Create a TargetPlatformCapabilities and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
-    generated_tpc = schema.TargetPlatformModel(
+    generated_tpc = schema.TargetPlatformCapabilities(
         default_qco=default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,

model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/latest/__init__.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 # ==============================================================================
 from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
-from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tp_model import get_tp_model, generate_tp_model, get_op_quantization_configs
+from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc import get_tpc, generate_tpc, get_op_quantization_configs
 if FOUND_TF:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tp_model import get_keras_tpc as get_keras_tpc_latest
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc import get_keras_tpc as get_keras_tpc_latest
     from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import \
         get_tpc_model as generate_keras_tpc
 if FOUND_TORCH:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tp_model import \
-        get_tp_model as get_pytorch_tpc_latest
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc import \
+        get_tpc as get_pytorch_tpc_latest
     from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import \
         get_tpc_model as generate_pytorch_tpc

model_compression_toolkit/target_platform_capabilities/tpc_models/tflite_tpc/v1/{tp_model.py → tpc.py}

@@ -16,35 +16,35 @@ from typing import List, Tuple
 
 import model_compression_toolkit as mct
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.target_platform_capabilities.constants import BIAS_ATTR, KERNEL_ATTR, TFLITE_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, Signedness, \
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities, Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
-tp = mct.target_platform
 
 
-def get_tp_model() -> TargetPlatformModel:
+def get_tpc() -> TargetPlatformCapabilities:
     """
     A method that generates a default target platform model, with base 8-bit quantization configuration and 8, 4, 2
     bits configuration list for mixed-precision quantization.
     NOTE: in order to generate a target platform model with different configurations but with the same Operators Sets
     (for tests, experiments, etc.), use this method implementation as a test-case, i.e., override the
-    'get_op_quantization_configs' method and use its output to call 'generate_tp_model' with your configurations.
+    'get_op_quantization_configs' method and use its output to call 'generate_tpc' with your configurations.
 
-    Returns: A TargetPlatformModel object.
+    Returns: A TargetPlatformCapabilities object.
 
     """
     base_config, mixed_precision_cfg_list, default_config = get_op_quantization_configs()
-    return generate_tp_model(default_config=default_config,
-                             base_config=base_config,
-                             mixed_precision_cfg_list=mixed_precision_cfg_list,
-                             name='tflite_tp_model')
+    return generate_tpc(default_config=default_config,
+                        base_config=base_config,
+                        mixed_precision_cfg_list=mixed_precision_cfg_list,
+                        name='tflite_tpc')
 
 
 def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig], OpQuantizationConfig]:
     """
-    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformModel.
+    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformCapabilities.
     In addition, creates a default configuration objects list (with 8, 4 and 2 bit quantization) to be used as
     default configuration for mixed-precision quantization.
 
@@ -54,7 +54,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a default quantization config for all non-specified weights attributes.
     default_weight_attr_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=8,
         weights_per_channel_threshold=False,
         enable_weights_quantization=False,
@@ -62,7 +62,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a quantization config to quantize the kernel (for layers where there is a kernel attribute).
     kernel_base_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=8,
         weights_per_channel_threshold=True,
         enable_weights_quantization=True,
@@ -70,7 +70,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a quantization config to quantize the bias (for layers where there is a bias attribute).
     bias_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=FLOAT_BITWIDTH,
         weights_per_channel_threshold=False,
         enable_weights_quantization=False,
@@ -85,7 +85,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     eight_bits_default = schema.OpQuantizationConfig(
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={},
-        activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
+        activation_quantization_method=QuantizationMethod.POWER_OF_TWO,
         activation_n_bits=8,
         supported_input_activation_n_bits=8,
         enable_activation_quantization=True,
@@ -97,7 +97,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
     linear_eight_bits = schema.OpQuantizationConfig(
-        activation_quantization_method=tp.QuantizationMethod.UNIFORM,
+        activation_quantization_method=QuantizationMethod.UNIFORM,
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
         activation_n_bits=8,
@@ -114,22 +114,22 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     return linear_eight_bits, mixed_precision_cfg_list, eight_bits_default
 
 
-def generate_tp_model(default_config: OpQuantizationConfig,
-                      base_config: OpQuantizationConfig,
-                      mixed_precision_cfg_list: List[OpQuantizationConfig],
-                      name: str) -> TargetPlatformModel:
+def generate_tpc(default_config: OpQuantizationConfig,
+                 base_config: OpQuantizationConfig,
+                 mixed_precision_cfg_list: List[OpQuantizationConfig],
+                 name: str) -> TargetPlatformCapabilities:
     """
-    Generates TargetPlatformModel with default defined Operators Sets, based on the given base configuration and
+    Generates TargetPlatformCapabilities with default defined Operators Sets, based on the given base configuration and
     mixed-precision configurations options list.
 
     Args
         default_config: A default OpQuantizationConfig to set as the TP model default configuration.
-        base_config: An OpQuantizationConfig to set as the TargetPlatformModel base configuration for mixed-precision purposes only.
+        base_config: An OpQuantizationConfig to set as the TargetPlatformCapabilities base configuration for mixed-precision purposes only.
         mixed_precision_cfg_list: A list of OpQuantizationConfig to be used as the TP model mixed-precision
             quantization configuration options.
-        name: The name of the TargetPlatformModel.
+        name: The name of the TargetPlatformCapabilities.
 
-    Returns: A TargetPlatformModel object.
+    Returns: A TargetPlatformCapabilities object.
 
     """
     # Create a QuantizationConfigOptions, which defines a set
@@ -193,8 +193,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD)
     bias_add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD_BIAS)
 
-    kernel = schema.OperatorSetConcat(operators_set=[conv2d, fc])
-    activations_to_fuse = schema.OperatorSetConcat(operators_set=[relu, elu])
+    kernel = schema.OperatorSetGroup(operators_set=[conv2d, fc])
+    activations_to_fuse = schema.OperatorSetGroup(operators_set=[relu, elu])
 
     operator_set.extend([fc, conv2d, relu, relu6, tanh, sigmoid, batch_norm, add, bias_add, elu, squeeze])
 
@@ -209,10 +209,10 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     fusing_patterns.append(schema.Fusing(operator_groups=(batch_norm, activations_to_fuse)))
     fusing_patterns.append(schema.Fusing(operator_groups=(batch_norm, add, activations_to_fuse)))
 
-    # Create a TargetPlatformModel and set its default quantization config.
+    # Create a TargetPlatformCapabilities and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
-    generated_tpc = schema.TargetPlatformModel(
+    generated_tpc = schema.TargetPlatformCapabilities(
         default_qco=default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,

model_compression_toolkit/trainable_infrastructure/common/get_quantizers.py

@@ -15,8 +15,7 @@
 from typing import Union, Any
 
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from mct_quantizers import QuantizationTarget
+from mct_quantizers import QuantizationTarget, QuantizationMethod
 from mct_quantizers.common.constants \
     import QUANTIZATION_TARGET, QUANTIZATION_METHOD, QUANTIZER_ID
 from mct_quantizers.common.get_all_subclasses \

model_compression_toolkit/trainable_infrastructure/common/trainable_quantizer_config.py

@@ -14,7 +14,8 @@
 # ==============================================================================
 from abc import ABC
 from typing import Dict, List
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+
+from mct_quantizers import QuantizationMethod
 
 
 class TrainableQuantizerCandidateConfig:

model_compression_toolkit/trainable_infrastructure/keras/activation_quantizers/lsq/symmetric_lsq.py

@@ -23,9 +23,8 @@ from model_compression_toolkit.constants import SIGNED
 
 from model_compression_toolkit.trainable_infrastructure import TrainingMethod
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
-from mct_quantizers import QuantizationTarget, mark_quantizer
+from mct_quantizers import QuantizationTarget, mark_quantizer, QuantizationMethod
 from model_compression_toolkit.qat.common import THRESHOLD_TENSOR
 from model_compression_toolkit import constants as C
 

model_compression_toolkit/trainable_infrastructure/keras/config_serialization.py

@@ -19,7 +19,7 @@ from enum import Enum
 
 import numpy as np
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.trainable_infrastructure.common.trainable_quantizer_config import \
     TrainableQuantizerActivationConfig, TrainableQuantizerWeightsConfig
 from mct_quantizers.common import constants as C

model_compression_toolkit/xquant/common/model_folding_utils.py

@@ -23,7 +23,8 @@ from model_compression_toolkit.core.graph_prep_runner import graph_preparation_r
 from typing import Any, Callable
 
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import \
+    FrameworkQuantizationCapabilities
 
 
 class ModelFoldingUtils:
@@ -35,19 +36,19 @@ class ModelFoldingUtils:
     def __init__(self,
                  fw_info: FrameworkInfo,
                  fw_impl: FrameworkImplementation,
-                 fw_default_tpc: TargetPlatformCapabilities):
+                 fw_default_fqc: FrameworkQuantizationCapabilities):
         """
         Initialize the ModelFoldingUtils class with framework-specific information, implementation details,
-        and default TPC.
+        and default FQC.
 
         Args:
             fw_info: Framework-specific information.
             fw_impl: Implementation functions for the framework.
-            fw_default_tpc: Default target platform capabilities for the handled framework.
+            fw_default_fqc: Default target platform capabilities for the handled framework.
         """
         self.fw_info = fw_info
         self.fw_impl = fw_impl
-        self.fw_default_tpc = fw_default_tpc
+        self.fw_default_fqc = fw_default_fqc
 
     def create_float_folded_model(self, float_model: Any, representative_dataset: Any = None) -> Any:
         """
@@ -101,5 +102,5 @@ class ModelFoldingUtils:
                                          fw_impl=self.fw_impl,
                                          fw_info=self.fw_info,
                                          quantization_config=DEFAULTCONFIG,
-                                         tpc=self.fw_default_tpc)
+                                         fqc=self.fw_default_fqc)
         return graph

model_compression_toolkit/xquant/keras/keras_report_utils.py

@@ -17,6 +17,8 @@ from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import TENSORFLOW
 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.target_platform_capabilities.targetplatform2framework.attach2keras import \
+    AttachTpcToKeras
 from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
 from model_compression_toolkit.xquant.common.model_folding_utils import ModelFoldingUtils
 from model_compression_toolkit.xquant.common.similarity_calculator import SimilarityCalculator
@@ -27,8 +29,6 @@ from model_compression_toolkit.xquant.keras.similarity_functions import KerasSim
 from model_compression_toolkit.xquant.keras.tensorboard_utils import KerasTensorboardUtils
 from mct_quantizers.keras.metadata import get_metadata
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
-    AttachTpcToKeras
 
 
 class KerasReportUtils(FrameworkReportUtils):
@@ -46,12 +46,12 @@ class KerasReportUtils(FrameworkReportUtils):
         # Set the default Target Platform Capabilities (TPC) for Keras.
         default_tpc = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
         attach2pytorch = AttachTpcToKeras()
-        target_platform_capabilities = attach2pytorch.attach(default_tpc)
+        framework_platform_capabilities = attach2pytorch.attach(default_tpc)
 
         dataset_utils = KerasDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=target_platform_capabilities)
+                                          fw_default_fqc=framework_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py

@@ -16,7 +16,7 @@ from model_compression_toolkit import get_target_platform_capabilities
 from model_compression_toolkit.constants import PYTORCH
 from model_compression_toolkit.core.pytorch.utils import get_working_device
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2pytorch import \
     AttachTpcToPytorch
 
 from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
@@ -44,12 +44,12 @@ class PytorchReportUtils(FrameworkReportUtils):
         # Set the default Target Platform Capabilities (TPC) for PyTorch.
         default_tpc = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
         attach2pytorch = AttachTpcToPytorch()
-        target_platform_capabilities = attach2pytorch.attach(default_tpc)
+        framework_quantization_capabilities = attach2pytorch.attach(default_tpc)
 
         dataset_utils = PytorchDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=target_platform_capabilities)
+                                          fw_default_fqc=framework_quantization_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

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

@@ -1,105 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-import copy
-from enum import Enum
-from functools import partial
-from typing import List, Any
-import numpy as np
-
-from pulp import lpSum
-
-
-def sum_ru_values(ru_vector: np.ndarray, set_constraints: bool = True) -> List[Any]:
-    """
-    Aggregates resource utilization vector to a single resource utilization measure by summing all values.
-
-    Args:
-        ru_vector: A vector with nodes' resource utilization values.
-        set_constraints: A flag for utilizing the method for resource utilization computation of a
-            given config not for LP formalization purposes.
-
-    Returns: A list with an lpSum object for lp problem definition with the vector's sum.
-
-    """
-    if set_constraints:
-        return [lpSum(ru_vector)]
-    return [0] if len(ru_vector) == 0 else [sum(ru_vector)]
-
-
-
-def max_ru_values(ru_vector: np.ndarray, set_constraints: bool = True) -> List[float]:
-    """
-    Aggregates resource utilization vector to allow max constraint in the linear programming problem formalization.
-    In order to do so, we need to define a separate constraint on each value in the resource utilization vector,
-    to be bounded by the target resource utilization.
-
-    Args:
-        ru_vector: A vector with nodes' resource utilization values.
-        set_constraints: A flag for utilizing the method for resource utilization computation of a
-            given config not for LP formalization purposes.
-
-    Returns: A list with the vector's values, to be used to define max constraint
-    in the linear programming problem formalization.
-
-    """
-    if set_constraints:
-        return [ru for ru in ru_vector]
-    return [0] if len(ru_vector) == 0 else [max(ru_vector)]
-
-
-
-def total_ru(ru_tensor: np.ndarray, set_constraints: bool = True) -> List[float]:
-    """
-    Aggregates resource utilization vector to allow weights and activation total utilization constraint in the linear programming
-    problem formalization. In order to do so, we need to define a separate constraint on each activation memory utilization value in
-    the resource utilization vector, combined with the sum weights memory utilization.
-    Note that the given ru_tensor should contain weights and activation utilization values in each entry.
-
-    Args:
-        ru_tensor: A tensor with nodes' resource utilization values for weights and activation.
-        set_constraints: A flag for utilizing the method for resource utilization computation of a
-            given config not for LP formalization purposes.
-
-    Returns: A list with lpSum objects, to be used to define total constraint
-    in the linear programming problem formalization.
-
-    """
-    if set_constraints:
-        weights_ru = lpSum([ru[0] for ru in ru_tensor])
-        return [weights_ru + activation_ru for _, activation_ru in ru_tensor]
-    else:
-        weights_ru = sum([ru[0] for ru in ru_tensor])
-        activation_ru = max([ru[1] for ru in ru_tensor])
-        return [weights_ru + activation_ru]
-
-
-class MpRuAggregation(Enum):
-    """
-    Defines resource utilization aggregation functions that can be used to compute final resource utilization metric.
-    The enum values can be used to call a function on a set of arguments.
-
-     SUM - applies the sum_ru_values function
-
-     MAX - applies the max_ru_values function
-
-     TOTAL - applies the total_ru function
-
-    """
-    SUM = partial(sum_ru_values)
-    MAX = partial(max_ru_values)
-    TOTAL = partial(total_ru)
-
-    def __call__(self, *args):
-        return self.value(*args)

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

@@ -1,33 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-from typing import NamedTuple
-
-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.ru_aggregation_methods import MpRuAggregation
-from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.ru_methods import MpRuMetric
-
-
-# When adding a RUTarget that we want to consider in our mp search,
-# a matching pair of resource_utilization_tools computation function and a resource_utilization_tools
-# aggregation function should be added to this dictionary
-class RuFunctions(NamedTuple):
-    metric_fn: MpRuMetric
-    aggregate_fn: MpRuAggregation
-
-
-ru_functions_mapping = {RUTarget.WEIGHTS: RuFunctions(MpRuMetric.WEIGHTS_SIZE, MpRuAggregation.SUM),
-                        RUTarget.ACTIVATION: RuFunctions(MpRuMetric.ACTIVATION_MAXCUT_SIZE, MpRuAggregation.MAX),
-                        RUTarget.TOTAL: RuFunctions(MpRuMetric.TOTAL_WEIGHTS_ACTIVATION_SIZE, MpRuAggregation.TOTAL),
-                        RUTarget.BOPS: RuFunctions(MpRuMetric.BOPS_COUNT, MpRuAggregation.SUM)}