mct-nightly 2.2.0.20250106.546__py3-none-any.whl → 2.2.0.20250107.134735__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tp_model.py

@@ -167,38 +167,70 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    operator_set.append(schema.OperatorsSet(name="NoQuantization",
-                           qc_options=default_configuration_options.clone_and_edit(enable_activation_quantization=False)
-                           .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
+    no_quantization_config = (default_configuration_options.clone_and_edit(enable_activation_quantization=False)
+                              .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.STACK, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.UNSTACK, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.DROPOUT, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.FLATTEN, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.SPLIT_CHUNK, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.GET_ITEM, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.RESHAPE, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.UNSQUEEZE, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.SIZE, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.PERMUTE, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.TRANSPOSE, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.EQUAL, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.ARGMAX, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.GATHER, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.TOPK, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.SQUEEZE, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MAXPOOL, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.PAD, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.ZERO_PADDING2D, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.CAST, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.COMBINED_NON_MAX_SUPPRESSION, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.FAKE_QUANT, qc_options=no_quantization_config))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.SSD_POST_PROCESS, qc_options=no_quantization_config))
 
     # Define operator sets that use mixed_precision_configuration_options:
-    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
-    fc = schema.OperatorsSet(name="FullyConnected", qc_options=mixed_precision_configuration_options)
+    conv = schema.OperatorsSet(name=schema.OperatorSetNames.CONV, qc_options=mixed_precision_configuration_options)
+    conv_transpose = schema.OperatorsSet(name=schema.OperatorSetNames.CONV_TRANSPOSE, qc_options=mixed_precision_configuration_options)
+    depthwise_conv = schema.OperatorsSet(name=schema.OperatorSetNames.DEPTHWISE_CONV, qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name=schema.OperatorSetNames.FULLY_CONNECTED, qc_options=mixed_precision_configuration_options)
 
     # Define operations sets without quantization configuration
     # options (useful for creating fusing patterns, for example):
-    any_relu = schema.OperatorsSet(name="AnyReLU")
-    add = schema.OperatorsSet(name="Add")
-    sub = schema.OperatorsSet(name="Sub")
-    mul = schema.OperatorsSet(name="Mul")
-    div = schema.OperatorsSet(name="Div")
-    prelu = schema.OperatorsSet(name="PReLU")
-    swish = schema.OperatorsSet(name="Swish")
-    sigmoid = schema.OperatorsSet(name="Sigmoid")
-    tanh = schema.OperatorsSet(name="Tanh")
-
-    operator_set.extend([conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, tanh])
+    relu = schema.OperatorsSet(name=schema.OperatorSetNames.RELU)
+    relu6 = schema.OperatorsSet(name=schema.OperatorSetNames.RELU6)
+    leaky_relu = schema.OperatorsSet(name=schema.OperatorSetNames.LEAKY_RELU)
+    prelu = schema.OperatorsSet(name=schema.OperatorSetNames.PRELU)
+    add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD)
+    sub = schema.OperatorsSet(name=schema.OperatorSetNames.SUB)
+    mul = schema.OperatorsSet(name=schema.OperatorSetNames.MUL)
+    div = schema.OperatorsSet(name=schema.OperatorSetNames.DIV)
+    swish = schema.OperatorsSet(name=schema.OperatorSetNames.SWISH)
+    hard_swish = schema.OperatorsSet(name=schema.OperatorSetNames.HARDSWISH)
+    sigmoid = schema.OperatorsSet(name=schema.OperatorSetNames.SIGMOID)
+    tanh = schema.OperatorsSet(name=schema.OperatorSetNames.TANH)
+    hard_tanh = schema.OperatorsSet(name=schema.OperatorSetNames.HARD_TANH)
+
+    operator_set.extend([conv, conv_transpose, depthwise_conv, fc, relu, relu6, leaky_relu, add, sub, mul, div, prelu, swish,
+                         hard_swish, sigmoid, tanh, hard_tanh])
+    any_relu = schema.OperatorSetConcat(operators_set=[relu, relu6, leaky_relu, hard_tanh])
     # Combine multiple operators into a single operator to avoid quantization between
     # them. To do this we define fusing patterns using the OperatorsSets that were created.
     # To group multiple sets with regard to fusing, an OperatorSetConcat can be created
-    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
-    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[relu, relu6, leaky_relu, hard_tanh, swish, hard_swish, prelu, sigmoid, tanh])
+    conv_types = schema.OperatorSetConcat(operators_set=[conv, conv_transpose, depthwise_conv])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[relu, relu6, leaky_relu, hard_tanh, swish, hard_swish, sigmoid])
     any_binary = schema.OperatorSetConcat(operators_set=[add, sub, mul, div])
 
     # ------------------- #
     # Fusions
     # ------------------- #
-    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv_types, activations_after_conv_to_fuse)))
     fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
     fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 

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

@@ -15,8 +15,12 @@
 from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
 from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model, generate_tp_model, get_op_quantization_configs
 if FOUND_TF:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc_keras import get_keras_tpc as get_keras_tpc_latest
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc_keras import generate_keras_tpc
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model 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, get_tpc_model as generate_keras_tpc
 if FOUND_TORCH:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc_pytorch import get_pytorch_tpc as get_pytorch_tpc_latest
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc_pytorch import generate_pytorch_tpc
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model 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, get_tpc_model as generate_pytorch_tpc

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tp_model.py

@@ -148,19 +148,29 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    conv = schema.OperatorsSet(name="Conv")
-    batchnorm = schema.OperatorsSet(name="BatchNorm")
-    relu = schema.OperatorsSet(name="Relu")
-    linear = schema.OperatorsSet(name="Linear")
+    conv = schema.OperatorsSet(name=schema.OperatorSetNames.CONV)
+    conv_depthwise = schema.OperatorsSet(name=schema.OperatorSetNames.DEPTHWISE_CONV)
+    conv_transpose = schema.OperatorsSet(name=schema.OperatorSetNames.CONV_TRANSPOSE)
+    batchnorm = schema.OperatorsSet(name=schema.OperatorSetNames.BATCH_NORM)
+    relu = schema.OperatorsSet(name=schema.OperatorSetNames.RELU)
+    relu6 = schema.OperatorsSet(name=schema.OperatorSetNames.RELU6)
+
+    hard_tanh = schema.OperatorsSet(name=schema.OperatorSetNames.HARD_TANH)
+    linear = schema.OperatorsSet(name=schema.OperatorSetNames.FULLY_CONNECTED)
+
+    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])
 
-    operator_set.extend([conv, batchnorm, relu, linear])
     # ------------------- #
     # Fusions
     # ------------------- #
-    fusing_patterns.append(schema.Fusing(operator_groups=(conv, batchnorm, relu)))
-    fusing_patterns.append(schema.Fusing(operator_groups=(conv, batchnorm)))
-    fusing_patterns.append(schema.Fusing(operator_groups=(conv, relu)))
-    fusing_patterns.append(schema.Fusing(operator_groups=(linear, relu)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv_opset_concat, batchnorm, relu_opset_concat)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv_opset_concat, batchnorm)))
+    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.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):

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

@@ -15,8 +15,11 @@
 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
 if FOUND_TF:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc_keras import get_keras_tpc as get_keras_tpc_latest
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc_keras import generate_keras_tpc
+    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.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.tpc_pytorch import get_pytorch_tpc as get_pytorch_tpc_latest
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc_pytorch import generate_pytorch_tpc
+    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.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

@@ -18,8 +18,7 @@ import model_compression_toolkit as mct
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 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 TargetPlatformModel, Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
@@ -137,8 +136,7 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     # of possible configurations to consider when quantizing a set of operations (in mixed-precision, for example).
     # If the QuantizationConfigOptions contains only one configuration,
     # this configuration will be used for the operation quantization:
-    default_configuration_options = schema.QuantizationConfigOptions(
-        quantization_configurations=tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([default_config]))
 
     # In TFLite, the quantized operator specifications constraint operators quantization
     # differently. For more details:
@@ -146,44 +144,60 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    operator_set.append(schema.OperatorsSet(name="NoQuantization",
-                                            qc_options=default_configuration_options.clone_and_edit(
-                                                quantization_preserving=True)))
-
-    fc = schema.OperatorsSet(name="FullyConnected",
-                             qc_options=default_configuration_options.clone_and_edit_weight_attribute(
-                                 weights_per_channel_threshold=False))
-
-    operator_set.append(schema.OperatorsSet(name="L2Normalization",
+    quant_preserving = default_configuration_options.clone_and_edit(quantization_preserving=True)
+
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.UNSTACK, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.TRANSPOSE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.GATHER, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.RESHAPE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MAXPOOL, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.AVGPOOL, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.STRIDED_SLICE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.CONCATENATE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MUL, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MIN, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MAX, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.ZERO_PADDING2D, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.RESIZE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.PAD, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.FOLD, qc_options=quant_preserving))
+
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.L2NORM,
                                             qc_options=default_configuration_options.clone_and_edit(
                                                 fixed_zero_point=0, fixed_scale=1 / 128)))
-    operator_set.append(schema.OperatorsSet(name="LogSoftmax",
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.LOG_SOFTMAX,
                                             qc_options=default_configuration_options.clone_and_edit(
                                                 fixed_zero_point=127, fixed_scale=16 / 256)))
-    operator_set.append(schema.OperatorsSet(name="Tanh",
-                                            qc_options=default_configuration_options.clone_and_edit(
-                                                fixed_zero_point=0, fixed_scale=1 / 128)))
-    operator_set.append(schema.OperatorsSet(name="Softmax",
-                                            qc_options=default_configuration_options.clone_and_edit(
-                                                fixed_zero_point=-128, fixed_scale=1 / 256)))
-    operator_set.append(schema.OperatorsSet(name="Logistic",
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.SOFTMAX,
                                             qc_options=default_configuration_options.clone_and_edit(
                                                 fixed_zero_point=-128, fixed_scale=1 / 256)))
 
-    conv2d = schema.OperatorsSet(name="Conv2d")
-    kernel = schema.OperatorSetConcat(operators_set=[conv2d, fc])
+    sigmoid = schema.OperatorsSet(name=schema.OperatorSetNames.SIGMOID,
+                                  qc_options=default_configuration_options.clone_and_edit_weight_attribute(
+                                      weights_per_channel_threshold=False))
+    tanh = schema.OperatorsSet(name=schema.OperatorSetNames.TANH,
+                               qc_options=default_configuration_options.clone_and_edit(
+                                   fixed_zero_point=-128, fixed_scale=1 / 256))
+    fc = schema.OperatorsSet(name=schema.OperatorSetNames.FULLY_CONNECTED,
+                             qc_options=default_configuration_options.clone_and_edit_weight_attribute(
+                                 weights_per_channel_threshold=False))
+    squeeze = schema.OperatorsSet(name=schema.OperatorSetNames.SQUEEZE,
+                                  qc_options=default_configuration_options.clone_and_edit(
+                                      quantization_preserving=True))
+
+    conv2d = schema.OperatorsSet(name=schema.OperatorSetNames.CONV)
+    relu = schema.OperatorsSet(name=schema.OperatorSetNames.RELU)
+    relu6 = schema.OperatorsSet(name=schema.OperatorSetNames.RELU6)
+    elu = schema.OperatorsSet(name=schema.OperatorSetNames.ELU)
+    batch_norm = schema.OperatorsSet(name=schema.OperatorSetNames.BATCH_NORM)
+    add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD)
+    bias_add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD_BIAS)
 
-    relu = schema.OperatorsSet(name="Relu")
-    elu = schema.OperatorsSet(name="Elu")
+    kernel = schema.OperatorSetConcat(operators_set=[conv2d, fc])
     activations_to_fuse = schema.OperatorSetConcat(operators_set=[relu, elu])
 
-    batch_norm = schema.OperatorsSet(name="BatchNorm")
-    bias_add = schema.OperatorsSet(name="BiasAdd")
-    add = schema.OperatorsSet(name="Add")
-    squeeze = schema.OperatorsSet(name="Squeeze",
-                                  qc_options=default_configuration_options.clone_and_edit(
-                                      quantization_preserving=True))
-    operator_set.extend([fc, conv2d, relu, elu, batch_norm, bias_add, add, squeeze])
+    operator_set.extend([fc, conv2d, relu, relu6, tanh, sigmoid, batch_norm, add, bias_add, elu, squeeze])
+
     # ------------------- #
     # Fusions
     # ------------------- #

model_compression_toolkit/xquant/keras/keras_report_utils.py

@@ -13,11 +13,11 @@
 #  limitations under the License.
 #  ==============================================================================
 
-
+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.xquant.common.framework_report_utils import FrameworkReportUtils
-from model_compression_toolkit.ptq.keras.quantization_facade import DEFAULT_KERAS_TPC
 from model_compression_toolkit.xquant.common.model_folding_utils import ModelFoldingUtils
 from model_compression_toolkit.xquant.common.similarity_calculator import SimilarityCalculator
 from model_compression_toolkit.xquant.keras.dataset_utils import KerasDatasetUtils
@@ -26,6 +26,9 @@ from model_compression_toolkit.xquant.keras.model_analyzer import KerasModelAnal
 from model_compression_toolkit.xquant.keras.similarity_functions import KerasSimilarityFunctions
 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):
@@ -40,10 +43,15 @@ class KerasReportUtils(FrameworkReportUtils):
         fw_info = DEFAULT_KERAS_INFO
         fw_impl = KerasImplementation()
 
+        # 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)
+
         dataset_utils = KerasDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=DEFAULT_KERAS_TPC)
+                                          fw_default_tpc=target_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py

@@ -12,9 +12,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #  ==============================================================================
+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 \
+    AttachTpcToPytorch
 
-from model_compression_toolkit.ptq.pytorch.quantization_facade import DEFAULT_PYTORCH_TPC
 from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
 from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
 from model_compression_toolkit.core.pytorch.pytorch_implementation import PytorchImplementation
@@ -37,11 +41,15 @@ class PytorchReportUtils(FrameworkReportUtils):
         """
         fw_info = DEFAULT_PYTORCH_INFO
         fw_impl = PytorchImplementation()
+        # 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)
 
         dataset_utils = PytorchDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=DEFAULT_PYTORCH_TPC)
+                                          fw_default_tpc=target_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py

@@ -1,98 +0,0 @@
-# Copyright 2023 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 model_compression_toolkit.logger import Logger
-
-from model_compression_toolkit.constants import TENSORFLOW, PYTORCH
-from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
-from model_compression_toolkit.target_platform_capabilities.constants import LATEST
-
-
-def get_tpc_dict_by_fw(fw_name):
-    tpc_models_dict = None
-    if fw_name == TENSORFLOW:
-        ###############################
-        # Build Tensorflow TPC models
-        ###############################
-        if FOUND_TF:
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.latest import \
-                get_keras_tpc_latest
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_lut.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_pot.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1_pot
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v2
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2_lut.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v2_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v3
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3_lut.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v3_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v4
-
-            # Keras: TPC versioning
-            tpc_models_dict = {'v1': get_keras_tpc_v1,
-                               'v1_lut': get_keras_tpc_v1_lut,
-                               'v1_pot': get_keras_tpc_v1_pot,
-                               'v2': get_keras_tpc_v2,
-                               'v2_lut': get_keras_tpc_v2_lut,
-                               'v3': get_keras_tpc_v3,
-                               'v3_lut': get_keras_tpc_v3_lut,
-                               'v4': get_keras_tpc_v4,
-                               LATEST: get_keras_tpc_latest}
-    elif fw_name == PYTORCH:
-        ###############################
-        # Build Pytorch TPC models
-        ###############################
-        if FOUND_TORCH:
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.latest import \
-                get_pytorch_tpc_latest
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_pot.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1_pot
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_lut.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v2
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2_lut.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v2_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v3
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3_lut.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v3_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v4
-
-            # Pytorch: TPC versioning
-            tpc_models_dict = {'v1': get_pytorch_tpc_v1,
-                               'v1_lut': get_pytorch_tpc_v1_lut,
-                               'v1_pot': get_pytorch_tpc_v1_pot,
-                               'v2': get_pytorch_tpc_v2,
-                               'v2_lut': get_pytorch_tpc_v2_lut,
-                               'v3': get_pytorch_tpc_v3,
-                               'v3_lut': get_pytorch_tpc_v3_lut,
-                               'v4': get_pytorch_tpc_v4,
-                               LATEST: get_pytorch_tpc_latest}
-    if tpc_models_dict is not None:
-        return tpc_models_dict
-    else:
-        Logger.critical(f'Framework {fw_name} is not supported in imx500 or the relevant packages are not '
-                        f'installed. Please make sure the relevant packages are installed when using MCT for optimizing'
-                        f' a {fw_name} model. For Tensorflow, please install tensorflow. For PyTorch, please install '
-                        f'torch.')  # pragma: no cover

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tpc_keras.py

@@ -1,129 +0,0 @@
-# Copyright 2023 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 tensorflow as tf
-from packaging import version
-
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
-from model_compression_toolkit.defaultdict import DefaultDict
-from model_compression_toolkit.verify_packages import FOUND_SONY_CUSTOM_LAYERS
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, KERAS_DEPTHWISE_KERNEL, \
-    KERAS_KERNEL, BIAS_ATTR, BIAS
-
-if FOUND_SONY_CUSTOM_LAYERS:
-    from sony_custom_layers.keras.object_detection.ssd_post_process import SSDPostProcess
-
-if version.parse(tf.__version__) >= version.parse("2.13"):
-    from keras.src.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
-        MaxPooling2D, Activation, ReLU, Add, Subtract, Multiply, PReLU, Flatten, Cropping2D, LeakyReLU, Permute, \
-        Conv2DTranspose
-else:
-    from keras.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
-        MaxPooling2D, Activation, ReLU, Add, Subtract, Multiply, PReLU, Flatten, Cropping2D, LeakyReLU, Permute, \
-        Conv2DTranspose
-
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tp_model import get_tp_model
-import model_compression_toolkit as mct
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1 import __version__ as TPC_VERSION
-
-tp = mct.target_platform
-
-
-def get_keras_tpc() -> tp.TargetPlatformCapabilities:
-    """
-    get a Keras TargetPlatformCapabilities object with default operation sets to layers mapping.
-    Returns: a Keras TargetPlatformCapabilities object for the given TargetPlatformModel.
-    """
-    imx500_tpc_tp_model = get_tp_model()
-    return generate_keras_tpc(name='imx500_tpc_keras_tpc', tp_model=imx500_tpc_tp_model)
-
-
-def generate_keras_tpc(name: str, tp_model: TargetPlatformModel):
-    """
-    Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
-
-    Args:
-        name: Name of the TargetPlatformCapabilities.
-        tp_model: TargetPlatformModel object.
-
-    Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
-    """
-
-    keras_tpc = tp.TargetPlatformCapabilities(tp_model)
-
-    no_quant_list = [Reshape,
-                     tf.reshape,
-                     Permute,
-                     tf.transpose,
-                     Flatten,
-                     Cropping2D,
-                     ZeroPadding2D,
-                     Dropout,
-                     MaxPooling2D,
-                     tf.split,
-                     tf.quantization.fake_quant_with_min_max_vars,
-                     tf.math.argmax,
-                     tf.shape,
-                     tf.math.equal,
-                     tf.gather,
-                     tf.cast,
-                     tf.unstack,
-                     tf.compat.v1.gather,
-                     tf.nn.top_k,
-                     tf.__operators__.getitem,
-                     tf.image.combined_non_max_suppression,
-                     tf.compat.v1.shape]
-
-    if FOUND_SONY_CUSTOM_LAYERS:
-        no_quant_list.append(SSDPostProcess)
-
-    with keras_tpc:
-        tp.OperationsSetToLayers("NoQuantization", no_quant_list)
-        tp.OperationsSetToLayers("Conv",
-                                 [Conv2D,
-                                  DepthwiseConv2D,
-                                  Conv2DTranspose,
-                                  tf.nn.conv2d,
-                                  tf.nn.depthwise_conv2d,
-                                  tf.nn.conv2d_transpose],
-                                 # we provide attributes mapping that maps each layer type in the operations set
-                                 # that has weights attributes with provided quantization config (in the tp model) to
-                                 # its framework-specific attribute name.
-                                 # note that a DefaultDict should be provided if not all the layer types in the
-                                 # operation set are provided separately in the mapping.
-                                 attr_mapping={
-                                     KERNEL_ATTR: DefaultDict({
-                                         DepthwiseConv2D: KERAS_DEPTHWISE_KERNEL,
-                                         tf.nn.depthwise_conv2d: KERAS_DEPTHWISE_KERNEL}, default_value=KERAS_KERNEL),
-                                     BIAS_ATTR: DefaultDict(default_value=BIAS)})
-        tp.OperationsSetToLayers("FullyConnected", [Dense],
-                                 attr_mapping={KERNEL_ATTR: DefaultDict(default_value=KERAS_KERNEL),
-                                               BIAS_ATTR: DefaultDict(default_value=BIAS)})
-        tp.OperationsSetToLayers("AnyReLU", [tf.nn.relu,
-                                             tf.nn.relu6,
-                                             tf.nn.leaky_relu,
-                                             ReLU,
-                                             LeakyReLU,
-                                             tp.LayerFilterParams(Activation, activation="relu"),
-                                             tp.LayerFilterParams(Activation, activation="leaky_relu")])
-        tp.OperationsSetToLayers("Add", [tf.add, Add])
-        tp.OperationsSetToLayers("Sub", [tf.subtract, Subtract])
-        tp.OperationsSetToLayers("Mul", [tf.math.multiply, Multiply])
-        tp.OperationsSetToLayers("Div", [tf.math.divide])
-        tp.OperationsSetToLayers("PReLU", [PReLU])
-        tp.OperationsSetToLayers("Swish", [tf.nn.swish, tp.LayerFilterParams(Activation, activation="swish")])
-        tp.OperationsSetToLayers("Sigmoid", [tf.nn.sigmoid, tp.LayerFilterParams(Activation, activation="sigmoid")])
-        tp.OperationsSetToLayers("Tanh", [tf.nn.tanh, tp.LayerFilterParams(Activation, activation="tanh")])
-
-    return keras_tpc