mct-nightly 1.8.0.20052023.post401__py3-none-any.whl → 1.8.0.20230610.post356__py3-none-any.whl

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantize_wrapper.py

@@ -1,269 +0,0 @@
-# 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.constants import FOUND_TORCH
-from model_compression_toolkit.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

@@ -1,152 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/activation_inferable_quantizers/__init__.py

@@ -1,14 +0,0 @@
-# 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/activation_inferable_quantizers/activation_lut_pot_inferable_quantizer.py

@@ -1,96 +0,0 @@
-# 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.constants import FOUND_TORCH
-from model_compression_toolkit.target_platform_capabilities.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.
-            """
-            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

@@ -1,62 +0,0 @@
-# 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.constants import FOUND_TORCH
-from model_compression_toolkit.target_platform_capabilities.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.')