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/candidate_node_quantization_config.py

@@ -58,7 +58,7 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
         if activation_quantization_cfg is not None:
             self.activation_quantization_cfg = activation_quantization_cfg
         else:
-            if any(v is None for v in (qc, op_cfg, activation_quantization_fn, activation_quantization_params_fn)):
+            if any(v is None for v in (qc, op_cfg, activation_quantization_fn, activation_quantization_params_fn)):  # pragma: no cover
                 Logger.critical(
                     "Missing required arguments to initialize a node activation quantization configuration. "
                     "Ensure QuantizationConfig, OpQuantizationConfig, activation quantization function, "
@@ -72,7 +72,7 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
         if weights_quantization_cfg is not None:
             self.weights_quantization_cfg = weights_quantization_cfg
         else:
-            if any(v is None for v in (qc, op_cfg, node_attrs_list)):
+            if any(v is None for v in (qc, op_cfg, node_attrs_list)):  # pragma: no cover
                 Logger.critical("Missing required arguments to initialize a node weights quantization configuration. "
                                 "Ensure QuantizationConfig, OpQuantizationConfig, weights quantization function, "
                                 "parameters function, and weights attribute quantization config are provided.")

model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -96,6 +96,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         self.activation_n_bits = op_cfg.activation_n_bits
         self.relu_bound_to_power_of_2 = qc.relu_bound_to_power_of_2
         self.enable_activation_quantization = op_cfg.enable_activation_quantization
+        self.is_signed = op_cfg.is_signed
         self.activation_channel_equalization = qc.activation_channel_equalization
         self.input_scaling = qc.input_scaling
         self.min_threshold = qc.min_threshold
@@ -178,20 +179,6 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         for param_name, param_value in activation_params.items():
             self.activation_quantization_params[param_name] = param_value
 
-    def has_activation_quantization_params(self) -> bool:
-        """
-
-        Returns: Whether NodeQuantizationConfig has a activation quantization params or not.
-
-        """
-        return len(self.activation_quantization_params) > 0
-
-    def no_quantization(self) -> bool:
-        """
-        Returns: Whether NodeQuantizationConfig does not have activation params.
-        """
-        return (not self.has_activation_quantization_params())
-
     def __eq__(self, other: Any) -> bool:
         """
         Compares the object to another object to find if they are equal.
@@ -203,7 +190,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
 
         """
         if not isinstance(other, NodeActivationQuantizationConfig):
-            return False
+            return False  # pragma: no cover
 
         return self.activation_quantization_fn == other.activation_quantization_fn and \
                self.activation_quantization_params_fn == other.activation_quantization_params_fn and \
@@ -340,14 +327,6 @@ class WeightsAttrQuantizationConfig:
         else:
             self.set_weights_quantization_param({})
 
-    def has_weights_quantization_params(self) -> bool:
-        """
-
-        Returns: Whether NodeQuantizationConfig has weights quantization params or not.
-
-        """
-        return len(self.weights_quantization_params) > 0
-
     def __eq__(self, other: Any) -> bool:
         """
         Compares the object to another object to find if they are equal.
@@ -359,7 +338,7 @@ class WeightsAttrQuantizationConfig:
 
         """
         if not isinstance(other, WeightsAttrQuantizationConfig):
-            return False
+            return False  # pragma: no cover
 
         return self.weights_quantization_fn == other.weights_quantization_fn and \
                self.weights_quantization_params_fn == other.weights_quantization_params_fn and \
@@ -419,11 +398,11 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 # In Tensorflow, the attribute name is composed of the framework attribute name and the layer name,
                 # therefore, we need to look for the attribute in the op_cfg that is contained in the node attribute's name.
                 attrs_included_in_name = {k: v for k, v in op_cfg.attr_weights_configs_mapping.items() if k in attr}
-                if len(attrs_included_in_name) > 1:
-                    Logger.error(f"Found multiple attribute in TPC OpConfig that are contained "
-                                 f"in the attribute name '{attr}'."
-                                 f"Please fix the TPC attribute names mapping such that each operator's attribute would "
-                                 f"have a unique matching name.")
+                if len(attrs_included_in_name) > 1:  # pragma: no cover
+                    Logger.critical(f"Found multiple attribute in TPC OpConfig that are contained "
+                                    f"in the attribute name '{attr}'."
+                                    f"Please fix the TPC attribute names mapping such that each operator's attribute would "
+                                    f"have a unique matching name.")
                 if len(attrs_included_in_name) == 0:
                     attr_cfg = op_cfg.default_weight_attr_config
                 else:
@@ -446,8 +425,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
         Returns: An attribute quantization configuration.
 
         """
-        if attr_name is None:
-            Logger.error("Got 'None' attribute name for retrieving weights attribute quantization configuration.")
+        if attr_name is None:  # pragma: no cover
+            Logger.critical("Got 'None' attribute name for retrieving weights attribute quantization configuration.")
 
         if isinstance(attr_name, int):
             # this is a positional attribute
@@ -463,8 +442,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 # If no attribute with the exact name then an error would be thrown
                 attr_cfg = self.attributes_config_mapping.get(attr_name)
 
-        if attr_cfg is None:
-            Logger.error(f"Weight attribute '{attr_name}' config could not be found.")
+        if attr_cfg is None:  # pragma: no cover
+            Logger.critical(f"Weight attribute '{attr_name}' config could not be found.")
 
         return attr_cfg
 
@@ -519,8 +498,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                            f"{list(attrs_with_name.keys())}.")
         return attrs_with_name
 
-    def set_quant_config_attr(self, config_parameter_name: str, config_parameter_value: Any, attr_name: str = None,
-                              *args: List[Any], **kwargs: Dict[str, Any]):
+    def set_quant_config_attr(self, config_parameter_name: str, config_parameter_value: Any,
+                              attr_name: Union[str, int] = None, *args: List[Any], **kwargs: Dict[str, Any]):
         """
         This method overrides the parent class set_quant_config_attr to enable setting a specific weights
         attribute config parameter.
@@ -546,8 +525,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 else:
                     Logger.warning(f"Parameter {config_parameter_name} could not be found in the node quantization config of "
                                    f"weights attribute {attr_name} and was not updated!")
-            else:
-                Logger.error(f"Weights attribute {attr_name} could not be found to set parameter {config_parameter_name}.")
+            else:  # pragma: no cover
+                Logger.critical(f"Weights attribute {attr_name} could not be found to set parameter {config_parameter_name}.")
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -560,7 +539,7 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
 
         """
         if not isinstance(other, NodeWeightsQuantizationConfig):
-            return False
+            return False  # pragma: no cover
 
         return self.min_threshold == other.min_threshold and \
             self.simd_size == other.simd_size and \

model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py

@@ -19,7 +19,7 @@ from sklearn.cluster import KMeans
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
 from model_compression_toolkit.constants import LUT_VALUES, MIN_THRESHOLD, SCALE_PER_CHANNEL, \
-    LUT_VALUES_BITWIDTH, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES
+    LUT_VALUES_BITWIDTH, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import \
     max_power_of_two, int_quantization_with_threshold
@@ -110,7 +110,8 @@ def lut_kmeans_histogram(bins: np.ndarray,
                          constrained: bool = True,
                          n_iter: int = 20,
                          min_threshold: float = MIN_THRESHOLD,
-                         quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> Dict:
+                         quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                         is_signed: bool = None) -> Dict:
     """
     Finds quantization cluster points for non-uniform activation quantization.
     The quantizer first finds the closest power-of-two number to the max value of the given histogram,
@@ -129,6 +130,7 @@ def lut_kmeans_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small.
         quant_error_method: an error function to optimize the parameters' selection accordingly (not used for this method).
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         A dictionary containing the cluster assignments according to the k-means algorithm and
@@ -148,9 +150,9 @@ def lut_kmeans_histogram(bins: np.ndarray,
     tensor_max = np.max(bins_with_values)
     threshold = max_power_of_two(tensor_max, min_threshold)
 
-    signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
+    signed = np.any(bins[:-1][counts != 0] < 0) if is_signed is None else is_signed  # Whether histogram contains negative values or not.
     tensor_for_kmeans = int_quantization_with_threshold(data=bins, threshold=threshold, n_bits=LUT_VALUES_BITWIDTH, signed=signed)
     kmeans.fit(tensor_for_kmeans.reshape(-1, 1), sample_weight=np.insert(counts, 0, 0))
 
     return {LUT_VALUES: np.float32(np.round(kmeans.cluster_centers_)),
-            THRESHOLD: threshold}
+            THRESHOLD: threshold, SIGNED: signed}

model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py

@@ -16,7 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES
+from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.qparams_search import \
     qparams_selection_tensor_search, qparams_selection_histogram_search
@@ -105,7 +105,8 @@ def power_of_two_selection_histogram(bins: np.ndarray,
                                      constrained: bool = True,
                                      n_iter: int = 20,
                                      min_threshold: float = MIN_THRESHOLD,
-                                     quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> dict:
+                                     quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                                     is_signed: bool = None) -> Dict:
     """
     Compute the power of two threshold based on the provided QuantizationErrorMethod to quantize a histogram.
     Different search is applied, depends on the value of the selected QuantizationErrorMethod.
@@ -121,6 +122,7 @@ def power_of_two_selection_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small (used only for kl threshold selection).
         quant_error_method: an error function to optimize the parameters' selection accordingly.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Power of two threshold to quantize the histogram a power of 2 manner.
@@ -128,17 +130,20 @@ def power_of_two_selection_histogram(bins: np.ndarray,
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
         tensor_max = np.max(np.abs(bins)[1:][counts > 0])
         threshold = max_power_of_two(tensor_max, min_threshold)
+        # Resolve is_signed in case it is None.
+        signed = (bins<0).any() if is_signed is None else is_signed
     else:
         error_function = get_threshold_selection_histogram_error_function(QuantizationMethod.POWER_OF_TWO,
                                                                           quant_error_method, p)
-        threshold = qparams_selection_histogram_search(error_function,
-                                                       bins,
-                                                       counts,
-                                                       n_bits,
-                                                       constrained=constrained,
-                                                       n_iter=n_iter,
-                                                       min_threshold=min_threshold)
-    return {THRESHOLD: threshold}
+        threshold, signed = qparams_selection_histogram_search(error_function,
+                                                               bins,
+                                                               counts,
+                                                               n_bits,
+                                                               constrained=constrained,
+                                                               n_iter=n_iter,
+                                                               min_threshold=min_threshold,
+                                                               is_signed=is_signed)
+    return {THRESHOLD: threshold, SIGNED: signed}
 
 
 def power_of_two_no_clipping_selection_min_max(bins: np.ndarray,
@@ -151,7 +156,8 @@ def power_of_two_no_clipping_selection_min_max(bins: np.ndarray,
                                                n_iter: int = 20,
                                                min_threshold: float = MIN_THRESHOLD,
                                                quant_error_method: qc.QuantizationErrorMethod =
-                                               qc.QuantizationErrorMethod.NOCLIPPING) -> dict:
+                                               qc.QuantizationErrorMethod.NOCLIPPING,
+                                               is_signed: bool = None) -> Dict:
     """
     Gets a threshold between min and max numbers.
     If computed threshold is less than min_threshold, min_threshold is returned.
@@ -168,4 +174,5 @@ def power_of_two_no_clipping_selection_min_max(bins: np.ndarray,
                                             constrained,
                                             n_iter,
                                             min_threshold=min_threshold,
-                                            quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING)
+                                            quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING,
+                                            is_signed=is_signed)

model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 import numpy as np
-from typing import Dict
+from typing import Dict, Union
 
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.core.common.collectors.statistics_collector import BaseStatsCollector
@@ -25,7 +25,7 @@ from model_compression_toolkit.core.common.quantization.node_quantization_config
 
 def get_activations_qparams(activation_quant_cfg: NodeActivationQuantizationConfig,
                             nodes_prior_info: NodePriorInfo,
-                            out_stats_container: BaseStatsCollector) -> Dict[str, float]:
+                            out_stats_container: BaseStatsCollector) -> Dict[str, Union[np.ndarray, float, bool]]:
     """
     Compute the activations params for a given node in a graph according to a params function.
 
@@ -49,7 +49,9 @@ def get_activations_qparams(activation_quant_cfg: NodeActivationQuantizationConf
                                                                     bins_counts)
     min_value, max_value = out_stats_container.get_min_max_values()
 
-    if nodes_prior_info.is_output_bounded():
+    if activation_quant_cfg.is_signed is not None:
+        signed = activation_quant_cfg.is_signed
+    elif nodes_prior_info.is_output_bounded():
         signed = min_value < 0
     else:
         signed = np.any(bins_values[:-1][bins_counts > 0] < 0)
@@ -65,14 +67,12 @@ def get_activations_qparams(activation_quant_cfg: NodeActivationQuantizationConf
             activation_quant_cfg.activation_quantization_params_fn = \
                 quantization_params_generation.uniform_no_clipping_selection_min_max
 
-    activation_params = activation_quant_cfg.activation_quantization_params_fn(bins_values,
-                                                                               bins_counts,
-                                                                               activation_quant_cfg.l_p_value,
-                                                                               activation_quant_cfg.activation_n_bits,
-                                                                               min_value,
-                                                                               max_value,
-                                                                               min_threshold=activation_quant_cfg.min_threshold,
-                                                                               quant_error_method=activation_quant_cfg.activation_error_method)
-    activation_params.update({SIGNED: signed})
-
-    return activation_params
+    return activation_quant_cfg.activation_quantization_params_fn(bins_values,
+                                                                  bins_counts,
+                                                                  activation_quant_cfg.l_p_value,
+                                                                  activation_quant_cfg.activation_n_bits,
+                                                                  min_value,
+                                                                  max_value,
+                                                                  min_threshold=activation_quant_cfg.min_threshold,
+                                                                  quant_error_method=activation_quant_cfg.activation_error_method,
+                                                                  is_signed=signed)

model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_search.py

@@ -107,7 +107,8 @@ def qparams_selection_histogram_search(error_function: Callable,
                                        n_bits: int,
                                        constrained: bool = True,
                                        n_iter: int = 10,
-                                       min_threshold: float = MIN_THRESHOLD):
+                                       min_threshold: float = MIN_THRESHOLD,
+                                       is_signed: bool = None) -> Tuple[np.ndarray, bool]:
     """
     Search for an optimal threshold to quantize a histogram of collected float values.
     The search_methods starts with the constrained no-clipping threshold by the bins' maximal value, and continues with
@@ -123,13 +124,14 @@ def qparams_selection_histogram_search(error_function: Callable,
         constrained: Whether the threshold should be constrained or not.
         n_iter: Number of searching iterations.
         min_threshold: Threshold to return if the computed threshold is smaller that min_threshold.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimal constrained threshold to quantize the tensor.
 
     """
 
-    signed = np.any(bins < 0)  # Whether histogram contains negative values or not.
+    signed = (bins < 0).any() if is_signed is None else is_signed  # Whether histogram contains negative values or not.
     tensor_data = np.abs(bins)
     tensor_max = np.max(tensor_data)
     if not constrained:
@@ -150,7 +152,7 @@ def qparams_selection_histogram_search(error_function: Callable,
         error_list.append(error)
 
     # Return the threshold with the minimal error.
-    return np.maximum(threshold_list[np.argmin(error_list)], min_threshold)
+    return np.maximum(threshold_list[np.argmin(error_list)], min_threshold), signed
 
 
 def qparams_symmetric_iterative_minimization(x0: np.ndarray,
@@ -537,7 +539,8 @@ def qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                  counts: np.ndarray,
                                                  n_bits: int,
                                                  n_iter: int = SYMMETRIC_HISTOGRAM_N_ITER,
-                                                 min_threshold: float = MIN_THRESHOLD):
+                                                 min_threshold: float = MIN_THRESHOLD,
+                                                 is_signed: bool = None) -> Tuple[np.ndarray, bool]:
     """
     search for optimal threshold (per-channel or per-tensor) for symmetric quantization of a histogram,
     using the iterative optimizer method.
@@ -550,12 +553,13 @@ def qparams_symmetric_selection_histogram_search(error_function: Callable,
         n_bits: Number of bits to quantize the tensor.
         n_iter: Number of searching iterations.
         min_threshold: Threshold to return if the computed threshold is smaller that min_threshold.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimized threshold for quantifying the histogram.
 
     """
-    signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
+    signed = np.any(bins[:-1][counts != 0] < 0) if is_signed is None else is_signed  # Whether histogram contains negative values or not.
 
     res = qparams_symmetric_iterative_minimization(x0=get_init_threshold(min_threshold, tensor_max),
                                                    x=bins,
@@ -570,7 +574,7 @@ def qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                    n_iter=SYMMETRIC_HISTOGRAM_N_ITER,
                                                    dec_freq=SYMMETRIC_HISTOGRAM_DEC_FREQ,
                                                    per_channel=False)
-    return max(min_threshold, res['param'])
+    return max(min_threshold, res['param']), signed
 
 
 def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
@@ -579,7 +583,8 @@ def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                     counts: np.ndarray,
                                                     n_bits: int,
                                                     n_iter: int = SYMMETRIC_HISTOGRAM_N_ITER,
-                                                    min_threshold: float = MIN_THRESHOLD):
+                                                    min_threshold: float = MIN_THRESHOLD,
+                                                    is_signed: bool = None) -> Tuple[np.ndarray, bool]:
     """
     Search for optimal threshold (per-channel or per-tensor) for symmetric quantization of a histogram,
     with KL-Divergence loss function (needs a separate search function
@@ -599,7 +604,7 @@ def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
         Optimized threshold for quantifying the histogram.
 
     """
-    signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
+    signed = np.any(bins[:-1][counts != 0] < 0) if is_signed is None else is_signed  # Whether histogram contains negative values or not.
     res = qparams_symmetric_iterative_minimization(x0=get_init_threshold(min_threshold, tensor_max),
                                                    x=bins,
                                                    loss_fn=lambda x, q_x, t:
@@ -617,7 +622,7 @@ def kl_qparams_symmetric_selection_histogram_search(error_function: Callable,
                                                    n_iter=SYMMETRIC_HISTOGRAM_N_ITER,
                                                    dec_freq=SYMMETRIC_HISTOGRAM_DEC_FREQ,
                                                    per_channel=False)
-    return max(min_threshold, res['param'])
+    return max(min_threshold, res['param']), signed
 
 
 def qparams_uniform_selection_histogram_search(error_function: Callable,

model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_weights_computation.py

@@ -22,10 +22,7 @@ from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
     WeightsAttrQuantizationConfig
-
-# If the quantization config does not contain kernel channel mapping or the weights
-# quantization is not per-channel, we use a dummy channel mapping.
-dummy_channel_mapping = DefaultDict(default_value=(None, None))
+from model_compression_toolkit.logger import Logger
 
 
 def get_weights_qparams(weights_attr_values: np.ndarray,
@@ -64,29 +61,10 @@ def get_weights_qparams(weights_attr_values: np.ndarray,
             node=node,
             hessian_info_service=hessian_info_service,
             num_hessian_samples=num_hessian_samples)
-    else:
+    else:  # pragma: no cover
+        Logger.error(f"Requested weights quantization parameters computation for node {node.name} without providing a "
+                     f"weights_quantization_params_fn."
+                     f"Returning an empty dictionary since no quantization parameters were computed.")
         weights_params = {}
 
     return weights_params, output_channels_axis
-
-
-def _get_kernel_channels_mapping(fw_info:FrameworkInfo,
-                                use_dummy: bool) -> DefaultDict:
-    """
-    Get a kernel channel mapping from the framework info, or use dummy mapping (which returns a
-    tuple of Nones) if use_use_dummy is True.
-
-    Args:
-        fw_info: Framework info which contains a kernel channels mapping.
-        use_dummy: Whether to use a dummy mapping or not.
-
-    Returns:
-        Kernel channels mapping.
-    """
-
-    # Set a kernel channels mapping
-    if use_dummy:  # If kernel mapping is missing, we use a dummy channels mapping
-        kernel_channels_mapping = dummy_channel_mapping
-    else:
-        kernel_channels_mapping = fw_info.kernel_channels_mapping
-    return kernel_channels_mapping

model_compression_toolkit/core/common/quantization/quantization_params_generation/symmetric_selection.py

@@ -16,7 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES
+from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.error_functions import \
     get_threshold_selection_tensor_error_function, get_threshold_selection_histogram_error_function, _kl_error_histogram
@@ -106,7 +106,8 @@ def symmetric_selection_histogram(bins: np.ndarray,
                                   constrained: bool = True,
                                   n_iter: int = 20,
                                   min_threshold: float = MIN_THRESHOLD,
-                                  quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> dict:
+                                  quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                                  is_signed: bool = None) -> Dict:
     """
     Compute the optimal threshold based on the provided QuantizationErrorMethod to quantize a histogram.
     Different search is applied, depends on the value of the selected QuantizationErrorMethod.
@@ -122,6 +123,7 @@ def symmetric_selection_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small (used only for kl threshold selection).
         quant_error_method: an error function to optimize the parameters' selection accordingly.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimal threshold to quantize the histogram a symmetric manner.
@@ -129,23 +131,27 @@ def symmetric_selection_histogram(bins: np.ndarray,
     tensor_max = np.max(np.abs(bins)[1:][counts > 0])
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
         threshold = get_init_threshold(min_threshold, tensor_max)
+        # Resolve is_signed in case it is None.
+        signed = (bins<0).any() if is_signed is None else is_signed
     elif quant_error_method == qc.QuantizationErrorMethod.KL:
         # search for KL error is separated because the error method signature is different from the other error methods.
-        threshold = kl_qparams_symmetric_selection_histogram_search(_kl_error_histogram,
-                                                                    tensor_max,
-                                                                    bins,
-                                                                    counts,
-                                                                    n_bits,
-                                                                    min_threshold=min_threshold)
+        threshold, signed = kl_qparams_symmetric_selection_histogram_search(_kl_error_histogram,
+                                                                            tensor_max,
+                                                                            bins,
+                                                                            counts,
+                                                                            n_bits,
+                                                                            min_threshold=min_threshold,
+                                                                            is_signed=is_signed)
     else:
         error_function = get_threshold_selection_histogram_error_function(QuantizationMethod.SYMMETRIC, quant_error_method, p)
-        threshold = qparams_symmetric_selection_histogram_search(error_function,
-                                                                 tensor_max,
-                                                                 bins,
-                                                                 counts,
-                                                                 n_bits,
-                                                                 min_threshold=min_threshold)
-    return {THRESHOLD: threshold}
+        threshold, signed = qparams_symmetric_selection_histogram_search(error_function,
+                                                                         tensor_max,
+                                                                         bins,
+                                                                         counts,
+                                                                         n_bits,
+                                                                         min_threshold=min_threshold,
+                                                                         is_signed=is_signed)
+    return {THRESHOLD: threshold, SIGNED: signed}
 
 
 def symmetric_no_clipping_selection_min_max(bins: np.ndarray,
@@ -158,7 +164,8 @@ def symmetric_no_clipping_selection_min_max(bins: np.ndarray,
                                             n_iter: int = 20,
                                             min_threshold: float = MIN_THRESHOLD,
                                             quant_error_method: qc.QuantizationErrorMethod =
-                                            qc.QuantizationErrorMethod.NOCLIPPING) -> dict:
+                                            qc.QuantizationErrorMethod.NOCLIPPING,
+                                            is_signed: bool = None) -> Dict:
     """
     Gets a threshold between min and max numbers.
     If computed threshold is less than min_threshold, min_threshold is returned.
@@ -175,7 +182,8 @@ def symmetric_no_clipping_selection_min_max(bins: np.ndarray,
                                          constrained,
                                          n_iter,
                                          min_threshold=min_threshold,
-                                         quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING)
+                                         quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING,
+                                         is_signed=is_signed)
 
 
 def get_init_threshold(min_threshold: float, tensor_max: np.ndarray, per_channel: bool = False) -> np.ndarray:

model_compression_toolkit/core/common/quantization/quantization_params_generation/uniform_selection.py

@@ -16,7 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import MIN_THRESHOLD, RANGE_MIN, RANGE_MAX, NUM_QPARAM_HESSIAN_SAMPLES
+from model_compression_toolkit.constants import MIN_THRESHOLD, RANGE_MIN, RANGE_MAX, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.qparams_search import \
     qparams_uniform_selection_tensor_search, qparams_uniform_selection_histogram_search
@@ -114,7 +114,8 @@ def uniform_selection_histogram(bins: np.ndarray,
                                 constrained: bool = True,
                                 n_iter: int = 20,
                                 min_threshold: float = MIN_THRESHOLD,
-                                quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> dict:
+                                quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                                is_signed: bool = None) -> Dict:
     """
     Compute the optimal quantization range based on the provided QuantizationErrorMethod
     to uniformly quantize the histogram.
@@ -131,6 +132,7 @@ def uniform_selection_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small (not used for this method).
         quant_error_method: an error function to optimize the range parameters selection accordingly.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimal quantization range to quantize the histogram uniformly.
@@ -139,6 +141,7 @@ def uniform_selection_histogram(bins: np.ndarray,
     tensor_max = np.max(bins[1:][counts > 0])
     tensor_min_max = np.array([tensor_min, tensor_max])
 
+    signed = tensor_min < 0 if is_signed is None else is_signed
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
         mm = tensor_min_max
     else:
@@ -150,7 +153,7 @@ def uniform_selection_histogram(bins: np.ndarray,
                                                         n_bits)
 
     return {RANGE_MIN: mm[0],
-            RANGE_MAX: mm[1]}
+            RANGE_MAX: mm[1], SIGNED: signed}
 
 
 def uniform_no_clipping_selection_min_max(bins: np.ndarray,
@@ -163,7 +166,8 @@ def uniform_no_clipping_selection_min_max(bins: np.ndarray,
                                           n_iter: int = 20,
                                           min_threshold: float = MIN_THRESHOLD,
                                           quant_error_method: qc.QuantizationErrorMethod =
-                                          qc.QuantizationErrorMethod.NOCLIPPING) -> dict:
+                                          qc.QuantizationErrorMethod.NOCLIPPING,
+                                          is_signed: bool = None) -> Dict:
     """
     Gets a quantization rage between min and max numbers.
 
@@ -179,5 +183,5 @@ def uniform_no_clipping_selection_min_max(bins: np.ndarray,
                                        constrained,
                                        n_iter,
                                        min_threshold=min_threshold,
-                                       quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING)
-
+                                       quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING,
+                                       is_signed=is_signed)