Function naming refactor

Author: nikita-savelyevv

nncf/openvino/optimized_functions/__init__.py

@@ -10,8 +10,10 @@
 # limitations under the License.
 
 from nncf.openvino.optimized_functions.functions import astype as astype
-from nncf.openvino.optimized_functions.functions import do_int_quantization as do_int_quantization
+from nncf.openvino.optimized_functions.functions import do_integer_quantization as do_integer_quantization
 from nncf.openvino.optimized_functions.functions import get_integer_quantization_error as get_integer_quantization_error
-from nncf.openvino.optimized_functions.functions import quantize_dequantize_weight as quantize_dequantize_weight
+from nncf.openvino.optimized_functions.functions import (
+    integer_quantize_dequantize_weight as integer_quantize_dequantize_weight,
+)
 from nncf.openvino.optimized_functions.models import OVModelParameters as OVModelParameters
 from nncf.openvino.optimized_functions.models import clear_ov_model_cache as clear_ov_model_cache

nncf/openvino/optimized_functions/functions.py

@@ -15,9 +15,9 @@
 from nncf.openvino.optimized_functions.models import OV_MODEL_CACHE
 from nncf.openvino.optimized_functions.models import OVModelParameters
 from nncf.openvino.optimized_functions.models import get_astype_model
-from nncf.openvino.optimized_functions.models import get_compress_decompress_weight_model
-from nncf.openvino.optimized_functions.models import get_compress_weight_model
-from nncf.openvino.optimized_functions.models import get_quantization_error_model
+from nncf.openvino.optimized_functions.models import get_integer_quantization_error_model
+from nncf.openvino.optimized_functions.models import get_integer_quantization_model
+from nncf.openvino.optimized_functions.models import get_integer_quantize_dequantize_weight_model
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionConfig
 from nncf.quantization.algorithms.weight_compression.weight_lowering import reshape_weight_for_grouped_quantization
 from nncf.tensor import Tensor
@@ -27,7 +27,7 @@
 ReductionAxes = Union[int, Tuple[int, ...]]
 
 
-def do_int_quantization(
+def do_integer_quantization(
     weight: Tensor,
     config: WeightCompressionConfig,
     reduction_axes: Optional[ReductionAxes] = None,
@@ -63,7 +63,7 @@ def do_int_quantization(
             {"compressed_weight": compressed_weight_dtype, "zero_point": compressed_weight_dtype}
         )
 
-    model = get_compress_weight_model(
+    model = get_integer_quantization_model(
         ov_model_params,
         config,
         weight_shape,
@@ -97,7 +97,7 @@ def do_int_quantization(
     return compressed_weight, scale, zero_point
 
 
-def quantize_dequantize_weight(
+def integer_quantize_dequantize_weight(
     weight: Tensor,
     config: WeightCompressionConfig,
     reduction_axes: Optional[ReductionAxes] = None,
@@ -135,7 +135,7 @@ def quantize_dequantize_weight(
     if precomputed_zero_point is not None:
         ov_model_params.input_dtypes["zero_point"] = precomputed_zero_point.dtype
 
-    model = get_compress_decompress_weight_model(
+    model = get_integer_quantize_dequantize_weight_model(
         ov_model_params, config, weight_shape, scale_shape, zero_point_shape, reduction_axes, return_compressed_weight
     )
 
@@ -188,7 +188,7 @@ def get_integer_quantization_error(
 
     ov_model_params = OVModelParameters()
     ov_model_params.input_dtypes["weight"] = weight.dtype
-    model = get_quantization_error_model(
+    model = get_integer_quantization_error_model(
         ov_model_params, config, original_weight_shape, weight.shape, original_reduction_axes, reduction_axes
     )
 

nncf/openvino/optimized_functions/models.py

@@ -168,7 +168,7 @@ def _infer_ov_model(
     return outputs
 
 
-def _prepare_compression_model_inputs(
+def _prepare_quantization_model_inputs(
     ov_model_params,
     weight_shape: Tuple,
     scale_shape: Optional[Tuple],
@@ -196,7 +196,7 @@ def _prepare_compression_model_inputs(
     return weight_shape, scale_shape, zero_point_shape
 
 
-def get_compress_weight_model(
+def get_integer_quantization_model(
     ov_model_params: OVModelParameters,
     config: WeightCompressionConfig,
     weight_shape: Tuple,
@@ -219,11 +219,11 @@ def get_compress_weight_model(
     :return: A model callable that compresses weights using the given configuration. Or a model as nodes, if
         `return_nodes` is True.
     """
-    weight_shape, scale_shape, zero_point_shape = _prepare_compression_model_inputs(
+    weight_shape, scale_shape, zero_point_shape = _prepare_quantization_model_inputs(
         ov_model_params, weight_shape, scale_shape, zero_point_shape, reduction_axes
     )
 
-    return _build_compress_model(
+    return _build_integer_quantization_model(
         config,
         ov_model_params,
         weight_shape,
@@ -233,7 +233,7 @@ def get_compress_weight_model(
     )
 
 
-def get_compress_decompress_weight_model(
+def get_integer_quantize_dequantize_weight_model(
     ov_model_params: OVModelParameters,
     config: WeightCompressionConfig,
     weight_shape: Tuple,
@@ -259,11 +259,11 @@ def get_compress_decompress_weight_model(
     :return: A model callable that returns a decompressed weight, and optionally compressed weight, scale,
         (and zero point) if `return_compressed_weight` is True.
     """
-    weight_shape, scale_shape, zero_point_shape = _prepare_compression_model_inputs(
+    weight_shape, scale_shape, zero_point_shape = _prepare_quantization_model_inputs(
         ov_model_params, weight_shape, scale_shape, zero_point_shape, reduction_axes
     )
 
-    return _build_compress_decompress_model(
+    return _build_integer_quantize_dequantize_weight_model(
         config,
         ov_model_params,
         weight_shape,
@@ -274,7 +274,7 @@ def get_compress_decompress_weight_model(
     )
 
 
-def get_quantization_error_model(
+def get_integer_quantization_error_model(
     ov_model_params: OVModelParameters,
     config: WeightCompressionConfig,
     original_weight_shape: Tuple,
@@ -296,15 +296,15 @@ def get_quantization_error_model(
     :param reduction_axes: Axes to reduce the weight tensor.
     :return: A model callable that returns the quantization error.
     """
-    weight_shape, _, _ = _prepare_compression_model_inputs(ov_model_params, weight_shape, None, None, reduction_axes)
+    weight_shape, _, _ = _prepare_quantization_model_inputs(ov_model_params, weight_shape, None, None, reduction_axes)
 
-    return _build_quantization_error_model(
+    return _build_integer_quantization_error_model(
         config, ov_model_params, original_weight_shape, weight_shape, original_reduction_axes, reduction_axes
     )
 
 
 @cache_results(OV_MODEL_CACHE)
-def _build_compress_model(
+def _build_integer_quantization_model(
     config: WeightCompressionConfig,
     ov_model_params: OVModelParameters,
     weight_shape: Tuple,
@@ -454,7 +454,7 @@ def _build_compress_model(
 
 
 @cache_results(OV_MODEL_CACHE)
-def _build_compress_decompress_model(
+def _build_integer_quantize_dequantize_weight_model(
     config: WeightCompressionConfig,
     ov_model_params: OVModelParameters,
     weight_shape: Tuple,
@@ -477,7 +477,7 @@ def _build_compress_decompress_model(
         raise ValueError(msg)
 
     # Get compression model as input/result nodes and potentially modified ov model parameters
-    ov_parameters, ov_results, ov_model_params = _build_compress_model(
+    ov_parameters, ov_results, ov_model_params = _build_integer_quantization_model(
         config, ov_model_params, weight_shape, scale_shape, zero_point_shape, reduction_axes, return_nodes=True
     )
 
@@ -514,15 +514,15 @@ def _build_compress_decompress_model(
 
 
 @cache_results(OV_MODEL_CACHE)
-def _build_quantization_error_model(
+def _build_integer_quantization_error_model(
     config: WeightCompressionConfig,
     ov_model_params: OVModelParameters,
     original_weight_shape: Tuple,
     weight_shape: Tuple,
     original_reduction_axes: ReductionAxes,
     reduction_axes: ReductionAxes,
 ) -> ModelCallable:
-    ov_parameters, ov_results, ov_model_params = _build_compress_decompress_model(
+    ov_parameters, ov_results, ov_model_params = _build_integer_quantize_dequantize_weight_model(
         config,
         ov_model_params,
         weight_shape,

nncf/quantization/algorithms/weight_compression/awq.py

@@ -30,10 +30,10 @@
 from nncf.quantization.algorithms.weight_compression.activation_stats import process_stats
 from nncf.quantization.algorithms.weight_compression.backend import WeightCompressionAlgoBackend
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionParameters
+from nncf.quantization.algorithms.weight_compression.weight_lowering import calculate_nf4_quantized_weight
 from nncf.quantization.algorithms.weight_compression.weight_lowering import calculate_nf4_scale
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_nf4_dequantization
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_nf4_quantization
-from nncf.quantization.algorithms.weight_compression.weight_lowering import quantize_dequantize_weight
+from nncf.quantization.algorithms.weight_compression.weight_lowering import do_float_dequantization
+from nncf.quantization.algorithms.weight_compression.weight_lowering import integer_quantize_dequantize_weight
 from nncf.quantization.passes import transform_to_inference_graph
 from nncf.tensor import TensorDataType
 from nncf.tensor import functions as fns
@@ -256,10 +256,10 @@ def apply(
                     weights_to_fake_quantize = gweight * cur_scale
                     if config.mode == CompressWeightsMode.NF4:
                         g_c_scale = calculate_nf4_scale(weights_to_fake_quantize, reduction_axis)
-                        g_compressed_weighs = do_nf4_quantization(weights_to_fake_quantize, g_c_scale)
-                        g_decompressed_weighs = do_nf4_dequantization(g_compressed_weighs, g_c_scale)
+                        g_compressed_weighs = calculate_nf4_quantized_weight(weights_to_fake_quantize, g_c_scale)
+                        g_decompressed_weighs = do_float_dequantization(g_compressed_weighs, g_c_scale)
                     else:
-                        g_decompressed_weighs = quantize_dequantize_weight(
+                        g_decompressed_weighs = integer_quantize_dequantize_weight(
                             weights_to_fake_quantize, awq_config, reduction_axis
                         )
                     sacts = gacts / fns.unsqueeze(cur_scale, 1)

nncf/quantization/algorithms/weight_compression/gptq.py

@@ -27,10 +27,10 @@
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionParameters
 from nncf.quantization.algorithms.weight_compression.scale_estimation import ScaleEstimation
 from nncf.quantization.algorithms.weight_compression.weight_lowering import calculate_integer_quantization_params
+from nncf.quantization.algorithms.weight_compression.weight_lowering import calculate_nf4_quantized_weight
 from nncf.quantization.algorithms.weight_compression.weight_lowering import calculate_nf4_scale
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_nf4_dequantization
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_nf4_quantization
-from nncf.quantization.algorithms.weight_compression.weight_lowering import quantize_dequantize_weight
+from nncf.quantization.algorithms.weight_compression.weight_lowering import do_float_dequantization
+from nncf.quantization.algorithms.weight_compression.weight_lowering import integer_quantize_dequantize_weight
 from nncf.tensor import Tensor
 from nncf.tensor import functions as fns
 from nncf.tensor.definitions import TensorDataType
@@ -284,12 +284,12 @@ def _quantize_weights(
                         zero_points.append(zero_point)
 
                 if block_compression_config.mode == CompressWeightsMode.NF4:
-                    compressed_weights = do_nf4_quantization(
+                    compressed_weights = calculate_nf4_quantized_weight(
                         fns.unsqueeze(weight_col, 1), scales[-1], is_normalized_weight=False
                     )
-                    quantized_col = do_nf4_dequantization(compressed_weights, scales[-1], reduction_axis=-1)
+                    quantized_col = do_float_dequantization(compressed_weights, scales[-1], reduction_axis=-1)
                 else:
-                    quantized_col, compressed_weights, _, _ = quantize_dequantize_weight(
+                    quantized_col, compressed_weights, _, _ = integer_quantize_dequantize_weight(
                         fns.unsqueeze(weight_col, 1),
                         block_compression_config,
                         reduction_axes=None,

nncf/quantization/algorithms/weight_compression/lora_correction.py

@@ -25,9 +25,9 @@
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionConfig
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionParameters
 from nncf.quantization.algorithms.weight_compression.weight_lowering import CompressedWeight
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_int_dequantization
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_nf4_dequantization
-from nncf.quantization.algorithms.weight_compression.weight_lowering import do_nf4_quantization
+from nncf.quantization.algorithms.weight_compression.weight_lowering import calculate_nf4_quantized_weight
+from nncf.quantization.algorithms.weight_compression.weight_lowering import do_float_dequantization
+from nncf.quantization.algorithms.weight_compression.weight_lowering import do_integer_dequantization
 from nncf.tensor import Tensor
 from nncf.tensor import functions as fns
 from nncf.tensor.definitions import TensorDataType
@@ -170,15 +170,17 @@ def calculate_low_rank_matrices(
         assert len(reduction_axes) == 1, "Assumed a single reduction axis"
         reduction_axis = reduction_axes[0] if compression_config.group_size != -1 else -1
         if mode in (CompressWeightsMode.INT4_SYM, CompressWeightsMode.INT4_ASYM):
-            fq_weights = do_int_dequantization(
+            fq_weights = do_integer_dequantization(
                 compressed_weight.tensor,
                 compressed_weight.scale,
                 compressed_weight.zero_point,
                 reduction_axis,
             )
         elif mode == CompressWeightsMode.NF4:
-            indexes = do_nf4_quantization(compressed_weight.tensor, compressed_weight.scale, is_normalized_weight=True)
-            fq_weights = do_nf4_dequantization(indexes, compressed_weight.scale, reduction_axis)
+            indexes = calculate_nf4_quantized_weight(
+                compressed_weight.tensor, compressed_weight.scale, is_normalized_weight=True
+            )
+            fq_weights = do_float_dequantization(indexes, compressed_weight.scale, reduction_axis)
         else:
             msg = (
                 f"{mode.value} mode is invalid for Lora Correction algorithm. Supported modes: INT4_SYM, INT4_ASYM, NF4"

nncf/quantization/algorithms/weight_compression/mixed_precision.py

@@ -29,7 +29,7 @@
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionConfig
 from nncf.quantization.algorithms.weight_compression.config import WeightCompressionParameters
 from nncf.quantization.algorithms.weight_compression.weight_lowering import get_integer_quantization_error
-from nncf.quantization.algorithms.weight_compression.weight_lowering import quantize_dequantize_weight
+from nncf.quantization.algorithms.weight_compression.weight_lowering import integer_quantize_dequantize_weight
 from nncf.tensor import Tensor
 from nncf.tensor import functions as fns
 from nncf.tensor.definitions import TensorDataType
@@ -353,7 +353,7 @@ def _calc_weight_sensitivity(
         if weight.dtype != TensorDataType.float32:
             weight = weight.astype(TensorDataType.float32)
 
-        decompressed_weight = quantize_dequantize_weight(weight, backup_config, reduction_axes)
+        decompressed_weight = integer_quantize_dequantize_weight(weight, backup_config, reduction_axes)
         decompressed_weight = decompressed_weight.reshape(orig_shape)
         return fns.linalg.norm(decompressed_weight - weight, ord="fro").item()