[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

neural_compressor/adaptor/torch_utils/weight_only.py

@@ -654,7 +654,7 @@ def quant_weight_w_scale(weight, scale, zp, group_size=-1):
     leng = weight.shape[1] // group_size
     tail_flag = False if weight.shape[1] % group_size == 0 else True
     for i in range(leng):
-        int_weight_tmp = weight[:, i * group_size : (i + 1) * group_size].div_(scale[:, i].unsqueeze(1)) 
+        int_weight_tmp = weight[:, i * group_size : (i + 1) * group_size].div_(scale[:, i].unsqueeze(1))
         if zp is not None:
             int_weight_tmp.add_(zp[:, i].unsqueeze(1))
         int_weight[:, i * group_size : (i + 1) * group_size].copy_(int_weight_tmp.round_())

neural_compressor/torch/algorithms/weight_only/README.md

@@ -1 +1 @@
-# Demo of algorithm usage w/o INC
+# Demo of algorithm usage w/o INC

neural_compressor/torch/algorithms/weight_only/rtn.py

@@ -24,11 +24,7 @@
 
 from neural_compressor.torch.utils import logger, set_module
 
-
-from .utility import (
-    quant_tensor,
-    search_clip,
-)
+from .utility import quant_tensor, search_clip
 
 
 def rtn_quantize(
@@ -101,24 +97,23 @@ def rtn_quantize(
             group_size = weight_config[name]["group_size"]
             scheme = weight_config[name]["scheme"]
             quantile = weight_config[name].get("quantile", 1.0)
-            group_dim = weight_config[name]['group_dim']
-            use_full_range = weight_config[name]['use_full_range']
-            use_mse_search = weight_config[name]['use_mse_search']
-            use_layer_wise = weight_config[name]['use_layer_wise']
-            export_compressed_model = weight_config[name]['export_compressed_model']
+            group_dim = weight_config[name]["group_dim"]
+            use_full_range = weight_config[name]["use_full_range"]
+            use_mse_search = weight_config[name]["use_mse_search"]
+            use_layer_wise = weight_config[name]["use_layer_wise"]
+            export_compressed_model = weight_config[name]["export_compressed_model"]
             if export_compressed_model:
                 use_optimum_format = kwargs.get("use_optimum_format", True)
-            double_quant_dtype = weight_config[name]['double_quant_dtype']
+            double_quant_dtype = weight_config[name]["double_quant_dtype"]
             double_quant_config = {
                 "double_quant": False if double_quant_dtype == "fp32" else True,
                 "double_quant_dtype": double_quant_dtype,
-                "double_quant_bits": weight_config[name]['double_quant_bits'],
-                "double_quant_scheme": weight_config[name]['double_quant_scheme'],
-                "double_quant_group_size": weight_config[name]['double_quant_group_size'],
+                "double_quant_bits": weight_config[name]["double_quant_bits"],
+                "double_quant_scheme": weight_config[name]["double_quant_scheme"],
+                "double_quant_group_size": weight_config[name]["double_quant_group_size"],
             }
         log_msg = (
-            f"RTN quantization config: bits={bits}, group_size={group_size}, "
-            + f"scheme={scheme}, quantile={quantile}"
+            f"RTN quantization config: bits={bits}, group_size={group_size}, " + f"scheme={scheme}, quantile={quantile}"
         )
         if dtype != "int":
             log_msg += f", dtype={dtype}"

neural_compressor/torch/algorithms/weight_only/utility.py

@@ -1,3 +1,16 @@
+# Copyright (c) 2024 Intel Corporation
+#
+# 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 torch.nn import functional as F
@@ -163,9 +176,7 @@ def qdq_weight_sym(weight, bits=4, quantile=1.0, return_int=False, full_range=Fa
     return weight.mul_(scale)
 
 
-def qdq_weight_actor(
-    weight, bits, scheme, quantile=1.0, dtype="int", return_int=False, full_range=False, **kwargs
-):
+def qdq_weight_actor(weight, bits, scheme, quantile=1.0, dtype="int", return_int=False, full_range=False, **kwargs):
     """Quant and dequant tensor per channel. It is an in-place op.
 
     Args:
@@ -417,7 +428,7 @@ def quant_weight_w_scale(weight, scale, zp, group_size=-1, dtype="int"):
     leng = weight.shape[1] // group_size
     tail_flag = False if weight.shape[1] % group_size == 0 else True
     for i in range(leng):
-        int_weight_tmp = weight[:, i * group_size : (i + 1) * group_size].div_(scale[:, i].unsqueeze(1)) 
+        int_weight_tmp = weight[:, i * group_size : (i + 1) * group_size].div_(scale[:, i].unsqueeze(1))
         if zp is not None:
             int_weight_tmp.add_(zp[:, i].unsqueeze(1))
         int_weight[:, i * group_size : (i + 1) * group_size].copy_(int_weight_tmp.round_())
@@ -426,4 +437,4 @@ def quant_weight_w_scale(weight, scale, zp, group_size=-1, dtype="int"):
         if zp is not None:
             int_weight_tmp.add_(zp[:, -1].unsqueeze(1))
         int_weight[:, leng * group_size :].copy_(int_weight_tmp.round_())
-    return int_weight
+    return int_weight

neural_compressor/torch/quantization/__init__.py

@@ -19,11 +19,13 @@
     GPTQConfig,
 )
 from .quantize import quantize, quantize_dynamic
+
 # TODO(Yi): move config to config.py
 from .autotune import autotune, TuningConfig, get_default_tune_config
 
 ### Quantization Function Registration ###
 from neural_compressor.torch.quantization.weight_only import quantization_impl
 from neural_compressor.torch.utils import is_hpex_available
+
 if is_hpex_available():
     from neural_compressor.torch.quantization.fp8 import quantization_impl

neural_compressor/torch/quantization/config.py

@@ -16,18 +16,12 @@
 # limitations under the License.
 # pylint:disable=import-error
 
-import torch
 from typing import Callable, Dict, List, NamedTuple, Optional, Tuple, Union
 
-from neural_compressor.common.base_config import BaseConfig, config_registry, register_config
-from neural_compressor.common.utility import (
-    OP_NAME_OR_MODULE_TYPE,
-    DEFAULT_WHITE_LIST,
-    FP8_QUANT,
-    GPTQ,
-    RTN,
-)
+import torch
 
+from neural_compressor.common.base_config import BaseConfig, config_registry, register_config
+from neural_compressor.common.utility import DEFAULT_WHITE_LIST, FP8_QUANT, GPTQ, OP_NAME_OR_MODULE_TYPE, RTN
 from neural_compressor.torch.utils import is_hpex_available, logger
 from neural_compressor.torch.utils.constants import PRIORITY_GPTQ, PRIORITY_RTN
 
@@ -75,7 +69,7 @@ def __init__(
         use_layer_wise: bool = False,
         export_compressed_model: bool = False,
         double_quant_dtype: str = "fp32",
-        double_quant_bits: int = 8, # not available when double_quant_dtype is not 'int'
+        double_quant_bits: int = 8,  # not available when double_quant_dtype is not 'int'
         double_quant_sym: bool = True,
         double_quant_group_size: int = 256,
         white_list: Optional[List[OP_NAME_OR_MODULE_TYPE]] = DEFAULT_WHITE_LIST,
@@ -255,9 +249,7 @@ def register_supported_configs(cls) -> List[OperatorConfig]:
         # TODO(Yi)
         linear_gptq_config = GPTQConfig()
         operators = [torch.nn.Linear, torch.nn.functional.linear]
-        supported_configs.append(
-            OperatorConfig(config=linear_gptq_config, operators=operators)
-        )
+        supported_configs.append(OperatorConfig(config=linear_gptq_config, operators=operators))
         cls.supported_configs = supported_configs
 
     @staticmethod
@@ -362,8 +354,10 @@ def get_default_fp8_qconfig() -> FP8QConfig:
         """
         return FP8QConfig()
 
+
 ##################### Algo Configs End ###################################
 
+
 def get_all_registered_configs() -> Dict[str, BaseConfig]:
     registered_configs = config_registry.get_all_configs()
     return registered_configs.get(FRAMEWORK_NAME, {})

neural_compressor/torch/quantization/weight_only/quantization_impl.py

@@ -1,11 +1,25 @@
+# Copyright (c) 2024 Intel Corporation
+#
+# 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
 
 import torch
-from typing import Dict, Tuple
-from neural_compressor.common.utility import RTN, GPTQ # unified namespace
-from neural_compressor.torch.quantization import RTNConfig, GPTQConfig
-from neural_compressor.torch.utils import logger, fetch_module, register_algo
-from neural_compressor.torch.algorithms import rtn_quantize, gptq_quantize
+
+from neural_compressor.common.utility import GPTQ, RTN  # unified namespace
+from neural_compressor.torch.algorithms import gptq_quantize, rtn_quantize
+from neural_compressor.torch.quantization import GPTQConfig, RTNConfig
+from neural_compressor.torch.utils import fetch_module, logger, register_algo
 
 
 ###################### RTN Algo Entry ##################################

neural_compressor/torch/utils/utility.py

@@ -13,8 +13,10 @@
 # limitations under the License.
 
 
-import torch
 from typing import Callable, Dict, List, Tuple
+
+import torch
+
 from neural_compressor.common.logger import Logger
 
 # Dictionary to store a mapping between algorithm names and corresponding algo implementation(function)
@@ -118,4 +120,3 @@ def get_double_quant_config(double_quant_type, weight_sym=True):
     )
     DOUBLE_QUANT_CONFIGS[double_quant_type]["weight_sym"] = weight_sym
     return DOUBLE_QUANT_CONFIGS[double_quant_type]
-

test/3x/torch/quantization/weight_only/test_rtn.py

@@ -1,11 +1,9 @@
-import unittest
 import copy
+import unittest
+
 import transformers
-from neural_compressor.torch.quantization import (
-    get_default_rtn_config,
-    RTNConfig,
-    quantize,
-)
+
+from neural_compressor.torch.quantization import RTNConfig, get_default_rtn_config, quantize
 
 
 class TestRTNQuant(unittest.TestCase):
@@ -25,5 +23,6 @@ def test_export_compressed_model(self):
         model = quantize(model, quant_config)
         print(model)
 
+
 if __name__ == "__main__":
     unittest.main()

test/3x/torch/test_config.py

@@ -1,13 +1,11 @@
 import copy
 import unittest
 
+import torch
 import transformers
 
-from neural_compressor.torch.utils import logger
 from neural_compressor.torch.quantization import RTNConfig, quantize
-
-
-import torch
+from neural_compressor.torch.utils import logger
 
 
 def build_simple_torch_model():
@@ -142,7 +140,6 @@ def test_quantize_rtn_from_dict_advance(self):
         self.assertIsNotNone(qmodel)
 
     def test_quantize_rtn_from_class_advance(self):
-
         quant_config = RTNConfig(weight_bits=4, weight_dtype="nf4")
         # set operator instance
         fc1_config = RTNConfig(weight_bits=4, weight_dtype="int8")
@@ -153,7 +150,6 @@ def test_quantize_rtn_from_class_advance(self):
         self.assertIsNotNone(qmodel)
 
     def test_config_white_lst(self):
-
         global_config = RTNConfig(weight_bits=4, weight_dtype="nf4")
         # set operator instance
         fc1_config = RTNConfig(weight_bits=4, weight_dtype="int8", white_list=["model.fc1"])
@@ -179,7 +175,6 @@ def test_config_white_lst2(self):
         self.assertTrue(configs_mapping[("fc2", torch.nn.Linear)].weight_bits == 4)
 
     def test_config_from_dict(self):
-
         quant_config = {
             "rtn_weight_only_quant": {
                 "global": {
@@ -199,7 +194,6 @@ def test_config_from_dict(self):
         self.assertIsNotNone(config.local_config)
 
     def test_config_to_dict(self):
-
         quant_config = RTNConfig(weight_bits=4, weight_dtype="nf4")
         fc1_config = RTNConfig(weight_bits=4, weight_dtype="int8")
         quant_config.set_local("model.fc1", fc1_config)
@@ -208,7 +202,6 @@ def test_config_to_dict(self):
         self.assertIn("local", config_dict)
 
     def test_same_type_configs_addition(self):
-
         quant_config1 = {
             "rtn_weight_only_quant": {
                 "weight_dtype": "nf4",
@@ -242,7 +235,6 @@ def test_same_type_configs_addition(self):
         )
 
     def test_diff_types_configs_addition(self):
-
         quant_config1 = {
             "rtn_weight_only_quant": {
                 "weight_dtype": "nf4",
@@ -259,7 +251,6 @@ def test_diff_types_configs_addition(self):
         self.assertIn("gptq", combined_config_d)
 
     def test_composable_config_addition(self):
-
         quant_config1 = {
             "rtn_weight_only_quant": {
                 "weight_dtype": "nf4",