mct-nightly 1.7.1.31122022.post351__py3-none-any.whl → 1.8.0.1042023.post423__py3-none-any.whl

model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/symmetric_ste.py

@@ -0,0 +1,204 @@
+# 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 typing import Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.qat.common import THRESHOLD_TENSOR
+from model_compression_toolkit import quantizers_infrastructure as qi, TrainingMethod
+from model_compression_toolkit.qat.pytorch.quantizer.base_pytorch_qat_quantizer import BasePytorchQATTrainableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer
+from model_compression_toolkit.core.common import constants as C
+from model_compression_toolkit.core.pytorch.utils import to_torch_tensor
+from model_compression_toolkit.qat.pytorch.quantizer.quantizer_utils import ste_round, ste_clip, symmetric_quantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
+    WeightsPOTInferableQuantizer, WeightsSymmetricInferableQuantizer, ActivationPOTInferableQuantizer, \
+    ActivationSymmetricInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.common.trainable_quantizer_config import \
+    TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
+
+
+@mark_quantizer(quantization_target=qi.QuantizationTarget.Weights,
+                quantization_method=[QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC],
+                quantizer_type=TrainingMethod.STE)
+class STEWeightQATQuantizer(BasePytorchQATTrainableQuantizer):
+    """
+    Trainable constrained quantizer to quantize a layer weights.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerWeightsConfig):
+        """
+        Initialize a TrainableWeightQuantizer 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.weights_quantization_method == QuantizationMethod.POWER_OF_TWO
+        self.threshold_values = quantization_config.weights_quantization_params[C.THRESHOLD]
+        self.threshold_shape = np.asarray(self.threshold_values).shape
+        self.np_threshold_values = self.threshold_values
+
+        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 = self.quantization_config.weights_n_bits
+        n_pos_bits = self.num_bits - int(C.WEIGHTS_SIGNED)
+        delta = self.np_threshold_values / np.power(2.0, n_pos_bits)
+        self.delta_tensor = to_torch_tensor(delta)
+        self.min_int = -int(C.WEIGHTS_SIGNED) * (2 ** n_pos_bits)
+        self.max_int = (2 ** n_pos_bits) - 1
+        self.min = delta * self.min_int
+        self.max = delta * self.max_int
+
+
+    def initialize_quantization(self,
+                                tensor_shape: torch.Size,
+                                name: str,
+                                layer: qi.PytorchQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+
+        # Add threshold variables to layer.
+        layer.register_parameter(name + "_" + THRESHOLD_TENSOR, nn.Parameter(to_torch_tensor(self.np_threshold_values),
+                                                                             requires_grad=False))
+
+        # save the quantizer added parameters for later calculations
+        self.add_quantizer_variable(THRESHOLD_TENSOR, layer.get_parameter(name + "_" + THRESHOLD_TENSOR), VariableGroup.QPARAMS)
+
+
+    def __call__(self,
+                 inputs: nn.Parameter,
+                 training: bool) -> nn.Parameter:
+        """
+        Quantize a tensor
+        Args:
+            inputs: Input tensor to quantize.
+            training: whether in training mode or not
+        Returns:
+            quantized tensor
+        """
+        w0 = ste_round(inputs / self.delta_tensor)
+        w1 = ste_clip(w0, min_val=self.min_int, max_val=self.max_int)
+        w_q = self.delta_tensor * w1
+        return w_q
+
+    def convert2inferable(self) -> Union[WeightsPOTInferableQuantizer, WeightsSymmetricInferableQuantizer]:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            A pytorch inferable quanizer object.
+        """
+        np_threshold = self.get_quantizer_variable(THRESHOLD_TENSOR).cpu().detach().numpy().flatten()
+        if self.power_of_two:
+            pot_threshold = 2 ** np.ceil(np.log2(np_threshold))
+            return WeightsPOTInferableQuantizer(num_bits=self.num_bits,
+                                                threshold=pot_threshold,
+                                                per_channel=self.quantization_config.weights_per_channel_threshold,
+                                                channel_axis=self.quantization_config.weights_channels_axis)
+        else:
+            return WeightsSymmetricInferableQuantizer(num_bits=self.num_bits,
+                                                      threshold=np_threshold,
+                                                      per_channel=self.quantization_config.weights_per_channel_threshold,
+                                                      channel_axis=self.quantization_config.weights_channels_axis)
+
+
+
+@mark_quantizer(quantization_target=qi.QuantizationTarget.Activation,
+                quantization_method=[QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC],
+                quantizer_type=TrainingMethod.STE)
+class STEActivationQATQuantizer(BasePytorchQATTrainableQuantizer):
+    """
+    Trainable constrained quantizer to quantize a layer activations.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerActivationConfig):
+        """
+        Initialize a STEActivationQATQuantizer object with parameters to use
+        for symmetric or power of two 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.sign = quantization_config.activation_quantization_params['is_signed']
+        np_threshold_values = quantization_config.activation_quantization_params[C.THRESHOLD]
+        self.threshold_tensor = torch.Tensor([np_threshold_values])
+        self.num_bits = quantization_config.activation_n_bits
+
+    def initialize_quantization(self,
+                                tensor_shape: torch.Size,
+                                name: str,
+                                layer: qi.PytorchQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+        layer.register_parameter(name, nn.Parameter(to_torch_tensor(self.threshold_tensor), requires_grad=True))
+
+        # save the quantizer added parameters for later calculations
+        self.add_quantizer_variable(THRESHOLD_TENSOR, layer.get_parameter(name), VariableGroup.QPARAMS)
+
+    def __call__(self,
+                 inputs: torch.Tensor,
+                 training: bool = True) -> torch.Tensor:
+        """
+        Quantize a tensor.
+        Args:
+            inputs: Input tensor to quantize.
+            training: Whether the graph is in training mode.
+
+        Returns:
+            The quantized tensor.
+        """
+
+        _t = self.get_quantizer_variable(THRESHOLD_TENSOR)
+        q_tensor = symmetric_quantizer(inputs, _t, self.num_bits, sign=self.sign)
+        return q_tensor
+
+    def convert2inferable(self) -> Union[ActivationPOTInferableQuantizer, ActivationSymmetricInferableQuantizer]:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            A pytorch inferable quanizer object.
+        """
+        np_threshold = self.get_quantizer_variable(THRESHOLD_TENSOR).cpu().detach().numpy()
+        if self.power_of_two:
+            pot_threshold = np.power(2.0, np.ceil(np.log2(np_threshold)))
+            return ActivationPOTInferableQuantizer(num_bits=self.num_bits,
+                                                   threshold=pot_threshold,
+                                                   signed=self.sign)
+        else:
+            return ActivationSymmetricInferableQuantizer(num_bits=self.num_bits,
+                                                         threshold=np_threshold,
+                                                         signed=self.sign)

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

@@ -0,0 +1,190 @@
+# 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.
+# ==============================================================================
+import numpy as np
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from model_compression_toolkit.core.common.constants import RANGE_MAX, RANGE_MIN
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.qat.common.constants import FQ_MIN, FQ_MAX
+from model_compression_toolkit.core.common import constants as C
+from model_compression_toolkit import quantizers_infrastructure as qi, TrainingMethod
+from model_compression_toolkit.qat.pytorch.quantizer.base_pytorch_qat_quantizer import BasePytorchQATTrainableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer
+from model_compression_toolkit.core.pytorch.utils import to_torch_tensor
+from model_compression_toolkit.qat.pytorch.quantizer.quantizer_utils import uniform_quantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
+    WeightsUniformInferableQuantizer, ActivationUniformInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.common.trainable_quantizer_config import \
+    TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
+
+
+@mark_quantizer(quantization_target=qi.QuantizationTarget.Weights,
+                quantization_method=[QuantizationMethod.UNIFORM],
+                quantizer_type=TrainingMethod.STE)
+class STEUniformWeightQATQuantizer(BasePytorchQATTrainableQuantizer):
+    """
+    Trainable constrained quantizer to quantize a layer inputs.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerWeightsConfig):
+        """
+        Initialize a TrainableWeightQuantizer object with parameters to use
+        for the quantization.
+
+        Args:
+            quantization_config: trainable quantizer config class
+        """
+        super().__init__(quantization_config)
+        self.num_bits = self.quantization_config.weights_n_bits
+        self.min_int = 0
+        self.max_int = 2 ** self.num_bits - 1
+        self.max_values = quantization_config.weights_quantization_params[RANGE_MAX]
+        self.min_values = quantization_config.weights_quantization_params[RANGE_MIN]
+        self.min_max_shape = np.asarray(self.max_values).shape
+        self.max = np.reshape(self.max_values,
+                              [-1]) if self.quantization_config.weights_per_channel_threshold else float(
+            self.max_values)
+        self.min = np.reshape(self.min_values,
+                              [-1]) if self.quantization_config.weights_per_channel_threshold else float(
+            self.min_values)
+
+
+    def initialize_quantization(self,
+                                tensor_shape: torch.Size,
+                                name: str,
+                                layer: qi.PytorchQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+
+        # Add min and max variables to layer.
+        layer.register_parameter(name+"_"+FQ_MIN, nn.Parameter(to_torch_tensor(self.min_values), requires_grad=False))
+        layer.register_parameter(name+"_"+FQ_MAX, nn.Parameter(to_torch_tensor(self.max_values), requires_grad=False))
+
+        # Save the quantizer parameters for later calculations
+        self.add_quantizer_variable(FQ_MIN, layer.get_parameter(name+"_"+FQ_MIN), VariableGroup.QPARAMS)
+        self.add_quantizer_variable(FQ_MAX, layer.get_parameter(name+"_"+FQ_MAX), VariableGroup.QPARAMS)
+
+
+    def __call__(self,
+                 inputs: nn.Parameter,
+                 training: bool) -> Tensor:
+        """
+        Quantize a tensor
+        Args:
+            inputs: Input tensor to quantize.
+            training: whether in training mode or not
+        Returns:
+            quantized tensor
+        """
+        return uniform_quantizer(inputs, self.get_quantizer_variable(FQ_MIN), self.get_quantizer_variable(FQ_MAX), self.num_bits)
+
+    def convert2inferable(self) -> WeightsUniformInferableQuantizer:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            A pytorch inferable quanizer object.
+        """
+        _min = self.get_quantizer_variable(FQ_MIN).cpu().detach().numpy()
+        _max = self.get_quantizer_variable(FQ_MAX).cpu().detach().numpy()
+
+        return WeightsUniformInferableQuantizer(num_bits=self.num_bits,
+                                                min_range=_min, max_range=_max,
+                                                per_channel=self.quantization_config.weights_per_channel_threshold,
+                                                channel_axis=self.quantization_config.weights_channels_axis)
+
+
+@mark_quantizer(quantization_target=qi.QuantizationTarget.Activation,
+                quantization_method=[QuantizationMethod.UNIFORM],
+                quantizer_type=TrainingMethod.STE)
+class STEUniformActivationQATQuantizer(BasePytorchQATTrainableQuantizer):
+    """
+    Trainable constrained quantizer to quantize a layer activations.
+    """
+
+    def __init__(self, quantization_config: TrainableQuantizerActivationConfig):
+        """
+        Initialize a STEUniformActivationQATQuantizer object with parameters to use
+        for uniform quantization.
+
+        Args:
+            quantization_config: trainable quantizer config class
+        """
+        super().__init__(quantization_config)
+
+        np_min_range = quantization_config.activation_quantization_params[C.RANGE_MIN]
+        np_max_range = quantization_config.activation_quantization_params[C.RANGE_MAX]
+        self.min_range_tensor = torch.Tensor([np_min_range])
+        self.max_range_tensor = torch.Tensor([np_max_range])
+        self.num_bits = quantization_config.activation_n_bits
+
+    def initialize_quantization(self,
+                                tensor_shape: torch.Size,
+                                name: str,
+                                layer: qi.PytorchQuantizationWrapper):
+        """
+        Add quantizer parameters to the quantizer parameters dictionary
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+        """
+        layer.register_parameter(name+"_"+FQ_MIN, nn.Parameter(to_torch_tensor(self.min_range_tensor), requires_grad=True))
+        layer.register_parameter(name+"_"+FQ_MAX, nn.Parameter(to_torch_tensor(self.max_range_tensor), requires_grad=True))
+
+        # Save the quantizer parameters for later calculations
+        self.add_quantizer_variable(FQ_MIN, layer.get_parameter(name+"_"+FQ_MIN), VariableGroup.QPARAMS)
+        self.add_quantizer_variable(FQ_MAX, layer.get_parameter(name+"_"+FQ_MAX), VariableGroup.QPARAMS)
+
+    def __call__(self,
+                 inputs: torch.Tensor,
+                 training: bool = True) -> torch.Tensor:
+        """
+        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 = uniform_quantizer(inputs, _min, _max, self.num_bits)
+        return q_tensor
+
+    def convert2inferable(self) -> ActivationUniformInferableQuantizer:
+        """
+        Convert quantizer to inferable quantizer.
+
+        Returns:
+            A pytorch inferable quanizer object.
+        """
+        _min = self.get_quantizer_variable(FQ_MIN).cpu().detach().numpy()
+        _max = self.get_quantizer_variable(FQ_MAX).cpu().detach().numpy()
+
+        return ActivationUniformInferableQuantizer(num_bits=self.num_bits,
+                                                   min_range=_min, max_range=_max)

model_compression_toolkit/quantizers_infrastructure/__init__.py

@@ -0,0 +1,23 @@
+# 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.common.base_inferable_quantizer import QuantizationTarget, BaseInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.common.trainable_quantizer_config import \
+    TrainableQuantizerWeightsConfig, TrainableQuantizerActivationConfig
+from model_compression_toolkit.quantizers_infrastructure.trainable_infrastructure.keras.base_keras_quantizer import BaseKerasTrainableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.load_model import keras_load_quantized_model
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantize_wrapper import KerasQuantizationWrapper
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantize_wrapper import PytorchQuantizationWrapper
+

model_compression_toolkit/{gptq/keras/quantizer/configs → quantizers_infrastructure/inferable_infrastructure}/__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/{gptq/keras/quantizer/gumbel_rounding → quantizers_infrastructure/inferable_infrastructure/common}/__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/common/base_inferable_quantizer.py

@@ -0,0 +1,87 @@
+# 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 enum import Enum
+from typing import Any, Dict, List
+
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+
+
+class QuantizationTarget(Enum):
+    Activation = "Activation"
+    Weights = "Weights"
+
+
+def mark_quantizer(quantization_target: QuantizationTarget = None,
+                   quantization_method: List[QuantizationMethod] = None,
+                   quantizer_type: Any = None):
+    """
+    A function to be used as decoration for all inferable quantizers (which inherit from BaseInferableQuantizer).
+    By decorating a class with this decoration, we can define required static properties of the quantizer.
+
+    Args:
+        quantization_target: QuantizationTarget value which indicates what is the target for quantization to
+            use the quantizer for.
+        quantization_method: A list of QuantizationMethod values to indicate all type of quantization methods that the
+            quantizer supports.
+        quantizer_type: The type of the quantizer (quantization technique).
+            This can differ, depending on the purpose the quantizer is for.
+
+    Returns: A function that decorates a class object.
+
+    """
+    def mark(quantizer_class_object: BaseInferableQuantizer):
+        """
+        Initializes the parameters for the decorator.
+
+        Args:
+            quantizer_class_object: The class to be decorated.
+
+        Returns: A decorated class.
+
+        """
+        quantizer_class_object.quantization_target = quantization_target
+        quantizer_class_object.quantization_method = quantization_method
+        quantizer_class_object.quantizer_type = quantizer_type
+
+        return quantizer_class_object
+
+    return mark
+
+
+class BaseInferableQuantizer:
+
+    def __init__(self):
+        """
+        This class is a base quantizer which defines an abstract
+        function which any quantizer needs to implement.
+        """
+        pass
+
+    def initialize_quantization(self,
+                                tensor_shape: Any,
+                                name: str,
+                                layer: Any) -> Dict[Any, Any]:
+        """
+        Return a dictionary of quantizer parameters and their names.
+
+        Args:
+            tensor_shape: tensor shape of the quantized tensor.
+            name: Tensor name.
+            layer: Layer to quantize.
+
+        Returns:
+            Dictionary of parameters names to the variables.
+        """
+        return {}

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/common/constants.py

@@ -0,0 +1,41 @@
+# 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.
+# ==============================================================================
+
+IS_WEIGHTS = "is_weights"
+IS_ACTIVATIONS = "is_activations"
+ACTIVATION_QUANTIZERS = "activation_quantizers"
+WEIGHTS_QUANTIZERS = "weights_quantizer"
+WEIGHTS_QUANTIZATION_METHOD = 'weights_quantization_method'
+WEIGHTS_N_BITS = 'weights_n_bits'
+WEIGHTS_QUANTIZATION_PARAMS = 'weights_quantization_params'
+ENABLE_WEIGHTS_QUANTIZATION = 'enable_weights_quantization'
+WEIGHTS_CHANNELS_AXIS = 'weights_channels_axis'
+WEIGHTS_PER_CHANNEL_THRESHOLD = 'weights_per_channel_threshold'
+MIN_THRESHOLD = 'min_threshold'
+ACTIVATION_QUANTIZATION_METHOD = 'activation_quantization_method'
+ACTIVATION_N_BITS = 'activation_n_bits'
+ACTIVATION_QUANTIZATION_PARAMS = 'activation_quantization_params'
+ENABLE_ACTIVATION_QUANTIZATION = 'enable_activation_quantization'
+LAYER = "layer"
+STEPS = "optimizer_step"
+TRAINING = "training"
+
+
+QUANTIZATION_TARGET = 'quantization_target'
+QUANTIZATION_METHOD = 'quantization_method'
+QUANTIZER_TYPE = 'quantizer_type'
+
+EPS = 1e-8
+MULTIPLIER_N_BITS = 8

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/common/get_all_subclasses.py

@@ -0,0 +1,31 @@
+# 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 Set
+
+
+def get_all_subclasses(cls: type) -> Set[type]:
+    """
+    This function returns a list of all subclasses of the given class,
+    including all subclasses of those subclasses, and so on.
+    Recursively get all subclasses of the subclass and add them to the list of all subclasses.
+
+    Args:
+        cls: A class object.
+
+    Returns: All classes that inherit from cls.
+
+    """
+
+    return set(cls.__subclasses__()).union([s for c in cls.__subclasses__() for s in get_all_subclasses(c)])

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/common/get_quantizers.py

@@ -0,0 +1,53 @@
+# 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.core.common import Logger
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure import QuantizationTarget
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import QUANTIZATION_TARGET, \
+    QUANTIZATION_METHOD
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.get_all_subclasses import get_all_subclasses
+
+
+def get_inferable_quantizer_class(quant_target: QuantizationTarget,
+                                  quant_method: QuantizationMethod,
+                                  quantizer_base_class: type) -> type:
+    """
+    Searches for an inferable quantizer class that matches the requested QuantizationTarget and QuantizationMethod.
+    Exactly one class should be found.
+
+    Args:
+        quant_target: QuantizationTarget value (Weights or Activation) which indicates what is the target for
+            quantization to use the quantizer for.
+        quant_method: A list of QuantizationMethod values to indicate all type of quantization methods that the
+            quantizer supports.
+        quantizer_base_class: A type of quantizer that the requested quantizer should inherit from.
+
+    Returns: A class of a quantizer that inherits from BaseKerasInferableQuantizer.
+
+    """
+    qat_quantizer_classes = get_all_subclasses(quantizer_base_class)
+    filtered_quantizers = list(filter(lambda q_class: getattr(q_class, QUANTIZATION_TARGET) == quant_target and
+                                                      getattr(q_class, QUANTIZATION_METHOD) is not None and
+                                                      quant_method in getattr(q_class, QUANTIZATION_METHOD),
+                                      qat_quantizer_classes))
+
+    if len(filtered_quantizers) != 1:
+        Logger.error(f"Found {len(filtered_quantizers)} quantizer for target {quant_target.value} "
+                     f"that matches the requested quantization method {quant_method.name} "
+                     f"but there should be exactly one."
+                     f"The possible quantizers that were found are {filtered_quantizers}.")
+
+    return filtered_quantizers[0]