Revert "Merge branch 'feature_tpc_improvement' into feature_tpc_improvement"

This reverts commit 05f4868, reversing
changes made to 63b4793.

Author: KazunoriSumiya

model_compression_toolkit/verify_packages.py

@@ -30,4 +30,4 @@
 FOUND_TORCHVISION = importlib.util.find_spec("torchvision") is not None
 FOUND_ONNX = importlib.util.find_spec("onnx") is not None
 FOUND_ONNXRUNTIME = importlib.util.find_spec("onnxruntime") is not None
-
+FOUND_TPC = importlib.util.find_spec("edgemdt_tpc") is not None

model_compression_toolkit/wrapper/constants.py

@@ -13,10 +13,13 @@
 # limitations under the License.
 # ==============================================================================
 
-
 # TPC parameters
 FW_NAME = 'fw_name'
-SDSP_VERSION = 'sdsp_version'
+TARGET_PLATFORM_NAME = 'target_platform_name'
+TARGET_PLATFORM_VERSION = 'target_platform_version'
+TPC_VERSION = 'tpc_version'
+DEVICE_TYPE = 'device_type'
+EXTENDED_VERSION = 'extended_version'
 
 # MixedPrecisionQuantizationConfig parameters
 NUM_OF_IMAGES = 'num_of_images'

model_compression_toolkit/wrapper/mct_wrapper.py

@@ -16,8 +16,10 @@
 from typing import Dict, Any, List, Optional, Tuple
 import model_compression_toolkit as mct
 from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.verify_packages import FOUND_TPC
 from model_compression_toolkit.wrapper.constants import (
-    REPRESENTATIVE_DATA_GEN, CORE_CONFIG, FW_NAME, SDSP_VERSION,
+    REPRESENTATIVE_DATA_GEN, CORE_CONFIG, FW_NAME, TARGET_PLATFORM_VERSION,
+    TARGET_PLATFORM_NAME, TPC_VERSION, DEVICE_TYPE, EXTENDED_VERSION,
     NUM_OF_IMAGES, USE_HESSIAN_BASED_SCORES, IN_MODEL, IN_MODULE, MODEL,
     TARGET_PLATFORM_CAPABILITIES, TARGET_RESOURCE_UTILIZATION,
     ACTIVATION_ERROR_METHOD, WEIGHTS_ERROR_METHOD, WEIGHTS_BIAS_CORRECTION,
@@ -54,6 +56,8 @@ def __init__(self):
            :header: "Parameter Key", "Default Value", "Description"
            :widths: 30, 30, 40
 
+           "target_platform_version", "'v1'", "Target platform version (use_internal_tpc=True)"
+           "tpc_version", "'5.0'", "TPC version (use_internal_tpc=False)"
            "activation_error_method", "mct.core.QuantizationErrorMethod.MSE", "Activation quantization error method"
            "weights_bias_correction", "True", "Enable weights bias correction"
            "z_threshold", "float('inf')", "Z-threshold for quantization"
@@ -67,6 +71,8 @@ def __init__(self):
            :header: "Parameter Key", "Default Value", "Description"
            :widths: 30, 30, 40
 
+           "target_platform_version", "'v1'", "Target platform version (use_internal_tpc=True)"
+           "tpc_version", "'5.0'", "TPC version (use_internal_tpc=False)"
            "num_of_images", "5", "Number of images for mixed precision"
            "use_hessian_based_scores", "False", "Use Hessian-based scores for mixed precision"
            "weights_compression_ratio", "None", "Weights compression ratio for resource util"
@@ -78,6 +84,8 @@ def __init__(self):
            :header: "Parameter Key", "Default Value", "Description"
            :widths: 30, 30, 40
 
+           "target_platform_version", "'v1'", "Target platform version (use_internal_tpc=True)"
+           "tpc_version", "'5.0'", "TPC version (use_internal_tpc=False)"
            "n_epochs", "5", "Number of training epochs for GPTQ"
            "optimizer", "None", "Optimizer for GPTQ training"
            "save_model_path", "'./qmodel.keras' / './qmodel.onnx'", "Path to save quantized model (Keras/Pytorch)"
@@ -88,6 +96,8 @@ def __init__(self):
            :header: "Parameter Key", "Default Value", "Description"
            :widths: 30, 30, 40
 
+           "target_platform_version", "'v1'", "Target platform version (use_internal_tpc=True)"
+           "tpc_version", "'5.0'", "TPC version (use_internal_tpc=False)"
            "n_epochs", "5", "Number of training epochs for GPTQ"
            "optimizer", "None", "Optimizer for GPTQ training"
            "num_of_images", "5", "Number of images for mixed precision"
@@ -99,7 +109,8 @@ def __init__(self):
         self.params: Dict[str, Any] = {
             # TPC
             FW_NAME: 'pytorch',
-            SDSP_VERSION: '3.14',
+            TARGET_PLATFORM_VERSION: 'v1',
+            TPC_VERSION: '5.0',
 
             # QuantizationConfig
             ACTIVATION_ERROR_METHOD: mct.core.QuantizationErrorMethod.MSE,
@@ -129,8 +140,9 @@ def __init__(self):
 
     def _initialize_and_validate(self, float_model: Any,
                                  representative_dataset: Optional[Any],
-                                 framework: str,
                                  method: str,
+                                 framework: str,
+                                 use_internal_tpc: bool,
                                  use_mixed_precision: bool
                                  ) -> None:
         """
@@ -139,8 +151,9 @@ def _initialize_and_validate(self, float_model: Any,
         Args:
             float_model: The float model to be quantized.
             representative_dataset (Callable, np.array, tf.Tensor): Representative dataset for calibration.
-            framework (str): Target framework ('tensorflow', 'pytorch').
             method (str): Quantization method ('PTQ', 'GPTQ', 'LQPTQ').
+            framework (str): Target framework ('tensorflow', 'pytorch').
+            use_internal_tpc (bool): Whether to use MCT's built-in TPC.
             use_mixed_precision (bool): Whether to use mixed-precision quantization.
 
         Raises:
@@ -159,25 +172,29 @@ def _initialize_and_validate(self, float_model: Any,
         self.representative_dataset = representative_dataset
         self.method = method
         self.framework = framework
+        self.use_internal_tpc = use_internal_tpc
         self.use_mixed_precision = use_mixed_precision
 
         # Keep only the parameters you need for the quantization mode
         if method == 'PTQ':
             if not use_mixed_precision:
-                allowed_keys = [ FW_NAME, SDSP_VERSION, ACTIVATION_ERROR_METHOD, WEIGHTS_BIAS_CORRECTION, 
+                allowed_keys = [ FW_NAME, TARGET_PLATFORM_VERSION, TPC_VERSION, 
+                                 ACTIVATION_ERROR_METHOD, WEIGHTS_BIAS_CORRECTION, 
                                  Z_THRESHOLD, LINEAR_COLLAPSING, RESIDUAL_COLLAPSING,
                                  SAVE_MODEL_PATH ]
             else:
-                allowed_keys = [ FW_NAME, SDSP_VERSION, NUM_OF_IMAGES, USE_HESSIAN_BASED_SCORES, 
+                allowed_keys = [ FW_NAME, TARGET_PLATFORM_VERSION, TPC_VERSION, 
+                                 NUM_OF_IMAGES, USE_HESSIAN_BASED_SCORES, 
                                  WEIGHTS_COMPRESSION_RATIO, SAVE_MODEL_PATH ]
         else:
             if not use_mixed_precision:
-                allowed_keys = [FW_NAME, SDSP_VERSION, N_EPOCHS, OPTIMIZER,
-                                SAVE_MODEL_PATH]
+                allowed_keys = [ FW_NAME, TARGET_PLATFORM_VERSION, TPC_VERSION, 
+                                 N_EPOCHS, OPTIMIZER, SAVE_MODEL_PATH ]
             else:
-                allowed_keys = [FW_NAME, SDSP_VERSION, N_EPOCHS, OPTIMIZER,
-                                NUM_OF_IMAGES, USE_HESSIAN_BASED_SCORES,
-                                WEIGHTS_COMPRESSION_RATIO, SAVE_MODEL_PATH]
+                allowed_keys = [ FW_NAME, TARGET_PLATFORM_VERSION, TPC_VERSION, 
+                                 N_EPOCHS, OPTIMIZER, NUM_OF_IMAGES, 
+                                 USE_HESSIAN_BASED_SCORES, WEIGHTS_COMPRESSION_RATIO, 
+                                 SAVE_MODEL_PATH ]
 
         self.params = { k: v for k, v in self.params.items() if k in allowed_keys }
 
@@ -296,18 +313,36 @@ def _select_argname(self) -> None:
 
     def _get_tpc(self) -> None:
         """
-        Configure Target Platform Capabilities (TPC).
+        Configure Target Platform Capabilities (TPC) based on selected option.
 
-        Sets up TPC configuration for the target platform.
+        Sets up either MCT's built-in TPC or external EdgeMDT TPC configuration
+        for the IMX500 target platform.
 
         Note:
             This method sets self.tpc attribute with the configured TPC object.
         """
-        # Get default TPC for the framework
-        params_TPC = {
-            SDSP_VERSION: self.params[SDSP_VERSION]
-        }
-        self.tpc = mct.get_target_platform_capabilities_sdsp(**params_TPC)
+        if self.use_internal_tpc:
+            # Use MCT's built-in TPC configuration
+            params_TPC = {
+                FW_NAME: self.params[FW_NAME],
+                TARGET_PLATFORM_NAME: 'imx500',
+                TARGET_PLATFORM_VERSION: self.params[TARGET_PLATFORM_VERSION],
+            }
+            # Get TPC from MCT framework
+            self.tpc = mct.get_target_platform_capabilities(**params_TPC)
+        else:
+            if FOUND_TPC:
+                import edgemdt_tpc
+                # Use external EdgeMDT TPC configuration
+                params_TPC = {
+                    TPC_VERSION: self.params[TPC_VERSION],
+                    DEVICE_TYPE: 'imx500',
+                    EXTENDED_VERSION: None
+                }
+                # Get TPC from EdgeMDT framework
+                self.tpc = edgemdt_tpc.get_target_platform_capabilities(**params_TPC)
+            else:
+                raise Exception("EdgeMDT TPC module is not available.")
 
     def _setting_PTQ_mixed_precision(self) -> Dict[str, Any]:
         """
@@ -475,6 +510,8 @@ def _export_model(self, quantized_model: Any) -> None:
             params_export = {
                 'model': quantized_model,
                 'save_model_path': self.params['save_model_path'],
+                'serialization_format': (mct.exporter.KerasExportSerializationFormat.KERAS),
+                'quantization_format': (mct.exporter.QuantizationFormat.FAKELY_QUANT)
             }
         elif self.framework == 'pytorch':
             params_export = {
@@ -486,8 +523,9 @@ def _export_model(self, quantized_model: Any) -> None:
 
     def quantize_and_export(self, float_model: Any,
                             representative_dataset: Any,
-                            framework: str = 'pytorch',
                             method: str = 'PTQ',
+                            framework: str = 'pytorch',
+                            use_internal_tpc: bool = True,
                             use_mixed_precision: bool = False,
                             param_items: Optional[List[List[Any]]] = None
                             ) -> Tuple[bool, Any]:
@@ -498,10 +536,12 @@ def quantize_and_export(self, float_model: Any,
             float_model: The float model to be quantized.
             representative_dataset (Callable, np.array, tf.Tensor):
                 Representative dataset for calibration.
-            framework (str): 'tensorflow' or 'pytorch'.
-                Default: 'pytorch'
             method (str): Quantization method, e.g., 'PTQ' or 'GPTQ'.
                 Default: 'PTQ'
+            framework (str): 'tensorflow' or 'pytorch'.
+                Default: 'pytorch'
+            use_internal_tpc (bool): Whether to use internal_tpc.
+                Default: True
             use_mixed_precision (bool): Whether to use mixed-precision
                 quantization. Default: False
             param_items (list): List of parameter settings.
@@ -525,10 +565,11 @@ def quantize_and_export(self, float_model: Any,
 
             >>> wrapper = mct.MCTWrapper()
 
-            set framework, method, and other parameters
+            set method, framework, and other parameters
 
-            >>> framework = 'tensorflow'
             >>> method = 'PTQ'
+            >>> framework = 'tensorflow'
+            >>> use_internal_tpc = True
             >>> use_mixed_precision = False
 
             set parameters if needed
@@ -540,17 +581,19 @@ def quantize_and_export(self, float_model: Any,
             >>> flag, quantized_model = wrapper.quantize_and_export(
             ...     float_model=float_model,
             ...     representative_dataset=representative_dataset,
-            ...     framework=framework,
             ...     method=method,
+            ...     framework=framework,
+            ...     use_internal_tpc=use_internal_tpc,
             ...     use_mixed_precision=use_mixed_precision,
             ...     param_items=param_items
             ... )
 
         """
         try:
             # Step 1: Initialize and validate all input parameters
-            self._initialize_and_validate( float_model, representative_dataset, 
-                                          framework, method, use_mixed_precision)
+            self._initialize_and_validate(
+                float_model, representative_dataset, method, framework,
+                use_internal_tpc, use_mixed_precision)
 
             # Step 2: Apply custom parameter modifications
             self._modify_params(param_items)

tests_pytest/keras_tests/e2e_tests/wrapper/test_mct_wrapper_keras_e2e.py

@@ -128,13 +128,14 @@ def PTQ_Keras(float_model: keras.Model) -> Tuple[bool, keras.Model]:
         predefined target platform capabilities for optimal quantization settings.
         """
         # Quantization method configuration
-        framework = 'tensorflow'
         method = 'PTQ'
+        framework = 'tensorflow'
+        use_internal_tpc = True
         use_mixed_precision = False
 
         # Configure quantization parameters for optimal model performance
         param_items = [
-            ['sdsp_version', '3.14'],  # The version of the SDSP converter.
+            ['target_platform_version', 'v1'],  # The version of the TPC to use.
             ['activation_error_method', QuantizationErrorMethod.MSE],  # ErrorMethod.
             ['weights_bias_correction', True],  # Enable bias correction
             ['z_threshold', float('inf')],  # Z threshold
@@ -145,7 +146,7 @@ def PTQ_Keras(float_model: keras.Model) -> Tuple[bool, keras.Model]:
 
         # Execute quantization using MCTWrapper
         wrapper = mct.wrapper.mct_wrapper.MCTWrapper()
-        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, framework, method, use_mixed_precision, param_items)
+        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, method, framework, use_internal_tpc, use_mixed_precision, param_items)
         return flag, quantized_model
 
     #########################################################################
@@ -159,13 +160,14 @@ def PTQ_Keras_mixed_precision(float_model: keras.Model) -> Tuple[bool, keras.Mod
         optimizing the trade-off between model size and accuracy.
         """
         # Quantization method configuration
-        framework = 'tensorflow'
         method = 'PTQ'
+        framework = 'tensorflow'
+        use_internal_tpc = True
         use_mixed_precision = True
 
         # Configure mixed precision parameters for optimal compression
         param_items = [
-            ['sdsp_version', '3.14'],  # The version of the SDSP converter.
+            ['target_platform_version', 'v1'],  # The version of the TPC to use.
             ['num_of_images', 5],  # Number of images
             ['use_hessian_based_scores', False],  # Use Hessian scores
             ['weights_compression_ratio', 0.75],  # Compression ratio
@@ -174,7 +176,7 @@ def PTQ_Keras_mixed_precision(float_model: keras.Model) -> Tuple[bool, keras.Mod
 
         # Execute quantization with mixed precision using MCTWrapper
         wrapper = mct.wrapper.mct_wrapper.MCTWrapper()
-        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, framework, method, use_mixed_precision, param_items)
+        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, method, framework, use_internal_tpc, use_mixed_precision, param_items)
         return flag, quantized_model
 
     #########################################################################
@@ -188,33 +190,35 @@ def GPTQ_Keras(float_model: keras.Model) -> Tuple[bool, keras.Model]:
         resulting in better model accuracy compared to standard PTQ.
         """
         # Quantization method configuration
-        framework = 'tensorflow'
         method = 'GPTQ'
+        framework = 'tensorflow'
+        use_internal_tpc = True
         use_mixed_precision = False
 
         # Configure GPTQ-specific parameters for gradient-based optimization
         param_items = [
-            ['sdsp_version', '3.14'],  # The version of the SDSP converter.
+            ['target_platform_version', 'v1'],  # The version of the TPC to use.
             ['n_epochs', 5],  # Number of training epochs
             ['optimizer', None],  # Optimizer for training
             ['save_model_path', './qmodel_GPTQ_Keras.keras']  # Path to save the model.
         ]
 
         # Execute gradient-based quantization using MCTWrapper
         wrapper = mct.wrapper.mct_wrapper.MCTWrapper()
-        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, framework, method, use_mixed_precision, param_items)
+        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, method, framework, use_internal_tpc, use_mixed_precision, param_items)
         return flag, quantized_model
 
     #########################################################################
     # Run GPTQ + Mixed Precision Quantization (mixed_precision) with Keras
     @decorator
     def GPTQ_Keras_mixed_precision(float_model: keras.Model) -> Tuple[bool, keras.Model]:
-        framework = 'tensorflow'
         method = 'GPTQ'
+        framework = 'tensorflow'
+        use_internal_tpc = True
         use_mixed_precision = True
 
         param_items = [
-            ['sdsp_version', '3.14'],  # The version of the SDSP converter.
+            ['target_platform_version', 'v1'],  # The version of the TPC to use.
             ['n_epochs', 5],  # Number of training epochs
             ['optimizer', None],  # Optimizer for training
             ['num_of_images', 5],  # Number of images
@@ -224,15 +228,16 @@ def GPTQ_Keras_mixed_precision(float_model: keras.Model) -> Tuple[bool, keras.Mo
         ]
 
         wrapper = mct.wrapper.mct_wrapper.MCTWrapper()
-        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, framework, method, use_mixed_precision, param_items)
+        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, method, framework, use_internal_tpc, use_mixed_precision, param_items)
         return flag, quantized_model
 
     #########################################################################
     # Run LQPTQ (Low-bit Quantizer PTQ) with Keras
     @decorator
     def LQPTQ_Keras(float_model: keras.Model) -> Tuple[bool, keras.Model]:
-        framework = 'tensorflow'
         method = 'LQPTQ'
+        framework = 'tensorflow'
+        use_internal_tpc = True
         use_mixed_precision = False
 
         param_items = [
@@ -241,8 +246,8 @@ def LQPTQ_Keras(float_model: keras.Model) -> Tuple[bool, keras.Model]:
             ['save_model_path', './qmodel_LQPTQ_Keras.keras']  # Path to save the model.
         ]
 
-        wrapper = mct.wrapper.mct_wrapper.MCTWrapper()
-        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, framework, method, use_mixed_precision, param_items)
+        wrapper = mct.wrapper.wrap.MCTWrapper()
+        flag, quantized_model = wrapper.quantize_and_export(float_model, representative_dataset_gen, method, framework, use_internal_tpc, use_mixed_precision, param_items)
         return flag, quantized_model
 
     # Execute the selected quantization method