[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/evaluation/lm_eval/utils.py

@@ -22,6 +22,7 @@
 
 from neural_compressor.common import logger
 
+
 class LMEvalParser:
     def __init__(
         self,

neural_compressor/torch/algorithms/fp8_quant/_core/patching_common.py

@@ -1,3 +1,17 @@
+# Copyright (c) 2025 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 importlib.util
 
 from ..model_configs import ModuleInfo, ModuleType

neural_compressor/torch/algorithms/fp8_quant/_core/quantized_hpu_ops.py

@@ -1,4 +1,18 @@
 
+# Copyright (c) 2025 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 .._quant_common.quant_config import ScaleFormat
 from ..utils.logger import logger
 

neural_compressor/torch/algorithms/weight_only/save_load.py

@@ -26,14 +26,14 @@
 from neural_compressor.torch.utils import (
     HPU_SAFE_WEIGHTS_NAME,
     HPU_WEIGHT_NAME,
+    LM_HEAD_NAMES,
     QCONFIG_NAME,
     WEIGHT_NAME,
     SaveLoadFormat,
+    get_accelerator,
+    get_enum_from_format,
     logger,
     set_module,
-    get_enum_from_format,
-    LM_HEAD_NAMES,
-    get_accelerator,
 )
 
 from .modules import HPUWeightOnlyLinear, INCWeightOnlyLinear, MulLinear
@@ -964,8 +964,9 @@ def change_config_to_hf_format(config_mappings):
         "true_sequential": True,
         "model_name_or_path": None,
         "model_file_base_name": "model",
-        "quant_method": "gptq"  # INC is using AutoGPTQ format for RTN, GPTQ, AWQ, and TEQ
+        "quant_method": "gptq",  # INC is using AutoGPTQ format for RTN, GPTQ, AWQ, and TEQ
     }
+
     def _is_lm_head(name):
         for lm_head_name in LM_HEAD_NAMES:
             if re.match(lm_head_name, name):
@@ -992,17 +993,21 @@ def _is_lm_head(name):
         else:
             assert bits == config.bits, "bits should be the same for all modules, got {bits} and {config.bits}."
             assert sym == config.use_sym, "sym should be the same for all modules, got {sym} and {config.use_sym}."
-            assert group_size == config.group_size, \
-                    "group_size should be the same for all modules, got {group_size} and {config.group_size}."
+            assert (
+                group_size == config.group_size
+            ), "group_size should be the same for all modules, got {group_size} and {config.group_size}."
             if hasattr(config, "percdamp"):
-                assert damp_percent == config.percdamp, \
-                        "percdamp should be the same for all modules, got {damp_percent} and {config.percdamp}."
+                assert (
+                    damp_percent == config.percdamp
+                ), "percdamp should be the same for all modules, got {damp_percent} and {config.percdamp}."
             if hasattr(config, "act_order"):
-                assert desc_act == config.act_order, \
-                        "act_order should be the same for all modules, got {desc_act} and {config.act_order}."
+                assert (
+                    desc_act == config.act_order
+                ), "act_order should be the same for all modules, got {desc_act} and {config.act_order}."
             if hasattr(config, "true_sequential"):
-                assert true_sequential == config.true_sequential, \
-                        "true_sequential should be the same for all modules, got {true_sequential} and {config.true_sequential}."
+                assert (
+                    true_sequential == config.true_sequential
+                ), "true_sequential should be the same for all modules, got {true_sequential} and {config.true_sequential}."
     default_quantization_config["bits"] = bits
     default_quantization_config["group_size"] = group_size
     default_quantization_config["damp_percent"] = damp_percent

neural_compressor/torch/quantization/config.py

@@ -1786,6 +1786,7 @@ def get_default_hqq_config() -> HQQConfig:
 @register_config(framework_name=FRAMEWORK_NAME, algo_name=FP8_QUANT)
 class FP8Config(TorchBaseConfig):
     """Config class for FP8 quantization."""
+
     name = FP8_QUANT
 
     def __init__(

neural_compressor/torch/quantization/save_load_entry.py

@@ -50,6 +50,7 @@ def save(model, checkpoint_dir="saved_results", format="default"):
     # fp8_quant
     if isinstance(config_object, FP8Config):
         from neural_compressor.torch.algorithms import fp8_quant
+
         if format == SaveLoadFormat.DEFAULT:
             format = SaveLoadFormat.HUGGINGFACE
         fp8_quant.save(model, checkpoint_dir, format)

neural_compressor/torch/utils/environ.py

@@ -15,8 +15,8 @@
 """Intel Neural Compressor PyTorch environment check."""
 
 import importlib
-import sys
 import os
+import sys
 
 import torch
 from packaging.version import Version

neural_compressor/torch/utils/llm_utility.py

@@ -16,10 +16,13 @@
 
 def initialize_model_and_tokenizer(model_name_or_path, use_load=False, device="cpu"):
     import transformers
-    from neural_compressor.torch.utils import local_rank, world_size, logger
+
+    from neural_compressor.torch.utils import local_rank, logger, world_size
+
     tokenizer = transformers.AutoTokenizer.from_pretrained(model_name_or_path)
     if use_load:
         from neural_compressor.torch.quantization import load
+
         model = load(model_name_or_path, format="huggingface", device=device)
         model, tokenizer = update_tokenizer(model, tokenizer)
         return model, tokenizer
@@ -37,6 +40,7 @@ def initialize_model_and_tokenizer(model_name_or_path, use_load=False, device="c
             "keep_module_on_host": True,
         }
         import deepspeed
+
         ds_model = deepspeed.init_inference(model, **ds_inference_kwargs)
         model = ds_model.module
     model.eval()
@@ -95,10 +99,14 @@ def __getitem__(self, idx):
     dataloader = DataLoader(tokenized_dataset, batch_size=bs, shuffle=True)
     return dataloader
 
+
 def llm_benchmark(model, batch_size, input_length, warmup_iters=3, total_iters=20):
     import time
+
     import torch
+
     from neural_compressor.torch.utils import get_accelerator, logger
+
     cur_accelerator = get_accelerator()
     # this is a simple example to show the performance benefit of quantization
     example_inputs = torch.ones((batch_size, input_length), dtype=torch.long)

test/3x/torch/algorithms/fp8_quant/tester.py

@@ -49,7 +49,7 @@
 QUANT_MODES_QUANT_ONLY = [QuantMode.QUANTIZE]
 
 DTYPE_TO_HPDTYPE_STR = {
-    torch.bfloat16: "BF16", 
+    torch.bfloat16: "BF16",
     torch.float16: "FP16",
     torch.float32: "FP32",
 }

test/3x/torch/algorithms/fp8_quant/unit_tests/test_save_load.py

@@ -32,18 +32,18 @@ def compare_parameters_buffers(model1, model2):
     unique_keys_in_dict2 = keys2 - keys1
     unique_keys = unique_keys_in_dict1.union(unique_keys_in_dict2)
     assert len(dict1) == len(dict2), f"The number of parameters and buffers are different, {unique_keys}.\n" + \
-            f"unique_keys_in_model1: {unique_keys_in_dict1}\nunique_keys_in_model2: {unique_keys_in_dict2}\n" 
+            f"unique_keys_in_model1: {unique_keys_in_dict1}\nunique_keys_in_model2: {unique_keys_in_dict2}\n"
     for k, v in dict1.items():
         assert k in dict2, "k not in dict2"
         assert v.dtype == dict2[k].dtype, f"dtype of {k} is differnt.\n{v.dtype}\n{dict2[k].dtype}"
         assert torch.allclose(v, dict2[k]), f"{k} is differnt in model1 and model2.\n" + f"{v}\n" + f"{dict2[k]}\n"
 
 
 @pytest.mark.parametrize("scale_method", [
-    "unit_scale", "hw_aligned_single_scale", "maxabs_hw", "maxabs_pow2", 
-    "maxabs_arbitrary", "maxabs_hw_opt_weight", "maxabs_pow2_opt_weight", 
+    "unit_scale", "hw_aligned_single_scale", "maxabs_hw", "maxabs_pow2",
+    "maxabs_arbitrary", "maxabs_hw_opt_weight", "maxabs_pow2_opt_weight",
     # per-channel
-    "act_maxabs_hw_weights_pcs_maxabs_pow2", "act_maxabs_hw_weights_pcs_opt_pow2", 
+    "act_maxabs_hw_weights_pcs_maxabs_pow2", "act_maxabs_hw_weights_pcs_opt_pow2",
     "act_maxabs_pow2_weights_pcs_maxabs_pow2", "act_maxabs_pow2_weights_pcs_opt_pow2",
 ])
 @pytest.mark.parametrize("scale_format", ["const", "scalar"])