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

model_compression_toolkit/qat/keras/qat_model_builder.py

@@ -1,105 +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.
-# ==============================================================================
-
-from typing import List
-from tensorflow.keras.layers import Layer
-from tensorflow.python.util.object_identity import Reference as TFReference
-
-from model_compression_toolkit import get_target_platform_capabilities
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common import BaseNode
-from model_compression_toolkit.core.common.constants import TENSORFLOW
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
-
-from model_compression_toolkit.core.keras.back2framework.keras_model_builder import KerasModelBuilder
-from model_compression_toolkit.core.keras.constants import DEFAULT_TP_MODEL
-from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
-from model_compression_toolkit.qat.keras.quantizer.quantization_dispatcher_builder import \
-    quantization_dispatcher_builder
-from model_compression_toolkit import qunatizers_infrastructure as qi
-
-DEFAULT_KERAS_TPC = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
-
-
-def _is_qat_applicable(node: common.BaseNode,
-                       fw_info: FrameworkInfo) -> bool:
-    """
-    A function for deciding if a layer should be fine-tuned during QAT
-    Args:
-        node (BaseNode): Node for quantization decision
-        fw_info (FrameworkInfo): Keras quantization information
-
-    Returns:
-        A boolean whether the layer is to be wrapped with a QuantizeWrapper
-    """
-
-    return fw_info.is_kernel_op(node.type) and node.is_weights_quantization_enabled()
-
-
-def qat_wrapper(n: common.BaseNode, layer: Layer):
-    """
-    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
-
-    """
-    if _is_qat_applicable(n, DEFAULT_KERAS_INFO):
-        return qi.KerasQuantizationWrapper(layer, quantization_dispatcher_builder(n, DEFAULT_KERAS_INFO))
-    else:
-        return layer
-
-
-class QATKerasModelBuilder(KerasModelBuilder):
-    """
-    Builder of QAT Keras models.
-    """
-
-    def __init__(self,
-                 graph: common.Graph,
-                 append2output=None,
-                 fw_info: FrameworkInfo = DEFAULT_KERAS_INFO,
-                 return_float_outputs: bool = False):
-        """
-
-        Args:
-            graph: Graph to build the model from.
-            append2output: Nodes to append to model's output.
-            fw_info: Information about the specific framework of the model that is built.
-            return_float_outputs: Whether the model returns float tensors or not.
-        """
-        super().__init__(graph,
-                         append2output,
-                         fw_info,
-                         return_float_outputs,
-                         wrapper=qat_wrapper)
-
-    def _quantize_node_activations(self,
-                                   node: BaseNode,
-                                   input_tensors: List[TFReference]) -> List[TFReference]:
-        """
-        Quantize node's activation given input tensors.
-
-        Args:
-            node: Node to quantize its outputs.
-            input_tensors: Input tensors of the node.
-
-        Returns:
-            Output of the node.
-
-        """
-        return node.final_activation_quantization_cfg.quantize_node_output(input_tensors)

model_compression_toolkit/qat/keras/quantizer/quantization_dispatcher_builder.py

@@ -1,56 +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.
-# ==============================================================================
-
-
-from typing import Dict
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
-from model_compression_toolkit import qunatizers_infrastructure as qi
-from model_compression_toolkit.qat.keras.quantizer.ste_rounding.symmetirc_ste import STEWeightQuantizer
-from model_compression_toolkit.qat.keras.quantizer.ste_rounding.uniform_ste import STEUniformWeightQuantizer
-
-METHOD2QUANTIZER = {qi.QuantizationMethod.SYMMETRIC: STEWeightQuantizer,
-                    qi.QuantizationMethod.POWER_OF_TWO: STEWeightQuantizer,
-                    qi.QuantizationMethod.UNIFORM: STEUniformWeightQuantizer}
-
-
-def quantization_dispatcher_builder(n: common.BaseNode,
-                                    fw_info: FrameworkInfo,
-                                    method2quantizer: Dict[
-                                        qi.QuantizationMethod, qi.BaseKerasQuantizer] = METHOD2QUANTIZER) -> qi.KerasNodeQuantizationDispatcher:
-    """
-    Build a NodeQuantizationDispatcher for a node according to its quantization configuration and
-    a global NoOpQuantizeConfig object.
-
-    Args:
-        n: Node to build its QuantizeConfig.
-        fw_info: Framework information (e.g., mapping from layers to their attributes to quantize).
-        method2quantizer: A mapping between quantization method to quantizer.
-
-    Returns:
-        A QuantizeConfig object with the appropriate quantizers (according to the node's
-        quantization configuration).
-    """
-    nqd = qi.KerasNodeQuantizationDispatcher()
-    if n.is_weights_quantization_enabled():
-        attributes = fw_info.get_kernel_op_attributes(n.type)
-        for attr in attributes:
-            qunatizer_class = method2quantizer.get(n.final_weights_quantization_cfg.weights_quantization_method)
-            if qunatizer_class is None:
-                common.Logger.error(
-                    f'Unknown Quantiztion method: {n.final_weights_quantization_cfg.weights_quantization_method}')
-            nqd.add_weight_quantizer(attr, qunatizer_class(n.final_weights_quantization_cfg))
-
-    return nqd

model_compression_toolkit/qat/keras/quantizer/ste_rounding/symmetirc_ste.py

@@ -1,145 +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.
-# ==============================================================================
-
-from typing import Dict
-
-import numpy as np
-import tensorflow as tf
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapper
-from tensorflow.python.framework.tensor_shape import TensorShape
-
-from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig
-
-from model_compression_toolkit.core.common.target_platform import QuantizationMethod
-from model_compression_toolkit.qat.common import THRESHOLD_TENSOR
-from model_compression_toolkit.qat.common.constants import FQ_MIN, FQ_MAX
-from model_compression_toolkit import qunatizers_infrastructure as qi
-from model_compression_toolkit.core.common import constants as C
-
-
-class STEWeightQuantizer(qi.BaseKerasQuantizer):
-    """
-    Trainable constrained quantizer to quantize a layer inputs.
-    """
-
-    def __init__(self, quantization_config: NodeWeightsQuantizationConfig):
-        """
-        Initialize a TrainableWeightQuantizer object with parameters to use
-        for the quantization.
-
-        Args:
-            quantization_config: node quantization config class
-        """
-        super().__init__(quantization_config,
-                         qi.QuantizationTarget.Weights,
-                         [qi.QuantizationMethod.POWER_OF_TWO, qi.QuantizationMethod.SYMMETRIC])
-        self.power_of_two = quantization_config.weights_quantization_method == QuantizationMethod.POWER_OF_TWO
-        self.threshold_values = quantization_config.weights_quantization_params[C.THRESHOLD]
-        self.threshold_shape = np.asarray(self.threshold_values).shape
-        self.np_threshold_values = np.reshape(np.asarray(self.threshold_values),
-                                              [-1]) if self.quantization_config.weights_channels_axis else float(
-            self.threshold_values)
-
-        if self.quantization_config.weights_per_channel_threshold and self.quantization_config.weights_channels_axis not in [
-            -1, len(self.threshold_shape) - 1]:
-            # Tensorflow's fake_quant_with_min_max_vars_per_channel only works on last axis, so
-            # need to move the quantization axis to the last axis
-            self.perm_vec = list(np.arange(len(self.threshold_shape)))
-            self.perm_vec[self.quantization_config.weights_channels_axis] = len(self.threshold_shape) - 1
-            self.perm_vec[len(self.threshold_shape) - 1] = self.quantization_config.weights_channels_axis
-        else:
-            self.perm_vec = None
-
-        if self.power_of_two:
-            self.np_threshold_values = np.power(2.0,
-                                                np.ceil(np.log2(np.maximum(self.np_threshold_values, C.MIN_THRESHOLD))))
-        num_bits = self.quantization_config.weights_n_bits
-        delta = self.np_threshold_values / np.power(2.0, num_bits - int(C.WEIGHTS_SIGNED))
-        min_int = -int(C.WEIGHTS_SIGNED) * (2 ** (num_bits - int(C.WEIGHTS_SIGNED)))
-        max_int = (2 ** (num_bits - int(C.WEIGHTS_SIGNED))) - 1
-        self.min = delta * min_int
-        self.max = delta * max_int
-        self.quantizer_parameters = {}
-
-    def initialize_quantization(self,
-                                tensor_shape: TensorShape,
-                                name: str,
-                                layer: QuantizeWrapper) -> Dict[str, tf.Variable]:
-        """
-        Add min and max variables to layer.
-        Args:
-            tensor_shape: Tensor shape the quantizer quantize.
-            name: Prefix of variables names.
-            layer: Layer to add the variables to. The variables are saved
-            in the layer's scope.
-
-        Returns:
-            Dictionary of new variables.
-        """
-        ptq_threshold_tensor = layer.add_weight(
-            name + THRESHOLD_TENSOR,
-            shape=len(self.np_threshold_values) if self.quantization_config.weights_channels_axis else (),
-            initializer=tf.keras.initializers.Constant(1.0),
-            trainable=False)
-        ptq_threshold_tensor.assign(self.np_threshold_values)
-
-        fq_min = layer.add_weight(
-            name + FQ_MIN,
-            shape=len(self.min) if self.quantization_config.weights_channels_axis else (),
-            initializer=tf.keras.initializers.Constant(-1.0),
-            trainable=False)
-        fq_min.assign(self.min)
-
-        fq_max = layer.add_weight(
-            name + FQ_MAX,
-            shape=len(self.max) if self.quantization_config.weights_channels_axis else (),
-            initializer=tf.keras.initializers.Constant(1.0),
-            trainable=False)
-        fq_max.assign(self.max)
-
-        # save the quantizer added parameters for later calculations
-        self.quantizer_parameters = {THRESHOLD_TENSOR: ptq_threshold_tensor,
-                                     FQ_MIN: fq_min, FQ_MAX: fq_max}
-        return self.quantizer_parameters
-
-    def __call__(self,
-                 inputs: tf.Tensor,
-                 training: bool):
-        """
-        Quantize a tensor.
-        Args:
-            inputs: Input tensor to quantize.
-            training: Whether the graph is in training mode.
-            weights: Dictionary of weights the quantizer can use to quantize the tensor.
-            **kwargs: Additional variables the quantizer may receive.
-
-        Returns:
-            The quantized tensor.
-        """
-
-        _min = self.quantizer_parameters[FQ_MIN]
-        _max = self.quantizer_parameters[FQ_MAX]
-        if self.quantization_config.weights_channels_axis:
-            if self.perm_vec:
-                inputs = tf.transpose(inputs, perm=self.perm_vec)
-            q_tensor = tf.quantization.fake_quant_with_min_max_vars_per_channel(inputs, _min, _max,
-                                                                                num_bits=self.quantization_config.weights_n_bits)
-            if self.perm_vec:
-                q_tensor = tf.transpose(q_tensor, perm=self.perm_vec)
-        else:
-            q_tensor = tf.quantization.fake_quant_with_min_max_vars(inputs, _min, _max,
-                                                                    num_bits=self.quantization_config.weights_n_bits)
-
-        return q_tensor

model_compression_toolkit/qunatizers_infrastructure/__init__.py

@@ -1,8 +0,0 @@
-from model_compression_toolkit.qunatizers_infrastructure.common.base_quantizer import QuantizationTarget, \
-    QuantizationMethod
-
-from model_compression_toolkit.qunatizers_infrastructure.keras.quantize_wrapper import KerasQuantizationWrapper
-from model_compression_toolkit.qunatizers_infrastructure.keras.base_keras_quantizer import BaseKerasQuantizer
-from model_compression_toolkit.qunatizers_infrastructure.keras.load_model import keras_load_quantized_model
-from model_compression_toolkit.qunatizers_infrastructure.keras.keras_node_quantization_dispatcher import \
-    KerasNodeQuantizationDispatcher

model_compression_toolkit/qunatizers_infrastructure/common/__init__.py

@@ -1,14 +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.
-# ==============================================================================

model_compression_toolkit/qunatizers_infrastructure/common/base_quantizer.py

@@ -1,123 +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.
-# ==============================================================================
-
-from typing import List
-from enum import Enum
-
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
-    NodeActivationQuantizationConfig, BaseNodeQuantizationConfig
-from model_compression_toolkit.core.common.target_platform import QuantizationMethod
-
-
-class QuantizationTarget(Enum):
-    Activation = 0
-    Weights = 1
-
-
-class BaseQuantizer:
-    def __init__(self,
-                 quantization_config: BaseNodeQuantizationConfig,
-                 quantization_target: QuantizationTarget,
-                 quantization_method: List[QuantizationMethod]):
-        """
-        This class is a base quantizer which validate the the provide quantization config and define abstract function which any quantizer need to implment.
-
-        Args:
-            quantization_config: node quantization config class contins all the information above a quantizer.
-            quantization_target: A enum which decided the qunaizer tensor type activation or weights.
-            quantization_method: A list of "QuantizationMethod" enums which represent the quantizer supported methods.
-        """
-        self.quantization_config = quantization_config
-        self.quantization_target = quantization_target
-        self.quantization_method = quantization_method
-        if self.quantization_target == QuantizationTarget.Weights:
-            self.validate_weights()
-            if self.quantization_config.weights_quantization_method not in quantization_method:
-                common.Logger.error(
-                    f'Quantization method mismatch expected:{quantization_method} and got  {self.quantization_config.weights_quantization_method}')
-        elif self.quantization_target == QuantizationTarget.Activation:
-            self.validate_activation()
-            if self.quantization_config.activation_quantization_method not in quantization_method:
-                common.Logger.error(
-                    f'Quantization method mismatch expected:{quantization_method} and got  {self.quantization_config.activation_quantization_method}')
-        else:
-            common.Logger.error(
-                f'Unknown Quantization Part:{quantization_target}')
-
-    def initialize_quantization(self,
-                                tensor_shape,
-                                name: str,
-                                layer):
-        """
-        This initializes the quantizer parameters given the parameter name and shape.
-
-        Args:
-            tensor_shape:  tensor shape
-            name: tensor name
-            layer: layer to quantized
-
-        Returns: None
-
-        """
-        raise NotImplemented
-
-    def __call__(self,
-                 input2quantize,
-                 training: bool):
-        """
-        Quantize a tensor.
-
-        Args:
-            input2quantize: Input tensor to quantize.
-            training: Whether the graph is in training mode.
-
-        Returns:
-            The quantized tensor.
-        """
-        raise NotImplemented
-
-    def activation_quantization(self) -> bool:
-        """
-
-        Returns: A boolean stating is this activation quantizer
-
-        """
-        return isinstance(self.quantization_config, NodeActivationQuantizationConfig)
-
-    def weights_quantization(self) -> bool:
-        """
-
-        Returns: A boolean stating is this weights quantizer
-
-        """
-        return isinstance(self.quantization_config, NodeWeightsQuantizationConfig)
-
-    def validate_weights(self) -> None:
-        """
-        This function valid the quantize config compare with it parameters.
-
-
-        """
-        if self.activation_quantization() or not self.weights_quantization():
-            common.Logger.error(f'Expect weight quantization got activation')
-
-    def validate_activation(self) -> None:
-        """
-        This function valid the quantize config compare with it parameters.
-
-        """
-        if not self.activation_quantization() or self.weights_quantization():
-            common.Logger.error(f'Expect activation quantization got weight')

model_compression_toolkit/qunatizers_infrastructure/common/node_quantization_dispatcher.py

@@ -1,65 +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.
-# ==============================================================================
-
-from typing import Dict, List
-
-from model_compression_toolkit.qunatizers_infrastructure.common.base_quantizer import BaseQuantizer
-
-
-class NodeQuantizationDispatcher:
-    def __init__(self,
-                 weight_quantizers: Dict[str, BaseQuantizer] = None,
-                 activation_quantizers: List[BaseQuantizer] = None):
-        """
-        Node quantization dispatcher collects all the quantizer of a given layer.
-
-        Args:
-            weight_quantizers: A dictionary between weight name to it quantizer .
-            activation_quantizers: A list of activation quantization one for each layer output.
-        """
-        self.weight_quantizers = weight_quantizers if weight_quantizers is not None else dict()
-        self.activation_quantizers = activation_quantizers if activation_quantizers is not None else list()
-
-    def add_weight_quantizer(self, param_name: str, quantizer: BaseQuantizer):
-        """
-        This function add a weight quantizer to existing node dispatcher
-
-        Args:
-            param_name: The name of the parameter to quantize
-            quantizer: A quantizer.
-
-        Returns: None
-
-        """
-        self.weight_quantizers.update({param_name: quantizer})
-
-    @property
-    def is_activation_quantization(self) -> bool:
-        """
-        This function check activation quantizer exists in dispatcher.
-        Returns: a boolean if activation quantizer exists
-
-        """
-        return len(self.activation_quantizers) > 0
-
-    @property
-    def is_weights_quantization(self) -> bool:
-        """
-        This function check weights quantizer exists in dispatcher.
-
-        Returns: a boolean if weights quantizer exists
-
-        """
-        return len(self.weight_quantizers) > 0

model_compression_toolkit/qunatizers_infrastructure/keras/__init__.py

@@ -1,14 +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.
-# ==============================================================================

model_compression_toolkit/qunatizers_infrastructure/keras/base_keras_quantizer.py

@@ -1,75 +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.
-# ==============================================================================
-from typing import Dict, Any, List
-
-from model_compression_toolkit.core.common import Logger
-from model_compression_toolkit.core.common.constants import FOUND_TF
-from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig
-from model_compression_toolkit.core.common.target_platform import QuantizationMethod
-
-from model_compression_toolkit.qunatizers_infrastructure.common.base_quantizer import BaseQuantizer, QuantizationTarget
-
-if FOUND_TF:
-    QUANTIZATION_CONFIG = 'qunatization_config'
-    from model_compression_toolkit.qunatizers_infrastructure.keras.config_serialization import config_serialization, \
-        config_deserialization
-
-
-    class BaseKerasQuantizer(BaseQuantizer):
-        def __init__(self,
-                     quantization_config: BaseNodeQuantizationConfig,
-                     quantization_target: QuantizationTarget,
-                     quantization_method: List[QuantizationMethod]):
-            """
-            This class is a base quantizer which validate the provide quantization config and define abstract function which any quantizer need to implment.
-            This class add to the base quantizer get_config and from_config function to enable keras load and save model.
-            Args:
-                quantization_config: node quantization config class contins all the information above a quantizer.
-                quantization_target: A enum which decided the qunaizer tensor type activation or weights.
-                quantization_method: A list of enums which represent the quantizer supported methods.
-            """
-            super().__init__(quantization_config, quantization_target, quantization_method)
-
-        def get_config(self) -> Dict[str, Any]:
-            """
-
-            Returns: Configuration of BaseKerasQuantizer.
-
-            """
-            return {QUANTIZATION_CONFIG: config_serialization(self.quantization_config)}
-
-        @classmethod
-        def from_config(cls, config: dict):
-            """
-
-            Args:
-                config(dict): dictonory  of  BaseKerasQuantizer Configuration
-
-            Returns: A BaseKerasQuantizer
-
-            """
-            config = config.copy()
-            quantization_config = config_deserialization(config[QUANTIZATION_CONFIG])
-            # Note that a quantizer only receive quantization config and the rest of define hardcoded inside the speficie quantizer.
-            return cls(quantization_config=quantization_config)
-
-else:
-    class BaseKerasQuantizer(BaseQuantizer):
-        def __init__(self, quantization_config: BaseNodeQuantizationConfig, quantization_target: QuantizationTarget,
-                     quantization_method: List[QuantizationMethod]):
-            super().__init__(quantization_config, quantization_target, quantization_method)
-            Logger.critical('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                            'when using BaseKerasQuantizer. '
-                            'Could not find Tensorflow package.')