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

@@ -0,0 +1,269 @@
+# Copyright 2022 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.
+# ==============================================================================f
+from typing import List, Union, Any, Dict, Tuple
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+from model_compression_toolkit.core.common.logger import Logger
+from model_compression_toolkit.quantizers_infrastructure import BaseInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import LAYER, TRAINING
+import inspect
+
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.pytorch.base_pytorch_quantizer import \
+    BasePytorchTrainableQuantizer
+
+if FOUND_TORCH:
+    import torch
+    import torch.nn as nn
+
+
+    class PytorchQuantizationWrapper(nn.Module):
+        def __init__(self,
+                     module: nn.Module,
+                     weights_quantizers: Dict[str, BaseInferableQuantizer] = None,
+                     activation_quantizers: List[BaseInferableQuantizer] = None):
+            """
+            Pytorch Quantization Wrapper takes a pytorch module and quantizers and infer a quantized module.
+
+            Args:
+                module: A pytorch module.
+                weights_quantizers: A dictionary between a weight's name to its quantizer.
+                activation_quantizers: A list of activations quantization, one for each layer output.
+            """
+            super().__init__()
+            if isinstance(module, nn.Module):
+                self.add_module(LAYER, module)
+            else:
+                # Functional layers
+                setattr(self, LAYER, module)
+
+            self.weights_quantizers = weights_quantizers if weights_quantizers is not None else dict()
+            self.activation_quantizers = activation_quantizers if activation_quantizers is not None else list()
+            self._set_weights_vars(True)
+            self._set_activation_vars()
+
+        def add_weights_quantizer(self, param_name: str, quantizer: BaseInferableQuantizer):
+            """
+            This function adds a weights quantizer to existing wrapper
+
+            Args:
+                param_name: The name of the parameter to quantize
+                quantizer: A quantizer.
+
+            Returns: None
+
+            """
+            self.weights_quantizers.update({param_name: quantizer})
+
+        @property
+        def is_activation_quantization(self) -> bool:
+            """
+            This function check activation quantizer exists in wrapper.
+            Returns: a boolean if activation quantizer exists
+
+            """
+            return self.num_activation_quantizers > 0
+
+        @property
+        def is_weights_quantization(self) -> bool:
+            """
+            This function check weights quantizer exists in wrapper.
+
+            Returns: a boolean if weights quantizer exists
+
+            """
+            return self.num_weights_quantizers > 0
+
+        @property
+        def num_weights_quantizers(self) -> int:
+            """
+            Returns: number of weights quantizers
+            """
+            return len(self.weights_quantizers)
+
+        @property
+        def num_activation_quantizers(self) -> int:
+            """
+            Returns: number of activations quantizers
+            """
+            return len(self.activation_quantizers)
+
+        def convert_to_inferable_quantizers(self):
+            """
+            Convert the wrapper quantizers with inferable quantizers
+
+            """
+            # Activation quantizers
+            if self.is_activation_quantization:
+                inferable_activation_quantizers = []
+                for quantizer in self.activation_quantizers:
+                    if isinstance(quantizer, BasePytorchTrainableQuantizer):
+                        inferable_activation_quantizers.append(quantizer.convert2inferable())
+                    else:
+                        Logger.error('Can only convert trainable quantizers based on BasePytorchTrainableQuantizer') # pragma: no cover
+                self.activation_quantizers = inferable_activation_quantizers
+                self._set_activation_vars()
+
+            # Weight quantizers
+            if self.is_weights_quantization:
+                inferable_weight_quantizers = {}
+                for name, quantizer in self.weights_quantizers.items():
+                    if isinstance(quantizer, BasePytorchTrainableQuantizer):
+                        inferable_weight_quantizers.update({name: quantizer.convert2inferable()})
+                    else:
+                        Logger.error('Can only convert trainable quantizers based on BasePytorchTrainableQuantizer') # pragma: no cover
+                self.weights_quantizers = inferable_weight_quantizers
+                self._set_weights_vars(False)
+
+        def _set_weights_vars(self, is_training: bool = True):
+            """
+            Initialize learnable weights as parameters in the wrapper, and their quantizers
+
+            Args:
+                is_training: Whether working with InferableQuantizers or not. If so, do not register weight as parameter.
+
+            """
+            self._weights_vars = []
+
+            # Init weights quantizers
+            for name, quantizer in self.weights_quantizers.items():
+                if is_training:
+                    weight = getattr(self.layer, name).detach()
+                    delattr(self.layer, name)
+                    setattr(self.layer, name, weight)
+                    self.register_parameter(name, torch.nn.Parameter(weight, requires_grad=True))
+                else:
+                    weight = getattr(self, name).detach()
+                    delattr(self.layer, name)
+                    setattr(self.layer, name, weight)
+                quantizer.initialize_quantization(weight.shape, name, self)
+                self._weights_vars.append((name, getattr(self, name), quantizer))
+
+        def _set_activation_vars(self):
+            """
+            Initialize layer outputs and their quantizers in the wrapper
+            """
+            self._activation_vars = []
+            for i, quantizer in enumerate(self.activation_quantizers):
+                quantizer.initialize_quantization(None, f"tensor{i}", self)
+                self._activation_vars.append(quantizer)
+
+        def set_quantize_weights(self, quantized_weights: dict):
+            """
+            This function updates layer weights after quantization.
+
+            Args:
+                quantized_weights: a dict of weight to update
+
+            Returns: None
+
+            """
+            for weight_attr in self.weights_quantizers.keys():
+                weight = quantized_weights.get(weight_attr)
+                setattr(self.layer, weight_attr, weight)
+
+        def get_weights_vars(self) -> List[Tuple[str, Any, BaseInferableQuantizer]]:
+            """
+            A getter of the layer's weights variables.
+
+            Returns:
+                List pf tuples of the wrapped layer's weights variables with weight name, values and assigned quantizer.
+
+            """
+
+            return self._weights_vars
+
+        def forward(self,
+                    *args: List[Any],
+                    **kwargs: Dict[str, Any]) -> Union[torch.Tensor, List[torch.Tensor]]:
+            """
+            PytorchQuantizationWrapper forward functions
+            Args:
+                args: arguments to pass to internal layer.
+                kwargs: key-word dictionary to pass to the internal layer.
+
+            Returns: a tensor that simulates a quantized layer.
+
+            """
+
+            # ----------------------------------
+            # Quantize all weights, and replace them in the underlying layer.
+            # ----------------------------------
+            if self.is_weights_quantization:
+
+                quantized_weights = {}
+                for name, unquantized_weight, quantizer in self._weights_vars:
+                    s = inspect.signature(quantizer.__call__)
+                    if TRAINING in s.parameters.keys():
+                        quantized_weight = quantizer(unquantized_weight, self.training)
+                    else:
+                        quantized_weight = quantizer(unquantized_weight)
+
+                    quantized_weights.update({name: quantized_weight})
+
+                self.set_quantize_weights(quantized_weights)
+
+            # ----------------------------------
+            # Layer operation
+            # ----------------------------------
+            outputs = self.layer(*args, **kwargs)
+
+            # ----------------------------------
+            # Quantize all activations
+            # ----------------------------------
+            if self.is_activation_quantization:
+
+                if not isinstance(outputs, list):
+                    outputs = [outputs]
+
+                if len(outputs) != self.num_activation_quantizers:
+                    Logger.error(f"Number of outputs {len(outputs)} is incompatible number of activation quantizers {self.num_activation_quantizers}")  # pragma: no cover
+
+                # Quantize all activations tensors
+                outputs_quantized = []
+                for quantizer, output in zip(self._activation_vars, outputs):
+                    outputs_quantized.append(quantizer(output))
+
+                outputs = outputs_quantized[0] if len(outputs_quantized) == 1 else outputs_quantized
+
+            return outputs
+
+        def get_quantized_weights(self) -> Dict[str, torch.Tensor]:
+            """
+
+            Returns: A dictionary of weights attributes to quantized weights.
+
+            """
+            quantized_weights = {}
+            weights_var = self.get_weights_vars()
+            for name, w, quantizer in weights_var:
+                quantized_weights[name] = quantizer(w)
+            return quantized_weights
+
+else:
+    class PytorchQuantizationWrapper(object):
+        def __init__(self,
+                     layer,
+                     weight_quantizers: Dict[str, BaseInferableQuantizer] = None,
+                     activation_quantizers: List[BaseInferableQuantizer] = None):
+            """
+            Pytorch Quantization Wrapper takes a pytorch module and quantizers and infer a quantized layer.
+
+            Args:
+                layer: A pytorch module.
+                weight_quantizers: A dictionary between a weight's name to its quantizer.
+                activation_quantizers: A list of activations quantization, one for each layer output.
+            """
+            Logger.critical('Installing Pytorch is mandatory '
+                            'when using PytorchQuantizationWrapper. '
+                            'Could not find torch package.')  # pragma: no cover

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizer_utils.py

@@ -0,0 +1,152 @@
+# 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 Tuple
+
+import torch
+import numpy as np
+
+
+def get_working_device():
+    """
+    Get the working device of the environment
+
+    Returns:
+        Device "cuda" if GPU is available, else "cpu"
+
+    """
+    return torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+
+def to_torch_tensor(tensor):
+    """
+    Convert a Numpy array to a Torch tensor.
+    Args:
+        tensor: Numpy array.
+
+    Returns:
+        Torch tensor converted from the input Numpy array.
+    """
+    working_device = get_working_device()
+    if isinstance(tensor, torch.Tensor):
+        return tensor.to(working_device)
+    elif isinstance(tensor, list):
+        return [to_torch_tensor(t) for t in tensor]
+    elif isinstance(tensor, tuple):
+        return (to_torch_tensor(t) for t in tensor)
+    elif isinstance(tensor, np.ndarray):
+        return torch.from_numpy(tensor.astype(np.float32)).to(working_device)
+    elif isinstance(tensor, float):
+        return torch.Tensor([tensor]).to(working_device)
+    elif isinstance(tensor, int):
+        return torch.Tensor([tensor]).int().to(working_device)
+    else:
+        raise Exception(f'Conversion of type {type(tensor)} to {type(torch.Tensor)} is not supported')
+
+
+def fix_range_to_include_zero(range_min: torch.Tensor,
+                              range_max: torch.Tensor,
+                              n_bits: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Adjusting the quantization range to include representation of 0.0 in the quantization grid.
+    If quantization per-channel, then range_min and range_max should be tensors in the specific shape that allows
+    quantization along the channel_axis.
+    Args:
+        range_min: min bound of the quantization range (before adjustment).
+        range_max: max bound of the quantization range (before adjustment).
+        n_bits: Number of bits to quantize the tensor.
+    Returns: adjusted quantization range
+    """
+    min_positive = range_min > 0
+    max_negative = range_max < 0
+    mid_range = torch.logical_and(torch.logical_not(min_positive), torch.logical_not(max_negative))
+    min_positive = min_positive.float()
+    max_negative = max_negative.float()
+    mid_range = mid_range.float()
+
+    scale = (range_max - range_min) / (2 ** n_bits - 1)
+    min_range_adj = scale * torch.round(range_min / scale)
+    max_range_adj = range_max - range_min + min_range_adj
+
+    min_range_adj = min_range_adj * mid_range + max_negative * range_min
+    max_range_adj = max_range_adj * mid_range + min_positive * range_max
+    return min_range_adj, max_range_adj
+
+
+def lut_quantizer(tensor_data: torch.Tensor,
+                  cluster_centers: torch.Tensor,
+                  signed: bool,
+                  threshold: torch.Tensor,
+                  multiplier_n_bits: int,
+                  eps: float) -> torch.Tensor:
+    """
+    Quantize a tensor using a non-uniform quantization based on the pre-defined clusters.
+    1. Scales tensor_data with the threshold into n-bit quantization range.
+    2. Assigns cluster centers to each value.
+    3. Scales back by multiplying the result by threshold and dividing with the quantization range max value.
+    The result is the quantized tensor.
+
+    Args:
+        tensor_data: Input activation tensor.
+        cluster_centers: The cluster centers to assign the tensor values.
+        signed: Whether the quantization is signed or not.
+        threshold: Threshold for quantization.
+        multiplier_n_bits: Number of bits that determines the quantization range
+        eps: Small value for numerical stability in division.
+
+    Returns: Quantized tensor.
+    """
+
+    tensor = int_quantization_with_threshold(tensor_data, n_bits=multiplier_n_bits, signed=signed, threshold=threshold,
+                                             eps=eps)
+    tensor = tensor.unsqueeze(-1)
+
+    expanded_cluster_centers = cluster_centers.reshape([*[1 for _ in range(len(tensor.shape) - 1)], -1])
+    cluster_assignments = torch.argmin(torch.abs(tensor - expanded_cluster_centers), dim=-1)
+    centers = cluster_centers.flatten()[cluster_assignments]
+
+    quant_tensor = (centers / (2 ** (multiplier_n_bits - int(signed)))) * threshold
+
+    return quant_tensor
+
+
+def int_quantization_with_threshold(data: torch.Tensor,
+                                    n_bits: int,
+                                    signed: bool,
+                                    threshold: torch.Tensor,
+                                    eps: float) -> torch.Tensor:
+    """
+    Divides data by threshold and quantize it to integers in the quantization range (depends on signed value).
+
+    Args:
+        data: Tensor data.
+        n_bits: Number of bits that determines the quantization range.
+        signed: Whether the quantization is signed or not.
+        threshold: Threshold for quantization.
+        eps: Small value for numerical stability in division.
+
+    Returns:
+        Uniform Quantized tensor.
+
+    """
+
+    if signed:
+        clip_max = 2 ** (n_bits - 1) - 1
+        clip_min = -2 ** (n_bits - 1)
+    else:
+        clip_max = 2 ** n_bits - 1
+        clip_min = 0
+
+    return torch.clip((data / (threshold + eps)) * (2 ** (n_bits - int(signed))),
+                      min=clip_min, max=clip_max)

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

@@ -0,0 +1,35 @@
+# 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 model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.activation_inferable_quantizers.activation_pot_inferable_quantizer \
+    import ActivationPOTInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.activation_inferable_quantizers.activation_symmetric_inferable_quantizer \
+    import ActivationSymmetricInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.activation_inferable_quantizers.activation_uniform_inferable_quantizer \
+    import ActivationUniformInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.activation_inferable_quantizers.activation_lut_pot_inferable_quantizer \
+    import ActivationLutPOTInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_pytorch_inferable_quantizer \
+    import BasePyTorchInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.weights_inferable_quantizers.weights_pot_inferable_quantizer \
+    import WeightsPOTInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.weights_inferable_quantizers.weights_symmetric_inferable_quantizer \
+    import WeightsSymmetricInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.weights_inferable_quantizers.weights_uniform_inferable_quantizer \
+    import WeightsUniformInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.weights_inferable_quantizers.weights_lut_symmetric_inferable_quantizer \
+    import WeightsLUTSymmetricInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.weights_inferable_quantizers.weights_lut_pot_inferable_quantizer \
+    import WeightsLUTPOTInferableQuantizer

model_compression_toolkit/{exporter/model_wrapper/pytorch/quantizers → quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/activation_inferable_quantizers}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
+# 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.

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

@@ -0,0 +1,97 @@
+# 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:
+    import torch
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizer_utils \
+        import to_torch_tensor, get_working_device, lut_quantizer
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers \
+        .base_lut_symmetric_inferable_quantizer import BaseLUTSymmetricInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                    quantization_method=[QuantizationMethod.LUT_POT_QUANTIZER],
+                    quantizer_type=None)
+    class ActivationLutPOTInferableQuantizer(BaseLUTSymmetricInferableQuantizer):
+        """
+        Class for quantizing activations using a lut power-of-two quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     cluster_centers: np.ndarray,
+                     threshold: np.ndarray,
+                     signed: bool,
+                     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 activations
+                threshold: threshold for quantizing activations
+                signed: whether to use signed quantization or not
+                multiplier_n_bits: Number of bits that determines the quantization range
+                eps: Small value for numerical stability in division
+            """
+
+            super(ActivationLutPOTInferableQuantizer, self).__init__(
+                num_bits=num_bits,
+                cluster_centers=cluster_centers,
+                threshold=threshold,
+                signed=signed,
+                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}'
+
+            # Activation supports only per-tensor quantization
+            assert len(
+                self.threshold) == 1, f'For activation, quantization per channel is not supported and threshold ' \
+                                      f'should be of length 1 but is {len(threshold)}'
+            self.threshold = self.threshold[0]
+
+            self.cluster_centers = to_torch_tensor(self.cluster_centers).to(get_working_device())
+
+        def __call__(self, inputs: torch.Tensor):
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            inputs.requires_grad = False
+            return lut_quantizer(inputs, cluster_centers=self.cluster_centers, signed=self.signed,
+                                 threshold=self.threshold, multiplier_n_bits=self.multiplier_n_bits, eps=self.eps)
+
+else:
+    class ActivationLutPOTInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using ActivationLutPOTInferableQuantizer. '
+                            'Could not find torch package.')

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

@@ -0,0 +1,62 @@
+# 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:
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.activation_inferable_quantizers.activation_symmetric_inferable_quantizer import \
+        ActivationSymmetricInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                    quantization_method=[QuantizationMethod.POWER_OF_TWO],
+                    quantizer_type=None)
+    class ActivationPOTInferableQuantizer(ActivationSymmetricInferableQuantizer):
+        """
+        Class for quantizing activations using power-of-two 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
+            """
+            # target of Activation quantization
+            super(ActivationPOTInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                                  signed=signed,
+                                                                  threshold=threshold)
+
+            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 ActivationPOTInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using ActivationPOTInferableQuantizer. '
+                            'Could not find torch package.')