mct-nightly 1.8.0.20052023.post401__py3-none-any.whl → 1.8.0.20230610.post356__py3-none-any.whl

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/activation_inferable_quantizers/activation_lut_pot_inferable_quantizer.py

@@ -1,148 +0,0 @@
-# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-import warnings
-from typing import List
-
-import numpy as np
-
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.constants import FOUND_TF
-
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.quantizers_infrastructure import QuantizationTarget
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import MULTIPLIER_N_BITS, EPS
-
-if FOUND_TF:
-    import tensorflow as tf
-    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.quantizer_utils import lut_quantizer
-
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
-                    quantization_method=[QuantizationMethod.LUT_POT_QUANTIZER],
-                    quantizer_type=None)
-    class ActivationLutPOTInferableQuantizer(BaseKerasInferableQuantizer):
-        """
-        Class for quantizing activations using lut power-of-two quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     cluster_centers: np.ndarray,
-                     threshold: List[float],
-                     signed: bool,
-                     multiplier_n_bits: int = MULTIPLIER_N_BITS,
-                     eps: float = EPS):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                cluster_centers: the cluster centers to assign the activations
-                threshold: threshold for quantizing activations
-                signed: whether or not to use signed quantization
-                multiplier_n_bits: Number of bits that determines the quantization range
-                eps: Small value for numerical stability in division
-            """
-            # Call the superclass constructor with the given parameters, along with the target of Activation
-            # quantization
-            super(ActivationLutPOTInferableQuantizer, self).__init__()
-
-            assert isinstance(threshold, list), f'Expected threshold to be of type list but is {type(threshold)}'
-            assert all([isinstance(x, (float, np.float32, tf.float32)) for x in
-                        threshold]), f'Expected threshold list to contain float or np.float values but found ' \
-                                     f'{[type(x) for x in threshold]}'
-
-            # In activation per-channel quantization is not supported thus we expect a single threshold value.
-            assert len(threshold) == 1, f'In per-tensor quantization threshold should be of ' \
-                                        f'length 1 but is {len(threshold)}'
-
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in threshold])
-            assert is_threshold_pot, f'Expected threshold to be power of 2 but is {threshold}'
-
-            self.threshold = threshold[0]
-
-            assert len(np.unique(cluster_centers)) <= 2 ** num_bits, \
-                f'Expected num of cluster centers to be less or equal than {2 ** num_bits} ' \
-                f'but got {len(cluster_centers)}'
-
-            assert not np.any(cluster_centers - cluster_centers.astype(int)), f'Expected cluster centers to be integers'
-
-            if signed:
-                assert np.all((-1 * (2 ** (multiplier_n_bits - int(signed))) <= cluster_centers) &
-                              (cluster_centers <= (2 ** (multiplier_n_bits - int(signed)) - 1))), \
-                    f'Expected cluster centers in the quantization range'
-            else:
-                assert np.all(cluster_centers <= (2 ** multiplier_n_bits)), \
-                    f'Expected cluster centers in the quantization range'
-
-            # num_bits must be less than multiplier_n_bits
-            assert num_bits <= multiplier_n_bits, f'Look-Up-Table bit configuration has {num_bits} bits. It must be ' \
-                                                  f'less then {multiplier_n_bits}'
-            if num_bits == multiplier_n_bits:
-                warnings.warn("Num of bits equal to multiplier n bits, Please be aware LUT quantizier may be "
-                              "inefficient in that case, consider using SymmetricInferableQuantizer instead")
-
-            # If unsigned activation quantization, all cluster_centers must have the same sign
-            if not signed:
-                assert np.all(cluster_centers >= 0), f'Expected unsigned cluster centers in unsigned activation ' \
-                                                     f'quantization '
-
-            self.num_bits = num_bits
-            self.cluster_centers = cluster_centers
-            self.signed = signed
-            self.multiplier_n_bits = multiplier_n_bits
-            self.eps = eps
-
-        def __call__(self, inputs: tf.Tensor) -> tf.Tensor:
-            """
-            Quantize the given inputs using the quantizer parameters.
-
-            Args:
-                inputs: input tensor to quantize
-
-            Returns:
-                quantized tensor.
-            """
-            assert inputs.dtype == tf.float32, f'Input tensor was expected to be a float tensor but is of type ' \
-                                               f'{inputs.dtype}'
-
-            return lut_quantizer(inputs, cluster_centers=self.cluster_centers, signed=self.signed,
-                                 threshold=self.threshold, multiplier_n_bits=self.multiplier_n_bits, eps=self.eps)
-
-        def get_config(self):
-            """
-            Return a dictionary with the configuration of the quantizer.
-
-            Returns:
-                Dictionary with the following keys: 'num_bits', 'cluster_centers', 'threshold', 'signed',
-                'multiplier_n_bits', 'eps'
-            """
-            return {'num_bits': self.num_bits,
-                    'cluster_centers': self.cluster_centers,
-                    'threshold': self.threshold,
-                    'signed': self.signed,
-                    'multiplier_n_bits': self.multiplier_n_bits,
-                    'eps': self.eps}
-
-
-else:
-    class ActivationLutPOTInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                         'when using ActivationLutPOTInferableQuantizer. '
-                         'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/activation_inferable_quantizers/activation_pot_inferable_quantizer.py

@@ -1,65 +0,0 @@
-# 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 List
-
-import numpy as np
-
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.constants import FOUND_TF
-
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.quantizers_infrastructure import QuantizationTarget
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer
-
-
-if FOUND_TF:
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.activation_inferable_quantizers.activation_symmetric_inferable_quantizer \
-        import ActivationSymmetricInferableQuantizer
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
-                    quantization_method=[QuantizationMethod.POWER_OF_TWO],
-                    quantizer_type=None)
-    class ActivationPOTInferableQuantizer(ActivationSymmetricInferableQuantizer):
-        """
-        Class for quantizing activations using power-of-two quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     threshold: List[float],
-                     signed: bool):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                threshold: threshold for quantizing activations
-                signed: whether or not to use signed quantization
-            """
-            # Call the superclass constructor with the given parameters, along with the target of Activation
-            # quantization
-            super(ActivationPOTInferableQuantizer, self).__init__(num_bits=num_bits,
-                                                                  threshold=threshold,
-                                                                  signed=signed)
-
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in self.threshold.flatten()])
-            assert is_threshold_pot, f'Expected threshold to be power of 2 but is {self.threshold}'
-
-else:
-    class ActivationPOTInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                         'when using ActivationPOTInferableQuantizer. '
-                         'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/activation_inferable_quantizers/activation_symmetric_inferable_quantizer.py

@@ -1,86 +0,0 @@
-# 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 List
-
-import numpy as np
-
-from model_compression_toolkit.constants import FOUND_TF
-
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer, \
-    QuantizationTarget
-
-
-if FOUND_TF:
-    import tensorflow as tf
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.activation_inferable_quantizers.activation_uniform_inferable_quantizer \
-        import ActivationUniformInferableQuantizer
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
-                    quantization_method=[QuantizationMethod.SYMMETRIC],
-                    quantizer_type=None)
-    class ActivationSymmetricInferableQuantizer(ActivationUniformInferableQuantizer):
-
-        """
-        Class for quantizing activations using a symmetric quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     threshold: List[float],
-                     signed: bool):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                threshold: threshold for quantizing activations
-                signed: whether or not to use signed quantization
-            """
-            assert isinstance(threshold, list), f'Expected threshold to be of type list but is {type(threshold)}'
-            assert all([isinstance(x, (float, np.float32, tf.float32)) for x in
-                        threshold]), f'Expected threshold list to contain float or np.float values but found ' \
-                                     f'{[type(x) for x in threshold]}'
-
-            self.threshold = np.asarray(threshold)
-            self.signed = signed
-
-            delta = self.threshold / (2 ** (num_bits - int(self.signed)))
-            # In activation quantization is per-tensor only - thus we pass the threshold as a list with a len of 1
-            min_range = list(-self.threshold) if self.signed else [0.0]
-            max_range = list(self.threshold - delta)
-
-            super(ActivationSymmetricInferableQuantizer, self).__init__(num_bits=num_bits,
-                                                                        min_range=min_range,
-                                                                        max_range=max_range)
-
-        def get_config(self):
-            """
-            Return a dictionary with the configuration of the quantizer.
-
-            Returns:
-                Dictionary with the following keys: 'num_bits', 'signed', 'threshold'
-            """
-            return {'num_bits': self.num_bits,
-                    'signed': self.signed,
-                    'threshold': self.threshold}
-
-
-else:
-    class ActivationSymmetricInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                            'when using ActivationSymmetricInferableQuantizer. '
-                            'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/activation_inferable_quantizers/activation_uniform_inferable_quantizer.py

@@ -1,111 +0,0 @@
-# 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 List
-
-import numpy as np
-
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.constants import FOUND_TF
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.quantizers_infrastructure import QuantizationTarget
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.quant_utils import \
-    adjust_range_to_include_zero
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.validation_functions import \
-    validate_uniform_min_max_ranges, validate_adjusted_min_max_ranges
-
-if FOUND_TF:
-    import tensorflow as tf
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.base_keras_inferable_quantizer import BaseKerasInferableQuantizer
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Activation,
-                    quantization_method=[QuantizationMethod.UNIFORM],
-                    quantizer_type=None)
-    class ActivationUniformInferableQuantizer(BaseKerasInferableQuantizer):
-        """
-        Class for quantizing activations using an uniform quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     min_range: List[float],
-                     max_range: List[float],
-                     ):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                min_range: min range for quantizing activations
-                max_range: max range for quantizing activations
-            """
-            super(ActivationUniformInferableQuantizer, self).__init__()
-
-            # Validate ranges properties
-            validate_uniform_min_max_ranges(min_range,
-                                            max_range)
-
-            # In activation per-channel quantization is not supported thus we expect a single min/max value.
-            assert len(min_range) == 1, f'In per-tensor quantization min_range should be of length 1 but is {len(min_range)}'
-            assert len(max_range) == 1, f'In per-tensor quantization max_range should be of length 1 but is {len(max_range)}'
-
-            self.num_bits = num_bits
-
-            # Convert min/max to numpy arrays
-            min_range, max_range = np.asarray(min_range), np.asarray(max_range)
-            _min_range, _max_range = adjust_range_to_include_zero(min_range, max_range, num_bits)
-            validate_adjusted_min_max_ranges(min_range=min_range,
-                                             max_range=max_range,
-                                             adj_min=_min_range,
-                                             adj_max=_max_range)
-
-            self.max_range = _max_range[0]
-            self.min_range = _min_range[0]
-
-
-        def __call__(self, inputs:tf.Tensor) -> tf.Tensor:
-            """
-            Quantize the given inputs using the quantizer parameters.
-
-            Args:
-                inputs: input tensor to quantize
-
-            Returns:
-                quantized tensor.
-            """
-            assert inputs.dtype==tf.float32, f'Input tensor was expected to be a float tensor but is of type {inputs.dtype}'
-
-            return tf.quantization.fake_quant_with_min_max_vars(inputs,
-                                                                min=self.min_range,
-                                                                max=self.max_range,
-                                                                num_bits=self.num_bits)
-
-        def get_config(self):
-            """
-            Return a dictionary with the configuration of the quantizer.
-
-            Returns:
-                Dictionary with the following keys: 'num_bits', 'min_range', 'max_range'
-            """
-            return {'num_bits': self.num_bits,
-                    'min_range': self.min_range,
-                    'max_range': self.max_range}
-
-else:
-    class ActivationUniformInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                         'when using ActivationUniformInferableQuantizer. '
-                         'Could not find Tensorflow package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/base_keras_inferable_quantizer.py

@@ -1,56 +0,0 @@
-# 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 abc import abstractmethod
-
-from model_compression_toolkit.constants import FOUND_TF
-from model_compression_toolkit.quantizers_infrastructure import BaseInferableQuantizer
-
-if FOUND_TF:
-    import tensorflow as tf
-
-    class BaseKerasInferableQuantizer(BaseInferableQuantizer):
-        def __init__(self):
-            """
-            This class is a base quantizer for Keras quantizers for inference only.
-            """
-            super(BaseKerasInferableQuantizer, self).__init__()
-
-        @abstractmethod
-        def get_config(self):
-            """
-            Return a dictionary with the configuration of the quantizer.
-            """
-            raise NotImplemented(f'{self.__class__.__name__} did not implement get_config')  # pragma: no cover
-
-        @abstractmethod
-        def __call__(self, inputs: tf.Tensor):
-            """
-            Quantize the given inputs using the quantizer parameters.
-
-            Args:
-                inputs: input tensor to quantize
-
-            Returns:
-                quantized tensor.
-            """
-            raise NotImplemented(f'{self.__class__.__name__} did not implement __call__')  # pragma: no cover
-else:
-    class BaseKerasInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                            'when using BaseKerasInferableQuantizer. '
-                            'Could not find Tensorflow package.')
-
-

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/weights_inferable_quantizers/__init__.py

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

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/keras/quantizers/weights_inferable_quantizers/weights_lut_pot_inferable_quantizer.py

@@ -1,79 +0,0 @@
-# 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 List
-
-import numpy as np
-
-from model_compression_toolkit.constants import FOUND_TF
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import mark_quantizer, \
-    QuantizationTarget
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.constants import MULTIPLIER_N_BITS, EPS
-
-if FOUND_TF:
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.keras.quantizers.weights_inferable_quantizers.\
-        weights_lut_symmetric_inferable_quantizer import WeightsLUTSymmetricInferableQuantizer
-
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
-                    quantization_method=[QuantizationMethod.LUT_POT_QUANTIZER],
-                    quantizer_type=None)
-    class WeightsLUTPOTInferableQuantizer(WeightsLUTSymmetricInferableQuantizer):
-        """
-        Class for quantizing weights using a lut power-of-two quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     cluster_centers: np.ndarray,
-                     threshold: List[float],
-                     per_channel: bool,
-                     channel_axis: int = None,
-                     input_rank: int = None,
-                     multiplier_n_bits: int = MULTIPLIER_N_BITS,
-                     eps: float = EPS):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                cluster_centers: the cluster centers to assign the weights
-                threshold: threshold for quantizing weights
-                per_channel: whether to use per-channel quantization
-                channel_axis: axis along which to apply per-channel quantization
-                input_rank: number of dimensions of input tensor the quantizer quantizes
-                multiplier_n_bits: Number of bits that determines the quantization range
-                eps: Small value for numerical stability in division
-            """
-
-            super(WeightsLUTPOTInferableQuantizer, self).__init__(num_bits=num_bits,
-                                                                  cluster_centers=cluster_centers,
-                                                                  threshold=threshold,
-                                                                  per_channel=per_channel,
-                                                                  channel_axis=channel_axis,
-                                                                  input_rank=input_rank,
-                                                                  multiplier_n_bits=multiplier_n_bits,
-                                                                  eps=eps)
-
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in self.threshold.flatten()])
-            assert is_threshold_pot, f'Expected threshold to be power of 2 but is {self.threshold}'
-
-
-else:
-    class WeightsLUTPOTInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            raise Exception('Installing tensorflow and tensorflow_model_optimization is mandatory '
-                            'when using WeightsLUTPOTInferableQuantizer. '
-                            'Could not find Tensorflow package.')