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/base_gumbel_rounding.py

@@ -1,263 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-from typing import Dict, Any, List
-
-import numpy as np
-import tensorflow as tf
-
-from model_compression_toolkit import GumbelConfig
-from model_compression_toolkit.core.keras.quantizer.base_quantizer import BaseTrainableQuantizer
-from model_compression_toolkit.core.common.defaultdict import DefaultDict
-from model_compression_toolkit.core import common
-from model_compression_toolkit.gptq.keras.quantizer import kernel_functions
-from model_compression_toolkit.gptq.keras.quantizer.gumbel_rounding.gumbel_softmax import sample_gumbel
-from model_compression_toolkit.gptq.common import gptq_constants
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapper
-from tensorflow.python.framework.tensor_shape import TensorShape
-from model_compression_toolkit.gptq.keras.quantizer import quant_utils as qutils
-
-P_INIT = 0.01
-GR_SHIFT_BASE = 2
-
-
-def init_aux_var(ceil_indicator: np.ndarray, w_shape: List[int], m: int, p: float = P_INIT) -> np.ndarray:
-    """
-    This function generate a random pi matrix for Gumbel Rounding such that the search start at the rounding point.
-    Args:
-        ceil_indicator: An array of indicator if the value should be ceil or floor.
-        w_shape(List[int]): A list of integers that represent the shape of the weights tensor to be quantization.
-        p(float): A floating point number that represent the probability of non round options of pi matrix.
-        m(int):  An integer that define the number of shift.
-
-    Returns: A numpy array of pi tensor
-
-    """
-    if m < 2:
-        common.logger.Logger.error("m must be larger than two")
-    if m % 2 != 0:
-        common.logger.Logger.error("m must be module two")
-    m_hat = m // 2 - 1
-    shift = -np.log(-np.log(1 - p))
-    n = np.random.randn(*[m, *w_shape]) * np.sqrt(np.power(np.pi, 2) / 6)
-    n = n.reshape([m, -1]).T
-    ceil_indicator = ceil_indicator.flatten()
-    n[np.arange(ceil_indicator.size), ceil_indicator + m_hat] += shift
-    n = n.T.reshape(*[m, *w_shape])
-    return n
-
-
-def _init_shift_var(m: int) -> List[int]:
-    """
-    This function generate an list of 2*m+1 from -m to m
-    Args:
-        m: An integer value the represent m
-
-    Returns: A list of size m
-
-    """
-    m_hat = m // 2
-    aux_index_shift = [-m_hat + 1 + i for i in range(m)]
-    return aux_index_shift
-
-
-class GumbelRoundingBase(BaseTrainableQuantizer):
-    def __init__(self,
-                 num_bits: int,
-                 per_axis: bool,
-                 signed: bool,
-                 symmetric: bool,
-                 power_of_two: bool,
-                 quantization_parameter_learning: bool,
-                 quantization_axis: int,
-                 gumbel_config: GumbelConfig,
-                 max_lsbs_change_map: dict = DefaultDict({}, lambda: 1),
-                 max_iteration: int = 10000):
-        """
-        A base class for GumRounding
-
-        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.
-            symmetric:  Whether to quantize is symmetric.
-            power_of_two: Whether to quantize is power-of-two.
-            quantization_parameter_learning: A bool flag state if the quantizer parameter are trainable
-            quantization_axis: Axis of tensor to use for the quantization.
-            gumbel_config: A class with the gumbel rounding configurations.
-            max_lsbs_change_map: a mapping between number of bits to max lsb change.
-            max_iteration: The number of iteration of gptq.
-        """
-        self.num_bits = num_bits
-        self.per_axis = per_axis
-        self.signed = signed
-        self.quantization_axis = quantization_axis
-        self.max_iteration = max_iteration
-        self.power_of_two = power_of_two
-        self.symmetric = symmetric
-        self.quantization_parameter_learning = quantization_parameter_learning
-        self.temperature_learning = gumbel_config.temperature_learning
-        self.quantizer_parameters = {}
-        self.gumbel_config = gumbel_config
-
-        self.max_lsbs_change_map = max_lsbs_change_map
-        self.max_lsbs_change = max_lsbs_change_map.get(num_bits)
-        self.m = GR_SHIFT_BASE * self.max_lsbs_change + GR_SHIFT_BASE
-
-        self.n_cycles = gumbel_config.n_cycles
-        self.minimal_temp = gumbel_config.minimal_temp
-        self.maximal_temp = gumbel_config.maximal_temp
-        self.cycle_iterations = max(1, int(self.max_iteration / self.n_cycles))
-        self.tau = None
-        self.g_t = None
-        self.p_t = None
-        scale = self.cycle_iterations / (-2 * np.log(0.001))
-
-        self.gumbel_scale = gumbel_config.gumbel_scale
-        self.gumbel_scale_per_bitwidth = gumbel_config.gumbel_scale_per_bitwidth
-
-        def tau_function(i):
-            """
-            A function the generate the gumbel temperature.
-            Args:
-                i: An int the represent the current iteration number
-
-            Returns: A temperature value.
-
-            """
-            if i < (self.cycle_iterations - 1):
-                index = ((i + 1) % self.cycle_iterations) / scale
-            else:
-                index = (i % self.cycle_iterations) / scale
-
-            x = tf.exp(-index)
-            return self.minimal_temp + (self.maximal_temp - self.minimal_temp) * x
-
-        self.tau_function = tau_function
-        self.w_shape = None
-        self.update_gumbel_param = True
-
-    def enable_update(self):
-        self.update_gumbel_param = True
-
-    def disable_update(self):
-        self.update_gumbel_param = False
-
-    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.
-        """
-        w_shape = kernel_functions.get_kernel(layer.weights).shape
-        self.w_shape = w_shape
-
-        ar_iter = layer.add_weight(
-            name + gptq_constants.GPTQ_ITER,
-            shape=(),
-            initializer=tf.keras.initializers.Constant(0.0),
-            trainable=False)
-
-        temp_tensor = layer.add_weight(
-            name + gptq_constants.TEMP,
-            shape=[1, *self.w_shape],
-            initializer=tf.keras.initializers.Constant(self.maximal_temp),
-            trainable=True)
-
-        shift_tensor = layer.add_weight(name + gptq_constants.AUXSHIFT,
-                                        shape=self.m,
-                                        initializer=tf.keras.initializers.Constant(0.0),
-                                        trainable=False)
-        shift_tensor.assign(_init_shift_var(self.m))
-
-        self.quantizer_parameters = {gptq_constants.GPTQ_ITER: ar_iter,
-                                     gptq_constants.AUXSHIFT: shift_tensor,
-                                     gptq_constants.TEMP: temp_tensor}
-        return self.quantizer_parameters
-
-    def get_aux_variable(self) -> tf.Tensor:
-        return self.quantizer_parameters[gptq_constants.AUXVAR]
-
-    def get_trainable_parameters(self) -> List[tf.Tensor]:
-        """
-        A function to get a list trainable of trainable parameters of the quantizer for GPTQ retraining
-
-        Returns:
-            A list of trainable Tensors
-
-        """
-        return [t for t in self.quantizer_parameters.values() if t.trainable]
-
-    def __eq__(self, other: Any) -> bool:
-        """
-        Check if equals to another object.
-        Args:
-            other: Other object to compare.
-
-        Returns:
-            Whether they are equal or not.
-        """
-        if not isinstance(other, GumbelRoundingBase):
-            return False
-
-        return (self.num_bits == other.num_bits and
-                self.per_axis == other.per_axis and
-                self.symmetric == other.symmetric)
-
-    def __ne__(self, other: Any) -> bool:
-        """
-        Check if not equals to another object.
-        Args:
-            other: Other object to compare.
-
-        Returns:
-            Whether they are differ or not.
-        """
-        return not self.__eq__(other)
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-        Returns: Configuration of TrainableQuantizer.
-        """
-
-        return {
-            'num_bits': self.num_bits,
-            'per_axis': self.per_axis,
-            'symmetric': self.symmetric,
-            'power_of_two': self.power_of_two
-        }
-
-    def update_iteration(self, training, ar_iter):
-        if self.temperature_learning:
-            self.tau = qutils.ste_clip(self.quantizer_parameters[gptq_constants.TEMP], self.maximal_temp,
-                                       self.minimal_temp)
-        else:
-            self.tau = self.tau_function(ar_iter)
-        if self.update_gumbel_param and training:
-            ar_iter.assign_add(1.0)
-            self.g_t = sample_gumbel([self.m, *self.w_shape])
-
-    def get_temperature_variable(self):
-        return self.quantizer_parameters[gptq_constants.TEMP]
-
-    def get_gumbel_probability(self):
-        return self.p_t

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

@@ -1,75 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-import tensorflow as tf
-
-
-def sample_gumbel(shape, eps=1e-6) -> tf.Tensor:
-    """
-    A function that sample a tensor of i.i.d gumbel random variable.
-    Args:
-        shape: The tensor output shape
-        eps: A small number for numeric stability.
-
-    Returns: A tensor of i.i.d gumbel random variable.
-
-    """
-    u = tf.random.uniform(shape)
-    return -tf.math.log(-tf.math.log(u + eps) + eps)
-
-
-def gumbel_softmax(in_pi: tf.Tensor, in_tau: tf.Tensor, in_gumbel: tf.Tensor, eps: float = 1e-6, axis=0,
-                   gumbel_scale: float = 1.0) -> tf.Tensor:
-    """
-    A gumbel softmax function.
-    Args:
-        in_pi: A tensor of log probability.
-        in_tau: A temperature tensor.
-        in_gumbel: A tensor of gumbel random variable.
-        eps: A small number for numeric stability.
-        axis: A integer representing the axis of which the gumbel softmax applyed on.
-        gumbel_scale: A normalization factor for the gumbel tensor values
-
-    Returns: A gumbel softmax probability tensor.
-
-    """
-    return tf.nn.softmax((tf.nn.log_softmax(in_pi, axis=axis) + gumbel_scale * in_gumbel) / (in_tau + eps), axis=axis)
-
-
-def ste_gumbel(in_prob: tf.Tensor) -> tf.Tensor:
-    """
-    This function apply ste on the output of the gumbel softmax.
-    Args:
-        in_prob:A tensor of probability
-
-    Returns: A Tensor of ohe hot vector with STE.
-
-    """
-
-    delta = tf.stop_gradient(select_gumbel(in_prob) - in_prob)
-    return in_prob + delta
-
-
-def select_gumbel(in_prob: tf.Tensor) -> tf.Tensor:
-    """
-    This function apply ste on the output of the gumbel softmax.
-    Args:
-        in_prob: A tensor of probability.
-
-    Returns: A Tensor of ohe hot vector
-
-    """
-    max_index = tf.argmax(in_prob, axis=0)
-    one_hot_prob = tf.one_hot(max_index, depth=in_prob.shape[0], axis=0)
-    return one_hot_prob + 0 * in_prob

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

@@ -1,266 +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 THRESHOLD, GUMBEL_MAX_ITER, MIN_THRESHOLD
-from model_compression_toolkit.gptq.common import gptq_constants
-from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import max_power_of_two
-from model_compression_toolkit.gptq.keras.quantizer.ste_rounding.symmetric_ste import symmetric_quantizer
-
-
-def gumbel_rounding_symmetric_quantizer(input_tensor: tf.Tensor,
-                                        auxvar_tensor: tf.Variable,
-                                        max_tensor: tf.Tensor,
-                                        num_bits: int,
-                                        signed: bool,
-                                        power_of_two: bool) -> tf.Tensor:
-    """
-    Quantize a tensor symmetrically with maximum LSBs shift.
-    Args:
-        input_tensor: Tensor to quantize. values of this tensor are not changed during gptq.
-        auxvar_tensor: Tensor that manifests the bit shift the weight due to gptq.
-        max_tensor: Tensor with max values to compute the threshold.
-        num_bits: Num of bits to use.
-        signed: Signedness of the quantization range.
-        power_of_two: Whether the threshold should be constrained or not.
-
-    Returns:
-        A quantized tensor.
-    """
-
-    if power_of_two:
-        max_tensor = qutils.power_of_two_max(max_tensor)
-    delta = qutils.calculate_delta(max_tensor, num_bits, signed)
-    input_tensor = tf.stop_gradient(input_tensor)
-    input_tensor_int = tf.floor(input_tensor / delta)
-    tensor_q = input_tensor_int + auxvar_tensor
-    min_int = -int(signed) * (2 ** (num_bits - int(signed)))
-    max_int = (2 ** (num_bits - int(signed))) - 1
-    return delta * qutils.clip(tensor_q, max_val=max_int, min_val=min_int)
-
-
-class SymmetricGumbelRounding(GumbelRoundingBase):
-    """
-    Trainable constrained quantizer to quantize a layer inputs.
-    """
-    PTQ_THRESHOLD = "_ptq_threshold"
-    SCALE_PTQ = "_scale"
-
-    def __init__(self, num_bits: int,
-                 per_axis: bool,
-                 signed: bool,
-                 power_of_two: bool,
-                 quantization_parameter_learning: bool,
-                 threshold_values: np.ndarray,
-                 gumbel_config: GumbelConfig,
-                 quantization_axis: int = -1,
-                 max_lsbs_change_map: dict = DefaultDict({}, lambda: 1),
-                 max_iteration: int = GUMBEL_MAX_ITER):
-        """
-        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.
-            threshold_values: Threshold to use for the quantization.
-            gumbel_config: A class with the gumbel rounding configurations.
-            quantization_axis: Axis of tensor to use for the quantization.
-            power_of_two: Whether the threshold should be constrained or not.
-            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, True, power_of_two, quantization_parameter_learning,
-                         quantization_axis, gumbel_config,
-                         max_lsbs_change_map,
-                         max_iteration)
-        self.threshold_shape = np.asarray(threshold_values).shape
-        self.threshold_values = np.reshape(np.asarray(threshold_values), [-1]) if self.per_axis else float(
-            threshold_values)
-        self.k_threshold = len(self.threshold_values) 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]
-
-        ptq_threshold_tensor = layer.add_weight(
-            name + self.PTQ_THRESHOLD,
-            shape=reshape_shape,
-            initializer=tf.keras.initializers.Constant(1.0),
-            trainable=False)
-        ptq_threshold_tensor.assign(self.threshold_values.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 - symmetric_quantizer(w,
-                                          ptq_threshold_tensor,
-                                          num_bits=self.num_bits,
-                                          signed=True,
-                                          power_of_two=self.power_of_two)
-
-        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_THRESHOLD: ptq_threshold_tensor})
-
-        if self.quantization_parameter_learning and not self.power_of_two:
-            scale = layer.add_weight(
-                name + self.SCALE_PTQ,
-                shape=self.k_threshold,
-                initializer=tf.keras.initializers.Constant(1.0),
-                trainable=True)
-            self.quantizer_parameters.update({self.SCALE_PTQ: scale})
-
-        return self.quantizer_parameters
-
-    def get_quantization_variable(self) -> List[tf.Tensor]:
-        """
-        This function return a list of quantizer parameters.
-        Returns: A list of the quantizer parameters
-
-        """
-        if self.quantization_parameter_learning and not self.power_of_two:
-            return [self.quantizer_parameters[self.SCALE_PTQ]]
-        else:
-            return []
-
-    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_threshold_tensor = weights[self.PTQ_THRESHOLD]
-        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:
-                gumbel_scale = self.gumbel_scale if self.gumbel_scale_per_bitwidth is None \
-                    else self.gumbel_scale_per_bitwidth.get(self.num_bits, self.gumbel_scale)
-                p_t = gumbel_softmax(auxvar, self.tau, self.g_t, gumbel_scale=gumbel_scale)
-            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_threshold_tensor_hat = tf.reshape(ptq_threshold_tensor, 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_symmetric_quantizer(inputs, auxvar_hat,
-                                                           ptq_threshold_tensor_hat,
-                                                           self.num_bits,
-                                                           self.signed,
-                                                           self.power_of_two)
-            if self.quantization_parameter_learning and not self.power_of_two:
-                scale = tf.reshape(self.quantizer_parameters[self.SCALE_PTQ], reshape_shape)
-                q_tensor *= scale
-
-            return q_tensor
-        else:
-            return gumbel_rounding_symmetric_quantizer(inputs, auxvar,
-                                                       ptq_threshold_tensor,
-                                                       self.num_bits,
-                                                       self.signed,
-                                                       self.power_of_two)
-
-    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
-
-        """
-
-        if self.power_of_two:
-            old_threshold = self.quantizer_parameters[self.PTQ_THRESHOLD]
-            old_threshold = max_power_of_two(old_threshold, MIN_THRESHOLD)
-        else:
-            old_threshold = self.quantizer_parameters[self.PTQ_THRESHOLD]
-            if self.quantization_parameter_learning:
-                scale = tf.reshape(self.quantizer_parameters[self.SCALE_PTQ], self.threshold_shape)
-                old_threshold = old_threshold * scale
-            old_threshold = old_threshold.numpy()
-        old_threshold = old_threshold.reshape(self.threshold_shape)
-        return {THRESHOLD: old_threshold}