mct-nightly 2.4.0.20250706.701__py3-none-any.whl → 2.4.0.20250708.612__py3-none-any.whl

model_compression_toolkit/core/pytorch/pruning/pruning_pytorch_implementation.py

@@ -29,6 +29,10 @@ import numpy as np
 from model_compression_toolkit.logger import Logger
 
 
+# default output channel axis to use when it's not defined in node's fw_info.
+_default_output_channel_axis = 1
+
+
 class PruningPytorchImplementation(PytorchImplementation, PruningFrameworkImplementation):
     """
     Implementation of the PruningFramework for the Pytorch framework. This class provides
@@ -190,6 +194,10 @@ class PruningPytorchImplementation(PytorchImplementation, PruningFrameworkImplem
 
         return attributes_with_axis
 
+    @property
+    def default_output_channel_axis(self):
+        return _default_output_channel_axis
+
 
 def _is_pytorch_node_pruning_section_edge(node: BaseNode) -> bool:
     """
@@ -283,7 +291,7 @@ def _edit_node_input_shape(node: BaseNode,
 
     # Adjust the last dimension of the shape to match the number of unpruned (retained) channels.
     # This is done by summing the mask, as each '1' in the mask represents a retained channel.
-    channel_axis = node.out_channel_axis
+    channel_axis = _default_output_channel_axis if node.out_channel_axis is None else node.out_channel_axis
     new_input_shape[0][channel_axis] = int(np.sum(input_mask))
 
     # Update the node's input shape with the new dimensions.

model_compression_toolkit/core/quantization_prep_runner.py

@@ -87,8 +87,8 @@ def quantization_preparation_runner(graph: Graph,
     # Calculate quantization params
     ######################################
 
-    calculate_quantization_params(graph, fw_impl=fw_impl, repr_data_gen_fn=representative_data_gen,
-                                  hessian_info_service=hessian_info_service)
+    calculate_quantization_params(graph, core_config.quantization_config, fw_impl=fw_impl,
+                                  repr_data_gen_fn=representative_data_gen, hessian_info_service=hessian_info_service)
 
     if tb_w is not None:
         tb_w.add_graph(graph, 'thresholds_selection')

model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -43,7 +43,6 @@ if FOUND_TF:
     import tensorflow as tf
     from model_compression_toolkit.core.keras.default_framework_info import set_keras_info
     from model_compression_toolkit.gptq.keras.gptq_keras_implementation import GPTQKerasImplemantation
-    from model_compression_toolkit.core.keras.keras_model_validation import KerasModelValidation
     from tensorflow.keras.models import Model
     from model_compression_toolkit.gptq.keras.gptq_loss import GPTQMultipleTensorsLoss, sample_layer_attention_loss
     from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
@@ -235,8 +234,6 @@ if FOUND_TF:
         if core_config.debug_config.bypass:
             return in_model, None
 
-        KerasModelValidation(model=in_model).validate()
-
         if core_config.is_mixed_precision_enabled:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "

model_compression_toolkit/ptq/keras/quantization_facade.py

@@ -38,7 +38,6 @@ if FOUND_TF:
         AttachTpcToKeras
     from model_compression_toolkit.core.keras.default_framework_info import set_keras_info
     from model_compression_toolkit.core.keras.keras_implementation import KerasImplementation
-    from model_compression_toolkit.core.keras.keras_model_validation import KerasModelValidation
     from tensorflow.keras.models import Model
     from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
     from model_compression_toolkit.exporter.model_wrapper import get_exportable_keras_model
@@ -129,8 +128,6 @@ if FOUND_TF:
         if core_config.debug_config.bypass:
             return in_model, None
 
-        KerasModelValidation(model=in_model).validate()
-
         if core_config.is_mixed_precision_enabled:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config to mixed-precision facade is not of type "

model_compression_toolkit/qat/keras/quantization_facade.py

@@ -38,7 +38,6 @@ if FOUND_TF:
 
     from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
     from model_compression_toolkit.core.keras.keras_implementation import KerasImplementation
-    from model_compression_toolkit.core.keras.keras_model_validation import KerasModelValidation
     from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
     from model_compression_toolkit.core.keras.default_framework_info import set_keras_info
 
@@ -175,8 +174,6 @@ if FOUND_TF:
                        f"If you encounter an issue, please open an issue in our GitHub "
                        f"project https://github.com/sony/model_optimization")
 
-        KerasModelValidation(model=in_model).validate()
-
         if core_config.is_mixed_precision_enabled:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config to mixed-precision facade is not of type "

model_compression_toolkit/trainable_infrastructure/common/get_quantizer_config.py

@@ -48,7 +48,6 @@ def get_trainable_quantizer_weights_config(
                                            final_attr_cfg.enable_weights_quantization,
                                            final_attr_cfg.weights_channels_axis[0],  # Output channel axis
                                            final_attr_cfg.weights_per_channel_threshold,
-                                           final_node_cfg.min_threshold,
                                            weights_quantization_candidates)
 
 
@@ -76,7 +75,6 @@ def get_trainable_quantizer_activation_config(
                                               final_cfg.activation_n_bits,
                                               final_cfg.activation_quantization_params,
                                               final_cfg.enable_activation_quantization,
-                                              final_cfg.min_threshold,
                                               activation_quantization_candidates)
 
 

model_compression_toolkit/trainable_infrastructure/common/trainable_quantizer_config.py

@@ -44,7 +44,6 @@ class TrainableQuantizerActivationConfig:
                  activation_n_bits: int,
                  activation_quantization_params: Dict,
                  enable_activation_quantization: bool,
-                 min_threshold: float,
                  activation_quantization_candidates: List[TrainableQuantizerCandidateConfig] = None,
                  ):
         """
@@ -55,13 +54,11 @@ class TrainableQuantizerActivationConfig:
             activation_n_bits (int): Number of bits to quantize the activations.
             activation_quantization_params (Dict): Dictionary that contains activation quantization params.
             enable_activation_quantization (bool): Whether to quantize the layer's activations or not.
-            min_threshold (float): Minimum threshold to use during thresholds selection.
         """
         self.activation_quantization_method = activation_quantization_method
         self.activation_n_bits = activation_n_bits
         self.activation_quantization_params = activation_quantization_params
         self.enable_activation_quantization = enable_activation_quantization
-        self.min_threshold = min_threshold
         self.activation_bits_candidates = activation_quantization_candidates
 
 
@@ -73,7 +70,6 @@ class TrainableQuantizerWeightsConfig:
                  enable_weights_quantization: bool,
                  weights_channels_axis: int,
                  weights_per_channel_threshold: bool,
-                 min_threshold: float,
                  weights_quantization_candidates: List[TrainableQuantizerCandidateConfig] = None,
                  ):
         """
@@ -86,7 +82,6 @@ class TrainableQuantizerWeightsConfig:
             enable_weights_quantization (bool): Whether to quantize the layer's weights or not.
             weights_channels_axis (int): Axis to quantize a node's kernel when quantizing per-channel.
             weights_per_channel_threshold (bool): Whether to quantize the weights per-channel or not (per-tensor).
-            min_threshold (float): Minimum threshold to use during thresholds selection.
         """
         self.weights_quantization_method = weights_quantization_method
         self.weights_n_bits = weights_n_bits
@@ -94,5 +89,4 @@ class TrainableQuantizerWeightsConfig:
         self.enable_weights_quantization = enable_weights_quantization
         self.weights_channels_axis = weights_channels_axis
         self.weights_per_channel_threshold = weights_per_channel_threshold
-        self.min_threshold = min_threshold
         self.weights_bits_candidates = weights_quantization_candidates

model_compression_toolkit/trainable_infrastructure/keras/config_serialization.py

@@ -77,13 +77,11 @@ def config_deserialization(in_config: dict) -> Union[TrainableQuantizerWeightsCo
                                                weights_quantization_params=weights_quantization_params,
                                                enable_weights_quantization=in_config[C.ENABLE_WEIGHTS_QUANTIZATION],
                                                weights_channels_axis=in_config[C.WEIGHTS_CHANNELS_AXIS],
-                                               weights_per_channel_threshold=in_config[C.WEIGHTS_PER_CHANNEL_THRESHOLD],
-                                               min_threshold=in_config[C.MIN_THRESHOLD])
+                                               weights_per_channel_threshold=in_config[C.WEIGHTS_PER_CHANNEL_THRESHOLD])
     elif in_config[C.IS_ACTIVATIONS]:
         return TrainableQuantizerActivationConfig(activation_quantization_method=QuantizationMethod(in_config[C.ACTIVATION_QUANTIZATION_METHOD]),
                                                   activation_n_bits=in_config[C.ACTIVATION_N_BITS],
                                                   activation_quantization_params=in_config[C.ACTIVATION_QUANTIZATION_PARAMS],
-                                                  enable_activation_quantization=in_config[C.ENABLE_ACTIVATION_QUANTIZATION],
-                                                  min_threshold=in_config[C.MIN_THRESHOLD])
+                                                  enable_activation_quantization=in_config[C.ENABLE_ACTIVATION_QUANTIZATION])
     else:
         raise NotImplemented  # pragma: no cover

model_compression_toolkit/core/common/model_validation.py

@@ -1,41 +0,0 @@
-from abc import abstractmethod
-from typing import Any
-
-from model_compression_toolkit.core import FrameworkInfo
-
-
-class ModelValidation:
-    """
-    Class to define validation methods in order to validate the received model to quantize.
-    """
-
-    def __init__(self,
-                 model: Any):
-        """
-        Initialize a ModelValidation object.
-
-        Args:
-            model: Model to check its validity.
-        """
-        self.model = model
-
-    @abstractmethod
-    def validate_output_channel_consistency(self):
-        """
-
-        Validate that output channels index in all layers of the model are the same.
-        If the model has layers with different output channels index, it should throw an exception.
-
-        """
-        raise NotImplemented(
-            f'Framework validation class did not implement validate_output_channel_consistency')  # pragma: no cover
-
-    def validate(self):
-        """
-
-        Run all validation methods before the quantization process starts.
-
-        """
-        self.validate_output_channel_consistency()
-
-

model_compression_toolkit/core/keras/keras_model_validation.py

@@ -1,37 +0,0 @@
-from tensorflow.keras.models import Model
-
-from model_compression_toolkit.core.common.framework_info import get_fw_info
-from model_compression_toolkit.core.common.framework_info import ChannelAxis
-from model_compression_toolkit.core.common.model_validation import ModelValidation
-from model_compression_toolkit.core.keras.constants import CHANNELS_FORMAT, CHANNELS_FORMAT_LAST, CHANNELS_FORMAT_FIRST
-
-
-class KerasModelValidation(ModelValidation):
-    """
-    Class to define validation methods in order to validate the received Keras model to quantize.
-    """
-
-    def __init__(self, model: Model):
-        """
-        Initialize a KerasModelValidation object.
-
-        Args:
-            model: Keras model to check its validity.
-        """
-
-        super(KerasModelValidation, self).__init__(model=model)
-
-    def validate_output_channel_consistency(self):
-        """
-
-        Validate that output channels index in all layers of the model are the same.
-        If the model has layers with different output channels index, an exception is thrown.
-
-        """
-        fw_info = get_fw_info()
-        for layer in self.model.layers:
-            data_format = layer.get_config().get(CHANNELS_FORMAT)
-            if data_format is not None:
-                assert (data_format == CHANNELS_FORMAT_LAST and fw_info.get_out_channel_axis(layer) == ChannelAxis.NHWC.value
-                        or data_format == CHANNELS_FORMAT_FIRST and fw_info.get_out_channel_axis(layer) == ChannelAxis.NCHW.value), \
-                    f'Model can not have layers with different data formats.'