mct-nightly 1.8.0.27022023.post430__py3-none-any.whl → 1.8.0.27032023.post403__py3-none-any.whl

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

@@ -14,46 +14,52 @@
 # ==============================================================================
 from typing import Tuple
 
-import tensorflow as tf
-from tensorflow.keras.layers import Layer
 
 from model_compression_toolkit import quantizers_infrastructure as qi
 from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common import Graph
+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
-from model_compression_toolkit.exporter.model_wrapper.keras.builder.node_to_quantizers import \
-    get_quantization_quantizers
-
-
-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:
-        n: A node of mct graph.
-        layer: A keras layer
-
-    Returns: Wrapped layer with weights quantizers and activation quantizers
-
-    """
-    weights_quantizers, activation_quantizers = get_quantization_quantizers(node)
-    return qi.KerasQuantizationWrapper(layer, weights_quantizers, activation_quantizers)
-
-
-def get_exportable_keras_model(graph: Graph) -> Tuple[tf.keras.models.Model,UserInformation]:
-    """
-    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 and user information.
-    """
-    exportable_model, user_info = KerasModelBuilder(graph=graph,
-                                         wrapper=_get_wrapper).build_model()
-    exportable_model.trainable = False
-    return exportable_model, user_info
+
+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
+
+    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:
+            n: A node of mct graph.
+            layer: A keras layer
+
+        Returns: Wrapped layer with weights quantizers and activation quantizers
+
+        """
+        weights_quantizers, activation_quantizers = get_quantization_quantizers(node)
+        return qi.KerasQuantizationWrapper(layer, weights_quantizers, activation_quantizers)
+
+
+    def get_exportable_keras_model(graph: Graph) -> Tuple[tf.keras.models.Model, UserInformation]:
+        """
+        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 and user information.
+        """
+        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

@@ -15,15 +15,12 @@
 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
+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.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]:
@@ -44,19 +41,29 @@ def get_inferable_quantizer_kwargs(node: BaseNode,
         # Return the appropriate quantization parameters based on the quantization method
         if quantization_method in [QuantizationMethod.POWER_OF_TWO,
                                    QuantizationMethod.SYMMETRIC]:
-            return {'num_bits': node_w_qc.weights_n_bits,
-                    'threshold': list(node_w_qc.weights_quantization_params[THRESHOLD].flatten()),
-                    'per_channel': node_w_qc.weights_per_channel_threshold,
-                    'channel_axis': node_w_qc.weights_channels_axis,
-                    'input_rank': len(node_w_qc.weights_quantization_params[THRESHOLD].shape)}
+            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 {'num_bits': node_w_qc.weights_n_bits,
-                    'per_channel': node_w_qc.weights_per_channel_threshold,
-                    'min_range': list(node_w_qc.weights_quantization_params[RANGE_MIN].flatten()),
-                    'max_range': list(node_w_qc.weights_quantization_params[RANGE_MAX].flatten()),
-                    'channel_axis': node_w_qc.weights_channels_axis,
-                    'input_rank': len(node_w_qc.weights_quantization_params[THRESHOLD].shape)}
+            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
 
@@ -68,16 +75,24 @@ def get_inferable_quantizer_kwargs(node: BaseNode,
         # Return the appropriate quantization parameters based on the quantization method
         if quantization_method in [QuantizationMethod.POWER_OF_TWO,
                                    QuantizationMethod.SYMMETRIC]:
-            return {'num_bits': node_qc.activation_n_bits,
+            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
-                    'threshold': [node_qc.activation_quantization_params[THRESHOLD]],
-                    'signed': node_qc.activation_quantization_params[SIGNED]}
+                    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 {'num_bits': node_qc.activation_n_bits,
+            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
-                    'min_range': [node_qc.activation_quantization_params[RANGE_MIN]],
-                    'max_range': [node_qc.activation_quantization_params[RANGE_MAX]]}
+                    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:

model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py

@@ -14,61 +14,69 @@
 # ==============================================================================
 from typing import Any
 
-from keras.engine.input_layer import InputLayer
 
 from model_compression_toolkit.core.common import Logger
-from model_compression_toolkit.quantizers_infrastructure import KerasQuantizationWrapper
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import BaseInferableQuantizer
-
+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, 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
+        Args:
+            layer: Keras layer to check if considered to be valid for exporting.
 
-    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
+        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
 
-    for _, weights_quantizer in layer.weights_quantizers.items():
-        if not isinstance(weights_quantizer, BaseInferableQuantizer):
+        valid_layer = isinstance(layer, KerasQuantizationWrapper)
+        if not valid_layer:
             Logger.error(
-                f'weights_quantizer must be a BaseInferableQuantizer object but has a '
-                f'{type(weights_quantizer)} object')  # pragma: no cover
+                f'Exportable layer must be wrapped using KerasQuantizationWrapper, but layer {layer.name} is of type '
+                f'{type(layer)}') # pragma: no cover
 
-    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
+        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
+
+        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
 
-    for activation_quantizers in layer.activation_quantizers:
-        if not isinstance(activation_quantizers, BaseInferableQuantizer):
+        valid_activation_quantizers = isinstance(layer.activation_quantizers, list)
+        if not valid_activation_quantizers:
             Logger.error(
-                f'activation_quantizers must be a BaseInferableQuantizer object but has a '
-                f'{type(activation_quantizers)} object')  # pragma: no cover
+                f'KerasQuantizationWrapper must have a activation_quantizers list but has a '
+                f'{type(layer.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
+        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
 
-    return True
+        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,42 +13,49 @@
 # limitations under the License.
 # ==============================================================================
 
-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 Graph
-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
-
-
-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:
-        node: A node of mct graph.
-        module: A Pytorch module
-
-    Returns: Wrapped layer
-
-    """
-    weight_quantizers, activation_quantizers = get_quantization_quantizers(node)
-    wrapped_layer = qi.PytorchQuantizationWrapper(module, weight_quantizers, activation_quantizers)
-    return wrapped_layer
-
-
-def get_exportable_pytorch_model(graph: Graph):
-    """
-    Convert graph to fully quantized PyTorch model.
-
-    Args:
-        graph: Graph to convert to a PyTorch model.
-
-    Returns:
-        Fully quantized PyTorch model.
-    """
-    return PyTorchModelBuilder(graph=graph,
-                               wrapper=fully_quantized_wrapper).build_model()
+from model_compression_toolkit.core.common import Graph, Logger
+from model_compression_toolkit.core.common.constants import FOUND_TORCH
+
+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
+
+    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:
+            node: A node of mct graph.
+            module: A Pytorch module
+
+        Returns: Wrapped layer
+
+        """
+        weight_quantizers, activation_quantizers = get_quantization_quantizers(node)
+        wrapped_layer = qi.PytorchQuantizationWrapper(module, weight_quantizers, activation_quantizers)
+        return wrapped_layer
+
+
+    def get_exportable_pytorch_model(graph: Graph):
+        """
+        Convert graph to fully quantized PyTorch model.
+
+        Args:
+            graph: Graph to convert to a PyTorch model.
+
+        Returns:
+            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

@@ -16,7 +16,8 @@
 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.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 \
@@ -45,6 +46,15 @@ def get_weights_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
                 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
+
     else:
         Logger.critical(f'Not supported quantization method for weights inferable quantizers.')  # pragma: no cover
 
@@ -65,6 +75,15 @@ def get_activation_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
         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
 
@@ -111,10 +130,10 @@ def get_activations_quantizer_for_node(node: BaseNode) -> BasePyTorchInferableQu
     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,
-                                                      BasePyTorchInferableQuantizer)
+    quantizer_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
+                                                       activation_quantization_method,
+                                                       BasePyTorchInferableQuantizer)
     kwargs = get_activation_inferable_quantizer_kwargs(node)
 
-    return quantier_for_node(**kwargs)
+    return quantizer_for_node(**kwargs)
 

model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py

@@ -14,24 +14,31 @@
 # ==============================================================================
 from typing import Any
 
-from model_compression_toolkit.quantizers_infrastructure import PytorchQuantizationWrapper
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
-    BasePyTorchInferableQuantizer
+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.
 
-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.
 
-    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
+        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