mct-nightly 2.2.0.20241012.448__py3-none-any.whl → 2.2.0.20241018.449__py3-none-any.whl

model_compression_toolkit/qat/keras/quantizer/ste_rounding/uniform_ste.py

@@ -16,28 +16,26 @@ import numpy as np
 import tensorflow as tf
 from tensorflow.python.framework.tensor_shape import TensorShape
 from model_compression_toolkit.constants import RANGE_MIN, RANGE_MAX
+from model_compression_toolkit.qat.keras.quantizer.base_keras_qat_weight_quantizer import \
+    BaseKerasQATWeightTrainableQuantizer
 from model_compression_toolkit.trainable_infrastructure.common.constants import FQ_MIN, FQ_MAX
 from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
 from model_compression_toolkit.trainable_infrastructure import TrainingMethod
 
 from mct_quantizers import mark_quantizer, QuantizationMethod, QuantizationTarget
-from mct_quantizers.keras.quantizers import \
-    BaseKerasInferableQuantizer, WeightsUniformInferableQuantizer, ActivationUniformInferableQuantizer
+from mct_quantizers.keras.quantizers import BaseKerasInferableQuantizer, WeightsUniformInferableQuantizer
 
 from model_compression_toolkit.qat.keras.quantizer.quant_utils import adjust_range_to_include_zero
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import fix_range_to_include_zero
-from model_compression_toolkit import constants as C
 
-from model_compression_toolkit.qat.keras.quantizer.base_keras_qat_quantizer import BaseKerasQATTrainableQuantizer
-from model_compression_toolkit.trainable_infrastructure import TrainableQuantizerWeightsConfig, \
-    TrainableQuantizerActivationConfig
+from model_compression_toolkit.trainable_infrastructure import TrainableQuantizerWeightsConfig
 from model_compression_toolkit.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
 
 
 @mark_quantizer(quantization_target=QuantizationTarget.Weights,
                 quantization_method=[QuantizationMethod.UNIFORM],
                 identifier=TrainingMethod.STE)
-class STEUniformWeightQATQuantizer(BaseKerasQATTrainableQuantizer):
+class STEUniformWeightQATQuantizer(BaseKerasQATWeightTrainableQuantizer):
     """
     Trainable constrained quantizer to quantize a layer inputs.
     """
@@ -148,91 +146,3 @@ class STEUniformWeightQATQuantizer(BaseKerasQATTrainableQuantizer):
                                                 input_rank=len(self.min_max_shape))
 
 
-@mark_quantizer(quantization_target=QuantizationTarget.Activation,
-                quantization_method=[QuantizationMethod.UNIFORM],
-                identifier=TrainingMethod.STE)
-class STEUniformActivationQATQuantizer(BaseKerasQATTrainableQuantizer):
-    """
-    Trainable constrained quantizer to quantize a layer outputs.
-    """
-
-    def __init__(self, quantization_config: TrainableQuantizerActivationConfig):
-        """
-        Initialize a STEUniformActivationQATQuantizer object with parameters to use
-        for the quantization.
-
-        Args:
-            quantization_config: trainable quantizer config class
-        """
-        super().__init__(quantization_config)
-
-        self.num_bits = quantization_config.activation_n_bits
-        self.min_range = quantization_config.activation_quantization_params[C.RANGE_MIN]
-        self.max_range = quantization_config.activation_quantization_params[C.RANGE_MAX]
-
-    def initialize_quantization(self,
-                                tensor_shape: TensorShape,
-                                name: str,
-                                layer: KerasTrainableQuantizationWrapper):
-        """
-        Add quantizer parameters to the quantizer parameters dictionary
-
-        Args:
-            tensor_shape: tensor shape of the quantized tensor.
-            name: Tensor name.
-            layer: Layer to quantize.
-        """
-        fq_min = layer.add_weight(
-            name + FQ_MIN,
-            shape=(),
-            initializer=tf.keras.initializers.Constant(-1.0),
-            trainable=False)
-        fq_min.assign(self.min_range)
-
-        fq_max = layer.add_weight(
-            name + FQ_MAX,
-            shape=(),
-            initializer=tf.keras.initializers.Constant(1.0),
-            trainable=False)
-        fq_max.assign(self.max_range)
-
-        # save the quantizer added parameters for later calculations
-        self.add_quantizer_variable(FQ_MIN, fq_min, VariableGroup.QPARAMS)
-        self.add_quantizer_variable(FQ_MAX, fq_max, VariableGroup.QPARAMS)
-
-    def __call__(self,
-                 inputs: tf.Tensor,
-                 training: bool):
-        """
-        Quantize a tensor.
-        Args:
-            inputs: Input tensor to quantize.
-            training: Whether the graph is in training mode.
-
-        Returns:
-            The quantized tensor.
-        """
-
-        _min = self.get_quantizer_variable(FQ_MIN)
-        _max = self.get_quantizer_variable(FQ_MAX)
-        _min, _max = adjust_range_to_include_zero(_min, _max, self.num_bits)
-        q_tensor = tf.quantization.fake_quant_with_min_max_vars(inputs, _min, _max,
-                                                                num_bits=self.num_bits)
-
-        return q_tensor
-
-    def convert2inferable(self) -> BaseKerasInferableQuantizer:
-        """
-        Convert quantizer to inferable quantizer.
-
-        Returns:
-            BaseKerasInferableQuantizer object.
-        """
-        min_range, max_range = fix_range_to_include_zero(self.get_quantizer_variable(FQ_MIN).numpy(),
-                                                         self.get_quantizer_variable(FQ_MAX).numpy(),
-                                                         self.num_bits)
-        return ActivationUniformInferableQuantizer(num_bits=self.num_bits,
-                                                   # In activation quantization is per-tensor only - thus we pass
-                                                   # the min/max as lists with a len of 1
-                                                   min_range=[min_range],
-                                                   max_range=[max_range])

model_compression_toolkit/trainable_infrastructure/keras/activation_quantizers/__init__.py

@@ -0,0 +1,20 @@
+# Copyright 2024 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 .base_activation_quantizer import BaseKerasActivationTrainableQuantizer
+from .ste.symmetric_ste import STESymmetricActivationTrainableQuantizer
+from .ste.uniform_ste import STEUniformActivationTrainableQuantizer
+from .lsq.symmetric_lsq import LSQSymmetricActivationTrainableQuantizer
+from .lsq.uniform_lsq import LSQUniformActivationTrainableQuantizer

model_compression_toolkit/trainable_infrastructure/keras/activation_quantizers/base_activation_quantizer.py

@@ -0,0 +1,22 @@
+# Copyright 2024 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 ABC
+
+from model_compression_toolkit.trainable_infrastructure import BaseKerasTrainableQuantizer
+
+
+class BaseKerasActivationTrainableQuantizer(BaseKerasTrainableQuantizer, ABC):
+    """ Base class for Keras trainable activation quantizers """
+    pass

model_compression_toolkit/trainable_infrastructure/keras/activation_quantizers/lsq/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2024 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/trainable_infrastructure/keras/activation_quantizers/lsq/symmetric_lsq.py

@@ -0,0 +1,127 @@
+# Copyright 2024 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.trainable_infrastructure.keras.quantizer_utils import symmetric_lsq_quantizer
+from model_compression_toolkit.trainable_infrastructure.keras.activation_quantizers import BaseKerasActivationTrainableQuantizer
+from typing import Union
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.python.framework.tensor_shape import TensorShape
+from model_compression_toolkit.constants import SIGNED
+
+from model_compression_toolkit.trainable_infrastructure import TrainingMethod
+
+from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
+from mct_quantizers import QuantizationTarget, mark_quantizer
+from model_compression_toolkit.qat.common import THRESHOLD_TENSOR
+from model_compression_toolkit import constants as C
+
+from model_compression_toolkit.trainable_infrastructure import TrainableQuantizerActivationConfig
+from mct_quantizers.keras.quantizers import ActivationPOTInferableQuantizer, ActivationSymmetricInferableQuantizer
+from model_compression_toolkit.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
+
+@mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                quantization_method=[QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC],
+                identifier=TrainingMethod.LSQ)
+class LSQSymmetricActivationTrainableQuantizer(BaseKerasActivationTrainableQuantizer):
+    """
+    Trainable constrained quantizer to quantize layer activations.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerActivationConfig):
+        """
+        Initialize a LSQActivationQATQuantizer object with parameters to use
+        for the quantization.
+
+        Args:
+            quantization_config: trainable quantizer config class
+        """
+        super().__init__(quantization_config)
+        self.power_of_two = quantization_config.activation_quantization_method == QuantizationMethod.POWER_OF_TWO
+        self.threshold_values = float(quantization_config.activation_quantization_params[C.THRESHOLD])
+        self.threshold_shape = np.asarray(self.threshold_values).shape
+        self.sign = quantization_config.activation_quantization_params[SIGNED]
+        self.num_bits = quantization_config.activation_n_bits
+        n_pos_bits = self.num_bits - int(self.sign)
+        self.min_int = -int(self.sign) * (2 ** n_pos_bits)
+        self.max_int = (2 ** n_pos_bits) - 1
+        if self.power_of_two:
+            self.threshold_values = np.power(2.0, np.ceil(np.log2(np.maximum(self.threshold_values, C.MIN_THRESHOLD))))
+
+
+    def initialize_quantization(self,
+                                tensor_shape: TensorShape,
+                                name: str,
+                                layer: KerasTrainableQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+        ptq_threshold_tensor = layer.add_weight(
+            name + THRESHOLD_TENSOR,
+            shape=(),
+            initializer=tf.keras.initializers.Constant(1.0),
+            trainable=True)
+        ptq_threshold_tensor.assign(self.threshold_values)
+
+        # save the quantizer added parameters for later calculations
+        self.add_quantizer_variable(THRESHOLD_TENSOR, ptq_threshold_tensor, VariableGroup.QPARAMS)
+
+    def __call__(self,
+                 inputs: tf.Tensor,
+                 training: bool):
+        """
+        Quantize a tensor.
+        Args:
+            inputs: Input tensor to quantize.
+            training: Whether the graph is in training mode.
+
+        Returns:
+            The quantized tensor.
+        """
+
+        thresholds = self.get_quantizer_variable(THRESHOLD_TENSOR)
+        n_channels = inputs.shape[-1]
+        scale_factor = 1.0 / np.sqrt(self.max_int * n_channels)
+        q_tensor = symmetric_lsq_quantizer(inputs, thresholds, self.num_bits, self.sign, self.min_int, self.max_int, scale_factor)
+        return q_tensor
+
+    def convert2inferable(self) -> Union[ActivationPOTInferableQuantizer, ActivationSymmetricInferableQuantizer]:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            BaseKerasInferableQuantizer object.
+        """
+
+        if self.power_of_two:
+            thresholds = 2 ** np.ceil(np.log2(self.get_quantizer_variable(THRESHOLD_TENSOR).numpy()))
+            return ActivationPOTInferableQuantizer(num_bits=self.num_bits,
+                                                   # In activation quantization is per-tensor only - thus we pass
+                                                   # the threshold as a list with a len of 1
+                                                   threshold=[thresholds],
+                                                   signed=self.sign)
+        else:
+            thresholds = self.get_quantizer_variable(THRESHOLD_TENSOR).numpy()
+            return ActivationSymmetricInferableQuantizer(num_bits=self.num_bits,
+                                                         # In activation quantization is per-tensor only - thus we
+                                                         # pass the threshold as a list with a len of 1
+                                                         threshold=[thresholds],
+                                                         signed=self.sign)

model_compression_toolkit/trainable_infrastructure/keras/activation_quantizers/lsq/uniform_lsq.py

@@ -0,0 +1,129 @@
+# Copyright 2024 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 tensorflow as tf
+from tensorflow.python.framework.tensor_shape import TensorShape
+from model_compression_toolkit.constants import RANGE_MIN, RANGE_MAX
+from model_compression_toolkit.trainable_infrastructure.keras.quantizer_utils import uniform_lsq_quantizer
+from model_compression_toolkit.trainable_infrastructure.common.constants import FQ_MIN, FQ_MAX
+from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
+from model_compression_toolkit.trainable_infrastructure import TrainingMethod
+
+from mct_quantizers import mark_quantizer, QuantizationMethod, QuantizationTarget
+from mct_quantizers.keras.quantizers import \
+    BaseKerasInferableQuantizer, WeightsUniformInferableQuantizer, ActivationUniformInferableQuantizer
+
+from model_compression_toolkit import constants as C
+
+from model_compression_toolkit.trainable_infrastructure import TrainableQuantizerWeightsConfig, \
+    TrainableQuantizerActivationConfig
+from model_compression_toolkit.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
+from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import fix_range_to_include_zero
+from model_compression_toolkit.trainable_infrastructure.keras.activation_quantizers import \
+    BaseKerasActivationTrainableQuantizer
+
+
+@mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                quantization_method=[QuantizationMethod.UNIFORM],
+                identifier=TrainingMethod.LSQ)
+class LSQUniformActivationTrainableQuantizer(BaseKerasActivationTrainableQuantizer):
+    """
+    Trainable constrained quantizer to quantize layer activations.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerActivationConfig):
+        """
+        Initialize a LSQUniformActivationQATQuantizer object with parameters to use
+        for the quantization.
+
+        Args:
+            quantization_config: trainable quantizer config class
+        """
+        super().__init__(quantization_config)
+
+        self.num_bits = quantization_config.activation_n_bits
+        self.min_range = np.array(quantization_config.activation_quantization_params[C.RANGE_MIN])
+        self.max_range = np.array(quantization_config.activation_quantization_params[C.RANGE_MAX])
+        self.min_int = 0
+        self.max_int = 2**self.num_bits - 1
+
+    def initialize_quantization(self,
+                                tensor_shape: TensorShape,
+                                name: str,
+                                layer: KerasTrainableQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+        fq_min = layer.add_weight(
+            name + FQ_MIN,
+            shape=(),
+            initializer=tf.keras.initializers.Constant(-1.0),
+            trainable=True)
+        fq_min.assign(self.min_range)
+
+        fq_max = layer.add_weight(
+            name + FQ_MAX,
+            shape=(),
+            initializer=tf.keras.initializers.Constant(1.0),
+            trainable=True)
+        fq_max.assign(self.max_range)
+
+        # save the quantizer added parameters for later calculations
+        self.add_quantizer_variable(FQ_MIN, fq_min, VariableGroup.QPARAMS)
+        self.add_quantizer_variable(FQ_MAX, fq_max, VariableGroup.QPARAMS)
+
+    def __call__(self,
+                 inputs: tf.Tensor,
+                 training: bool):
+        """
+        Quantize a tensor.
+        Args:
+            inputs: Input tensor to quantize.
+            training: Whether the graph is in training mode.
+
+        Returns:
+            The quantized tensor.
+        """
+
+        min_range = self.get_quantizer_variable(FQ_MIN)
+        max_range = self.get_quantizer_variable(FQ_MAX)
+        n_channels = inputs.shape[-1]
+        scale_factor = 1.0 / np.sqrt(self.max_int * n_channels)
+        q_tensor = uniform_lsq_quantizer(inputs, min_range, max_range, self.num_bits, self.min_int, self.max_int, scale_factor)
+        return q_tensor
+
+    def convert2inferable(self) -> BaseKerasInferableQuantizer:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            BaseKerasInferableQuantizer object.
+        """
+        min_range, max_range = fix_range_to_include_zero(self.get_quantizer_variable(FQ_MIN).numpy(),
+                                                         self.get_quantizer_variable(FQ_MAX).numpy(),
+                                                         self.num_bits)
+        return ActivationUniformInferableQuantizer(num_bits=self.num_bits,
+                                                   # In activation quantization is per-tensor only - thus we pass
+                                                   # the min/max as lists with a len of 1
+                                                   min_range=[min_range],
+                                                   max_range=[max_range])
+
+

model_compression_toolkit/trainable_infrastructure/keras/activation_quantizers/ste/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2024 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/trainable_infrastructure/keras/activation_quantizers/ste/symmetric_ste.py

@@ -0,0 +1,148 @@
+# Copyright 2024 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 Union
+
+import numpy as np
+import tensorflow as tf
+
+from mct_quantizers import mark_quantizer, QuantizationTarget, QuantizationMethod
+from mct_quantizers.keras.quantizers import ActivationPOTInferableQuantizer, ActivationSymmetricInferableQuantizer
+from model_compression_toolkit import constants as C
+from model_compression_toolkit.trainable_infrastructure import TrainingMethod, TrainableQuantizerActivationConfig
+from model_compression_toolkit.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
+from model_compression_toolkit.trainable_infrastructure.common.constants import THRESHOLD_TENSOR
+from model_compression_toolkit.trainable_infrastructure.keras.activation_quantizers import BaseKerasActivationTrainableQuantizer
+from model_compression_toolkit.constants import SIGNED
+from tensorflow.python.framework.tensor_shape import TensorShape
+from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
+from model_compression_toolkit.trainable_infrastructure.common.constants import FQ_MIN, FQ_MAX
+
+
+# moved (and renamed) from model_compression_toolkit/qat/keras/quantizer/ste_rounding/symmetric_ste.py
+@mark_quantizer(quantization_target=QuantizationTarget.Activation,
+                quantization_method=[QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC],
+                identifier=TrainingMethod.STE)
+class STESymmetricActivationTrainableQuantizer(BaseKerasActivationTrainableQuantizer):
+
+    """
+    Trainable constrained quantizer to quantize a layer outputs.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerActivationConfig, freeze_quant_params: bool = False):
+        """
+        Initialize a STESymmetricActivationTrainableQuantizer object with parameters to use
+        for the quantization.
+
+        Args:
+            quantization_config: trainable quantizer config class
+            freeze_quant_params: whether to freeze learnable quantization parameters. This is unused here, since there is not any quantizaiton params that are learned.
+        """
+        super().__init__(quantization_config, freeze_quant_params)
+        self.power_of_two = quantization_config.activation_quantization_method == QuantizationMethod.POWER_OF_TWO
+        self.threshold_values = quantization_config.activation_quantization_params[C.THRESHOLD]
+        self.threshold_shape = np.asarray(self.threshold_values).shape
+        self.np_threshold_values = float(self.threshold_values)
+        self.signed = quantization_config.activation_quantization_params[SIGNED]
+        if self.power_of_two:
+            self.np_threshold_values = np.power(2.0,
+                                                np.ceil(
+                                                    np.log2(np.maximum(self.np_threshold_values, C.MIN_THRESHOLD))))
+        self.num_bits = quantization_config.activation_n_bits
+        delta = self.np_threshold_values / np.power(2.0, self.num_bits - int(self.signed))
+        min_int = -int(self.signed) * (2 ** (self.num_bits - int(self.signed)))
+        max_int = (2 ** (self.num_bits - int(self.signed))) - 1
+        self.min = delta * min_int
+        self.max = delta * max_int
+
+    def initialize_quantization(self,
+                                tensor_shape: TensorShape,
+                                name: str,
+                                layer: KerasTrainableQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+        ptq_threshold_tensor = layer.add_weight(
+            name + THRESHOLD_TENSOR,
+            shape=(),
+            initializer=tf.keras.initializers.Constant(1.0),
+            trainable=False)
+        ptq_threshold_tensor.assign(self.np_threshold_values)
+
+        fq_min = layer.add_weight(
+            name + FQ_MIN,
+            shape=(),
+            initializer=tf.keras.initializers.Constant(-1.0),
+            trainable=False)
+        fq_min.assign(self.min)
+
+        fq_max = layer.add_weight(
+            name + FQ_MAX,
+            shape=(),
+            initializer=tf.keras.initializers.Constant(1.0),
+            trainable=False)
+        fq_max.assign(self.max)
+
+        # save the quantizer added parameters for later calculations
+        self.add_quantizer_variable(THRESHOLD_TENSOR, ptq_threshold_tensor, VariableGroup.QPARAMS)
+        self.add_quantizer_variable(FQ_MIN, fq_min, VariableGroup.QPARAMS)
+        self.add_quantizer_variable(FQ_MAX, fq_max, VariableGroup.QPARAMS)
+
+    def __call__(self,
+                 inputs: tf.Tensor,
+                 training: bool):
+        """
+        Quantize a tensor.
+        Args:
+            inputs: Input tensor to quantize.
+            training: Whether the graph is in training mode.
+
+        Returns:
+            The quantized tensor.
+        """
+
+        _min = self.get_quantizer_variable(FQ_MIN)
+        _max = self.get_quantizer_variable(FQ_MAX)
+        q_tensor = tf.quantization.fake_quant_with_min_max_vars(inputs, _min, _max,
+                                                                num_bits=self.num_bits)
+
+        return q_tensor
+
+    def convert2inferable(self) -> Union[ActivationPOTInferableQuantizer, ActivationSymmetricInferableQuantizer]:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            BaseKerasInferableQuantizer object.
+        """
+
+        if self.power_of_two:
+            pot_threshold = 2 ** np.ceil(np.log2(self.get_quantizer_variable(THRESHOLD_TENSOR)))
+            return ActivationPOTInferableQuantizer(num_bits=self.num_bits,
+                                                   # In activation quantization is per-tensor only - thus we pass
+                                                   # the threshold as a list with a len of 1
+                                                   threshold=[pot_threshold],
+                                                   signed=self.signed)
+        else:
+            return ActivationSymmetricInferableQuantizer(num_bits=self.num_bits,
+                                                         # In activation quantization is per-tensor only - thus we
+                                                         # pass the threshold as a list with a len of 1
+                                                         threshold=[
+                                                             self.get_quantizer_variable(THRESHOLD_TENSOR).numpy()],
+                                                         signed=self.signed)