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_wrapper/keras/validate_layer.py

@@ -14,35 +14,69 @@
 # ==============================================================================
 from typing import Any
 
-from keras.engine.input_layer import InputLayer
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapperV2
 
 from model_compression_toolkit.core.common import Logger
-from model_compression_toolkit.exporter.model_wrapper.keras.builder.quantize_config_to_node import \
-    SUPPORTED_QUANTIZATION_CONFIG
-from model_compression_toolkit.exporter.model_wrapper.keras.extended_quantize_wrapper import ExtendedQuantizeWrapper
+from model_compression_toolkit.core.common.constants import FOUND_TF
 
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import BaseInferableQuantizer
 
-def is_keras_layer_exportable(layer: Any) -> bool:
-    """
-    Check whether a Keras layer is a valid exportable layer or not.
 
-    Args:
-        layer: Keras layer to check if considered to be valid for exporting.
+if FOUND_TF:
+    from keras.engine.input_layer import InputLayer
+    from model_compression_toolkit.quantizers_infrastructure import KerasQuantizationWrapper
 
-    Returns:
+    def is_keras_layer_exportable(layer: Any) -> bool:
+        """
         Check whether a Keras layer is a valid exportable layer or not.
-    """
-    # Keras Input layers are not wrapped
-    if isinstance(layer, InputLayer):
-        return True
 
-    valid_layer = isinstance(layer, ExtendedQuantizeWrapper)
-    if not valid_layer:
-        Logger.error(f'Exportable layer must be wrapped using ExtendedQuantizeWrapper, but layer {layer.name} is of type {type(layer)}')
+        Args:
+            layer: Keras layer to check if considered to be valid for exporting.
+
+        Returns:
+            Check whether a Keras layer is a valid exportable layer or not.
+        """
+        # Keras Input layers are not wrapped
+        if isinstance(layer, InputLayer):
+            return True
+
+        valid_layer = isinstance(layer, KerasQuantizationWrapper)
+        if not valid_layer:
+            Logger.error(
+                f'Exportable layer must be wrapped using KerasQuantizationWrapper, but layer {layer.name} is of type '
+                f'{type(layer)}') # pragma: no cover
+
+        valid_weights_quantizers = isinstance(layer.weights_quantizers, dict)
+        if not valid_weights_quantizers:
+            Logger.error(
+                f'KerasQuantizationWrapper must have a weights_quantizers but has a '
+                f'{type(layer.weights_quantizers)} object') # pragma: no cover
 
-    valid_quantize_config = type(layer.quantize_config) in SUPPORTED_QUANTIZATION_CONFIG
-    if not valid_quantize_config:
-        Logger.error(f'QuantizeConfig of layer is not supported. Type: {type(layer.quantize_config)}. Supported configs: {SUPPORTED_QUANTIZATION_CONFIG}.')
+        for _, weights_quantizer in layer.weights_quantizers.items():
+            if not isinstance(weights_quantizer, BaseInferableQuantizer):
+                Logger.error(
+                    f'weights_quantizer must be a BaseInferableQuantizer object but has a '
+                    f'{type(weights_quantizer)} object')  # pragma: no cover
 
-    return True
+        valid_activation_quantizers = isinstance(layer.activation_quantizers, list)
+        if not valid_activation_quantizers:
+            Logger.error(
+                f'KerasQuantizationWrapper must have a activation_quantizers list but has a '
+                f'{type(layer.activation_quantizers)} object') # pragma: no cover
+
+        for activation_quantizers in layer.activation_quantizers:
+            if not isinstance(activation_quantizers, BaseInferableQuantizer):
+                Logger.error(
+                    f'activation_quantizers must be a BaseInferableQuantizer object but has a '
+                    f'{type(activation_quantizers)} object')  # pragma: no cover
+
+        quantizers = layer.activation_quantizers + list(layer.weights_quantizers.values())
+        is_valid_quantizers = all([isinstance(x, BaseInferableQuantizer) for x in quantizers])
+        if not is_valid_quantizers:
+            Logger.error(f'Found a quantizer that is not of type BaseInferableQuantizer') # pragma: no cover
+
+        return True
+else:
+    def is_keras_layer_exportable(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                     'when using is_keras_layer_exportable. '
+                     'Could not find Tensorflow package.')

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

@@ -13,132 +13,49 @@
 # limitations under the License.
 # ==============================================================================
 
-from typing import List, Any, Tuple
-
-import torch
 
+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
-from model_compression_toolkit.core.common.user_info import UserInformation
-from model_compression_toolkit.core.pytorch.back2framework.instance_builder import node_builder
-from model_compression_toolkit.core.pytorch.back2framework.pytorch_model_builder import PyTorchModelBuilder, \
-    PytorchModel
-from model_compression_toolkit.core.pytorch.back2framework.quantization_wrapper.quantized_layer_wrapper import \
-    QuantizedLayerWrapper
-from model_compression_toolkit.core.pytorch.constants import BUFFER, CONSTANT
-from model_compression_toolkit.core.pytorch.reader.node_holders import BufferHolder, ConstantHolder
-from model_compression_toolkit.core.pytorch.utils import get_working_device
-
-
-from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantize_config import get_quantization_config
-
-
-def get_fully_quantized_pytorch_model(graph: Graph):
-    """
-    Convert graph to fully quantized PyTorch model.
+from model_compression_toolkit.core.common import Graph, Logger
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
 
-    Args:
-        graph: Graph to convert to a PyTorch model.
+if FOUND_TORCH:
+    import torch
+    from model_compression_toolkit.core.pytorch.back2framework.pytorch_model_builder import PyTorchModelBuilder
+    from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantizers import \
+        get_quantization_quantizers
 
-    Returns:
-        Fully quantized PyTorch model.
-    """
-    return FullyQuantizedPyTorchModelBuilder(graph=graph).build_model()
-
-
-
-class FullyQuantizedPyTorchModel(PytorchModel):
-    """
-    PyTorch model with all quantization information.
-    """
-
-    def __init__(self,
-                 graph: common.Graph):
+    def fully_quantized_wrapper(node: common.BaseNode, module: torch.nn.Module) -> qi.PytorchQuantizationWrapper:
         """
+        A function which takes a computational graph node and a pytorch module and
+        perform the quantization wrapping
 
         Args:
-            graph: Graph to build its corresponding Pytorch model.
-        """
+            node: A node of mct graph.
+            module: A Pytorch module
 
-        super().__init__(graph)
+        Returns: Wrapped layer
 
-
-    def _add_modules(self):
         """
+        weight_quantizers, activation_quantizers = get_quantization_quantizers(node)
+        wrapped_layer = qi.PytorchQuantizationWrapper(module, weight_quantizers, activation_quantizers)
+        return wrapped_layer
 
-        Add nodes in graph as modules.
-
-        """
-        for n in self.node_sort:
-            if n.type == BufferHolder:
-                self.add_module(n.name, node_builder(n))
-                self.get_submodule(n.name).register_buffer(n.name,
-                                                           torch.Tensor(n.get_weights_by_keys(BUFFER)).to(get_working_device()))
-            elif n.type == ConstantHolder:
-                self.add_module(n.name, node_builder(n))
-                self.get_submodule(n.name).register_buffer(n.name,
-                                                           torch.Tensor(n.get_weights_by_keys(CONSTANT)).to(get_working_device()))
-
-            else:
-                # Create a wrapper based on the corresponding quantization config.
-                layer_wrapper = QuantizedLayerWrapper(n, get_quantization_config(n))
-                # Add the wrapped layer to the model.
-                self.add_module(n.name, layer_wrapper)
-
-    def _get_op_func(self,
-                     node: BaseNode,
-                     configurable_nodes_names: List[str]) -> Any:
-        """
-        Get the operator corresponding to the passed node.
-
-        Args:
-            node: Node to get its op.
-            configurable_nodes_names: List of nodes that are configurable.
-
-        Returns:
-            Operator (module) of the node.
-        """
-        return getattr(self, node.name)
 
-    def _quantize_node_activations(self,
-                                   node: BaseNode,
-                                   input_tensors: List[torch.Tensor]) -> List[torch.Tensor]:
+    def get_exportable_pytorch_model(graph: Graph):
         """
-        Quantize node's activation given input tensors.
+        Convert graph to fully quantized PyTorch model.
 
         Args:
-            node: Node to quantize its outputs.
-            input_tensors: Input tensors of the node.
+            graph: Graph to convert to a PyTorch model.
 
         Returns:
-            Output of the node.
-
-        """
-        return input_tensors
-
-
-
-
-
-class FullyQuantizedPyTorchModelBuilder(PyTorchModelBuilder):
-    """
-    Fully-Quantized PyTorch model.
-    """
-
-    def __init__(self,
-                 graph: common.Graph):
-        """
-
-        Args:
-            graph: Graph to build the model from.
-        """
-
-        super().__init__(graph)
-
-    def build_model(self) -> Tuple[PytorchModel, UserInformation]:
-        """
-        Build a PyTorch fully quantized model and return it.
-        Returns: Fully quantized PyTorch model and user information.
-
-        """
-        return FullyQuantizedPyTorchModel(self.graph), self.graph.user_info
+            Fully quantized PyTorch model.
+        """
+        return PyTorchModelBuilder(graph=graph,
+                                   wrapper=fully_quantized_wrapper).build_model()
+else:
+    def get_exportable_pytorch_model(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing torch is mandatory '
+                     'when using get_exportable_pytorch_model. '
+                     'Could not find PyTorch package.')

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

@@ -12,31 +12,83 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-import numpy as np
 
-from typing import List, Callable
+from typing import Dict, Any
 
 from model_compression_toolkit.core.common import BaseNode, Logger
-from model_compression_toolkit.core.common.constants import THRESHOLD, SIGNED, RANGE_MIN, RANGE_MAX
-from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import calculate_delta
+from model_compression_toolkit.core.common.constants import THRESHOLD, SIGNED, RANGE_MIN, RANGE_MAX, \
+    SCALE_PER_CHANNEL, CLUSTER_CENTERS
 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.get_quantizers import \
+    get_inferable_quantizer_class
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
+    constants as qi_inferable_quantizers_constants, BasePyTorchInferableQuantizer
+import numpy as np
 
-# Supporting other quantizer types in the future
-from model_compression_toolkit.exporter.model_wrapper.pytorch.quantizers.fq_quantizer import FakeQuantQuantizer
-from model_compression_toolkit.exporter.model_wrapper.pytorch.quantizers.uniform_weights_quantizer import \
-    UniformWeightsQuantizer
-import torch
 
-SUPPORTED_WEIGHT_QUANTIZER_TYPES = [QuantizationMethod.POWER_OF_TWO,
-                                    QuantizationMethod.SYMMETRIC,
-                                    QuantizationMethod.UNIFORM]
+def get_weights_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
+    # 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_inferable_quantizers_constants.NUM_BITS: node_w_qc.weights_n_bits,
+                qi_inferable_quantizers_constants.THRESHOLD: node_w_qc.weights_quantization_params[THRESHOLD].flatten(),
+                qi_inferable_quantizers_constants.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
+                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_w_qc.weights_channels_axis}
+
+    elif quantization_method in [QuantizationMethod.UNIFORM]:
+        return {qi_inferable_quantizers_constants.NUM_BITS: node_w_qc.weights_n_bits,
+                qi_inferable_quantizers_constants.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
+                qi_inferable_quantizers_constants.MIN_RANGE: node_w_qc.weights_quantization_params[RANGE_MIN].flatten(),
+                qi_inferable_quantizers_constants.MAX_RANGE: node_w_qc.weights_quantization_params[RANGE_MAX].flatten(),
+                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_w_qc.weights_channels_axis}
+
+    elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER, QuantizationMethod.LUT_SYM_QUANTIZER]:
+        return {qi_inferable_quantizers_constants.NUM_BITS: node_w_qc.weights_n_bits,
+                qi_inferable_quantizers_constants.CLUSTER_CENTERS: node_w_qc.weights_quantization_params[CLUSTER_CENTERS].flatten(),
+                qi_inferable_quantizers_constants.THRESHOLD: node_w_qc.weights_quantization_params[SCALE_PER_CHANNEL].flatten(),
+                qi_inferable_quantizers_constants.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
+                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_w_qc.weights_channels_axis}
+                # TODO: Add MULTIPLIER_N_BITS & EPS to node quantization config
 
-SUPPORTED_ACTIVATION_QUANTIZER_TYPES = [QuantizationMethod.POWER_OF_TWO,
-                                        QuantizationMethod.SYMMETRIC,
-                                        QuantizationMethod.UNIFORM]
+    else:
+        Logger.critical(f'Not supported quantization method for weights inferable quantizers.')  # pragma: no cover
+
+
+def get_activation_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
+    # 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_inferable_quantizers_constants.NUM_BITS: node_qc.activation_n_bits,
+                qi_inferable_quantizers_constants.THRESHOLD: np.asarray([node_qc.activation_quantization_params[THRESHOLD]]),
+                qi_inferable_quantizers_constants.SIGNED: node_qc.activation_quantization_params.get(SIGNED)}
+
+    elif quantization_method in [QuantizationMethod.UNIFORM]:
+        return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.activation_n_bits,
+                qi_inferable_quantizers_constants.MIN_RANGE: np.asarray([node_qc.activation_quantization_params[RANGE_MIN]]),
+                qi_inferable_quantizers_constants.MAX_RANGE: np.asarray([node_qc.activation_quantization_params[RANGE_MAX]])}
+
+    elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER]:
+        return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.activation_n_bits,
+                qi_inferable_quantizers_constants.CLUSTER_CENTERS: np.asarray(
+                    [node_qc.activation_quantization_params[CLUSTER_CENTERS]]),
+                qi_inferable_quantizers_constants.THRESHOLD: np.asarray(
+                    [node_qc.activation_quantization_params[THRESHOLD]]),
+                qi_inferable_quantizers_constants.SIGNED: node_qc.activation_quantization_params.get(SIGNED)}
+        # TODO: Add MULTIPLIER_N_BITS & EPS to node quantization config
+    else:
+        Logger.critical(f'Not supported quantization method for inferable quantizers.')  # pragma: no cover
 
 
-def get_weights_quantizer_for_node(node: BaseNode) -> List[Callable]:
+def get_weights_quantizer_for_node(node: BaseNode) -> BasePyTorchInferableQuantizer:
     """
     Get weights quantizer for a node.
 
@@ -48,41 +100,20 @@ def get_weights_quantizer_for_node(node: BaseNode) -> List[Callable]:
 
     """
     if node.final_weights_quantization_cfg is None:
-        Logger.critical(f'Can not set quantizer for a node with no final weights quantization configuration')
-
+        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
 
-    if weights_quantization_method not in SUPPORTED_WEIGHT_QUANTIZER_TYPES:
-        Logger.error(f'Fully quantized models are now supported for {SUPPORTED_WEIGHT_QUANTIZER_TYPES} quantization methods, but node has {weights_quantization_method} quantization method')
-
-    # Compute quantizer params based on node's quantization params
-    if weights_quantization_method in [QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC]:
-        weight_thresholds = node_w_qc.weights_quantization_params.get(THRESHOLD)
-        assert weight_thresholds is not None
-        if weights_quantization_method == QuantizationMethod.POWER_OF_TWO:
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in weight_thresholds.flatten()])
-            if not is_threshold_pot:
-                Logger.error(f'Expected threshold to be power of 2 but is {weight_thresholds}')
-
-        min_range = -weight_thresholds
-        max_range = weight_thresholds - calculate_delta(weight_thresholds,
-                                                        n_bits=node_w_qc.weights_n_bits,
-                                                        signed=True)
-
-    else:
-        Logger.error(f'For now fully quantized models support only {SUPPORTED_WEIGHT_QUANTIZER_TYPES} for weights quantization, but found {weights_quantization_method}')
+    quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Weights,
+                                                      weights_quantization_method,
+                                                      BasePyTorchInferableQuantizer)
+    kwargs = get_weights_inferable_quantizer_kwargs(node)
 
-    return [UniformWeightsQuantizer(num_bits=node_w_qc.weights_n_bits,
-                                    max_range=max_range,
-                                    min_range=min_range,
-                                    quantization_method=node_w_qc.weights_quantization_method,
-                                    per_channel=node_w_qc.weights_per_channel_threshold,
-                                    output_channels_axis=node_w_qc.weights_channels_axis
-                                    )]
+    return quantier_for_node(**kwargs)
 
 
-def get_activations_quantizer_for_node(node: BaseNode) -> List[Callable]:
+def get_activations_quantizer_for_node(node: BaseNode) -> BasePyTorchInferableQuantizer:
     """
     Get activation quantizer for a node.
 
@@ -93,43 +124,16 @@ def get_activations_quantizer_for_node(node: BaseNode) -> List[Callable]:
         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')
-
+        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
 
-    if activation_quantization_method not in SUPPORTED_ACTIVATION_QUANTIZER_TYPES:
-        Logger.error(
-            f'Fully quantized models are now supported for {SUPPORTED_ACTIVATION_QUANTIZER_TYPES} quantization methods, '
-            f'but node has {activation_quantization_method} quantization method')
-
-    activation_thresholds = node_act_qc.activation_quantization_params.get(THRESHOLD)
-
-    if activation_quantization_method in [QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC]:
-        if activation_quantization_method == QuantizationMethod.POWER_OF_TWO:
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in activation_thresholds.flatten()])
-            if not is_threshold_pot:
-                Logger.error(f'Expected threshold to be power of 2 but is {node_act_qc.activation_quantization_params.get(THRESHOLD)}')
+    quantizer_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
+                                                       activation_quantization_method,
+                                                       BasePyTorchInferableQuantizer)
+    kwargs = get_activation_inferable_quantizer_kwargs(node)
 
-        min_range = 0
-        if node_act_qc.activation_quantization_params.get(SIGNED):
-            min_range = -activation_thresholds
-
-        max_range = activation_thresholds - calculate_delta(
-            activation_thresholds,
-            n_bits=node_act_qc.activation_n_bits,
-            signed=node_act_qc.activation_quantization_params.get(SIGNED))
-
-    elif activation_quantization_method in [QuantizationMethod.UNIFORM]:
-        min_range = node_act_qc.activation_quantization_params.get(RANGE_MIN)
-        max_range = node_act_qc.activation_quantization_params.get(RANGE_MAX)
-
-    else:
-        Logger.error(f'For now fully quantized models support only {SUPPORTED_ACTIVATION_QUANTIZER_TYPES} for activation quantization, but found {activation_quantization_method}')
+    return quantizer_for_node(**kwargs)
 
-    return [FakeQuantQuantizer(nbits=node_act_qc.activation_n_bits,
-                              min_range=min_range,
-                              max_range=max_range,
-                              quantization_method=activation_quantization_method)]

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

@@ -0,0 +1,47 @@
+# 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 Tuple, List, Dict
+from model_compression_toolkit.core.common import BaseNode
+from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
+from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantizer import \
+    get_activations_quantizer_for_node, get_weights_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 = {}
+    if node.is_weights_quantization_enabled():
+        weight_attrs = DEFAULT_PYTORCH_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
+
+    activation_quantizers = []
+    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

model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py

@@ -0,0 +1,44 @@
+# 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 Any
+
+from model_compression_toolkit.core.common import Logger
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+
+if FOUND_TORCH:
+    from model_compression_toolkit.quantizers_infrastructure import PytorchQuantizationWrapper
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
+        BasePyTorchInferableQuantizer
+    def is_pytorch_layer_exportable(layer: Any) -> bool:
+        """
+        Check whether a torch Module is a valid exportable module or not.
+
+        Args:
+            layer: PyTorch module to check if considered to be valid for exporting.
+
+        Returns:
+            Check whether a PyTorch layer is a valid exportable layer or not.
+        """
+        if isinstance(layer, PytorchQuantizationWrapper):
+            quantizers = list(layer.weights_quantizers.values())
+            quantizers.extend(layer.activation_quantizers)
+            if all([isinstance(q, BasePyTorchInferableQuantizer) for q in quantizers]):
+                return True
+        return False
+else:
+    def is_pytorch_layer_exportable(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing torch is mandatory '
+                     'when using is_pytorch_layer_exportable. '
+                     'Could not find PyTorch package.')

model_compression_toolkit/gptq/__init__.py

@@ -12,3 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+
+from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, RoundingType, GradientPTQConfigV2
+from model_compression_toolkit.gptq.keras.quantization_facade import keras_gradient_post_training_quantization_experimental
+from model_compression_toolkit.gptq.keras.quantization_facade import get_keras_gptq_config
+from model_compression_toolkit.gptq.pytorch.quantization_facade import pytorch_gradient_post_training_quantization_experimental
+from model_compression_toolkit.gptq.pytorch.quantization_facade import get_pytorch_gptq_config