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/weights_inferable_quantizers/weights_lut_symmetric_inferable_quantizer.py

@@ -0,0 +1,106 @@
+# 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.Weights,
+                    quantization_method=[QuantizationMethod.LUT_SYM_QUANTIZER],
+                    quantizer_type=None)
+    class WeightsLUTSymmetricInferableQuantizer(BaseLUTSymmetricInferableQuantizer):
+        """
+        Class for quantizing weights using a lut symmetric 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
+            """
+
+            super(WeightsLUTSymmetricInferableQuantizer, self).__init__(threshold=threshold,
+                                                                        num_bits=num_bits,
+                                                                        cluster_centers=cluster_centers,
+                                                                        signed=True,
+                                                                        multiplier_n_bits=multiplier_n_bits,
+                                                                        eps=eps)
+
+            if per_channel:
+                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 should be of length >= 1 but is ' \
+                                     f'{len(threshold)}'
+            else:
+                assert len(
+                    threshold) == 1, f'In per-tensor quantization threshold should be of length 1 but is ' \
+                                     f'{len(threshold)}'
+
+            self.per_channel = per_channel
+            self.channel_axis = channel_axis
+
+            self.threshold = to_torch_tensor(self.threshold).to(get_working_device())
+            self.cluster_centers = to_torch_tensor(self.cluster_centers).to(get_working_device())
+
+        def __call__(self, inputs: torch.Tensor) -> 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=True,
+                                 threshold=self.threshold, multiplier_n_bits=self.multiplier_n_bits, eps=self.eps)
+
+
+else:
+    class WeightsLUTSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using WeightsLUTSymmetricInferableQuantizer. '
+                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/weights_inferable_quantizers/weights_pot_inferable_quantizer.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.
+# ==============================================================================
+
+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.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: np.ndarray,
+                     per_channel: bool,
+                     channel_axis: 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 of input to apply per-channel quantization on.
+            """
+            # target of Weights quantization
+            super(WeightsPOTInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                               threshold=threshold,
+                                                               per_channel=per_channel,
+                                                               channel_axis=channel_axis)
+
+            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 WeightsPOTInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using WeightsPOTInferableQuantizer. '
+                            'Could not find torch package.')

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

@@ -0,0 +1,104 @@
+# 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.quantizer_utils import to_torch_tensor, \
+        get_working_device
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_symmetric_inferable_quantizer import \
+        BaseSymmetricInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.SYMMETRIC],
+                    quantizer_type=None)
+    class WeightsSymmetricInferableQuantizer(BaseSymmetricInferableQuantizer):
+        """
+        Class for quantizing weights using a symmetric quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     threshold: np.ndarray,
+                     per_channel: bool,
+                     channel_axis: 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 of input to apply per-channel quantization on.
+            """
+
+            super(WeightsSymmetricInferableQuantizer, self).__init__(threshold=threshold,
+                                                                     num_bits=num_bits,
+                                                                     signed=True)
+
+            if per_channel:
+                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 should be of length >= 1 but is ' \
+                                     f'{len(threshold)}'
+            else:
+                assert len(
+                    threshold) == 1, f'In per-tensor quantization threshold should be of length 1 but is {len(threshold)}'
+
+            self.per_channel = per_channel
+            self.channel_axis = channel_axis
+
+            self.scales = to_torch_tensor(self.scales).to(get_working_device())
+            self.zero_points = torch.zeros(len(threshold), dtype=torch.int32).to(get_working_device())
+
+        def __call__(self, inputs: torch.Tensor) -> torch.Tensor:
+            """
+            Quantize the given inputs using the quantizer parameters.
+
+            Args:
+                inputs: input tensor to quantize
+
+            Returns:
+                quantized tensor.
+            """
+            inputs.requires_grad = False
+            if self.per_channel:
+                return torch.fake_quantize_per_channel_affine(inputs,
+                                                              self.scales,
+                                                              self.zero_points,
+                                                              axis=self.channel_axis,
+                                                              quant_min=self.min_quantized_domain,
+                                                              quant_max=self.max_quantized_domain)
+            return torch.fake_quantize_per_tensor_affine(inputs,
+                                                         self.scales,
+                                                         self.zero_points,
+                                                         quant_min=self.min_quantized_domain,
+                                                         quant_max=self.max_quantized_domain)
+
+
+else:
+    class WeightsSymmetricInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            raise Exception('Installing torch is mandatory '
+                            'when using WeightsSymmetricInferableQuantizer. '
+                            'Could not find torch package.')

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

@@ -0,0 +1,109 @@
+# 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.logger import Logger
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import QuantizationTarget, \
+    mark_quantizer
+
+if FOUND_TORCH:
+    import torch
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizer_utils import get_working_device, \
+    fix_range_to_include_zero, to_torch_tensor
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_uniform_inferable_quantizer import \
+        BaseUniformInferableQuantizer
+
+
+    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
+                    quantization_method=[QuantizationMethod.UNIFORM],
+                    quantizer_type=None)
+    class WeightsUniformInferableQuantizer(BaseUniformInferableQuantizer):
+        """
+        Class for quantizing weights using a uniform quantizer
+        """
+
+        def __init__(self,
+                     num_bits: int,
+                     min_range: np.ndarray,
+                     max_range: np.ndarray,
+                     per_channel: bool,
+                     channel_axis: 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 of input to apply per-channel quantization on.
+            """
+            super(WeightsUniformInferableQuantizer, self).__init__(num_bits=num_bits,
+                                                                   min_range=min_range,
+                                                                   max_range=max_range)
+
+            # Align mix/max numpy arrays so they are torch Tensors on the working device
+            min_range = to_torch_tensor(min_range).to(get_working_device())
+            max_range = to_torch_tensor(max_range).to(get_working_device())
+
+            self.per_channel = per_channel
+            self.channel_axis = channel_axis
+
+            min_range, max_range = fix_range_to_include_zero(min_range,
+                                                             max_range,
+                                                             num_bits)
+            # Compute the step size of quantized values.
+            self.scales = (max_range - min_range) / (2 ** num_bits - 1)
+            self.zero_points = -(
+                        min_range / self.scales).int()  # zp has to be positive, and a <=0, so we multiply by -1
+
+            self.scales = self.scales.to(get_working_device())
+            self.zero_points = self.zero_points.to(get_working_device())
+
+        def __call__(self,
+                     inputs: torch.Tensor) -> torch.Tensor:
+            """
+            Weight fake quantizer
+            Args:
+                inputs: weights to quantize.
+
+            Returns:
+                quantized weights
+            """
+            inputs.requires_grad = False
+            if self.per_channel:
+                return torch.fake_quantize_per_channel_affine(inputs,
+                                                              self.scales.flatten(),
+                                                              self.zero_points.flatten(),
+                                                              axis=self.channel_axis,
+                                                              quant_min=self.min_quantized_domain,
+                                                              quant_max=self.max_quantized_domain)
+            return torch.fake_quantize_per_tensor_affine(inputs,
+                                                         self.scales,
+                                                         self.zero_points,
+                                                         quant_min=self.min_quantized_domain,
+                                                         quant_max=self.max_quantized_domain)
+
+
+else:
+    class WeightsUniformInferableQuantizer:  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            Logger.error('Installing torch is mandatory '
+                         'when using WeightsUniformInferableQuantizer. '
+                         'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/trainable_infrastructure/__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/trainable_infrastructure/common/__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/trainable_infrastructure/common/base_trainable_quantizer.py

@@ -0,0 +1,200 @@
+# 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.
+# ==============================================================================
+from abc import abstractmethod
+from enum import Enum
+from typing import Union, List, Any
+from inspect import signature
+
+from model_compression_toolkit.core import common
+from model_compression_toolkit.core.common import Logger
+
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import BaseInferableQuantizer, \
+    QuantizationTarget
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.common.trainable_quantizer_config import \
+    TrainableQuantizerActivationConfig, TrainableQuantizerWeightsConfig
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import QUANTIZATION_METHOD, \
+    QUANTIZATION_TARGET
+
+
+VAR = 'var'
+GROUP = 'group'
+
+class VariableGroup(Enum):
+    """
+    An enum for choosing trainable variable group
+    0. WEIGHTS
+    1. QPARAMS
+    """
+    WEIGHTS = 0
+    QPARAMS = 1
+
+
+class BaseTrainableQuantizer(BaseInferableQuantizer):
+    def __init__(self,
+                 quantization_config: Union[TrainableQuantizerActivationConfig, TrainableQuantizerWeightsConfig]):
+        """
+        This class is a base quantizer which validates the provided quantization config and defines an abstract function which any quantizer needs to implment.
+
+        Args:
+            quantization_config: quantizer config class contains all the information about the quantizer configuration.
+        """
+
+        # verify the quantizer class that inherits this class only has a config argument and key-word arguments
+        for i, (k, v) in enumerate(self.get_sig().parameters.items()):
+            if i == 0:
+                if v.annotation not in [TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig]:
+                    common.Logger.error(f"First parameter must be either TrainableQuantizerWeightsConfig or TrainableQuantizerActivationConfig")  # pragma: no cover
+            elif v.default is v.empty:
+                common.Logger.error(f"Parameter {k} doesn't have a default value")  # pragma: no cover
+
+        super(BaseTrainableQuantizer, self).__init__()
+        self.quantization_config = quantization_config
+
+        # Inherited class should be decorated with @mark_quantizer decorator, and define the following static properties
+        static_quantization_method = getattr(self, QUANTIZATION_METHOD, None)
+        static_quantization_target = getattr(self, QUANTIZATION_TARGET, None)
+
+        if static_quantization_method is None or static_quantization_target is None:
+            Logger.error("A quantizer class that inherit from BaseTrainableQuantizer is not defined appropriately."
+                         "Either it misses the @mark_quantizer decorator or the decorator is not used correctly.")
+
+        if static_quantization_target == QuantizationTarget.Weights:
+            self.validate_weights()
+            if self.quantization_config.weights_quantization_method not in static_quantization_method:
+                common.Logger.error(
+                    f'Quantization method mismatch expected: {static_quantization_method} and got  {self.quantization_config.weights_quantization_method}')
+        elif static_quantization_target == QuantizationTarget.Activation:
+            self.validate_activation()
+            if self.quantization_config.activation_quantization_method not in static_quantization_method:
+                common.Logger.error(
+                    f'Quantization method mismatch expected: {static_quantization_method} and got  {self.quantization_config.activation_quantization_method}')
+        else:
+            common.Logger.error(
+                f'Unknown Quantization Part:{static_quantization_target}')  # pragma: no cover
+
+        self.quantizer_parameters = {}
+
+    @classmethod
+    def get_sig(cls):
+        return signature(cls)
+
+    def initialize_quantization(self,
+                                tensor_shape,
+                                name: str,
+                                layer):
+        """
+        This initializes the quantizer parameters given the parameter name and shape.
+
+        Args:
+            tensor_shape:  tensor shape
+            name: tensor name
+            layer: layer to quantized
+
+        Returns: None
+
+        """
+        raise NotImplemented  # pragma: no cover
+
+    def __call__(self,
+                 input2quantize,
+                 training: bool):
+        """
+        Quantize a tensor.
+
+        Args:
+            input2quantize: Input tensor to quantize.
+            training: Whether the graph is in training mode.
+
+        Returns:
+            The quantized tensor.
+        """
+        raise NotImplemented  # pragma: no cover
+
+    def activation_quantization(self) -> bool:
+        """
+
+        Returns: A boolean stating is this activation quantizer
+
+        """
+        return isinstance(self.quantization_config, TrainableQuantizerActivationConfig)
+
+    def weights_quantization(self) -> bool:
+        """
+
+        Returns: A boolean stating is this weights quantizer
+
+        """
+        return isinstance(self.quantization_config, TrainableQuantizerWeightsConfig)
+
+    def validate_weights(self) -> None:
+        """
+        This function validates the quantization config compared with its parameters.
+
+
+        """
+        if self.activation_quantization() or not self.weights_quantization():
+            common.Logger.error(f'Expect weight quantization got activation')
+
+    def validate_activation(self) -> None:
+        """
+        This function validates the quantization config compared with its parameters.
+
+        """
+        if not self.activation_quantization() or self.weights_quantization():
+            common.Logger.error(f'Expect activation quantization got weight')
+
+    def convert2inferable(self) -> BaseInferableQuantizer:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            BaseInferableQuantizer object.
+        """
+        raise NotImplemented  # pragma: no cover
+
+    def add_quantizer_variable(self, name: str, variable: Any, group: VariableGroup = VariableGroup.WEIGHTS):
+        """
+        Add a quantizer variable to quantizer_parameters dictionary
+        """
+        self.quantizer_parameters.update({name: {VAR: variable, GROUP: group}})
+
+    def get_quantizer_variable(self, name: str) -> Any:
+        """
+        Get a quantizer variable by name
+
+        Args:
+            name: variable name
+
+        Returns:
+            trainable variable
+        """
+        if name in self.quantizer_parameters:
+            return self.quantizer_parameters[name][VAR]
+        else:
+            common.Logger.error(f'Variable {name} is not exist in quantizers parameters!') # pragma: no cover
+
+
+    @abstractmethod
+    def get_trainable_variables(self, group: VariableGroup) -> List[Any]:
+        """
+        Get trainable parameters with specific group from quantizer
+
+        Args:
+            group: Enum of variable group
+
+        Returns:
+            List of trainable variables
+        """
+        raise NotImplemented  # pragma: no cover