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/pytorch/quantizers/activation_inferable_quantizers/activation_symmetric_inferable_quantizer.py

@@ -0,0 +1,83 @@
+# 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 numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+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_TORCH:
+    import torch
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_symmetric_inferable_quantizer import \
+        BaseSymmetricInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                    quantization_method=[QuantizationMethod.SYMMETRIC],
+                    quantizer_type=None)
+    class ActivationSymmetricInferableQuantizer(BaseSymmetricInferableQuantizer):
+        """
+        Class for quantizing activations using a symmetric quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     threshold: np.ndarray,
+                     signed: bool):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                threshold: threshold for quantizing activations
+                signed: whether to use signed quantization or not
+            """
+
+            super(ActivationSymmetricInferableQuantizer, self).__init__(
+                num_bits=num_bits,
+                threshold=threshold,
+                signed=signed)
+
+            # Activation supports only per-tensor quantization
+            assert len(
+                self.scales) == 1, f'For activation, quantization per channel is not supported and threshold should ' \
+                                   f'be of length 1 but is {len(threshold)}'
+            self.scales = self.scales[0]
+
+            self.zero_points = 0
+
+        def __call__(self, inputs: torch.Tensor):
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            return torch.fake_quantize_per_tensor_affine(inputs,
+                                                         scale=self.scales,
+                                                         zero_point=self.zero_points,
+                                                         quant_min=self.min_quantized_domain,
+                                                         quant_max=self.max_quantized_domain)
+
+else:
+    class ActivationSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using ActivationSymmetricInferableQuantizer. '
+                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/activation_inferable_quantizers/activation_uniform_inferable_quantizer.py

@@ -0,0 +1,100 @@
+# 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 numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+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_TORCH:
+    import torch
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_uniform_inferable_quantizer import \
+        BaseUniformInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                    quantization_method=[QuantizationMethod.UNIFORM],
+                    quantizer_type=None)
+    class ActivationUniformInferableQuantizer(BaseUniformInferableQuantizer):
+        """
+        Class for quantizing activations using an uniform quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     min_range: np.ndarray,
+                     max_range: np.ndarray,
+                     ):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                min_range: min range for quantizing activations
+                max_range: max range for quantizing activations
+            """
+            super(ActivationUniformInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                                      min_range=min_range,
+                                                                      max_range=max_range)
+
+            assert isinstance(min_range,
+                              np.ndarray), f'min_range is expected to be numpy array, but is of type {type(min_range)}'
+            assert isinstance(max_range,
+                              np.ndarray), f'max_range is expected to be numpy array, but is of type {type(max_range)}'
+            assert min_range.ndim == 1, f'min_range is expected to be flatten, but of shape {min_range.shape}'
+            assert max_range.ndim == 1, f'max_range is expected to be flatten, but of shape {min_range.shape}'
+
+            assert len(
+                min_range) == 1, f'For activation, quantization per channel is not supported and min_range should be ' \
+                                 f'of length 1 but is {len(min_range)}'
+            assert len(
+                max_range) == 1, f'For activation, quantization per channel is not supported and max_range should be ' \
+                                 f'of length 1 but is {len(max_range)}'
+
+            # Activation is per-tensor thus we expect only a single min/max values
+            min_range = min_range[0]
+            max_range = max_range[0]
+
+            # fixing quantization range to include 0
+            a = 0 if min_range > 0 else min_range
+            b = 0 if max_range < 0 else max_range
+
+            self.scale = float((b - a) / ((2 ** num_bits) - 1))
+            self.zero_point = int(-np.round(a / self.scale))  # zp has to be positive, and a <=0, so we multiply by -1
+
+        def __call__(self, inputs: torch.Tensor):
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            return torch.fake_quantize_per_tensor_affine(inputs,
+                                                         scale=self.scale,
+                                                         zero_point=self.zero_point,
+                                                         quant_min=self.min_quantized_domain,
+                                                         quant_max=self.max_quantized_domain)
+
+
+else:
+    class ActivationUniformInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using ActivationUniformInferableQuantizer. '
+                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/base_lut_symmetric_inferable_quantizer.py

@@ -0,0 +1,95 @@
+# 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 numpy as np
+import warnings
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+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
+
+if FOUND_TORCH:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers \
+        .base_pytorch_inferable_quantizer import BasePyTorchInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=None,
+                    quantization_method=[QuantizationMethod.LUT_SYM_QUANTIZER],
+                    quantizer_type=None)
+    class BaseLUTSymmetricInferableQuantizer(BasePyTorchInferableQuantizer):
+
+        def __init__(self,
+                     num_bits: int,
+                     cluster_centers: np.ndarray,
+                     threshold: np.ndarray,
+                     signed: bool,
+                     multiplier_n_bits: int,
+                     eps: float):
+            """
+            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 values
+                threshold: threshold for quantizing values
+                signed: whether or not to use signed quantization
+                multiplier_n_bits: Number of bits that determines the quantization range
+                eps: Small value for numerical stability in division
+            """
+
+            super(BaseLUTSymmetricInferableQuantizer, self).__init__()
+
+            assert isinstance(threshold,
+                              np.ndarray), f'Threshold is expected to be numpy array, but is of type {type(threshold)}'
+            assert threshold.ndim == 1, f'Threshold is expected to be flatten, but of shape {threshold.shape}'
+
+            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'
+
+            if signed:
+                assert np.all((-1 * (2 ** (multiplier_n_bits - int(signed))) <= cluster_centers) &
+                              (cluster_centers <= (2 ** (multiplier_n_bits - int(signed)) - 1))), \
+                    f'Expected cluster centers in the quantization range'
+            else:
+                assert np.all(cluster_centers <= (2 ** multiplier_n_bits)), f'Expected cluster centers in the ' \
+                                                                            f'quantization range'
+
+            # If unsigned activation quantization, all cluster_centers must be positive
+            if not signed:
+                assert np.all(cluster_centers >= 0), f'Expected unsigned cluster centers in unsigned activation ' \
+                                                          f'quantization'
+
+            # 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.signed = signed
+            self.threshold = threshold
+            self.cluster_centers = cluster_centers
+            self.num_bits = num_bits
+            self.multiplier_n_bits = multiplier_n_bits
+            self.eps = eps
+
+else:
+    class BaseLUTSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory when using BaseLUTSymmetricInferableQuantizer. Could not '
+                            'find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/base_pytorch_inferable_quantizer.py

@@ -0,0 +1,48 @@
+# 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 abc import abstractmethod
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+from model_compression_toolkit.quantizers_infrastructure import BaseInferableQuantizer
+
+if FOUND_TORCH:
+    import torch
+
+
+    class BasePyTorchInferableQuantizer(BaseInferableQuantizer):
+        def __init__(self):
+            """
+            This class is a base quantizer for PyTorch quantizers for inference only.
+            """
+            super(BasePyTorchInferableQuantizer, self).__init__()
+
+        @abstractmethod
+        def __call__(self, inputs: torch.Tensor):
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            raise NotImplemented(f'{self.__class__.__name__} did not implement __call__')  # pragma: no cover
+else:
+    class BasePyTorchInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using BasePyTorchInferableQuantizer. '
+                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/base_symmetric_inferable_quantizer.py

@@ -0,0 +1,70 @@
+# 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 numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+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
+
+if FOUND_TORCH:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_pytorch_inferable_quantizer import \
+        BasePyTorchInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=None,
+                    quantization_method=[QuantizationMethod.SYMMETRIC],
+                    quantizer_type=None)
+    class BaseSymmetricInferableQuantizer(BasePyTorchInferableQuantizer):
+
+        def __init__(self,
+                     num_bits: int,
+                     threshold: np.ndarray,
+                     signed: bool):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                threshold: threshold for quantizing weights
+                signed: whether or not to use signed quantization
+            """
+
+            super(BaseSymmetricInferableQuantizer, self).__init__()
+
+            assert isinstance(threshold,
+                              np.ndarray), f'Threshold is expected to be numpy array, but is of type {type(threshold)}'
+            assert threshold.ndim == 1, f'Threshold is expected to be flatten, but of shape {threshold.shape}'
+
+            self.signed = signed
+            self.threshold = threshold
+            self.num_bits = num_bits
+
+            if signed:
+                self.min_quantized_domain = -2 ** (num_bits - 1)
+                self.max_quantized_domain = 2 ** (num_bits - 1) - 1
+                self.scales = threshold / 2 ** (num_bits - 1)
+            else:
+                self.min_quantized_domain = 0
+                self.max_quantized_domain = (2 ** num_bits) - 1
+                self.scales = threshold / 2 ** num_bits
+
+
+
+else:
+    class BaseSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using BaseSymmetricInferableQuantizer. '
+                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/base_uniform_inferable_quantizer.py

@@ -0,0 +1,57 @@
+# 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 numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+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
+
+if FOUND_TORCH:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_pytorch_inferable_quantizer import \
+        BasePyTorchInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=None,
+                    quantization_method=[QuantizationMethod.UNIFORM],
+                    quantizer_type=None)
+    class BaseUniformInferableQuantizer(BasePyTorchInferableQuantizer):
+
+        def __init__(self,
+                     num_bits: int,
+                     min_range: np.ndarray,
+                     max_range: np.ndarray):
+            """
+            Initialize the quantizer with the specified parameters.
+
+            Args:
+                num_bits: number of bits to use for quantization
+                min_range: min quantization range for quantizing
+                max_range: max quantization range for quantizing
+            """
+
+            super(BaseUniformInferableQuantizer, self).__init__()
+            self.num_bits = num_bits
+            self.min_range = min_range
+            self.max_range = max_range
+            self.min_quantized_domain = 0
+            self.max_quantized_domain = 2 ** num_bits - 1
+
+
+else:
+    class BaseUniformInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using BaseUniformInferableQuantizer. '
+                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/constants.py

@@ -0,0 +1,26 @@
+# 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.
+# ==============================================================================
+
+# Inferable pytorch quantizer signature parameters:
+NUM_BITS = 'num_bits'
+SIGNED = 'signed'
+THRESHOLD = 'threshold'
+PER_CHANNEL = 'per_channel'
+MIN_RANGE = 'min_range'
+MAX_RANGE = 'max_range'
+CHANNEL_AXIS = 'channel_axis'
+CLUSTER_CENTERS = 'cluster_centers'
+MULTIPLIER_N_BITS = 'multiplier_n_bits'
+EPS = 'eps'

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/weights_inferable_quantizers/__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.
+# ==============================================================================

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/weights_inferable_quantizers/weights_lut_pot_inferable_quantizer.py

@@ -0,0 +1,77 @@
+# 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 numpy as np
+
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+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_TORCH:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers \
+        .weights_inferable_quantizers.weights_lut_symmetric_inferable_quantizer import \
+        WeightsLUTSymmetricInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.LUT_POT_QUANTIZER],
+                    quantizer_type=None)
+    class WeightsLUTPOTInferableQuantizer(WeightsLUTSymmetricInferableQuantizer):
+        """
+        Class for quantizing weights using lut power-of-two quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     cluster_centers: np.ndarray,
+                     threshold: np.ndarray,
+                     per_channel: bool,
+                     channel_axis: 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 of input to apply per-channel quantization on
+                multiplier_n_bits: Number of bits that determines the quantization range
+                eps: Small value for numerical stability in division
+            """
+            # target of Weights quantization
+            super(WeightsLUTPOTInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                                  threshold=threshold,
+                                                                  cluster_centers=cluster_centers,
+                                                                  per_channel=per_channel,
+                                                                  channel_axis=channel_axis,
+                                                                  multiplier_n_bits=multiplier_n_bits,
+                                                                  eps=eps)
+
+            is_threshold_pot = np.all(np.round(np.log2(threshold.flatten())) == np.log2(threshold.flatten()))
+            assert is_threshold_pot, f'Expected threshold to be power of 2 but is {threshold}'
+
+
+else:
+    class WeightsLUTPOTInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using WeightsLUTPOTInferableQuantizer. '
+                            'Could not find torch package.')