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

model_compression_toolkit/qunatizers_infrastructure/keras/config_serialization.py

@@ -1,83 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-import copy
-
-from collections.abc import Callable
-from typing import Any
-
-from model_compression_toolkit import QuantizationConfig
-from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
-    BaseNodeQuantizationConfig
-from model_compression_toolkit.core.common.target_platform import QuantizationMethod, OpQuantizationConfig
-from enum import Enum
-
-IS_WEIGHTS = "is_weights"
-WEIGHTS_QUANTIZATION_METHOD = "weights_quantization_method"
-
-
-def transform_enum(v: Any):
-    """
-    If an enum is received it value is return otherwise the input is returned.
-    Args:
-        v: Any type
-
-    Returns: Any
-
-    """
-    if isinstance(v, Enum):
-        return v.value
-    return v
-
-
-def config_serialization(quantization_config: BaseNodeQuantizationConfig):
-    """
-    This function change BaseNodeQuantizationConfig to a dictionary
-    Args:
-        quantization_config: A BaseNodeQuantizationConfig for serialization
-
-    Returns: A config dictionary of BaseNodeQuantizationConfig
-
-    """
-    config_data = {k: transform_enum(v) for k, v in quantization_config.__dict__.items() if
-                   v is not isinstance(v, Callable)}
-    config_data[IS_WEIGHTS] = isinstance(quantization_config, NodeWeightsQuantizationConfig)
-    return config_data
-
-
-def config_deserialization(in_config: dict) -> BaseNodeQuantizationConfig:
-    """
-    This function change config dictionary to it BaseNodeQuantizationConfig.
-    Args:
-        in_config:  A config dictionary of BaseNodeQuantizationConfig
-
-    Returns: A BaseNodeQuantizationConfig
-
-    """
-    in_config = copy.deepcopy(in_config)
-    qc = QuantizationConfig()
-    op_cfg = OpQuantizationConfig(QuantizationMethod.POWER_OF_TWO, QuantizationMethod.POWER_OF_TWO,
-                                  8, 8, True, True, True, True, 0, 0, 8)
-    if in_config[IS_WEIGHTS]:
-        nwqc = NodeWeightsQuantizationConfig(qc=qc,
-                                             op_cfg=op_cfg,
-                                             weights_quantization_fn=None,
-                                             weights_quantization_params_fn=None,
-                                             weights_channels_axis=0)
-        in_config[WEIGHTS_QUANTIZATION_METHOD] = QuantizationMethod(in_config[WEIGHTS_QUANTIZATION_METHOD])
-
-        nwqc.__dict__.update(in_config)
-        return nwqc
-    else:
-        raise NotImplemented

model_compression_toolkit/qunatizers_infrastructure/keras/keras_node_quantization_dispatcher.py

@@ -1,74 +0,0 @@
-from typing import Dict, List
-
-from model_compression_toolkit.core.common import Logger
-from model_compression_toolkit.core.common.constants import FOUND_TF
-from model_compression_toolkit.qunatizers_infrastructure.common.base_quantizer import BaseQuantizer
-from model_compression_toolkit.qunatizers_infrastructure.common.node_quantization_dispatcher import \
-    NodeQuantizationDispatcher
-
-if FOUND_TF:
-    ACTIVATION_QUANTIZERS = "activation_quantizers"
-    WEIGHT_QUANTIZERS = "weight_quantizer"
-    import tensorflow as tf
-
-    keras = tf.keras
-
-
-    class KerasNodeQuantizationDispatcher(NodeQuantizationDispatcher):
-        def __init__(self, weight_quantizers: Dict[str, BaseQuantizer] = None,
-                     activation_quantizers: List[BaseQuantizer] = None):
-            """
-            Keras Node quantization dispatcher collect all the quantizer of a given layer.
-            Add to functions get_config and from_config to enable saving and loading of keras models.
-            Args:
-                weight_quantizers: A dictionary between weight name to it quantizer .
-                activation_quantizers: A list of activation quantization one for each layer output.
-            """
-            super().__init__(weight_quantizers, activation_quantizers)
-
-        def get_config(self) -> dict:
-            """
-
-            Returns: Configuration of KerasNodeQuantizationDispatcher.
-
-            """
-            return {
-                ACTIVATION_QUANTIZERS: [keras.utils.serialize_keras_object(act) for act in self.activation_quantizers],
-                WEIGHT_QUANTIZERS: {k: keras.utils.serialize_keras_object(v) for k, v in
-                                    self.weight_quantizers.items()}}
-
-        @classmethod
-        def from_config(cls, config):
-            """
-
-            Args:
-                config(dict): dictonory  of  KerasNodeQuantizationDispatcher Configuration
-
-            Returns: A KerasNodeQuantizationDispatcher
-
-            """
-            config = config.copy()
-            activation_quantizers = [keras.utils.deserialize_keras_object(act,
-                                                                          module_objects=globals(),
-                                                                          custom_objects=None) for act in
-                                     config.get(ACTIVATION_QUANTIZERS)]
-            weight_quantizer = {k: keras.utils.deserialize_keras_object(v,
-                                                                        module_objects=globals(),
-                                                                        custom_objects=None) for k, v in
-                                config.get(WEIGHT_QUANTIZERS).items()}
-            return cls(weight_quantizer, activation_quantizers)
-else:
-    class KerasNodeQuantizationDispatcher(NodeQuantizationDispatcher):
-        def __init__(self, weight_quantizer: Dict[str, BaseQuantizer] = None,
-                     activation_quantizers: List[BaseQuantizer] = None):
-            """
-            Keras Node quantization dispatcher collect all the quantizer of a given layer.
-            Add to functions get_config and from_config to enable saving and loading of keras models.
-            Args:
-                weight_quantizers: A dictionary between weight name to it quantizer .
-                activation_quantizers: A list of activation quantization one for each layer output.
-            """
-            super().__init__(weight_quantizer, activation_quantizers)
-            Logger.critical('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                            'when using KerasNodeQuantizationDispatcher. '
-                            'Could not find Tensorflow package.')

model_compression_toolkit/qunatizers_infrastructure/keras/quantize_wrapper.py

@@ -1,194 +0,0 @@
-# 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.
-# ==============================================================================f
-
-
-from model_compression_toolkit.core.common.constants import FOUND_TF
-from model_compression_toolkit.core.common.logger import Logger
-from model_compression_toolkit.qunatizers_infrastructure.common.node_quantization_dispatcher import \
-    NodeQuantizationDispatcher
-
-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
-
-    DISPATCHER = "dispatcher"
-    LAYER = "layer"
-    STEPS = "optimizer_step"
-    TRAINING = "training"
-
-
-    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,
-                     dispatcher: NodeQuantizationDispatcher):
-            """
-            Keras Quantization Wrapper takes a keras layer and dispatcher and infer a quantized layer.
-
-            Args:
-                layer: A keras layer.
-                dispatcher: A node quantization dispatcher.
-            """
-            super(KerasQuantizationWrapper, self).__init__(layer)
-            self.dispatcher = dispatcher
-
-        def get_config(self):
-            """
-
-            Returns: Configuration of KerasQuantizationWrapper.
-
-            """
-            base_config = super(KerasQuantizationWrapper, self).get_config()
-            config = {DISPATCHER: keras.utils.serialize_keras_object(self.dispatcher)}
-            return dict(list(base_config.items()) + list(config.items()))
-
-        @classmethod
-        def from_config(cls, config):
-            """
-
-            Args:
-                config(dict): dictonory  of  KerasNodeQuantizationDispatcher Configuration
-
-            Returns: A KerasNodeQuantizationDispatcher
-
-            """
-            config = config.copy()
-
-            dispatcher = keras.utils.deserialize_keras_object(
-                config.pop(DISPATCHER),
-                module_objects=globals(),
-                custom_objects=None)
-
-            layer = tf.keras.layers.deserialize(config.pop(LAYER))
-
-            return cls(layer=layer, dispatcher=dispatcher)
-
-        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._weight_vars = []
-            for name, quantizer in self.dispatcher.weight_quantizers.items():
-                weight = getattr(self.layer, name)
-                quantizer.initialize_quantization(weight.shape,
-                                                  _weight_name(weight.name), self)
-
-                self._weight_vars.append((name, weight, quantizer))
-                # Needed to ensure unquantized weights get trained as part of the wrapper. ?? Nost sure
-                self._trainable_weights.append(weight)
-
-        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.dispatcher.weight_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 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 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._weight_vars:
-                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})
-
-            self.set_quantize_weights(quantized_weights)
-
-            args = tf_inspect.getfullargspec(self.layer.call).args
-            if TRAINING in args:
-                outputs = self.layer.call(inputs, training=training, **kwargs)
-            else:
-                outputs = self.layer.call(inputs, **kwargs)
-            return outputs
-
-else:
-    class KerasQuantizationWrapper(object):
-        def __init__(self, layer, dispatcher: NodeQuantizationDispatcher):
-            """
-            Keras Quantization Wrapper takes a keras layer and dispatcher and infer a quantized layer.
-
-            Args:
-                layer: A keras layer.
-                dispatcher: A node quantization dispatcher.
-            """
-            Logger.critical('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                            'when using KerasQuantizationWrapper. '
-                            'Could not find Tensorflow package.')