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

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

@@ -1,66 +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 Any
-
-from tensorflow_model_optimization.python.core.quantization.keras.default_8bit.default_8bit_quantize_configs import \
-    NoOpQuantizeConfig
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_config import QuantizeConfig
-
-from model_compression_toolkit.core.common import BaseNode
-from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
-from model_compression_toolkit.exporter.model_wrapper.keras.builder.quantizer_to_node import \
-    get_weights_quantizer_for_node, get_activations_quantizer_for_node
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.activation_quantize_config import \
-    ActivationQuantizeConfig
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.weights_activation_quantize_config \
-    import \
-    WeightsActivationQuantizeConfig
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.weights_quantize_config import \
-    WeightsQuantizeConfig
-
-SUPPORTED_QUANTIZATION_CONFIG = [WeightsQuantizeConfig,
-                                 ActivationQuantizeConfig,
-                                 NoOpQuantizeConfig,
-                                 WeightsActivationQuantizeConfig]
-
-
-def get_quantization_config(node: BaseNode) -> QuantizeConfig:
-    """
-    Create a QuantizeConfig to wrap a layer for its corresponding node.
-
-    Args:
-        node: Node to create a QuantizeConfig for.
-
-    Returns:
-        QuantizeConfig to use for wrapping the layer from the passed node.
-    """
-
-    if node.is_weights_quantization_enabled() and not node.is_activation_quantization_enabled():
-        weight_attrs = DEFAULT_KERAS_INFO.get_kernel_op_attributes(node.type)
-        return WeightsQuantizeConfig(weight_attrs=weight_attrs,
-                                     w_quantizer=get_weights_quantizer_for_node(node,
-                                                                                weight_attrs))
-
-    elif not node.is_weights_quantization_enabled() and node.is_activation_quantization_enabled():
-        return ActivationQuantizeConfig(activation_quantizer=get_activations_quantizer_for_node(node))
-
-    elif not node.is_weights_quantization_enabled() and not node.is_activation_quantization_enabled():
-        return NoOpQuantizeConfig()
-
-    weight_attrs = DEFAULT_KERAS_INFO.get_kernel_op_attributes(node.type)
-    return WeightsActivationQuantizeConfig(activation_quantizer=get_activations_quantizer_for_node(node),
-                                           w_quantizer=get_weights_quantizer_for_node(node,
-                                                                                      weight_attrs),
-                                           weight_attrs=DEFAULT_KERAS_INFO.get_kernel_op_attributes(node.type))

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

@@ -1,134 +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 numpy as np
-from tensorflow_model_optimization.python.core.quantization.keras.quantizers import Quantizer
-from typing import List
-
-from model_compression_toolkit.core.common import BaseNode, Logger
-from model_compression_toolkit.core.common.constants import THRESHOLD, SIGNED, RANGE_MIN, RANGE_MAX
-from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import calculate_delta
-from model_compression_toolkit.core.common.target_platform import QuantizationMethod
-from model_compression_toolkit.exporter.model_wrapper.keras.quantizers.fq_quantizer import FakeQuantQuantizer
-from model_compression_toolkit.exporter.model_wrapper.keras.quantizers.weights_uniform_quantizer import \
-    WeightsUniformQuantizer
-
-# Supporting other quantizer types in the future
-SUPPORTED_WEIGHT_QUANTIZER_TYPES = [QuantizationMethod.POWER_OF_TWO,
-                                    QuantizationMethod.SYMMETRIC,
-                                    QuantizationMethod.UNIFORM]
-
-SUPPORTED_ACTIVATION_QUANTIZER_TYPES = [QuantizationMethod.POWER_OF_TWO,
-                                        QuantizationMethod.SYMMETRIC,
-                                        QuantizationMethod.UNIFORM]
-
-
-def get_weights_quantizer_for_node(node: BaseNode, weights_attr: List[str]) -> Quantizer:
-    """
-    Get weights quantizer for a node.
-
-    Args:
-        node: Node to create a weight quantizer for.
-        weights_attr: Attributes of the layer to quantize its weights.
-
-    Returns:
-        Quantizer for the node's weights.
-
-    """
-    if node.final_weights_quantization_cfg is None:
-        Logger.critical(f'Can not set quantizer for a node with no final weights quantization configuration')
-
-    node_w_qc = node.final_weights_quantization_cfg
-    weights_quantization_method = node_w_qc.weights_quantization_method
-
-    if weights_quantization_method not in SUPPORTED_WEIGHT_QUANTIZER_TYPES:
-        Logger.error(f'Fully quantized models are now supported for {SUPPORTED_WEIGHT_QUANTIZER_TYPES} quantization methods, but node has {weights_quantization_method} quantization method')
-
-    weight_thresholds = node_w_qc.weights_quantization_params.get(THRESHOLD)
-
-    # Compute quantizer params based on node's quantization params
-    if weights_quantization_method in [QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC]:
-        if weights_quantization_method == QuantizationMethod.POWER_OF_TWO:
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in weight_thresholds.flatten()])
-            if not is_threshold_pot:
-                Logger.error(f'Expected threshold to be power of 2 but is {weight_thresholds}')
-
-        min_range = -weight_thresholds
-        max_range = weight_thresholds - calculate_delta(weight_thresholds,
-                                                        n_bits=node_w_qc.weights_n_bits,
-                                                        signed=True)
-
-    elif weights_quantization_method in [QuantizationMethod.UNIFORM]:
-        min_range = node_w_qc.weights_quantization_params.get(RANGE_MIN)
-        max_range = node_w_qc.weights_quantization_params.get(RANGE_MAX)
-
-    else:
-        Logger.error(f'For now fully quantized models support only {SUPPORTED_WEIGHT_QUANTIZER_TYPES} for weights quantization, but found {weights_quantization_method}')
-
-    if len(weights_attr) > 1:
-        Logger.error(f'Currently, we support only one quantized weight per layer, but received {len(weights_attr)} attributes to quantize')
-
-    return WeightsUniformQuantizer(nbits=node_w_qc.weights_n_bits,
-                                   min_range=min_range,
-                                   max_range=max_range,
-                                   weight=node.get_weights_by_keys(weights_attr[0]),
-                                   quantization_method=weights_quantization_method)
-
-
-def get_activations_quantizer_for_node(node: BaseNode) -> Quantizer:
-    """
-    Get activation quantizer for a node.
-
-    Args:
-        node: Node to create an activation quantizer for.
-
-    Returns:
-        Quantizer for the node's activations.
-
-    """
-
-    if node.final_activation_quantization_cfg is None:
-        Logger.critical(f'Can not set quantizer for a node with no final activation quantization configuration')
-
-    node_act_qc = node.final_activation_quantization_cfg
-    activation_quantization_method = node_act_qc.activation_quantization_method
-
-    if activation_quantization_method not in SUPPORTED_ACTIVATION_QUANTIZER_TYPES:
-        Logger.error(
-            f'Fully quantized models are now supported for {SUPPORTED_ACTIVATION_QUANTIZER_TYPES} quantization methods, '
-            f'but node has {activation_quantization_method} quantization method')
-
-    activation_thresholds = node_act_qc.activation_quantization_params.get(THRESHOLD)
-
-    if activation_quantization_method in [QuantizationMethod.POWER_OF_TWO, QuantizationMethod.SYMMETRIC]:
-        if activation_quantization_method == QuantizationMethod.POWER_OF_TWO:
-            is_threshold_pot = np.all([int(np.log2(x)) == np.log2(x) for x in activation_thresholds.flatten()])
-            if not is_threshold_pot:
-                Logger.error(f'Expected threshold to be power of 2 but is {node_act_qc.activation_quantization_params.get(THRESHOLD)}')
-
-        min_range = 0
-        if node_act_qc.activation_quantization_params.get(SIGNED):
-            min_range = -activation_thresholds
-
-        max_range = activation_thresholds - calculate_delta(
-            activation_thresholds,
-            n_bits=node_act_qc.activation_n_bits,
-            signed=node_act_qc.activation_quantization_params.get(SIGNED))
-    else:
-        Logger.error(f'For now fully quantized models support only {SUPPORTED_ACTIVATION_QUANTIZER_TYPES} for activation quantization, but found {activation_quantization_method}')
-
-    return FakeQuantQuantizer(nbits=node_act_qc.activation_n_bits,
-                              min_range=min_range,
-                              max_range=max_range,
-                              quantization_method=activation_quantization_method)

model_compression_toolkit/exporter/model_wrapper/keras/extended_quantize_wrapper.py

@@ -1,81 +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, Tuple, Any
-
-from keras.engine.base_layer import Layer
-from keras.layers import TFOpLambda
-from tensorflow import TensorShape
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_config import QuantizeConfig
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapper
-
-
-class ExtendedQuantizeWrapper(QuantizeWrapper):
-
-    """Quantizes the weights and activations of the keras layer it wraps, according
-    to the quantization config that is passed. This class was created to deal with TFOpLambda that can
-    not use TF QuantizeWrapper since it does not implement compute_output_shape.
-    Notice that reused layers do not have a compute_output_shape method, thus the added method
-    is irrelevant for wrapping them."""
-
-    def __init__(self,
-                 layer:Layer,
-                 quantize_config:QuantizeConfig,
-                 output_shape:Tuple[Any]=None,
-                 **kwargs:Dict[str, Any]):
-        """
-        Create a wrapper for a keras layer.
-
-        Args:
-            layer: The keras layer to be quantized.
-            quantize_config: `QuantizeConfig` to quantize the layer.
-            output_shape: The output shape of the layer.
-            **kwargs: Keyword arguments to build the base class QuantizeWrapper.
-        """
-
-        # TFOpLambda does not implement the method compute_output_shape which is mandatory for cloning the model
-        # and use TF transformations. For this reason, we add the output_shape in the layer configuration and
-        # add an implementation for compute_output_shape.
-        self._output_shape = output_shape
-        if isinstance(layer, TFOpLambda):
-            layer.compute_output_shape = self._compute_output_shape
-
-        super(ExtendedQuantizeWrapper, self).__init__(layer=layer,
-                                                      quantize_config=quantize_config,
-                                                      **kwargs)
-
-    def _compute_output_shape(self, input_shape: TensorShape) -> Tuple[Any]:
-        """
-        Internal method that returns the output shape of the layer.
-
-        Args:
-            input_shape: Input shape the layer is expecting to have.
-
-        Returns:
-            The layer's output shape.
-        """
-
-        return self._output_shape
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-
-        Returns: The layer configuration with the output shape, so it can be deserialized.
-
-        """
-        cfg = super(ExtendedQuantizeWrapper, self).get_config()
-        cfg.update({'output_shape': self._output_shape})
-        return cfg
-

model_compression_toolkit/exporter/model_wrapper/keras/quantize_configs/activation_quantize_config.py

@@ -1,81 +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, Tuple, Any, Dict
-
-import tensorflow as tf
-from tensorflow import Tensor
-from tensorflow_model_optimization.python.core.quantization.keras.quantizers import Quantizer
-from packaging import version
-
-# As from Tensorflow 2.6, keras is a separate package and some classes should be imported differently.
-if version.parse(tf.__version__) < version.parse("2.6"):
-    from tensorflow.python.keras.layers import Layer
-else:
-    from keras.engine.base_layer import Layer
-from tensorflow.python.training.tracking.data_structures import ListWrapper
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_config import QuantizeConfig
-
-
-class ActivationQuantizeConfig(QuantizeConfig):
-    """
-    QuantizeConfig to quantize a layer's activations.
-    """
-
-    def __init__(self,
-                 activation_quantizer: Quantizer):
-        """
-
-        Args:
-            activation_quantizer: Quantizer for quantization the layer's activations.
-        """
-
-        self.activation_quantizer = activation_quantizer
-
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-
-        Returns: Configuration of ActivationQuantizeConfig
-
-        """
-        return {
-            'activation_quantizer': self.activation_quantizer}
-
-    def get_weights_and_quantizers(self, layer: Layer) -> List[Tuple[Tensor, Any]]:
-        return []
-
-    def get_activations_and_quantizers(self, layer: Layer) -> list:
-        # For configurable activations we use get_output_quantizers,
-        # Therefore, we do not need to implement this method.
-        return []
-
-    def set_quantize_weights(self, layer: Layer, quantize_weights: List[Tensor]):
-        pass
-
-    def set_quantize_activations(self, layer, quantize_activations: ListWrapper):
-        pass
-
-    def get_output_quantizers(self, layer: Layer) -> List[Quantizer]:
-        """
-        Quantize layer's outputs.
-
-        Args:
-            layer: Layer to quantize its activations.
-
-        Returns: List of activation quantizers.
-
-        """
-        return [self.activation_quantizer]

model_compression_toolkit/exporter/model_wrapper/keras/quantize_configs/weights_activation_quantize_config.py

@@ -1,128 +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, Tuple, Any, Dict
-
-import tensorflow as tf
-from tensorflow import Tensor
-from tensorflow_model_optimization.python.core.quantization.keras.quantizers import Quantizer
-
-# As from Tensorflow 2.6, keras is a separate package and some classes should be imported differently.
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.activation_quantize_config import \
-    ActivationQuantizeConfig
-from model_compression_toolkit.exporter.model_wrapper.keras.quantize_configs.weights_quantize_config import \
-    WeightsQuantizeConfig
-from packaging import version
-
-if version.parse(tf.__version__) < version.parse("2.6"):
-    from tensorflow.python.keras.layers import Layer
-else:
-    from keras.engine.base_layer import Layer
-from tensorflow.python.training.tracking.data_structures import ListWrapper
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_config import QuantizeConfig
-
-
-class WeightsActivationQuantizeConfig(QuantizeConfig):
-    """
-    QuantizeConfig to quantize a layer's activations and weights.
-    """
-
-    def __init__(self,
-                 activation_quantizer: Quantizer,
-                 w_quantizer: Quantizer,
-                 weight_attrs: List[str] = None):
-        """
-
-        Args:
-            activation_quantizer: Quantizer for activations.
-            w_quantizer: Quantizer for weights.
-            weight_attrs: Weights attributes to quantize.
-        """
-        self.act_config = ActivationQuantizeConfig(activation_quantizer=activation_quantizer)
-        self.weights_config = WeightsQuantizeConfig(w_quantizer=w_quantizer,
-                                                    weight_attrs=weight_attrs)
-
-
-    def get_config(self) -> Dict[str,Any]:
-        """
-
-        Returns: Configuration of WeightsActivationQuantizeConfig
-
-        """
-        return {"activation_quantizer": self.act_config.activation_quantizer,
-                "w_quantizer": self.weights_config.w_quantizer,
-                "weight_attrs": self.weights_config.weight_attrs}
-
-    def get_weights_and_quantizers(self, layer: Layer) -> List[Tuple[Tensor, Any]]:
-        """
-        Get the layer's weights to quantize and quantizers.
-
-        Args:
-            layer: Layer wrapped with this WeightsQuantizeConfig
-
-        Returns:
-            List of weights and quantizers to quantize these weights.
-        """
-        return self.weights_config.get_weights_and_quantizers(layer)
-
-    def get_activations_and_quantizers(self, layer: Layer) -> list:
-        """
-        Get the layer's activations to quantize and quantizers.
-
-        Args:
-            layer: Layer wrapped with this WeightsActivationQuantizeConfig
-
-        Returns:
-            List of activation tensors and quantizers to quantize them.
-        """
-        return self.act_config.get_activations_and_quantizers(layer)
-
-    def set_quantize_weights(self, layer: Layer, quantize_weights: List[Tensor]):
-        """
-        Set layer's weights with quantized weights.
-
-        Args:
-            layer: Layer wrapped with this WeightsQuantizeConfig
-            quantize_weights: Quantized weights to set to the layer
-
-        Returns:
-            None
-        """
-        self.weights_config.set_quantize_weights(layer, quantize_weights)
-
-    def set_quantize_activations(self, layer, quantize_activations: ListWrapper):
-        """
-        Set layer's activations with quantized activations.
-
-        Args:
-            layer: Layer wrapped with this WeightsActivationQuantizeConfig
-            quantize_activations: Quantized activation to set to the layer
-
-        Returns:
-            None
-        """
-        self.act_config.set_quantize_activations(layer, quantize_activations)
-
-    def get_output_quantizers(self, layer: Layer) -> List[Quantizer]:
-        """
-        Quantize layer's outputs.
-
-        Args:
-            layer: Layer to quantize its activations.
-
-        Returns: List of activation quantizers.
-
-        """
-        return self.act_config.get_output_quantizers(layer)

model_compression_toolkit/exporter/model_wrapper/keras/quantize_configs/weights_quantize_config.py

@@ -1,107 +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, Tuple, Any, Dict
-
-import tensorflow as tf
-from tensorflow import Tensor
-from tensorflow_model_optimization.python.core.quantization.keras.quantizers import Quantizer
-from packaging import version
-
-# As from Tensorflow 2.6, keras is a separate package and some classes should be imported differently.
-if version.parse(tf.__version__) < version.parse("2.6"):
-    from tensorflow.python.keras.layers import Layer
-else:
-    from keras.engine.base_layer import Layer
-from tensorflow.python.training.tracking.data_structures import ListWrapper
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_config import QuantizeConfig
-
-
-class WeightsQuantizeConfig(QuantizeConfig):
-    """
-    QuantizeConfig to quantize a layer's weights.
-    """
-
-    def __init__(self,
-                 w_quantizer: Quantizer,
-                 weight_attrs: List[str] = None):
-        """
-
-        Args:
-            w_quantizer: Quantizer for weights.
-            weight_attrs: Weights attributes to quantize.
-        """
-
-        self.weight_attrs = weight_attrs
-        self.w_quantizer = w_quantizer
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-
-        Returns: Configuration of WeightsQuantizeConfig
-
-        """
-        return {'w_quantizer': self.w_quantizer,
-                'weight_attrs': self.weight_attrs}
-
-    def get_weights_and_quantizers(self, layer: Layer) -> List[Tuple[Tensor, Any]]:
-        """
-        Get the layer's weights to quantize and quantizers.
-
-        Args:
-            layer: Layer wrapped with this WeightsQuantizeConfig
-
-        Returns:
-            List of weights and quantizers to quantize these weights.
-        """
-        return [(getattr(layer, self.weight_attrs[i]),
-                 self.w_quantizer) for i in range(len(self.weight_attrs))]
-
-    def get_activations_and_quantizers(self, layer: Layer) -> list:
-        # For configurable activations we use get_output_quantizers,
-        # Therefore, we do not need to implement this method.
-        return []
-
-    def set_quantize_weights(self, layer: Layer, quantize_weights: List[Tensor]):
-        """
-        Set layer's weights with quantized weights.
-
-        Args:
-            layer: Layer wrapped with this WeightsQuantizeConfig
-            quantize_weights: Quantized weights to set to the layer
-
-        Returns:
-            None
-        """
-        if len(self.weight_attrs) != len(quantize_weights):
-            raise ValueError(
-                '`set_quantize_weights` called on layer {} with {} '
-                'weight parameters, but layer expects {} values.'.format(
-                    layer.name, len(quantize_weights), len(self.weight_attrs)))
-
-        for weight_attr, weight in zip(self.weight_attrs, quantize_weights):
-            current_weight = getattr(layer, weight_attr)
-            if current_weight.shape != weight.shape:
-                raise ValueError('Existing layer weight shape {} is incompatible with'
-                                 'provided weight shape {}'.format(
-                    current_weight.shape, weight.shape))
-
-            setattr(layer, weight_attr, weight)
-
-    def set_quantize_activations(self, layer, quantize_activations: ListWrapper):
-        pass
-
-    def get_output_quantizers(self, layer: Layer) -> List[Quantizer]:
-        return []