mct-nightly 2.1.0.20240731.414__py3-none-any.whl → 2.1.0.20240802.429__py3-none-any.whl

model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py

@@ -60,33 +60,6 @@ def calculate_delta(threshold: np.ndarray,
     return threshold / (2 ** (n_bits - int(signed)))
 
 
-def calculate_min_max_values(threshold: np.ndarray,
-                             n_bits: int = 8,
-                             signed: bool = False) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Compute the min/max values of a quantization range according to the threshold,
-    number of bits and whether its signed or unsigned.
-
-    Args:
-        threshold: Threshold of quantization range to compute its min/max values.
-        n_bits: Number of bits used in the quantization.
-        signed: Whether the quantization range is signed or not.
-
-    Returns:
-        Min/max values of quantization range.
-    """
-
-    delta = calculate_delta(threshold,
-                            n_bits=n_bits,
-                            signed=signed)
-
-    # If unsigned: min=0, otherwise its -threshold
-    min_value = int(signed) * -threshold
-    max_value = threshold - delta
-
-    return min_value, max_value
-
-
 def quantize_tensor(tensor_data: np.ndarray,
                     threshold: np.ndarray,
                     n_bits: int,
@@ -238,7 +211,7 @@ def get_tensor_max(tensor_data: np.ndarray,
 
     """
     if n_bits < 1:
-        Logger.critical(f"Parameter n_bits must be positive; however 'n_bits'={n_bits} was provided.")
+        Logger.critical(f"Parameter n_bits must be positive; however 'n_bits'={n_bits} was provided.")  # pragma: no cover
     if is_uniform_quantization:
         expansion_factor = 1.0
     elif n_bits == 1:
@@ -337,40 +310,3 @@ def get_output_shape(tensor_shape, channel_axis):
 
     """
     return [-1 if i is channel_axis else 1 for i in range(len(tensor_shape))]
-
-
-def get_range_bounds(tensor_min, tensor_max):
-    """
-    Gets bounds on the quantization range limits for the minimization process.
-    Calculates the bounds in a way that would leave a gap between the possible optimized values
-    and the tensor min-max values.
-
-    Args:
-        tensor_min: min value of a tensor.
-        tensor_max: max value of a tensor.
-
-    Returns: An array with (lbound, ubound) pairs on the quantization range limit values.
-
-    """
-    # choosing bounds that have some gap from the original tensor min/max values.
-    l_bound = tensor_min / 2 if tensor_min > 0 else tensor_min * 2
-    u_bound = tensor_max * 2 if tensor_max > 0 else tensor_min / 2
-    return [(l_bound, u_bound), (l_bound, u_bound)]
-
-
-def get_threshold_bounds(min_threshold, max_threshold):
-    """
-    Gets bounds on the threshold for the minimization process.
-    Calculates the bounds in a way that would leave a gap between the possible optimized threshold
-    and the tensor max values. We use min_threshold as lower-bound to prevent the selected threshold
-    from being zero or negative.
-
-    Args:
-        min_threshold: minimal threshold to use if threshold is too small (not used for this method).
-        max_threshold: maximal threshold to be used in quantization.
-
-    Returns: An array with a pair of (lbound, ubound) on the quantization threshold limit values.
-
-    """
-    max_threshold = max(min_threshold, max_threshold)
-    return [(min_threshold, 2 * max_threshold)]

model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -64,6 +64,7 @@ def set_quantization_configuration_to_graph(graph: Graph,
 
     for n in graph.nodes:
         set_quantization_configs_to_node(node=n,
+                                         graph=graph,
                                          quant_config=quant_config,
                                          fw_info=graph.fw_info,
                                          tpc=graph.tpc,
@@ -72,6 +73,7 @@ def set_quantization_configuration_to_graph(graph: Graph,
 
 
 def set_quantization_configs_to_node(node: BaseNode,
+                                     graph: Graph,
                                      quant_config: QuantizationConfig,
                                      fw_info: FrameworkInfo,
                                      tpc: TargetPlatformCapabilities,
@@ -81,19 +83,22 @@ def set_quantization_configs_to_node(node: BaseNode,
 
     Args:
         node: Node to set its quantization configurations.
+        graph: Model's internal representation graph.
         quant_config: Quantization configuration to generate the node's configurations from.
         fw_info: Information needed for quantization about the specific framework.
         tpc: TargetPlatformCapabilities to get default OpQuantizationConfig.
         mixed_precision_enable: is mixed precision enabled.
     """
     node_qc_options = node.get_qco(tpc)
+    base_config, node_qc_options_list = node.filter_node_qco_by_graph(tpc, graph.get_next_nodes(node), node_qc_options)
 
     # Create QC candidates for weights and activation combined
     weight_channel_axis = fw_info.kernel_channels_mapping.get(node.type)
     node.candidates_quantization_cfg = _create_node_candidates_qc(quant_config,
                                                                   fw_info,
                                                                   weight_channel_axis,
-                                                                  node_qc_options,
+                                                                  node_qc_options_list,
+                                                                  base_config,
                                                                   node,
                                                                   mixed_precision_enable=mixed_precision_enable)
 
@@ -186,7 +191,8 @@ def _create_node_single_candidate_qc(qc: QuantizationConfig,
 def _create_node_candidates_qc(qc: QuantizationConfig,
                                fw_info: FrameworkInfo,
                                weight_channel_axis: Tuple[int, int],
-                               node_qc_options: QuantizationConfigOptions,
+                               node_qc_options_list: List[OpQuantizationConfig],
+                               base_config: OpQuantizationConfig,
                                node: BaseNode,
                                mixed_precision_enable: bool = False) -> List[CandidateNodeQuantizationConfig]:
     """
@@ -196,7 +202,8 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
         qc: Quantization configuration the quantization process should follow.
         fw_info: Framework information (e.g., which layers should have their kernels' quantized).
         weight_channel_axis: (Output, Input) channel index of the node's kernel.
-        node_qc_options: QuantizationConfigOptions for the node with quantization candidates information.
+        node_qc_options_list: List of quantization configs of node.
+        base_config: Base quantization config for node.
         node: A node to set quantization configuration candidates to.
         mixed_precision_enable: is mixed precision enabled
 
@@ -208,7 +215,7 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
     node_attrs_list = node.get_node_weights_attributes()
 
     if mixed_precision_enable:
-        for op_cfg in node_qc_options.quantization_config_list:
+        for op_cfg in node_qc_options_list:
             candidate_qc = copy.deepcopy(qc)
             candidates.append(_create_node_single_candidate_qc(candidate_qc,
                                                                fw_info,
@@ -220,7 +227,7 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
         candidates.append(_create_node_single_candidate_qc(qc,
                                                            fw_info,
                                                            weight_channel_axis,
-                                                           node_qc_options.base_config,
+                                                           base_config,
                                                            node_attrs_list))
 
     return candidates

model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -349,9 +349,15 @@ def shift_negative_function(graph: Graph,
                                    add_node.output_shape,
                                    pad_top, pad_btm, pad_left, pad_right)
 
+        # Insert a pad node between the add node to the op2d, and create statistics for the pad node
+        insert_node_before_node(graph,
+                                node_to_insert=pad_node,
+                                last_node=op2d_node)
+
         # Set quantization configuration to node, even though we do not quantize it:
         set_quantization_configs_to_node(fw_info=fw_info,
                                          node=pad_node,
+                                         graph=graph,
                                          quant_config=core_config.quantization_config,
                                          tpc=graph.tpc,
                                          mixed_precision_enable=core_config.mixed_precision_enable)
@@ -361,11 +367,6 @@ def shift_negative_function(graph: Graph,
             for attr in pad_node.get_node_weights_attributes():
                 candidate_qc.weights_quantization_cfg.get_attr_config(attr).enable_weights_quantization = False
 
-        # Insert a pad node between the add node to the op2d, and create statistics for the pad node
-        insert_node_before_node(graph,
-                                node_to_insert=pad_node,
-                                last_node=op2d_node)
-
         graph.set_out_stats_collector_to_node(pad_node,
                                               add_node_stats_collector)  # We ignore the padding effect on statistics
 
@@ -373,6 +374,7 @@ def shift_negative_function(graph: Graph,
 
     set_quantization_configs_to_node(fw_info=fw_info,
                                      node=add_node,
+                                     graph=graph,
                                      quant_config=core_config.quantization_config,
                                      tpc=graph.tpc,
                                      mixed_precision_enable=core_config.mixed_precision_enable)

model_compression_toolkit/core/keras/back2framework/factory_model_builder.py

@@ -37,10 +37,10 @@ def get_keras_model_builder(mode: ModelBuilderMode) -> type:
         Keras model builder for the given mode.
     """
 
-    if not isinstance(mode, ModelBuilderMode):
+    if not isinstance(mode, ModelBuilderMode):  # pragma: no cover
         Logger.critical(f"Expected a ModelBuilderMode type for 'mode', but received {type(mode)} instead.")
-    if mode is None:
+    if mode is None:  # pragma: no cover
         Logger.critical(f"get_keras_model_builder received 'mode' is None")
-    if mode not in keras_model_builders.keys():
+    if mode not in keras_model_builders.keys():  # pragma: no cover
         Logger.critical(f"'mode' {mode} is not recognized in the Keras model builders factory.")
     return keras_model_builders.get(mode)

model_compression_toolkit/core/keras/keras_implementation.py

@@ -21,6 +21,7 @@ from mct_quantizers import KerasQuantizationWrapper, KerasActivationQuantization
 from tensorflow.keras.models import Model
 
 from model_compression_toolkit.constants import HESSIAN_NUM_ITERATIONS
+from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianMode, HessianInfoService
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.remove_identity import RemoveIdentity
 from model_compression_toolkit.core.keras.hessian.activation_hessian_scores_calculator_keras import \
@@ -421,44 +422,47 @@ class KerasImplementation(FrameworkImplementation):
 
         return False
 
-    def get_mp_node_distance_fn(self, layer_class: type,
-                             framework_attrs: Dict[str, Any],
-                             compute_distance_fn: Callable = None,
-                             axis: int = None,
-                             norm_mse: bool = False) -> Callable:
+    def get_mp_node_distance_fn(self, n: BaseNode,
+                                compute_distance_fn: Callable = None,
+                                norm_mse: bool = False) -> Tuple[Callable, int]:
         """
         A mapping between layers' types and a distance function for computing the distance between
         two tensors in mixed precision (for loss computation purposes). Returns a specific function if node of specific types is
         given, or a default (normalized MSE) function otherwise.
 
         Args:
-            layer_class: Class path of a model's layer.
-            framework_attrs: Framework attributes the layer had which the graph node holds.
+            n: Node to choose distance function for.
             compute_distance_fn: An optional distance function to use globally for all nodes.
-            axis: The axis on which the operation is preformed (if specified).
             norm_mse: whether to normalize mse distance function.
 
-        Returns: A distance function between two tensors.
+        Returns: A distance function between two tensors and a axis on which the distance is computed (if exists).
         """
 
+        axis = n.framework_attr.get(keras_constants.AXIS) \
+            if not isinstance(n, FunctionalNode) else n.op_call_kwargs.get(keras_constants.AXIS)
+
+        layer_class = n.layer_class
+        framework_attrs = n.framework_attr
+
         if compute_distance_fn is not None:
-            return compute_distance_fn
+            return compute_distance_fn, axis
 
         if layer_class == Activation:
             node_type_name = framework_attrs[ACTIVATION]
             if node_type_name == SOFTMAX and axis is not None:
-                return compute_kl_divergence
+                return compute_kl_divergence, axis
             elif node_type_name == SIGMOID:
-                return compute_cs
+                return compute_cs, axis
         elif axis is not None and (layer_class == tf.nn.softmax or layer_class == tf.keras.layers.Softmax
                                    or (layer_class == TFOpLambda and
                                        SOFTMAX in framework_attrs[keras_constants.FUNCTION])):
-            return compute_kl_divergence
-        elif layer_class == tf.nn.sigmoid:
-            return compute_cs
+            return compute_kl_divergence, axis
+        elif layer_class == tf.nn.sigmoid or (layer_class == TFOpLambda and
+                                              SIGMOID in framework_attrs[keras_constants.FUNCTION]):
+            return compute_cs, axis
         elif layer_class == Dense:
-            return compute_cs
-        return partial(compute_mse, norm=norm_mse)
+            return compute_cs, axis
+        return partial(compute_mse, norm=norm_mse), axis
 
     def get_hessian_scores_calculator(self,
                                       graph: Graph,

model_compression_toolkit/core/keras/tf_tensor_numpy.py

@@ -36,7 +36,7 @@ def to_tf_tensor(tensor):
         return (to_tf_tensor(t) for t in tensor)
     elif isinstance(tensor, np.ndarray):
         return tf.convert_to_tensor(tensor.astype(np.float32))
-    else:
+    else:  # pragma: no cover
         Logger.critical(f'Unsupported type for conversion to TF tensor: {type(tensor)}.')
 
 
@@ -69,5 +69,5 @@ def tf_tensor_to_numpy(tensor: Union[List, Tuple, np.ndarray, tf.Tensor, float],
         return np.array([np_tensor]) if np.isscalar(np_tensor) else np_tensor
     elif isinstance(tensor, float):
         return np.array([tensor])
-    else:
+    else:  # pragma: no cover
         Logger.critical(f'Unsupported type for conversion to Numpy array: {type(tensor)}.')

model_compression_toolkit/core/pytorch/back2framework/factory_model_builder.py

@@ -37,10 +37,10 @@ def get_pytorch_model_builder(mode: ModelBuilderMode) -> type:
         PyTorch model builder for the given mode.
     """
 
-    if not isinstance(mode, ModelBuilderMode):
+    if not isinstance(mode, ModelBuilderMode):  # pragma: no cover
         Logger.critical(f"Expected a ModelBuilderMode type for 'mode' parameter; received {type(mode)} instead.")
-    if mode is None:
+    if mode is None:  # pragma: no cover
         Logger.critical(f"Received 'mode' parameter is None.")
-    if mode not in pytorch_model_builders.keys():
+    if mode not in pytorch_model_builders.keys():  # pragma: no cover
         Logger.critical(f"'mode' parameter {mode} is not supported by the PyTorch model builders factory.")
     return pytorch_model_builders.get(mode)

model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -30,6 +30,7 @@ from model_compression_toolkit.core import QuantizationConfig, FrameworkInfo, Co
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common import Graph, BaseNode
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.hessian import HessianScoresRequest, HessianMode, HessianInfoService
 from model_compression_toolkit.core.common.mixed_precision.sensitivity_evaluation import SensitivityEvaluation
 from model_compression_toolkit.core.common.mixed_precision.set_layer_to_bitwidth import set_layer_to_bitwidth
@@ -403,36 +404,36 @@ class PytorchImplementation(FrameworkImplementation):
             return True
         return False
 
-    def get_mp_node_distance_fn(self, layer_class: type,
-                             framework_attrs: Dict[str, Any],
-                             compute_distance_fn: Callable = None,
-                             axis: int = None,
-                             norm_mse: bool = False) -> Callable:
+    def get_mp_node_distance_fn(self, n: BaseNode,
+                                compute_distance_fn: Callable = None,
+                                norm_mse: bool = False) -> Tuple[Callable, int]:
         """
         A mapping between layers' types and a distance function for computing the distance between
         two tensors in mixed precision (for loss computation purposes). Returns a specific function if node of specific types is
         given, or a default (normalized MSE) function otherwise.
 
         Args:
-            layer_class: Class path of a model's layer.
-            framework_attrs: Framework attributes the layer had which the graph node holds.
+            n: Node to choose distance function for.
             compute_distance_fn: An optional distance function to use globally for all nodes.
-            axis: The axis on which the operation is preformed (if specified).
             norm_mse: whether to normalize mse distance function.
 
-        Returns: A distance function between two tensors.
+        Returns: A distance function between two tensors and a axis on which the distance is computed (if exists).
         """
+        axis = n.framework_attr.get(pytorch_constants.DIM) if not (
+            isinstance(n, FunctionalNode)) else n.op_call_kwargs.get(pytorch_constants.DIM)
+
+        layer_class = n.layer_class
 
         if compute_distance_fn is not None:
-            return compute_distance_fn
+            return compute_distance_fn, axis
 
         elif layer_class in [Softmax, softmax] and axis is not None:
-            return compute_kl_divergence
+            return compute_kl_divergence, axis
         elif layer_class in [Sigmoid, sigmoid]:
-            return compute_cs
+            return compute_cs, axis
         elif layer_class == Linear:
-            return compute_cs
-        return partial(compute_mse, norm=norm_mse)
+            return compute_cs, axis
+        return partial(compute_mse, norm=norm_mse), axis
 
     def is_output_node_compatible_for_hessian_score_computation(self,
                                                                 node: BaseNode) -> bool:

model_compression_toolkit/core/pytorch/reader/node_holders.py

@@ -25,7 +25,7 @@ class DummyPlaceHolder(torch.nn.Module):
     """
 
     def __name__(self):
-        return PLACEHOLDER
+        return PLACEHOLDER  # pragma: no cover
 
     def forward(self, x):
         return x

model_compression_toolkit/core/runner.py

@@ -222,5 +222,6 @@ def _set_final_resource_utilization(graph: Graph,
 
     final_ru = ResourceUtilization()
     final_ru.set_resource_utilization_by_target(final_ru_dict)
+    print(final_ru)
     graph.user_info.final_resource_utilization = final_ru
     graph.user_info.mixed_precision_cfg = final_bit_widths_config

model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py

@@ -24,7 +24,7 @@ if FOUND_TF:
     if version.parse(tf.__version__) >= version.parse("2.13"):
         from keras.src.engine.base_layer import Layer
         from keras.src.engine.input_layer import InputLayer
-    else:
+    else:  # pragma: no cover
         from keras.engine.base_layer import Layer
         from keras.engine.input_layer import InputLayer
 
@@ -57,7 +57,7 @@ if FOUND_TF:
                     f'KerasQuantizationWrapper must have a weights_quantizers but has a '
                     f'{type(layer.weights_quantizers)} object') # pragma: no cover
 
-            if len(layer.weights_quantizers) == 0:
+            if len(layer.weights_quantizers) == 0:  # pragma: no cover
                 Logger.critical(f'KerasQuantizationWrapper must have at least one weight quantizer, but found {len(layer.weights_quantizers)} quantizers. If layer is not quantized it should be a Keras layer.')
 
             for _, weights_quantizer in layer.weights_quantizers.items():

model_compression_toolkit/gptq/common/gptq_training.py

@@ -219,41 +219,6 @@ class GPTQTrainer(ABC):
 
         return hessian_approx_score_by_image
 
-    def _get_approximations_by_interest_point(self, approximations: Dict, image_idx: int) -> List:
-        """
-        Retrieves hessian approximations for a specific image index.
-
-        Args:
-            approximations (Dict): Hessian approximations.
-            image_idx (int): Image index.
-
-        Returns:
-            List: Hessian approximations for the given image index.
-        """
-        approx_by_interest_point = []
-        for target_node in self.compare_points:
-            hessian_approx_scores = approximations[target_node][image_idx]
-            self._validate_scores_approximation(hessian_approx_scores)
-            approx_by_interest_point.append(hessian_approx_scores[0])
-        return approx_by_interest_point
-
-    @staticmethod
-    def _validate_scores_approximation(hessian_approx_scores: List):
-        """
-        Validates the structure and length of the Hessian-approximation scores.
-
-        Args:
-            hessian_approx_scores: Scores to validate.
-        """
-        if not isinstance(hessian_approx_scores, list):
-            Logger.critical(f"Scores approximation was expected to be a list but is of type: {type(hessian_approx_scores)}.")   # pragma: no cover
-        if len(hessian_approx_scores) != 1:
-            Logger.critical(f"Scores approximation was expected to have a length of 1 "
-                            f"(for computations with granularity set to 'HessianInfoGranularity.PER_TENSOR') "
-                            f"but has a length of {len(hessian_approx_scores)}."
-            )   # pragma: no cover
-
-
     @abstractmethod
     def build_gptq_model(self):
         """

model_compression_toolkit/qat/keras/quantizer/base_keras_qat_quantizer.py

@@ -38,7 +38,7 @@ if FOUND_TF:
 
             super().__init__(quantization_config)
 
-else:
+else:  # pragma: no cover
     class BaseKerasQATTrainableQuantizer(BaseKerasTrainableQuantizer):
         def __init__(self,
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):

model_compression_toolkit/qat/pytorch/quantizer/base_pytorch_qat_quantizer.py

@@ -39,7 +39,7 @@ if FOUND_TORCH:
             """
             super().__init__(quantization_config)
 
-else:
+else:  # pragma: no cover
     class BasePytorchQATTrainableQuantizer(BasePytorchTrainableQuantizer):
         def __init__(self,
                      quantization_config: Union[TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]):

model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 
 import copy
-from typing import List, Dict, Union, Any
+from typing import List, Dict, Union, Any, Tuple
 
 from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
@@ -96,7 +96,7 @@ class AttributeQuantizationConfig:
             Whether this configuration is equal to another object or not.
         """
         if not isinstance(other, AttributeQuantizationConfig):
-            return False
+            return False  # pragma: no cover
         return self.weights_quantization_method == other.weights_quantization_method and \
             self.weights_n_bits == other.weights_n_bits and \
             self.weights_per_channel_threshold == other.weights_per_channel_threshold and \
@@ -114,11 +114,13 @@ class OpQuantizationConfig:
                  attr_weights_configs_mapping: Dict[str, AttributeQuantizationConfig],
                  activation_quantization_method: QuantizationMethod,
                  activation_n_bits: int,
+                 supported_input_activation_n_bits: Union[int, Tuple[int]],
                  enable_activation_quantization: bool,
                  quantization_preserving: bool,
                  fixed_scale: float,
                  fixed_zero_point: int,
-                 simd_size: int
+                 simd_size: int,
+                 is_signed: bool = None
                  ):
         """
 
@@ -127,10 +129,12 @@ class OpQuantizationConfig:
             attr_weights_configs_mapping (Dict[str, AttributeQuantizationConfig]): A mapping between an op attribute name and its quantization configuration.
             activation_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for activation quantization.
             activation_n_bits (int): Number of bits to quantize the activations.
+            supported_input_activation_n_bits (int or Tuple[int]): Number of bits that operator accepts as input.
             enable_activation_quantization (bool): Whether to quantize the model activations or not.
             quantization_preserving (bool): Whether quantization parameters should be the same for an operator's input and output.
             fixed_scale (float): Scale to use for an operator quantization parameters.
             fixed_zero_point (int): Zero-point to use for an operator quantization parameters.
+            is_signed (bool): Force activation quantization signedness (None means don't force).
             simd_size (int): Per op integer representing the Single Instruction, Multiple Data (SIMD) width of an operator. It indicates the number of data elements that can be fetched and processed simultaneously in a single instruction.
 
         """
@@ -140,10 +144,17 @@ class OpQuantizationConfig:
 
         self.activation_quantization_method = activation_quantization_method
         self.activation_n_bits = activation_n_bits
+        if isinstance(supported_input_activation_n_bits, tuple):
+            self.supported_input_activation_n_bits = supported_input_activation_n_bits
+        elif isinstance(supported_input_activation_n_bits, int):
+            self.supported_input_activation_n_bits = (supported_input_activation_n_bits,)
+        else:
+            Logger.critical(f"Supported_input_activation_n_bits only accepts int or tuple of ints, but got {type(supported_input_activation_n_bits)}")  # pragma: no cover
         self.enable_activation_quantization = enable_activation_quantization
         self.quantization_preserving = quantization_preserving
         self.fixed_scale = fixed_scale
         self.fixed_zero_point = fixed_zero_point
+        self.is_signed = is_signed
         self.simd_size = simd_size
 
     def get_info(self):
@@ -152,7 +163,7 @@ class OpQuantizationConfig:
         Returns: Info about the quantization configuration as a dictionary.
 
         """
-        return self.__dict__
+        return self.__dict__  # pragma: no cover
 
     def clone_and_edit(self, attr_to_edit: Dict[str, Dict[str, Any]] = {}, **kwargs):
         """
@@ -188,14 +199,26 @@ class OpQuantizationConfig:
             Whether this configuration is equal to another object or not.
         """
         if not isinstance(other, OpQuantizationConfig):
-            return False
+            return False  # pragma: no cover
         return self.default_weight_attr_config == other.default_weight_attr_config and \
             self.attr_weights_configs_mapping == other.attr_weights_configs_mapping and \
             self.activation_quantization_method == other.activation_quantization_method and \
             self.activation_n_bits == other.activation_n_bits and \
+            self.supported_input_activation_n_bits == other.supported_input_activation_n_bits and \
             self.enable_activation_quantization == other.enable_activation_quantization and \
+            self.is_signed == other.is_signed and \
             self.simd_size == other.simd_size
 
+    @property
+    def max_input_activation_n_bits(self) -> int:
+        """
+        Get maximum supported input bit-width.
+
+        Returns: Maximum supported input bit-width.
+
+        """
+        return max(self.supported_input_activation_n_bits)
+
 
 class QuantizationConfigOptions:
     """
@@ -279,12 +302,12 @@ class QuantizationConfigOptions:
             if attrs is None:
                 attrs_to_update = list(qc.attr_weights_configs_mapping.keys())
             else:
-                if not isinstance(attrs, List):
+                if not isinstance(attrs, List):  # pragma: no cover
                     Logger.critical(f"Expected a list of attributes but received {type(attrs)}.")
                 attrs_to_update = attrs
 
             for attr in attrs_to_update:
-                if qc.attr_weights_configs_mapping.get(attr) is None:
+                if qc.attr_weights_configs_mapping.get(attr) is None:  # pragma: no cover
                     Logger.critical(f'Editing attributes is only possible for existing attributes in the configuration\'s '
                                     f'weights config mapping; {attr} does not exist in {qc}.')
                 self.__edit_quantization_configuration(qc.attr_weights_configs_mapping[attr], kwargs)
@@ -310,6 +333,7 @@ class QuantizationConfigOptions:
         # If not, add base_config to the list of configurations to update
         cfgs_to_update = [cfg for cfg in qc_options.quantization_config_list]
         if not any(qc_options.base_config is cfg for cfg in cfgs_to_update):
+            # TODO: add test for this case
             cfgs_to_update.append(qc_options.base_config)
 
         for qc in cfgs_to_update:
@@ -319,7 +343,7 @@ class QuantizationConfigOptions:
                 new_attr_mapping = {}
                 for attr in list(qc.attr_weights_configs_mapping.keys()):
                     new_key = layer_attrs_mapping.get(attr)
-                    if new_key is None:
+                    if new_key is None:  # pragma: no cover
                         Logger.critical(f"Attribute \'{attr}\' does not exist in the provided attribute mapping.")
 
                     new_attr_mapping[new_key] = qc.attr_weights_configs_mapping.pop(attr)

model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py

@@ -96,7 +96,7 @@ class TargetPlatformModel(ImmutableClass):
         for op_set in self.operator_set:
             if operators_set_name == op_set.name:
                 return op_set.qc_options
-        return get_default_quantization_config_options()
+        return self.default_qco
 
     def get_default_op_quantization_config(self) -> OpQuantizationConfig:
         """
@@ -158,7 +158,7 @@ class TargetPlatformModel(ImmutableClass):
             self.fusing_patterns.append(tp_model_component)
         elif isinstance(tp_model_component, OperatorsSetBase):
             self.operator_set.append(tp_model_component)
-        else:
+        else:  # pragma: no cover
             Logger.critical(f'Attempted to append an unrecognized TargetPlatformModelComponent of type: {type(tp_model_component)}.')
 
     def __enter__(self):