[SW-192917] Update all HQT logic files with pre-commit check

Change-Id: I119dc8578cb10932fd1a8a674a8bdbf61f978e42
Signed-off-by: xinhe3 <[email protected]>
(cherry picked from commit 099e984)
Signed-off-by: xinhe3 <[email protected]>

Author: xinhe3

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

@@ -0,0 +1,13 @@
+# 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.

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

@@ -1,9 +1,24 @@
-import os
-import torch
-import json
-import numpy as np
+# 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 functools
 import importlib.util
+import json
+import os
+
+import numpy as np
+import torch
 
 from .._quant_common.helper_modules import *
 from .._quant_common.quant_config import get_hqt_config
@@ -117,7 +132,13 @@ def save_file(model, d, source_format, fname, mode):
 def module_convert(m, fcn):
     mt = ModuleConfig(
         tuple([fcn(x) for x in m.inputs]),
-        tuple([fcn(m.outputs)],) if type(m.outputs) == np.ndarray else tuple([fcn(y) for y in m.outputs]),
+        (
+            tuple(
+                [fcn(m.outputs)],
+            )
+            if type(m.outputs) == np.ndarray
+            else tuple([fcn(y) for y in m.outputs])
+        ),
         {k: fcn(m.params[k]) for k in m.params},
     )
     return mt

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

@@ -1,6 +1,21 @@
-import torch
+# 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 habana_frameworks.torch.core as htcore
 import habana_frameworks.torch.utils.experimental as htexp
+import torch
+
 from .common import *
 
 GAUDI2 = htexp.synDeviceType.synDeviceGaudi2
@@ -37,7 +52,7 @@ def get_default_exp_bias(dtype):
 def get_fullscale(dtype, exp_bias=None):
     default_exp_bias = get_default_exp_bias(dtype)
     fullscale = MAX_RANGE[dtype]
-    exp_bias = default_exp_bias if exp_bias == None else exp_bias
+    exp_bias = default_exp_bias if exp_bias is None else exp_bias
     fullscale = fullscale * (2 ** (default_exp_bias - exp_bias))
     return fullscale
 
@@ -50,7 +65,7 @@ def get_fp8_hw_alligned_scales(dtype, device):
     exp_bias_set = EXP_BIAS_SETS.get((device, dtype), None)
     return (
         None
-        if exp_bias_set == None
+        if exp_bias_set is None
         else [x / MAX_RANGE[dtype] for x in get_fullscales_by_expbias_set(dtype, exp_bias_set)]
     )
 
@@ -82,11 +97,11 @@ def scale_to_pow2(scale):
     return scale_pow2
 
 
-# Considering range of hw alligned scales: 2^a, 2^a+1,..., 2^b (a<b)
+# Considering range of hw aligned scales: 2^a, 2^a+1,..., 2^b (a<b)
 # we want to choose scale s for maxabs m such that 2^a <= s=2^x <= 2^b (for integer a<=x<=b)
 # and also 2^(x-1) < m <= 2^x
-# if m>=2^b then s=2^b, therefor min(_, 2^b)
-# if m<=2^a then s=2^a, therefor max(_, 2^a) --> 2^a <= min(max(_,2^a),2^b) <=2^b
+# if m>=2^b then s=2^b, therefore min(_, 2^b)
+# if m<=2^a then s=2^a, therefore max(_, 2^a) --> 2^a <= min(max(_,2^a),2^b) <=2^b
 # if s^a<m<2^b then m as a positive number can be written as m=2^y (y=log2(m))
 # if y is integer then y=ciel(y) we choose x=y so s=2^x=2^y=2^ciel(y)=2^ciel(log2(m))
 # else we choose x=ciel(y) and a<=x-1<y<x<=b and s=2^x=2^ciel(y)=2^ciel(log2(m))

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

@@ -1,18 +1,27 @@
+# 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 json
 import os
-import torch
-import numpy as np
+
 import habana_frameworks.torch.core as htcore
+import numpy as np
+import torch
 
-from .._quant_common.quant_config import (
-    QuantMode,
-    ScaleMethod,
-    MeasureExclude,
-    get_hqt_config,
-    set_hqt_config,
-)
-from .common import *
+from .._quant_common.quant_config import MeasureExclude, QuantMode, ScaleMethod, get_hqt_config, set_hqt_config
 from ..utils.logger import logger
+from .common import *
 
 imod_dict = {}
 gmod_list = []
@@ -139,7 +148,7 @@ def get_mod_extra_config_dict(model):
     for name, mod in model.named_modules():
         if hasattr(mod, "_mod_extra_config"):
             if is_measure_done(mod._mod_extra_config):
-                name = name.replace("_orig_mod.", "") # remove _orig_mod part added by dynamo mechanism
+                name = name.replace("_orig_mod.", "")  # remove _orig_mod part added by dynamo mechanism
                 mcd[name] = mod._mod_extra_config
             else:
                 logger.debug(
@@ -181,9 +190,7 @@ def measure_control_to_state_dict(mcd):
             sdl[mname]["params"] = dict()
             for param_name in mcd[mname].params:
                 if mcd[mname].params[param_name].state is not None:
-                    sd[mname]["params"][param_name] = (
-                        mcd[mname].params[param_name].state.detach().cpu().float().numpy()
-                    )
+                    sd[mname]["params"][param_name] = mcd[mname].params[param_name].state.detach().cpu().float().numpy()
                     sdl[mname]["params"][param_name] = (
                         mcd[mname].params[param_name].state.detach().cpu().float().numpy().tolist()
                     )
@@ -396,6 +403,13 @@ def is_used(self):
 observer_params = {
     "maxabs_per_channel": {
         "linear": ModuleConfig(({"dim": -1},), ({"dim": -1},), {"weight": {"dim": 0}}),
-        "matmul": ModuleConfig(({"dim": -1}, {"dim": -2},), ({"dim": -1},), None),
+        "matmul": ModuleConfig(
+            (
+                {"dim": -1},
+                {"dim": -2},
+            ),
+            ({"dim": -1},),
+            None,
+        ),
     }
 }

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

@@ -1,5 +1,21 @@
-import torch.nn as nn
+# 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 abc import abstractmethod
+
+import torch.nn as nn
+
 from .common import *
 
 

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

@@ -1,17 +1,27 @@
+# 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 habana_frameworks.torch.core as htcore
 import torch
 import torch.nn as nn
-import habana_frameworks.torch.core as htcore
-from .._quant_common.quant_config import get_hqt_config
+
 from .._quant_common.helper_modules import PatchedUnmeasuredModule
-from .measure import load_measurements
-from .scale import scale_method_mapping, get_config, scaling_methods
-from .common import (
-    mod_default_dict,
-    generate_model_info,
-    parent_child_mod_dict,
-    UNMEASURED_MODELS,
-)
+from .._quant_common.quant_config import get_hqt_config
 from ..utils.logger import logger
+from .common import UNMEASURED_MODELS, generate_model_info, mod_default_dict, parent_child_mod_dict
+from .measure import load_measurements
+from .scale import get_config, scale_method_mapping, scaling_methods
 
 
 def patch_module(mod, qconfig, mod_dict, patched_mod=None):

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

@@ -1,13 +1,26 @@
-import torch
+# 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 numpy as np
+import torch
 
 from .._quant_common.quant_config import ScaleMethod, set_hqt_config
-from .scale_methods import *
-from .quant_dequant import *
-
-from .fp_utils import *
-from .common import *
 from ..utils.logger import logger
+from .common import *
+from .fp_utils import *
+from .quant_dequant import *
+from .scale_methods import *
 
 
 def matmul_scales_to_mod_config(mod, scales, params):
@@ -110,7 +123,7 @@ def get_config(
             mod_type_str = mod.__class__.__name__
             layer_type = mod_dict[mod_type_str].type
             if mname not in scales:
-                logger.debug("Calcuating scales for layer %s", mname)
+                logger.debug("Calculating scales for layer %s", mname)
                 if mname not in measurement:
                     qconfig[UNMEASURED_MODELS].append(mname)
                     logger.debug(
@@ -119,7 +132,7 @@ def get_config(
                     )
                     continue
                 layer_measure = measurement[mname]  # ModuleConfig() of measurements
-                scales[mname] = method[layer_type][0](mod, layer_measure, params)   # ModuleConfig() of scales
+                scales[mname] = method[layer_type][0](mod, layer_measure, params)  # ModuleConfig() of scales
                 if scales_file is not None:
                     scales_obj[mname] = ModuleConfig(
                         **format_functions_rec((torch.Tensor, scales_file_format))(scales[mname].__dict__)
@@ -368,18 +381,6 @@ def get_config(
         ScaleMethod.ACT_MAXABS_POW2_WEIGHTS_PCS_OPT_POW2,
         "maxabs",
     ): "act_maxabs_pts_pow2_weights_opt_pcs_pow2",
-    (
-        ScaleMethod.ACT_MAXABS_POW2_WEIGHTS_PCS_OPT_POW2,
-        "maxabs_per_channel",
-    ): "act_maxabs_pts_pow2_weights_opt_pcs_pow2",
-    (
-        ScaleMethod.WEAKSMOOTHQUANT_WEIGHTS_OUTPUT_CHANNEL_MAXABS_POW2,
-        "maxabs_per_channel",
-    ): "weaksmoothquant_weights_maxabs_pow2",
-    (
-        ScaleMethod.SMOOTHQUANT_WEIGHTS_OUTPUT_CHANNEL_MAXABS_POW2,
-        "maxabs_per_channel",
-    ): "smoothquant_weights_maxabs_pow2",
     (ScaleMethod.SMOOTHQUANT_OPT, "maxabs_per_channel"): "smoothquant_weights_opt_pow2",
 }
 

neural_compressor/torch/algorithms/fp8_quant/_core/scale_methods/__init__.py

@@ -1,3 +1,17 @@
+# 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 .max_abs import *
 from .unit_scale import *
 from .smooth_quant import *

neural_compressor/torch/algorithms/fp8_quant/_core/scale_methods/max_abs.py

@@ -1,7 +1,21 @@
+# 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 ..fp_utils import *
 from ..common import *
+from ..fp_utils import *
 
 
 def linear_act_maxabs_pts_weight_maxabs_pts_pow2_hw_scales(mod, measurement, params):
@@ -140,7 +154,7 @@ def fsdpa_act_maxabs_pts_weight_maxabs_pts_pow2_scales(mod, measurement, params)
         for x in measurement.inputs
     ]
     # fsdpa is combined out of - BMM1(Q,K) -> Softmax -> BMM2(AMAX,V)
-    # during measure we recieve the amax value from the cguid and apply it during quant as input
+    # during measure we receive the amax value from the cguid and apply it during quant as input
     input_scale.append(
         calc_maxabs_scale(
             torch.tensor(measurement.outputs[1], dtype=hp_dtype, device=device).max(),

neural_compressor/torch/algorithms/fp8_quant/_core/scale_methods/smooth_quant.py

@@ -1,8 +1,22 @@
+# 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 tqdm import tqdm
 
-from ..fp_utils import *
 from ..common import *
+from ..fp_utils import *
 
 
 def linear_smoothquant_weights_opt_pow2_scales(mod, measurement, params):