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

model_compression_toolkit/gptq/keras/quantizer/gumbel_rounding/uniform_gumbel.py

@@ -1,247 +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 tensorflow as tf
-import numpy as np
-
-from model_compression_toolkit import GumbelConfig
-from model_compression_toolkit.gptq.keras.quantizer import quant_utils as qutils
-from model_compression_toolkit.gptq.keras.quantizer.gumbel_rounding.base_gumbel_rounding import GumbelRoundingBase, \
-    init_aux_var
-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.defaultdict import DefaultDict
-from typing import Dict, Any, List
-from model_compression_toolkit.gptq.keras.quantizer.gumbel_rounding.gumbel_softmax import gumbel_softmax, ste_gumbel
-from model_compression_toolkit.core.common.constants import RANGE_MIN, RANGE_MAX
-from model_compression_toolkit.gptq.common import gptq_constants
-from model_compression_toolkit.gptq.keras.quantizer.ste_rounding.uniform_ste import rounding_uniform_quantizer
-
-
-def gumbel_rounding_uniform_quantizer(tensor_data: tf.Tensor,
-                                      auxvar_tensor: tf.Variable,
-                                      range_min: tf.Tensor,
-                                      range_max: tf.Tensor,
-                                      n_bits: int) -> tf.Tensor:
-    """
-    Quantize a tensor according to given range (min, max) and number of bits.
-
-    Args:
-        tensor_data: Tensor values to quantize.
-        auxvar_tensor: Tensor that manifests the bit shift the weight due to gptq.
-        range_min: minimum bound of the range for quantization (or array of min values per channel).
-        range_max: maximum bound of the range for quantization (or array of max values per channel).
-        n_bits: Number of bits to quantize the tensor.
-
-    Returns:
-        Quantized data.
-    """
-
-    # adjusts the quantization rage so the quantization grid include zero.
-    a, b = qutils.fix_range_to_include_zero(range_min, range_max, n_bits)
-
-    # Compute the step size of quantized values.
-    delta = (b - a) / (2 ** n_bits - 1)
-
-    input_tensor_int = tf.stop_gradient(tf.floor((tensor_data - a) / delta))  # Apply rounding
-    tensor_q = input_tensor_int + auxvar_tensor
-
-    # Clip data in range
-    clipped_tensor = qutils.ste_clip(tensor_q, min_val=0, max_val=2 ** n_bits - 1)
-
-    # Quantize the data between min/max of quantization range.
-    q = delta * clipped_tensor + a
-    return q
-
-
-class UniformGumbelRounding(GumbelRoundingBase):
-    """
-    Trainable constrained quantizer to quantize a layer inputs.
-    """
-    PTQ_MIN_RANGE = "_min_range"
-    PTQ_MAX_RANGE = "_max_range"
-
-    def __init__(self, num_bits: int, per_axis: bool, signed: bool, quantization_parameter_learning: bool,
-                 min_range: np.ndarray, max_range: np.ndarray, gumbel_config: GumbelConfig,
-                 quantization_axis: int = -1, max_lsbs_change_map: dict = DefaultDict({}, lambda: 1),
-                 max_iteration: int = 10000):
-        """
-        Initialize a TrainableWeightQuantizer object with parameters to use
-        for the quantization.
-
-        Args:
-            num_bits: Number of bits to use for the quantization.
-            per_axis: Whether to quantize per-channel or per-tensor.
-            signed: Signedness to use for the quantization range.
-            quantization_parameter_learning: Threshold to use for the quantization.
-            min_range: a numpy array of the min range.
-            max_range: a numpy array of the max range.
-            gumbel_config: A class with the gumbel rounding configurations.
-            quantization_axis: Axis of tensor to use for the quantization.
-            max_lsbs_change_map: a mapping between number of bits to max lsb change.
-            max_iteration: The number of iteration of gptq.
-        """
-        super().__init__(num_bits, per_axis, signed, False, False, quantization_parameter_learning,
-                         quantization_axis, gumbel_config,
-                         max_lsbs_change_map,
-                         max_iteration)
-        self.threshold_shape = np.asarray(min_range).shape
-        self.min_range = np.reshape(np.asarray(min_range), [-1]) if self.per_axis else float(
-            min_range)
-        self.max_range = np.reshape(np.asarray(max_range), [-1]) if self.per_axis else float(
-            max_range)
-        self.k_threshold = len(self.max_range) if self.per_axis else 1
-
-    def build(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.
-        """
-        super().build(tensor_shape, name, layer)
-
-        if self.per_axis:
-            input_shape = tensor_shape
-            n_axis = len(input_shape)
-            quantization_axis = n_axis + self.quantization_axis if self.quantization_axis < 0 else \
-                self.quantization_axis
-            reshape_shape = [self.k_threshold if i == quantization_axis else 1 for i in range(n_axis)]
-        else:
-            reshape_shape = [self.k_threshold]
-
-        max_range = layer.add_weight(
-            name + self.PTQ_MAX_RANGE,
-            shape=reshape_shape,
-            initializer=tf.keras.initializers.Constant(1.0),
-            trainable=self.quantization_parameter_learning)
-        max_range.assign(self.max_range.reshape(reshape_shape))
-
-        min_range = layer.add_weight(
-            name + self.PTQ_MIN_RANGE,
-            shape=reshape_shape,
-            initializer=tf.keras.initializers.Constant(1.0),
-            trainable=self.quantization_parameter_learning)
-        min_range.assign(self.min_range.reshape(reshape_shape))
-
-        auxvar_tensor = layer.add_weight(
-            name + gptq_constants.AUXVAR,
-            shape=[self.m, *self.w_shape],
-            initializer=tf.keras.initializers.Constant(0.0),
-            trainable=True)
-        w = getattr(layer.layer, name)
-
-        q_error = w - rounding_uniform_quantizer(w, min_range, max_range,
-                                                 n_bits=self.num_bits)
-        ceil_indicator = (q_error < 0).numpy().astype("int")  # Negative error means the choose point is rounded to ceil.
-        auxvar_tensor.assign(init_aux_var(ceil_indicator, self.w_shape, self.m))
-
-        self.quantizer_parameters.update({gptq_constants.AUXVAR: auxvar_tensor,
-                                          self.PTQ_MAX_RANGE: max_range,
-                                          self.PTQ_MIN_RANGE: min_range})
-        return self.quantizer_parameters
-
-    def __call__(self, inputs: tf.Tensor,
-                 training: bool,
-                 weights: Dict[str, tf.Variable],
-                 **kwargs: Dict[str, Any]):
-        """
-        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.
-        """
-
-        auxvar = weights[gptq_constants.AUXVAR]
-        ar_iter = weights[gptq_constants.GPTQ_ITER]
-        ptq_min_range = weights[self.PTQ_MIN_RANGE]
-        ptq_max_range = weights[self.PTQ_MAX_RANGE]
-        aux_index_shift = weights[gptq_constants.AUXSHIFT]
-        self.update_iteration(training, ar_iter)
-        if self.per_axis:
-            input_shape = inputs.shape
-            n_axis = len(input_shape)
-            quantization_axis = n_axis + self.quantization_axis if self.quantization_axis < 0 else \
-                self.quantization_axis
-            reshape_shape = [-1 if i == quantization_axis else 1 for i in range(n_axis)]
-
-            reshape_shape_aux_ind = [-1, *[1 for _ in range(n_axis)]]
-            #####################################################
-            # Gumbel Softmax
-            #####################################################
-            if training:
-                p_t = gumbel_softmax(auxvar, self.tau, self.g_t)
-            else:
-                p_t = gumbel_softmax(auxvar, self.minimal_temp, 0)
-                p_t = ste_gumbel(p_t)
-            self.p_t = p_t
-            #####################################################
-            # Calculate v hat and threshold hat
-            #####################################################
-            ptq_min_range = tf.reshape(ptq_min_range, reshape_shape)
-            ptq_max_range = tf.reshape(ptq_max_range, reshape_shape)
-
-            auxvar_hat = tf.reduce_sum(p_t * tf.reshape(aux_index_shift, reshape_shape_aux_ind), axis=0)
-            #####################################################
-            # Quantized Input
-            #####################################################
-            q_tensor = gumbel_rounding_uniform_quantizer(inputs, auxvar_hat,
-                                                         ptq_min_range,
-                                                         ptq_max_range,
-                                                         self.num_bits)
-            return q_tensor
-        else:
-            raise NotImplemented
-            return gumbel_rounding_uniform_quantizer(inputs, auxvar_hat,
-                                                     ptq_max_range,
-                                                     ptq_min_range,
-                                                     self.num_bits)
-
-    def get_quant_config(self, layer) -> Dict[str, np.ndarray]:
-        """
-        Returns the config used to edit NodeQuantizationConfig after GPTQ retraining
-
-        Args:
-            layer: quantized layer
-
-        Returns:
-            A dictionary of attributes the quantize_config retraining has changed during GPTQ retraining.
-            Keys must match NodeQuantizationConfig attributes
-
-        """
-        min_range = self.quantizer_parameters[self.PTQ_MIN_RANGE]
-        max_range = self.quantizer_parameters[self.PTQ_MAX_RANGE]
-        return {RANGE_MIN: min_range.numpy().reshape(self.threshold_shape),
-                RANGE_MAX: max_range.numpy().reshape(self.threshold_shape)}
-
-    def get_quantization_variable(self) -> List[tf.Tensor]:
-        """
-         This function return a list of quantizer parameters.
-         Returns: A list of the quantizer parameters
-
-         """
-        return [self.quantizer_parameters[self.PTQ_MIN_RANGE], self.quantizer_parameters[self.PTQ_MAX_RANGE]]

model_compression_toolkit/gptq/keras/quantizer/kernel_functions.py

@@ -1,50 +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 tensorflow as tf
-from model_compression_toolkit.core.keras.constants import KERNEL
-
-
-def get_kernel(weights_list: list) -> tf.Tensor:
-    """
-    This function a list of weights and return the kernel
-    Args:
-        weights_list:  A list of Tensors
-
-    Returns: The kernel tensor.
-
-    """
-    for w in weights_list:
-        if KERNEL in w.name:
-            return w
-    raise Exception("Can't find kernel variable")
-
-
-def threshold_reshape(threshold_tensor: tf.Tensor, input_w: tf.Tensor, in_quantization_axis: int) -> tf.Tensor:
-    """
-    This function take a threshold tensor and re-aline it to the weight tensor channel axis.
-    Args:
-        threshold_tensor: A tensor of threshold
-        input_w: A weight tensor
-        in_quantization_axis: A int value that represent the channel axis.
-
-    Returns: A reshape tensor of threshold.
-
-    """
-    input_shape = input_w.shape
-    n_axis = len(input_shape)
-    quantization_axis = n_axis + in_quantization_axis if in_quantization_axis < 0 else in_quantization_axis
-    reshape_shape = [-1 if i == quantization_axis else 1 for i in range(n_axis)]
-    ptq_threshold_tensor = tf.reshape(threshold_tensor, reshape_shape)
-    return ptq_threshold_tensor

model_compression_toolkit/gptq/keras/quantizer/ste_rounding/uniform_ste.py

@@ -1,49 +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 tensorflow as tf
-
-from model_compression_toolkit.gptq.keras.quantizer import quant_utils as qutils
-
-
-def rounding_uniform_quantizer(tensor_data: tf.Tensor,
-                               range_min: tf.Tensor,
-                               range_max: tf.Tensor,
-                               n_bits: int) -> tf.Tensor:
-    """
-    Quantize a tensor according to given range (min, max) and number of bits.
-
-    Args:
-        tensor_data: Tensor values to quantize.
-        range_min: minimum bound of the range for quantization (or array of min values per channel).
-        range_max: maximum bound of the range for quantization (or array of max values per channel).
-        n_bits: Number of bits to quantize the tensor.
-
-    Returns:
-        Quantized data.
-    """
-    # adjusts the quantization rage so the quantization grid include zero.
-    a, b = qutils.fix_range_to_include_zero(range_min, range_max, n_bits)
-
-    # Compute the step size of quantized values.
-    delta = (b - a) / (2 ** n_bits - 1)
-
-    input_tensor_int = qutils.ste_round((tensor_data - a) / delta)  # Apply rounding
-
-    # Clip data in range
-    clipped_tensor = qutils.ste_clip(input_tensor_int, min_val=0, max_val=2 ** n_bits - 1)
-
-    # Quantize the data between min/max of quantization range.
-    q = delta * clipped_tensor + a
-    return q

model_compression_toolkit/gptq/pytorch/gptq_graph_info.py

@@ -1,94 +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 torch
-import torch.nn as nn
-from typing import List
-from model_compression_toolkit.gptq.pytorch.quantizer.quantizer_wrapper import WeightQuantizerWrapper
-from model_compression_toolkit.gptq.pytorch.quantizer.gumbel_rounding.base_gumbel_weights_quantizer import BaseGumbelWeightQuantizer
-from model_compression_toolkit.core.pytorch.constants import BIAS
-
-
-def get_trainable_parameters(fxp_model: nn.Module,
-                             add_bias: bool = False,
-                             quantization_parameters_learning: bool = False,
-                             is_gumbel: bool = False) -> (List[nn.Parameter], List[nn.Parameter], List[nn.Parameter]):
-    """
-    Get trainable parameters from all layers in a model
-
-    Args:
-        fxp_model: Model to get its trainable parameters.
-        add_bias: Whether to include biases of the model (if there are) or not.
-        quantization_parameters_learning: Whether to include quantization parameters of the model or not.
-        is_gumbel: Whether the fxp model is quantized using Gumbel Rounding
-    Returns:
-        A list of trainable variables in a model. Each item is a list of a layers weights.
-    """
-
-    trainable_aux_weights = nn.ParameterList()
-    trainable_threshold = nn.ParameterList()
-    trainable_bias = nn.ParameterList()
-    trainable_temperature = nn.ParameterList()
-
-    for layer in fxp_model.modules():
-        if isinstance(layer, WeightQuantizerWrapper):
-            trainable_aux_weights.append(layer.weight_quantizer.get_aux_variable())
-            if quantization_parameters_learning:
-                trainable_threshold.extend(layer.weight_quantizer.get_quantization_variable())
-            if is_gumbel:
-                trainable_temperature.append(layer.weight_quantizer.get_temperature_variable())
-            if add_bias and hasattr(layer.op, BIAS):
-                bias = getattr(layer.op, BIAS)
-                trainable_bias.append(bias)
-
-    return trainable_aux_weights, trainable_bias, trainable_threshold, trainable_temperature
-
-
-def get_gumbel_probability(fxp_model: nn.Module) -> List[torch.Tensor]:
-    """
-    This function return the gumbel softmax probability of GumRounding
-    Args:
-        fxp_model: A model to be quantized with GumRounding
-
-    Returns: A list of tensors.
-
-    """
-    gumbel_prob_aux = []
-    for layer in fxp_model.modules():
-        if isinstance(layer, WeightQuantizerWrapper) and isinstance(layer.weight_quantizer, BaseGumbelWeightQuantizer):
-            gumbel_prob_aux.append(layer.weight_quantizer.get_gumbel_probability())
-    return gumbel_prob_aux
-
-
-def get_weights_for_loss(fxp_model: nn.Module) -> [List, List]:
-    """
-    Get all float and quantized kernels for the GPTQ loss
-
-    Args:
-        fxp_model: Model to get its float and quantized weights.
-
-    Returns:
-        A list of float kernels, each item is the float kernel of the layer
-        A list of quantized kernels, each item is the quantized kernel of the layer
-    """
-
-    flp_weights_list, fxp_weights_list = [], []
-    for layer in fxp_model.modules():
-        if isinstance(layer, WeightQuantizerWrapper):
-            # Collect pairs of float and quantized weights per layer
-            weights = layer.op.weight
-            flp_weights_list.append(weights)
-            fxp_weights_list.append(layer.weight_quantizer(weights, training=False))
-
-    return flp_weights_list, fxp_weights_list

model_compression_toolkit/gptq/pytorch/gptq_model_builder.py

@@ -1,113 +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 torch
-from typing import Tuple, List
-from model_compression_toolkit.core.common.user_info import UserInformation
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.graph.base_graph import BaseNode
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
-from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
-from model_compression_toolkit.core.pytorch.back2framework.pytorch_model_builder import PyTorchModelBuilder, PytorchModel
-from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
-from model_compression_toolkit.gptq.pytorch.quantizer.quantizer_wrapper import quantizer_wrapper
-from model_compression_toolkit.core.pytorch.utils import get_working_device
-from model_compression_toolkit.core.pytorch.constants import BUFFER
-from model_compression_toolkit.core.pytorch.reader.node_holders import BufferHolder
-from model_compression_toolkit.core.pytorch.back2framework.instance_builder import node_builder
-
-
-class GPTQPytorchModel(PytorchModel):
-    """
-    Class for GPTQ PyTorch model.
-    """
-
-    def __init__(self,
-                 graph: common.Graph,
-                 gptq_config: GradientPTQConfig,
-                 append2output=None,
-                 return_float_outputs: bool = True):
-        """
-        Args:
-            graph: Graph to build the model from.
-            gptq_config: Configuration for GPTQ optimization.
-            append2output: Nodes to append to model's output.
-            return_float_outputs: Whether the model returns float tensors or not.
-        """
-
-        super().__init__(graph,
-                         append2output,
-                         DEFAULT_PYTORCH_INFO,
-                         return_float_outputs)
-
-        for node in graph.nodes():
-            if not isinstance(node, FunctionalNode):
-                if node.type == BufferHolder:
-                    self.add_module(node.name, node_builder(node))
-                    self.get_submodule(node.name).register_buffer(node.name,torch.Tensor(node.get_weights_by_keys(BUFFER)).to(get_working_device()))
-                else:
-                    self.add_module(node.name, quantizer_wrapper(node, gptq_config))
-
-
-    def _quantize_node_activations(self,
-                                   node: BaseNode,
-                                   input_tensors: List[torch.Tensor]) -> List[torch.Tensor]:
-        """
-        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)
-
-
-class GPTQPytorchModelBuilder(PyTorchModelBuilder):
-    """
-    Builder of GPTQ Pytorch models.
-    """
-
-    def __init__(self,
-                 graph: common.Graph,
-                 gptq_config: GradientPTQConfig,
-                 append2output=None,
-                 return_float_outputs: bool = True):
-        """
-
-        Args:
-            graph: Graph to build the model from.
-            gptq_config: Configuration for GPTQ optimization.
-            append2output: Nodes to append to model's output.
-            return_float_outputs: Whether the model returns float tensors or not.
-        """
-        super().__init__(graph,
-                         append2output,
-                         DEFAULT_PYTORCH_INFO,
-                         return_float_outputs)
-        self.gptq_config = gptq_config
-
-    def build_model(self) -> Tuple[PytorchModel, UserInformation]:
-        """
-        Build a GPTQ PyTorch model and return it.
-        Returns:
-            GPTQ PyTorch model and user information.
-        """
-        return GPTQPytorchModel(self.graph,
-                                self.gptq_config,
-                                self.append2output,
-                                self.return_float_outputs), self.graph.user_info

model_compression_toolkit/gptq/pytorch/quantizer/gptq_quantizer.py

@@ -1,71 +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 torch
-import torch.nn as nn
-from typing import List, Union, Dict, Any
-from abc import abstractmethod
-from model_compression_toolkit.core.common import Logger
-
-
-class BaseWeightQuantizer(nn.Module):
-
-    def __init__(self):
-        """
-        Construct a Base Pytorch model that utilizes a fake weight quantizer
-        """
-        super().__init__()
-        self.trainable_params = dict()
-
-    def get_trainable_params(self) -> List:
-        """
-        A function to get a list of trainable parameters of the quantizer for GPTQ retraining
-        Returns:
-            A list of trainable tensors
-        """
-        return [value for value in self.trainable_params.values() if value is not None]
-
-    @abstractmethod
-    def get_aux_variable(self) -> torch.Tensor:
-        """
-        Returns auxiliary trainable variables
-        """
-        raise Logger.error(f'{self.__class__.__name__} have to implement the this abstract function.')
-
-    @abstractmethod
-    def get_quantization_variable(self) -> Union[torch.Tensor, List]:
-        """
-        Returns quantization trainable variables
-        """
-        raise Logger.error(f'{self.__class__.__name__} have to implement the this abstract function.')
-
-
-    @abstractmethod
-    def get_weight_quantization_params(self) -> Dict[str, Any]:
-        """
-        Returns weight quantization dictionary params
-        """
-        raise Logger.error(f'{self.__class__.__name__} have to implement the this abstract function.')
-
-    @abstractmethod
-    def forward(self, w:nn.parameter, training:bool = True) -> torch.Tensor:
-        """
-        Forward-Pass
-        Args:
-            w: weights to quantize.
-            training: whether in training mode or not
-        Returns:
-            quantized weights
-        """
-        raise Logger.error(f'{self.__class__.__name__} have to implement the this abstract function.')

model_compression_toolkit/gptq/pytorch/quantizer/gumbel_rounding/__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.
-# ==============================================================================