mct-nightly 1.11.0.20240307.post318__tar.gz → 1.11.0.20240309.post349__tar.gz

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.11.0.20240307.post318
+Version: 1.11.0.20240309.post349
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN
@@ -74,7 +74,7 @@ Description: # Model Compression Toolkit (MCT)
         ## Supported Features
         MCT offers a range of powerful features to optimize neural network models for efficient deployment. These supported features include:
         
-        ### Data Generation
+        ### Data Generation [*](#experimental-features)
         MCT provides tools for generating synthetic images based on the statistics stored in a model's batch normalization layers. These generated images are valuable for various compression tasks where image data is required, such as quantization and pruning. 
         You can customize data generation configurations to suit your specific needs. [Go to the Data Generation page.](model_compression_toolkit/data_generation/README.md)
         
@@ -82,7 +82,7 @@ Description: # Model Compression Toolkit (MCT)
         MCT supports different quantization methods:
         * Post-training quantization (PTQ): [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_post_training_quantization_experimental.html#ug-keras-post-training-quantization-experimental), [PyTorch API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/pytorch_post_training_quantization_experimental.html#ug-pytorch-post-training-quantization-experimental)
         * Gradient-based post-training quantization (GPTQ): [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_gradient_post_training_quantization_experimental.html#ug-keras-gradient-post-training-quantization-experimental), [PyTorch API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/pytorch_gradient_post_training_quantization_experimental.html#ug-pytorch-gradient-post-training-quantization-experimental)
-        * Quantization-aware training (QAT)[*](#experimental-features)
+        * Quantization-aware training (QAT) [*](#experimental-features)
         
         
         | Quantization Method                           | Complexity | Computational Cost          |
@@ -117,6 +117,15 @@ Description: # Model Compression Toolkit (MCT)
         More details on the how to use EPTQ via MCT can be found in the [EPTQ guidelines](model_compression_toolkit/gptq/README.md).
         
         
+        ### Structured Pruning [*](#experimental-features)
+        MCT introduces a structured and hardware-aware model pruning.
+        This pruning technique is designed to compress models for specific hardware architectures, 
+        taking into account the target platform's Single Instruction, Multiple Data (SIMD) capabilities. 
+        By pruning groups of channels (SIMD groups), our approach not only reduces model size 
+        and complexity, but ensures that better utilization of channels is in line with the SIMD architecture 
+        for a target KPI of weights memory footprint.
+        [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_pruning_experimental.html)
+        [Pytorch API](https://github.com/sony/model_optimization/blob/main/model_compression_toolkit/pruning/pytorch/pruning_facade.py#L43) 
         
         #### Experimental features 
         
@@ -146,17 +155,8 @@ Description: # Model Compression Toolkit (MCT)
         
         For more results, please refer to [quick start](https://github.com/sony/model_optimization/tree/main/tutorials/quick_start).
         
-        ### Structured Pruning
-        MCT introduces a structured and hardware-aware model pruning.
-        This pruning technique is designed to compress models for specific hardware architectures, 
-        taking into account the target platform's Single Instruction, Multiple Data (SIMD) capabilities. 
-        By pruning groups of channels (SIMD groups), our approach not only reduces model size 
-        and complexity, but ensures that better utilization of channels is in line with the SIMD architecture 
-        for a target KPI of weights memory footprint.
-        [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_pruning_experimental.html)
-        [Pytorch API](https://github.com/sony/model_optimization/blob/main/model_compression_toolkit/pruning/pytorch/pruning_facade.py#L43) 
         
-        #### Results
+        #### Pruning Results
         
         Results for applying pruning to reduce the parameters of the following models by 50%:
         

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/README.md

@@ -68,7 +68,7 @@ Currently, MCT is being tested on various Python, Pytorch and TensorFlow version
 ## Supported Features
 MCT offers a range of powerful features to optimize neural network models for efficient deployment. These supported features include:
 
-### Data Generation
+### Data Generation [*](#experimental-features)
 MCT provides tools for generating synthetic images based on the statistics stored in a model's batch normalization layers. These generated images are valuable for various compression tasks where image data is required, such as quantization and pruning. 
 You can customize data generation configurations to suit your specific needs. [Go to the Data Generation page.](model_compression_toolkit/data_generation/README.md)
 
@@ -76,7 +76,7 @@ You can customize data generation configurations to suit your specific needs. [G
 MCT supports different quantization methods:
 * Post-training quantization (PTQ): [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_post_training_quantization_experimental.html#ug-keras-post-training-quantization-experimental), [PyTorch API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/pytorch_post_training_quantization_experimental.html#ug-pytorch-post-training-quantization-experimental)
 * Gradient-based post-training quantization (GPTQ): [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_gradient_post_training_quantization_experimental.html#ug-keras-gradient-post-training-quantization-experimental), [PyTorch API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/pytorch_gradient_post_training_quantization_experimental.html#ug-pytorch-gradient-post-training-quantization-experimental)
-* Quantization-aware training (QAT)[*](#experimental-features)
+* Quantization-aware training (QAT) [*](#experimental-features)
 
 
 | Quantization Method                           | Complexity | Computational Cost          |
@@ -111,6 +111,15 @@ The specifications of the algorithm are detailed in the paper: _"**EPTQ: Enhance
 More details on the how to use EPTQ via MCT can be found in the [EPTQ guidelines](model_compression_toolkit/gptq/README.md).
 
 
+### Structured Pruning [*](#experimental-features)
+MCT introduces a structured and hardware-aware model pruning.
+This pruning technique is designed to compress models for specific hardware architectures, 
+taking into account the target platform's Single Instruction, Multiple Data (SIMD) capabilities. 
+By pruning groups of channels (SIMD groups), our approach not only reduces model size 
+and complexity, but ensures that better utilization of channels is in line with the SIMD architecture 
+for a target KPI of weights memory footprint.
+[Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_pruning_experimental.html)
+[Pytorch API](https://github.com/sony/model_optimization/blob/main/model_compression_toolkit/pruning/pytorch/pruning_facade.py#L43) 
 
 #### Experimental features 
 
@@ -140,17 +149,8 @@ In the following table we present the ImageNet validation results for these mode
 
 For more results, please refer to [quick start](https://github.com/sony/model_optimization/tree/main/tutorials/quick_start).
 
-### Structured Pruning
-MCT introduces a structured and hardware-aware model pruning.
-This pruning technique is designed to compress models for specific hardware architectures, 
-taking into account the target platform's Single Instruction, Multiple Data (SIMD) capabilities. 
-By pruning groups of channels (SIMD groups), our approach not only reduces model size 
-and complexity, but ensures that better utilization of channels is in line with the SIMD architecture 
-for a target KPI of weights memory footprint.
-[Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_pruning_experimental.html)
-[Pytorch API](https://github.com/sony/model_optimization/blob/main/model_compression_toolkit/pruning/pytorch/pruning_facade.py#L43) 
 
-#### Results
+#### Pruning Results
 
 Results for applying pruning to reduce the parameters of the following models by 50%:
 

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.11.0.20240307.post318
+Version: 1.11.0.20240309.post349
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN
@@ -74,7 +74,7 @@ Description: # Model Compression Toolkit (MCT)
         ## Supported Features
         MCT offers a range of powerful features to optimize neural network models for efficient deployment. These supported features include:
         
-        ### Data Generation
+        ### Data Generation [*](#experimental-features)
         MCT provides tools for generating synthetic images based on the statistics stored in a model's batch normalization layers. These generated images are valuable for various compression tasks where image data is required, such as quantization and pruning. 
         You can customize data generation configurations to suit your specific needs. [Go to the Data Generation page.](model_compression_toolkit/data_generation/README.md)
         
@@ -82,7 +82,7 @@ Description: # Model Compression Toolkit (MCT)
         MCT supports different quantization methods:
         * Post-training quantization (PTQ): [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_post_training_quantization_experimental.html#ug-keras-post-training-quantization-experimental), [PyTorch API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/pytorch_post_training_quantization_experimental.html#ug-pytorch-post-training-quantization-experimental)
         * Gradient-based post-training quantization (GPTQ): [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_gradient_post_training_quantization_experimental.html#ug-keras-gradient-post-training-quantization-experimental), [PyTorch API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/pytorch_gradient_post_training_quantization_experimental.html#ug-pytorch-gradient-post-training-quantization-experimental)
-        * Quantization-aware training (QAT)[*](#experimental-features)
+        * Quantization-aware training (QAT) [*](#experimental-features)
         
         
         | Quantization Method                           | Complexity | Computational Cost          |
@@ -117,6 +117,15 @@ Description: # Model Compression Toolkit (MCT)
         More details on the how to use EPTQ via MCT can be found in the [EPTQ guidelines](model_compression_toolkit/gptq/README.md).
         
         
+        ### Structured Pruning [*](#experimental-features)
+        MCT introduces a structured and hardware-aware model pruning.
+        This pruning technique is designed to compress models for specific hardware architectures, 
+        taking into account the target platform's Single Instruction, Multiple Data (SIMD) capabilities. 
+        By pruning groups of channels (SIMD groups), our approach not only reduces model size 
+        and complexity, but ensures that better utilization of channels is in line with the SIMD architecture 
+        for a target KPI of weights memory footprint.
+        [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_pruning_experimental.html)
+        [Pytorch API](https://github.com/sony/model_optimization/blob/main/model_compression_toolkit/pruning/pytorch/pruning_facade.py#L43) 
         
         #### Experimental features 
         
@@ -146,17 +155,8 @@ Description: # Model Compression Toolkit (MCT)
         
         For more results, please refer to [quick start](https://github.com/sony/model_optimization/tree/main/tutorials/quick_start).
         
-        ### Structured Pruning
-        MCT introduces a structured and hardware-aware model pruning.
-        This pruning technique is designed to compress models for specific hardware architectures, 
-        taking into account the target platform's Single Instruction, Multiple Data (SIMD) capabilities. 
-        By pruning groups of channels (SIMD groups), our approach not only reduces model size 
-        and complexity, but ensures that better utilization of channels is in line with the SIMD architecture 
-        for a target KPI of weights memory footprint.
-        [Keras API](https://sony.github.io/model_optimization/docs/api/experimental_api_docs/methods/keras_pruning_experimental.html)
-        [Pytorch API](https://github.com/sony/model_optimization/blob/main/model_compression_toolkit/pruning/pytorch/pruning_facade.py#L43) 
         
-        #### Results
+        #### Pruning Results
         
         Results for applying pruning to reduce the parameters of the following models by 50%:
         

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/__init__.py

@@ -27,23 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-
-# Old API (will not be accessible in future releases)
-from model_compression_toolkit.core.common import network_editors as network_editor
-from model_compression_toolkit.core.common.quantization import quantization_config
-from model_compression_toolkit.core.common.mixed_precision import mixed_precision_quantization_config
-from model_compression_toolkit.core.common.quantization.debug_config import DebugConfig
-from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig, QuantizationErrorMethod, DEFAULTCONFIG
-from model_compression_toolkit.core.common.mixed_precision.kpi_tools.kpi import KPI
-from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig
-from model_compression_toolkit.logger import set_log_folder
-from model_compression_toolkit.core.common.data_loader import FolderImageLoader
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo, ChannelAxis
-from model_compression_toolkit.core.keras.kpi_data_facade import keras_kpi_data
-from model_compression_toolkit.core.pytorch.kpi_data_facade import pytorch_kpi_data
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
-from model_compression_toolkit.gptq.common.gptq_config import RoundingType
-from model_compression_toolkit.gptq.keras.quantization_facade import get_keras_gptq_config
-from model_compression_toolkit.gptq.pytorch.quantization_facade import get_pytorch_gptq_config
-
 __version__ = "1.11.0"

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/core/common/network_editors/actions.py

@@ -43,7 +43,7 @@ class EditRule(_EditRule):
         >>> import model_compression_toolkit as mct
         >>> from model_compression_toolkit.core.keras.constants import KERNEL
         >>> from tensorflow.keras.layers import Conv2D
-        >>> er_list = [mct.network_editor.EditRule(filter=mct.network_editor.NodeTypeFilter(Conv2D), action=mct.network_editor.ChangeCandidatesWeightsQuantConfigAttr(attr_name=KERNEL, weights_n_bits=9))]
+        >>> er_list = [mct.core.network_editor.EditRule(filter=mct.core.network_editor.NodeTypeFilter(Conv2D), action=mct.core.network_editor.ChangeCandidatesWeightsQuantConfigAttr(attr_name=KERNEL, weights_n_bits=9))]
 
         Then the rules list can be passed to :func:`~model_compression_toolkit.keras_post_training_quantization`
         to modify the network during the quantization process.

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -82,7 +82,7 @@ class QuantizationConfig:
             block_collapsing (bool): Whether to collapse block one to another in the input network
             shift_negative_ratio (float): Value for the ratio between the minimal negative value of a non-linearity output to its activation threshold, which above it - shifting negative activation should occur if enabled.
             shift_negative_threshold_recalculation (bool): Whether or not to recompute the threshold after shifting negative activation.
-            shift_negative_params_search (bool): Whether to search for optimal shift and threshold in shift negative activation (experimental)
+            shift_negative_params_search (bool): Whether to search for optimal shift and threshold in shift negative activation.
 
         Examples:
             One may create a quantization configuration to quantize a model according to.

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/core/keras/graph_substitutions/substitutions/separableconv_decomposition.py

@@ -75,8 +75,10 @@ class SeparableConvDecomposition(common.BaseSubstitution):
         pw_bias = separable_node.get_weights_by_keys(BIAS)
 
         dw_weights_dict = {DEPTHWISE_KERNEL: dw_kernel}
-        pw_weights_dict = {KERNEL: pw_kernel,
-                           BIAS: pw_bias}
+        pw_weights_dict = {KERNEL: pw_kernel}
+
+        if pw_bias is not None:
+            pw_weights_dict[BIAS] = pw_bias
 
         # Split separable node attributes into relevant attributes for each of the new nodes.
         # List of dw attributes that should take from separable as they are.

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/data_generation/__init__.py

@@ -16,7 +16,7 @@ from model_compression_toolkit.constants import FOUND_TORCH, FOUND_TF
 
 if FOUND_TF:
     from model_compression_toolkit.data_generation.keras.keras_data_generation import (
-        tensorflow_data_generation_experimental, get_tensorflow_data_generation_config)
+        keras_data_generation_experimental, get_keras_data_generation_config)
 
 if FOUND_TORCH:
     from model_compression_toolkit.data_generation.pytorch.pytorch_data_generation import (

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/data_generation/keras/keras_data_generation.py

@@ -49,7 +49,7 @@ if FOUND_TF:
         scheduler_step_function_dict
 
     # Function to create a DataGenerationConfig object with the specified configuration parameters for Tensorflow
-    def get_tensorflow_data_generation_config(
+    def get_keras_data_generation_config(
             n_iter: int = DEFAULT_N_ITER,
             optimizer: Optimizer = Adam,
             data_gen_batch_size: int = DEFAULT_DATA_GEN_BS,
@@ -115,13 +115,13 @@ if FOUND_TF:
             output_loss_multiplier=output_loss_multiplier)
 
 
-    def tensorflow_data_generation_experimental(
+    def keras_data_generation_experimental(
             model: tf.keras.Model,
             n_images: int,
             output_image_size: Tuple,
             data_generation_config: DataGenerationConfig) -> tf.Tensor:
         """
-        Function to perform data generation using the provided model and data generation configuration.
+        Function to perform data generation using the provided Keras model and data generation configuration.
 
         Args:
             model (Model): Keras model to generate data for.
@@ -132,6 +132,11 @@ if FOUND_TF:
         Returns:
             List[tf.Tensor]: Finalized list containing generated images.
         """
+        Logger.warning(f"keras_data_generation_experimental is experimental "
+                       f"and is subject to future changes."
+                       f"If you encounter an issue, please open an issue in our GitHub "
+                       f"project https://github.com/sony/model_optimization")
+
         # Get Data Generation functions and classes
         image_pipeline, normalization, bn_layer_weighting_fn, bn_alignment_loss_fn, output_loss_fn, \
             init_dataset = get_data_generation_classes(data_generation_config=data_generation_config,
@@ -323,11 +328,11 @@ if FOUND_TF:
 
 
 else:
-    def get_tensorflow_data_generation_config(*args, **kwargs):
-        Logger.critical('Installing tensorflow is mandatory when using get_tensorflow_data_generation_config. '
+    def get_keras_data_generation_config(*args, **kwargs):
+        Logger.critical('Installing tensorflow is mandatory when using get_keras_data_generation_config. '
                         'Could not find Tensorflow package.')  # pragma: no cover
 
 
-    def tensorflow_data_generation_experimental(*args, **kwargs):
+    def keras_data_generation_experimental(*args, **kwargs):
         Logger.critical('Installing tensorflow is mandatory when using pytorch_data_generation_experimental. '
                         'Could not find Tensorflow package.')  # pragma: no cover

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/data_generation/pytorch/pytorch_data_generation.py

@@ -143,6 +143,12 @@ if FOUND_TORCH:
         Returns:
             List[Tensor]: Finalized list containing generated images.
         """
+
+        Logger.warning(f"pytorch_data_generation_experimental is experimental "
+                       f"and is subject to future changes."
+                       f"If you encounter an issue, please open an issue in our GitHub "
+                       f"project https://github.com/sony/model_optimization")
+
         # get a static graph representation of the model using torch.fx
         fx_model = symbolic_trace(model)
 		

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/gptq/__init__.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, RoundingType, GradientPTQConfig, GPTQHessianScoresConfig
+from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, RoundingType, GPTQHessianScoresConfig
 from model_compression_toolkit.gptq.keras.quantization_facade import keras_gradient_post_training_quantization
 from model_compression_toolkit.gptq.keras.quantization_facade import get_keras_gptq_config
 from model_compression_toolkit.gptq.pytorch.quantization_facade import pytorch_gradient_post_training_quantization

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/gptq/common/gptq_config.py

@@ -36,8 +36,7 @@ class GPTQHessianScoresConfig:
                  hessians_num_samples: int = 16,
                  norm_scores: bool = True,
                  log_norm: bool = True,
-                 scale_log_norm: bool = False,
-                 hessians_n_iter: int = 50): #TODO: remove
+                 scale_log_norm: bool = False):
 
         """
         Initialize a GPTQHessianWeightsConfig.
@@ -47,14 +46,12 @@ class GPTQHessianScoresConfig:
             norm_scores (bool): Whether to normalize the returned scores of the weighted loss function (to get values between 0 and 1).
             log_norm (bool): Whether to use log normalization for the GPTQ Hessian-based scores.
             scale_log_norm (bool): Whether to scale the final vector of the Hessian-based scores.
-            hessians_n_iter (int): Number of random iterations to run Hessian approximation for GPTQ Hessian-based scores.
         """
 
         self.hessians_num_samples = hessians_num_samples
         self.norm_scores = norm_scores
         self.log_norm = log_norm
         self.scale_log_norm = scale_log_norm
-        self.hessians_n_iter = hessians_n_iter
 
 
 class GradientPTQConfig:

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -129,6 +129,10 @@ if FOUND_TORCH:
 
         Examples:
 
+            Import Model Compression Toolkit:
+
+            >>> import model_compression_toolkit as mct
+
             Import a Pytorch module:
 
             >>> from torchvision import models
@@ -149,7 +153,7 @@ if FOUND_TORCH:
 
             Pass the module, the representative dataset generator and the configuration (optional) to get a quantized module
 
-            >>> quantized_module, quantization_info = mct.gptq.pytorch_gradient_post_training_quantization_experimental(module, repr_datagen, core_config=config, gptq_config=gptq_conf)
+            >>> quantized_module, quantization_info = mct.gptq.pytorch_gradient_post_training_quantization(module, repr_datagen, core_config=config, gptq_config=gptq_conf)
 
         """
 

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/pruning/keras/pruning_facade.py

@@ -86,7 +86,7 @@ if FOUND_TF:
             are represented in float32 data type (thus, each parameter is represented using 4 bytes):
 
             >>> dense_nparams = sum([l.count_params() for l in model.layers])
-            >>> target_kpi = mct.KPI(weights_memory=dense_nparams * 4 * 0.5)
+            >>> target_kpi = mct.core.KPI(weights_memory=dense_nparams * 4 * 0.5)
 
             Optionally, define a pruning configuration. num_score_approximations can be passed
             to configure the number of importance scores that will be calculated for each channel.
@@ -101,6 +101,10 @@ if FOUND_TF:
 
         """
 
+        Logger.warning(f"keras_pruning_experimental is experimental and is subject to future changes."
+                       f"If you encounter an issue, please open an issue in our GitHub "
+                       f"project https://github.com/sony/model_optimization")
+
         # Instantiate the Keras framework implementation.
         fw_impl = PruningKerasImplementation()
 

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/pruning/pytorch/pruning_facade.py

@@ -93,7 +93,7 @@ if FOUND_TORCH:
             are represented in float32 data type (thus, each parameter is represented using 4 bytes):
 
             >>> dense_nparams = sum(p.numel() for p in model.state_dict().values())
-            >>> target_kpi = mct.KPI(weights_memory=dense_nparams * 4 * 0.5)
+            >>> target_kpi = mct.core.KPI(weights_memory=dense_nparams * 4 * 0.5)
 
             Optionally, define a pruning configuration. num_score_approximations can be passed
             to configure the number of importance scores that will be calculated for each channel.
@@ -108,6 +108,10 @@ if FOUND_TORCH:
 
         """
 
+        Logger.warning(f"pytorch_pruning_experimental is experimental and is subject to future changes."
+                       f"If you encounter an issue, please open an issue in our GitHub "
+                       f"project https://github.com/sony/model_optimization")
+
         # Instantiate the Pytorch framework implementation.
         fw_impl = PruningPytorchImplementation()
 

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/qat/__init__.py

@@ -14,5 +14,5 @@
 # ==============================================================================
 from model_compression_toolkit.qat.common.qat_config import QATConfig, TrainingMethod
 
-from model_compression_toolkit.qat.keras.quantization_facade import keras_quantization_aware_training_init, keras_quantization_aware_training_finalize
-from model_compression_toolkit.qat.pytorch.quantization_facade import pytorch_quantization_aware_training_init, pytorch_quantization_aware_training_finalize
+from model_compression_toolkit.qat.keras.quantization_facade import keras_quantization_aware_training_init_experimental, keras_quantization_aware_training_finalize_experimental
+from model_compression_toolkit.qat.pytorch.quantization_facade import pytorch_quantization_aware_training_init_experimental, pytorch_quantization_aware_training_finalize_experimental

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/qat/keras/quantization_facade.py

@@ -85,13 +85,13 @@ if FOUND_TF:
         return layer
 
 
-    def keras_quantization_aware_training_init(in_model: Model,
-                                               representative_data_gen: Callable,
-                                               target_kpi: KPI = None,
-                                               core_config: CoreConfig = CoreConfig(),
-                                               qat_config: QATConfig = QATConfig(),
-                                               fw_info: FrameworkInfo = DEFAULT_KERAS_INFO,
-                                               target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
+    def keras_quantization_aware_training_init_experimental(in_model: Model,
+                                                            representative_data_gen: Callable,
+                                                            target_kpi: KPI = None,
+                                                            core_config: CoreConfig = CoreConfig(),
+                                                            qat_config: QATConfig = QATConfig(),
+                                                            fw_info: FrameworkInfo = DEFAULT_KERAS_INFO,
+                                                            target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
         """
          Prepare a trained Keras model for quantization aware training. First the model quantization is optimized
          with post-training quantization, then the model layers are wrapped with QuantizeWrappers. The model is
@@ -161,7 +161,7 @@ if FOUND_TF:
              Pass the model, the representative dataset generator, the configuration and the target KPI to get a
              quantized model:
 
-             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init(model, repr_datagen, kpi, core_config=config)
+             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init_experimental(model, repr_datagen, kpi, core_config=config)
 
              Use the quantized model for fine-tuning. For loading the model from file, use the custom_objects dictionary:
 
@@ -170,6 +170,11 @@ if FOUND_TF:
              For more configuration options, please take a look at our `API documentation <https://sony.github.io/model_optimization/api/api_docs/modules/mixed_precision_quantization_config.html>`_.
 
          """
+
+        Logger.warning(f"keras_quantization_aware_training_init_experimental is experimental and is subject to future changes."
+                       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,
                              fw_info=fw_info).validate()
 
@@ -207,7 +212,7 @@ if FOUND_TF:
         return qat_model, user_info, {}
 
 
-    def keras_quantization_aware_training_finalize(in_model: Model) -> Model:
+    def keras_quantization_aware_training_finalize_experimental(in_model: Model) -> Model:
         """
          Convert a model fine-tuned by the user (Trainable quantizers) to a model with Inferable quantizers.
 
@@ -252,14 +257,19 @@ if FOUND_TF:
              Pass the model, the representative dataset generator, the configuration and the target KPI to get a
              quantized model:
 
-             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init(model, repr_datagen, kpi, core_config=config)
+             >>> quantized_model, quantization_info, custom_objects = mct.qat.keras_quantization_aware_training_init_experimental(model, repr_datagen, kpi, core_config=config)
 
              Use the quantized model for fine-tuning. For loading the model from file, use the custom_objects dictionary:
 
              >>> quantized_model = tf.keras.models.load_model(model_file, custom_objects=custom_objects)
-             >>> quantized_model = mct.qat.keras_quantization_aware_training_finalize(quantized_model)
+             >>> quantized_model = mct.qat.keras_quantization_aware_training_finalize_experimental(quantized_model)
 
          """
+        Logger.warning(
+            f"keras_quantization_aware_training_finalize_experimental is experimental and is subject to future changes."
+            f"If you encounter an issue, please open an issue in our GitHub "
+            f"project https://github.com/sony/model_optimization")
+
         def _export(layer):
             if isinstance(layer, KerasTrainableQuantizationWrapper):
                 layer = layer.convert_to_inferable_quantizers()
@@ -282,13 +292,13 @@ if FOUND_TF:
 else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use these functions.
-    def keras_quantization_aware_training_init(*args, **kwargs):
+    def keras_quantization_aware_training_init_experimental(*args, **kwargs):
         Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_quantization_aware_training_init. '
+                        'when using keras_quantization_aware_training_init_experimental. '
                         'Could not find Tensorflow package.')  # pragma: no cover
 
 
-    def keras_quantization_aware_training_finalize(*args, **kwargs):
+    def keras_quantization_aware_training_finalize_experimental(*args, **kwargs):
         Logger.critical('Installing tensorflow is mandatory '
-                        'when using keras_quantization_aware_training_finalize. '
+                        'when using keras_quantization_aware_training_finalize_experimental. '
                         'Could not find Tensorflow package.')  # pragma: no cover

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/model_compression_toolkit/qat/pytorch/quantization_facade.py

@@ -73,13 +73,13 @@ if FOUND_TORCH:
         return module
 
 
-    def pytorch_quantization_aware_training_init(in_model: Module,
-                                                 representative_data_gen: Callable,
-                                                 target_kpi: KPI = None,
-                                                 core_config: CoreConfig = CoreConfig(),
-                                                 qat_config: QATConfig = QATConfig(),
-                                                 fw_info: FrameworkInfo = DEFAULT_PYTORCH_INFO,
-                                                 target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
+    def pytorch_quantization_aware_training_init_experimental(in_model: Module,
+                                                              representative_data_gen: Callable,
+                                                              target_kpi: KPI = None,
+                                                              core_config: CoreConfig = CoreConfig(),
+                                                              qat_config: QATConfig = QATConfig(),
+                                                              fw_info: FrameworkInfo = DEFAULT_PYTORCH_INFO,
+                                                              target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
         """
          Prepare a trained Pytorch model for quantization aware training. First the model quantization is optimized
          with post-training quantization, then the model layers are wrapped with QuantizeWrappers. The model is
@@ -136,11 +136,15 @@ if FOUND_TORCH:
              Pass the model, the representative dataset generator, the configuration and the target KPI to get a
              quantized model. Now the model contains quantizer wrappers for fine tunning the weights:
 
-             >>> quantized_model, quantization_info = pytorch_quantization_aware_training_init(model, repr_datagen, core_config=config)
+             >>> quantized_model, quantization_info = mct.qat.pytorch_quantization_aware_training_init_experimental(model, repr_datagen, core_config=config)
 
              For more configuration options, please take a look at our `API documentation <https://sony.github.io/model_optimization/api/api_docs/modules/mixed_precision_quantization_config.html>`_.
 
          """
+        Logger.warning(
+            f"pytorch_quantization_aware_training_init_experimental is experimental and is subject to future changes."
+            f"If you encounter an issue, please open an issue in our GitHub "
+            f"project https://github.com/sony/model_optimization")
 
         if core_config.mixed_precision_enable:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
@@ -180,7 +184,7 @@ if FOUND_TORCH:
         return qat_model, user_info
 
 
-    def pytorch_quantization_aware_training_finalize(in_model: Module):
+    def pytorch_quantization_aware_training_finalize_experimental(in_model: Module):
         """
          Convert a model fine-tuned by the user to a network with QuantizeWrappers containing
          InferableQuantizers, that quantizes both the layers weights and outputs
@@ -214,13 +218,18 @@ if FOUND_TORCH:
              Pass the model, the representative dataset generator, the configuration and the target KPI to get a
              quantized model:
 
-             >>> quantized_model, quantization_info = pytorch_quantization_aware_training_init(model, repr_datagen, core_config=config)
+             >>> quantized_model, quantization_info = mct.qat.pytorch_quantization_aware_training_init_experimental(model, repr_datagen, core_config=config)
 
              Use the quantized model for fine-tuning. Finally, remove the quantizer wrappers and keep a quantize model ready for inference.
 
-             >>> quantized_model = mct.pytorch_quantization_aware_training_finalize(quantized_model)
+             >>> quantized_model = mct.qat.pytorch_quantization_aware_training_finalize_experimental(quantized_model)
 
          """
+        Logger.warning(
+            f"pytorch_quantization_aware_training_finalize_experimental is experimental and is subject to future changes."
+            f"If you encounter an issue, please open an issue in our GitHub "
+            f"project https://github.com/sony/model_optimization")
+
         for _, layer in in_model.named_children():
             if isinstance(layer, (PytorchQuantizationWrapper, PytorchActivationQuantizationHolder)):
                 layer.convert_to_inferable_quantizers()
@@ -231,13 +240,13 @@ if FOUND_TORCH:
 else:
     # If torch is not installed,
     # we raise an exception when trying to use these functions.
-    def pytorch_quantization_aware_training_init(*args, **kwargs):
+    def pytorch_quantization_aware_training_init_experimental(*args, **kwargs):
         Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_quantization_aware_training_init. '
+                        'when using pytorch_quantization_aware_training_init_experimental. '
                         'Could not find the torch package.')  # pragma: no cover
 
 
-    def pytorch_quantization_aware_training_finalize(*args, **kwargs):
+    def pytorch_quantization_aware_training_finalize_experimental(*args, **kwargs):
         Logger.critical('Installing Pytorch is mandatory '
-                        'when using pytorch_quantization_aware_training_finalize. '
+                        'when using pytorch_quantization_aware_training_finalize_experimental. '
                         'Could not find the torch package.')  # pragma: no cover

{mct-nightly-1.11.0.20240307.post318 → mct-nightly-1.11.0.20240309.post349}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 description-file = README.md
-version = 1.11.0.20240307-000318
+version = 1.11.0.20240309-000349
 
 [egg_info]
 tag_build =