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

model_compression_toolkit/exporter/model_exporter/tflite/int8_tflite_exporter.py

@@ -0,0 +1,180 @@
+# 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 copy
+from typing import Callable
+
+import keras.models
+import numpy as np
+import tensorflow as tf
+from keras import Sequential
+from keras.layers import Dense, Conv2D, Reshape
+from keras.models import clone_model
+
+from model_compression_toolkit import quantizers_infrastructure as qi
+from model_compression_toolkit.core.common import Logger
+from model_compression_toolkit.exporter.model_exporter.keras.fakely_quant_keras_exporter import FakelyQuantKerasExporter
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers import \
+    constants as keras_inferable_constants
+
+BIAS_INITIALIZER = 'bias_initializer'
+BIAS_REGULARIZER = 'bias_regularizer'
+BIAS_CONSTRAINT = 'bias_constraint'
+ACTIVITY_REGULARIZER = 'activity_regularizer'
+KERNEL_INITIALIZER = 'kernel_initializer'
+KERNEL_REGULARIZER = 'kernel_regularizer'
+KERNEL_CONSTRAINT = 'kernel_constraint'
+KERNEL_SIZE = 'kernel_size'
+PADDING = 'padding'
+STRIDES = 'strides'
+LAYER_NAME = 'name'
+TRAINABLE = 'trainable'
+ACTIVATION = 'activation'
+USE_BIAS = 'use_bias'
+FILTERS = 'filters'
+UNITS = 'units'
+PAD_VALID = 'valid'
+KERNEL = 'kernel'
+
+CONV_KERNEL_CHANNEL_AXIS = 3
+CONV_INPUT_CHANNELS_DIM = 4
+
+class INT8TFLiteExporter(FakelyQuantKerasExporter):
+    """
+    Exporter for INT8 TFLite models.
+    The exporter expects to receive an exportable model (where each layer's full quantization parameters
+    can be retrieved), and convert it into a quantized model where weights and activations are represented
+    as integer data type.
+    """
+
+    def __init__(self,
+                 model: keras.models.Model,
+                 is_layer_exportable_fn: Callable,
+                 save_model_path: str):
+        """
+
+        Args:
+            model: Model to export.
+            is_layer_exportable_fn: Callable to check whether a layer can be exported or not.
+            save_model_path: Path to save the exported model.
+        """
+        super().__init__(model,
+                         is_layer_exportable_fn,
+                         save_model_path)
+
+        self.exported_model = None
+
+    def _get_pointwise_layer_to_replace_dense(self, wrapped_layer: qi.KerasQuantizationWrapper) -> keras.layers.Layer:
+        # First we create a pointwise configuration based on the Dense layer's configuration
+        dense_cfg = wrapped_layer.layer.get_config()
+
+        # List of pw attributes that should be taken from the dense layer as they are.
+        pw_attr_list = [LAYER_NAME, ACTIVATION, USE_BIAS, BIAS_CONSTRAINT,
+                        BIAS_INITIALIZER, BIAS_REGULARIZER, TRAINABLE, ACTIVITY_REGULARIZER,
+                        KERNEL_INITIALIZER, KERNEL_REGULARIZER, KERNEL_CONSTRAINT]
+
+        pw_cfg = {attr: dense_cfg[attr] for attr in pw_attr_list}
+
+        # Use more attributes that are not taken as they are
+        pw_cfg.update({KERNEL_SIZE: (1, 1),
+                       STRIDES: (1, 1),
+                       PADDING: PAD_VALID,
+                       FILTERS: dense_cfg[UNITS]})
+
+        # Create the point-wise layer
+        pw_layer = Conv2D(**pw_cfg)
+        pw_layer.build(wrapped_layer.layer.input_shape)
+
+        # Create and set the point-wise weights to assign
+        dense_kernel = wrapped_layer.layer.kernel
+        pw_weights = []
+        pw_kernel = np.reshape(wrapped_layer.get_weights()[0],
+                               (1, 1, dense_kernel.get_shape()[0], dense_cfg[UNITS]))
+
+        pw_weights.append(pw_kernel)
+        if wrapped_layer.layer.use_bias:
+            pw_bias = wrapped_layer.get_weights()[2]
+            pw_weights.append(pw_bias)
+
+        pw_layer.set_weights(pw_weights)
+
+        # Now that we have the point-wise to replace the dense layer,
+        # we need to wrap it using qi.KerasQuantizationWrapper with a new
+        # relevant quantizers.
+        # Create new kernel quantizer
+        pw_kernel_quantizer_cfg = wrapped_layer.weights_quantizers[KERNEL].get_config()
+
+        # In Conv2D channel axis is 3 and not 1 as in Dense
+        pw_kernel_quantizer_cfg[keras_inferable_constants.CHANNEL_AXIS] = CONV_KERNEL_CHANNEL_AXIS
+
+        # Unquantized weight to conv layer has 4 dimensions (unlike dense which varies)
+        pw_kernel_quantizer_cfg[keras_inferable_constants.INPUT_RANK] = CONV_INPUT_CHANNELS_DIM
+
+        assert isinstance(pw_kernel_quantizer_cfg[keras_inferable_constants.THRESHOLD], np.ndarray), f'Expected to find threshold which is a numpy array, but found: {type(pw_kernel_quantizer_cfg[keras_inferable_constants.THRESHOLD])}'
+        pw_kernel_quantizer_cfg[keras_inferable_constants.THRESHOLD] = list(pw_kernel_quantizer_cfg[keras_inferable_constants.THRESHOLD])
+
+        # Now that we have the point-wise quantizer we can instantiate it
+        quantizer_class = type(wrapped_layer.weights_quantizers[KERNEL])
+        pw_quantizer = quantizer_class(**pw_kernel_quantizer_cfg)
+        pw_weights_quantizers = copy.deepcopy(wrapped_layer.weights_quantizers)
+        pw_weights_quantizers[KERNEL] = pw_quantizer
+
+        # Wrap pw with the new quantizers (the activation is not affected thus we take the Dense quantizers)
+        wrapped_pw = qi.KerasQuantizationWrapper(pw_layer,
+                                                 pw_weights_quantizers,
+                                                 wrapped_layer.activation_quantizers)
+
+        # Compute the shape that the input to the new layer should be reshaped into
+        # Example: Dense kernel with the following shape (3, 20) expects to have input with the
+        # next dimensions (BATCH_SIZE, x0, x1, ..., xn, 20).
+        # Conv layer expects 4-rank input. Thus, the input is reshaped to (BATCH_SIZE, 1, x0*x1*...*xn, 20)
+        dim = wrapped_layer.layer.input_shape[1:-1]
+        target_shape = (1, int(np.prod(dim))) + (dense_kernel.get_shape()[0],)
+
+        return Sequential([
+            Reshape(target_shape=target_shape),
+            wrapped_pw,
+            Reshape(wrapped_layer.layer.output_shape[1:])
+        ])
+
+    def export(self) -> None:
+        """
+        Export a fully quantized model to its int8 tflite model.
+        """
+
+        def _substitute_model(wrapped_layer: qi.KerasQuantizationWrapper) -> keras.layers.Layer:
+            assert self.is_layer_exportable_fn(
+                wrapped_layer), f'Layer {wrapped_layer.get_config()} did not pass validation'
+
+            # In order to support dense quantization using per-channel quantization (which is
+            # unsupported in TFLITE int models) we substitute each dense layer to its equivalent
+            # point-wise convolution.
+            if isinstance(wrapped_layer.layer, Dense):
+                return self._get_pointwise_layer_to_replace_dense(wrapped_layer)
+
+            return wrapped_layer
+
+        # Transform the model to a new model that can be converted to int8 models.
+        # For example: replace dense layers with point-wise layers (to support per-channel quantization)
+        self.transformed_model = clone_model(self.model,
+                                             clone_function=_substitute_model)
+
+        # Convert model to int8 representation
+        converter = tf.lite.TFLiteConverter.from_keras_model(self.transformed_model)
+        converter.optimizations = [tf.lite.Optimize.DEFAULT]
+        self.exported_model = converter.convert()
+
+        Logger.info(f'Exporting INT8 tflite model to: {self.save_model_path}')
+        with open(self.save_model_path, 'wb') as f:
+            f.write(self.exported_model)

model_compression_toolkit/exporter/model_exporter/tflite/tflite_export_facade.py

@@ -15,41 +15,59 @@
 from enum import Enum
 from typing import Callable
 
-import keras
-
 from model_compression_toolkit.core.common import Logger
-from model_compression_toolkit.exporter.model_exporter.tflite.fakely_quant_tflite_exporter import \
-    FakelyQuantTFLiteExporter
+from model_compression_toolkit.core.common.constants import FOUND_TF
 
 
 class TFLiteExportMode(Enum):
     FAKELY_QUANT = 0
+    INT8 = 1
+
+if FOUND_TF:
+    import keras
+    from model_compression_toolkit.exporter.model_exporter.tflite.fakely_quant_tflite_exporter import FakelyQuantTFLiteExporter
+    from model_compression_toolkit.exporter.model_exporter.tflite.int8_tflite_exporter import INT8TFLiteExporter
+    from model_compression_toolkit.exporter.model_wrapper.keras.validate_layer import is_keras_layer_exportable
 
+    def tflite_export_model(model: keras.models.Model,
+                            save_model_path: str,
+                            mode: TFLiteExportMode = TFLiteExportMode.FAKELY_QUANT,
+                            is_layer_exportable_fn: Callable = is_keras_layer_exportable
+                            ):
+        """
+        Export a Keras quantized model to a tflite model.
+        The model will be saved to the path in save_model_path.
+        Mode can be used for different exported files. Currently, tflite_export_model
+        supports TFLiteExportMode.FAKELY_QUANT (where weights and activations are
+        float fakely-quantized values), and TFLiteExportMode.INT8 (where weights
+        and activations are represented using 8bits integers).
 
-def tflite_export_model(model: keras.models.Model,
-                        is_layer_exportable_fn: Callable,
-                        mode: TFLiteExportMode = TFLiteExportMode.FAKELY_QUANT,
-                        save_model_path: str = None):
-    """
-    Prepare and return fully quantized model for export. Save exported model to
-    a path if passed.
+        Args:
+            model: Model to export.
+            is_layer_exportable_fn: Callable to check whether a layer can be exported or not.
+            mode: Mode to export the model according to.
+            save_model_path: Path to save the model.
 
-    Args:
-        model: Model to export.
-        is_layer_exportable_fn: Callable to check whether a layer can be exported or not.
-        mode: Mode to export the model according to.
-        save_model_path: Path to save the model.
+        """
 
-    """
+        if mode == TFLiteExportMode.FAKELY_QUANT:
+            exporter = FakelyQuantTFLiteExporter(model,
+                                                 is_layer_exportable_fn,
+                                                 save_model_path)
+        elif mode == TFLiteExportMode.INT8:
+            exporter = INT8TFLiteExporter(model,
+                                          is_layer_exportable_fn,
+                                          save_model_path)
 
-    if mode == TFLiteExportMode.FAKELY_QUANT:
-        exporter = FakelyQuantTFLiteExporter(model,
-                                             is_layer_exportable_fn,
-                                             save_model_path)
+        else:
+            Logger.critical(
+                f'Unsupported mode was used {mode.name} to export TFLite model.'
+                f' Please see API for supported modes.')  # pragma: no cover
 
-    else:
-        Logger.critical(
-            f'Unsupported mode was used {mode.name} to export TFLite model.'
-            f' Please see API for supported modes.')
+        exporter.export()
 
-    exporter.export()
+else:
+    def tflite_export_model(*args, **kwargs):
+        Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                     'when using tflite_export_model. '
+                     'Could not find some or all of TensorFlow packages.')  # pragma: no cover

model_compression_toolkit/exporter/model_wrapper/__init__.py

@@ -13,8 +13,8 @@
 # limitations under the License.
 # ==============================================================================
 
-from model_compression_toolkit.core.common.constants import FOUND_TF
+from model_compression_toolkit.exporter.model_wrapper.keras.validate_layer import is_keras_layer_exportable
+from model_compression_toolkit.exporter.model_wrapper.keras.builder.fully_quantized_model_builder import get_exportable_keras_model
 
-if FOUND_TF:
-    from model_compression_toolkit.exporter.model_wrapper.keras.validate_layer import is_keras_layer_exportable
-    from model_compression_toolkit.exporter.model_wrapper.keras.builder.fully_quantized_model_builder import get_exportable_keras_model
+from model_compression_toolkit.exporter.model_wrapper.pytorch.validate_layer import is_pytorch_layer_exportable
+from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.fully_quantized_model_builder import get_exportable_pytorch_model

model_compression_toolkit/exporter/model_wrapper/keras/builder/fully_quantized_model_builder.py

@@ -12,157 +12,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from typing import Tuple
 
-import tensorflow as tf
-import tensorflow_model_optimization.quantization.keras.graph_transformations.model_transformer as mt
-from keras.layers import TFOpLambda
-from keras.models import Model
-from tensorflow.python.util.object_identity import Reference as TFReference
-from tensorflow_model_optimization.python.core.quantization.keras.default_8bit.default_8bit_quantize_configs import \
-    NoOpQuantizeConfig
-from typing import List, Tuple, Dict, Any
-
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapper
 
+from model_compression_toolkit import quantizers_infrastructure as qi
 from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common import BaseNode, Graph, Logger
+from model_compression_toolkit.core.common import Graph, Logger
+from model_compression_toolkit.core.common.constants import FOUND_TF
 from model_compression_toolkit.core.common.user_info import UserInformation
-from model_compression_toolkit.core.keras.back2framework.keras_model_builder import KerasModelBuilder, \
-    is_layer_fake_quant, get_node_name_from_layer
-from model_compression_toolkit.core.keras.quantizer.input_layer_quantize_transform import InputLayerWrapperTransform
-
-from model_compression_toolkit.exporter.model_wrapper.keras.builder.quantize_config_to_node import \
-    get_quantization_config
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.activation_quantize_config import \
-    ActivationQuantizeConfig
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.weights_activation_quantize_config \
-    import \
-    WeightsActivationQuantizeConfig
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.weights_quantize_config import \
-    WeightsQuantizeConfig
-from model_compression_toolkit.exporter.model_wrapper.keras.extended_quantize_wrapper import ExtendedQuantizeWrapper
-from model_compression_toolkit.exporter.model_wrapper.keras.quantizers.fq_quantizer import FakeQuantQuantizer
-from model_compression_toolkit.exporter.model_wrapper.keras.quantizers.weights_uniform_quantizer import \
-    WeightsUniformQuantizer
-
-
-def get_exportable_keras_model(graph: Graph) -> tf.keras.models.Model:
-    """
-    Convert graph to an exportable Keras model (model with all quantization parameters).
-    An exportable model can then be exported using model_exporter, to retrieve the
-    final exported model.
-
-    Args:
-        graph: Graph to convert to an exportable Keras model.
 
-    Returns:
-        Exportable Keras model.
-    """
+if FOUND_TF:
+    import tensorflow as tf
+    from tensorflow.keras.layers import Layer
+    from model_compression_toolkit.core.keras.back2framework.keras_model_builder import KerasModelBuilder
+    from model_compression_toolkit.exporter.model_wrapper.keras.builder.node_to_quantizers import get_quantization_quantizers
 
-    return FullyQuantizedKerasModelBuilder(graph=graph).build_model()
-
-
-class FullyQuantizedKerasModelBuilder(KerasModelBuilder):
-    """
-    Builder of exportable Keras models (fully quantized).
-    """
-
-    def __init__(self,
-                 graph: common.Graph):
+    def _get_wrapper(node: common.BaseNode,
+                     layer: Layer) -> qi.KerasQuantizationWrapper:
         """
-
+        A function which takes a computational graph node and a keras layer and perform the quantization wrapping
         Args:
-            graph: Graph to build the model from.
-        """
+            n: A node of mct graph.
+            layer: A keras layer
 
-        super().__init__(graph)
+        Returns: Wrapped layer with weights quantizers and activation quantizers
 
-    def _quantize_node_activations(self,
-                                   node: BaseNode,
-                                   input_tensors: List[TFReference]) -> List[TFReference]:
         """
-        Quantize node's activation given input tensors.
+        weights_quantizers, activation_quantizers = get_quantization_quantizers(node)
+        return qi.KerasQuantizationWrapper(layer, weights_quantizers, activation_quantizers)
 
-        Args:
-            node: Node to quantize its outputs.
-            input_tensors: Input tensors of the node.
-
-        Returns:
-            Output of the node.
-
-        """
-        return input_tensors
 
-    def build_model(self) -> Tuple[Model, UserInformation]:
+    def get_exportable_keras_model(graph: Graph) -> Tuple[tf.keras.models.Model, UserInformation]:
         """
-        Build a Keras mixed-precision model and return it.
-        Returns: Mixed-precision Keras model.
-
-        """
-        model, user_info = super().build_model()
-
-        def _wrap_layer_with_quantize_config(layer):
-
-            node = self.oh.layer_to_node_dict.get(layer)
+        Convert graph to an exportable Keras model (model with all quantization parameters).
+        An exportable model can then be exported using model_exporter, to retrieve the
+        final exported model.
 
-            if node is not None:
-                # In case of layers that are in reused groups, output_shape does not exist.
-                layer_output_shape = layer.output_shape if (node.reuse_group is None) else None
-                # For now, we do not support reused TFOpLambda layers.
-                if isinstance(layer, TFOpLambda) and layer_output_shape is None:
-                    Logger.error(
-                        f'Output shape must be inferred to use ExtendedQuantizeWrapper, but it seems that TFOpLambda '
-                        f'layer {layer.name} has no output shape. If it is a reused layer, MCT does not support '
-                        f'reused TFOpLambda layers for now.')
-                return ExtendedQuantizeWrapper(layer, get_quantization_config(node), layer_output_shape)
-
-            elif is_layer_fake_quant(layer):
-                return layer
-
-            else:
-                raise Exception(
-                    f'Mismatch between keras model and graph cant find node named: '
-                    f'{get_node_name_from_layer(layer)}')
-
-        # clone each layer in the model and apply _wrap_layer_with_quantize_config to the layer.
-        model = tf.keras.models.clone_model(model,
-                                            input_tensors=None,
-                                            clone_function=_wrap_layer_with_quantize_config)
-
-
-        # We use a model transformer to wrap the input layer with QuantizeWrapper.
-        # A model transformer allows to modify a layer in an existing model, by applying the given list of
-        # transformers on the model (in this case,
-        # we only apply single transformer - InputLayerQuantizeTransform)
-        model_inputs = self.graph.get_inputs()
-
-        input_transformer = mt.ModelTransformer(model, [InputLayerWrapperTransform(inp,
-                                                                                   get_quantization_config(inp),
-                                                                                   self.get_custom_objects(),
-                                                                                   ExtendedQuantizeWrapper)
-                                                        for inp in model_inputs])
-
-        model = input_transformer.transform()[0]
-
-        return model, user_info
-
-    @staticmethod
-    def get_custom_objects() -> Dict[str, Any]:
-        """
-
-        Returns: Dictionary of custom objects needed to load this model builder's output.
+        Args:
+            graph: Graph to convert to an exportable Keras model.
 
+        Returns:
+            Exportable Keras model and user information.
         """
-        return {ExtendedQuantizeWrapper.__name__: ExtendedQuantizeWrapper,
-                QuantizeWrapper.__name__: QuantizeWrapper,
-                WeightsActivationQuantizeConfig.__name__: WeightsActivationQuantizeConfig,
-                ActivationQuantizeConfig.__name__: ActivationQuantizeConfig,
-                WeightsQuantizeConfig.__name__: WeightsQuantizeConfig,
-                WeightsUniformQuantizer.__name__: WeightsUniformQuantizer,
-                NoOpQuantizeConfig.__name__: NoOpQuantizeConfig,
-                FakeQuantQuantizer.__name__: FakeQuantQuantizer}
-
-
-
-
-
+        exportable_model, user_info = KerasModelBuilder(graph=graph,
+                                             wrapper=_get_wrapper).build_model()
+        exportable_model.trainable = False
+        return exportable_model, user_info
+else:
+    def get_exportable_keras_model(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                     'when using get_exportable_keras_model. '
+                     'Could not find Tensorflow package.')

model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py

@@ -0,0 +1,143 @@
+# 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 Dict, Any
+
+from model_compression_toolkit.core.common import BaseNode, Logger
+from model_compression_toolkit.core.common.constants import THRESHOLD, RANGE_MIN, RANGE_MAX, SIGNED, CLUSTER_CENTERS, SCALE_PER_CHANNEL
+from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import QuantizationTarget
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.get_quantizers import get_inferable_quantizer_class
+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 import constants as qi_keras_consts
+
+def get_inferable_quantizer_kwargs(node: BaseNode,
+                                   quantization_target: QuantizationTarget) -> Dict[str, Any]:
+    """
+    Get the quantization parameters for an inferable quantizer.
+    Args:
+        node: The node for which the quantizer is being created.
+        quantization_target: The target of the quantization (weights or activations).
+    Returns:
+        The quantization parameters as a dictionary.
+    """
+
+    if quantization_target == QuantizationTarget.Weights:
+        # Get the weights quantization configuration for the node
+        node_w_qc = node.final_weights_quantization_cfg
+        quantization_method = node_w_qc.weights_quantization_method
+
+        # Return the appropriate quantization parameters based on the quantization method
+        if quantization_method in [QuantizationMethod.POWER_OF_TWO,
+                                   QuantizationMethod.SYMMETRIC]:
+            return {qi_keras_consts.NUM_BITS: node_w_qc.weights_n_bits,
+                    qi_keras_consts.THRESHOLD: list(node_w_qc.weights_quantization_params[THRESHOLD].flatten()),
+                    qi_keras_consts.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
+                    qi_keras_consts.CHANNEL_AXIS: node_w_qc.weights_channels_axis,
+                    qi_keras_consts.INPUT_RANK: len(node_w_qc.weights_quantization_params[THRESHOLD].shape)}
+
+        elif quantization_method in [QuantizationMethod.UNIFORM]:
+            return {qi_keras_consts.NUM_BITS: node_w_qc.weights_n_bits,
+                    qi_keras_consts.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
+                    qi_keras_consts.MIN_RANGE: list(node_w_qc.weights_quantization_params[RANGE_MIN].flatten()),
+                    qi_keras_consts.MAX_RANGE: list(node_w_qc.weights_quantization_params[RANGE_MAX].flatten()),
+                    qi_keras_consts.CHANNEL_AXIS: node_w_qc.weights_channels_axis,
+                    qi_keras_consts.INPUT_RANK: len(node_w_qc.weights_quantization_params[RANGE_MIN].shape)}
+
+        elif quantization_method in [QuantizationMethod.LUT_SYM_QUANTIZER, QuantizationMethod.LUT_POT_QUANTIZER]:
+            return {qi_keras_consts.NUM_BITS: node_w_qc.weights_n_bits,
+                    qi_keras_consts.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
+                    qi_keras_consts.CLUSTER_CENTERS: node_w_qc.weights_quantization_params[CLUSTER_CENTERS],
+                    qi_keras_consts.THRESHOLD: list(node_w_qc.weights_quantization_params[SCALE_PER_CHANNEL].flatten()),
+                    qi_keras_consts.CHANNEL_AXIS: node_w_qc.weights_channels_axis,
+                    # TODO: how to pass multiplier nbits and eps for a specific node?
+                    qi_keras_consts.INPUT_RANK: len(node_w_qc.weights_quantization_params[SCALE_PER_CHANNEL].shape)}
+
+        else:
+            Logger.critical(f'Not supported quantization method for inferable quantizers.')  # pragma: no cover
+
+    elif quantization_target == QuantizationTarget.Activation:
+        # Get the activation quantization configuration for the node
+        node_qc = node.final_activation_quantization_cfg
+        quantization_method = node_qc.activation_quantization_method
+
+        # Return the appropriate quantization parameters based on the quantization method
+        if quantization_method in [QuantizationMethod.POWER_OF_TWO,
+                                   QuantizationMethod.SYMMETRIC]:
+            return {qi_keras_consts.NUM_BITS: node_qc.activation_n_bits,
+                    # In activation quantization is per-tensor only - thus we hold the threshold as a list with a len of 1
+                    qi_keras_consts.THRESHOLD: [node_qc.activation_quantization_params[THRESHOLD]],
+                    qi_keras_consts.SIGNED: node_qc.activation_quantization_params[SIGNED]}
+
+        elif quantization_method in [QuantizationMethod.UNIFORM]:
+            return {qi_keras_consts.NUM_BITS: node_qc.activation_n_bits,
+                    # In activation quantization is per-tensor only - thus we hold the min/max as a list with a len of 1
+                    qi_keras_consts.MIN_RANGE: [node_qc.activation_quantization_params[RANGE_MIN]],
+                    qi_keras_consts.MAX_RANGE: [node_qc.activation_quantization_params[RANGE_MAX]]}
+
+        elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER]:
+            return {qi_keras_consts.NUM_BITS: node_qc.activation_n_bits,
+                    qi_keras_consts.SIGNED: node_qc.activation_quantization_params[SIGNED],
+                    qi_keras_consts.CLUSTER_CENTERS: node_qc.activation_quantization_params[CLUSTER_CENTERS],
+                    qi_keras_consts.THRESHOLD: [node_qc.activation_quantization_params[THRESHOLD]]
+                    # TODO: how to pass multiplier nbits and eps for a specific node?
+                    }
+        else:
+            Logger.critical(f'Not supported quantization method for inferable quantizers.')  # pragma: no cover
+    else:
+        Logger.critical(f'{quantization_target} is not supported')  # pragma: no cover
+
+
+def get_weights_quantizer_for_node(node: BaseNode) -> BaseKerasInferableQuantizer:
+    """
+    Get weights quantizer for a node.
+    Args:
+        node: Node to create a weight quantizer for.
+    Returns:
+        Quantizer for the node's weights.
+    """
+    if node.final_weights_quantization_cfg is None:
+        Logger.critical(f'Can not set quantizer for a node with no final weights quantization configuration')  # pragma:
+        # no cover
+    node_w_qc = node.final_weights_quantization_cfg
+    weights_quantization_method = node_w_qc.weights_quantization_method
+
+    quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Weights,
+                                                      weights_quantization_method,
+                                                      BaseKerasInferableQuantizer)
+    kwargs = get_inferable_quantizer_kwargs(node, QuantizationTarget.Weights)
+
+    return quantier_for_node(**kwargs)
+
+
+def get_activations_quantizer_for_node(node: BaseNode) -> BaseKerasInferableQuantizer:
+    """
+    Get activation quantizer for a node.
+    Args:
+        node: Node to create an activation quantizer for.
+    Returns:
+        Quantizer for the node's activations.
+    """
+    if node.final_activation_quantization_cfg is None:
+        Logger.critical(f'Can not set quantizer for a node with no final activation quantization configuration')  #
+        # pragma: no cover
+    node_act_qc = node.final_activation_quantization_cfg
+    activation_quantization_method = node_act_qc.activation_quantization_method
+
+    quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
+                                                      activation_quantization_method,
+                                                      BaseKerasInferableQuantizer)
+    kwargs = get_inferable_quantizer_kwargs(node, QuantizationTarget.Activation)
+
+    return quantier_for_node(**kwargs)

model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizers.py

@@ -0,0 +1,46 @@
+# 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 Dict, List, Tuple
+from model_compression_toolkit.core.common import BaseNode
+from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
+from model_compression_toolkit.exporter.model_wrapper.keras.builder.node_to_quantizer import \
+    get_weights_quantizer_for_node, get_activations_quantizer_for_node
+
+
+def get_quantization_quantizers(node: BaseNode) -> Tuple[Dict, List]:
+    """
+    Create quantizers to wrap a layer for its corresponding node.
+
+    Args:
+        node: Node to create quantizers for.
+
+    Returns:
+        weight_quantizers: A dictionary between a weight's name to its quantizer.
+        activation_quantizers: A list of activations quantization, one for each layer output.
+    """
+    weight_quantizers = {}
+    activation_quantizers = []
+
+    if node.is_weights_quantization_enabled():
+        weight_attrs = DEFAULT_KERAS_INFO.get_kernel_op_attributes(node.type)
+        weight_quantizer = get_weights_quantizer_for_node(node)
+        for attr in weight_attrs:
+            weight_quantizers[attr] = weight_quantizer
+
+    if node.is_activation_quantization_enabled():
+        num_of_outputs = len(node.output_shape) if isinstance(node.output_shape, list) else 1
+        activation_quantizers = [get_activations_quantizer_for_node(node)] * num_of_outputs
+
+    return weight_quantizers, activation_quantizers