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/pytorch/quantizers/weights_inferable_quantizers/weights_lut_symmetric_inferable_quantizer.py

@@ -1,106 +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 numpy as np
-
-from model_compression_toolkit.constants import FOUND_TORCH
-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_TORCH:
-    import torch
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizer_utils \
-        import to_torch_tensor, get_working_device, lut_quantizer
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers \
-        .base_lut_symmetric_inferable_quantizer import BaseLUTSymmetricInferableQuantizer
-
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
-                    quantization_method=[QuantizationMethod.LUT_SYM_QUANTIZER],
-                    quantizer_type=None)
-    class WeightsLUTSymmetricInferableQuantizer(BaseLUTSymmetricInferableQuantizer):
-        """
-        Class for quantizing weights using a lut symmetric quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     cluster_centers: np.ndarray,
-                     threshold: np.ndarray,
-                     per_channel: bool,
-                     channel_axis: 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 of input to apply per-channel quantization on
-                multiplier_n_bits: Number of bits that determines the quantization range
-                eps: Small value for numerical stability in division
-            """
-
-            super(WeightsLUTSymmetricInferableQuantizer, self).__init__(threshold=threshold,
-                                                                        num_bits=num_bits,
-                                                                        cluster_centers=cluster_centers,
-                                                                        signed=True,
-                                                                        multiplier_n_bits=multiplier_n_bits,
-                                                                        eps=eps)
-
-            if per_channel:
-                assert channel_axis is not None, f'Channel axis is missing in per channel quantization'
-                assert len(
-                    threshold) >= 1, f'In per-channel quantization threshold should be of length >= 1 but is ' \
-                                     f'{len(threshold)}'
-            else:
-                assert len(
-                    threshold) == 1, f'In per-tensor quantization threshold should be of length 1 but is ' \
-                                     f'{len(threshold)}'
-
-            self.per_channel = per_channel
-            self.channel_axis = channel_axis
-
-            self.threshold = to_torch_tensor(self.threshold).to(get_working_device())
-            self.cluster_centers = to_torch_tensor(self.cluster_centers).to(get_working_device())
-
-        def __call__(self, inputs: torch.Tensor) -> torch.Tensor:
-            """
-            Quantize the given inputs using the quantizer parameters.
-
-            Args:
-                inputs: input tensor to quantize
-
-            Returns:
-                quantized tensor.
-            """
-            inputs.requires_grad = False
-            return lut_quantizer(inputs, cluster_centers=self.cluster_centers, signed=True,
-                                 threshold=self.threshold, multiplier_n_bits=self.multiplier_n_bits, eps=self.eps)
-
-
-else:
-    class WeightsLUTSymmetricInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            raise Exception('Installing torch is mandatory '
-                            'when using WeightsLUTSymmetricInferableQuantizer. '
-                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/weights_inferable_quantizers/weights_pot_inferable_quantizer.py

@@ -1,66 +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 numpy as np
-
-from model_compression_toolkit.constants import FOUND_TORCH
-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_TORCH:
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.weights_inferable_quantizers.weights_symmetric_inferable_quantizer import \
-        WeightsSymmetricInferableQuantizer
-
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
-                    quantization_method=[QuantizationMethod.POWER_OF_TWO],
-                    quantizer_type=None)
-    class WeightsPOTInferableQuantizer(WeightsSymmetricInferableQuantizer):
-        """
-        Class for quantizing weights using power-of-two quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     threshold: np.ndarray,
-                     per_channel: bool,
-                     channel_axis: int = None
-                     ):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                threshold: threshold for quantizing activations
-                per_channel: whether to use per-channel quantization
-                channel_axis: Axis of input to apply per-channel quantization on.
-            """
-            # target of Weights quantization
-            super(WeightsPOTInferableQuantizer, self).__init__(num_bits=num_bits,
-                                                               threshold=threshold,
-                                                               per_channel=per_channel,
-                                                               channel_axis=channel_axis)
-
-            is_threshold_pot = np.all(np.round(np.log2(threshold.flatten()))==np.log2(threshold.flatten()))
-            assert is_threshold_pot, f'Expected threshold to be power of 2 but is {threshold}'
-
-
-else:
-    class WeightsPOTInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            raise Exception('Installing torch is mandatory '
-                            'when using WeightsPOTInferableQuantizer. '
-                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/weights_inferable_quantizers/weights_symmetric_inferable_quantizer.py

@@ -1,104 +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 numpy as np
-
-from model_compression_toolkit.constants import FOUND_TORCH
-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_TORCH:
-    import torch
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizer_utils import to_torch_tensor, \
-        get_working_device
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_symmetric_inferable_quantizer import \
-        BaseSymmetricInferableQuantizer
-
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
-                    quantization_method=[QuantizationMethod.SYMMETRIC],
-                    quantizer_type=None)
-    class WeightsSymmetricInferableQuantizer(BaseSymmetricInferableQuantizer):
-        """
-        Class for quantizing weights using a symmetric quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     threshold: np.ndarray,
-                     per_channel: bool,
-                     channel_axis: int = None
-                     ):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                threshold: threshold for quantizing weights
-                per_channel: whether to use per-channel quantization
-                channel_axis: Axis of input to apply per-channel quantization on.
-            """
-
-            super(WeightsSymmetricInferableQuantizer, self).__init__(threshold=threshold,
-                                                                     num_bits=num_bits,
-                                                                     signed=True)
-
-            if per_channel:
-                assert channel_axis is not None, f'Channel axis is missing in per channel quantization'
-                assert len(
-                    threshold) >= 1, f'In per-channel quantization threshold should be of length >= 1 but is ' \
-                                     f'{len(threshold)}'
-            else:
-                assert len(
-                    threshold) == 1, f'In per-tensor quantization threshold should be of length 1 but is {len(threshold)}'
-
-            self.per_channel = per_channel
-            self.channel_axis = channel_axis
-
-            self.scales = to_torch_tensor(self.scales).to(get_working_device())
-            self.zero_points = torch.zeros(len(threshold), dtype=torch.int32).to(get_working_device())
-
-        def __call__(self, inputs: torch.Tensor) -> torch.Tensor:
-            """
-            Quantize the given inputs using the quantizer parameters.
-
-            Args:
-                inputs: input tensor to quantize
-
-            Returns:
-                quantized tensor.
-            """
-            inputs.requires_grad = False
-            if self.per_channel:
-                return torch.fake_quantize_per_channel_affine(inputs,
-                                                              self.scales,
-                                                              self.zero_points,
-                                                              axis=self.channel_axis,
-                                                              quant_min=self.min_quantized_domain,
-                                                              quant_max=self.max_quantized_domain)
-            return torch.fake_quantize_per_tensor_affine(inputs,
-                                                         self.scales,
-                                                         self.zero_points,
-                                                         quant_min=self.min_quantized_domain,
-                                                         quant_max=self.max_quantized_domain)
-
-
-else:
-    class WeightsSymmetricInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            raise Exception('Installing torch is mandatory '
-                            'when using WeightsSymmetricInferableQuantizer. '
-                            'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/inferable_infrastructure/pytorch/quantizers/weights_inferable_quantizers/weights_uniform_inferable_quantizer.py

@@ -1,109 +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 numpy as np
-
-from model_compression_toolkit.constants import FOUND_TORCH
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import QuantizationTarget, \
-    mark_quantizer
-
-if FOUND_TORCH:
-    import torch
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizer_utils import get_working_device, \
-    fix_range_to_include_zero, to_torch_tensor
-    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers.base_uniform_inferable_quantizer import \
-        BaseUniformInferableQuantizer
-
-
-    @mark_quantizer(quantization_target=QuantizationTarget.Weights,
-                    quantization_method=[QuantizationMethod.UNIFORM],
-                    quantizer_type=None)
-    class WeightsUniformInferableQuantizer(BaseUniformInferableQuantizer):
-        """
-        Class for quantizing weights using a uniform quantizer
-        """
-
-        def __init__(self,
-                     num_bits: int,
-                     min_range: np.ndarray,
-                     max_range: np.ndarray,
-                     per_channel: bool,
-                     channel_axis: int = None
-                     ):
-            """
-            Initialize the quantizer with the specified parameters.
-
-            Args:
-                num_bits: number of bits to use for quantization
-                min_range: min quantization range for quantizing weights
-                max_range: max quantization range for quantizing weights
-                per_channel: whether to use per-channel quantization
-                channel_axis: Axis of input to apply per-channel quantization on.
-            """
-            super(WeightsUniformInferableQuantizer, self).__init__(num_bits=num_bits,
-                                                                   min_range=min_range,
-                                                                   max_range=max_range)
-
-            # Align mix/max numpy arrays so they are torch Tensors on the working device
-            min_range = to_torch_tensor(min_range).to(get_working_device())
-            max_range = to_torch_tensor(max_range).to(get_working_device())
-
-            self.per_channel = per_channel
-            self.channel_axis = channel_axis
-
-            min_range, max_range = fix_range_to_include_zero(min_range,
-                                                             max_range,
-                                                             num_bits)
-            # Compute the step size of quantized values.
-            self.scales = (max_range - min_range) / (2 ** num_bits - 1)
-            self.zero_points = -(
-                        min_range / self.scales).int()  # zp has to be positive, and a <=0, so we multiply by -1
-
-            self.scales = self.scales.to(get_working_device())
-            self.zero_points = self.zero_points.to(get_working_device())
-
-        def __call__(self,
-                     inputs: torch.Tensor) -> torch.Tensor:
-            """
-            Weight fake quantizer
-            Args:
-                inputs: weights to quantize.
-
-            Returns:
-                quantized weights
-            """
-            inputs.requires_grad = False
-            if self.per_channel:
-                return torch.fake_quantize_per_channel_affine(inputs,
-                                                              self.scales.flatten(),
-                                                              self.zero_points.flatten(),
-                                                              axis=self.channel_axis,
-                                                              quant_min=self.min_quantized_domain,
-                                                              quant_max=self.max_quantized_domain)
-            return torch.fake_quantize_per_tensor_affine(inputs,
-                                                         self.scales,
-                                                         self.zero_points,
-                                                         quant_min=self.min_quantized_domain,
-                                                         quant_max=self.max_quantized_domain)
-
-
-else:
-    class WeightsUniformInferableQuantizer:  # pragma: no cover
-        def __init__(self, *args, **kwargs):
-            Logger.error('Installing torch is mandatory '
-                         'when using WeightsUniformInferableQuantizer. '
-                         'Could not find torch package.')

model_compression_toolkit/quantizers_infrastructure/trainable_infrastructure/__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/trainable_infrastructure/common/__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/trainable_infrastructure/keras/__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/trainable_infrastructure/pytorch/__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.
-# ==============================================================================