PyPI - mct-nightly - Versions diffs - 2.2.0.20250121.508__tar.gz → 2.3.0.20250122.511__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.2.0.20250121.508
+Version: 2.3.0.20250122.511
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.2.0.20250121.508
+Version: 2.3.0.20250122.511
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

@@ -27,4 +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
-__version__ = "2.2.0.20250121.000508"
+__version__ = "2.3.0.20250122.000511"

@@ -53,9 +53,10 @@ def compute_graph_max_cut(memory_graph: MemoryGraph,
         try:
             schedule, max_cut_size, cuts = max_cut_astar.solve(estimate=estimate, iter_limit=astar_n_iter,
                                                                time_limit=None if it == 0 else 300)
-        except TimeoutError:
+        except TimeoutError:  # pragma: no cover
+            # TODO: add test for this.
             if last_result[0] is None:
-                Logger.critical(f"Max-cut solver stopped on timeout in iteration {it} before finding a solution.")  # pragma: no cover
+                Logger.critical(f"Max-cut solver stopped on timeout in iteration {it} before finding a solution.")
             else:
                 Logger.warning(f"Max-cut solver stopped on timeout in iteration {it}.")
                 return last_result

@@ -151,7 +151,8 @@ class MaxCutAstar:
         t1 = time()
         while expansion_count < iter_limit and len(open_list) > 0:
             if time_limit is not None and time() - t1 > time_limit:
-                raise TimeoutError
+                # TODO: add test for this.
+                raise TimeoutError  # pragma: no cover
             # Choose next node to expand
             next_cut = self._get_cut_to_expand(open_list, costs, routes, estimate)

@@ -170,7 +170,6 @@ class ResourceUtilizationCalculator:
             w_total, *_ = self.compute_weights_utilization(target_criterion, bitwidth_mode, w_qcs)
         if {RUTarget.ACTIVATION, RUTarget.TOTAL}.intersection(ru_targets):
-            Logger.warning("Using an experimental feature max-cut for activation memory utilization estimation.")
             a_total = self.compute_activations_utilization(target_criterion, bitwidth_mode, act_qcs)
         ru = ResourceUtilization()

@@ -104,6 +104,12 @@ def requires_mixed_precision(in_model: Any,
     Returns: A boolean indicating if mixed precision is needed.
     """
+    # Any target resource utilization other than weights will always require MP calculation.
+    if target_resource_utilization.activation_restricted() or \
+            target_resource_utilization.total_mem_restricted() or \
+            target_resource_utilization.bops_restricted():
+        return True
     core_config = _create_core_config_for_ru(core_config)
     transformed_graph = graph_preparation_runner(in_model,

@@ -68,7 +68,7 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
             node_candidates = current_node.candidates_quantization_cfg
             # only weights kernel attribute is quantized with weights mixed precision
-            kernel_attr = search_manager.fw_info.get_kernel_op_attributes(current_node)
+            kernel_attr = search_manager.fw_info.get_kernel_op_attributes(current_node.type)
             kernel_attr = None if kernel_attr is None else kernel_attr[0]
             valid_candidates = _get_valid_candidates_indices(node_candidates, new_solution[node_idx], kernel_attr)
@@ -139,8 +139,9 @@ def _get_valid_candidates_indices(node_candidates: List[CandidateNodeQuantizatio
         activation_num_bits = current_candidate.activation_quantization_cfg.activation_n_bits
         # Filter candidates that have higher bit-width for both weights and activations (except for the current index).
+        # TODO: activation bits comparison: should be >= if ACTIVATION or TOTAL ru is used. else should be ==.
         return [i for i, c in enumerate(node_candidates) if
-                c.activation_quantization_cfg.activation_n_bits >= activation_num_bits
+                c.activation_quantization_cfg.activation_n_bits == activation_num_bits
                 and c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits >= weights_num_bits
                 and not (c.activation_quantization_cfg.activation_n_bits == activation_num_bits
                          and c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits == weights_num_bits)]

@@ -78,9 +78,6 @@ class QuantizationConfig:
         >>> qc = mct.core.QuantizationConfig(activation_error_method=mct.core.QuantizationErrorMethod.NOCLIPPING, weights_error_method=mct.core.QuantizationErrorMethod.MSE, relu_bound_to_power_of_2=True, weights_bias_correction=True)
-        The QuantizationConfig instance can then be used in the quantization workflow,
-        such as with Keras in the function: :func:~model_compression_toolkit.ptq.keras_post_training_quantization`.
     """
     activation_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE

@@ -90,9 +90,11 @@ def core_runner(in_model: Any,
     # Checking whether to run mixed precision quantization
     if target_resource_utilization is not None and target_resource_utilization.is_any_restricted():
-        if core_config.mixed_precision_config is None:
+        if core_config.mixed_precision_config is None:  # pragma: no cover
             Logger.critical("Provided an initialized target_resource_utilization, that means that mixed precision quantization is "
                             "enabled, but the provided MixedPrecisionQuantizationConfig is None.")
+        if target_resource_utilization.activation_restricted() or target_resource_utilization.total_mem_restricted():
+            Logger.warning("Using an experimental feature max-cut for activation memory utilization estimation.")
         # Determine whether to use mixed precision or single precision based on target_resource_utilization.
         if requires_mixed_precision(in_model,
                                     target_resource_utilization,

@@ -77,6 +77,7 @@ if FOUND_TORCH:
             regularization_factor (float): A floating point number that defines the regularization factor.
             hessian_batch_size (int): Batch size for Hessian computation in Hessian-based weights GPTQ.
             use_hessian_sample_attention (bool): whether to use Sample-Layer Attention score for weighted loss.
+            gradual_activation_quantization (bool, GradualActivationQuantizationConfig): If False, GradualActivationQuantization is disabled. If True, GradualActivationQuantization is enabled with the default settings. GradualActivationQuantizationConfig object can be passed to use non-default settings.
         returns:
             a GradientPTQConfig object to use when fine-tuning the quantized model using gptq.

@@ -16,12 +16,9 @@ from typing import List, Dict, Tuple
 from model_compression_toolkit.gptq import GradientPTQConfig
 from model_compression_toolkit.core import common
-from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantizer import \
-    get_activation_inferable_quantizer_kwargs
 from model_compression_toolkit.gptq.pytorch.quantizer.base_pytorch_gptq_quantizer import \
     BasePytorchGPTQTrainableQuantizer
 from mct_quantizers import QuantizationTarget
-from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers.pytorch.quantizers import BasePyTorchInferableQuantizer
 from model_compression_toolkit.logger import Logger

@@ -57,6 +57,7 @@ def get_versions_dict(fqc) -> Dict:
         tpc_minor_version: str = f'{fqc.tpc.tpc_minor_version}'
         tpc_patch_version: str = f'{fqc.tpc.tpc_patch_version}'
         tpc_platform_type: str = f'{fqc.tpc.tpc_platform_type}'
+        tpc_name: str = f'{fqc.tpc.name}'
         tpc_schema: str = f'{fqc.tpc.SCHEMA_VERSION}'
     return asdict(TPCVersions(mct_version))

@@ -110,7 +110,6 @@ if FOUND_TORCH:
              User information that may be needed to handle the quantized model.
          Examples:
              Import MCT:
              >>> import model_compression_toolkit as mct
@@ -120,21 +119,19 @@ if FOUND_TORCH:
              >>> from torchvision.models import mobilenet_v2
              >>> model = mobilenet_v2(pretrained=True)
-            Create a random dataset generator, for required number of calibration iterations (num_calibration_batches):
-            In this example a random dataset of 10 batches each containing 4 images is used.
+             Create a random dataset generator, for required number of calibration iterations (num_calibration_batches). In this example, a random dataset of 10 batches each containing 4 images is used:
-            >>> import numpy as np
-            >>> num_calibration_batches = 10
-            >>> def repr_datagen():
-            >>>     for _ in range(num_calibration_batches):
-            >>>         yield [np.random.random((4, 3, 224, 224))]
+             >>> import numpy as np
+             >>> num_calibration_batches = 10
+             >>> def repr_datagen():
+             >>>     for _ in range(num_calibration_batches):
+             >>>         yield [np.random.random((4, 3, 224, 224))]
              Create a MCT core config, containing the quantization configuration:
              >>> config = mct.core.CoreConfig()
-             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a
-             quantized model. Now the model contains quantizer wrappers for fine tunning the weights:
+             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a quantized model. Now the model contains quantizer wrappers for fine tunning the weights:
              >>> quantized_model, quantization_info = mct.qat.pytorch_quantization_aware_training_init_experimental(model, repr_datagen, core_config=config)
@@ -149,8 +146,8 @@ if FOUND_TORCH:
         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 "
-                             "MixedPrecisionQuantizationConfig. Please use pytorch_post_training_quantization API,"
-                             "or pass a valid mixed precision configuration.")
+                                "MixedPrecisionQuantizationConfig. Please use pytorch_post_training_quantization API,"
+                                "or pass a valid mixed precision configuration.")
         tb_w = init_tensorboard_writer(DEFAULT_PYTORCH_INFO)
         fw_impl = PytorchImplementation()

mct-nightly 2.2.0.20250121.508__tar.gz → 2.3.0.20250122.511__tar.gz

mct-nightly 2.2.0.20250121.508tar.gz → 2.3.0.20250122.511tar.gz