mct-nightly 1.7.1.31122022.post351__py3-none-any.whl → 1.8.0.1042023.post423__py3-none-any.whl

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/weights_inferable_quantizers/weights_lut_symmetric_inferable_quantizer.py

@@ -0,0 +1,179 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import warnings
+from typing import List
+
+import numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TF
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer, \
+    QuantizationTarget
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import MULTIPLIER_N_BITS, EPS
+
+if FOUND_TF:
+    import tensorflow as tf
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.base_keras_inferable_quantizer import \
+        BaseKerasInferableQuantizer
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizer_utils import \
+        lut_quantizer
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.LUT_SYM_QUANTIZER],
+                    quantizer_type=None)
+    class WeightsLUTSymmetricInferableQuantizer(BaseKerasInferableQuantizer):
+        """
+        Class for quantizing weights using a lut symmetric quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     cluster_centers: np.ndarray,
+                     threshold: List[float],
+                     per_channel: bool,
+                     channel_axis: int = None,
+                     input_rank: int = None,
+                     multiplier_n_bits: int = MULTIPLIER_N_BITS,
+                     eps: float = EPS):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                cluster_centers: the cluster centers to assign the weights
+                threshold: threshold for quantizing weights
+                per_channel: whether to use per-channel quantization
+                channel_axis: axis along which to apply per-channel quantization
+                input_rank: number of dimensions of input tensor the quantizer quantizes
+                multiplier_n_bits: Number of bits that determines the quantization range
+                eps: Small value for numerical stability in division
+            """
+
+            super(WeightsLUTSymmetricInferableQuantizer, self).__init__()
+
+            assert isinstance(threshold, list), f'Expected threshold to be of type list but is {type(threshold)}'
+            assert all([isinstance(x, (float, np.float32, np.float64)) for x in
+                        threshold]), f'Expected threshold list to contain float or np.float values but found ' \
+                                     f'{[type(x) for x in threshold]}'
+
+            self.threshold = np.asarray(threshold)
+
+            if per_channel:
+                assert input_rank is not None, f'Input rank is missing in per channel quantization'
+                assert channel_axis is not None, f'Channel axis is missing in per channel quantization'
+                assert len(threshold) >= 1, f'In per-channel quantization threshold list should be of length >= 1 ' \
+                                            f'but is {len(threshold)} '
+            else:
+                assert len(threshold) == 1, f'In per-tensor quantization threshold should be of length 1 but is' \
+                                            f' {len(threshold)}'
+                self.threshold = self.threshold[0]
+
+            assert len(np.unique(cluster_centers)) <= 2 ** num_bits, \
+                f'Expected num of cluster centers to be less or equal than {2 ** num_bits} ' \
+                f'but got {len(cluster_centers)}'
+
+            assert not np.any(cluster_centers - cluster_centers.astype(int)), f'Expected cluster centers to be integers'
+
+            # Weight quantization is signed, hence the quantization range is
+            # [-2**(multiplier_n_bits - 1), 2**(multiplier_n_bits - 1) - 1]
+            assert np.all((-1 * (2 ** (multiplier_n_bits - 1)) <= cluster_centers) &
+                          (cluster_centers <= (2 ** (multiplier_n_bits - 1) - 1))), \
+                f'Expected cluster centers in the quantization range'
+
+            # num_bits must be less than multiplier_n_bits
+            assert num_bits <= multiplier_n_bits, f'Look-Up-Table bit configuration has {num_bits} bits. It must be ' \
+                                                  f'less then {multiplier_n_bits}'
+            if num_bits == multiplier_n_bits:
+                warnings.warn("Num of bits equal to multiplier n bits, Please be aware LUT quantizier may be "
+                              "inefficient in that case, consider using SymmetricInferableQuantizer instead")
+
+            self.num_bits = num_bits
+            self.cluster_centers = cluster_centers
+            self.multiplier_n_bits = multiplier_n_bits
+            self.eps = eps
+            self.per_channel = per_channel
+            self.channel_axis = channel_axis
+            self.input_rank = input_rank
+
+            # Tensorflow's fake_quant_with_min_max_vars_per_channel only works on last axis, so
+            # need to move the quantization axis to the last axis
+            if per_channel and channel_axis not in [-1, self.input_rank - 1]:
+                # If per-channel quantization is being used and the channel axis is not the last axis,
+                # create a permutation vector to move the channel axis to the last position
+                self.perm_vec = list(np.arange(self.input_rank))
+                self.perm_vec[channel_axis] = self.input_rank - 1
+                self.perm_vec[self.input_rank - 1] = channel_axis
+            else:
+                # If per-channel quantization is not being used or the channel axis is already the last axis,
+                # set the permutation vector to None
+                self.perm_vec = None
+
+        def __call__(self, inputs: tf.Tensor) -> tf.Tensor:
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            assert inputs.dtype == tf.float32, f'Input tensor was expected to be a float tensor but is of type ' \
+                                               f'{inputs.dtype}'
+
+            # If per-channel quantization is being used
+            if self.per_channel:
+                # If a permutation vector has been created to move the channel axis to the last position
+                if self.perm_vec:
+                    # Transpose the input tensor to move the channel axis to the last position
+                    inputs = tf.transpose(inputs, perm=self.perm_vec)
+
+                # Quantize the input tensor using per-channel quantization
+                q_tensor = lut_quantizer(inputs, cluster_centers=self.cluster_centers, signed=True,
+                                         threshold=self.threshold, multiplier_n_bits=self.multiplier_n_bits,
+                                         eps=self.eps)
+                if self.perm_vec:
+                    # Transpose the quantized tensor back to its original shape
+                    q_tensor = tf.transpose(q_tensor, perm=self.perm_vec)
+
+                # Return the quantized tensor
+                return q_tensor
+            else:
+                return lut_quantizer(inputs, cluster_centers=self.cluster_centers, signed=True,
+                                     threshold=self.threshold, multiplier_n_bits=self.multiplier_n_bits, eps=self.eps)
+
+        def get_config(self):
+            """
+            Return a dictionary with the configuration of the quantizer.
+
+            Returns:
+                Dictionary with the following keys: 'per_channel', 'num_bits', 'cluster_centers', 'threshold',
+                 'channel_axis', 'input_rank', 'multiplier_n_bits', 'eps'
+            """
+            return {'per_channel': self.per_channel,
+                    'num_bits': self.num_bits,
+                    'cluster_centers': self.cluster_centers,
+                    'threshold': self.threshold,
+                    'channel_axis': self.channel_axis,
+                    'input_rank': self.input_rank,
+                    'multiplier_n_bits': self.multiplier_n_bits,
+                    'eps': self.eps}
+
+else:
+    class WeightsLUTSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                            'when using WeightsLUTSymmetricInferableQuantizer. '
+                            'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/weights_inferable_quantizers/weights_pot_inferable_quantizer.py

@@ -0,0 +1,67 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from typing import List
+
+import numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TF
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer, QuantizationTarget
+
+if FOUND_TF:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.weights_inferable_quantizers.weights_symmetric_inferable_quantizer \
+        import WeightsSymmetricInferableQuantizer
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.POWER_OF_TWO],
+                    quantizer_type=None)
+    class WeightsPOTInferableQuantizer(WeightsSymmetricInferableQuantizer):
+        """
+        Class for quantizing weights using power-of-two quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     threshold: List[float],
+                     per_channel: bool,
+                     channel_axis: int = None,
+                     input_rank: int = None):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                threshold: threshold for quantizing activations
+                per_channel: whether to use per-channel quantization
+                channel_axis: axis along which to apply per-channel quantization
+                input_rank: number of dimensions of input tensor the quantizer quantizes
+            """
+            # Call the superclass constructor with the given parameters, along with the target of Weights quantization
+            super(WeightsPOTInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                               threshold=threshold,
+                                                               per_channel=per_channel,
+                                                               channel_axis=channel_axis,
+                                                               input_rank=input_rank)
+
+            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in self.threshold.flatten()])
+            assert is_threshold_pot, f'Expected threshold to be power of 2 but is {self.threshold}'
+
+
+else:
+    class WeightsPOTInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                            'when using WeightsPOTInferableQuantizer. '
+                            'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/weights_inferable_quantizers/weights_symmetric_inferable_quantizer.py

@@ -0,0 +1,87 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from typing import List
+
+import numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TF
+
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer, QuantizationTarget
+
+if FOUND_TF:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.weights_inferable_quantizers.weights_uniform_inferable_quantizer \
+        import WeightsUniformInferableQuantizer
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.SYMMETRIC],
+                    quantizer_type=None)
+    class WeightsSymmetricInferableQuantizer(WeightsUniformInferableQuantizer):
+        """
+        Class for quantizing weights using a symmetric quantizer
+        """
+        def __init__(self,
+                     num_bits: int,
+                     threshold: List[float],
+                     per_channel: bool,
+                     channel_axis: int = None,
+                     input_rank: int = None
+                     ):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                threshold: threshold for quantizing weights
+                per_channel: whether to use per-channel quantization
+                channel_axis: axis along which to apply per-channel quantization
+                input_rank: number of dimensions of input tensor the quantizer quantizes
+            """
+            assert isinstance(threshold, list), f'Expected threshold to be of type list but is {type(threshold)}'
+            assert all([isinstance(x, (float, np.float32, np.float64)) for x in
+                        threshold]), f'Expected threshold list to contain float or np.float values but found ' \
+                                     f'{[type(x) for x in threshold]}'
+
+            self.threshold = np.asarray(threshold)
+
+            _min_range = -self.threshold
+            _max_range = self.threshold - self.threshold / (2 ** (num_bits - 1))
+
+            super(WeightsSymmetricInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                                     min_range=list(_min_range),
+                                                                     max_range=list(_max_range),
+                                                                     per_channel=per_channel,
+                                                                     channel_axis=channel_axis,
+                                                                     input_rank=input_rank)
+
+        def get_config(self):
+            """
+            Return a dictionary with the configuration of the quantizer.
+
+            Returns:
+                Dictionary with the following keys: 'num_bits', 'threshold', 'per_channel', 'channel_axis'
+            """
+            return {'num_bits': self.num_bits,
+                    'threshold': self.threshold,
+                    'per_channel': self.per_channel,
+                    'channel_axis': self.channel_axis,
+                    'input_rank': self.input_rank}
+
+else:
+    class WeightsSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                            'when using WeightsPOTInferableQuantizer. '
+                            'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/weights_inferable_quantizers/weights_uniform_inferable_quantizer.py

@@ -0,0 +1,163 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from typing import List
+
+import numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TF
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer, QuantizationTarget
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.quant_utils import \
+    adjust_range_to_include_zero
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.validation_functions import \
+    validate_uniform_min_max_ranges, validate_adjusted_min_max_ranges
+
+if FOUND_TF:
+    import tensorflow as tf
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.base_keras_inferable_quantizer import BaseKerasInferableQuantizer
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.UNIFORM],
+                    quantizer_type=None)
+    class WeightsUniformInferableQuantizer(BaseKerasInferableQuantizer):
+        """
+        Class for quantizing weights using a uniform quantizer
+        """
+        def __init__(self,
+                     num_bits: int,
+                     min_range: List[float],
+                     max_range: List[float],
+                     per_channel: bool,
+                     channel_axis: int = None,
+                     input_rank: int = None
+                     ):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                min_range: min quantization range for quantizing weights
+                max_range: max quantization range for quantizing weights
+                per_channel: whether to use per-channel quantization
+                channel_axis: axis along which to apply per-channel quantization
+                input_rank: number of dimensions of input tensor the quantizer quantizes
+            """
+
+            super(WeightsUniformInferableQuantizer, self).__init__()
+
+            # Validate inputs properties
+            validate_uniform_min_max_ranges(min_range,
+                                            max_range)
+
+            # Convert min/max to numpy arrays
+            min_range, max_range = np.asarray(min_range), np.asarray(max_range)
+            _min_range, _max_range = adjust_range_to_include_zero(min_range, max_range, num_bits)
+            validate_adjusted_min_max_ranges(min_range=min_range,
+                                             max_range=max_range,
+                                             adj_min=_min_range,
+                                             adj_max=_max_range)
+
+            self.num_bits = num_bits
+            self.max_range = _max_range
+            self.min_range = _min_range
+
+            if per_channel:
+                assert input_rank is not None, f'Input rank is missing in per channel quantization'
+                assert channel_axis is not None, f'Channel axis is missing in per channel quantization'
+                assert len(self.min_range) >= 1, f'In per-channel quantization min ranges list should be of length >= 1 but is {len(self.min_range)}'
+                assert len(self.max_range) >= 1, f'In per-channel quantization max ranges list should be of length >= 1 but is {len(self.max_range)}'
+            else:
+                assert len(self.min_range) == 1, f'In per-tensor quantization min/max should be of length 1 but is {len(min_range)}'
+                assert len(self.min_range) == 1, f'In per-tensor quantization min_range should be of length 1 but is {len(self.min_range)}'
+                assert len(self.max_range) == 1, f'In per-tensor quantization max_range should be of length 1 but is {len(self.max_range)}'
+                self.min_range = self.min_range[0]
+                self.max_range = self.max_range[0]
+
+            self.per_channel = per_channel
+            self.channel_axis = channel_axis
+            self.input_rank = input_rank
+
+            # Tensorflow's fake_quant_with_min_max_vars_per_channel only works on last axis, so
+            # need to move the quantization axis to the last axis
+            if per_channel and channel_axis not in [-1, self.input_rank - 1]:
+                # If per-channel quantization is being used and the channel axis is not the last axis,
+                # create a permutation vector to move the channel axis to the last position
+                self.perm_vec = list(np.arange(self.input_rank))
+                self.perm_vec[channel_axis] = self.input_rank - 1
+                self.perm_vec[self.input_rank - 1] = channel_axis
+            else:
+                # If per-channel quantization is not being used or the channel axis is already the last axis,
+                # set the permutation vector to None
+                self.perm_vec = None
+
+        def __call__(self, inputs: tf.Tensor) -> tf.Tensor:
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            assert inputs.dtype==tf.float32, f'Input tensor was expected to be a float tensor but is of type {inputs.dtype}'
+
+            # If per-channel quantization is being used
+            if self.per_channel:
+                # If a permutation vector has been created to move the channel axis to the last position
+                if self.perm_vec:
+                    # Transpose the input tensor to move the channel axis to the last position
+                    inputs = tf.transpose(inputs, perm=self.perm_vec)
+
+                # Quantize the input tensor using per-channel quantization
+                q_tensor = tf.quantization.fake_quant_with_min_max_vars_per_channel(inputs,
+                                                                                    min=self.min_range,
+                                                                                    max=self.max_range,
+                                                                                    num_bits=self.num_bits)
+                if self.perm_vec:
+                    # Transpose the quantized tensor back to its original shape
+                    q_tensor = tf.transpose(q_tensor, perm=self.perm_vec)
+
+                # Return the quantized tensor
+                return q_tensor
+            else:
+                # If per-channel quantization is not being used, quantize the input tensor using regular quantization
+                return tf.quantization.fake_quant_with_min_max_vars(inputs,
+                                                                    min=self.min_range,
+                                                                    max=self.max_range,
+                                                                    num_bits=self.num_bits)
+
+
+        def get_config(self):
+            """
+            Return a dictionary with the configuration of the quantizer.
+
+            Returns:
+                Dictionary with the following keys: 'num_bits', 'min_range', 'max_range', 'per_channel', 'channel_axis'
+            """
+            return {'per_channel': self.per_channel,
+                    'num_bits': self.num_bits,
+                    'max_range': self.max_range,
+                    'min_range': self.min_range,
+                    'channel_axis': self.channel_axis,
+                    'input_rank': self.input_rank}
+
+
+else:
+    class WeightsUniformInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                            'when using WeightsUniformInferableQuantizer. '
+                            'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/validation_functions.py

@@ -0,0 +1,66 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from typing import Any
+
+import numpy as np
+
+from model_compression_toolkit.core.common import Logger
+
+
+def validate_uniform_min_max_ranges(min_range: Any, max_range: Any) -> None:
+    """
+    Validate min/max ranges in uniform quantizers are valid
+
+    Args:
+        min_range: min range list to check
+        max_range: max range list to check
+
+    """
+    assert isinstance(min_range, list), f'Expected min_range to be of type list but is {type(min_range)}'
+    assert isinstance(max_range, list), f'Expected max_range to be of type list but is {type(max_range)}'
+
+    assert all([isinstance(x, (float, np.float32, np.float64)) for x in
+                min_range]), f'Expected min_range list to contain float values but found {[type(x) for x in min_range]}'
+    assert all([isinstance(x, (float, np.float32, np.float64)) for x in
+                max_range]), f'Expected max_range list to contain float values but found {[type(x) for x in max_range]}'
+
+    assert len(min_range) == len(
+        max_range), f'Expected min/max values to have the same length but min shape: {len(min_range)} and max shape: ' \
+                    f'{len(max_range)}'
+
+    # Convert min/max to numpy arrays
+    min_range, max_range = np.asarray(min_range), np.asarray(max_range)
+    assert np.all(max_range > min_range), f'Expected max_range to be bigger than min_range!'
+
+
+def validate_adjusted_min_max_ranges(min_range: Any,
+                                     max_range: Any,
+                                     adj_min:Any,
+                                     adj_max:Any) -> None:
+    """
+    Validate adjusted min/max ranges in uniform quantization are valid
+
+    Args:
+        min_range: original min range
+        max_range: original max range
+        adj_min: adjusted min range
+        adj_max: adjusted max range
+
+    """
+
+    assert np.all(adj_min <= 0) and np.all(
+        adj_max >= 0), f'Expected zero to be in the range, got min_range={adj_min}, max_range={adj_max}'
+    if not np.isclose(np.linalg.norm(adj_min - min_range), 0, atol=1e-6) or not np.isclose(np.linalg.norm(adj_max - max_range), 0, atol=1e-6):
+        Logger.warning(f"Adjusting (min_range, max_range) from ({min_range},{max_range}) to ({adj_min},{adj_max})")  # pragma: no cover

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================