PyPI - mct-nightly - Versions diffs - 2.3.0.20250303.547__tar.gz → 2.3.0.20250305.525__tar.gz - Mend

Files changed (536) hide show

{mct_nightly-2.3.0.20250303.547 → mct_nightly-2.3.0.20250305.525}/model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py RENAMED Viewed

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
-from typing import List
+from typing import List, Tuple, Dict
 from model_compression_toolkit.core import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_search_manager import \
@@ -21,7 +21,6 @@ from model_compression_toolkit.core.common.mixed_precision.mixed_precision_searc
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
     CandidateNodeQuantizationConfig
 from model_compression_toolkit.logger import Logger
-import numpy as np
 def greedy_solution_refinement_procedure(mp_solution: List[int],
@@ -68,9 +67,11 @@ 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.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)
+            valid_candidates = _get_valid_candidates_indices(node_candidates,
+                                                             new_solution[node_idx],
+                                                             target_resource_utilization.activation_restricted(),
+                                                             target_resource_utilization.weight_restricted()
+                                                             )
             # Create a list of ru for the valid candidates.
             updated_ru = []
@@ -108,40 +109,81 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
     return new_solution
-def _get_valid_candidates_indices(node_candidates: List[CandidateNodeQuantizationConfig],
-                                  current_chosen_index: int,
-                                  kernel_attr: str = None) -> List[int]:
+def _get_valid_candidates_indices(
+        node_candidates: List[CandidateNodeQuantizationConfig],
+        current_chosen_index: int,
+        is_activation_restricted: bool,
+        is_weight_restricted: bool
+) -> List[int]:
     """
-    Find node's valid candidates to try and improve the node's MP chosen candidate.
-    Valid indices are indices of candidates that have higher number of bits for both weights and activations
-    (if they are quantized in this node).
+    Find node's valid candidates to improve the node's MP chosen candidate.
+    Valid indices are indices of candidates that have a higher number of bits for both
+    weights and activations. In cases where weights or activations are not restricted (thus,
+    we do not search for an MP solution for them), a candidate is considered to be
+    valid only if the bit-width of the part that is not eligible for MP has equal bit-width
+    to the current candidate.
     Args:
-        node_candidates: Candidates of the node.
-        current_chosen_index: Current index in MP configuration of the node.
-        kernel_attr: The name of the kernel attribute on the node, otherwise None.
+        node_candidates (List[CandidateNodeQuantizationConfig]): List of candidate configurations for the node.
+        current_chosen_index (int): Index of the currently chosen candidate in the list.
+        is_activation_restricted (bool): Indicates whether activation resources are restricted.
+        is_weight_restricted (bool): Indicates whether weight resources are restricted.
     Returns:
-        List of indices of valid candidates.
+        List[int]: List of indices of valid candidates.
     """
+    def get_candidate_bits(candidate: CandidateNodeQuantizationConfig) -> Tuple[Dict[str, int], int]:
+        """
+        Extract weight and activation bits from a candidate.
+        Args:
+            candidate (CandidateNodeQuantizationConfig): A candidate node configuration.
+        Returns:
+            Tuple[Dict[str, int], int]:
+                - A dictionary mapping weight attributes to their bit-widths.
+                - The activation bit-width.
+        """
+        weight_attrs = candidate.weights_quantization_cfg.all_weight_attrs
+        weight_attrs_to_nbits: Dict[str, int] = {
+            w_attr: candidate.weights_quantization_cfg.get_attr_config(w_attr).weights_n_bits
+            for w_attr in weight_attrs
+        }
+        activation_n_bits: int = candidate.activation_quantization_cfg.activation_n_bits
+        return weight_attrs_to_nbits, activation_n_bits
+    def is_valid_candidate(candidate: CandidateNodeQuantizationConfig) -> bool:
+        """
+        Check if a candidate satisfies the weight and activation bit-width constraints to be
+        considered as a valid candidate.
+        Args:
+            candidate (CandidateNodeQuantizationConfig): A candidate node configuration.
+        Returns:
+            bool: True if the candidate is valid, False otherwise.
+        """
+        candidate_weight_bits, candidate_activation_bits = get_candidate_bits(candidate)
+        # Current candidate - no need to check
+        if candidate_activation_bits == current_activation_bits and all(candidate_weight_bits[attr] == current_weight_bits[attr] for attr in current_weight_bits.keys()):
+            return False
+        valid_weight = all(
+            candidate_weight_bits[attr] >= current_weight_bits[attr] if is_weight_restricted else
+            candidate_weight_bits[attr] == current_weight_bits[attr]
+            for attr in current_weight_bits.keys()
+        )
+        valid_activation = (
+            candidate_activation_bits >= current_activation_bits if is_activation_restricted else
+            candidate_activation_bits == current_activation_bits
+        )
+        return valid_weight and valid_activation
     current_candidate = node_candidates[current_chosen_index]
+    current_weight_bits, current_activation_bits = get_candidate_bits(current_candidate)
-    if kernel_attr is None:
-        # In this node we only quantize activation, so no need to check weights number of bits
-        activation_num_bits = current_candidate.activation_quantization_cfg.activation_n_bits
-        # Filter candidates that have higher bit-width for activations
-        return [i for i, c in enumerate(node_candidates) if
-                c.activation_quantization_cfg.activation_n_bits >= activation_num_bits
-                and not (c.activation_quantization_cfg.activation_n_bits == activation_num_bits)]
-    else:
-        weights_num_bits = current_candidate.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits
-        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
-                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)]
+    return [idx for idx, candidate in enumerate(node_candidates) if is_valid_candidate(candidate)]

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.3.0.20250303.547
+Version: 2.3.0.20250305.525
 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.3.0.20250303.547
+Version: 2.3.0.20250305.525
 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.3.0.20250303.000547"
+__version__ = "2.3.0.20250305.000525"

@@ -16,7 +16,6 @@ import numpy as np
 from model_compression_toolkit.core import ResourceUtilization, FrameworkInfo
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
     FrameworkQuantizationCapabilities
@@ -48,31 +47,23 @@ def filter_candidates_for_mixed_precision(graph: Graph,
     if tru.weight_restricted() and not tru.activation_restricted():
         # Running mixed precision for weights compression only -
         # filter out candidates activation only configurable node
-        weights_conf = graph.get_weights_configurable_nodes(fw_info)
-        activation_configurable_nodes = [n for n in graph.get_activation_configurable_nodes() if n not in weights_conf]
+        activation_configurable_nodes = [n for n in graph.get_activation_configurable_nodes()]
         for n in activation_configurable_nodes:
             base_cfg_nbits = n.get_qco(fqc).base_config.activation_n_bits
             filtered_conf = [c for c in n.candidates_quantization_cfg if
                              c.activation_quantization_cfg.enable_activation_quantization and
                              c.activation_quantization_cfg.activation_n_bits == base_cfg_nbits]
-            if len(filtered_conf) != 1:
-                Logger.critical(f"Running weights only mixed precision failed on layer {n.name} with multiple "
-                                f"activation quantization configurations.")  # pragma: no cover
             n.candidates_quantization_cfg = filtered_conf
     elif tru.activation_restricted() and not tru.weight_restricted():
         # Running mixed precision for activation compression only -
         # filter out candidates weights only configurable node
-        activation_conf = graph.get_activation_configurable_nodes()
-        weight_configurable_nodes = [n for n in graph.get_weights_configurable_nodes(fw_info) if n not in activation_conf]
+        weight_configurable_nodes = [n for n in graph.get_weights_configurable_nodes(fw_info)]
         for n in weight_configurable_nodes:
-            kernel_attr = graph.fw_info.get_kernel_op_attributes(n.type)[0]
+            kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
             base_cfg_nbits = n.get_qco(fqc).base_config.attr_weights_configs_mapping[kernel_attr].weights_n_bits
             filtered_conf = [c for c in n.candidates_quantization_cfg if
                              c.weights_quantization_cfg.get_attr_config(kernel_attr).enable_weights_quantization and
                              c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits == base_cfg_nbits]
-            if len(filtered_conf) != 1:
-                Logger.critical(f"Running activation only mixed precision failed on layer {n.name} with multiple "
-                                f"weights quantization configurations.")  # pragma: no cover
             n.candidates_quantization_cfg = filtered_conf

@@ -70,7 +70,7 @@ class AttachTpcToPytorch(AttachTpcToFramework):
             OperatorSetNames.HARDSWISH: [Hardswish, hardswish],
             OperatorSetNames.FLATTEN: [Flatten, flatten],
             OperatorSetNames.GET_ITEM: [operator.getitem],
-            OperatorSetNames.RESHAPE: [reshape],
+            OperatorSetNames.RESHAPE: [reshape, torch.Tensor.view],
             OperatorSetNames.UNSQUEEZE: [unsqueeze],
             OperatorSetNames.SQUEEZE: [squeeze],
             OperatorSetNames.PERMUTE: [permute],

@@ -137,6 +137,7 @@ def generate_tpc(default_config: OpQuantizationConfig,
     # 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]))
+    base_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([base_config]), base_config=base_config)
     # In TFLite, the quantized operator specifications constraint operators quantization
     # differently. For more details:
@@ -179,13 +180,13 @@ def generate_tpc(default_config: OpQuantizationConfig,
                                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(
+                             qc_options=base_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)
+    conv2d = schema.OperatorsSet(name=schema.OperatorSetNames.CONV, qc_options=base_configuration_options)
     relu = schema.OperatorsSet(name=schema.OperatorSetNames.RELU)
     relu6 = schema.OperatorsSet(name=schema.OperatorSetNames.RELU6)
     elu = schema.OperatorsSet(name=schema.OperatorSetNames.ELU)

mct-nightly 2.3.0.20250303.547__tar.gz → 2.3.0.20250305.525__tar.gz

mct-nightly 2.3.0.20250303.547tar.gz → 2.3.0.20250305.525tar.gz