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/common/quant_utils.py

@@ -0,0 +1,49 @@
+# 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 typing import Tuple
+
+
+def adjust_range_to_include_zero(range_min: np.ndarray,
+                                 range_max: np.ndarray,
+                                 n_bits: int) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Adjusting the quantization range to include representation of 0.0 in the quantization grid.
+    For per_channel quantization range_min\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
+    """
+    scale = (range_max - range_min) / (2 ** n_bits - 1)
+    min_range_adj = scale * np.round(range_min / scale)
+    max_range_adj = range_max - range_min + min_range_adj
+
+    min_positive = range_min > 0
+    max_negative = range_max < 0
+    mid_range = np.logical_and(np.logical_not(min_positive), np.logical_not(max_negative))
+
+    min_range_adj = min_range_adj * mid_range + max_negative * range_min
+    max_range_adj = max_range_adj * mid_range + min_positive * range_max
+
+    # Make sure min_range_adj < 0 and max_range_adj > 0 to avoid small numeric error
+    min_range_adj = np.minimum(min_range_adj, 0)
+    max_range_adj = np.maximum(max_range_adj, 0)
+
+    return min_range_adj, max_range_adj

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/__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/{qunatizers_infrastructure → quantizers_infrastructure/inferable_infrastructure}/keras/load_model.py

@@ -14,15 +14,17 @@
 # ==============================================================================
 from model_compression_toolkit.core.common import Logger
 from model_compression_toolkit.core.common.constants import FOUND_TF
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.get_all_subclasses import get_all_subclasses
 
 if FOUND_TF:
     import tensorflow as tf
-    from model_compression_toolkit import qunatizers_infrastructure as qi
-    from model_compression_toolkit.qunatizers_infrastructure.keras.base_keras_quantizer import BaseKerasQuantizer
-
+    from model_compression_toolkit import quantizers_infrastructure as qi
+    from model_compression_toolkit.quantizers_infrastructure import BaseKerasTrainableQuantizer
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.base_keras_inferable_quantizer \
+        import \
+        BaseKerasInferableQuantizer
     keras = tf.keras
 
-
     def keras_load_quantized_model(filepath, custom_objects=None, compile=True, options=None):
         """
         This function wraps the keras load model and MCT quantization custom class to it.
@@ -36,9 +38,25 @@ if FOUND_TF:
         Returns: A keras Model
 
         """
-        qi_custom_objects = {subclass.__name__: subclass for subclass in BaseKerasQuantizer.__subclasses__()}
-        qi_custom_objects.update({qi.KerasQuantizationWrapper.__name__: qi.KerasQuantizationWrapper,
-                                  qi.KerasNodeQuantizationDispatcher.__name__: qi.KerasNodeQuantizationDispatcher})
+        qi_inferable_custom_objects = {subclass.__name__: subclass for subclass in
+                                       get_all_subclasses(BaseKerasInferableQuantizer)}
+        all_inferable_names = list(qi_inferable_custom_objects.keys())
+        if len(set(all_inferable_names)) < len(all_inferable_names):
+            Logger.error(f"Found multiple quantizers with the same name that inherit from BaseKerasInferableQuantizer"
+                         f"while trying to load a model.")
+
+        qi_trainable_custom_objects = {subclass.__name__: subclass for subclass in
+                                       get_all_subclasses(BaseKerasTrainableQuantizer)}
+        all_trainable_names = list(qi_trainable_custom_objects.keys())
+        if len(set(all_trainable_names)) < len(all_trainable_names):
+            Logger.error(f"Found multiple quantizers with the same name that inherit from BaseKerasTrainableQuantizer"
+                         f"while trying to load a model.")
+
+        # Merge dictionaries into one dict
+        qi_custom_objects = {**qi_inferable_custom_objects, **qi_trainable_custom_objects}
+
+        # Add non-quantizers custom objects
+        qi_custom_objects.update({qi.KerasQuantizationWrapper.__name__: qi.KerasQuantizationWrapper})
         if custom_objects is not None:
             qi_custom_objects.update(custom_objects)
         return tf.keras.models.load_model(filepath,
@@ -60,4 +78,4 @@ else:
         """
         Logger.critical('Installing tensorflow and tensorflow_model_optimization is mandatory '
                         'when using keras_load_quantized_model. '
-                        'Could not find Tensorflow package.')
+                        'Could not find Tensorflow package.')  # pragma: no cover

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantize_wrapper.py

@@ -0,0 +1,345 @@
+# 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 Dict, List, Any, Tuple
+from model_compression_toolkit import quantizers_infrastructure as qi
+from model_compression_toolkit.core.common.constants import FOUND_TF
+from model_compression_toolkit.core.common.logger import Logger
+from model_compression_toolkit.quantizers_infrastructure import BaseInferableQuantizer
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import WEIGHTS_QUANTIZERS, ACTIVATION_QUANTIZERS, LAYER, STEPS, TRAINING
+
+if FOUND_TF:
+    import tensorflow as tf
+    from tensorflow.python.util import tf_inspect
+    from tensorflow_model_optimization.python.core.keras import utils
+
+    keras = tf.keras
+
+    def _make_quantizer_fn(quantizer, x, training):
+        """Use currying to return True/False specialized fns to the cond."""
+
+        def quantizer_fn():
+            return quantizer(x, training)
+
+        return quantizer_fn
+
+
+    def _weight_name(name: str) -> str:
+        """Extracts the weight name from the full TensorFlow variable name.
+
+        For example, returns 'kernel' for 'dense_2/kernel:0'.
+
+        Args:
+          name: TensorFlow variable name.
+
+        Returns:
+          Extracted weight name.
+        """
+        return name.split(':')[0].split('/')[-1]
+
+
+    class KerasQuantizationWrapper(tf.keras.layers.Wrapper):
+        def __init__(self,
+                     layer,
+                     weights_quantizers: Dict[str, BaseInferableQuantizer] = None,
+                     activation_quantizers: List[BaseInferableQuantizer] = None,
+                     **kwargs):
+            """
+            Keras Quantization Wrapper takes a keras layer and quantizers and infer a quantized layer.
+
+            Args:
+                layer: A keras layer.
+                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(KerasQuantizationWrapper, self).__init__(layer, **kwargs)
+            self._track_trackable(layer, name='layer')
+            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()
+
+        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 get_config(self):
+            """
+            Returns: Configuration of KerasQuantizationWrapper.
+
+            """
+            base_config = super(KerasQuantizationWrapper, self).get_config()
+            config = {
+                ACTIVATION_QUANTIZERS: [keras.utils.serialize_keras_object(act) for act in self.activation_quantizers],
+                WEIGHTS_QUANTIZERS: {k: keras.utils.serialize_keras_object(v) for k, v in self.weights_quantizers.items()}}
+            return dict(list(base_config.items()) + list(config.items()))
+
+        def _set_weights_vars(self, is_training: bool = True):
+            """
+            This function sets weights quantizers vars to the layer
+
+            Args:
+                is_training: Flag to indicate whether training or not
+
+            Returns: None
+            """
+            self._weights_vars = []
+            for name, quantizer in self.weights_quantizers.items():
+                weight = getattr(self.layer, name)
+                quantizer.initialize_quantization(weight.shape, _weight_name(weight.name) if is_training else None,
+                                                  self)
+                self._weights_vars.append((name, weight, quantizer))
+                self._trainable_weights.append(weight) # Must when inherit from tf.keras.layers.Wrapper in tf2.10 and below
+
+        def _set_activations_vars(self):
+            """
+            This function sets activations quantizers vars to the layer
+
+            Returns: None
+            """
+            self._activation_vars = []
+            for i, quantizer in enumerate(self.activation_quantizers):
+                quantizer.initialize_quantization(None, self.layer.name + f'/out{i}', self)
+                self._activation_vars.append(quantizer)
+
+        @classmethod
+        def from_config(cls, config):
+            """
+
+            Args:
+                config(dict): dictionary  of  KerasQuantizationWrapper Configuration
+
+            Returns: A KerasQuantizationWrapper
+
+            """
+            config = config.copy()
+            activation_quantizers = [keras.utils.deserialize_keras_object(act,
+                                                                          module_objects=globals(),
+                                                                          custom_objects=None) for act in
+                                     config.pop(ACTIVATION_QUANTIZERS)]
+            weights_quantizers = {k: keras.utils.deserialize_keras_object(v,
+                                                                         module_objects=globals(),
+                                                                         custom_objects=None) for k, v in
+                                 config.pop(WEIGHTS_QUANTIZERS).items()}
+            layer = tf.keras.layers.deserialize(config.pop(LAYER))
+            return cls(layer=layer, weights_quantizers=weights_quantizers, activation_quantizers=activation_quantizers, **config)
+
+        def build(self, input_shape):
+            """
+            KerasQuantization Wrapper build function.
+            Args:
+                input_shape: the layer input shape
+
+            Returns: None
+
+            """
+            super(KerasQuantizationWrapper, self).build(input_shape)
+
+            self.optimizer_step = self.add_weight(
+                STEPS,
+                initializer=tf.keras.initializers.Constant(-1),
+                dtype=tf.dtypes.int32,
+                trainable=False)
+
+            self._set_weights_vars()
+            self._set_activations_vars()
+
+        def set_quantize_weights(self, quantized_weights: dict):
+            """
+            This function update 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)
+                current_weight = getattr(self.layer, weight_attr)
+                if current_weight.shape != weight.shape:
+                    Logger.error(
+                        f"Existing layer weight shape {current_weight.shape} is incompatible with provided weight "
+                        f"shape {weight.shape}")  # pragma: no cover
+
+                setattr(self.layer, weight_attr, weight)
+
+        def call(self, inputs, training=None, **kwargs):
+            """
+            KerasQuantizationWrapper call functions
+            Args:
+                inputs: Input tensors to specified layer
+                training: a boolean stating if layer is in training mode.
+                **kwargs:
+
+            Returns: tensors that simulate a quantized layer.
+
+            """
+            if training is None:
+                training = tf.keras.backend.learning_phase()
+
+            # Quantize all weights, and replace them in the underlying layer.
+            quantized_weights = {}
+            for name, unquantized_weight, quantizer in self._weights_vars:
+
+                weights_quantizer_args_spec = tf_inspect.getfullargspec(quantizer.__call__).args
+                if TRAINING in weights_quantizer_args_spec:
+                    quantized_weight = utils.smart_cond(
+                        training,
+                        _make_quantizer_fn(quantizer, unquantized_weight, True),
+                        _make_quantizer_fn(quantizer, unquantized_weight, False))
+                    quantized_weights.update({name: quantized_weight})
+                else:
+                    # Keras weights inferable quantizer
+                    quantized_weight = quantizer(unquantized_weight)
+                    quantized_weights.update({name: quantized_weight})
+
+            self.set_quantize_weights(quantized_weights)
+
+            args_spec = tf_inspect.getfullargspec(self.layer.call).args
+            if TRAINING in args_spec:
+                outputs = self.layer.call(inputs, training=training, **kwargs)
+            else:
+                outputs = self.layer.call(inputs, **kwargs)
+
+            # Quantize all activations if quantizers exist.
+            if self.is_activation_quantization:
+                num_outputs = len(outputs) if isinstance(outputs, (list, tuple)) else 1
+                if self.num_activation_quantizers != num_outputs:
+                    Logger.error('Quantization wrapper output quantization error: '
+                                 f'number of outputs and quantizers mismatch ({num_outputs}!='
+                                 f'{self.num_activation_quantizers}')
+                if num_outputs == 1:
+                    outputs = [outputs]
+
+                _outputs = []
+                for _output, act_quant in zip(outputs, self.activation_quantizers):
+                    activation_quantizer_args_spec = tf_inspect.getfullargspec(act_quant.__call__).args
+                    if TRAINING in activation_quantizer_args_spec:
+                        _outputs.append(utils.smart_cond(
+                            training,
+                            _make_quantizer_fn(act_quant, _output, True),
+                            _make_quantizer_fn(act_quant, _output, False)))
+                    else:
+                        # Keras activation inferable quantizer.
+                        _outputs.append(act_quant(_output))
+                outputs = _outputs[0] if num_outputs == 1 else _outputs
+
+            return outputs
+
+        def convert_to_inferable_quantizers(self):
+            """
+            Convert layer's quantizers to inferable.
+
+            Returns:
+                None
+            """
+            # Activations quantizers
+            inferable_activation_quantizers = []
+            if self.is_activation_quantization:
+                for quantizer in self.activation_quantizers:
+                    if isinstance(quantizer, qi.BaseKerasTrainableQuantizer):
+                        inferable_activation_quantizers.append(quantizer.convert2inferable())
+                self.activation_quantizers = inferable_activation_quantizers
+                self._set_activations_vars()
+
+            # Weight quantizers
+            inferable_weight_quantizers = {}
+            if self.is_weights_quantization:
+                for name, quantizer in self.weights_quantizers.items():
+                    if isinstance(quantizer, qi.BaseKerasTrainableQuantizer):
+                        inferable_weight_quantizers.update({name: quantizer.convert2inferable()})
+                self.weights_quantizers = inferable_weight_quantizers
+                self._set_weights_vars(False)
+
+        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 get_quantized_weights(self) -> Dict[str, tf.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 KerasQuantizationWrapper(object):
+        def __init__(self,
+                     layer,
+                     weights_quantizers: Dict[str, BaseInferableQuantizer] = None,
+                     activation_quantizers: List[BaseInferableQuantizer] = None):
+            """
+            Keras Quantization Wrapper takes a keras layer and quantizers and infer a quantized layer.
+
+            Args:
+                layer: A keras layer.
+                weights_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 tensorflow and tensorflow_model_optimization is mandatory '
+                            'when using KerasQuantizationWrapper. '
+                            'Could not find Tensorflow package.')  # pragma: no cover

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizer_utils.py

@@ -0,0 +1,85 @@
+# 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
+import tensorflow as tf
+
+
+def lut_quantizer(tensor_data: tf.Tensor,
+                  cluster_centers: np.ndarray,
+                  signed: bool,
+                  threshold: np.ndarray,
+                  multiplier_n_bits: int,
+                  eps: float) -> tf.Tensor:
+    """
+    Quantize a tensor using a non-uniform quantization based on the pre-defined clusters.
+    1. Scales tensor_data with the threshold into multiplier_n_bits 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 = tf.expand_dims(tensor, -1)
+
+    expanded_cluster_centers = cluster_centers.reshape([*[1 for _ in range(len(tensor.shape) - 1)], -1])
+    cluster_assignments = tf.argmin(tf.abs(tensor - expanded_cluster_centers), axis=-1)
+    centers = tf.gather(cluster_centers.flatten(), cluster_assignments)
+
+    quant_tensor = (centers / (2 ** (multiplier_n_bits - int(signed)))) * threshold
+
+    return quant_tensor
+
+
+def int_quantization_with_threshold(data: tf.Tensor,
+                                    n_bits: int,
+                                    signed: bool,
+                                    threshold: np.ndarray,
+                                    eps: float) -> tf.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 tf.clip_by_value((data / (threshold + eps)) * (2 ** (n_bits - int(signed))),
+                            clip_value_max=clip_max, clip_value_min=clip_min)

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

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

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/activation_inferable_quantizers/__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.
+# ==============================================================================